@smithers-orchestrator/driver 0.25.0 → 0.25.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smithers-orchestrator/driver",
-  "version": "0.25.0",
+  "version": "0.25.1",
   "description": "Workflow execution driver — runs tasks, acts on EngineDecisions, reports results",
   "type": "module",
   "sideEffects": false,
@@ -63,11 +63,11 @@
   "dependencies": {
     "effect": "^3.21.1",
     "zod": "^4.3.6",
-    "@smithers-orchestrator/db": "0.25.0",
-    "@smithers-orchestrator/graph": "0.25.0",
-    "@smithers-orchestrator/observability": "0.25.0",
-    "@smithers-orchestrator/errors": "0.25.0",
-    "@smithers-orchestrator/scheduler": "0.25.0"
+    "@smithers-orchestrator/errors": "0.25.1",
+    "@smithers-orchestrator/db": "0.25.1",
+    "@smithers-orchestrator/graph": "0.25.1",
+    "@smithers-orchestrator/observability": "0.25.1",
+    "@smithers-orchestrator/scheduler": "0.25.1"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/src/RunResult.ts

@@ -6,4 +6,17 @@ export type RunResult = {
   readonly output?: unknown;
   readonly error?: unknown;
   readonly nextRunId?: string;
+  /**
+   * Number of tasks that ended `failed` yet did not fail the run — "masked"
+   * child failures (a `continueOnFail` task, or an agent task that failed
+   * transiently: rate limit, timeout, abort) the binary `finished` status cannot
+   * express. Present (and `> 0`) only on a `finished` result. See
+   * `docs/runtime/run-state.mdx`.
+   */
+  readonly failedChildren?: number;
+  /**
+   * Task state keys (`nodeId::iteration`) of the tasks counted by
+   * {@link failedChildren}.
+   */
+  readonly failedChildKeys?: readonly string[];
 };

package/src/index.d.ts

@@ -96,6 +96,19 @@ type RunResult$2 = {
     readonly output?: unknown;
     readonly error?: unknown;
     readonly nextRunId?: string;
+    /**
+     * Number of tasks that ended `failed` yet did not fail the run — "masked"
+     * child failures (a `continueOnFail` task, or an agent task that failed
+     * transiently: rate limit, timeout, abort) the binary `finished` status cannot
+     * express. Present (and `> 0`) only on a `finished` result. See
+     * `docs/runtime/run-state.mdx`.
+     */
+    readonly failedChildren?: number;
+    /**
+     * Task state keys (`nodeId::iteration`) of the tasks counted by
+     * {@link failedChildren}.
+     */
+    readonly failedChildKeys?: readonly string[];
 };
 
 type ContinueAsNewHandler$1 = (transition: unknown, context: {
@@ -164,6 +177,576 @@ type ResolveOutputRow$1<Schema, T> = T extends keyof Schema ? Schema[T] extends
     $inferSelect: infer R;
 } ? R : Record<string, unknown>;
 
+/**
+ * Resolve the row type a `ctx.output`/`ctx.outputMaybe`/`ctx.latest` call returns
+ * from the `table` argument it was given:
+ *
+ * - a string table name (a key of the workflow Schema) → the inferred row for
+ *   that registered schema (`outputs.X` keyed by name);
+ * - a Zod schema object (e.g. `outputs.research`) → `z.infer` of that schema;
+ * - a Drizzle table (carries `$inferSelect`) → its select row;
+ * - anything else (a widened `string`, `unknown`) → an untyped output row.
+ *
+ * This is what makes `ctx.outputMaybe(outputs.research, ...)` carry the research
+ * fields instead of an untyped `Record<string, unknown>`.
+ */
+type ResolveOutputRow$1<Schema, T> = T extends keyof Schema ? Schema[T] extends z.ZodTypeAny ? z.infer<Schema[T]> : Schema[T] extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown> : T extends z.ZodTypeAny ? z.infer<T> : T extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown>;
+
+/**
+ * Resolve the row type a `ctx.output`/`ctx.outputMaybe`/`ctx.latest` call returns
+ * from the `table` argument it was given:
+ *
+ * - a string table name (a key of the workflow Schema) → the inferred row for
+ *   that registered schema (`outputs.X` keyed by name);
+ * - a Zod schema object (e.g. `outputs.research`) → `z.infer` of that schema;
+ * - a Drizzle table (carries `$inferSelect`) → its select row;
+ * - anything else (a widened `string`, `unknown`) → an untyped output row.
+ *
+ * This is what makes `ctx.outputMaybe(outputs.research, ...)` carry the research
+ * fields instead of an untyped `Record<string, unknown>`.
+ */
+type ResolveOutputRow$1<Schema, T> = T extends keyof Schema ? Schema[T] extends z.ZodTypeAny ? z.infer<Schema[T]> : Schema[T] extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown> : T extends z.ZodTypeAny ? z.infer<T> : T extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown>;
+
+/**
+ * Resolve the row type a `ctx.output`/`ctx.outputMaybe`/`ctx.latest` call returns
+ * from the `table` argument it was given:
+ *
+ * - a string table name (a key of the workflow Schema) → the inferred row for
+ *   that registered schema (`outputs.X` keyed by name);
+ * - a Zod schema object (e.g. `outputs.research`) → `z.infer` of that schema;
+ * - a Drizzle table (carries `$inferSelect`) → its select row;
+ * - anything else (a widened `string`, `unknown`) → an untyped output row.
+ *
+ * This is what makes `ctx.outputMaybe(outputs.research, ...)` carry the research
+ * fields instead of an untyped `Record<string, unknown>`.
+ */
+type ResolveOutputRow$1<Schema, T> = T extends keyof Schema ? Schema[T] extends z.ZodTypeAny ? z.infer<Schema[T]> : Schema[T] extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown> : T extends z.ZodTypeAny ? z.infer<T> : T extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown>;
+
+/**
+ * Resolve the row type a `ctx.output`/`ctx.outputMaybe`/`ctx.latest` call returns
+ * from the `table` argument it was given:
+ *
+ * - a string table name (a key of the workflow Schema) → the inferred row for
+ *   that registered schema (`outputs.X` keyed by name);
+ * - a Zod schema object (e.g. `outputs.research`) → `z.infer` of that schema;
+ * - a Drizzle table (carries `$inferSelect`) → its select row;
+ * - anything else (a widened `string`, `unknown`) → an untyped output row.
+ *
+ * This is what makes `ctx.outputMaybe(outputs.research, ...)` carry the research
+ * fields instead of an untyped `Record<string, unknown>`.
+ */
+type ResolveOutputRow$1<Schema, T> = T extends keyof Schema ? Schema[T] extends z.ZodTypeAny ? z.infer<Schema[T]> : Schema[T] extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown> : T extends z.ZodTypeAny ? z.infer<T> : T extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown>;
+
+/**
+ * Resolve the row type a `ctx.output`/`ctx.outputMaybe`/`ctx.latest` call returns
+ * from the `table` argument it was given:
+ *
+ * - a string table name (a key of the workflow Schema) → the inferred row for
+ *   that registered schema (`outputs.X` keyed by name);
+ * - a Zod schema object (e.g. `outputs.research`) → `z.infer` of that schema;
+ * - a Drizzle table (carries `$inferSelect`) → its select row;
+ * - anything else (a widened `string`, `unknown`) → an untyped output row.
+ *
+ * This is what makes `ctx.outputMaybe(outputs.research, ...)` carry the research
+ * fields instead of an untyped `Record<string, unknown>`.
+ */
+type ResolveOutputRow$1<Schema, T> = T extends keyof Schema ? Schema[T] extends z.ZodTypeAny ? z.infer<Schema[T]> : Schema[T] extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown> : T extends z.ZodTypeAny ? z.infer<T> : T extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown>;
+
+/**
+ * Resolve the row type a `ctx.output`/`ctx.outputMaybe`/`ctx.latest` call returns
+ * from the `table` argument it was given:
+ *
+ * - a string table name (a key of the workflow Schema) → the inferred row for
+ *   that registered schema (`outputs.X` keyed by name);
+ * - a Zod schema object (e.g. `outputs.research`) → `z.infer` of that schema;
+ * - a Drizzle table (carries `$inferSelect`) → its select row;
+ * - anything else (a widened `string`, `unknown`) → an untyped output row.
+ *
+ * This is what makes `ctx.outputMaybe(outputs.research, ...)` carry the research
+ * fields instead of an untyped `Record<string, unknown>`.
+ */
+type ResolveOutputRow$1<Schema, T> = T extends keyof Schema ? Schema[T] extends z.ZodTypeAny ? z.infer<Schema[T]> : Schema[T] extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown> : T extends z.ZodTypeAny ? z.infer<T> : T extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown>;
+
+/**
+ * Resolve the row type a `ctx.output`/`ctx.outputMaybe`/`ctx.latest` call returns
+ * from the `table` argument it was given:
+ *
+ * - a string table name (a key of the workflow Schema) → the inferred row for
+ *   that registered schema (`outputs.X` keyed by name);
+ * - a Zod schema object (e.g. `outputs.research`) → `z.infer` of that schema;
+ * - a Drizzle table (carries `$inferSelect`) → its select row;
+ * - anything else (a widened `string`, `unknown`) → an untyped output row.
+ *
+ * This is what makes `ctx.outputMaybe(outputs.research, ...)` carry the research
+ * fields instead of an untyped `Record<string, unknown>`.
+ */
+type ResolveOutputRow$1<Schema, T> = T extends keyof Schema ? Schema[T] extends z.ZodTypeAny ? z.infer<Schema[T]> : Schema[T] extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown> : T extends z.ZodTypeAny ? z.infer<T> : T extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown>;
+
+/**
+ * Resolve the row type a `ctx.output`/`ctx.outputMaybe`/`ctx.latest` call returns
+ * from the `table` argument it was given:
+ *
+ * - a string table name (a key of the workflow Schema) → the inferred row for
+ *   that registered schema (`outputs.X` keyed by name);
+ * - a Zod schema object (e.g. `outputs.research`) → `z.infer` of that schema;
+ * - a Drizzle table (carries `$inferSelect`) → its select row;
+ * - anything else (a widened `string`, `unknown`) → an untyped output row.
+ *
+ * This is what makes `ctx.outputMaybe(outputs.research, ...)` carry the research
+ * fields instead of an untyped `Record<string, unknown>`.
+ */
+type ResolveOutputRow$1<Schema, T> = T extends keyof Schema ? Schema[T] extends z.ZodTypeAny ? z.infer<Schema[T]> : Schema[T] extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown> : T extends z.ZodTypeAny ? z.infer<T> : T extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown>;
+
+/**
+ * Resolve the row type a `ctx.output`/`ctx.outputMaybe`/`ctx.latest` call returns
+ * from the `table` argument it was given:
+ *
+ * - a string table name (a key of the workflow Schema) → the inferred row for
+ *   that registered schema (`outputs.X` keyed by name);
+ * - a Zod schema object (e.g. `outputs.research`) → `z.infer` of that schema;
+ * - a Drizzle table (carries `$inferSelect`) → its select row;
+ * - anything else (a widened `string`, `unknown`) → an untyped output row.
+ *
+ * This is what makes `ctx.outputMaybe(outputs.research, ...)` carry the research
+ * fields instead of an untyped `Record<string, unknown>`.
+ */
+type ResolveOutputRow$1<Schema, T> = T extends keyof Schema ? Schema[T] extends z.ZodTypeAny ? z.infer<Schema[T]> : Schema[T] extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown> : T extends z.ZodTypeAny ? z.infer<T> : T extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown>;
+
+/**
+ * Resolve the row type a `ctx.output`/`ctx.outputMaybe`/`ctx.latest` call returns
+ * from the `table` argument it was given:
+ *
+ * - a string table name (a key of the workflow Schema) → the inferred row for
+ *   that registered schema (`outputs.X` keyed by name);
+ * - a Zod schema object (e.g. `outputs.research`) → `z.infer` of that schema;
+ * - a Drizzle table (carries `$inferSelect`) → its select row;
+ * - anything else (a widened `string`, `unknown`) → an untyped output row.
+ *
+ * This is what makes `ctx.outputMaybe(outputs.research, ...)` carry the research
+ * fields instead of an untyped `Record<string, unknown>`.
+ */
+type ResolveOutputRow$1<Schema, T> = T extends keyof Schema ? Schema[T] extends z.ZodTypeAny ? z.infer<Schema[T]> : Schema[T] extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown> : T extends z.ZodTypeAny ? z.infer<T> : T extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown>;
+
+/**
+ * Resolve the row type a `ctx.output`/`ctx.outputMaybe`/`ctx.latest` call returns
+ * from the `table` argument it was given:
+ *
+ * - a string table name (a key of the workflow Schema) → the inferred row for
+ *   that registered schema (`outputs.X` keyed by name);
+ * - a Zod schema object (e.g. `outputs.research`) → `z.infer` of that schema;
+ * - a Drizzle table (carries `$inferSelect`) → its select row;
+ * - anything else (a widened `string`, `unknown`) → an untyped output row.
+ *
+ * This is what makes `ctx.outputMaybe(outputs.research, ...)` carry the research
+ * fields instead of an untyped `Record<string, unknown>`.
+ */
+type ResolveOutputRow$1<Schema, T> = T extends keyof Schema ? Schema[T] extends z.ZodTypeAny ? z.infer<Schema[T]> : Schema[T] extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown> : T extends z.ZodTypeAny ? z.infer<T> : T extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown>;
+
+/**
+ * Resolve the row type a `ctx.output`/`ctx.outputMaybe`/`ctx.latest` call returns
+ * from the `table` argument it was given:
+ *
+ * - a string table name (a key of the workflow Schema) → the inferred row for
+ *   that registered schema (`outputs.X` keyed by name);
+ * - a Zod schema object (e.g. `outputs.research`) → `z.infer` of that schema;
+ * - a Drizzle table (carries `$inferSelect`) → its select row;
+ * - anything else (a widened `string`, `unknown`) → an untyped output row.
+ *
+ * This is what makes `ctx.outputMaybe(outputs.research, ...)` carry the research
+ * fields instead of an untyped `Record<string, unknown>`.
+ */
+type ResolveOutputRow$1<Schema, T> = T extends keyof Schema ? Schema[T] extends z.ZodTypeAny ? z.infer<Schema[T]> : Schema[T] extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown> : T extends z.ZodTypeAny ? z.infer<T> : T extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown>;
+
+/**
+ * Resolve the row type a `ctx.output`/`ctx.outputMaybe`/`ctx.latest` call returns
+ * from the `table` argument it was given:
+ *
+ * - a string table name (a key of the workflow Schema) → the inferred row for
+ *   that registered schema (`outputs.X` keyed by name);
+ * - a Zod schema object (e.g. `outputs.research`) → `z.infer` of that schema;
+ * - a Drizzle table (carries `$inferSelect`) → its select row;
+ * - anything else (a widened `string`, `unknown`) → an untyped output row.
+ *
+ * This is what makes `ctx.outputMaybe(outputs.research, ...)` carry the research
+ * fields instead of an untyped `Record<string, unknown>`.
+ */
+type ResolveOutputRow$1<Schema, T> = T extends keyof Schema ? Schema[T] extends z.ZodTypeAny ? z.infer<Schema[T]> : Schema[T] extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown> : T extends z.ZodTypeAny ? z.infer<T> : T extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown>;
+
+/**
+ * Resolve the row type a `ctx.output`/`ctx.outputMaybe`/`ctx.latest` call returns
+ * from the `table` argument it was given:
+ *
+ * - a string table name (a key of the workflow Schema) → the inferred row for
+ *   that registered schema (`outputs.X` keyed by name);
+ * - a Zod schema object (e.g. `outputs.research`) → `z.infer` of that schema;
+ * - a Drizzle table (carries `$inferSelect`) → its select row;
+ * - anything else (a widened `string`, `unknown`) → an untyped output row.
+ *
+ * This is what makes `ctx.outputMaybe(outputs.research, ...)` carry the research
+ * fields instead of an untyped `Record<string, unknown>`.
+ */
+type ResolveOutputRow$1<Schema, T> = T extends keyof Schema ? Schema[T] extends z.ZodTypeAny ? z.infer<Schema[T]> : Schema[T] extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown> : T extends z.ZodTypeAny ? z.infer<T> : T extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown>;
+
+/**
+ * Resolve the row type a `ctx.output`/`ctx.outputMaybe`/`ctx.latest` call returns
+ * from the `table` argument it was given:
+ *
+ * - a string table name (a key of the workflow Schema) → the inferred row for
+ *   that registered schema (`outputs.X` keyed by name);
+ * - a Zod schema object (e.g. `outputs.research`) → `z.infer` of that schema;
+ * - a Drizzle table (carries `$inferSelect`) → its select row;
+ * - anything else (a widened `string`, `unknown`) → an untyped output row.
+ *
+ * This is what makes `ctx.outputMaybe(outputs.research, ...)` carry the research
+ * fields instead of an untyped `Record<string, unknown>`.
+ */
+type ResolveOutputRow$1<Schema, T> = T extends keyof Schema ? Schema[T] extends z.ZodTypeAny ? z.infer<Schema[T]> : Schema[T] extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown> : T extends z.ZodTypeAny ? z.infer<T> : T extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown>;
+
+/**
+ * Resolve the row type a `ctx.output`/`ctx.outputMaybe`/`ctx.latest` call returns
+ * from the `table` argument it was given:
+ *
+ * - a string table name (a key of the workflow Schema) → the inferred row for
+ *   that registered schema (`outputs.X` keyed by name);
+ * - a Zod schema object (e.g. `outputs.research`) → `z.infer` of that schema;
+ * - a Drizzle table (carries `$inferSelect`) → its select row;
+ * - anything else (a widened `string`, `unknown`) → an untyped output row.
+ *
+ * This is what makes `ctx.outputMaybe(outputs.research, ...)` carry the research
+ * fields instead of an untyped `Record<string, unknown>`.
+ */
+type ResolveOutputRow$1<Schema, T> = T extends keyof Schema ? Schema[T] extends z.ZodTypeAny ? z.infer<Schema[T]> : Schema[T] extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown> : T extends z.ZodTypeAny ? z.infer<T> : T extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown>;
+
+/**
+ * Resolve the row type a `ctx.output`/`ctx.outputMaybe`/`ctx.latest` call returns
+ * from the `table` argument it was given:
+ *
+ * - a string table name (a key of the workflow Schema) → the inferred row for
+ *   that registered schema (`outputs.X` keyed by name);
+ * - a Zod schema object (e.g. `outputs.research`) → `z.infer` of that schema;
+ * - a Drizzle table (carries `$inferSelect`) → its select row;
+ * - anything else (a widened `string`, `unknown`) → an untyped output row.
+ *
+ * This is what makes `ctx.outputMaybe(outputs.research, ...)` carry the research
+ * fields instead of an untyped `Record<string, unknown>`.
+ */
+type ResolveOutputRow$1<Schema, T> = T extends keyof Schema ? Schema[T] extends z.ZodTypeAny ? z.infer<Schema[T]> : Schema[T] extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown> : T extends z.ZodTypeAny ? z.infer<T> : T extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown>;
+
+/**
+ * Resolve the row type a `ctx.output`/`ctx.outputMaybe`/`ctx.latest` call returns
+ * from the `table` argument it was given:
+ *
+ * - a string table name (a key of the workflow Schema) → the inferred row for
+ *   that registered schema (`outputs.X` keyed by name);
+ * - a Zod schema object (e.g. `outputs.research`) → `z.infer` of that schema;
+ * - a Drizzle table (carries `$inferSelect`) → its select row;
+ * - anything else (a widened `string`, `unknown`) → an untyped output row.
+ *
+ * This is what makes `ctx.outputMaybe(outputs.research, ...)` carry the research
+ * fields instead of an untyped `Record<string, unknown>`.
+ */
+type ResolveOutputRow$1<Schema, T> = T extends keyof Schema ? Schema[T] extends z.ZodTypeAny ? z.infer<Schema[T]> : Schema[T] extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown> : T extends z.ZodTypeAny ? z.infer<T> : T extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown>;
+
+/**
+ * Resolve the row type a `ctx.output`/`ctx.outputMaybe`/`ctx.latest` call returns
+ * from the `table` argument it was given:
+ *
+ * - a string table name (a key of the workflow Schema) → the inferred row for
+ *   that registered schema (`outputs.X` keyed by name);
+ * - a Zod schema object (e.g. `outputs.research`) → `z.infer` of that schema;
+ * - a Drizzle table (carries `$inferSelect`) → its select row;
+ * - anything else (a widened `string`, `unknown`) → an untyped output row.
+ *
+ * This is what makes `ctx.outputMaybe(outputs.research, ...)` carry the research
+ * fields instead of an untyped `Record<string, unknown>`.
+ */
+type ResolveOutputRow$1<Schema, T> = T extends keyof Schema ? Schema[T] extends z.ZodTypeAny ? z.infer<Schema[T]> : Schema[T] extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown> : T extends z.ZodTypeAny ? z.infer<T> : T extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown>;
+
+/**
+ * Resolve the row type a `ctx.output`/`ctx.outputMaybe`/`ctx.latest` call returns
+ * from the `table` argument it was given:
+ *
+ * - a string table name (a key of the workflow Schema) → the inferred row for
+ *   that registered schema (`outputs.X` keyed by name);
+ * - a Zod schema object (e.g. `outputs.research`) → `z.infer` of that schema;
+ * - a Drizzle table (carries `$inferSelect`) → its select row;
+ * - anything else (a widened `string`, `unknown`) → an untyped output row.
+ *
+ * This is what makes `ctx.outputMaybe(outputs.research, ...)` carry the research
+ * fields instead of an untyped `Record<string, unknown>`.
+ */
+type ResolveOutputRow$1<Schema, T> = T extends keyof Schema ? Schema[T] extends z.ZodTypeAny ? z.infer<Schema[T]> : Schema[T] extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown> : T extends z.ZodTypeAny ? z.infer<T> : T extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown>;
+
+/**
+ * Resolve the row type a `ctx.output`/`ctx.outputMaybe`/`ctx.latest` call returns
+ * from the `table` argument it was given:
+ *
+ * - a string table name (a key of the workflow Schema) → the inferred row for
+ *   that registered schema (`outputs.X` keyed by name);
+ * - a Zod schema object (e.g. `outputs.research`) → `z.infer` of that schema;
+ * - a Drizzle table (carries `$inferSelect`) → its select row;
+ * - anything else (a widened `string`, `unknown`) → an untyped output row.
+ *
+ * This is what makes `ctx.outputMaybe(outputs.research, ...)` carry the research
+ * fields instead of an untyped `Record<string, unknown>`.
+ */
+type ResolveOutputRow$1<Schema, T> = T extends keyof Schema ? Schema[T] extends z.ZodTypeAny ? z.infer<Schema[T]> : Schema[T] extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown> : T extends z.ZodTypeAny ? z.infer<T> : T extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown>;
+
+/**
+ * Resolve the row type a `ctx.output`/`ctx.outputMaybe`/`ctx.latest` call returns
+ * from the `table` argument it was given:
+ *
+ * - a string table name (a key of the workflow Schema) → the inferred row for
+ *   that registered schema (`outputs.X` keyed by name);
+ * - a Zod schema object (e.g. `outputs.research`) → `z.infer` of that schema;
+ * - a Drizzle table (carries `$inferSelect`) → its select row;
+ * - anything else (a widened `string`, `unknown`) → an untyped output row.
+ *
+ * This is what makes `ctx.outputMaybe(outputs.research, ...)` carry the research
+ * fields instead of an untyped `Record<string, unknown>`.
+ */
+type ResolveOutputRow$1<Schema, T> = T extends keyof Schema ? Schema[T] extends z.ZodTypeAny ? z.infer<Schema[T]> : Schema[T] extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown> : T extends z.ZodTypeAny ? z.infer<T> : T extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown>;
+
+/**
+ * Resolve the row type a `ctx.output`/`ctx.outputMaybe`/`ctx.latest` call returns
+ * from the `table` argument it was given:
+ *
+ * - a string table name (a key of the workflow Schema) → the inferred row for
+ *   that registered schema (`outputs.X` keyed by name);
+ * - a Zod schema object (e.g. `outputs.research`) → `z.infer` of that schema;
+ * - a Drizzle table (carries `$inferSelect`) → its select row;
+ * - anything else (a widened `string`, `unknown`) → an untyped output row.
+ *
+ * This is what makes `ctx.outputMaybe(outputs.research, ...)` carry the research
+ * fields instead of an untyped `Record<string, unknown>`.
+ */
+type ResolveOutputRow$1<Schema, T> = T extends keyof Schema ? Schema[T] extends z.ZodTypeAny ? z.infer<Schema[T]> : Schema[T] extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown> : T extends z.ZodTypeAny ? z.infer<T> : T extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown>;
+
+/**
+ * Resolve the row type a `ctx.output`/`ctx.outputMaybe`/`ctx.latest` call returns
+ * from the `table` argument it was given:
+ *
+ * - a string table name (a key of the workflow Schema) → the inferred row for
+ *   that registered schema (`outputs.X` keyed by name);
+ * - a Zod schema object (e.g. `outputs.research`) → `z.infer` of that schema;
+ * - a Drizzle table (carries `$inferSelect`) → its select row;
+ * - anything else (a widened `string`, `unknown`) → an untyped output row.
+ *
+ * This is what makes `ctx.outputMaybe(outputs.research, ...)` carry the research
+ * fields instead of an untyped `Record<string, unknown>`.
+ */
+type ResolveOutputRow$1<Schema, T> = T extends keyof Schema ? Schema[T] extends z.ZodTypeAny ? z.infer<Schema[T]> : Schema[T] extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown> : T extends z.ZodTypeAny ? z.infer<T> : T extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown>;
+
+/**
+ * Resolve the row type a `ctx.output`/`ctx.outputMaybe`/`ctx.latest` call returns
+ * from the `table` argument it was given:
+ *
+ * - a string table name (a key of the workflow Schema) → the inferred row for
+ *   that registered schema (`outputs.X` keyed by name);
+ * - a Zod schema object (e.g. `outputs.research`) → `z.infer` of that schema;
+ * - a Drizzle table (carries `$inferSelect`) → its select row;
+ * - anything else (a widened `string`, `unknown`) → an untyped output row.
+ *
+ * This is what makes `ctx.outputMaybe(outputs.research, ...)` carry the research
+ * fields instead of an untyped `Record<string, unknown>`.
+ */
+type ResolveOutputRow$1<Schema, T> = T extends keyof Schema ? Schema[T] extends z.ZodTypeAny ? z.infer<Schema[T]> : Schema[T] extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown> : T extends z.ZodTypeAny ? z.infer<T> : T extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown>;
+
+/**
+ * Resolve the row type a `ctx.output`/`ctx.outputMaybe`/`ctx.latest` call returns
+ * from the `table` argument it was given:
+ *
+ * - a string table name (a key of the workflow Schema) → the inferred row for
+ *   that registered schema (`outputs.X` keyed by name);
+ * - a Zod schema object (e.g. `outputs.research`) → `z.infer` of that schema;
+ * - a Drizzle table (carries `$inferSelect`) → its select row;
+ * - anything else (a widened `string`, `unknown`) → an untyped output row.
+ *
+ * This is what makes `ctx.outputMaybe(outputs.research, ...)` carry the research
+ * fields instead of an untyped `Record<string, unknown>`.
+ */
+type ResolveOutputRow$1<Schema, T> = T extends keyof Schema ? Schema[T] extends z.ZodTypeAny ? z.infer<Schema[T]> : Schema[T] extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown> : T extends z.ZodTypeAny ? z.infer<T> : T extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown>;
+
+/**
+ * Resolve the row type a `ctx.output`/`ctx.outputMaybe`/`ctx.latest` call returns
+ * from the `table` argument it was given:
+ *
+ * - a string table name (a key of the workflow Schema) → the inferred row for
+ *   that registered schema (`outputs.X` keyed by name);
+ * - a Zod schema object (e.g. `outputs.research`) → `z.infer` of that schema;
+ * - a Drizzle table (carries `$inferSelect`) → its select row;
+ * - anything else (a widened `string`, `unknown`) → an untyped output row.
+ *
+ * This is what makes `ctx.outputMaybe(outputs.research, ...)` carry the research
+ * fields instead of an untyped `Record<string, unknown>`.
+ */
+type ResolveOutputRow$1<Schema, T> = T extends keyof Schema ? Schema[T] extends z.ZodTypeAny ? z.infer<Schema[T]> : Schema[T] extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown> : T extends z.ZodTypeAny ? z.infer<T> : T extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown>;
+
+/**
+ * Resolve the row type a `ctx.output`/`ctx.outputMaybe`/`ctx.latest` call returns
+ * from the `table` argument it was given:
+ *
+ * - a string table name (a key of the workflow Schema) → the inferred row for
+ *   that registered schema (`outputs.X` keyed by name);
+ * - a Zod schema object (e.g. `outputs.research`) → `z.infer` of that schema;
+ * - a Drizzle table (carries `$inferSelect`) → its select row;
+ * - anything else (a widened `string`, `unknown`) → an untyped output row.
+ *
+ * This is what makes `ctx.outputMaybe(outputs.research, ...)` carry the research
+ * fields instead of an untyped `Record<string, unknown>`.
+ */
+type ResolveOutputRow$1<Schema, T> = T extends keyof Schema ? Schema[T] extends z.ZodTypeAny ? z.infer<Schema[T]> : Schema[T] extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown> : T extends z.ZodTypeAny ? z.infer<T> : T extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown>;
+
+/**
+ * Resolve the row type a `ctx.output`/`ctx.outputMaybe`/`ctx.latest` call returns
+ * from the `table` argument it was given:
+ *
+ * - a string table name (a key of the workflow Schema) → the inferred row for
+ *   that registered schema (`outputs.X` keyed by name);
+ * - a Zod schema object (e.g. `outputs.research`) → `z.infer` of that schema;
+ * - a Drizzle table (carries `$inferSelect`) → its select row;
+ * - anything else (a widened `string`, `unknown`) → an untyped output row.
+ *
+ * This is what makes `ctx.outputMaybe(outputs.research, ...)` carry the research
+ * fields instead of an untyped `Record<string, unknown>`.
+ */
+type ResolveOutputRow$1<Schema, T> = T extends keyof Schema ? Schema[T] extends z.ZodTypeAny ? z.infer<Schema[T]> : Schema[T] extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown> : T extends z.ZodTypeAny ? z.infer<T> : T extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown>;
+
+/**
+ * Resolve the row type a `ctx.output`/`ctx.outputMaybe`/`ctx.latest` call returns
+ * from the `table` argument it was given:
+ *
+ * - a string table name (a key of the workflow Schema) → the inferred row for
+ *   that registered schema (`outputs.X` keyed by name);
+ * - a Zod schema object (e.g. `outputs.research`) → `z.infer` of that schema;
+ * - a Drizzle table (carries `$inferSelect`) → its select row;
+ * - anything else (a widened `string`, `unknown`) → an untyped output row.
+ *
+ * This is what makes `ctx.outputMaybe(outputs.research, ...)` carry the research
+ * fields instead of an untyped `Record<string, unknown>`.
+ */
+type ResolveOutputRow$1<Schema, T> = T extends keyof Schema ? Schema[T] extends z.ZodTypeAny ? z.infer<Schema[T]> : Schema[T] extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown> : T extends z.ZodTypeAny ? z.infer<T> : T extends {
+    $inferSelect: infer R;
+} ? R : Record<string, unknown>;
+
 type SmithersRuntimeConfig$1 = {
     cliAgentToolsDefault?: "all" | "explicit-only";
     baseRootDir?: string;