@bastani/atomic 0.9.11-alpha.8 → 0.9.11

package/dist/builtin/workflows/src/shared/render-inputs-schema.ts

@@ -39,16 +39,16 @@
  *   3 inputs · 1 required · pass via key=value or run with no args for picker
  */
 
-import type { GraphTheme } from "../tui/graph-theme.js";
-import { paint } from "../tui/color-utils.js";
-import { renderRoundedBox, chatWidth } from "../tui/chat-surface.js";
 import type { WorkflowInputEntry } from "../extension/render-result.js";
+import { chatWidth, renderRoundedBox } from "../tui/chat-surface.js";
+import { paint } from "../tui/color-utils.js";
+import type { GraphTheme } from "../tui/graph-theme.js";
 
 export interface RenderInputsSchemaOptions {
-  /** When provided, output uses ANSI colours and indented `INPUTS` chrome. */
-  theme?: GraphTheme;
-  /** Optional host render width in terminal cells. */
-  width?: number;
+	/** When provided, output uses ANSI colours and indented `INPUTS` chrome. */
+	theme?: GraphTheme;
+	/** Optional host render width in terminal cells. */
+	width?: number;
 }
 
 /**
@@ -57,13 +57,13 @@ export interface RenderInputsSchemaOptions {
  * the historical plain-text form, byte-for-byte stable for snapshot tests.
  */
 export function renderInputsSchema(
-  name: string,
-  inputs: WorkflowInputEntry[],
-  opts: RenderInputsSchemaOptions = {},
+	name: string,
+	inputs: WorkflowInputEntry[],
+	opts: RenderInputsSchemaOptions = {},
 ): string {
-  return opts.theme === undefined
-    ? renderPlain(name, inputs, opts.width)
-    : renderPretty(name, inputs, opts.theme, opts.width);
+	return opts.theme === undefined
+		? renderPlain(name, inputs, opts.width)
+		: renderPretty(name, inputs, opts.theme, opts.width);
 }
 
 // ---------------------------------------------------------------------------
@@ -71,25 +71,25 @@ export function renderInputsSchema(
 // ---------------------------------------------------------------------------
 
 function renderPlain(name: string, inputs: WorkflowInputEntry[], width?: number): string {
-  const boxWidth = chatWidth(width);
-  const body: string[] = [];
-
-  if (inputs.length === 0) {
-    body.push(` Workflow has no declared inputs. Workflow: "${name}". `);
-  } else {
-    for (let i = 0; i < inputs.length; i++) {
-      if (i > 0) body.push("");
-      body.push(...renderInputRows(inputs[i]!));
-    }
-    body.push("");
-    body.push(` ${inputsSummary(name, inputs)} `);
-  }
-
-  return renderRoundedBox({
-    title: `INPUTS FOR ${name}`,
-    bodyLines: body,
-    width: boxWidth,
-  });
+	const boxWidth = chatWidth(width);
+	const body: string[] = [];
+
+	if (inputs.length === 0) {
+		body.push(` Workflow has no declared inputs. Workflow: "${name}". `);
+	} else {
+		for (let i = 0; i < inputs.length; i++) {
+			if (i > 0) body.push("");
+			body.push(...renderInputRows(inputs[i]!));
+		}
+		body.push("");
+		body.push(` ${inputsSummary(name, inputs)} `);
+	}
+
+	return renderRoundedBox({
+		title: `INPUTS FOR ${name}`,
+		bodyLines: body,
+		width: boxWidth,
+	});
 }
 
 // ---------------------------------------------------------------------------
@@ -101,68 +101,61 @@ function renderPlain(name: string, inputs: WorkflowInputEntry[], width?: number)
 // without being alarming the way red would.
 // ---------------------------------------------------------------------------
 
-function renderPretty(
-  name: string,
-  inputs: WorkflowInputEntry[],
-  theme: GraphTheme,
-  width?: number,
-): string {
-  const boxWidth = chatWidth(width);
-  const body: string[] = [];
-
-  if (inputs.length === 0) {
-    body.push(` ${paint(`Workflow has no declared inputs. Workflow: "${name}".`, theme.dim)} `);
-  } else {
-    for (let i = 0; i < inputs.length; i++) {
-      if (i > 0) body.push("");
-      body.push(...renderInputRows(inputs[i]!, theme));
-    }
-    body.push("");
-    body.push(` ${paint(inputsSummary(name, inputs), theme.dim)} `);
-  }
-
-  return renderRoundedBox({
-    title: `INPUTS FOR ${name.toUpperCase()}`,
-    bodyLines: body,
-    accent: theme.mauve,
-    theme,
-    width: boxWidth,
-  });
+function renderPretty(name: string, inputs: WorkflowInputEntry[], theme: GraphTheme, width?: number): string {
+	const boxWidth = chatWidth(width);
+	const body: string[] = [];
+
+	if (inputs.length === 0) {
+		body.push(` ${paint(`Workflow has no declared inputs. Workflow: "${name}".`, theme.dim)} `);
+	} else {
+		for (let i = 0; i < inputs.length; i++) {
+			if (i > 0) body.push("");
+			body.push(...renderInputRows(inputs[i]!, theme));
+		}
+		body.push("");
+		body.push(` ${paint(inputsSummary(name, inputs), theme.dim)} `);
+	}
+
+	return renderRoundedBox({
+		title: `INPUTS FOR ${name.toUpperCase()}`,
+		bodyLines: body,
+		accent: theme.mauve,
+		theme,
+		width: boxWidth,
+	});
 }
 
-function renderInputRows(
-  field: WorkflowInputEntry,
-  theme?: GraphTheme,
-): string[] {
-  const tagLabel = field.required ? "required" : "optional";
-  const heading = theme
-    ? ` ${paint(field.name, theme.text, { bold: true })}  ${paint(field.type, theme.dim)}  ·  ${paint(tagLabel, field.required ? theme.warning : theme.dim)} `
-    : ` ${field.name}  ${field.type}  ·  ${tagLabel} `;
-  const lines: string[] = [heading];
-
-  if (field.description) {
-    lines.push(`   ${theme ? paint(field.description, theme.textMuted) : field.description} `);
-  }
-  if (field.choices && field.choices.length > 0) {
-    const values = field.choices.join("  ·  ");
-    lines.push(`   ${theme ? paint("values: ", theme.dim) + paint(values, theme.text) : `values: ${values}`} `);
-  }
-  if (field.default !== undefined) {
-    const value = JSON.stringify(field.default);
-    lines.push(`   ${theme ? paint("default: ", theme.dim) + paint(value, theme.text) : `default: ${value}`} `);
-  }
-  if (field.placeholder) {
-    lines.push(`   ${theme ? paint("placeholder: ", theme.dim) + paint(field.placeholder, theme.textMuted) : `placeholder: ${field.placeholder}`} `);
-  }
-
-  return lines;
+function renderInputRows(field: WorkflowInputEntry, theme?: GraphTheme): string[] {
+	const tagLabel = field.required ? "required" : "optional";
+	const heading = theme
+		? ` ${paint(field.name, theme.text, { bold: true })}  ${paint(field.type, theme.dim)}  ·  ${paint(tagLabel, field.required ? theme.warning : theme.dim)} `
+		: ` ${field.name}  ${field.type}  ·  ${tagLabel} `;
+	const lines: string[] = [heading];
+
+	if (field.description) {
+		lines.push(`   ${theme ? paint(field.description, theme.textMuted) : field.description} `);
+	}
+	if (field.choices && field.choices.length > 0) {
+		const values = field.choices.join("  ·  ");
+		lines.push(`   ${theme ? paint("values: ", theme.dim) + paint(values, theme.text) : `values: ${values}`} `);
+	}
+	if (field.default !== undefined) {
+		const value = JSON.stringify(field.default);
+		lines.push(`   ${theme ? paint("default: ", theme.dim) + paint(value, theme.text) : `default: ${value}`} `);
+	}
+	if (field.placeholder) {
+		lines.push(
+			`   ${theme ? paint("placeholder: ", theme.dim) + paint(field.placeholder, theme.textMuted) : `placeholder: ${field.placeholder}`} `,
+		);
+	}
+
+	return lines;
 }
 
 function inputsSummary(name: string, inputs: readonly WorkflowInputEntry[]): string {
-  const required = inputs.filter((i) => i.required).length;
-  const total = inputs.length;
-  const totalLabel = `${total} input${total === 1 ? "" : "s"}`;
-  const reqLabel = `${required} required`;
-  return `${totalLabel}  ·  ${reqLabel}  ·  pass via key=value or run \`/workflow ${name}\` with no args for picker`;
+	const required = inputs.filter((i) => i.required).length;
+	const total = inputs.length;
+	const totalLabel = `${total} input${total === 1 ? "" : "s"}`;
+	const reqLabel = `${required} required`;
+	return `${totalLabel}  ·  ${reqLabel}  ·  pass via key=value or run \`/workflow ${name}\` with no args for picker`;
 }
-

package/dist/builtin/workflows/src/shared/resume-continuation.ts

@@ -1,2 +1,2 @@
 export const RESUME_CONTINUATION_PROMPT =
-  "Continue where you left off. If you believe you are finished with your original task (or a redefined task if the user told you), stop.";
+	"Continue where you left off. If you believe you are finished with your original task (or a redefined task if the user told you), stop.";

package/dist/builtin/workflows/src/shared/returned-run-status.ts

@@ -2,116 +2,130 @@ import type { RunEndMetadata } from "./store-public-types.js";
 import type { RunSnapshot, RunStatus, StageSnapshot, WorkflowFailureKind } from "./store-types.js";
 import type { WorkflowOutputValues } from "./types.js";
 
-const RETURNED_BLOCKED_STATUSES = new Set([
-  "blocked",
-  "needs_human",
-  "incomplete",
-  "auth_blocked",
-  "active",
-]);
+const RETURNED_BLOCKED_STATUSES = new Set(["blocked", "needs_human", "incomplete", "auth_blocked", "active"]);
 
 export interface StructuredRecoverableWorkflowFailure {
-  readonly error: string;
-  readonly metadata: RunEndMetadata;
+	readonly error: string;
+	readonly metadata: RunEndMetadata;
 }
 
 export function normalizeReturnedWorkflowStatus(status: unknown): string | undefined {
-  if (typeof status !== "string") return undefined;
-  const normalized = status.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
-  return normalized.length > 0 ? normalized : undefined;
+	if (typeof status !== "string") return undefined;
+	const normalized = status
+		.trim()
+		.toLowerCase()
+		.replace(/[^a-z0-9]+/g, "_")
+		.replace(/^_+|_+$/g, "");
+	return normalized.length > 0 ? normalized : undefined;
 }
 
 export function isReturnedBlockedWorkflowStatus(status: string): boolean {
-  return RETURNED_BLOCKED_STATUSES.has(status);
+	return RETURNED_BLOCKED_STATUSES.has(status);
 }
 
 export function isReturnedResumableBlockedWorkflowStatus(status: string): boolean {
-  return status !== "blocked" && isReturnedBlockedWorkflowStatus(status);
+	return status !== "blocked" && isReturnedBlockedWorkflowStatus(status);
 }
 
 export function actionableReturnedStatusText(result: WorkflowOutputValues | undefined): string | undefined {
-  return stringResultField(result, "summary") ?? stringResultField(result, "remaining_work") ?? stringResultField(result, "result");
+	return (
+		stringResultField(result, "summary") ??
+		stringResultField(result, "remaining_work") ??
+		stringResultField(result, "result")
+	);
 }
 
 export function structuredRecoverableWorkflowFailure(
-  run: Pick<RunSnapshot,
-    | "error"
-    | "failureKind"
-    | "failureCode"
-    | "failureRecoverability"
-    | "failureDisposition"
-    | "failureMessage"
-    | "failedStageId"
-    | "retryAfterMs"
-    | "stages"
-  >,
+	run: Pick<
+		RunSnapshot,
+		| "error"
+		| "failureKind"
+		| "failureCode"
+		| "failureRecoverability"
+		| "failureDisposition"
+		| "failureMessage"
+		| "failedStageId"
+		| "retryAfterMs"
+		| "stages"
+	>,
 ): StructuredRecoverableWorkflowFailure | undefined {
-  const runFailure = structuredRecoverableFailureFromSnapshot(run);
-  if (runFailure !== undefined) return runFailure;
-  if (run.failedStageId === undefined) return undefined;
+	const runFailure = structuredRecoverableFailureFromSnapshot(run);
+	if (runFailure !== undefined) return runFailure;
+	if (run.failedStageId === undefined) return undefined;
 
-  const failedStage = run.stages.find((stage) => stage.id === run.failedStageId);
-  return failedStage === undefined
-    ? undefined
-    : structuredRecoverableFailureFromSnapshot(failedStage, failedStage.id);
+	const failedStage = run.stages.find((stage) => stage.id === run.failedStageId);
+	return failedStage === undefined ? undefined : structuredRecoverableFailureFromSnapshot(failedStage, failedStage.id);
 }
 
 export function structuredRecoverableWorkflowFailureText(
-  run: Pick<RunSnapshot,
-    | "error"
-    | "failureKind"
-    | "failureCode"
-    | "failureRecoverability"
-    | "failureDisposition"
-    | "failureMessage"
-    | "failedStageId"
-    | "retryAfterMs"
-    | "stages"
-  >,
+	run: Pick<
+		RunSnapshot,
+		| "error"
+		| "failureKind"
+		| "failureCode"
+		| "failureRecoverability"
+		| "failureDisposition"
+		| "failureMessage"
+		| "failedStageId"
+		| "retryAfterMs"
+		| "stages"
+	>,
 ): string | undefined {
-  return structuredRecoverableWorkflowFailure(run)?.error;
+	return structuredRecoverableWorkflowFailure(run)?.error;
 }
 
 export function effectiveRunStatus(run: RunSnapshot): RunStatus {
-  if ((run.status === "running" || run.status === "completed")
-    && structuredRecoverableWorkflowFailure(run) !== undefined) return "blocked";
-  if (run.status !== "completed") return run.status;
-  const returnedStatus = normalizeReturnedWorkflowStatus(run.result?.["status"]);
-  if (returnedStatus === "failed") return "failed";
-  if (returnedStatus !== undefined && isReturnedBlockedWorkflowStatus(returnedStatus)) return "blocked";
-  return run.status;
+	if (
+		(run.status === "running" || run.status === "completed") &&
+		structuredRecoverableWorkflowFailure(run) !== undefined
+	)
+		return "blocked";
+	if (run.status !== "completed") return run.status;
+	const returnedStatus = normalizeReturnedWorkflowStatus(run.result?.status);
+	if (returnedStatus === "failed") return "failed";
+	if (returnedStatus !== undefined && isReturnedBlockedWorkflowStatus(returnedStatus)) return "blocked";
+	return run.status;
 }
 
 function structuredRecoverableFailureFromSnapshot(
-  snapshot: Pick<RunSnapshot | StageSnapshot, "error" | "failureKind" | "failureCode" | "failureRecoverability" | "failureDisposition" | "failureMessage" | "retryAfterMs">,
-  failedStageId?: string,
+	snapshot: Pick<
+		RunSnapshot | StageSnapshot,
+		| "error"
+		| "failureKind"
+		| "failureCode"
+		| "failureRecoverability"
+		| "failureDisposition"
+		| "failureMessage"
+		| "retryAfterMs"
+	>,
+	failedStageId?: string,
 ): StructuredRecoverableWorkflowFailure | undefined {
-  if (snapshot.failureDisposition !== "active_blocked") return undefined;
-  if (snapshot.failureRecoverability !== "recoverable") return undefined;
-  if (!isRecoverableProviderFailureKind(snapshot.failureKind)) return undefined;
-  const error = snapshot.error ?? snapshot.failureMessage ?? "Workflow is blocked by a recoverable provider failure.";
-  return {
-    error,
-    metadata: {
-      failureKind: snapshot.failureKind,
-      ...(snapshot.failureCode !== undefined ? { failureCode: snapshot.failureCode } : {}),
-      failureRecoverability: snapshot.failureRecoverability,
-      failureDisposition: snapshot.failureDisposition,
-      failureMessage: snapshot.failureMessage ?? error,
-      ...(failedStageId !== undefined ? { failedStageId } : {}),
-      resumable: true,
-      ...(snapshot.retryAfterMs !== undefined ? { retryAfterMs: snapshot.retryAfterMs } : {}),
-    },
-  };
+	if (snapshot.failureDisposition !== "active_blocked") return undefined;
+	if (snapshot.failureRecoverability !== "recoverable") return undefined;
+	if (!isRecoverableProviderFailureKind(snapshot.failureKind)) return undefined;
+	const error = snapshot.error ?? snapshot.failureMessage ?? "Workflow is blocked by a recoverable provider failure.";
+	return {
+		error,
+		metadata: {
+			failureKind: snapshot.failureKind,
+			...(snapshot.failureCode !== undefined ? { failureCode: snapshot.failureCode } : {}),
+			failureRecoverability: snapshot.failureRecoverability,
+			failureDisposition: snapshot.failureDisposition,
+			failureMessage: snapshot.failureMessage ?? error,
+			...(failedStageId !== undefined ? { failedStageId } : {}),
+			resumable: true,
+			...(snapshot.retryAfterMs !== undefined ? { retryAfterMs: snapshot.retryAfterMs } : {}),
+		},
+	};
 }
 
-function isRecoverableProviderFailureKind(kind: WorkflowFailureKind | undefined): kind is "auth" | "rate_limit" | "provider" {
-  return kind === "auth" || kind === "rate_limit" || kind === "provider";
+function isRecoverableProviderFailureKind(
+	kind: WorkflowFailureKind | undefined,
+): kind is "auth" | "rate_limit" | "provider" {
+	return kind === "auth" || kind === "rate_limit" || kind === "provider";
 }
 
-
-
 function stringResultField(result: WorkflowOutputValues | undefined, key: string): string | undefined {
-  const value = result?.[key];
-  return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+	const value = result?.[key];
+	return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
 }

package/dist/builtin/workflows/src/shared/run-id.ts

@@ -0,0 +1,36 @@
+/**
+ * The run identifier contract.
+ *
+ * A run id is a bare `crypto.randomUUID()` value (see `extension/dispatcher.ts`),
+ * and the durable DBOS `workflowId` is that same value. Every user-facing surface
+ * renders it in full, so every resolver accepts it only in full: there is no
+ * unique-prefix fallback and no truncated form that addresses a run.
+ *
+ * This lives in `shared/` because both the extension resolvers and the durable
+ * catalog need it, and `durable/` must not import from `extension/`.
+ */
+
+/** Canonical rendered length of a run id, dashes included. */
+export const RUN_ID_LENGTH = 36;
+
+const RUN_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+/**
+ * True only for a full 8-4-4-4-12 hex UUID.
+ *
+ * Rejects a prefix, a 32-character dashless form, and a 36-character string that
+ * is the right length but not hex — a transposed or truncated paste should fail
+ * loudly here rather than silently miss during lookup.
+ */
+export function isFullRunId(value: string): boolean {
+	return RUN_ID_PATTERN.test(value);
+}
+
+/**
+ * Reported instead of "not found" so a truncated paste is diagnosable as
+ * truncated. A well-formed id that no run happens to carry is a different
+ * failure and keeps the not-found message.
+ */
+export function malformedRunIdMessage(target: string): string {
+	return `Run id must be a full ${RUN_ID_LENGTH}-character UUID; got "${target}" (${target.length} chars).`;
+}

package/dist/builtin/workflows/src/shared/run-visibility.ts

@@ -1,9 +1,9 @@
 import type { RunSnapshot } from "./store-types.js";
 
 export function isTopLevelWorkflowRun(run: Pick<RunSnapshot, "parentRunId">): boolean {
-  return run.parentRunId === undefined;
+	return run.parentRunId === undefined;
 }
 
 export function topLevelWorkflowRuns(runs: readonly RunSnapshot[]): RunSnapshot[] {
-  return runs.filter(isTopLevelWorkflowRun);
+	return runs.filter(isTopLevelWorkflowRun);
 }

package/dist/builtin/workflows/src/shared/schema-introspection.ts

@@ -11,78 +11,70 @@
  */
 
 import {
-  IsAny,
-  IsArray,
-  IsBoolean,
-  IsInteger,
-  IsLiteralString,
-  IsNumber,
-  IsObject,
-  IsOptional,
-  IsString,
-  IsUnion,
-  type TSchema,
+	IsAny,
+	IsArray,
+	IsBoolean,
+	IsInteger,
+	IsLiteralString,
+	IsNumber,
+	IsObject,
+	IsOptional,
+	IsString,
+	IsUnion,
+	type TSchema,
 } from "typebox";
 import type { WorkflowInputEntry } from "../extension/render-result.js";
 
 /** Field-kind label expected by the legacy descriptor consumers. */
-export type SchemaFieldKind =
-  | "text"
-  | "number"
-  | "integer"
-  | "boolean"
-  | "select"
-  | "object"
-  | "array"
-  | "unknown";
+export type SchemaFieldKind = "text" | "number" | "integer" | "boolean" | "select" | "object" | "array" | "unknown";
 
 interface SchemaMeta {
-  readonly default?: unknown;
-  readonly description?: string;
-  readonly anyOf?: readonly TSchema[];
-  readonly const?: unknown;
+	readonly default?: unknown;
+	readonly description?: string;
+	readonly anyOf?: readonly TSchema[];
+	readonly const?: unknown;
 }
 
 function meta(schema: TSchema): SchemaMeta {
-  return schema as unknown as SchemaMeta;
+	return schema as unknown as SchemaMeta;
 }
 
 /** True when every member of a union is a string literal. */
 function isStringLiteralUnion(schema: TSchema): boolean {
-  if (!IsUnion(schema)) return false;
-  const members = meta(schema).anyOf ?? [];
-  return members.length > 0 && members.every((m) => IsLiteralString(m));
+	if (!IsUnion(schema)) return false;
+	const members = meta(schema).anyOf ?? [];
+	return members.length > 0 && members.every((m) => IsLiteralString(m));
 }
 
 /** Map a TypeBox schema to the legacy field-kind label. */
 export function schemaFieldKind(schema: TSchema): SchemaFieldKind {
-  if (isStringLiteralUnion(schema)) return "select";
-  if (IsLiteralString(schema)) return "text";
-  if (IsString(schema)) return "text";
-  if (IsInteger(schema)) return "integer";
-  if (IsNumber(schema)) return "number";
-  if (IsBoolean(schema)) return "boolean";
-  if (IsObject(schema)) return "object";
-  if (IsArray(schema)) return "array";
-  if (IsAny(schema)) return "unknown";
-  return "unknown";
+	if (isStringLiteralUnion(schema)) return "select";
+	if (IsLiteralString(schema)) return "text";
+	if (IsString(schema)) return "text";
+	if (IsInteger(schema)) return "integer";
+	if (IsNumber(schema)) return "number";
+	if (IsBoolean(schema)) return "boolean";
+	if (IsObject(schema)) return "object";
+	if (IsArray(schema)) return "array";
+	if (IsAny(schema)) return "unknown";
+	return "unknown";
 }
 
 /** Declared default value (`schema.default`), or undefined when none. */
 export function schemaDefault(schema: TSchema): unknown {
-  return meta(schema).default;
+	return meta(schema).default;
 }
 
 /** Declared description, or undefined. */
 export function schemaDescription(schema: TSchema): string | undefined {
-  return meta(schema).description;
+	return meta(schema).description;
 }
 
 /** Allowed string values for a string-literal union, else undefined. */
 export function schemaChoices(schema: TSchema): readonly string[] | undefined {
-  if (!isStringLiteralUnion(schema)) return undefined;
-  const members = meta(schema).anyOf ?? [];
-  return members.map((m) => String(meta(m).const));
+	if (!isStringLiteralUnion(schema)) return undefined;
+	const members = meta(schema).anyOf ?? [];
+	return members.map((m) => String(meta(m).const));
 }
 
 /**
@@ -94,28 +86,26 @@ export function schemaChoices(schema: TSchema): readonly string[] | undefined {
  * `{ default }` implied `required: false`.
  */
 export function schemaIsRequired(schema: TSchema): boolean {
-  return !IsOptional(schema) && schemaDefault(schema) === undefined;
+	return !IsOptional(schema) && schemaDefault(schema) === undefined;
 }
 
 /** Derive the legacy normalized input descriptor for a single named field. */
 export function deriveInputField(name: string, schema: TSchema): WorkflowInputEntry {
-  const choices = schemaChoices(schema);
-  const def = schemaDefault(schema);
-  const description = schemaDescription(schema);
-  const entry: WorkflowInputEntry = {
-    name,
-    type: schemaFieldKind(schema),
-    required: schemaIsRequired(schema),
-  };
-  if (description !== undefined) entry.description = description;
-  if (def !== undefined) entry.default = def;
-  if (choices !== undefined) entry.choices = choices;
-  return entry;
+	const choices = schemaChoices(schema);
+	const def = schemaDefault(schema);
+	const description = schemaDescription(schema);
+	const entry: WorkflowInputEntry = {
+		name,
+		type: schemaFieldKind(schema),
+		required: schemaIsRequired(schema),
+	};
+	if (description !== undefined) entry.description = description;
+	if (def !== undefined) entry.default = def;
+	if (choices !== undefined) entry.choices = choices;
+	return entry;
 }
 
 /** Derive descriptors for an entire declared input map (preserving order). */
-export function deriveInputFields(
-  schema: Readonly<Record<string, TSchema>>,
-): WorkflowInputEntry[] {
-  return Object.entries(schema).map(([name, s]) => deriveInputField(name, s));
+export function deriveInputFields(schema: Readonly<Record<string, TSchema>>): WorkflowInputEntry[] {
+	return Object.entries(schema).map(([name, s]) => deriveInputField(name, s));
 }