@styx-api/core 0.1.0

package/src/backend/python/typemap.ts

@@ -0,0 +1,131 @@
+import type { AccessPath, BindingId, BoundType } from "../../bindings/index.js";
+
+/**
+ * Map a BoundType to its Python type expression.
+ *
+ * `resolve` is the named-type resolver from `collectNamedTypes` - returns the
+ * declared name for struct/union types so they can be referenced symbolically
+ * rather than inlined.
+ *
+ * Python target: 3.10+ (uses `X | None`, `list[T]`, `int`/`str`/etc.).
+ */
+export function mapType(type: BoundType, resolve: (type: BoundType) => string | undefined): string {
+  switch (type.kind) {
+    case "scalar":
+      return { int: "int", float: "float", str: "str", path: "InputPathType" }[type.scalar];
+    case "bool":
+      return "bool";
+    case "count":
+      return "int";
+    case "literal":
+      return typeof type.value === "string"
+        ? `typing.Literal[${pyStr(type.value)}]`
+        : `typing.Literal[${type.value}]`;
+    case "optional":
+      // The solver has no nullable type: `optional` means "omittable" (the key
+      // may be absent), never "the value may be None". Omittability is expressed
+      // structurally at the field level (`typing.NotRequired[...]`); the value
+      // type itself is just the inner type. So in any value position (nested
+      // list/union arm, validator messages) we render the inner type with no
+      // `| None`.
+      return mapType(type.inner, resolve);
+    case "list":
+      return `list[${mapType(type.item, resolve)}]`;
+    case "struct": {
+      const name = resolve(type);
+      if (name) return name;
+      // Fallback: inline as Mapping[str, object]. Real struct types should always
+      // resolve to a declared TypedDict.
+      return "typing.Mapping[str, object]";
+    }
+    case "union": {
+      const name = resolve(type);
+      if (name) return name;
+      return type.variants.map((v) => mapType(v.type, resolve)).join(" | ");
+    }
+  }
+}
+
+/** Render a JS default value as a Python literal (signatures, `.get(k, default)`). */
+export function renderPyLiteral(value: string | number | boolean): string {
+  if (typeof value === "boolean") return value ? "True" : "False";
+  if (typeof value === "number") return Number.isFinite(value) ? String(value) : "float('nan')";
+  return pyStr(value);
+}
+
+/** Python double-quoted string literal with minimal escaping. */
+export function pyStr(value: string): string {
+  // For any value containing control characters, JSON encoding produces a valid
+  // Python double-quoted literal (with the same `\n`/`\t`/`\uXXXX` escapes).
+  // Otherwise we hand-escape backslashes and double quotes only.
+  for (let i = 0; i < value.length; i++) {
+    if (value.charCodeAt(i) < 0x20) return JSON.stringify(value);
+  }
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+
+/** Options controlling how `renderAccess` renders an access path. */
+export interface RenderAccessOptions {
+  /**
+   * Render the LAST segment - if it is a `field` - as `base.get(key)` instead of
+   * `base[key]`. Used when binding the value of an optional field to a narrowed
+   * local: the params factory omits optional-without-default keys entirely (they
+   * are `typing.NotRequired`), so a bare subscript would raise `KeyError`. `.get()`
+   * yields `None` for an absent key, matching the present-and-None case. (Unlike
+   * JS, where `obj[missing]` is `undefined`, Python subscript on a missing key
+   * raises - so the structurally-mirrored TS walk needs this read in Python.)
+   */
+  finalFieldGet?: boolean;
+  /**
+   * Render the LAST segment - if it is a `field` - as `base.get(key, <default>)`,
+   * supplying a fallback value for an absent key. Used for fields that carry a
+   * Boutiques default and are read unconditionally (e.g. an output-basename like
+   * `maskfile="img_bet"`): the field is `NotRequired`, so a bare subscript would
+   * raise `KeyError`, and a bare `.get()` would yield `None` (wrong - the default
+   * must be substituted). The string is an already-rendered Python literal.
+   * Takes precedence over `finalFieldGet`.
+   */
+  finalFieldDefault?: string;
+  /**
+   * Prefix substitutions: maps a rendered access prefix (e.g. `params["cfg"]`) to
+   * a local variable name. After each segment is appended, if the rendered prefix
+   * so far matches a key, it is replaced by the local. This lets reads of an
+   * optional field (and anything nested under it) resolve to the `.get()`-narrowed
+   * local bound by the enclosing presence guard - one lookup, absent-safe, and
+   * mypy can narrow it (a re-subscript or a fresh `.get()` cannot be narrowed).
+   */
+  subst?: ReadonlyMap<string, string>;
+}
+
+/**
+ * Render a solver-assigned `AccessPath` to a Python expression. Starts from
+ * `params`; each `field` segment subscripts a key, and each `iter` segment
+ * resets the base to the loop variable bound to that repeat binding (resolved
+ * via `lookupLoopVar`). Mirrors the TypeScript `renderAccess`.
+ */
+export function renderAccess(
+  path: AccessPath,
+  lookupLoopVar: (binding: BindingId) => string,
+  options: RenderAccessOptions = {},
+): string {
+  const { finalFieldGet = false, finalFieldDefault, subst } = options;
+  let cur = "params";
+  path.forEach((seg, i) => {
+    if (seg.kind !== "field") {
+      cur = lookupLoopVar(seg.binding);
+    } else {
+      const isLast = i === path.length - 1;
+      if (isLast && finalFieldDefault !== undefined) {
+        cur = `${cur}.get(${pyStr(seg.name)}, ${finalFieldDefault})`;
+      } else if (isLast && finalFieldGet) {
+        cur = `${cur}.get(${pyStr(seg.name)})`;
+      } else {
+        cur = `${cur}[${pyStr(seg.name)}]`;
+      }
+    }
+    // Swap in a narrowed local if this prefix was bound by an enclosing guard.
+    const sub = subst?.get(cur);
+    if (sub !== undefined) cur = sub;
+  });
+  return cur;
+}

package/src/backend/python/types.ts

@@ -0,0 +1,8 @@
+// Re-export shared utilities for convenience. All logic lives in shared
+// backend modules.
+
+export { structKey, unionKey } from "../type-keys.js";
+export type { NamedType } from "../collect-named-types.js";
+export { collectNamedTypes, resolveTypeName } from "../collect-named-types.js";
+export type { FieldInfo } from "../collect-field-info.js";
+export { collectFieldInfo } from "../collect-field-info.js";

package/src/backend/python/validate-emit.ts

@@ -0,0 +1,356 @@
+import type { BoundType } from "../../bindings/index.js";
+import type { Expr } from "../../ir/index.js";
+import type { CodegenContext } from "../../manifest/index.js";
+import type { CodeBuilder } from "../code-builder.js";
+import type { Scope } from "../scope.js";
+import {
+  findAlternativeNode,
+  findRangeNode,
+  findRepeatNode,
+  structFields,
+} from "../validate-walk.js";
+import { structVariants } from "../union-variants.js";
+import { emitDocstring } from "./emit.js";
+import { mapType, pyStr } from "./typemap.js";
+
+/**
+ * Emit a `<tool>_validate(params)` function that walks the solved root
+ * `BoundType` and raises `StyxValidationError` on invalid input. Mirrors the
+ * runtime validation v1 niwrap emits, but as a single inlined function (the v2
+ * backends inline `_cargs`/`_outputs` too, rather than v1's per-struct
+ * dispatch).
+ *
+ * Constraints checked: presence (required fields), `isinstance`, int/float
+ * range, list length, union `@type` membership + per-variant recursion, and
+ * nested struct recursion.
+ */
+
+type Resolve = (t: BoundType) => string | undefined;
+
+interface Emit {
+  ctx: CodegenContext;
+  resolve: Resolve;
+  /** Per-function scope for generated locals (loop vars), reserving `params`. */
+  scope: Scope;
+  cb: CodeBuilder;
+}
+
+export function emitValidate(
+  ctx: CodegenContext,
+  rootType: BoundType,
+  rootNode: Expr,
+  paramsType: string,
+  funcName: string,
+  resolve: Resolve,
+  scope: Scope,
+  cb: CodeBuilder,
+): void {
+  const e: Emit = { ctx, resolve, scope: scope.child(["params"]), cb };
+  // Untyped input: a boundary guard usable on a parsed dict / config blob, not
+  // just an already-typed value (mirrors styx v1's `typing.Any` validator).
+  cb.line(`def ${funcName}(params: typing.Any) -> None:`);
+  cb.indent(() => {
+    emitDocstring(
+      cb,
+      `Validate untrusted parameters. Raises StyxValidationError if \`params\` is not a valid ${paramsType}.`,
+    );
+    emitRoot(e, rootType, rootNode);
+  });
+}
+
+function emitRoot(e: Emit, rootType: BoundType, rootNode: Expr): void {
+  if (rootType.kind === "struct") {
+    e.cb.line("if params is None or not isinstance(params, dict):");
+    e.cb.indent(() => raise(e, wrongObjectTypeMsg("params")));
+    for (const f of structFields(e.ctx, rootType, rootNode)) {
+      emitField(e, f.name, f.type, f.node, f.hasDefault, "params");
+    }
+  } else if (rootType.kind === "union") {
+    emitUnion(e, rootType, rootNode, "params", "params");
+  } else {
+    emitValue(e, rootType, rootNode, "params", "params", expectedType(e, rootType));
+  }
+}
+
+/** Validate one struct field, handling required-presence vs optional gating. */
+function emitField(
+  e: Emit,
+  name: string,
+  fieldType: BoundType,
+  node: Expr | undefined,
+  hasDefault: boolean,
+  base: string,
+): void {
+  // `@type` and other fixed literals have no user-supplied runtime value.
+  if (fieldType.kind === "literal") return;
+
+  const getExpr = `${base}.get(${pyStr(name)}, None)`;
+  const idxExpr = `${base}[${pyStr(name)}]`;
+  const expected = expectedType(e, fieldType);
+  const valueType = fieldType.kind === "optional" ? fieldType.inner : fieldType;
+
+  // Optionals and defaulted fields/flags accept None (None = "use default"), so
+  // gate the body instead of requiring presence.
+  if (fieldType.kind === "optional" || hasDefault) {
+    e.cb.line(`if ${getExpr} is not None:`);
+    e.cb.indent(() => emitValue(e, valueType, node, name, idxExpr, expected));
+  } else {
+    e.cb.line(`if ${getExpr} is None:`);
+    e.cb.indent(() => raise(e, str("`" + name + "` must not be None")));
+    emitValue(e, valueType, node, name, idxExpr, expected);
+  }
+}
+
+/** Validate a known-non-null value at `valueExpr` against `type`. */
+function emitValue(
+  e: Emit,
+  type: BoundType,
+  node: Expr | undefined,
+  wireKey: string,
+  valueExpr: string,
+  expected: string,
+): void {
+  switch (type.kind) {
+    case "optional":
+      emitValue(e, type.inner, node, wireKey, valueExpr, expected);
+      return;
+    case "literal":
+      return;
+    case "scalar":
+      switch (type.scalar) {
+        case "str":
+          checkType(e, valueExpr, "str", wireKey, expected);
+          return;
+        case "int":
+          checkType(e, valueExpr, "int", wireKey, expected);
+          emitRange(e, node, wireKey, valueExpr);
+          return;
+        case "float":
+          checkType(e, valueExpr, "(float, int)", wireKey, expected);
+          emitRange(e, node, wireKey, valueExpr);
+          return;
+        case "path":
+          checkType(e, valueExpr, "(pathlib.Path, str)", wireKey, expected);
+          return;
+      }
+      return;
+    case "bool":
+      checkType(e, valueExpr, "bool", wireKey, expected);
+      return;
+    case "count":
+      checkType(e, valueExpr, "int", wireKey, expected);
+      return;
+    case "list": {
+      checkType(e, valueExpr, "list", wireKey, expected);
+      emitListLength(e, node, wireKey, valueExpr);
+      const itemNode = findRepeatNode(node)?.attrs.node;
+      const elem = e.scope.add("e");
+      e.cb.line(`for ${elem} in ${valueExpr}:`);
+      e.cb.indent(() => emitValue(e, type.item, itemNode, wireKey, elem, expected));
+      return;
+    }
+    case "struct": {
+      e.cb.line(`if not isinstance(${valueExpr}, dict):`);
+      e.cb.indent(() => raise(e, wrongObjectTypeMsg(valueExpr)));
+      for (const f of structFields(e.ctx, type, node)) {
+        emitField(e, f.name, f.type, f.node, f.hasDefault, valueExpr);
+      }
+      return;
+    }
+    case "union":
+      emitUnion(e, type, node, wireKey, valueExpr);
+      return;
+  }
+}
+
+function emitUnion(
+  e: Emit,
+  unionType: Extract<BoundType, { kind: "union" }>,
+  node: Expr | undefined,
+  wireKey: string,
+  valueExpr: string,
+): void {
+  const litVariants = unionType.variants.filter((v) => v.type.kind === "literal");
+  const hasStruct = unionType.variants.some((v) => v.type.kind === "struct");
+
+  // Pure enum/choice: no struct variants, just literal values (no `@type`).
+  if (!hasStruct) {
+    const values = litVariants.map(
+      (v) => (v.type as Extract<BoundType, { kind: "literal" }>).value,
+    );
+    const allStr = values.every((x) => typeof x === "string");
+    checkType(e, valueExpr, allStr ? "str" : "(float, int)", wireKey, expectedType(e, unionType));
+    emitLiteralMembership(e, values, wireKey, valueExpr);
+    return;
+  }
+
+  const altNode = findAlternativeNode(node);
+  // Struct variants with their indices; throws if two share an `@type` (a
+  // duplicate-tagged variant is unreachable and a mypy `comparison-overlap` -
+  // frontends must dodge duplicate tags before codegen). The index keeps each
+  // arm aligned with the IR `alts`.
+  const structVars = structVariants(unionType);
+  const emitStructArm = (): void => {
+    // `valueExpr` is known to be a dict here.
+    e.cb.line(`if "@type" not in ${valueExpr}:`);
+    e.cb.indent(() => raise(e, str("Params object is missing `@type`")));
+    const names = structVars
+      .map(({ variant }) => variant.name)
+      .filter((n): n is string => n !== undefined)
+      .map((n) => pyStr(n))
+      .join(", ");
+    e.cb.line(`if ${valueExpr}["@type"] not in [${names}]:`);
+    e.cb.indent(() =>
+      raise(e, str("Parameter `" + wireKey + "`s `@type` must be one of [" + names + "]")),
+    );
+    structVars.forEach(({ variant, i }, k) => {
+      const vt = variant.type as Extract<BoundType, { kind: "struct" }>;
+      const keyword = k === 0 ? "if" : "elif";
+      e.cb.line(`${keyword} ${valueExpr}["@type"] == ${pyStr(variant.name ?? "")}:`);
+      e.cb.indent(() => {
+        const fields = structFields(e.ctx, vt, altNode?.attrs.alts[i]).filter(
+          (f) => f.type.kind !== "literal",
+        );
+        if (fields.length === 0) {
+          e.cb.line("pass");
+        } else {
+          for (const f of fields) emitField(e, f.name, f.type, f.node, f.hasDefault, valueExpr);
+        }
+      });
+    });
+  };
+
+  // Pure discriminated union: every variant is a struct with an `@type`.
+  if (litVariants.length === 0) {
+    e.cb.line(`if not isinstance(${valueExpr}, dict):`);
+    e.cb.indent(() => raise(e, wrongObjectTypeMsg(valueExpr)));
+    emitStructArm();
+    return;
+  }
+
+  // Mixed union: a value is either a struct (dict with `@type`) or a bare
+  // literal. Branch on the runtime shape.
+  e.cb.line(`if isinstance(${valueExpr}, dict):`);
+  e.cb.indent(emitStructArm);
+  e.cb.line("else:");
+  e.cb.indent(() => {
+    const values = litVariants.map(
+      (v) => (v.type as Extract<BoundType, { kind: "literal" }>).value,
+    );
+    emitLiteralMembership(e, values, wireKey, valueExpr);
+  });
+}
+
+/** Emit a `not in [...]` membership check over literal values. */
+function emitLiteralMembership(
+  e: Emit,
+  values: (string | number)[],
+  wireKey: string,
+  valueExpr: string,
+): void {
+  const rendered = values.map((x) => (typeof x === "string" ? pyStr(x) : pyNum(x))).join(", ");
+  e.cb.line(`if ${valueExpr} not in [${rendered}]:`);
+  e.cb.indent(() => raise(e, str("Parameter `" + wireKey + "` must be one of [" + rendered + "]")));
+}
+
+function checkType(
+  e: Emit,
+  valueExpr: string,
+  pyType: string,
+  wireKey: string,
+  expected: string,
+): void {
+  e.cb.line(`if not isinstance(${valueExpr}, ${pyType}):`);
+  e.cb.indent(() => raise(e, wrongTypeMsg(wireKey, valueExpr, expected)));
+}
+
+function emitRange(e: Emit, node: Expr | undefined, wireKey: string, valueExpr: string): void {
+  const term = findRangeNode(node);
+  if (!term) return;
+  const { minValue, maxValue } = term.attrs;
+  if (minValue !== undefined && maxValue !== undefined) {
+    e.cb.line(`if not (${pyNum(minValue)} <= ${valueExpr} <= ${pyNum(maxValue)}):`);
+    e.cb.indent(() =>
+      raise(
+        e,
+        str(`Parameter \`${wireKey}\` must be between ${minValue} and ${maxValue} (inclusive)`),
+      ),
+    );
+  } else if (minValue !== undefined) {
+    e.cb.line(`if ${valueExpr} < ${pyNum(minValue)}:`);
+    e.cb.indent(() => raise(e, str(`Parameter \`${wireKey}\` must be at least ${minValue}`)));
+  } else if (maxValue !== undefined) {
+    e.cb.line(`if ${valueExpr} > ${pyNum(maxValue)}:`);
+    e.cb.indent(() => raise(e, str(`Parameter \`${wireKey}\` must be at most ${maxValue}`)));
+  }
+}
+
+function emitListLength(e: Emit, node: Expr | undefined, wireKey: string, valueExpr: string): void {
+  const rep = findRepeatNode(node);
+  if (!rep) return;
+  const { countMin, countMax } = rep.attrs;
+  if (countMin !== undefined && countMax !== undefined) {
+    e.cb.line(`if not (${countMin} <= len(${valueExpr}) <= ${countMax}):`);
+    e.cb.indent(() =>
+      raise(
+        e,
+        str(
+          `Parameter \`${wireKey}\` must contain between ${countMin} and ${countMax} elements (inclusive)`,
+        ),
+      ),
+    );
+  } else if (countMin !== undefined) {
+    e.cb.line(`if len(${valueExpr}) < ${countMin}:`);
+    e.cb.indent(() =>
+      raise(
+        e,
+        str(
+          `Parameter \`${wireKey}\` must contain at least ${countMin} ${plural("element", countMin)}`,
+        ),
+      ),
+    );
+  } else if (countMax !== undefined) {
+    e.cb.line(`if len(${valueExpr}) > ${countMax}:`);
+    e.cb.indent(() =>
+      raise(
+        e,
+        str(
+          `Parameter \`${wireKey}\` must contain at most ${countMax} ${plural("element", countMax)}`,
+        ),
+      ),
+    );
+  }
+}
+
+// -- Message + literal rendering --
+
+function raise(e: Emit, messageExpr: string): void {
+  e.cb.line(`raise StyxValidationError(${messageExpr})`);
+}
+
+/** A plain double-quoted Python string message. */
+function str(text: string): string {
+  return pyStr(text);
+}
+
+/** A single-quoted f-string "wrong type" message referencing the runtime type. */
+function wrongTypeMsg(wireKey: string, valueExpr: string, expected: string): string {
+  return `f'\`${wireKey}\` has the wrong type: Received \`{type(${valueExpr})}\` expected \`${expected}\`'`;
+}
+
+/** The generic "Params object has the wrong type" f-string message. */
+function wrongObjectTypeMsg(valueExpr: string): string {
+  return `f'Params object has the wrong type \\'{type(${valueExpr})}\\''`;
+}
+
+function expectedType(e: Emit, type: BoundType): string {
+  return mapType(type, e.resolve);
+}
+
+function pyNum(n: number): string {
+  return Number.isFinite(n) ? String(n) : "float('nan')";
+}
+
+function plural(word: string, count: number): string {
+  return count === 1 ? word : `${word}s`;
+}

package/src/backend/resolve-field-binding.ts

@@ -0,0 +1,41 @@
+import type { Binding, BoundType } from "../bindings/index.js";
+import type { Expr } from "../ir/index.js";
+import type { CodegenContext } from "../manifest/index.js";
+
+/**
+ * Resolve a struct child node to its field binding, handling collapsed sequences.
+ *
+ * When the solver's simplify pass collapses `seq(lit("--flag"), terminal)` into
+ * just the terminal, the binding ends up on the inner node while metadata (doc,
+ * defaultValue) may remain on the outermost wrapper. This function recursively
+ * descends through collapsed sequences to find the binding, tracking the outermost
+ * node for metadata recovery.
+ *
+ * Uses type identity (`===`) to verify the binding matches the struct's field type,
+ * preventing cross-nesting name collisions where an inner struct has a field with
+ * the same name as the outer struct.
+ */
+export function resolveFieldBinding(
+  node: Expr,
+  ctx: CodegenContext,
+  structType: Extract<BoundType, { kind: "struct" }>,
+  outermost?: Expr,
+): { binding: Binding; wrapperNode: Expr } | undefined {
+  const wrapper = outermost ?? node;
+  const binding = ctx.resolve(node);
+  if (
+    binding &&
+    binding.name in structType.fields &&
+    binding.type === structType.fields[binding.name]
+  ) {
+    return { binding, wrapperNode: wrapper };
+  }
+  // Recurse into collapsed sequences to find the binding deeper
+  if (node.kind === "sequence") {
+    for (const inner of node.attrs.nodes) {
+      const result = resolveFieldBinding(inner, ctx, structType, wrapper);
+      if (result) return result;
+    }
+  }
+  return undefined;
+}

package/src/backend/resolve-output-tokens.ts

@@ -0,0 +1,80 @@
+import type {
+  BindingRegistry,
+  GateAtom,
+  OutputScope,
+  ResolvedOutput,
+  ResolvedToken,
+} from "../bindings/index.js";
+import { outputGate } from "../bindings/index.js";
+
+// Re-export the core helper so backends have a single entry point.
+export { outputGate };
+
+/**
+ * Compact consecutive literal tokens. Backends that emit string concatenation
+ * benefit from a shorter token stream; backends that template each token
+ * individually can ignore this and use `output.tokens` directly.
+ */
+export function compactTokens(tokens: ResolvedToken[]): ResolvedToken[] {
+  const out: ResolvedToken[] = [];
+  for (const tok of tokens) {
+    const last = out[out.length - 1];
+    if (tok.kind === "literal" && last && last.kind === "literal") {
+      out[out.length - 1] = { kind: "literal", value: last.value + tok.value };
+    } else {
+      out.push(tok);
+    }
+  }
+  return out;
+}
+
+/**
+ * One output ready for codegen. `gate` is the wrapper sequence (outermost
+ * first); the backend renders each atom as the appropriate scope-introducing
+ * statement, then emits the path expression inside the innermost layer.
+ */
+export interface OutputEmitPlan {
+  name: string;
+  gate: GateAtom[];
+  tokens: ResolvedToken[];
+  resolved: ResolvedOutput;
+}
+
+export function planOutput(
+  scopeGate: GateAtom[],
+  output: ResolvedOutput,
+  bindings: BindingRegistry,
+): OutputEmitPlan {
+  return {
+    name: output.name,
+    gate: outputGate(scopeGate, output, bindings),
+    tokens: compactTokens(output.tokens),
+    resolved: output,
+  };
+}
+
+/**
+ * Does the output have any conditional wrapper? Equivalent to "is at least one
+ * atom a `present` or `variant`?". `iter` alone means the output emits a list
+ * and is not conditionally absent.
+ */
+export function isGated(plan: OutputEmitPlan): boolean {
+  return plan.gate.some((a) => a.kind === "present" || a.kind === "variant");
+}
+
+/** Does the output iterate (emit zero-or-more values)? */
+export function isIterated(plan: OutputEmitPlan): boolean {
+  return plan.gate.some((a) => a.kind === "iter");
+}
+
+/**
+ * Convenience for backends emitting all outputs of a scope at once. The caller
+ * provides the scope's gate (typically `bindings.get(scope.scope)?.gate ?? []`).
+ */
+export function planScope(
+  scope: OutputScope,
+  scopeGate: GateAtom[],
+  bindings: BindingRegistry,
+): OutputEmitPlan[] {
+  return scope.outputs.map((output) => planOutput(scopeGate, output, bindings));
+}

package/src/backend/schema/index.ts

@@ -0,0 +1,2 @@
+export type { JsonSchema } from "./jsonschema.js";
+export { generateOutputsSchema, generateSchema, JsonSchemaBackend } from "./jsonschema.js";