@toolproof-core/schema 1.0.3 → 1.0.5

package/dist/scripts/generateTypes.js

@@ -1,503 +1,385 @@
 import fs from 'fs';
 import path from 'path';
-import { compileFromFile } from 'json-schema-to-typescript';
+import { compile } from 'json-schema-to-typescript';
 import { getConfig } from './_lib/config.js';
-const config = getConfig();
-const projectRoot = config.getRoot();
-const inputDir = config.getSchemasDir();
-// We emit under src/genesis/generated/types and dist/genesis/generated/types
-const srcLibTypesDir = config.getTypesSrcDir();
-const srcLibOutputPath = config.getTypesSrcPath('types.d.ts');
-// Build an index of all schema files by their basename
-// This supports location-independent $id values where folder segments were removed
-function buildSchemaIndex(root) {
-    const index = new Map();
-    const stack = [root];
-    while (stack.length) {
-        const current = stack.pop();
-        const entries = fs.readdirSync(current, { withFileTypes: true });
-        for (const entry of entries) {
-            const full = path.join(current, entry.name);
-            if (entry.isDirectory()) {
-                // Skip dist or types output folders if present inside schemas (defensive)
-                if (entry.name === 'node_modules' || entry.name.startsWith('.'))
-                    continue;
-                stack.push(full);
-            }
-            else if (entry.isFile() && entry.name.endsWith('.json')) {
-                // Ignore temp files that can be left behind after crashes
-                if (entry.name === '.combined-schema.json')
-                    continue;
-                if (entry.name.startsWith('.normalized.'))
-                    continue;
-                if (entry.name.startsWith('.'))
-                    continue;
-                const baseName = entry.name; // keep extension for direct mapping
-                if (index.has(baseName)) {
-                    // Hard fail on collisions so they can be fixed explicitly
-                    const existing = index.get(baseName);
-                    throw new Error(`Schema basename collision detected for "${baseName}"\n` +
-                        `First:  ${existing}\n` +
-                        `Second: ${full}\n` +
-                        `Please rename one of the schemas to ensure unique basenames.`);
-                }
-                else {
-                    index.set(baseName, full);
-                }
-            }
+// PURE: Format a JSON path for error messages.
+function formatPath(pathSegments) {
+    let out = '';
+    for (const seg of pathSegments) {
+        if (typeof seg === 'number') {
+            out += `[${seg}]`;
+            continue;
         }
+        out = out ? `${out}.${seg}` : seg;
     }
-    return index;
+    return out || '<root>';
 }
-// List all schema files (relative to inputDir), excluding documentation and temp files
-function listAllSchemaFiles(root) {
-    const files = [];
-    const stack = [root];
-    while (stack.length) {
-        const current = stack.pop();
-        const entries = fs.readdirSync(current, { withFileTypes: true });
-        for (const entry of entries) {
-            const full = path.join(current, entry.name);
-            if (entry.isDirectory()) {
-                if (entry.name === 'documentation' || entry.name === 'node_modules' || entry.name.startsWith('.'))
-                    continue;
-                stack.push(full);
-            }
-            else if (entry.isFile() && entry.name.endsWith('.json')) {
-                // Ignore temp files that can be left behind after crashes
-                if (entry.name === '.combined-schema.json')
-                    continue;
-                if (entry.name.startsWith('.normalized.'))
-                    continue;
-                if (entry.name.startsWith('.'))
-                    continue;
-                // produce path relative to root with posix separators
-                const rel = path.relative(root, full).split(path.sep).join('/');
-                files.push(rel);
-            }
+// PURE: Validate schema array-keyword shapes; returns a list of issues (no mutation, no I/O).
+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;
     }
-    files.sort(); // deterministic order
-    return files;
-}
-async function main() {
-    // Ensure types output folder exists
-    fs.mkdirSync(srcLibTypesDir, { recursive: true });
-    const parts = [];
-    parts.push('// Auto-generated from JSON schemas. Do not edit.\n');
-    // Precompute index for location-independent IDs (filename only after version segment)
-    const schemaIndex = buildSchemaIndex(inputDir);
-    const idToCanonical = {};
-    // Custom resolver to map our absolute schema IDs to local files, preventing HTTP fetches.
-    const toolproofResolver = {
-        order: 1,
-        canRead: (file) => {
-            let url = (typeof file.url === 'string' ? file.url : file.url?.href) || '';
-            // Strip accidental wrapping quotes
-            if ((url.startsWith("'") && url.endsWith("'")) || (url.startsWith('"') && url.endsWith('"'))) {
-                url = url.slice(1, -1);
-            }
-            return config.isSchemaUrl(url);
-        },
-        read: (file) => {
-            let url = (typeof file.url === 'string' ? file.url : file.url?.href) || '';
-            // Strip accidental wrapping quotes
-            if ((url.startsWith("'") && url.endsWith("'")) || (url.startsWith('"') && url.endsWith('"'))) {
-                url = url.slice(1, -1);
+    if (!node || typeof node !== 'object')
+        return [];
+    // IMPORTANT:
+    // In meta-schemas we often have `properties: { required: { ...schema... } }`.
+    // Here, the key "required" is a *property name*, not the JSON-Schema keyword.
+    // So when we are iterating a property-name map, do not treat keys as schema keywords.
+    const isPropertyNameMap = parentKey === 'properties' ||
+        parentKey === 'patternProperties' ||
+        parentKey === '$defs' ||
+        parentKey === 'dependentSchemas' ||
+        parentKey === 'dependentRequired';
+    const arrayKeys = ['anyOf', 'allOf', 'oneOf', 'required', 'enum'];
+    const issues = [];
+    for (const [k, v] of Object.entries(node)) {
+        // Keyword sanity checks for schema objects (regardless of where they appear).
+        // These reduce the chance of feeding obviously malformed shapes into the generator.
+        if (k === 'properties' || k === 'patternProperties' || k === '$defs' || k === 'dependentSchemas') {
+            if (v === null || typeof v !== 'object' || Array.isArray(v)) {
+                issues.push(`${formatPath(pathSegments.concat([k]))}: expected \`${k}\` to be an object map, got ${v === null ? 'null' : Array.isArray(v) ? 'array' : typeof v}`);
             }
-            // Strip hash part (anchors) for path resolution
-            const noHash = url.split('#')[0];
-            // Extract schema name using config
-            const schemaName = config.extractSchemaName(noHash);
-            const fileName = schemaName.endsWith('.json') ? schemaName : `${schemaName}.json`;
-            // Resolve by basename only (location-independent IDs)
-            const indexed = schemaIndex.get(fileName);
-            if (indexed) {
-                return fs.readFileSync(indexed, 'utf8');
-            }
-            throw new Error(`Toolproof resolver: could not locate schema for URL "${url}". ` +
-                `Tried basename "${fileName}" in schema index. Ensure unique basenames and correct $id.`);
-        }
-    };
-    // Files to include in the combined schema (auto-discovered, excludes documentation)
-    const toCompile = listAllSchemaFiles(inputDir);
-    // Collect schema refs and defs; we'll compile files individually to avoid combined-schema traversal issues.
-    const definitions = {};
-    const includedNames = [];
-    for (const fileName of toCompile) {
-        const p = path.join(inputDir, fileName);
-        if (!fs.existsSync(p)) {
-            console.warn(`Schema file missing, skipping: ${p}`);
-            continue;
         }
-        // Definition key: basename without extension, with path segments removed
-        const base = path.basename(fileName, '.json');
-        // Prefer the schema's declared $id so all references point to the same absolute URI
-        // This helps json-schema-to-typescript dedupe declarations instead of emitting FooJson and FooJson1
-        let refValue = `./${fileName}`;
-        try {
-            const raw = fs.readFileSync(p, 'utf8');
-            const parsed = JSON.parse(raw);
-            if (parsed && typeof parsed.$id === 'string' && parsed.$id.trim()) {
-                // Sanitize IDs that may have been emitted with surrounding quotes
-                // e.g. quotes around schema URL
-                let cleaned = parsed.$id.trim();
-                if ((cleaned.startsWith("'") && cleaned.endsWith("'")) || (cleaned.startsWith('"') && cleaned.endsWith('"'))) {
-                    cleaned = cleaned.slice(1, -1);
-                }
-                refValue = cleaned;
-                idToCanonical[refValue] = base + 'Json';
+        if (k === 'dependentRequired') {
+            if (v === null || typeof v !== 'object' || Array.isArray(v)) {
+                issues.push(`${formatPath(pathSegments.concat([k]))}: expected \`dependentRequired\` to be an object map, got ${v === null ? 'null' : Array.isArray(v) ? 'array' : typeof v}`);
             }
-            // Promote this file's $defs to top-level combined $defs so each gets its own exported type
-            if (parsed && parsed.$defs && typeof parsed.$defs === 'object') {
-                const defNames = Object.keys(parsed.$defs).filter((k) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(k));
-                for (const defName of defNames) {
-                    // Prefer bare def name; if collision, namespace with file base
-                    let entryName = defName;
-                    if (definitions[entryName]) {
-                        entryName = `${base}_${defName}`;
+            else {
+                for (const [depKey, depVal] of Object.entries(v)) {
+                    if (!Array.isArray(depVal)) {
+                        issues.push(`${formatPath(pathSegments.concat([k, depKey]))}: expected dependentRequired entries to be string arrays, got ${depVal === null ? 'null' : typeof depVal}`);
+                        continue;
                     }
-                    if (!definitions[entryName]) {
-                        definitions[entryName] = { $ref: `${refValue}#/$defs/${defName}` };
-                        includedNames.push(entryName);
+                    for (let i = 0; i < depVal.length; i++) {
+                        if (typeof depVal[i] !== 'string') {
+                            issues.push(`${formatPath(pathSegments.concat([k, depKey, i]))}: expected dependentRequired entries to be strings, got ${depVal[i] === null ? 'null' : typeof depVal[i]}`);
+                        }
                     }
                 }
             }
         }
-        catch (e) {
-            // If parsing fails, fall back to relative ref; proceed gracefully
-        }
-        definitions[base] = { $ref: refValue };
-        includedNames.push(base);
-    }
-    if (includedNames.length === 0) {
-        console.warn('No schema files found to compile. Nothing to do.');
-        return;
-    }
-    // Instead of building a combined schema (which can trip json-schema-to-typescript traversals),
-    // compile each discovered schema file individually and concatenate the outputs.
-    try {
-        let ts = '';
-        for (const fileName of toCompile) {
-            const schemaPath = path.join(inputDir, fileName);
-            if (!fs.existsSync(schemaPath))
-                continue;
-            // Load and defensively normalize array-expected keywords to avoid generator crashes
-            let toCompilePath = schemaPath;
-            try {
-                const rawSchema = fs.readFileSync(schemaPath, 'utf8');
-                const parsedSchema = JSON.parse(rawSchema);
-                function normalizeArrays(node, parentKey) {
-                    if (Array.isArray(node)) {
-                        for (let i = 0; i < node.length; i++)
-                            normalizeArrays(node[i], parentKey);
-                        return;
-                    }
-                    if (!node || typeof node !== 'object')
-                        return;
-                    // IMPORTANT:
-                    // In meta-schemas we often have `properties: { required: { ...schema... } }`.
-                    // Here, the key "required" is a *property name*, not the JSON-Schema keyword
-                    // "required". Blindly normalizing would wrap that schema object into an array,
-                    // causing json-schema-to-typescript to emit the schema-shape instead of `string[]`.
-                    //
-                    // So: only coerce array-keywords when we're not inside a map of property names.
-                    const isPropertyNameMap = parentKey === 'properties'
-                        || parentKey === 'patternProperties'
-                        || parentKey === '$defs'
-                        || parentKey === 'definitions'
-                        || parentKey === 'dependentSchemas';
-                    if (!isPropertyNameMap) {
-                        const arrayKeys = ['anyOf', 'allOf', 'oneOf', 'required', 'enum'];
-                        for (const k of arrayKeys) {
-                            if (k in node) {
-                                const v = node[k];
-                                if (!Array.isArray(v))
-                                    node[k] = [v];
-                            }
+        if (!isPropertyNameMap && arrayKeys.includes(k) && Object.prototype.hasOwnProperty.call(node, k)) {
+            if (!Array.isArray(v)) {
+                issues.push(`${formatPath(pathSegments.concat([k]))}: expected \`${k}\` to be an array, got ${v === null ? 'null' : typeof v}`);
+            }
+            else {
+                if ((k === 'anyOf' || k === 'allOf' || k === 'oneOf') && v.length === 0) {
+                    issues.push(`${formatPath(pathSegments.concat([k]))}: expected \`${k}\` to be a non-empty array`);
+                }
+                if (k === 'anyOf' || k === 'allOf' || k === 'oneOf') {
+                    for (let i = 0; i < v.length; i++) {
+                        const item = v[i];
+                        const ok = typeof item === 'boolean' ||
+                            (item !== null && typeof item === 'object' && !Array.isArray(item));
+                        if (!ok) {
+                            issues.push(`${formatPath(pathSegments.concat([k, i]))}: expected a schema (object or boolean), got ${item === null ? 'null' : Array.isArray(item) ? 'array' : typeof item}`);
                         }
                     }
-                    for (const [k, v] of Object.entries(node))
-                        normalizeArrays(v, k);
                 }
-                // json-schema-to-typescript has a long-standing quirk:
-                // when a schema uses `allOf`, sibling object keywords like `properties`/`required`
-                // can be ignored in the emitted TS (it treats `allOf` as the whole schema).
-                //
-                // Example (Genesis $defs/Job):
-                //   { type: 'object', allOf: [Documented, RolesWrapper], properties: { identity: ... }, required: [...] }
-                // can become:
-                //   type Job = Documented & RolesWrapper
-                //
-                // To avoid cluttering the source JSON schemas, we normalize to a temp file:
-                // move those sibling object keywords into an extra `allOf` item.
-                function normalizeAllOfSiblingObjectKeywords(node) {
-                    if (Array.isArray(node)) {
-                        for (const item of node)
-                            normalizeAllOfSiblingObjectKeywords(item);
-                        return;
-                    }
-                    if (!node || typeof node !== 'object')
-                        return;
-                    const hasAllOf = Array.isArray(node.allOf) && node.allOf.length > 0;
-                    const looksLikeObjectSchema = node.type === 'object' ||
-                        node.properties !== undefined ||
-                        node.required !== undefined ||
-                        node.unevaluatedProperties !== undefined ||
-                        node.additionalProperties !== undefined;
-                    if (hasAllOf && looksLikeObjectSchema) {
-                        const siblingKeys = [
-                            'properties',
-                            'required',
-                            'additionalProperties',
-                            'unevaluatedProperties',
-                            'propertyNames',
-                            'patternProperties',
-                            'dependentRequired',
-                            'dependentSchemas',
-                            'minProperties',
-                            'maxProperties'
-                        ];
-                        const hasSiblingObjectKeywords = siblingKeys.some((k) => k in node);
-                        if (hasSiblingObjectKeywords) {
-                            const overlay = {};
-                            if (node.type === 'object')
-                                overlay.type = 'object';
-                            for (const k of siblingKeys) {
-                                if (k in node) {
-                                    overlay[k] = node[k];
-                                    delete node[k];
-                                }
-                            }
-                            // Prepend so it participates in the intersection early.
-                            node.allOf = [overlay, ...node.allOf];
+                if (k === 'required') {
+                    // `required` must be string[] when used as a JSON-Schema keyword.
+                    const seen = new Set();
+                    for (let i = 0; i < v.length; i++) {
+                        if (typeof v[i] !== 'string') {
+                            issues.push(`${formatPath(pathSegments.concat([k, i]))}: expected \`required\` entries to be strings, got ${v[i] === null ? 'null' : typeof v[i]}`);
+                            continue;
+                        }
+                        if (seen.has(v[i])) {
+                            issues.push(`${formatPath(pathSegments.concat([k]))}: duplicate required entry \`${v[i]}\``);
                         }
+                        seen.add(v[i]);
                     }
-                    for (const v of Object.values(node))
-                        normalizeAllOfSiblingObjectKeywords(v);
                 }
-                // Normalize expected arrays to prevent traversal crashes
-                normalizeArrays(parsedSchema);
-                // Normalize `allOf` + sibling object keywords so the TS generator doesn't drop them.
-                normalizeAllOfSiblingObjectKeywords(parsedSchema);
-                const tmpPath = path.join(inputDir, `.normalized.${path.basename(fileName)}`);
-                fs.writeFileSync(tmpPath, JSON.stringify(parsedSchema, null, 2), 'utf8');
-                toCompilePath = tmpPath;
             }
-            catch (e) {
-                // If normalization fails, fall back to original path
-            }
-            const part = await compileFromFile(toCompilePath, {
-                bannerComment: '',
-                // 
-                declareExternallyReferenced: true,
-                unreachableDefinitions: true,
-                // Forward ref parser options so absolute $id/$ref URLs resolve from local files
-                $refOptions: {
-                    // Don’t go to the network; we provide a local resolver for our domain
-                    resolve: {
-                        file: { order: 2 },
-                        http: false,
-                        https: false,
-                        toolproof: toolproofResolver
-                    }
-                }
-            });
-            ts += '\n' + part + '\n';
-            // Cleanup temp normalized file
-            if (toCompilePath !== schemaPath) {
-                try {
-                    fs.unlinkSync(toCompilePath);
+        }
+        issues.push(...validateSchemaArrayKeywords(v, k, pathSegments.concat([k])));
+    }
+    return issues;
+}
+// PURE: Move sibling object keywords into `allOf` overlays (returns a new tree; does not mutate inputs).
+function normalizeAllOfSiblingObjectKeywords(node) {
+    if (Array.isArray(node)) {
+        let changed = false;
+        const out = node.map((item) => {
+            const next = normalizeAllOfSiblingObjectKeywords(item);
+            if (next !== item)
+                changed = true;
+            return next;
+        });
+        return changed ? out : node;
+    }
+    if (!node || typeof node !== 'object')
+        return node;
+    const hasAllOf = Array.isArray(node.allOf) && node.allOf.length > 0;
+    const looksLikeObjectSchema = node.type === 'object' ||
+        node.properties !== undefined ||
+        node.required !== undefined ||
+        node.unevaluatedProperties !== undefined ||
+        node.additionalProperties !== undefined;
+    const siblingKeys = [
+        'properties',
+        'required',
+        'additionalProperties',
+        'unevaluatedProperties',
+        'propertyNames',
+        'patternProperties',
+        'dependentRequired',
+        'dependentSchemas',
+        'minProperties',
+        'maxProperties'
+    ];
+    let localNode = node;
+    if (hasAllOf && looksLikeObjectSchema) {
+        const hasSiblingObjectKeywords = siblingKeys.some((k) => k in localNode);
+        if (hasSiblingObjectKeywords) {
+            const overlay = {};
+            if (localNode.type === 'object')
+                overlay.type = 'object';
+            const nextNode = { ...localNode };
+            for (const k of siblingKeys) {
+                if (k in nextNode) {
+                    overlay[k] = nextNode[k];
+                    delete nextNode[k];
                 }
-                catch { }
             }
+            nextNode.allOf = [overlay, ...nextNode.allOf];
+            localNode = nextNode;
         }
-        // Remove permissive index signatures that make interfaces open-ended.
-        // Keep meaningful map-like signatures (e.g., `[k: string]: ResourceRoleValue`) intact.
-        // Robust single-pass: delete the entire line (with optional trailing newline) where the signature appears.
-        // This avoids introducing extra blank lines while handling CRLF/LF and varying indentation.
-        ts = ts.replace(/^\s*\[k:\s*string\]:\s*unknown;\s*(?:\r?\n)?/gm, '');
-        // Fix meta-schema types where json-schema-to-typescript can still incorrectly interpret
-        // schema definitions as literal values (or emit overly-restrictive `{}` objects).
-        // We do this as a broad post-pass on the emitted TS because the generator output varies
-        // (e.g. `allOf?: { }[];` vs `allOf?: [{type:"array"; ...}]`).
-        // `$defs?: { }` or `$defs: { }` -> map type (preserve required/optional marker)
-        // NOTE: We emit `Record<...>` instead of an index signature because later cleanup
-        // strips standalone `[k: string]: unknown;` lines.
-        ts = ts.replace(/^(\s*)(\$defs\??:\s*)\{\s*\r?\n\s*\};/gm, (_m, indent, head) => `${indent}${head}Record<string, unknown>;`);
-        // `properties?: { }` or `properties: { }` -> map type
-        ts = ts.replace(/^(\s*)(properties\??:\s*)\{\s*\r?\n\s*\};/gm, (_m, indent, head) => `${indent}${head}Record<string, unknown>;`);
-        // `allOf?: { }[];` (and similar for anyOf/oneOf) -> array of schema-ish objects
-        ts = ts.replace(/^(\s*)((?:allOf|anyOf|oneOf)\??:\s*)\{\s*\r?\n\s*\}\[\];/gm, (_m, indent, head) => `${indent}${head}Array<{[k: string]: unknown}>;`);
-        // Older broken shapes from earlier normalization (keep for backwards compatibility)
-        ts = ts.replace(/((?:allOf|anyOf|oneOf)\??:\s*)\[\{type:\s*"array";\s*items:\s*\{type:\s*"object"\}\}\];/g, '$1Array<{[k: string]: unknown}>;');
-        ts = ts.replace(/required\?:\s*\[\{type:\s*"array";\s*items:\s*\{type:\s*"string"\};\s*uniqueItems:\s*true\}\];/g, 'required?: string[];');
-        // Similarly fix IdentityProp/MeritProp which have the same issue
-        ts = ts.replace(/^(export interface IdentityProp[\s\S]*?)(required:\s*\[\{type:\s*"array";\s*contains:\s*\{const:\s*"identity"\};\s*items:\s*\{type:\s*"string"\};\s*uniqueItems:\s*true\}\];)/gm, '$1required?: string[];');
-        ts = ts.replace(/^(export interface MeritProp[\s\S]*?)(required:\s*\[\{type:\s*"array";\s*items:\s*\{type:\s*"string"\};\s*uniqueItems:\s*true\}\];)/gm, '$1required?: string[];');
-        // Prune verbose type/interface names produced from absolute $id URLs.
-        // Deterministic pruning based on original $id -> baseName map
-        // This avoids heuristic truncation that dropped prefixes.
-        function idToGeneratedIdentifier(id) {
-            // json-schema-to-typescript seems to create a PascalCase of the URL with protocol prefix
-            // Simplified reconstruction: 'https://' => 'Https', then capitalize path & host segments
-            const noProto = id.replace(/^https?:\/\//i, '');
-            const tokens = noProto
-                .split(/[\/#?.=&_-]+/)
-                .filter(Boolean)
-                .map((t) => t.replace(/[^A-Za-z0-9]/g, ''))
-                .filter(Boolean)
-                .map((t) => t.charAt(0).toUpperCase() + t.slice(1));
-            return 'Https' + tokens.join('') + 'Json';
+    }
+    let changed = localNode !== node;
+    const out = localNode === node ? {} : { ...localNode };
+    for (const [k, v] of Object.entries(localNode)) {
+        const next = normalizeAllOfSiblingObjectKeywords(v);
+        if (next !== v) {
+            if (!changed) {
+                changed = true;
+                Object.assign(out, localNode);
+            }
+            out[k] = next;
         }
-        // Perform replacements for known IDs
-        for (const [id, canonical] of Object.entries(idToCanonical)) {
-            const longName = idToGeneratedIdentifier(id);
-            if (longName === canonical)
-                continue; // already minimal
-            const re = new RegExp(`\\b${longName}\\b`, 'g');
-            ts = ts.replace(re, canonical);
+        else if (changed) {
+            out[k] = v;
         }
-        // Remove version prefixes inside any remaining long identifiers: Https...V0... -> remove V0 if followed by capital
-        ts = ts.replace(/(Https[A-Za-z0-9_]*?)V\d+([A-Z])/g, '$1$2');
-        // Final cleanup: aggressively strip the domain prefix `HttpsSchemasToolproofCom` from ALL identifiers.
-        // This is safe because those long names are only artifacts of json-schema-to-typescript; base names don't start with that sequence.
-        ts = ts.replace(/\bHttpsSchemasToolproofCom(?=[A-Z])/g, '');
-        // Remove accidental duplicate union entries in any exported union types after shortening.
-        ts = ts.replace(/export type ([A-Za-z0-9_]+) =([\s\S]*?);/g, (m, typeName, body) => {
-            const lines = body.split(/\n/);
-            const seen2 = 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 (!seen2.has(name)) {
-                        seen2.add(name);
-                        kept.push('  | ' + name);
-                    }
-                }
-                else if (trimmed.length) {
-                    kept.push(line);
-                }
-            }
-            return `export type ${typeName} =\n` + kept.join('\n') + ';';
-        });
-        // If nothing was emitted, compile Genesis.json as a final fallback.
-        if (!ts || !ts.trim()) {
-            const primary = path.join(inputDir, 'Genesis.json');
-            if (fs.existsSync(primary)) {
-                ts = await compileFromFile(primary, {
-                    bannerComment: '',
-                    declareExternallyReferenced: true,
-                    unreachableDefinitions: true,
-                    $refOptions: {
-                        resolve: {
-                            file: { order: 2 },
-                            http: false,
-                            https: false,
-                            toolproof: toolproofResolver
-                        }
-                    }
-                });
-            }
+    }
+    return changed ? out : node;
+}
+// PURE: Clone + apply all generator-normalizations.
+function normalizeSchemaForGenerator(schema) {
+    return normalizeAllOfSiblingObjectKeywords(schema);
+}
+// PURE: Convert a regex-ish pattern into a TS template literal when recognizable.
+function deriveTemplateFromPattern(pattern) {
+    // Common (and currently canonical for identities): ^PREFIX-.+$ => `PREFIX-${string}`
+    const m1 = /^\^([^$]+)\.\+\$/.exec(pattern);
+    if (m1) {
+        const prefix = m1[1];
+        if (!/[`]/.test(prefix)) {
+            return '`' + prefix + '${string}`';
         }
-        // Still nothing? ensure we emit a module so downstream imports don't fail.
-        if (!ts || !ts.trim()) {
-            ts = '// (No concrete types emitted by generator)\nexport {}\n';
+    }
+    return undefined;
+}
+// PURE: Extract Identity template-literal aliases from a parsed schema.
+function loadPatternTemplatesFromSchema(schema) {
+    const map = {};
+    const defs = schema?.$defs && typeof schema.$defs === 'object' ? schema.$defs : {};
+    for (const [defName, defVal] of Object.entries(defs)) {
+        const isPatternType = /Identity$/.test(defName);
+        if (!isPatternType)
+            continue;
+        const v = defVal;
+        if (v && v.type === 'string' && typeof v.pattern === 'string') {
+            const tmpl = deriveTemplateFromPattern(v.pattern);
+            if (tmpl)
+                map[defName] = tmpl;
         }
-        // Overlay Identity/Ref aliases with template literal types inferred from Genesis.json patterns.
-        // For each $defs entry ending with "Identity" or "Ref", and that provides a `pattern`,
-        // derive a TS template literal; otherwise fall back to plain `string`.
-        function deriveTemplateFromPattern(pattern) {
-            // Common form: ^PREFIX-.+$ => PREFIX-${string}
-            const m1 = /^\^([^$]+)\.\+\$/.exec(pattern);
-            if (m1) {
-                const prefix = m1[1];
-                if (!/[`]/.test(prefix)) {
-                    return '`' + prefix + '${string}`';
-                }
-            }
-            // Slightly stricter forms: ^PREFIX-[A-Za-z0-9]+$ => PREFIX-${string}
-            const m2 = /^\^([A-Za-z0-9._:-]+-)\[?\^?[A-Za-z0-9]+\]?\+?\$/.exec(pattern);
-            if (m2) {
-                const prefix = m2[1];
-                if (!/[`]/.test(prefix)) {
-                    return '`' + prefix + '${string}`';
+    }
+    return map;
+}
+// PURE: Remove duplicate union members from emitted `export type X = | ...` blocks.
+function removeDuplicateUnionEntries(ts) {
+    return ts.replace(/export type ([A-Za-z0-9_]+) =([\s\S]*?);/g, (_m, 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 (!seen.has(name)) {
+                    seen.add(name);
+                    kept.push('  | ' + name);
                 }
+                continue;
             }
-            return undefined;
+            if (trimmed.length)
+                kept.push(line);
         }
-        function loadPatternTemplates() {
-            const map = {};
-            try {
-                const genesisPath = path.join(inputDir, config.getSourceFile());
-                if (fs.existsSync(genesisPath)) {
-                    const raw = fs.readFileSync(genesisPath, 'utf8');
-                    const parsed = JSON.parse(raw);
-                    const defs = parsed?.$defs && typeof parsed.$defs === 'object' ? parsed.$defs : {};
-                    for (const [defName, defVal] of Object.entries(defs)) {
-                        // Process pattern-bearing string types.
-                        // Supports "...Identity" / "...Ref" conventions.
-                        const isPatternType = /(?:Identity|Ref)$/.test(defName);
-                        if (!isPatternType)
-                            continue;
-                        const v = defVal;
-                        if (v && v.type === 'string' && typeof v.pattern === 'string') {
-                            const tmpl = deriveTemplateFromPattern(v.pattern);
-                            if (tmpl)
-                                map[defName] = tmpl;
-                        }
-                    }
+        return `export type ${typeName} =\n` + kept.join('\n') + ';';
+    });
+}
+// PURE: Escape a string for use inside a RegExp pattern.
+function escapeRegExpLiteral(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+// PURE: Fix a known json-schema-to-typescript edge case where a JSON-like recursive value union
+// accidentally includes a direct self-reference (`| JsonData`) instead of the intended array case (`| JsonData[]`).
+function fixJsonDataSelfReference(ts) {
+    const lines = ts.split(/\r?\n/);
+    const startIndex = lines.findIndex((l) => /^export\s+type\s+JsonData\s*=\s*$/.test(l.trimEnd()));
+    if (startIndex < 0)
+        return ts;
+    // This type currently ends with a union member object whose closing line is `};`.
+    // Find that terminator after the type header.
+    let endIndex = -1;
+    for (let i = startIndex + 1; i < lines.length; i++) {
+        if (/^\s*};\s*$/.test(lines[i])) {
+            endIndex = i;
+            break;
+        }
+    }
+    if (endIndex < 0)
+        return ts;
+    for (let i = startIndex + 1; i < endIndex; i++) {
+        if (/^\s*\|\s*JsonData\s*$/.test(lines[i])) {
+            lines[i] = lines[i].replace(/\bJsonData\b/, 'JsonData[]');
+        }
+    }
+    return lines.join('\n');
+}
+// PURE: Apply deterministic post-processing to the generator output (no I/O).
+function postProcessEmittedTypes(ts, parsedSchema) {
+    // Remove permissive index signatures that make interfaces open-ended.
+    // Keep meaningful map-like signatures (e.g., `[k: string]: ResourceRoleValue`) intact.
+    // Robust single-pass: delete the entire line (with optional trailing newline) where the signature appears.
+    // This avoids introducing extra blank lines while handling CRLF/LF and varying indentation.
+    ts = ts.replace(/^\s*\[k:\s*string\]:\s*unknown;\s*(?:\r?\n)?/gm, '');
+    // Fix meta-schema types where json-schema-to-typescript can still incorrectly interpret
+    // schema definitions as literal values (or emit overly-restrictive `{}` objects).
+    // We do this as a broad post-pass on the emitted TS because the generator output varies
+    // (e.g. `allOf?: { }[];` vs `allOf?: [{type:"array"; ...}]`).
+    // `$defs?: { }` or `$defs: { }` -> map type (preserve required/optional marker)
+    // NOTE: We emit `Record<...>` instead of an index signature because later cleanup
+    // strips standalone `[k: string]: unknown;` lines.
+    ts = ts.replace(/^(\s*)(\$defs\??:\s*)\{\s*\r?\n\s*\};/gm, (_m, indent, head) => `${indent}${head}Record<string, unknown>;`);
+    // `properties?: { }` or `properties: { }` -> map type
+    ts = ts.replace(/^(\s*)(properties\??:\s*)\{\s*\r?\n\s*\};/gm, (_m, indent, head) => `${indent}${head}Record<string, unknown>;`);
+    // `allOf?: { }[];` (and similar for anyOf/oneOf) -> array of schema-ish objects
+    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);
+    // Strip URL-derived root schema interface names produced by json-schema-to-typescript
+    // (e.g. `HttpsSchemasToolproofComV2GenesisJson`). These are naming artifacts and not
+    // meaningful domain types.
+    const schemaId = parsedSchema?.$id;
+    if (typeof schemaId === 'string') {
+        const m = /\/([^/]+)\.json$/i.exec(schemaId);
+        const rootBaseName = m?.[1];
+        if (rootBaseName) {
+            const rootJsonSuffix = `${rootBaseName}Json`;
+            const rootJsonSuffixEsc = escapeRegExpLiteral(rootJsonSuffix);
+            // Remove the (typically empty) URL-derived root interface, if present.
+            ts = ts.replace(new RegExp(`^export interface Https[A-Za-z0-9_]*${rootJsonSuffixEsc}\\s*\\{\\s*\\}\\s*(?:\\r?\\n)?`, 'gm'), '');
+            // Replace remaining references to that URL-derived name in doc/comments.
+            ts = ts.replace(new RegExp(`\\bHttps[A-Za-z0-9_]*${rootJsonSuffixEsc}\\b`, 'g'), rootBaseName);
+        }
+    }
+    if (!ts || !ts.trim()) {
+        throw new Error('Type generator emitted no output for Genesis schema.');
+    }
+    // Overlay Identity aliases with template literal types inferred from Genesis.json patterns.
+    // For each $defs entry ending with "Identity" that provides a `pattern`,
+    // derive a TS template literal; otherwise fall back to plain `string`.
+    const patternTemplates = loadPatternTemplatesFromSchema(parsedSchema);
+    // Replace any exported Identity aliases to use the inferred template literals where available.
+    // Handle the common `= string;` output from json-schema-to-typescript.
+    ts = ts.replace(/^(export\s+type\s+)([A-Za-z_][A-Za-z0-9_]*Identity)(\s*=\s*)string\s*;$/gm, (_m, p1, typeName, p3) => {
+        const tmpl = patternTemplates[typeName];
+        return `${p1}${typeName}${p3}${tmpl ?? 'string'};`;
+    });
+    // Post-process map-like interfaces to enforce key constraints via template literal Identity types.
+    // Replace index-signature interfaces with Record<KeyType, ValueType> so object literal keys are checked.
+    const resourceRoleKeyType = 'ResourceRoleIdentity';
+    const jobStepKeyType = 'JobStepIdentity';
+    const strategyThreadKeyType = 'StrategyThreadIdentity';
+    ts = ts.replace(/export interface RoleMap\s*{[^}]*}/g, `export type RoleMap = Record<${resourceRoleKeyType}, ResourceRoleValue>;`);
+    // Normalize StrategyState & related socket maps to identity-keyed Records.
+    // These are emitted as `[k: string]` by json-schema-to-typescript but are identity-keyed in practice.
+    // Per schema: JobStepSocket: Record<ResourceRoleIdentity, Resource>
+    //            StrategyState: Record<JobStepIdentity, JobStepSocket>
+    const jobStepSocketValueType = 'Resource';
+    ts = ts.replace(/export interface JobStepSocket\s*\{\s*\[k:\s*string\]:\s*[^;]+;\s*\}/g, `export type JobStepSocket = Record<${resourceRoleKeyType}, ${jobStepSocketValueType}>;`);
+    ts = ts.replace(/export interface StrategyState\s*\{\s*\[k:\s*string\]:\s*JobStepSocket;\s*\}/g, `export type StrategyState = Record<${jobStepKeyType}, JobStepSocket>;`);
+    ts = ts.replace(/(strategyStateUpdate\??:\s*)\{\s*\[k:\s*string\]:\s*JobStepSocket;\s*\};/g, `$1Record<${jobStepKeyType}, JobStepSocket>;`);
+    // Ensure key constraints for strategyThreadMap are preserved as template-literal identity keys.
+    // json-schema-to-typescript emits `[k: string]: StepArray;`, but we want keys to be `StrategyThreadIdentity`.
+    ts = ts.replace(/export interface StrategyThreadMap\s*\{\s*\[k:\s*string\]:\s*StepArray;\s*\}/g, `export type StrategyThreadMap = Record<${strategyThreadKeyType}, StepArray>;`);
+    ts = fixJsonDataSelfReference(ts);
+    return ts;
+}
+// PURE: Add banner + formatting/guards to build the final .d.ts content.
+function finalizeOutputDts(emittedType) {
+    const banner = '// Auto-generated from JSON schemas. Do not edit.\n';
+    let output = banner + '\n' + emittedType + '\n';
+    // Final guard: strip any lingering `[k: string]: unknown;` that might have been
+    // reintroduced by later transforms.
+    output = output.replace(/^\s*\[k:\s*string\]:\s*unknown;\s*$/gm, '');
+    // Cosmetic post-format: remove lone blank lines before closing braces and collapse excessive blank lines
+    // - Remove a single blank line before `};` and `}`
+    // - Collapse 3+ consecutive newlines into a maximum of 2
+    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');
+    // As an additional safeguard, make sure the final .d.ts is treated as a module.
+    // If no export/interface/module is present, append an empty export.
+    if (!/\bexport\b|\bdeclare\s+module\b|\bdeclare\s+namespace\b/.test(output)) {
+        output += '\nexport {}\n';
+    }
+    return output;
+}
+// IMPURE: Main script entrypoint (config + filesystem I/O + console + process exit).
+async function main() {
+    try {
+        const config = getConfig();
+        const inputDir = config.getSchemasDir();
+        const srcLibTypesDir = config.getTypesSrcDir();
+        const srcLibOutputPath = config.getTypesSrcPath('types.d.ts');
+        fs.mkdirSync(srcLibTypesDir, { recursive: true });
+        const schemaFileName = config.getSourceFile();
+        const schemaPath = path.join(inputDir, schemaFileName);
+        if (!fs.existsSync(schemaPath)) {
+            throw new Error(`Root schema not found: ${schemaPath}\n` +
+                `Run the schema extraction step first (e.g. pnpm run extractSchemasFromResourceTypeShells).`);
+        }
+        const rawSchema = fs.readFileSync(schemaPath, 'utf8');
+        const parsedSchema = JSON.parse(rawSchema);
+        const validationIssues = validateSchemaArrayKeywords(parsedSchema);
+        if (validationIssues.length) {
+            throw new Error('Genesis schema is not in canonical form for type generation:\n' +
+                validationIssues.map((s) => `- ${s}`).join('\n'));
+        }
+        const normalizedSchema = normalizeSchemaForGenerator(parsedSchema);
+        let ts;
+        const rootName = path.basename(schemaFileName, path.extname(schemaFileName));
+        ts = await compile(normalizedSchema, rootName, {
+            bannerComment: '',
+            declareExternallyReferenced: true,
+            unreachableDefinitions: true,
+            $refOptions: {
+                resolve: {
+                    file: { order: 2 },
+                    http: false,
+                    https: false
                 }
             }
-            catch {
-                // ignore failures; we'll just fall back to string
-            }
-            return map;
-        }
-        const patternTemplates = loadPatternTemplates();
-        // Replace any exported Identity/Ref aliases to use the inferred template literals where available.
-        // Handle the common `= string;` output from json-schema-to-typescript.
-        ts = ts.replace(/^(export\s+type\s+)([A-Za-z_][A-Za-z0-9_]*(?:Identity|Ref))(\s*=\s*)string\s*;$/gm, (_m, p1, typeName, p3) => {
-            const tmpl = patternTemplates[typeName];
-            return `${p1}${typeName}${p3}${tmpl ?? 'string'};`;
         });
-        // Post-process map-like interfaces to enforce key constraints via template literal Identity types.
-        // Replace index-signature interfaces with Record<KeyType, ValueType> so object literal keys are checked.
-        const resourceRoleKeyType = 'ResourceRoleIdentity';
-        const resourceKeyType = 'ResourceIdentity';
-        const executionKeyType = 'ExecutionIdentity';
-        const strategyThreadKeyType = 'StrategyThreadIdentity';
-        ts = ts.replace(/export interface RoleMap\s*{[^}]*}/g, `export type RoleMap = Record<${resourceRoleKeyType}, ResourceRoleValue>;`);
-        ts = ts.replace(/export interface RoleBindingMap\s*{[^}]*}/g, `export type RoleBindingMap = Record<${resourceRoleKeyType}, ${resourceKeyType}>;`);
-        // Normalize StrategyState & related socket maps to identity-keyed Records.
-        // These are emitted as `[k: string]` by json-schema-to-typescript but are identity-keyed in practice.
-        const executionSocketValueType = 'ResourceMissing | ResourcePotentialInput | ResourcePotentialOutput | Resource';
-        ts = ts.replace(/export interface ExecutionSocket\s*\{\s*\[k:\s*string\]:\s*[^;]+;\s*\}/g, `export type ExecutionSocket = Record<${resourceRoleKeyType}, ${executionSocketValueType}>;`);
-        ts = ts.replace(/export interface StrategyState\s*\{\s*\[k:\s*string\]:\s*ExecutionSocket;\s*\}/g, `export type StrategyState = Record<${executionKeyType}, ExecutionSocket>;`);
-        ts = ts.replace(/(strategyStateUpdate\??:\s*)\{\s*\[k:\s*string\]:\s*ExecutionSocket;\s*\};/g, `$1Record<${executionKeyType}, ExecutionSocket>;`);
-        // Ensure key constraints for strategyThreadMap are preserved as template-literal identity keys.
-        // json-schema-to-typescript emits `[k: string]: Step[];`, but we want keys to be `StrategyThreadIdentity`.
-        ts = ts.replace(/export interface StrategyThreadMap\s*\{\s*\[k:\s*string\]:\s*Step\[\];\s*\}/g, `export type StrategyThreadMap = Record<${strategyThreadKeyType}, Step[]>;`);
-        parts.push(ts);
-        let output = parts.join('\n');
-        // Final guard: strip any lingering `[k: string]: unknown;` that might have been
-        // reintroduced by later transforms.
-        output = output.replace(/^\s*\[k:\s*string\]:\s*unknown;\s*$/gm, '');
-        // Cosmetic post-format: remove lone blank lines before closing braces and collapse excessive blank lines
-        // - Remove a single blank line before `};` and `}`
-        // - Collapse 3+ consecutive newlines into a maximum of 2
-        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');
-        // As an additional safeguard, make sure the final .d.ts is treated as a module.
-        // If no export/interface/module is present, append an empty export.
-        if (!/\bexport\b|\bdeclare\s+module\b|\bdeclare\s+namespace\b/.test(output)) {
-            output += '\nexport {}\n';
-        }
+        ts = postProcessEmittedTypes(ts, parsedSchema);
+        const output = finalizeOutputDts(ts);
         // Write only under configured types output folder
         try {
             fs.writeFileSync(srcLibOutputPath, output, 'utf8');
@@ -540,11 +422,9 @@ async function main() {
             console.warn('Failed to write types.js to dist/_lib:', e);
         }
     }
-    finally {
-        // No temp combined schema used.
+    catch (err) {
+        console.error(err);
+        process.exitCode = 1;
     }
 }
-main().catch((err) => {
-    console.error(err);
-    process.exitCode = 1;
-});
+void main();