@lostgradient/weft 0.2.0

package/dist/cli/api.js

@@ -0,0 +1,191 @@
+import { createLiveOperationRegistry } from "../server/rest-bindings.js";
+import { findNearestCandidate } from "./command-suggestions.js";
+import snapshotData from "./generated/operation-catalog.snapshot.json";
+import { sendJsonRpcRequest } from "./json-rpc-client.js";
+const snapshot = snapshotData, operationByName = new Map(snapshot.operations.map((operation) => [operation.name, operation]));
+export async function executeApi(command) {
+  if (command.list)
+    return listOperations(command);
+  if (command.describe !== void 0)
+    return describeOperation(command.describe, command.json);
+  const operationResult = resolveInvokableOperation(command);
+  if (!operationResult.ok)
+    return operationResult.output;
+  const operation = operationResult.operation, inputResult = await readInput(command);
+  if (!inputResult.ok)
+    return inputResult.output;
+  const validation = validateInput(operation.name, inputResult.value);
+  if (!validation.ok)
+    return validation.output;
+  return callOperation(command, operation.name, validation.value);
+}
+function resolveInvokableOperation(command) {
+  if (command.operationName === void 0)
+    return {
+      ok: !1,
+      output: usageError("api: expected --list, --describe <operation-name>, or an operation name")
+    };
+  const operation = operationByName.get(command.operationName);
+  if (operation === void 0)
+    return { ok: !1, output: usageError(formatUnknownOperation(command.operationName)) };
+  return assertInvokableOperation(operation, command.yes);
+}
+function assertInvokableOperation(operation, confirmed) {
+  if (operation.kind !== "unary")
+    return {
+      ok: !1,
+      output: usageError(`api: ${operation.name} is ${operation.kind}; flat invocation supports unary operations only`)
+    };
+  if (!operation.transports.jsonRpcHttp)
+    return {
+      ok: !1,
+      output: usageError(`api: ${operation.name} is not available over JSON-RPC HTTP`)
+    };
+  if (operation.destructive && !confirmed)
+    return {
+      ok: !1,
+      output: {
+        stdout: "",
+        stderr: `api: ${operation.name} is destructive; pass --yes to confirm execution`,
+        exitCode: 1
+      }
+    };
+  return { ok: !0, operation };
+}
+function listOperations(command) {
+  const operations = snapshot.operations.map((operation) => ({
+    name: operation.name,
+    kind: operation.kind,
+    scope: formatAccess(operation),
+    transport: operation.transports.jsonRpcHttp ? "json-rpc-http" : "unsupported",
+    destructive: operation.destructive,
+    summary: operation.summary
+  }));
+  if (command.json)
+    return { stdout: JSON.stringify({ operations }, null, 2), exitCode: 0 };
+  const rows = operations.map((operation) => [
+    operation.name.padEnd(38),
+    operation.kind.padEnd(12),
+    operation.scope.padEnd(24),
+    operation.transport.padEnd(14),
+    operation.destructive ? "destructive" : "safe",
+    operation.summary
+  ].join("  "));
+  return {
+    stdout: [
+      "name".padEnd(38) + "  kind          scope                     transport       safety       summary",
+      ...rows
+    ].join(`
+`),
+    exitCode: 0
+  };
+}
+function describeOperation(name, json) {
+  const operation = operationByName.get(name);
+  if (operation === void 0)
+    return usageError(formatUnknownOperation(name));
+  if (json)
+    return { stdout: JSON.stringify(operation, null, 2), exitCode: 0 };
+  return {
+    stdout: formatOperationDescription(operation),
+    exitCode: 0
+  };
+}
+function formatOperationDescription(operation) {
+  return [
+    `Name: ${operation.name}`,
+    `Summary: ${operation.summary}`,
+    `Description: ${operation.description ?? operation.summary}`,
+    `Kind: ${operation.kind}`,
+    `Scope: ${formatAccess(operation)}`,
+    `Transport: ${operation.transports.jsonRpcHttp ? "json-rpc-http" : "unsupported"}`,
+    `Safety: ${operation.destructive ? "destructive" : "safe"}`,
+    `Input schema: ${JSON.stringify(operation.inputSchema, null, 2)}`,
+    `Output schema: ${JSON.stringify(operation.outputSchema, null, 2)}`,
+    `Faults: ${JSON.stringify(operation.producibleFaults, null, 2)}`
+  ].join(`
+`);
+}
+async function readInput(command) {
+  if (command.input !== void 0)
+    return parseInput(command.input);
+  if (command.inputFile !== void 0) {
+    if (command.inputFile === "-")
+      return parseInput(await Bun.stdin.text());
+    const file = Bun.file(command.inputFile);
+    if (!await file.exists())
+      return { ok: !1, output: usageError(`api: input file not found: ${command.inputFile}`) };
+    return parseInput(await file.text());
+  }
+  return { ok: !0, value: {} };
+}
+function parseInput(source) {
+  try {
+    return { ok: !0, value: JSON.parse(source) };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { ok: !1, output: usageError(`api: invalid JSON input: ${message}`) };
+  }
+}
+function validateInput(operationName, input) {
+  const operation = createLiveOperationRegistry().get(operationName);
+  if (operation === void 0)
+    return { ok: !1, output: usageError(formatUnknownOperation(operationName)) };
+  const parsed = operation.inputSchema.safeParse(input);
+  if (!parsed.success)
+    return {
+      ok: !1,
+      output: usageError(`api: input validation failed for ${operationName}: ${parsed.error.issues.map((issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`).join("; ")}`)
+    };
+  return normalizeValidatedInput(operationName, parsed.data);
+}
+export function normalizeValidatedInput(operationName, parsedData) {
+  if (parsedData === null || typeof parsedData !== "object" || Array.isArray(parsedData))
+    return { ok: !1, output: usageError(`api: ${operationName} input must be a JSON object`) };
+  return { ok: !0, value: parsedData };
+}
+async function callOperation(command, operationName, input) {
+  let result;
+  try {
+    result = await sendJsonRpcRequest(command, operationName, input, "weft-api");
+  } catch (error) {
+    return {
+      stdout: "",
+      stderr: `api: connection failed: ${error instanceof Error ? error.message : String(error)}`,
+      exitCode: 2
+    };
+  }
+  if (!result.ok) {
+    if (command.json)
+      return {
+        stdout: JSON.stringify({ ok: !1, error: result.error }, null, 2),
+        exitCode: 1
+      };
+    return {
+      stdout: "",
+      stderr: `api: ${result.error.message}`,
+      exitCode: 1
+    };
+  }
+  return {
+    stdout: JSON.stringify(result.result, null, 2),
+    exitCode: 0
+  };
+}
+function formatAccess(operation) {
+  const access = operation.access;
+  if (access.kind === "public" || access.kind === "authenticated")
+    return access.kind;
+  if (access.kind === "scoped")
+    return access.scopes.join(",");
+  if (access.kind === "optionalAuth")
+    return `optional:${access.scopes.join(",")}`;
+  return access.alternatives.map((alternative) => alternative.join("&")).join("|");
+}
+function formatUnknownOperation(name) {
+  const suggestion = findNearestCandidate(name, snapshot.operations.map((operation) => operation.name), 6), suffix = suggestion === void 0 ? "" : `. Did you mean ${suggestion}?`;
+  return `api: unknown operation ${name}${suffix}. Run weft api --list`;
+}
+function usageError(message) {
+  return { stdout: "", stderr: message, exitCode: 3 };
+}

package/dist/cli/codegen-arguments.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Argument parser for the `weft codegen` subcommand. Kept in its own
+ * module so {@link parse-arguments} doesn't grow past the per-file
+ * size budget.
+ *
+ * @module cli/codegen-arguments
+ */
+import type { CliCommand } from './types.ts';
+/** Parse a `weft codegen ...` argument list. */
+export declare function parseCodegenArguments(args: string[]): CliCommand;

package/dist/cli/codegen-arguments.js

@@ -0,0 +1,50 @@
+import { parseArgs } from "node:util";
+const CODEGEN_DEFAULT_TIMEOUT_MS = 30000;
+function parseCodegenTimeout(value) {
+  if (value === void 0)
+    return CODEGEN_DEFAULT_TIMEOUT_MS;
+  const timeoutMs = Number(value);
+  if (!Number.isSafeInteger(timeoutMs) || timeoutMs <= 0)
+    throw Error(`--timeout must be a positive integer number of milliseconds (got '${value}')`);
+  return timeoutMs;
+}
+function validateCodegenFlags(values) {
+  if (values.server !== void 0 && values.from !== void 0)
+    throw Error("codegen: --server and --from cannot be used together");
+  if (values.out === void 0 || values.out === "")
+    throw Error("codegen: --out is required");
+  if (values.token !== void 0 && values.from !== void 0)
+    throw Error("codegen: --token cannot be used with --from");
+}
+function buildCodegenCommand(values, help) {
+  return {
+    command: "codegen",
+    out: values.out ?? "",
+    timeoutMs: help ? CODEGEN_DEFAULT_TIMEOUT_MS : parseCodegenTimeout(values.timeout),
+    help,
+    json: values.json ?? !1,
+    ...values.server !== void 0 ? { server: values.server } : {},
+    ...values.from !== void 0 ? { from: values.from } : {},
+    ...values.token !== void 0 ? { token: values.token } : {}
+  };
+}
+export function parseCodegenArguments(args) {
+  const { values } = parseArgs({
+    args,
+    options: {
+      server: { type: "string" },
+      from: { type: "string" },
+      token: { type: "string" },
+      out: { type: "string", short: "o" },
+      timeout: { type: "string" },
+      json: { type: "boolean", short: "j", default: !1 },
+      help: { type: "boolean", short: "h", default: !1 }
+    },
+    strict: !0,
+    allowPositionals: !1
+  });
+  if (values.help ?? !1)
+    return buildCodegenCommand(values, !0);
+  validateCodegenFlags(values);
+  return buildCodegenCommand(values, !1);
+}

package/dist/cli/codegen-emit-keywords.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Shared JSON-Schema keyword sets and the error type used by the
+ * codegen emitter. Lives in its own module so `codegen-emit.ts`
+ * stays under the 500-line per-file budget.
+ *
+ * @module cli/codegen-emit-keywords
+ */
+import { WeftError } from '../core/weft-error.ts';
+export declare const ANNOTATION_ONLY_KEYWORDS: ReadonlySet<string>;
+/** Keys each per-shape dispatcher in the emitter understands. */
+export declare const PRIMITIVE_SUPPORTED_KEYS: readonly ["type"];
+export declare const OBJECT_SUPPORTED_KEYS: readonly ["type", "properties", "required", "additionalProperties"];
+export declare const ARRAY_SUPPORTED_KEYS: readonly ["type", "items", "prefixItems", "additionalItems"];
+/**
+ * Thrown by the emitter when the converter cannot produce a type it
+ * is willing to stand behind (e.g. recursion overflow). Callers must
+ * translate this to a user-facing diagnostic.
+ */
+export declare class CodegenEmitError extends WeftError<'CodegenEmitError'> {
+    constructor(message: string);
+}
+/**
+ * Returns true when `node` has any own key not in `expected` and not
+ * in {@link ANNOTATION_ONLY_KEYWORDS}. Used by combinator,
+ * enum/const, and type/shape dispatchers to detect sibling
+ * constraints they cannot compose with.
+ */
+export declare function hasUnexpectedSibling(node: Record<string, unknown>, expected: readonly string[]): boolean;

package/dist/cli/codegen-emit-keywords.js

@@ -0,0 +1,48 @@
+import { WeftError } from "../core/weft-error.js";
+export const ANNOTATION_ONLY_KEYWORDS = new Set([
+  "description",
+  "title",
+  "default",
+  "$comment",
+  "examples",
+  "readOnly",
+  "writeOnly",
+  "deprecated",
+  "$schema",
+  "$id",
+  "minLength",
+  "maxLength",
+  "pattern",
+  "format",
+  "minimum",
+  "maximum",
+  "exclusiveMinimum",
+  "exclusiveMaximum",
+  "multipleOf",
+  "minItems",
+  "maxItems",
+  "uniqueItems",
+  "minProperties",
+  "maxProperties"
+]), PRIMITIVE_SUPPORTED_KEYS = ["type"], OBJECT_SUPPORTED_KEYS = [
+  "type",
+  "properties",
+  "required",
+  "additionalProperties"
+], ARRAY_SUPPORTED_KEYS = ["type", "items", "prefixItems", "additionalItems"];
+
+export class CodegenEmitError extends WeftError {
+  constructor(message) {
+    super("CodegenEmitError", message);
+  }
+}
+export function hasUnexpectedSibling(node, expected) {
+  for (const key of Object.keys(node)) {
+    if (expected.includes(key))
+      continue;
+    if (ANNOTATION_ONLY_KEYWORDS.has(key))
+      continue;
+    return !0;
+  }
+  return !1;
+}

package/dist/cli/codegen-emit.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Deterministic JSON-Schema → TypeScript emitter for `weft codegen`.
+ *
+ * Consumes a {@link RegistrySnapshot} (the same shape served by
+ * `GET /v1/registry`) and produces a single `.d.ts` string that
+ * augments the public `'@lostgradient/weft'` module with typed `WorkflowRegistry`
+ * entries. The output is byte-stable across runs with the same input:
+ * keys are sorted with explicit codepoint comparators, property names
+ * are uniformly double-quoted via `JSON.stringify`, and there are no
+ * timestamps or environment-dependent paths.
+ *
+ * The augmented `WorkflowRegistry` interface is the single source of
+ * truth for per-workflow input/output typing across the whole public
+ * surface: `engine.start`, `WorkflowHandle.result()`, AND the client
+ * (`WeftClient.start`/`schedule` and `ClientHandle.result()`). The
+ * client overloads key off this interface, so emitting one declaration
+ * narrows both engine and client call sites — there is no separate
+ * client-specific emission, and skipping codegen leaves both usable with
+ * plain string names.
+ *
+ * Activity names are no longer emitted as a global `ActivityTypes`
+ * module augmentation — that interface was removed when the chained
+ * workflow builder made activity names a per-workflow concern (typed at
+ * the builder's `.activities({...})` step). The snapshot still carries
+ * activity schemas because the same registry feeds discovery and MCP tooling,
+ * but the emitter intentionally drops them from the
+ * generated `.d.ts`.
+ *
+ * The JSON Schema subset supported here covers what
+ * `definitionSchemaToJsonSchema` actually produces today (Zod via
+ * `z.toJSONSchema` and Valibot via `@valibot/to-json-schema`).
+ * Anything outside that subset degrades to `unknown` so the emitter
+ * never claims a type it cannot justify.
+ *
+ * @module cli/codegen-emit
+ */
+import type { RegistrySnapshot } from '../core/registry-snapshot.ts';
+export { CodegenEmitError } from './codegen-emit-keywords.ts';
+/** Emit a TypeScript property key as a double-quoted string literal. */
+export declare function emitPropertyKey(name: string): string;
+/** Convert a single JSON Schema fragment to a TypeScript type expression. */
+export declare function jsonSchemaToTypeScript(schema: unknown): string;
+/**
+ * Emit the full `.d.ts` declaration string for a registry snapshot.
+ *
+ * The output is deterministic: keys are sorted by codepoint, property
+ * names go through {@link emitPropertyKey}, and unions/intersections
+ * are always parenthesized so they compose correctly when nested.
+ */
+export declare function emitRegistryDeclaration(snapshot: RegistrySnapshot): string;

package/dist/cli/codegen-emit.js

@@ -0,0 +1,280 @@
+import {
+  ARRAY_SUPPORTED_KEYS,
+  CodegenEmitError,
+  hasUnexpectedSibling,
+  OBJECT_SUPPORTED_KEYS,
+  PRIMITIVE_SUPPORTED_KEYS
+} from "./codegen-emit-keywords.js";
+export { CodegenEmitError } from "./codegen-emit-keywords.js";
+const WEFT_PACKAGE_NAME = "@lostgradient/weft";
+function codepointCompare(a, b) {
+  if (a < b)
+    return -1;
+  if (a > b)
+    return 1;
+  return 0;
+}
+export function emitPropertyKey(name) {
+  return JSON.stringify(name);
+}
+function primitiveTypeFor(typeKeyword) {
+  switch (typeKeyword) {
+    case "string":
+      return "string";
+    case "number":
+    case "integer":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "null":
+      return "null";
+    default:
+      return;
+  }
+}
+const MAX_RECURSION_DEPTH = 64;
+function tryCombinator(node, depth) {
+  const hasOneOf = Array.isArray(node.oneOf), hasAnyOf = Array.isArray(node.anyOf), hasAllOf = Array.isArray(node.allOf), combinatorCount = (hasOneOf ? 1 : 0) + (hasAnyOf ? 1 : 0) + (hasAllOf ? 1 : 0);
+  if (combinatorCount === 0)
+    return;
+  if (combinatorCount > 1)
+    return "unknown";
+  if (hasUnexpectedSibling(node, ["oneOf", "anyOf", "allOf"]))
+    return "unknown";
+  if (hasOneOf)
+    return parenUnion(node.oneOf, depth);
+  if (hasAnyOf)
+    return parenUnion(node.anyOf, depth);
+  return parenIntersection(node.allOf, depth);
+}
+function enumLiteralsToTypeScript(entries) {
+  if (entries.length === 0)
+    return "unknown";
+  const literals = entries.map(literalFromValue);
+  if (literals.some((literal) => literal === "unknown"))
+    return "unknown";
+  if (literals.length === 1)
+    return literals[0];
+  return `(${literals.join(" | ")})`;
+}
+function tryEnumOrConst(node) {
+  const hasConst = "const" in node, hasEnum = Array.isArray(node.enum);
+  if (!hasConst && !hasEnum)
+    return;
+  if (hasConst && hasEnum)
+    return "unknown";
+  if (hasUnexpectedSibling(node, [hasConst ? "const" : "enum"]))
+    return "unknown";
+  if (hasConst)
+    return literalFromValue(node.const);
+  return enumLiteralsToTypeScript(node.enum);
+}
+const OBJECT_ONLY_KEYWORDS = ["properties", "required", "additionalProperties"], ARRAY_ONLY_KEYWORDS = ["items", "prefixItems", "additionalItems"];
+function projectNodeForTypeBranch(node, branchType) {
+  const projected = {};
+  for (const [key, value] of Object.entries(node)) {
+    if (key === "type")
+      continue;
+    if (branchType !== "object" && OBJECT_ONLY_KEYWORDS.includes(key))
+      continue;
+    if (branchType !== "array" && ARRAY_ONLY_KEYWORDS.includes(key))
+      continue;
+    projected[key] = value;
+  }
+  projected.type = branchType;
+  return projected;
+}
+function expandTypeArray(node, typeKeyword, depth) {
+  if (typeKeyword.length === 0)
+    return "unknown";
+  const branches = typeKeyword.map((branchType) => {
+    if (typeof branchType !== "string")
+      return "unknown";
+    return jsonSchemaToTypeScriptAtDepth(projectNodeForTypeBranch(node, branchType), depth + 1);
+  });
+  if (branches.length === 1)
+    return branches[0];
+  return `(${branches.join(" | ")})`;
+}
+function dispatchTypeString(node, typeKeyword, depth) {
+  if (typeKeyword === "array") {
+    if (hasUnexpectedSibling(node, ARRAY_SUPPORTED_KEYS))
+      return "unknown";
+    return arrayTypeScript(node, depth);
+  }
+  if (typeKeyword === "object") {
+    if (hasUnexpectedSibling(node, OBJECT_SUPPORTED_KEYS))
+      return "unknown";
+    return objectTypeScript(node, depth);
+  }
+  const primitive = primitiveTypeFor(typeKeyword);
+  if (primitive === void 0)
+    return;
+  if (hasUnexpectedSibling(node, PRIMITIVE_SUPPORTED_KEYS))
+    return "unknown";
+  return primitive;
+}
+function dispatchByType(node, depth) {
+  const typeKeyword = node.type;
+  if (Array.isArray(typeKeyword))
+    return expandTypeArray(node, typeKeyword, depth);
+  if (typeof typeKeyword !== "string")
+    return;
+  return dispatchTypeString(node, typeKeyword, depth);
+}
+function dispatchByShape(node, depth) {
+  if ("properties" in node || "additionalProperties" in node) {
+    if (hasUnexpectedSibling(node, OBJECT_SUPPORTED_KEYS))
+      return "unknown";
+    return objectTypeScript(node, depth);
+  }
+  if ("items" in node || "prefixItems" in node) {
+    if (hasUnexpectedSibling(node, ARRAY_SUPPORTED_KEYS))
+      return "unknown";
+    return arrayTypeScript(node, depth);
+  }
+  return;
+}
+function normalizeSchema(schema) {
+  if (schema === void 0 || schema === null)
+    return "unknown";
+  if (schema === !0)
+    return "unknown";
+  if (schema === !1)
+    return "never";
+  if (typeof schema !== "object" || Array.isArray(schema))
+    return "unknown";
+  return schema;
+}
+function jsonSchemaToTypeScriptAtDepth(schema, depth) {
+  if (depth > MAX_RECURSION_DEPTH)
+    throw new CodegenEmitError(`JSON Schema converter exceeded ${MAX_RECURSION_DEPTH} levels of nesting`);
+  const node = normalizeSchema(schema);
+  if (typeof node === "string")
+    return node;
+  return tryCombinator(node, depth) ?? tryEnumOrConst(node) ?? dispatchByType(node, depth) ?? dispatchByShape(node, depth) ?? "unknown";
+}
+export function jsonSchemaToTypeScript(schema) {
+  return jsonSchemaToTypeScriptAtDepth(schema, 0);
+}
+function parenUnion(branches, depth) {
+  if (branches.length === 0)
+    return "unknown";
+  const types = branches.map((branch) => jsonSchemaToTypeScriptAtDepth(branch, depth + 1));
+  if (types.length === 1)
+    return types[0];
+  return `(${types.join(" | ")})`;
+}
+function parenIntersection(branches, depth) {
+  if (branches.length === 0)
+    return "unknown";
+  const types = branches.map((branch) => jsonSchemaToTypeScriptAtDepth(branch, depth + 1));
+  if (types.length === 1)
+    return types[0];
+  return `(${types.join(" & ")})`;
+}
+function literalFromValue(value) {
+  if (value === null)
+    return "null";
+  if (typeof value === "string")
+    return JSON.stringify(value);
+  if (typeof value === "number" && Number.isFinite(value))
+    return String(value);
+  if (typeof value === "boolean")
+    return value ? "true" : "false";
+  return "unknown";
+}
+function arrayTypeScript(node, depth) {
+  const { prefixItems, items: itemsRaw, additionalItems: additionalItemsRaw } = node, childDepth = depth + 1;
+  if (Array.isArray(prefixItems)) {
+    const positions = prefixItems.map((p) => jsonSchemaToTypeScriptAtDepth(p, childDepth));
+    if (itemsRaw === !1)
+      return `[${positions.join(", ")}]`;
+    if (itemsRaw === void 0)
+      return `[${[...positions, "...unknown[]"].join(", ")}]`;
+    const restType = jsonSchemaToTypeScriptAtDepth(itemsRaw, childDepth);
+    return `[${[...positions, `...${restType}[]`].join(", ")}]`;
+  }
+  if (Array.isArray(itemsRaw)) {
+    const positions = itemsRaw.map((p) => jsonSchemaToTypeScriptAtDepth(p, childDepth));
+    if (additionalItemsRaw === !1)
+      return `[${positions.join(", ")}]`;
+    if (additionalItemsRaw === void 0)
+      return `[${[...positions, "...unknown[]"].join(", ")}]`;
+    const restType = jsonSchemaToTypeScriptAtDepth(additionalItemsRaw, childDepth);
+    return `[${[...positions, `...${restType}[]`].join(", ")}]`;
+  }
+  if (itemsRaw === void 0 || itemsRaw === !0)
+    return "Array<unknown>";
+  if (itemsRaw === !1)
+    return "[]";
+  return `Array<${jsonSchemaToTypeScriptAtDepth(itemsRaw, childDepth)}>`;
+}
+function renderObjectProperties(properties, requiredSet, depth) {
+  const declaredKeys = properties ? Object.keys(properties) : [], declaredKeySet = new Set(declaredKeys), missingRequired = [...requiredSet].filter((key) => !declaredKeySet.has(key)), allKeys = [...declaredKeys, ...missingRequired].toSorted(codepointCompare), propertyLines = [], namedValueTypes = [];
+  let hasOptionalNamedProperty = !1;
+  for (const key of allKeys) {
+    const isRequired = requiredSet.has(key), schemaForKey = properties && declaredKeySet.has(key) ? properties[key] : void 0, valueType = jsonSchemaToTypeScriptAtDepth(schemaForKey, depth + 1);
+    namedValueTypes.push(valueType);
+    if (!isRequired)
+      hasOptionalNamedProperty = !0;
+    propertyLines.push(`${emitPropertyKey(key)}${isRequired ? "" : "?"}: ${valueType};`);
+  }
+  return { propertyLines, namedValueTypes, hasOptionalNamedProperty };
+}
+function emptyObjectTypeScript(indexSignature) {
+  if (indexSignature === void 0)
+    return "Record<string, never>";
+  if (indexSignature === "unknown")
+    return "Record<string, unknown>";
+  return `{ [index: string]: ${indexSignature} }`;
+}
+function objectTypeScript(node, depth) {
+  const propertiesRaw = node.properties, properties = propertiesRaw !== null && typeof propertiesRaw === "object" && !Array.isArray(propertiesRaw) ? propertiesRaw : void 0, requiredRaw = node.required, requiredSet = new Set(Array.isArray(requiredRaw) ? requiredRaw.filter((entry) => typeof entry === "string") : []), rendering = renderObjectProperties(properties, requiredSet, depth), indexSignature = indexSignatureForObject(node.additionalProperties, rendering.namedValueTypes, rendering.hasOptionalNamedProperty, depth);
+  if (rendering.propertyLines.length === 0)
+    return emptyObjectTypeScript(indexSignature);
+  if (indexSignature === void 0)
+    return `{ ${rendering.propertyLines.join(" ")} }`;
+  return `{ ${rendering.propertyLines.join(" ")} [index: string]: ${indexSignature}; }`;
+}
+function indexSignatureForObject(additionalRaw, namedValueTypes, hasOptionalNamedProperty, depth) {
+  if (additionalRaw === !1)
+    return;
+  if (additionalRaw === void 0 || additionalRaw === !0)
+    return "unknown";
+  if (additionalRaw !== null && typeof additionalRaw === "object" && !Array.isArray(additionalRaw)) {
+    const typedValue = jsonSchemaToTypeScriptAtDepth(additionalRaw, depth + 1), unionMembers = new Set([typedValue, ...namedValueTypes]);
+    if (hasOptionalNamedProperty)
+      unionMembers.add("undefined");
+    const members = [...unionMembers];
+    if (members.length === 1)
+      return members[0];
+    return members.join(" | ");
+  }
+  return "unknown";
+}
+function sortedWorkflowEntries(workflows) {
+  return Object.entries(workflows).toSorted(([a], [b]) => codepointCompare(a, b));
+}
+function emitWorkflowEntry(name, entry) {
+  const input = jsonSchemaToTypeScript(entry.inputSchema), output = jsonSchemaToTypeScript(entry.outputSchema);
+  return `    ${emitPropertyKey(name)}: { input: ${input}; output: ${output} };`;
+}
+export function emitRegistryDeclaration(snapshot) {
+  const workflowLines = sortedWorkflowEntries(snapshot.workflows).map(([name, entry]) => emitWorkflowEntry(name, entry)), workflowBlock = workflowLines.length === 0 ? "  interface WorkflowRegistry {}" : ["  interface WorkflowRegistry {", ...workflowLines, "  }"].join(`
+`);
+  return [
+    "// Generated by `weft codegen`. Do not edit by hand.",
+    "// Augments `WorkflowRegistry` to type engine and client call sites",
+    "// (start/schedule input and handle.result() output) per workflow.",
+    "/* eslint-disable */",
+    "",
+    `declare module '${WEFT_PACKAGE_NAME}' {`,
+    workflowBlock,
+    "}",
+    "",
+    "export {};",
+    ""
+  ].join(`
+`);
+}