@toolproof-core/genesis 1.0.50 → 1.0.52

package/src/utils/schemaRefNormalization.ts

@@ -1,83 +1,83 @@
-export function stripAnchors<T>(schema: T): T {
-    const seen = new WeakMap<object, unknown>();
-
-    function walk(node: unknown): unknown {
-        if (!node || typeof node !== 'object') return node;
-
-        const existing = seen.get(node as object);
-        if (existing) return existing;
-
-        if (Array.isArray(node)) {
-            const out: unknown[] = [];
-            seen.set(node, out);
-            for (const item of node) out.push(walk(item));
-            return out;
-        }
-
-        const out: Record<string, unknown> = {};
-        seen.set(node as object, out);
-
-        for (const [key, value] of Object.entries(node as Record<string, unknown>)) {
-            if (key === '$anchor') continue;
-            out[key] = walk(value);
-        }
-
-        return out;
-    }
-
-    return walk(schema) as T;
-}
-
-export function normalizeAnchorsToPointers<T>(input: T): T {
-    if (!input || typeof input !== 'object') return input;
-
-    const root = JSON.parse(JSON.stringify(input)) as { $defs?: Record<string, unknown> };
-    const defs: Record<string, unknown> = root.$defs && typeof root.$defs === 'object' ? root.$defs : {};
-    const anchorToDef: Record<string, string> = {};
-
-    for (const [defName, defValue] of Object.entries(defs)) {
-        if (!anchorToDef[defName]) {
-            anchorToDef[defName] = defName;
-        }
-
-        if (!defValue || typeof defValue !== 'object') continue;
-
-        const envelope = defValue as { projectionSchema?: { $anchor?: unknown }; $anchor?: unknown };
-        const projectionSchema = envelope.projectionSchema;
-        if (projectionSchema && typeof projectionSchema === 'object') {
-            const anchor = projectionSchema.$anchor;
-            if (typeof anchor === 'string' && !anchorToDef[anchor]) {
-                anchorToDef[anchor] = defName;
-            }
-        } else {
-            const anchor = envelope.$anchor;
-            if (typeof anchor === 'string' && !anchorToDef[anchor]) {
-                anchorToDef[anchor] = defName;
-            }
-        }
-    }
-
-    function walk(node: unknown): void {
-        if (Array.isArray(node)) {
-            for (const item of node) walk(item);
-            return;
-        }
-        if (!node || typeof node !== 'object') return;
-
-        const obj = node as { $ref?: unknown } & Record<string, unknown>;
-        if (typeof obj.$ref === 'string' && obj.$ref.startsWith('#') && !obj.$ref.startsWith('#/')) {
-            const anchor = obj.$ref.slice(1);
-            const defName = anchorToDef[anchor];
-            if (defName) {
-                obj.$ref = `#/$defs/${defName}`;
-            }
-        }
-
-        for (const value of Object.values(obj)) {
-            walk(value);
-        }
-    }
-
-    walk(root);
-    return root as T;
+export function stripAnchors<T>(schema: T): T {
+    const seen = new WeakMap<object, unknown>();
+
+    function walk(node: unknown): unknown {
+        if (!node || typeof node !== 'object') return node;
+
+        const existing = seen.get(node as object);
+        if (existing) return existing;
+
+        if (Array.isArray(node)) {
+            const out: unknown[] = [];
+            seen.set(node, out);
+            for (const item of node) out.push(walk(item));
+            return out;
+        }
+
+        const out: Record<string, unknown> = {};
+        seen.set(node as object, out);
+
+        for (const [key, value] of Object.entries(node as Record<string, unknown>)) {
+            if (key === '$anchor') continue;
+            out[key] = walk(value);
+        }
+
+        return out;
+    }
+
+    return walk(schema) as T;
+}
+
+export function normalizeAnchorsToPointers<T>(input: T): T {
+    if (!input || typeof input !== 'object') return input;
+
+    const root = JSON.parse(JSON.stringify(input)) as { $defs?: Record<string, unknown> };
+    const defs: Record<string, unknown> = root.$defs && typeof root.$defs === 'object' ? root.$defs : {};
+    const anchorToDef: Record<string, string> = {};
+
+    for (const [defName, defValue] of Object.entries(defs)) {
+        if (!anchorToDef[defName]) {
+            anchorToDef[defName] = defName;
+        }
+
+        if (!defValue || typeof defValue !== 'object') continue;
+
+        const envelope = defValue as { projectionSchema?: { $anchor?: unknown }; $anchor?: unknown };
+        const projectionSchema = envelope.projectionSchema;
+        if (projectionSchema && typeof projectionSchema === 'object') {
+            const anchor = projectionSchema.$anchor;
+            if (typeof anchor === 'string' && !anchorToDef[anchor]) {
+                anchorToDef[anchor] = defName;
+            }
+        } else {
+            const anchor = envelope.$anchor;
+            if (typeof anchor === 'string' && !anchorToDef[anchor]) {
+                anchorToDef[anchor] = defName;
+            }
+        }
+    }
+
+    function walk(node: unknown): void {
+        if (Array.isArray(node)) {
+            for (const item of node) walk(item);
+            return;
+        }
+        if (!node || typeof node !== 'object') return;
+
+        const obj = node as { $ref?: unknown } & Record<string, unknown>;
+        if (typeof obj.$ref === 'string' && obj.$ref.startsWith('#') && !obj.$ref.startsWith('#/')) {
+            const anchor = obj.$ref.slice(1);
+            const defName = anchorToDef[anchor];
+            if (defName) {
+                obj.$ref = `#/$defs/${defName}`;
+            }
+        }
+
+        for (const value of Object.values(obj)) {
+            walk(value);
+        }
+    }
+
+    walk(root);
+    return root as T;
 }

package/src/utils/schemaShims.ts

@@ -1,17 +1,17 @@
-import * as path from 'node:path';
-
-export function generateShimContent(jsonFile: string, variableName: string): string {
-    return `import ${variableName} from './${jsonFile}' with { type: 'json' };\nexport default ${variableName};\n`;
-}
-
-export function getShimsForFiles(jsonFiles: string[], variableName: string): Record<string, string> {
-    const shims: Record<string, string> = {};
-
-    for (const jsonFile of jsonFiles) {
-        const baseName = path.basename(jsonFile, '.json');
-        const tsFile = `${baseName}.ts`;
-        shims[tsFile] = generateShimContent(jsonFile, variableName);
-    }
-
-    return shims;
+import * as path from 'node:path';
+
+export function generateShimContent(jsonFile: string, variableName: string): string {
+    return `import ${variableName} from './${jsonFile}' with { type: 'json' };\nexport default ${variableName};\n`;
+}
+
+export function getShimsForFiles(jsonFiles: string[], variableName: string): Record<string, string> {
+    const shims: Record<string, string> = {};
+
+    for (const jsonFile of jsonFiles) {
+        const baseName = path.basename(jsonFile, '.json');
+        const tsFile = `${baseName}.ts`;
+        shims[tsFile] = generateShimContent(jsonFile, variableName);
+    }
+
+    return shims;
 }

package/src/utils/standaloneSchemas.ts

@@ -1,114 +1,114 @@
-export function isObject(value: unknown): value is Record<string, unknown> {
-    return value !== null && typeof value === 'object' && !Array.isArray(value);
-}
-
-export function deepClone<T>(value: T): T {
-    if (Array.isArray(value)) return value.map((item) => deepClone(item)) as T;
-    if (isObject(value)) {
-        const out: Record<string, unknown> = {};
-        for (const key of Object.keys(value)) out[key] = deepClone(value[key]);
-        return out as T;
-    }
-    return value;
-}
-
-export function extractPointerDefName(ref: string): string | null {
-    if (!ref || !ref.startsWith('#/')) return null;
-    const parts = ref.slice(2).split('/');
-    if (parts.length !== 2) return null;
-    if (parts[0] !== '$defs') return null;
-    const defName = parts[1];
-    if (defName === undefined) return null;
-    return defName.replace(/~1/g, '/').replace(/~0/g, '~');
-}
-
-export function collectLocalDefClosure(node: unknown, rootDefs: Record<string, unknown>): Set<string> {
-    const needed = new Set<string>();
-    const queue: string[] = [];
-
-    function visit(value: unknown) {
-        if (Array.isArray(value)) {
-            for (const item of value) visit(item);
-            return;
-        }
-        if (!isObject(value)) return;
-
-        if (typeof value.$ref === 'string') {
-            const name = extractPointerDefName(value.$ref);
-            if (name && !needed.has(name)) {
-                needed.add(name);
-                queue.push(name);
-            }
-        }
-
-        for (const nested of Object.values(value)) visit(nested);
-    }
-
-    visit(node);
-
-    while (queue.length > 0) {
-        const name = queue.shift();
-        if (!name) continue;
-        const def = rootDefs[name];
-        if (def === undefined) continue;
-        visit(def);
-    }
-
-    return needed;
-}
-
-export function extractStandaloneSchema(
-    schemasDocument: { $defs?: Record<string, unknown> },
-    name: string,
-): { schema: unknown; warnings: string[] } {
-    const rootDefs = schemasDocument.$defs;
-    if (!rootDefs || typeof rootDefs !== 'object') {
-        throw new Error('No $defs object found in schema document');
-    }
-
-    const target = rootDefs[name];
-    if (target === undefined) {
-        throw new Error(`Subschema named '${name}' not found under $defs in schema document`);
-    }
-
-    const needed = collectLocalDefClosure(target, rootDefs);
-    const targetClone = deepClone(target);
-    const defsOut: Record<string, unknown> = {};
-    const warnings: string[] = [];
-
-    for (const defName of needed) {
-        if (defName === name) continue;
-        const defSchema = rootDefs[defName];
-        if (defSchema === undefined) {
-            warnings.push(`Warning: referenced def '${defName}' missing in root $defs (skipped).`);
-            continue;
-        }
-        defsOut[defName] = deepClone(defSchema);
-    }
-
-    const existingInner = isObject(targetClone) && isObject(targetClone.$defs)
-        ? targetClone.$defs
-        : {};
-
-    if (isObject(targetClone)) {
-        targetClone.$defs = { ...existingInner, ...defsOut };
-    }
-
-    return { schema: targetClone, warnings };
-}
-
-export function generateStandaloneSchemas(
-    schemasDocument: { $defs?: Record<string, unknown> },
-    names: string[],
-): { standaloneSchemas: Record<string, unknown>; warnings: string[] } {
-    const standaloneSchemas: Record<string, unknown> = {};
-    const warnings: string[] = [];
-
-    for (const name of names) {
-        const result = extractStandaloneSchema(schemasDocument, name);
-        standaloneSchemas[name] = result.schema;
-        warnings.push(...result.warnings);
-    }
-
-    return { standaloneSchemas, warnings };
+export function isObject(value: unknown): value is Record<string, unknown> {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+export function deepClone<T>(value: T): T {
+    if (Array.isArray(value)) return value.map((item) => deepClone(item)) as T;
+    if (isObject(value)) {
+        const out: Record<string, unknown> = {};
+        for (const key of Object.keys(value)) out[key] = deepClone(value[key]);
+        return out as T;
+    }
+    return value;
+}
+
+export function extractPointerDefName(ref: string): string | null {
+    if (!ref || !ref.startsWith('#/')) return null;
+    const parts = ref.slice(2).split('/');
+    if (parts.length !== 2) return null;
+    if (parts[0] !== '$defs') return null;
+    const defName = parts[1];
+    if (defName === undefined) return null;
+    return defName.replace(/~1/g, '/').replace(/~0/g, '~');
+}
+
+export function collectLocalDefClosure(node: unknown, rootDefs: Record<string, unknown>): Set<string> {
+    const needed = new Set<string>();
+    const queue: string[] = [];
+
+    function visit(value: unknown) {
+        if (Array.isArray(value)) {
+            for (const item of value) visit(item);
+            return;
+        }
+        if (!isObject(value)) return;
+
+        if (typeof value.$ref === 'string') {
+            const name = extractPointerDefName(value.$ref);
+            if (name && !needed.has(name)) {
+                needed.add(name);
+                queue.push(name);
+            }
+        }
+
+        for (const nested of Object.values(value)) visit(nested);
+    }
+
+    visit(node);
+
+    while (queue.length > 0) {
+        const name = queue.shift();
+        if (!name) continue;
+        const def = rootDefs[name];
+        if (def === undefined) continue;
+        visit(def);
+    }
+
+    return needed;
+}
+
+export function extractStandaloneSchema(
+    schemasDocument: { $defs?: Record<string, unknown> },
+    name: string,
+): { schema: unknown; warnings: string[] } {
+    const rootDefs = schemasDocument.$defs;
+    if (!rootDefs || typeof rootDefs !== 'object') {
+        throw new Error('No $defs object found in schema document');
+    }
+
+    const target = rootDefs[name];
+    if (target === undefined) {
+        throw new Error(`Subschema named '${name}' not found under $defs in schema document`);
+    }
+
+    const needed = collectLocalDefClosure(target, rootDefs);
+    const targetClone = deepClone(target);
+    const defsOut: Record<string, unknown> = {};
+    const warnings: string[] = [];
+
+    for (const defName of needed) {
+        if (defName === name) continue;
+        const defSchema = rootDefs[defName];
+        if (defSchema === undefined) {
+            warnings.push(`Warning: referenced def '${defName}' missing in root $defs (skipped).`);
+            continue;
+        }
+        defsOut[defName] = deepClone(defSchema);
+    }
+
+    const existingInner = isObject(targetClone) && isObject(targetClone.$defs)
+        ? targetClone.$defs
+        : {};
+
+    if (isObject(targetClone)) {
+        targetClone.$defs = { ...existingInner, ...defsOut };
+    }
+
+    return { schema: targetClone, warnings };
+}
+
+export function generateStandaloneSchemas(
+    schemasDocument: { $defs?: Record<string, unknown> },
+    names: string[],
+): { standaloneSchemas: Record<string, unknown>; warnings: string[] } {
+    const standaloneSchemas: Record<string, unknown> = {};
+    const warnings: string[] = [];
+
+    for (const name of names) {
+        const result = extractStandaloneSchema(schemasDocument, name);
+        standaloneSchemas[name] = result.schema;
+        warnings.push(...result.warnings);
+    }
+
+    return { standaloneSchemas, warnings };
 }

package/src/utils/standaloneTypes.ts

@@ -1,28 +1,28 @@
-export function generateStandaloneTypeContent(name: string): string {
-    const header = '// Auto-generated strict composite type. Do not edit.\n';
-    const standaloneResourceTypeName = `${name}Resource`;
-
-    const ts =
-        `import type { ResourcePointer, ${name} as ProjectionSchema } from "../types.js";\n` +
-        `export type ${standaloneResourceTypeName} = ResourcePointer & { projection: ProjectionSchema };\n`;
-    return header + ts;
-}
-
-export function validateStandaloneSchemaForWarnings(schema: any): string[] {
-    const warnings: string[] = [];
-    if (schema?.$schema && schema.$schema !== 'https://json-schema.org/draft/2020-12/schema') {
-        warnings.push(
-            `Warning: schema $schema is '${String(schema.$schema)}', expected draft 2020-12. Proceeding anyway.`,
-        );
-    }
-    return warnings;
-}
-
-export function generateStandaloneTypeArtifacts(name: string): { dtsFileName: string; jsFileName: string; dtsContent: string; jsContent: string } {
-    return {
-        dtsFileName: `${name}Resource.d.ts`,
-        jsFileName: `${name}Resource.js`,
-        dtsContent: generateStandaloneTypeContent(name),
-        jsContent: 'export {}\n',
-    };
+export function generateStandaloneTypeContent(name: string): string {
+    const header = '// Auto-generated strict composite type. Do not edit.\n';
+    const standaloneResourceTypeName = `${name}Resource`;
+
+    const ts =
+        `import type { ResourcePointer, ${name} as ProjectionSchema } from "../types.js";\n` +
+        `export type ${standaloneResourceTypeName} = ResourcePointer & { projection: ProjectionSchema };\n`;
+    return header + ts;
+}
+
+export function validateStandaloneSchemaForWarnings(schema: any): string[] {
+    const warnings: string[] = [];
+    if (schema?.$schema && schema.$schema !== 'https://json-schema.org/draft/2020-12/schema') {
+        warnings.push(
+            `Warning: schema $schema is '${String(schema.$schema)}', expected draft 2020-12. Proceeding anyway.`,
+        );
+    }
+    return warnings;
+}
+
+export function generateStandaloneTypeArtifacts(name: string): { dtsFileName: string; jsFileName: string; dtsContent: string; jsContent: string } {
+    return {
+        dtsFileName: `${name}Resource.d.ts`,
+        jsFileName: `${name}Resource.js`,
+        dtsContent: generateStandaloneTypeContent(name),
+        jsContent: 'export {}\n',
+    };
 }

package/src/utils/standaloneZodSchemas.ts

@@ -1,72 +1,72 @@
-import { jsonSchemaToZodExpressions, type JsonSchemaToZodWarning } from './zodCodegen.js';
-
-export type GeneratedZodModule = {
-    fileName: string;
-    content: string;
-    warnings: JsonSchemaToZodWarning[];
-};
-
-function isValidIdentifier(name: string): boolean {
-    return /^[A-Za-z_][A-Za-z0-9_]*$/.test(name);
-}
-
-function toIdentifier(name: string): string {
-    let out = name.replace(/[^A-Za-z0-9_]/g, '_');
-    if (!/^[A-Za-z_]/.test(out)) out = `_${out}`;
-    return out;
-}
-
-function emitHeader(name: string): string {
-    return (
-        `// Auto-generated from standalone schema '${name}'. Do not edit.\n` +
-        `import { z } from 'zod/v4';\n\n`
-    );
-}
-
-function emitModule(name: string, expressionsByName: Record<string, string>, warnings: JsonSchemaToZodWarning[]): string {
-    const lines: string[] = [];
-    lines.push(emitHeader(name));
-
-    if (warnings.length > 0) {
-        const warningsName = `${toIdentifier(name)}ZodGenerationWarnings`;
-        lines.push(`export const ${warningsName} = ${JSON.stringify(warnings, null, 2)} as const;\n`);
-    }
-
-    const rootIdent = toIdentifier(name);
-    const defNames = Object.keys(expressionsByName)
-        .filter((schemaName) => schemaName !== name)
-        .sort((a, b) => a.localeCompare(b));
-
-    for (const schemaName of defNames) {
-        const ident = toIdentifier(schemaName);
-        if (!isValidIdentifier(ident)) {
-            throw new Error(`Invalid generated identifier for schema '${schemaName}': '${ident}'`);
-        }
-        const expr = expressionsByName[schemaName];
-        lines.push(`const ${ident}Schema: z.ZodTypeAny = z.lazy(() => ${expr});`);
-    }
-
-    lines.push('');
-
-    const rootExpr = expressionsByName[name];
-    lines.push(`export const ${rootIdent}Schema: z.ZodTypeAny = z.lazy(() => ${rootExpr});`);
-
-    return lines.join('\n') + '\n';
-}
-
-export function generateStandaloneZodModule(name: string, standaloneSchema: unknown): GeneratedZodModule {
-    const { expressionsByName, warnings } = jsonSchemaToZodExpressions(standaloneSchema, name);
-    return {
-        fileName: `${name}.ts`,
-        content: emitModule(name, expressionsByName, warnings),
-        warnings,
-    };
-}
-
-export function generateStandaloneZodBarrel(names: string[]): string {
-    const exports = names
-        .slice()
-        .sort((a, b) => a.localeCompare(b))
-        .map((name) => `export { ${toIdentifier(name)}Schema } from './${name}.js';`);
-    return `// Auto-generated barrel file. Do not edit.\n${exports.join('\n')}\n`;
+import { jsonSchemaToZodExpressions, type JsonSchemaToZodWarning } from './zodCodegen.js';
+
+export type GeneratedZodModule = {
+    fileName: string;
+    content: string;
+    warnings: JsonSchemaToZodWarning[];
+};
+
+function isValidIdentifier(name: string): boolean {
+    return /^[A-Za-z_][A-Za-z0-9_]*$/.test(name);
+}
+
+function toIdentifier(name: string): string {
+    let out = name.replace(/[^A-Za-z0-9_]/g, '_');
+    if (!/^[A-Za-z_]/.test(out)) out = `_${out}`;
+    return out;
+}
+
+function emitHeader(name: string): string {
+    return (
+        `// Auto-generated from standalone schema '${name}'. Do not edit.\n` +
+        `import { z } from 'zod/v4';\n\n`
+    );
+}
+
+function emitModule(name: string, expressionsByName: Record<string, string>, warnings: JsonSchemaToZodWarning[]): string {
+    const lines: string[] = [];
+    lines.push(emitHeader(name));
+
+    if (warnings.length > 0) {
+        const warningsName = `${toIdentifier(name)}ZodGenerationWarnings`;
+        lines.push(`export const ${warningsName} = ${JSON.stringify(warnings, null, 2)} as const;\n`);
+    }
+
+    const rootIdent = toIdentifier(name);
+    const defNames = Object.keys(expressionsByName)
+        .filter((schemaName) => schemaName !== name)
+        .sort((a, b) => a.localeCompare(b));
+
+    for (const schemaName of defNames) {
+        const ident = toIdentifier(schemaName);
+        if (!isValidIdentifier(ident)) {
+            throw new Error(`Invalid generated identifier for schema '${schemaName}': '${ident}'`);
+        }
+        const expr = expressionsByName[schemaName];
+        lines.push(`const ${ident}Schema: z.ZodTypeAny = z.lazy(() => ${expr});`);
+    }
+
+    lines.push('');
+
+    const rootExpr = expressionsByName[name];
+    lines.push(`export const ${rootIdent}Schema: z.ZodTypeAny = z.lazy(() => ${rootExpr});`);
+
+    return lines.join('\n') + '\n';
+}
+
+export function generateStandaloneZodModule(name: string, standaloneSchema: unknown): GeneratedZodModule {
+    const { expressionsByName, warnings } = jsonSchemaToZodExpressions(standaloneSchema, name);
+    return {
+        fileName: `${name}.ts`,
+        content: emitModule(name, expressionsByName, warnings),
+        warnings,
+    };
+}
+
+export function generateStandaloneZodBarrel(names: string[]): string {
+    const exports = names
+        .slice()
+        .sort((a, b) => a.localeCompare(b))
+        .map((name) => `export { ${toIdentifier(name)}Schema } from './${name}.js';`);
+    return `// Auto-generated barrel file. Do not edit.\n${exports.join('\n')}\n`;
 }