@@ -42,11 +42,11 @@ fn with_passthrough_rules<C: Clone + 'static>(mut rules: Vec<Rule<C>>) -> Vec<Ru
             |ast, output, captures, source_range, user_ctx, translator| {
                 let mut children = Vec::new();
                 for child in captures.get_all("children") {
-                    children.extend(translator.translate(ast, output, user_ctx, child)?);
+                    children.extend(translator.translate(ast, output, user_ctx, child));
                 }
                 let kind = output
                     .id_for_node_kind("program")
-                    .ok_or("program kind is not registered")?;
+                    .expect("program kind is not registered");
                 let fields = BTreeMap::from([(CHILD_FIELD, children)]);
                 let program = output.create_node_with_range(
                     kind,
@@ -55,7 +55,7 @@ fn with_passthrough_rules<C: Clone + 'static>(mut rules: Vec<Rule<C>>) -> Vec<Ru
                     true,
                     source_range,
                 );
-                Ok(vec![program])
+                vec![program]
             },
         ),
     );
@@ -341,7 +341,7 @@ fn test_query_match() {
     );
 
     let mut captures = yeast::captures::Captures::new();
-    let matched = query.do_match(&ast, ast.get_root(), &mut captures).unwrap();
+    let matched = query.do_match(&ast, ast.get_root(), &mut captures);
     assert!(matched);
     assert!(captures.get_var("left").is_ok());
     assert!(captures.get_var("right").is_ok());
@@ -411,7 +411,7 @@ fn test_query_no_match() {
     );
 
     let mut captures = yeast::captures::Captures::new();
-    let matched = query.do_match(&ast, ast.get_root(), &mut captures).unwrap();
+    let matched = query.do_match(&ast, ast.get_root(), &mut captures);
     assert!(!matched);
 }
 
@@ -436,7 +436,7 @@ fn test_query_skips_extras_in_positional_match() {
     // the comment that sits between them.
     let query = yeast::query!((array (_) @a (_) @b));
     let mut captures = yeast::captures::Captures::new();
-    let matched = query.do_match(&ast, array_id, &mut captures).unwrap();
+    let matched = query.do_match(&ast, array_id, &mut captures);
     assert!(matched);
     assert_eq!(
         ast.get_node(captures.get_var("a").unwrap())
@@ -492,7 +492,7 @@ fn test_query_repeated_capture() {
     let assignment_id = cursor.node_id();
 
     let mut captures = yeast::captures::Captures::new();
-    let matched = query.do_match(&ast, assignment_id, &mut captures).unwrap();
+    let matched = query.do_match(&ast, assignment_id, &mut captures);
     assert!(matched);
     assert_eq!(captures.get_all("names").len(), 3);
 }
@@ -515,7 +515,7 @@ fn test_capture_unnamed_node_parenthesized() {
     let assignment_id = cursor.node_id();
 
     let mut captures = yeast::captures::Captures::new();
-    let matched = query.do_match(&ast, assignment_id, &mut captures).unwrap();
+    let matched = query.do_match(&ast, assignment_id, &mut captures);
     assert!(matched);
     let op_id = captures.get_var("op").unwrap();
     let op_node = ast.get_node(op_id).unwrap();
@@ -536,7 +536,7 @@ fn test_capture_bare_underscore_repeated() {
     let assignment_id = cursor.node_id();
 
     let mut captures = yeast::captures::Captures::new();
-    let matched = query.do_match(&ast, assignment_id, &mut captures).unwrap();
+    let matched = query.do_match(&ast, assignment_id, &mut captures);
     assert!(matched);
 
     let all = captures.get_all("all");
@@ -563,7 +563,7 @@ fn test_capture_unnamed_node_bare_literal() {
     let assignment_id = cursor.node_id();
 
     let mut captures = yeast::captures::Captures::new();
-    let matched = query.do_match(&ast, assignment_id, &mut captures).unwrap();
+    let matched = query.do_match(&ast, assignment_id, &mut captures);
     assert!(matched);
     let op_id = captures.get_var("op").unwrap();
     let op_node = ast.get_node(op_id).unwrap();
@@ -587,9 +587,7 @@ fn test_bare_underscore_matches_unnamed() {
     // child is the unnamed `=`).
     let query_named = yeast::query!((assignment (_) @any));
     let mut captures = yeast::captures::Captures::new();
-    let matched = query_named
-        .do_match(&ast, assignment_id, &mut captures)
-        .unwrap();
+    let matched = query_named.do_match(&ast, assignment_id, &mut captures);
     assert!(
         !matched,
         "(_) should skip the unnamed `=` and fail to match"
@@ -599,9 +597,7 @@ fn test_bare_underscore_matches_unnamed() {
     // unnamed `=` token.
     let query_any = yeast::query!((assignment _ @any));
     let mut captures = yeast::captures::Captures::new();
-    let matched = query_any
-        .do_match(&ast, assignment_id, &mut captures)
-        .unwrap();
+    let matched = query_any.do_match(&ast, assignment_id, &mut captures);
     assert!(matched, "_ should match the unnamed `=`");
     let any_node = ast.get_node(captures.get_var("any").unwrap()).unwrap();
     assert_eq!(any_node.kind_name(), "=");
@@ -625,7 +621,7 @@ fn test_bare_forms_in_field_position() {
     // first child of `left` happens to be named.
     let query = yeast::query!((assignment left: _ @lhs));
     let mut captures = yeast::captures::Captures::new();
-    let matched = query.do_match(&ast, assignment_id, &mut captures).unwrap();
+    let matched = query.do_match(&ast, assignment_id, &mut captures);
     assert!(matched);
     assert_eq!(
         ast.get_node(captures.get_var("lhs").unwrap())
@@ -637,7 +633,7 @@ fn test_bare_forms_in_field_position() {
     // Bare literal in field position. Equivalent to `("=") @op`.
     let query = yeast::query!((assignment child: "=" @op));
     let mut captures = yeast::captures::Captures::new();
-    let matched = query.do_match(&ast, assignment_id, &mut captures).unwrap();
+    let matched = query.do_match(&ast, assignment_id, &mut captures);
     assert!(matched);
     let op = ast.get_node(captures.get_var("op").unwrap()).unwrap();
     assert_eq!(op.kind_name(), "=");
@@ -665,7 +661,7 @@ fn test_forward_scan_finds_unnamed_token_late() {
 
     let query = yeast::query!((do ("end") @kw));
     let mut captures = yeast::captures::Captures::new();
-    let matched = query.do_match(&ast, do_id, &mut captures).unwrap();
+    let matched = query.do_match(&ast, do_id, &mut captures);
     assert!(matched, "forward-scan should find the `end` keyword");
     let kw = ast.get_node(captures.get_var("kw").unwrap()).unwrap();
     assert_eq!(kw.kind_name(), "end");
@@ -690,7 +686,7 @@ fn test_forward_scan_preserves_order() {
 
     let query = yeast::query!((do ("end") @first ("do") @second));
     let mut captures = yeast::captures::Captures::new();
-    let matched = query.do_match(&ast, do_id, &mut captures).unwrap();
+    let matched = query.do_match(&ast, do_id, &mut captures);
     assert!(!matched, "scan must not go backwards");
 }
 
@@ -1389,16 +1385,38 @@ fn test_translation_phase_errors_when_no_rule_matches() {
     let err = runner
         .run("x = 1")
         .expect_err("expected translation to error on unmatched node");
-    assert!(
-        err.contains("Phase `translate`"),
-        "error should name the phase, got: {err}"
-    );
     assert!(
         err.contains("no rule matched") && err.contains("integer"),
         "error should describe the unmatched node kind, got: {err}"
     );
 }
 
+#[test]
+fn test_translation_phase_catches_panics() {
+    fn panic_during_translation() -> Vec<yeast::OutputId> {
+        panic!("deliberate translation panic")
+    }
+
+    let schema = yeast::node_types_yaml::schema_from_yaml(OUTPUT_SCHEMA_YAML).unwrap();
+    let rules: Vec<Rule> = vec![yeast::rule!(
+        (integer)
+        =>
+        integer {
+            panic_during_translation()
+        }
+    )];
+    let phases = [Phase::new("translate", rules)];
+    let runner: Runner = Runner::with_schema_no_language(&schema, &phases);
+
+    let err = runner
+        .run_from_ast(synthetic_integer_ast("1"))
+        .expect_err("expected translation panic to become an error");
+    assert_eq!(
+        err,
+        "YEAST translation panicked: deliberate translation panic"
+    );
+}
+
 #[test]
 fn test_guard_runs_before_capture_translation() {
     let lang: tree_sitter::Language = tree_sitter_ruby::LANGUAGE.into();
@@ -1448,7 +1466,7 @@ fn test_transform_context_propagates_to_nested_guard_without_mutating_caller() {
             =>
             program {
                 ctx.enabled = true;
-                let stmt = ctx.translate(stmt)?;
+                let stmt = ctx.translate(stmt);
                 tree!((program stmt: {stmt}))
             }
         ),
@@ -1611,7 +1629,7 @@ fn test_raw_capture_marker() {
     // string "x" (source_text inherits the input range), so the dump
     // wouldn't change here. The companion test
     // `test_raw_capture_marker_explicit_translate` exercises the
-    // stronger property that `ctx.translate(raw_lhs)?` succeeds and
+    // stronger property that `ctx.translate(raw_lhs)` succeeds and
     // produces the translated `(identifier "ID")`.
     assert_dump_eq(
         &dump,
@@ -1646,7 +1664,7 @@ fn test_raw_capture_marker_explicit_translate() {
             (assignment left: (_) @@raw_lhs right: (_) @rhs)
             =>
             call {
-                let translated_lhs = ctx.translate(raw_lhs)?;
+                let translated_lhs = ctx.translate(raw_lhs);
                 tree!((call
                     method: {translated_lhs}
                     receiver: {rhs}))
@@ -2144,10 +2162,10 @@ fn test_explicit_recursive_translation_keeps_nested_rule_location() {
         (call method: (identifier) @@name)
         =>
         identifier {
-            ctx.translate(name)?
+            ctx.translate(name)
                 .into_iter()
                 .next()
-                .ok_or("identifier translation produced no result")?
+                .expect("identifier translation produced no result")
         }
     );
     let translate_identifier: Rule = rule!((identifier) @@identifier => (identifier #{identifier}));