@starci/hfs 4.11.22 → 4.12.0

package/emit/contracts.mjs

@@ -27,86 +27,82 @@ import { fileURLToPath } from 'node:url';
 import { emitEvents, eventServices, eventsSnapshotPath } from './events.mjs';
 import { openapiPath } from './operations.mjs';
 import { readEnv } from '../runtime/scripts/lib/env.mjs';
-
 /** The stderr prefix of a dependency the worker could not load and stood in for. */
 const STAND_IN = 'stand-in ';
 const WORKER = path.join(path.dirname(fileURLToPath(import.meta.url)), 'schema-worker.mjs');
 const OPERATIONS_WORKER = path.join(path.dirname(fileURLToPath(import.meta.url)), 'operations-worker.mjs');
-
 /** The repository-relative path of an app's root module. */
 export const appModulePath = (app) => `apps/${app}/src/app.module.ts`;
-
 /** The repository-relative path of an app's snapshot. */
 const snapshotPath = (app) => `contracts/${app}/schema.graphql`;
-
 /** The `paths` aliases of a tsconfig as [{ prefix, targets }], `@modules/*` giving prefix `@modules/`. Pure. */
 export function aliasesOf(paths, baseDir) {
-  return Object.entries(paths ?? {})
-    .filter(([pattern]) => pattern.endsWith('/*'))
-    .map(([pattern, targets]) => ({ prefix: pattern.slice(0, -1), targets: targets.map((target) => path.resolve(baseDir, target.replace(/\*$/, ''))) }));
+    return Object.entries(paths ?? {})
+        .filter(([pattern]) => pattern.endsWith('/*'))
+        .map(([pattern, targets]) => ({ prefix: pattern.slice(0, -1), targets: targets.map((target) => path.resolve(baseDir, target.replace(/\*$/, ''))) }));
 }
-
 /** The absolute base a specifier resolves to through the aliases, or null when it is not aliased. Pure. */
 export function aliasTarget(aliases, specifier) {
-  const alias = aliases.find((item) => specifier.startsWith(item.prefix));
-  return alias ? path.join(alias.targets[0], specifier.slice(alias.prefix.length)) : null;
+    const alias = aliases.find((item) => specifier.startsWith(item.prefix));
+    return alias ? path.join(alias.targets[0], specifier.slice(alias.prefix.length)) : null;
 }
-
 /** The api apps of a declaration that can serve GraphQL: kind `api`. Pure. */
 const apiApps = (declaration) => (declaration.apps ?? []).filter((app) => app.kind === 'api').map((app) => app.name);
-
 /** The text written to a snapshot file: the printed schema and one final newline. Pure. */
 export const snapshotText = (printed) => `${printed.replace(/\n+$/, '')}\n`;
-
 /** Runs one worker of one app; answers its stdout, or null when the app has nothing of that kind (exit 3). */
 function runWorker(worker, repoRoot, app) {
-  const result = spawnSync(process.execPath, [worker, repoRoot, app], { encoding: 'utf8', cwd: repoRoot, env: { PATH: readEnv('PATH') ?? '' }, maxBuffer: 256 * 1024 * 1024 });
-  if (result.status === 3) return { text: null, lines: [] };
-  const lines = (result.stderr ?? '').split(/\r?\n/).filter(Boolean);
-  if (result.status !== 0) throw new Error(`starci app emit: ${app} failed (exit ${result.status}): ${(lines.join('\n') || result.stdout).trim()}`);
-  return { text: result.stdout, lines: lines.filter((line) => line.startsWith(STAND_IN)) };
+    const result = spawnSync(process.execPath, [worker, repoRoot, app], { encoding: 'utf8', cwd: repoRoot, env: { PATH: readEnv('PATH') ?? '' }, maxBuffer: 256 * 1024 * 1024 });
+    if (result.status === 3)
+        return { text: null, lines: [] };
+    const lines = (result.stderr ?? '').split(/\r?\n/).filter(Boolean);
+    if (result.status !== 0)
+        throw new Error(`starci app emit: ${app} failed (exit ${result.status}): ${(lines.join('\n') || result.stdout).trim()}`);
+    return { text: result.stdout, lines: lines.filter((line) => line.startsWith(STAND_IN)) };
 }
-
 /** Emits the GraphQL schema and the operations of one app: `{ graphql, openapi, standIns }`, each text or null. */
 function emitApp(repoRoot, app) {
-  const graphql = runWorker(WORKER, repoRoot, app);
-  const operations = runWorker(OPERATIONS_WORKER, repoRoot, app);
-  return { graphql: graphql.text, openapi: operations.text, standIns: [...graphql.lines, ...operations.lines] };
+    const graphql = runWorker(WORKER, repoRoot, app);
+    const operations = runWorker(OPERATIONS_WORKER, repoRoot, app);
+    return { graphql: graphql.text, openapi: operations.text, standIns: [...graphql.lines, ...operations.lines] };
 }
-
 /**
  * Writes the snapshots of every api app: `contracts/<app>/schema.graphql` when it serves GraphQL and `contracts/<app>/openapi.json`
  * when it has an operation table. Answers `{ written: [paths], skipped: [apps], standIns: { app: [lines] } }`, `skipped`
  * being the apps with neither. `declaration` is the parsed hfs.json. `outDir` (absolute) redirects the snapshots to another
  * root, keeping their relative paths.
  */
-export function emitContracts({ repoRoot, declaration, outDir = repoRoot } = {}) {
-  const written = [];
-  const skipped = [];
-  const standIns = {};
-  for (const app of apiApps(declaration)) {
-    const emitted = emitApp(repoRoot, app);
-    if (emitted.graphql === null && emitted.openapi === null) {
-      skipped.push(app);
-      continue;
+export function emitContracts({ repoRoot, declaration, outDir = repoRoot }) {
+    const written = [];
+    const skipped = [];
+    const standIns = {};
+    for (const app of apiApps(declaration)) {
+        const emitted = emitApp(repoRoot, app);
+        if (emitted.graphql === null && emitted.openapi === null) {
+            skipped.push(app);
+            continue;
+        }
+        const snapshots = [[emitted.graphql, snapshotPath(app)], [emitted.openapi, openapiPath(app)]];
+        for (const [text, relative] of snapshots) {
+            if (text === null)
+                continue;
+            const target = path.join(outDir, relative);
+            fs.mkdirSync(path.dirname(target), { recursive: true });
+            fs.writeFileSync(target, snapshotText(text));
+            written.push(relative);
+        }
+        if (emitted.standIns.length)
+            standIns[app] = emitted.standIns;
     }
-    for (const [text, relative] of [[emitted.graphql, snapshotPath(app)], [emitted.openapi, openapiPath(app)]]) {
-      if (text === null) continue;
-      const target = path.join(outDir, relative);
-      fs.mkdirSync(path.dirname(target), { recursive: true });
-      fs.writeFileSync(target, snapshotText(text));
-      written.push(relative);
+    for (const service of eventServices(repoRoot)) {
+        const events = emitEvents({ repoRoot, service });
+        if (events === null)
+            continue;
+        const relative = eventsSnapshotPath(service);
+        const target = path.join(outDir, relative);
+        fs.mkdirSync(path.dirname(target), { recursive: true });
+        fs.writeFileSync(target, events);
+        written.push(relative);
     }
-    if (emitted.standIns.length) standIns[app] = emitted.standIns;
-  }
-  for (const service of eventServices(repoRoot)) {
-    const events = emitEvents({ repoRoot, service });
-    if (events === null) continue;
-    const relative = eventsSnapshotPath(service);
-    const target = path.join(outDir, relative);
-    fs.mkdirSync(path.dirname(target), { recursive: true });
-    fs.writeFileSync(target, events);
-    written.push(relative);
-  }
-  return { written, skipped, standIns };
+    return { written, skipped, standIns };
 }

package/emit/events.d.mts

@@ -0,0 +1,9 @@
+/** The repository-relative path of a service's event contract. */
+export declare const eventsSnapshotPath: (service: string) => string;
+/** The services that declare event classes under `src/modules/events/<service>/`. */
+export declare function eventServices(repoRoot: string): string[];
+/** The text of the event contract of `service`, or null when it declares no event class; a class that cannot be read throws. */
+export declare function emitEvents({ repoRoot, service }: {
+    repoRoot: string;
+    service: string;
+}): string | null;

package/emit/events.mjs

@@ -9,33 +9,32 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { createRequire } from 'node:module';
 import { readEventClasses, snapshotText } from '../runtime/scripts/lib/event-contract.mjs';
-
 const EVENTS_ROOT = 'src/modules/events';
 const EVENT_SUFFIX = '.event.ts';
-
 /** The repository-relative path of a service's event contract. */
 export const eventsSnapshotPath = (service) => `contracts/${service}/events.json`;
-
 /** The services that declare event classes under `src/modules/events/<service>/`. */
 export function eventServices(repoRoot) {
-  const root = path.join(repoRoot, EVENTS_ROOT);
-  if (!fs.existsSync(root)) return [];
-  return fs.readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+    const root = path.join(repoRoot, EVENTS_ROOT);
+    if (!fs.existsSync(root))
+        return [];
+    return fs.readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
 }
-
 /** The text of the event contract of `service`, or null when it declares no event class; a class that cannot be read throws. */
 export function emitEvents({ repoRoot, service }) {
-  const folder = path.join(repoRoot, EVENTS_ROOT, service);
-  const files = fs.existsSync(folder) ? fs.readdirSync(folder).filter((name) => name.endsWith(EVENT_SUFFIX)).sort() : [];
-  if (files.length === 0) return null;
-  const ts = createRequire(path.join(repoRoot, 'package.json'))('typescript');
-  const events = [];
-  const problems = [];
-  for (const name of files) {
-    const read = readEventClasses(ts, fs.readFileSync(path.join(folder, name), 'utf8'), name);
-    events.push(...read.events);
-    problems.push(...read.problems.map((problem) => `${name}: ${problem}`));
-  }
-  if (problems.length > 0) throw new Error(`starci app emit: the event classes of ${service} cannot be read: ${problems.join('; ')}`);
-  return snapshotText(service, events);
+    const folder = path.join(repoRoot, EVENTS_ROOT, service);
+    const files = fs.existsSync(folder) ? fs.readdirSync(folder).filter((name) => name.endsWith(EVENT_SUFFIX)).sort() : [];
+    if (files.length === 0)
+        return null;
+    const ts = createRequire(path.join(repoRoot, 'package.json'))('typescript');
+    const events = [];
+    const problems = [];
+    for (const name of files) {
+        const read = readEventClasses(ts, fs.readFileSync(path.join(folder, name), 'utf8'), name);
+        events.push(...read.events);
+        problems.push(...read.problems.map((problem) => `${name}: ${problem}`));
+    }
+    if (problems.length > 0)
+        throw new Error(`starci app emit: the event classes of ${service} cannot be read: ${problems.join('; ')}`);
+    return snapshotText(service, events);
 }

package/emit/form-bounds.d.mts

@@ -0,0 +1,83 @@
+/** A GraphQL directive argument definition of the schema. */
+export interface DirectiveArgumentLike {
+    readonly name: string;
+    readonly type: unknown;
+    readonly defaultValue?: unknown;
+}
+/** A directive use on a field: its arguments with their literal values. */
+export interface DirectiveNodeLike {
+    readonly name: {
+        readonly value: string;
+    };
+    readonly arguments?: ReadonlyArray<{
+        readonly name: {
+            readonly value: string;
+        };
+        readonly value: {
+            readonly kind: string;
+            readonly value?: unknown;
+        };
+    }>;
+}
+/** A field of an input object type. */
+export interface InputFieldLike {
+    readonly name: string;
+    readonly astNode?: {
+        readonly directives?: readonly DirectiveNodeLike[] | undefined;
+    } | null | undefined;
+}
+/** A named type of the schema; input objects carry `getFields`. */
+export interface SchemaTypeLike {
+    readonly name: string;
+    readonly astNode?: {
+        readonly kind: string;
+    } | null | undefined;
+    readonly getFields?: () => Record<string, InputFieldLike>;
+}
+/** An input object type of the schema. */
+export interface InputTypeLike extends SchemaTypeLike {
+    readonly getFields: () => Record<string, InputFieldLike>;
+}
+/** The part of a GraphQL schema the form bounds read. */
+export interface GraphqlSchemaLike {
+    getTypeMap(): Record<string, SchemaTypeLike>;
+    getDirective(name: string): {
+        readonly args?: readonly DirectiveArgumentLike[];
+    } | null | undefined;
+}
+/** A JSON Schema fragment of an emitted OpenAPI contract. */
+export interface OpenApiSchemaLike {
+    readonly $ref?: string;
+    readonly type?: unknown;
+    readonly properties?: Readonly<Record<string, OpenApiSchemaLike>>;
+    readonly allOf?: readonly OpenApiSchemaLike[];
+    readonly anyOf?: readonly OpenApiSchemaLike[];
+    readonly oneOf?: readonly OpenApiSchemaLike[];
+    readonly prefixItems?: readonly OpenApiSchemaLike[];
+    readonly items?: OpenApiSchemaLike;
+    readonly [keyword: string]: unknown;
+}
+/** An emitted OpenAPI 3.1 contract, as far as the bounds read it. */
+export interface OpenApiContractLike {
+    readonly openapi?: string;
+    readonly components?: {
+        readonly schemas?: Readonly<Record<string, OpenApiSchemaLike>>;
+    };
+    readonly [extension: string]: unknown;
+}
+/** Clears generated GraphQL form limits when the last backend schema snapshot is removed. */
+export declare function emptyInputBoundsSource(): string;
+/**
+ * GraphQL Code Generator plugin: derives typed form limits from the emitted input-field directives.
+ * Generate beside the wire types and import through the API owner. Legacy or unsupported metadata refuses generation;
+ * forms apply all carried limits from their translated zod refinements without importing backend code.
+ */
+export declare function inputBoundsPlugin(schema: GraphqlSchemaLike): string;
+/** Refuses differing bounds on shared input names before Codegen merges multiple service schemas. */
+export declare function assertCompatibleInputBounds(schemas: Readonly<Record<string, GraphqlSchemaLike>>): void;
+/**
+ * Generates REST_INPUT_BOUNDS from emitted OpenAPI contracts, keyed by service, DTO and property.
+ * REST-only forms use the API owner's generated module. Union constraints are conservatively intersected;
+ * unresolved references and malformed limits refuse generation rather than retaining stale client limits.
+ */
+export declare function openApiBoundsSource(contracts: Readonly<Record<string, OpenApiContractLike>>): string;

package/emit/form-bounds.mjs

@@ -1,155 +1,171 @@
 import fs from 'node:fs';
 import { INPUT_BOUND_ARGUMENTS, INPUT_BOUNDS_DIRECTIVE, INPUT_BOUNDS_VERSION, INPUT_BOUNDS_VERSION_ARGUMENT, INPUT_BOUNDS_OPENAPI_EXTENSION, JSON_SCHEMA_BOUND_KEYS } from './input-bounds.mjs';
 import { byCodeUnit } from '../report/order.mjs';
-
+// The schema and the contracts are parsed input from the repository under generation (its own graphql, a contract file read
+// from disk), so they are read through the structural shapes below; this package imports no graphql type, and consumers of the
+// public `@starci/hfs/form-bounds` export need none either.
+/** The scalar each bound argument carries, looked up by an arbitrary name. */
+const BOUND_SCALARS = INPUT_BOUND_ARGUMENTS;
+/** The JSON Schema keyword of a bound whose name differs from it, looked up by an arbitrary name. */
+const JSON_KEYS = JSON_SCHEMA_BOUND_KEYS;
 const READER = `/** One field's backend bounds, including each-item validators. */\ntype InputBoundField = Readonly<Partial<Record<${Object.keys(INPUT_BOUND_ARGUMENTS).map(key => JSON.stringify(key)).join(' | ')}, number | undefined>>>\n\n${fs.readFileSync(new URL('./form-bounds-reader.ts.partial', import.meta.url), 'utf8')}`;
-const graphqlBoundsText = inputs => `/** Backend input bounds, generated from the contract. */\nexport const INPUT_BOUNDS = ${JSON.stringify(inputs, null, 2)} as const\n\n${READER}`;
-
+const graphqlBoundsText = (inputs) => `/** Backend input bounds, generated from the contract. */\nexport const INPUT_BOUNDS = ${JSON.stringify(inputs, null, 2)} as const\n\n${READER}`;
 /** Clears generated GraphQL form limits when the last backend schema snapshot is removed. */
 export function emptyInputBoundsSource() {
-  return graphqlBoundsText({});
+    return graphqlBoundsText({});
 }
-
-const inputTypes = schema => Object.values(schema.getTypeMap()).filter(type => type.astNode?.kind === 'InputObjectTypeDefinition');
-
+const inputTypes = (schema) => Object.values(schema.getTypeMap()).filter((type) => type.astNode?.kind === 'InputObjectTypeDefinition');
 function requireGraphqlBoundsFormat(schema, label = 'GraphQL contract') {
-  if (inputTypes(schema).length === 0) return;
-  const directive = schema.getDirective(INPUT_BOUNDS_DIRECTIVE);
-  const args = new Map((directive?.args ?? []).map(argument => [argument.name, argument]));
-  const version = args.get(INPUT_BOUNDS_VERSION_ARGUMENT);
-  const argumentsMatch = Object.entries(INPUT_BOUND_ARGUMENTS).every(([name, type]) => String(args.get(name)?.type) === type);
-  if (version?.defaultValue !== INPUT_BOUNDS_VERSION || String(version?.type) !== 'Int' ||
-      args.size !== Object.keys(INPUT_BOUND_ARGUMENTS).length + 1 || !argumentsMatch) {
-    throw new Error(`${label}: missing or unsupported input-bounds metadata; run starci app emit with matching HFS/CLI versions`);
-  }
+    if (inputTypes(schema).length === 0)
+        return;
+    const directive = schema.getDirective(INPUT_BOUNDS_DIRECTIVE);
+    const args = new Map((directive?.args ?? []).map((argument) => [argument.name, argument]));
+    const version = args.get(INPUT_BOUNDS_VERSION_ARGUMENT);
+    const argumentsMatch = Object.entries(INPUT_BOUND_ARGUMENTS).every(([name, type]) => String(args.get(name)?.type) === type);
+    if (version?.defaultValue !== INPUT_BOUNDS_VERSION || String(version?.type) !== 'Int' ||
+        args.size !== Object.keys(INPUT_BOUND_ARGUMENTS).length + 1 || !argumentsMatch) {
+        throw new Error(`${label}: missing or unsupported input-bounds metadata; run starci app emit with matching HFS/CLI versions`);
+    }
 }
-
 function fieldBounds(type, field) {
-  const directives = field.astNode?.directives?.filter((item) => item.name.value === INPUT_BOUNDS_DIRECTIVE) ?? [];
-  if (directives.length === 0) return null;
-  const label = `${type.name}.${field.name}`;
-  if (directives.length !== 1) throw new Error(`${label}: duplicate ${INPUT_BOUNDS_DIRECTIVE} directive`);
-  const bounds = {};
-  for (const argument of directives[0].arguments ?? []) {
-    const name = argument.name.value;
-    const scalar = INPUT_BOUND_ARGUMENTS[name];
-    const value = Number(argument.value.value);
-    const numeric = argument.value.kind === 'IntValue' || argument.value.kind === 'FloatValue';
-    if (name === INPUT_BOUNDS_VERSION_ARGUMENT) {
-      if (argument.value.kind !== 'IntValue' || value !== INPUT_BOUNDS_VERSION) throw new Error(`${label}: unsupported input-bounds version`);
-      continue;
-    }
-    if (!Object.hasOwn(INPUT_BOUND_ARGUMENTS, name) || !numeric || !Number.isFinite(value) ||
-        (scalar === 'Int' && (!Number.isSafeInteger(value) || value < 0))) {
-      throw new Error(`${label}: invalid input bound ${name}`);
+    const directives = field.astNode?.directives?.filter((item) => item.name.value === INPUT_BOUNDS_DIRECTIVE) ?? [];
+    if (directives.length === 0)
+        return null;
+    const label = `${type.name}.${field.name}`;
+    if (directives.length !== 1)
+        throw new Error(`${label}: duplicate ${INPUT_BOUNDS_DIRECTIVE} directive`);
+    const bounds = {};
+    for (const argument of directives[0]?.arguments ?? []) {
+        const name = argument.name.value;
+        const scalar = BOUND_SCALARS[name];
+        const value = Number(argument.value.value);
+        const numeric = argument.value.kind === 'IntValue' || argument.value.kind === 'FloatValue';
+        if (name === INPUT_BOUNDS_VERSION_ARGUMENT) {
+            if (argument.value.kind !== 'IntValue' || value !== INPUT_BOUNDS_VERSION)
+                throw new Error(`${label}: unsupported input-bounds version`);
+            continue;
+        }
+        if (!Object.hasOwn(INPUT_BOUND_ARGUMENTS, name) || !numeric || !Number.isFinite(value) ||
+            (scalar === 'Int' && (!Number.isSafeInteger(value) || value < 0))) {
+            throw new Error(`${label}: invalid input bound ${name}`);
+        }
+        if (Object.hasOwn(bounds, name))
+            throw new Error(`${label}: duplicate input bound ${name}`);
+        bounds[name] = value;
     }
-    if (Object.hasOwn(bounds, name)) throw new Error(`${label}: duplicate input bound ${name}`);
-    bounds[name] = value;
-  }
-  if (Object.keys(bounds).length === 0) throw new Error(`${label}: empty ${INPUT_BOUNDS_DIRECTIVE} directive`);
-  return Object.fromEntries(Object.entries(bounds).sort(([a], [b]) => byCodeUnit(a, b)));
+    if (Object.keys(bounds).length === 0)
+        throw new Error(`${label}: empty ${INPUT_BOUNDS_DIRECTIVE} directive`);
+    return Object.fromEntries(Object.entries(bounds).sort(([a], [b]) => byCodeUnit(a, b)));
 }
-
 /**
  * GraphQL Code Generator plugin: derives typed form limits from the emitted input-field directives.
  * Generate beside the wire types and import through the API owner. Legacy or unsupported metadata refuses generation;
  * forms apply all carried limits from their translated zod refinements without importing backend code.
  */
 export function inputBoundsPlugin(schema) {
-  requireGraphqlBoundsFormat(schema);
-  const inputs = {};
-  for (const type of inputTypes(schema).sort((a, b) => byCodeUnit(a.name, b.name))) {
-    const fields = {};
-    for (const field of Object.values(type.getFields()).sort((a, b) => byCodeUnit(a.name, b.name))) {
-      const bounds = fieldBounds(type, field);
-      if (bounds !== null) fields[field.name] = bounds;
+    requireGraphqlBoundsFormat(schema);
+    const inputs = {};
+    for (const type of inputTypes(schema).sort((a, b) => byCodeUnit(a.name, b.name))) {
+        const fields = {};
+        for (const field of Object.values(type.getFields()).sort((a, b) => byCodeUnit(a.name, b.name))) {
+            const bounds = fieldBounds(type, field);
+            if (bounds !== null)
+                fields[field.name] = bounds;
+        }
+        inputs[type.name] = fields;
     }
-    inputs[type.name] = fields;
-  }
-  return graphqlBoundsText(inputs);
+    return graphqlBoundsText(inputs);
 }
-
 /** Refuses differing bounds on shared input names before Codegen merges multiple service schemas. */
 export function assertCompatibleInputBounds(schemas) {
-  const seen = new Map();
-  for (const [service, schema] of Object.entries(schemas)) {
-    requireGraphqlBoundsFormat(schema, service);
-    for (const type of inputTypes(schema)) {
-      for (const field of Object.values(type.getFields())) {
-        const key = `${type.name}.${field.name}`;
-        const bounds = JSON.stringify(fieldBounds(type, field));
-        const prior = seen.get(key);
-        if (prior && prior.bounds !== bounds) throw new Error(`conflicting input bounds for ${key}: ${prior.service} and ${service}`);
-        seen.set(key, { service, bounds });
-      }
+    const seen = new Map();
+    for (const [service, schema] of Object.entries(schemas)) {
+        requireGraphqlBoundsFormat(schema, service);
+        for (const type of inputTypes(schema)) {
+            for (const field of Object.values(type.getFields())) {
+                const key = `${type.name}.${field.name}`;
+                const bounds = JSON.stringify(fieldBounds(type, field));
+                const prior = seen.get(key);
+                if (prior && prior.bounds !== bounds)
+                    throw new Error(`conflicting input bounds for ${key}: ${prior.service} and ${service}`);
+                seen.set(key, { service, bounds });
+            }
+        }
     }
-  }
 }
-
 function mergeBounds(target, source) {
-  for (const [name, value] of Object.entries(source)) {
-    if (!Number.isFinite(value) || (INPUT_BOUND_ARGUMENTS[name] === 'Int' && (!Number.isSafeInteger(value) || value < 0))) {
-      throw new Error(`invalid OpenAPI input bound ${name}`);
+    for (const [name, value] of Object.entries(source)) {
+        if (typeof value !== 'number' || !Number.isFinite(value) || (BOUND_SCALARS[name] === 'Int' && (!Number.isSafeInteger(value) || value < 0))) {
+            throw new Error(`invalid OpenAPI input bound ${name}`);
+        }
+        const previous = target[name];
+        target[name] = previous === undefined ? value : name.toLowerCase().includes('min') ? Math.max(previous, value) : Math.min(previous, value);
     }
-    const previous = target[name];
-    target[name] = previous === undefined ? value : name.toLowerCase().includes('min') ? Math.max(previous, value) : Math.min(previous, value);
-  }
-  return target;
+    return target;
 }
-
 function schemaBounds(schema, components, seen = new Set()) {
-  if (!schema || typeof schema !== 'object') throw new Error('an OpenAPI property needs a schema');
-  if (seen.has(schema)) return {};
-  const next = new Set([...seen, schema]);
-  const bounds = {};
-  if (schema.$ref) {
-    const prefix = '#/components/schemas/';
-    const name = schema.$ref.startsWith(prefix) ? schema.$ref.slice(prefix.length).replaceAll('~1', '/').replaceAll('~0', '~') : null;
-    if (name === null || !Object.hasOwn(components, name)) throw new Error(`unresolved OpenAPI input reference ${schema.$ref}`);
-    mergeBounds(bounds, schemaBounds(components[name], components, next));
-  }
-  for (const key of Object.keys(INPUT_BOUND_ARGUMENTS).filter(name => !name.startsWith('item'))) {
-    const value = schema[JSON_SCHEMA_BOUND_KEYS[key] ?? key];
-    if (value !== undefined) mergeBounds(bounds, { [key]: value });
-  }
-  for (const part of [...(schema.allOf ?? []), ...(schema.anyOf ?? []), ...(schema.oneOf ?? [])]) {
-    mergeBounds(bounds, schemaBounds(part, components, next));
-  }
-  const itemSchemas = [...(schema.prefixItems ?? []), ...(schema.items ? [schema.items] : [])];
-  if (itemSchemas.length) {
-    const items = {};
-    for (const item of itemSchemas) mergeBounds(items, schemaBounds(item, components, next));
-    for (const [name, value] of Object.entries(items)) {
-      const key = `item${name[0].toUpperCase()}${name.slice(1)}`;
-      if (Object.hasOwn(INPUT_BOUND_ARGUMENTS, key)) mergeBounds(bounds, { [key]: value });
+    if (!schema || typeof schema !== 'object')
+        throw new Error('an OpenAPI property needs a schema');
+    if (seen.has(schema))
+        return {};
+    const next = new Set([...seen, schema]);
+    const bounds = {};
+    if (schema.$ref) {
+        const prefix = '#/components/schemas/';
+        const name = schema.$ref.startsWith(prefix) ? schema.$ref.slice(prefix.length).replaceAll('~1', '/').replaceAll('~0', '~') : null;
+        const component = name === null || !Object.hasOwn(components, name) ? undefined : components[name];
+        if (component === undefined)
+            throw new Error(`unresolved OpenAPI input reference ${schema.$ref}`);
+        mergeBounds(bounds, schemaBounds(component, components, next));
+    }
+    for (const key of Object.keys(INPUT_BOUND_ARGUMENTS).filter(name => !name.startsWith('item'))) {
+        const value = schema[JSON_KEYS[key] ?? key];
+        if (value !== undefined)
+            mergeBounds(bounds, { [key]: value });
     }
-  }
-  return Object.fromEntries(Object.entries(bounds).sort(([a], [b]) => byCodeUnit(a, b)));
+    for (const part of [...(schema.allOf ?? []), ...(schema.anyOf ?? []), ...(schema.oneOf ?? [])]) {
+        mergeBounds(bounds, schemaBounds(part, components, next));
+    }
+    const itemSchemas = [...(schema.prefixItems ?? []), ...(schema.items ? [schema.items] : [])];
+    if (itemSchemas.length) {
+        const items = {};
+        for (const item of itemSchemas)
+            mergeBounds(items, schemaBounds(item, components, next));
+        for (const [name, value] of Object.entries(items)) {
+            const key = `item${name.charAt(0).toUpperCase()}${name.slice(1)}`;
+            if (Object.hasOwn(INPUT_BOUND_ARGUMENTS, key))
+                mergeBounds(bounds, { [key]: value });
+        }
+    }
+    return Object.fromEntries(Object.entries(bounds).sort(([a], [b]) => byCodeUnit(a, b)));
 }
-
 /**
  * Generates REST_INPUT_BOUNDS from emitted OpenAPI contracts, keyed by service, DTO and property.
  * REST-only forms use the API owner's generated module. Union constraints are conservatively intersected;
  * unresolved references and malformed limits refuse generation rather than retaining stale client limits.
  */
 export function openApiBoundsSource(contracts) {
-  const services = {};
-  for (const [service, document] of Object.entries(contracts).sort(([a], [b]) => byCodeUnit(a, b))) {
-    if (document.openapi !== '3.1.0' || !document.components?.schemas) throw new Error(`${service}: expected an emitted OpenAPI 3.1 contract`);
-    if (document[INPUT_BOUNDS_OPENAPI_EXTENSION] !== INPUT_BOUNDS_VERSION) {
-      throw new Error(`${service}: missing or unsupported input-bounds metadata; run starci app emit with matching HFS/CLI versions`);
-    }
-    const inputs = {};
-    const components = document.components.schemas;
-    for (const [name, schema] of Object.entries(components).sort(([a], [b]) => byCodeUnit(a, b))) {
-      const fields = {};
-      for (const [property, definition] of Object.entries(schema.properties ?? {}).sort(([a], [b]) => byCodeUnit(a, b))) {
-        const bounds = schemaBounds(definition, components);
-        if (Object.keys(bounds).length) fields[property] = bounds;
-      }
-      if (schema.type === 'object' || schema.properties) inputs[name] = fields;
+    const services = {};
+    for (const [service, document] of Object.entries(contracts).sort(([a], [b]) => byCodeUnit(a, b))) {
+        if (document.openapi !== '3.1.0' || !document.components?.schemas)
+            throw new Error(`${service}: expected an emitted OpenAPI 3.1 contract`);
+        if (document[INPUT_BOUNDS_OPENAPI_EXTENSION] !== INPUT_BOUNDS_VERSION) {
+            throw new Error(`${service}: missing or unsupported input-bounds metadata; run starci app emit with matching HFS/CLI versions`);
+        }
+        const inputs = {};
+        const components = document.components.schemas;
+        for (const [name, schema] of Object.entries(components).sort(([a], [b]) => byCodeUnit(a, b))) {
+            const fields = {};
+            for (const [property, definition] of Object.entries(schema.properties ?? {}).sort(([a], [b]) => byCodeUnit(a, b))) {
+                const bounds = schemaBounds(definition, components);
+                if (Object.keys(bounds).length)
+                    fields[property] = bounds;
+            }
+            if (schema.type === 'object' || schema.properties)
+                inputs[name] = fields;
+        }
+        if (Object.keys(inputs).length)
+            services[service] = inputs;
     }
-    if (Object.keys(inputs).length) services[service] = inputs;
-  }
-  return `/** Backend input bounds, generated from OpenAPI contracts. */\nexport const REST_INPUT_BOUNDS = ${JSON.stringify(services, null, 2)} as const\n\n${READER}`;
+    return `/** Backend input bounds, generated from OpenAPI contracts. */\nexport const REST_INPUT_BOUNDS = ${JSON.stringify(services, null, 2)} as const\n\n${READER}`;
 }