@toolproof-core/genesis 1.0.47

package/dist/src/utils/standaloneTypes.d.ts

@@ -0,0 +1,8 @@
+export declare function generateStandaloneTypeContent(name: string): string;
+export declare function validateStandaloneSchemaForWarnings(schema: any): string[];
+export declare function generateStandaloneTypeArtifacts(name: string): {
+    dtsFileName: string;
+    jsFileName: string;
+    dtsContent: string;
+    jsContent: string;
+};

package/dist/src/utils/standaloneTypes.js

@@ -0,0 +1,22 @@
+export function generateStandaloneTypeContent(name) {
+    const header = '// Auto-generated strict composite type. Do not edit.\n';
+    const standaloneResourceTypeName = `${name}Resource`;
+    const ts = `import type { ResourcePointer, ${name} as ValueSchema } from "../types.js";\n` +
+        `export type ${standaloneResourceTypeName} = ResourcePointer & { value: ValueSchema };\n`;
+    return header + ts;
+}
+export function validateStandaloneSchemaForWarnings(schema) {
+    const warnings = [];
+    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) {
+    return {
+        dtsFileName: `${name}Resource.d.ts`,
+        jsFileName: `${name}Resource.js`,
+        dtsContent: generateStandaloneTypeContent(name),
+        jsContent: 'export {}\n',
+    };
+}

package/dist/src/utils/standaloneZodSchemas.d.ts

@@ -0,0 +1,8 @@
+import { type JsonSchemaToZodWarning } from './zodCodegen.js';
+export type GeneratedZodModule = {
+    fileName: string;
+    content: string;
+    warnings: JsonSchemaToZodWarning[];
+};
+export declare function generateStandaloneZodModule(name: string, standaloneSchema: unknown): GeneratedZodModule;
+export declare function generateStandaloneZodBarrel(names: string[]): string;

package/dist/src/utils/standaloneZodSchemas.js

@@ -0,0 +1,53 @@
+import { jsonSchemaToZodExpressions } from './zodCodegen.js';
+function isValidIdentifier(name) {
+    return /^[A-Za-z_][A-Za-z0-9_]*$/.test(name);
+}
+function toIdentifier(name) {
+    let out = name.replace(/[^A-Za-z0-9_]/g, '_');
+    if (!/^[A-Za-z_]/.test(out))
+        out = `_${out}`;
+    return out;
+}
+function emitHeader(name) {
+    return (`// Auto-generated from standalone schema '${name}'. Do not edit.\n` +
+        `import { z } from 'zod/v4';\n\n`);
+}
+function emitModule(name, expressionsByName, warnings) {
+    const lines = [];
+    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, standaloneSchema) {
+    const { expressionsByName, warnings } = jsonSchemaToZodExpressions(standaloneSchema, name);
+    return {
+        fileName: `${name}.ts`,
+        content: emitModule(name, expressionsByName, warnings),
+        warnings,
+    };
+}
+export function generateStandaloneZodBarrel(names) {
+    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`;
+}

package/dist/src/utils/typeGeneration.d.ts

@@ -0,0 +1 @@
+export declare function generateTypeDeclarations(parsedSchema: any, rootName: string): Promise<string>;

package/dist/src/utils/typeGeneration.js

@@ -0,0 +1,25 @@
+import { compile } from 'json-schema-to-typescript';
+import { finalizeOutputDts, postProcessEmittedTypes } from './typeGenerationPostProcess.js';
+import { normalizeSchemaForGenerator, validateSchemaArrayKeywords } from './typeGenerationPreflight.js';
+export async function generateTypeDeclarations(parsedSchema, rootName) {
+    const validationIssues = validateSchemaArrayKeywords(parsedSchema);
+    if (validationIssues.length) {
+        throw new Error('Schema is not in canonical form for type generation:\n' +
+            validationIssues.map((issue) => `- ${issue}`).join('\n'));
+    }
+    const normalizedSchema = normalizeSchemaForGenerator(parsedSchema);
+    let ts = await compile(normalizedSchema, rootName, {
+        bannerComment: '',
+        declareExternallyReferenced: true,
+        unreachableDefinitions: true,
+        $refOptions: {
+            resolve: {
+                file: { order: 2 },
+                http: false,
+                https: false,
+            },
+        },
+    });
+    ts = postProcessEmittedTypes(ts, parsedSchema);
+    return finalizeOutputDts(ts);
+}

package/dist/src/utils/typeGenerationPostProcess.d.ts

@@ -0,0 +1,2 @@
+export declare function postProcessEmittedTypes(ts: string, parsedSchema: any): string;
+export declare function finalizeOutputDts(emittedType: string): string;

package/dist/src/utils/typeGenerationPostProcess.js

@@ -0,0 +1,166 @@
+function deriveTemplateFromPattern(pattern) {
+    const match = /^\^([^$]+)\.\+\$/.exec(pattern);
+    if (match) {
+        const prefix = match[1];
+        if (prefix === undefined)
+            return undefined;
+        if (!/[`]/.test(prefix)) {
+            return '`' + prefix + '${string}`';
+        }
+    }
+    return undefined;
+}
+function loadPatternTemplatesFromSchema(schema) {
+    const map = {};
+    const defs = schema?.$defs && typeof schema.$defs === 'object' ? schema.$defs : {};
+    for (const [defName, defVal] of Object.entries(defs)) {
+        if (!/(Id|Handle)$/.test(defName))
+            continue;
+        const value = defVal;
+        if (value && value.type === 'string' && typeof value.pattern === 'string') {
+            const tmpl = deriveTemplateFromPattern(value.pattern);
+            if (tmpl)
+                map[defName] = tmpl;
+        }
+    }
+    return map;
+}
+function removeDuplicateUnionEntries(ts) {
+    return ts.replace(/export type ([A-Za-z0-9_]+) =([\s\S]*?);/g, (_match, typeName, body) => {
+        const lines = body.split(/\r?\n/);
+        const seen = new Set();
+        const kept = [];
+        for (const line of lines) {
+            const trimmed = line.trim();
+            const match = /^\|\s*([A-Za-z0-9_]+)\b/.exec(trimmed);
+            if (match) {
+                const name = match[1];
+                if (name === undefined)
+                    continue;
+                if (!seen.has(name)) {
+                    seen.add(name);
+                    kept.push('  | ' + name);
+                }
+                continue;
+            }
+            if (trimmed.length)
+                kept.push(line);
+        }
+        return `export type ${typeName} =\n` + kept.join('\n') + ';';
+    });
+}
+function escapeRegExpLiteral(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function deriveStrategyStateInputEntryByRoleNameValueType(parsedSchema) {
+    const defs = parsedSchema?.$defs ?? parsedSchema?.valueSchema?.$defs;
+    const def = defs?.StrategyStateInputEntryByRoleName;
+    const schemaNode = def?.valueSchema ?? def;
+    const additionalProperties = schemaNode?.additionalProperties;
+    if (!additionalProperties || typeof additionalProperties !== 'object' || Array.isArray(additionalProperties)) {
+        return 'StrategyStateInputEntry';
+    }
+    const union = additionalProperties.oneOf ?? additionalProperties.anyOf;
+    if (!Array.isArray(union) || union.length === 0) {
+        const ref = additionalProperties.$ref;
+        const match = typeof ref === 'string'
+            ? /^#(?:\/(?:\$defs|definitions)\/)?([A-Za-z_][A-Za-z0-9_]*)$/.exec(ref)
+            : undefined;
+        const typeName = match?.[1];
+        return typeName ?? 'StrategyStateInputEntry';
+    }
+    const names = [];
+    for (const item of union) {
+        const ref = item && typeof item === 'object' ? item.$ref : undefined;
+        if (typeof ref !== 'string')
+            continue;
+        const match = /^#(?:\/(?:\$defs|definitions)\/)?([A-Za-z_][A-Za-z0-9_]*)$/.exec(ref);
+        const name = match?.[1];
+        if (name !== undefined)
+            names.push(name);
+    }
+    const unique = Array.from(new Set(names));
+    if (!unique.length)
+        return 'StrategyStateInputEntry';
+    return unique.join(' | ');
+}
+function fixRecursiveArrayAliasSelfReference(ts, typeName) {
+    const lines = ts.split(/\r?\n/);
+    const typeNamePattern = escapeRegExpLiteral(typeName);
+    const startIndex = lines.findIndex((line) => new RegExp(`^export\\s+type\\s+${typeNamePattern}\\s*=\\s*$`).test(line.trimEnd()));
+    if (startIndex < 0)
+        return ts;
+    let endIndex = -1;
+    for (let i = startIndex + 1; i < lines.length; i++) {
+        const line = lines[i];
+        if (line !== undefined && /^\s*};\s*$/.test(line)) {
+            endIndex = i;
+            break;
+        }
+    }
+    if (endIndex < 0)
+        return ts;
+    for (let i = startIndex + 1; i < endIndex; i++) {
+        const line = lines[i];
+        if (line !== undefined && new RegExp(`^\\s*\\|\\s*${typeNamePattern}\\s*$`).test(line)) {
+            lines[i] = line.replace(new RegExp(`\\b${typeNamePattern}\\b`), `${typeName}[]`);
+        }
+    }
+    return lines.join('\n');
+}
+export function postProcessEmittedTypes(ts, parsedSchema) {
+    ts = ts.replace(/^\s*\[k:\s*string\]:\s*unknown;\s*(?:\r?\n)?/gm, '');
+    ts = ts.replace(/^(\s*)(\$defs\??:\s*)\{\s*\r?\n\s*\};/gm, (_m, indent, head) => `${indent}${head}Record<string, unknown>;`);
+    ts = ts.replace(/^(\s*)(properties\??:\s*)\{\s*\r?\n\s*\};/gm, (_m, indent, head) => `${indent}${head}Record<string, unknown>;`);
+    ts = ts.replace(/^(\s*)((?:allOf|anyOf|oneOf)\??:\s*)\{\s*\r?\n\s*\}\[\];/gm, (_m, indent, head) => `${indent}${head}Array<{[k: string]: unknown}>;`);
+    ts = removeDuplicateUnionEntries(ts);
+    const schemaId = parsedSchema?.$id;
+    if (typeof schemaId === 'string') {
+        const match = /\/([^/]+)\.json$/i.exec(schemaId);
+        const rootBaseName = match?.[1];
+        if (rootBaseName) {
+            const rootTypeNameEsc = escapeRegExpLiteral(rootBaseName);
+            const generatedRootSchemaNamePattern = `Https[A-Za-z0-9_]*${rootTypeNameEsc}(?:Json)?`;
+            ts = ts.replace(new RegExp(`^export interface ${generatedRootSchemaNamePattern}\\s*\\{\\s*\\}\\s*(?:\\r?\\n)?`, 'gm'), '');
+            ts = ts.replace(new RegExp(`\\b${generatedRootSchemaNamePattern}\\b`, 'g'), rootBaseName);
+        }
+    }
+    if (!ts || !ts.trim()) {
+        throw new Error('Type generator emitted no output for schema.');
+    }
+    const patternTemplates = loadPatternTemplatesFromSchema(parsedSchema);
+    ts = ts.replace(/^(export\s+type\s+)([A-Za-z_][A-Za-z0-9_]*(?:Id|Handle))(\s*=\s*)string\s*;$/gm, (_m, p1, typeName, p3) => {
+        const tmpl = patternTemplates[typeName];
+        return `${p1}${typeName}${p3}${tmpl ?? 'string'};`;
+    });
+    const roleNameKeyType = 'RoleName';
+    const unthreadedToolStepPathKeyType = 'UnthreadedToolStepPath';
+    const threadedToolStepPathKeyType = 'ThreadedToolStepPath';
+    const toolStepPathKeyType = 'ToolStepPath';
+    ts = ts.replace(/export interface RoleValueByName\s*\{\s*\[k:\s*string\]:\s*RoleValue;\s*\}/g, `export type RoleValueByName = Record<${roleNameKeyType}, RoleValue>;`);
+    const strategyStateInputEntryByRoleNameValueType = deriveStrategyStateInputEntryByRoleNameValueType(parsedSchema);
+    ts = ts.replace(/export interface StrategyStateInputEntryByRoleName\s*\{\s*\[k:\s*string\]:\s*[^;]+;\s*\}/g, `export type StrategyStateInputEntryByRoleName = Record<${roleNameKeyType}, ${strategyStateInputEntryByRoleNameValueType}>;`);
+    ts = ts.replace(/export\s+type\s+StrategyStateInputEntryByRoleName\s*=\s*Record<\s*RoleName\s*,\s*[^>]+>\s*;/g, `export type StrategyStateInputEntryByRoleName = Record<${roleNameKeyType}, ${strategyStateInputEntryByRoleNameValueType}>;`);
+    ts = ts.replace(/export interface StrategyStateInputEntryByRoleNameByUnthreadedToolStepPath\s*\{\s*\[k:\s*string\]:\s*StrategyStateInputEntryByRoleName;\s*\}/g, `export type StrategyStateInputEntryByRoleNameByUnthreadedToolStepPath = Record<${unthreadedToolStepPathKeyType}, StrategyStateInputEntryByRoleName>;`);
+    ts = ts.replace(/export interface StrategyStateInputEntryByRoleNameByThreadedToolStepPath\s*\{\s*\[k:\s*string\]:\s*StrategyStateInputEntryByRoleName;\s*\}/g, `export type StrategyStateInputEntryByRoleNameByThreadedToolStepPath = Record<${threadedToolStepPathKeyType}, StrategyStateInputEntryByRoleName>;`);
+    ts = ts.replace(/export\s+type\s+UnthreadedStrategyState\s*=\s*StrategyStateInputEntryByRoleNameByUnthreadedToolStepPath\s*;/g, `export type UnthreadedStrategyState = Record<${unthreadedToolStepPathKeyType}, StrategyStateInputEntryByRoleName>;`);
+    ts = ts.replace(/export\s+type\s+ThreadedStrategyState\s*=\s*StrategyStateInputEntryByRoleNameByThreadedToolStepPath\s*;/g, `export type ThreadedStrategyState = Record<${threadedToolStepPathKeyType}, StrategyStateInputEntryByRoleName>;`);
+    ts = ts.replace(/(strategyState\??:\s*)\{\s*\[k:\s*string\]:\s*StrategyStateInputEntryByRoleName;\s*\};/g, `$1Record<${toolStepPathKeyType}, StrategyStateInputEntryByRoleName>;`);
+    ts = ts.replace(/(strategyStateUpdate\??:\s*)\{\s*\[k:\s*string\]:\s*StrategyStateInputEntryByRoleName;\s*\};/g, `$1Record<${toolStepPathKeyType}, StrategyStateInputEntryByRoleName>;`);
+    ts = ts.replace(/export interface StepsByThreadIndexFacet\s*\{\s*stepsByThreadIndex:\s*StepArrayArray;\s*\}/g, 'export interface StepsByThreadIndexFacet {\n  stepsByThreadIndex: StepArrayArray;\n}');
+    ts = fixRecursiveArrayAliasSelfReference(ts, 'JsonData');
+    return ts;
+}
+export function finalizeOutputDts(emittedType) {
+    const banner = '// Auto-generated from JSON schemas. Do not edit.\n';
+    let output = banner + '\n' + emittedType + '\n';
+    output = output.replace(/^\s*\[k:\s*string\]:\s*unknown;\s*$/gm, '');
+    output = output
+        .replace(/\r?\n\s*\r?\n(\s*};)/g, '\n$1')
+        .replace(/\r?\n\s*\r?\n(\s*})/g, '\n$1')
+        .replace(/(\r?\n){3,}/g, '\n\n');
+    if (!/\bexport\b|\bdeclare\s+module\b|\bdeclare\s+namespace\b/.test(output)) {
+        output += '\nexport {}\n';
+    }
+    return output;
+}

package/dist/src/utils/typeGenerationPreflight.d.ts

@@ -0,0 +1,2 @@
+export declare function validateSchemaArrayKeywords(node: any, parentKey?: string, pathSegments?: Array<string | number>): string[];
+export declare function normalizeSchemaForGenerator(schema: any): any;

package/dist/src/utils/typeGenerationPreflight.js

@@ -0,0 +1,93 @@
+import { normalizeAllOfSiblingObjectKeywords } from './schemaObjectNormalization.js';
+function formatPath(pathSegments) {
+    let out = '';
+    for (const seg of pathSegments) {
+        if (typeof seg === 'number') {
+            out += `[${seg}]`;
+            continue;
+        }
+        out = out ? `${out}.${seg}` : seg;
+    }
+    return out || '<root>';
+}
+export function validateSchemaArrayKeywords(node, parentKey, pathSegments = []) {
+    if (Array.isArray(node)) {
+        const issues = [];
+        for (let i = 0; i < node.length; i++) {
+            issues.push(...validateSchemaArrayKeywords(node[i], parentKey, pathSegments.concat([i])));
+        }
+        return issues;
+    }
+    if (!node || typeof node !== 'object')
+        return [];
+    const isPropertyNameMap = parentKey === 'properties' ||
+        parentKey === 'patternProperties' ||
+        parentKey === '$defs' ||
+        parentKey === 'dependentSchemas' ||
+        parentKey === 'dependentRequired';
+    const arrayKeys = ['anyOf', 'allOf', 'oneOf', 'required', 'enum'];
+    const issues = [];
+    for (const [key, value] of Object.entries(node)) {
+        if (key === 'properties' || key === 'patternProperties' || key === '$defs' || key === 'dependentSchemas') {
+            if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+                issues.push(`${formatPath(pathSegments.concat([key]))}: expected \`${key}\` to be an object map, got ${value === null ? 'null' : Array.isArray(value) ? 'array' : typeof value}`);
+            }
+        }
+        if (key === 'dependentRequired') {
+            if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+                issues.push(`${formatPath(pathSegments.concat([key]))}: expected \`dependentRequired\` to be an object map, got ${value === null ? 'null' : Array.isArray(value) ? 'array' : typeof value}`);
+            }
+            else {
+                for (const [depKey, depVal] of Object.entries(value)) {
+                    if (!Array.isArray(depVal)) {
+                        issues.push(`${formatPath(pathSegments.concat([key, depKey]))}: expected dependentRequired entries to be string arrays, got ${depVal === null ? 'null' : typeof depVal}`);
+                        continue;
+                    }
+                    for (let i = 0; i < depVal.length; i++) {
+                        if (typeof depVal[i] !== 'string') {
+                            issues.push(`${formatPath(pathSegments.concat([key, depKey, i]))}: expected dependentRequired entries to be strings, got ${depVal[i] === null ? 'null' : typeof depVal[i]}`);
+                        }
+                    }
+                }
+            }
+        }
+        if (!isPropertyNameMap && arrayKeys.includes(key) && Object.prototype.hasOwnProperty.call(node, key)) {
+            if (!Array.isArray(value)) {
+                issues.push(`${formatPath(pathSegments.concat([key]))}: expected \`${key}\` to be an array, got ${value === null ? 'null' : typeof value}`);
+            }
+            else {
+                if ((key === 'anyOf' || key === 'allOf' || key === 'oneOf') && value.length === 0) {
+                    issues.push(`${formatPath(pathSegments.concat([key]))}: expected \`${key}\` to be a non-empty array`);
+                }
+                if (key === 'anyOf' || key === 'allOf' || key === 'oneOf') {
+                    for (let i = 0; i < value.length; i++) {
+                        const item = value[i];
+                        const ok = typeof item === 'boolean' ||
+                            (item !== null && typeof item === 'object' && !Array.isArray(item));
+                        if (!ok) {
+                            issues.push(`${formatPath(pathSegments.concat([key, i]))}: expected a schema (object or boolean), got ${item === null ? 'null' : Array.isArray(item) ? 'array' : typeof item}`);
+                        }
+                    }
+                }
+                if (key === 'required') {
+                    const seen = new Set();
+                    for (let i = 0; i < value.length; i++) {
+                        if (typeof value[i] !== 'string') {
+                            issues.push(`${formatPath(pathSegments.concat([key, i]))}: expected \`required\` entries to be strings, got ${value[i] === null ? 'null' : typeof value[i]}`);
+                            continue;
+                        }
+                        if (seen.has(value[i])) {
+                            issues.push(`${formatPath(pathSegments.concat([key]))}: duplicate required entry \`${value[i]}\``);
+                        }
+                        seen.add(value[i]);
+                    }
+                }
+            }
+        }
+        issues.push(...validateSchemaArrayKeywords(value, key, pathSegments.concat([key])));
+    }
+    return issues;
+}
+export function normalizeSchemaForGenerator(schema) {
+    return normalizeAllOfSiblingObjectKeywords(schema);
+}

package/dist/src/utils/zodCodegen.d.ts

@@ -0,0 +1,10 @@
+export type JsonSchema = any;
+export type JsonSchemaToZodWarning = {
+    path: string;
+    message: string;
+};
+export type JsonSchemaToZodResult = {
+    expressionsByName: Record<string, string>;
+    warnings: JsonSchemaToZodWarning[];
+};
+export declare function jsonSchemaToZodExpressions(standaloneSchema: JsonSchema, rootName: string): JsonSchemaToZodResult;