@toolproof-core/schema 1.0.4 → 1.0.6

package/dist/scripts/_lib/config.d.ts

@@ -12,10 +12,11 @@ export declare class SchemaConfig {
     private readonly sourceFile;
     private readonly normalizedDir;
     private readonly schemasDir;
+    private readonly constantsDir;
     private readonly resourcesDir;
     private readonly dependencyMapPath;
-    private readonly typesTsSrcDir;
-    private readonly typesTsDistDir;
+    private readonly typesSrcDir;
+    private readonly typesDistDir;
     private readonly baseUrl;
     private readonly version;
     constructor();
@@ -28,16 +29,18 @@ export declare class SchemaConfig {
     getNormalizedSourcePath(): string;
     getSchemasDir(): string;
     getSchemaPath(filename: string): string;
-    getSchemasStandaloneDir(): string;
-    getSchemaStandalonePath(filename: string): string;
-    getTypesTsSrcDir(): string;
-    getTypesTsDistDir(): string;
-    getTypesTsSrcPath(filename: string): string;
-    getTypesTsDistPath(filename: string): string;
-    getStandaloneTypeTsSrcDir(): string;
-    getStandaloneTypeTsDistDir(): string;
-    getStandaloneTypeTsSrcPath(filename: string): string;
-    getStandaloneTypeTsDistPath(filename: string): string;
+    getConstantsDir(): string;
+    getConstantsPath(filename: string): string;
+    getStandaloneSchemaDir(): string;
+    getStandaloneSchemaPath(filename: string): string;
+    getTypesSrcDir(): string;
+    getTypesDistDir(): string;
+    getTypesSrcPath(filename: string): string;
+    getTypesDistPath(filename: string): string;
+    getStandaloneTypeSrcDir(): string;
+    getStandaloneTypeDistDir(): string;
+    getStandaloneTypeSrcPath(filename: string): string;
+    getStandaloneTypeDistPath(filename: string): string;
     getResourcesDir(): string;
     getDependencyMapPath(): string;
     getBaseUrl(): string;

package/dist/scripts/_lib/config.js

@@ -20,14 +20,13 @@ export class SchemaConfig {
         this.root = getEnv('TP_SCHEMA_ROOT', process.cwd());
         this.sourceDir = getEnv('TP_SCHEMA_SOURCE_DIR', 'src/');
         this.sourceFile = getEnv('TP_SCHEMA_SOURCE_FILE', 'Genesis.json');
-        // Intermediate, generated artifact produced by normalizeAnchorsToPointers.
-        // This should NOT live next to the source-of-truth schemas.
         this.normalizedDir = getEnv('TP_SCHEMA_NORMALIZED_DIR', 'src/generated/normalized');
         this.schemasDir = getEnv('TP_SCHEMA_SCHEMAS_DIR', 'src/generated/schemas');
+        this.constantsDir = getEnv('TP_SCHEMA_CONSTANTS_DIR', 'src/generated/constants');
         this.resourcesDir = getEnv('TP_SCHEMA_RESOURCES_DIR', 'src/generated/resources');
         this.dependencyMapPath = getEnv('TP_SCHEMA_DEPENDENCY_MAP_PATH', 'src/generated/dependencies/dependencyMap.json');
-        this.typesTsSrcDir = getEnv('TP_SCHEMA_TYPES_TS_SRC_DIR', 'src/generated/typesTS');
-        this.typesTsDistDir = getEnv('TP_SCHEMA_TYPES_TS_DIST_DIR', 'dist/generated/typesTS');
+        this.typesSrcDir = getEnv('TP_SCHEMA_TYPES_SRC_DIR', 'src/generated/types');
+        this.typesDistDir = getEnv('TP_SCHEMA_TYPES_DIST_DIR', 'dist/generated/types');
         this.baseUrl = getEnv('TP_SCHEMA_BASE_URL', 'https://schemas.toolproof.com');
         this.version = getEnv('TP_SCHEMA_VERSION', 'v0');
     }
@@ -68,39 +67,47 @@ export class SchemaConfig {
     getSchemaPath(filename) {
         return path.join(this.getSchemasDir(), filename);
     }
-    getSchemasStandaloneDir() {
+    getConstantsDir() {
+        return path.isAbsolute(this.constantsDir)
+            ? this.constantsDir
+            : path.join(this.root, this.constantsDir);
+    }
+    getConstantsPath(filename) {
+        return path.join(this.getConstantsDir(), filename);
+    }
+    getStandaloneSchemaDir() {
         return path.join(this.getSchemasDir(), 'standalone');
     }
-    getSchemaStandalonePath(filename) {
-        return path.join(this.getSchemasStandaloneDir(), filename);
+    getStandaloneSchemaPath(filename) {
+        return path.join(this.getStandaloneSchemaDir(), filename);
     }
-    getTypesTsSrcDir() {
-        return path.isAbsolute(this.typesTsSrcDir)
-            ? this.typesTsSrcDir
-            : path.join(this.root, this.typesTsSrcDir);
+    getTypesSrcDir() {
+        return path.isAbsolute(this.typesSrcDir)
+            ? this.typesSrcDir
+            : path.join(this.root, this.typesSrcDir);
     }
-    getTypesTsDistDir() {
-        return path.isAbsolute(this.typesTsDistDir)
-            ? this.typesTsDistDir
-            : path.join(this.root, this.typesTsDistDir);
+    getTypesDistDir() {
+        return path.isAbsolute(this.typesDistDir)
+            ? this.typesDistDir
+            : path.join(this.root, this.typesDistDir);
     }
-    getTypesTsSrcPath(filename) {
-        return path.join(this.getTypesTsSrcDir(), filename);
+    getTypesSrcPath(filename) {
+        return path.join(this.getTypesSrcDir(), filename);
     }
-    getTypesTsDistPath(filename) {
-        return path.join(this.getTypesTsDistDir(), filename);
+    getTypesDistPath(filename) {
+        return path.join(this.getTypesDistDir(), filename);
     }
-    getStandaloneTypeTsSrcDir() {
-        return path.join(this.getTypesTsSrcDir(), 'standalone');
+    getStandaloneTypeSrcDir() {
+        return path.join(this.getTypesSrcDir(), 'standalone');
     }
-    getStandaloneTypeTsDistDir() {
-        return path.join(this.getTypesTsDistDir(), 'standalone');
+    getStandaloneTypeDistDir() {
+        return path.join(this.getTypesDistDir(), 'standalone');
     }
-    getStandaloneTypeTsSrcPath(filename) {
-        return path.join(this.getStandaloneTypeTsSrcDir(), filename);
+    getStandaloneTypeSrcPath(filename) {
+        return path.join(this.getStandaloneTypeSrcDir(), filename);
     }
-    getStandaloneTypeTsDistPath(filename) {
-        return path.join(this.getStandaloneTypeTsDistDir(), filename);
+    getStandaloneTypeDistPath(filename) {
+        return path.join(this.getStandaloneTypeDistDir(), filename);
     }
     getResourcesDir() {
         return path.isAbsolute(this.resourcesDir)

package/dist/scripts/generateConstants.d.ts

@@ -0,0 +1,12 @@
+export type GeneratedConstants = {
+    IDENTIFIABLES: {
+        PREFIXES: Record<string, string>;
+        NAMES: Record<string, string>;
+    };
+    ENUMS: Record<string, Record<string, string>>;
+};
+export declare function extractIdentityPrefixes(schema: unknown): Record<string, string>;
+export declare function deriveIdentifiablesFromIdentityPrefixes(identityPrefixes: Record<string, string>): Record<string, string>;
+export declare function extractEnums(schema: unknown): Record<string, Record<string, string>>;
+export declare function extractConstants(schema: unknown): GeneratedConstants;
+export declare function renderConstantsTs(constants: GeneratedConstants): string;

package/dist/scripts/generateConstants.js

@@ -0,0 +1,179 @@
+import fs from 'fs';
+import path from 'path';
+import { getConfig } from './_lib/config.js';
+// PURE: Attempt to derive a canonical identity prefix from a canonical identity regex pattern.
+function deriveIdentityPrefixFromPattern(pattern) {
+    // Canonical (currently used across schemas): ^PREFIX-.+$
+    const match = /^\^([^$]+)\.\+\$$/.exec(pattern);
+    if (!match)
+        return undefined;
+    const prefix = match[1];
+    if (!prefix || /[`\n\r]/.test(prefix))
+        return undefined;
+    return prefix;
+}
+// PURE: Extract all identity prefixes from `$defs/*Identity` string-pattern definitions.
+export function extractIdentityPrefixes(schema) {
+    if (!schema || typeof schema !== 'object')
+        return {};
+    const defs = schema.$defs;
+    if (!defs || typeof defs !== 'object')
+        return {};
+    const defEntries = Object.entries(defs);
+    defEntries.sort(([a], [b]) => a.localeCompare(b));
+    const out = {};
+    for (const [defName, defVal] of defEntries) {
+        if (!/Identity$/.test(defName))
+            continue;
+        if (!defVal || typeof defVal !== 'object' || Array.isArray(defVal))
+            continue;
+        const v = defVal;
+        if (v.type !== 'string')
+            continue;
+        if (typeof v.pattern !== 'string')
+            continue;
+        const prefix = deriveIdentityPrefixFromPattern(v.pattern);
+        if (!prefix)
+            continue;
+        out[defName] = prefix;
+    }
+    return out;
+}
+// PURE: Derive identifiables from extracted Identity def names.
+// Example: { BranchStepIdentity: 'BRANCH_STEP-' } => { BranchStep: 'BranchStep' }
+export function deriveIdentifiablesFromIdentityPrefixes(identityPrefixes) {
+    const keys = Object.keys(identityPrefixes).sort((a, b) => a.localeCompare(b));
+    const out = {};
+    for (const key of keys) {
+        if (!key.endsWith('Identity'))
+            continue;
+        const name = key.slice(0, -'Identity'.length);
+        if (!name)
+            continue;
+        out[name] = name;
+    }
+    return out;
+}
+// PURE: Extract all string enums from `$defs/*Kind|*Status` definitions.
+// Shape: { StepKind: { job: 'job', ... }, ResourceKind: { 'input-potential': 'input-potential', ... } }
+export function extractEnums(schema) {
+    if (!schema || typeof schema !== 'object')
+        return {};
+    const defs = schema.$defs;
+    if (!defs || typeof defs !== 'object')
+        return {};
+    const defEntries = Object.entries(defs);
+    defEntries.sort(([a], [b]) => a.localeCompare(b));
+    const out = {};
+    for (const [defName, defVal] of defEntries) {
+        if (!/(Kind|Status)$/.test(defName))
+            continue;
+        if (!defVal || typeof defVal !== 'object' || Array.isArray(defVal))
+            continue;
+        const v = defVal;
+        if (v.type !== 'string')
+            continue;
+        if (!Array.isArray(v.enum) || v.enum.length === 0)
+            continue;
+        if (v.enum.some((x) => typeof x !== 'string'))
+            continue;
+        const members = {};
+        for (const member of v.enum) {
+            members[member] = member;
+        }
+        out[defName] = members;
+    }
+    return out;
+}
+// PURE: Extract all generated constants from a parsed schema.
+export function extractConstants(schema) {
+    const identityPrefixes = extractIdentityPrefixes(schema);
+    const identifiables = deriveIdentifiablesFromIdentityPrefixes(identityPrefixes);
+    const enums = extractEnums(schema);
+    return {
+        IDENTIFIABLES: {
+            PREFIXES: identityPrefixes,
+            NAMES: identifiables,
+        },
+        ENUMS: enums,
+    };
+}
+// PURE: Render helpers for TS keys/strings.
+function escapeTsString(value) {
+    return value
+        .replace(/\\/g, '\\\\')
+        .replace(/\r/g, '\\r')
+        .replace(/\n/g, '\\n')
+        .replace(/\t/g, '\\t')
+        .replace(/'/g, "\\'");
+}
+function renderTsStringLiteral(value) {
+    return `'${escapeTsString(value)}'`;
+}
+function isValidTsIdentifier(key) {
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key);
+}
+function renderTsKey(key) {
+    return isValidTsIdentifier(key) ? key : renderTsStringLiteral(key);
+}
+// PURE: Render constants TypeScript source.
+export function renderConstantsTs(constants) {
+    const prefixKeys = Object.keys(constants.IDENTIFIABLES.PREFIXES).sort((a, b) => a.localeCompare(b));
+    const nameKeys = Object.keys(constants.IDENTIFIABLES.NAMES).sort((a, b) => a.localeCompare(b));
+    const enumKeys = Object.keys(constants.ENUMS).sort((a, b) => a.localeCompare(b));
+    const lines = [];
+    lines.push('const CONSTANTS = {');
+    lines.push('    IDENTIFIABLES: {');
+    lines.push('        PREFIXES: {');
+    for (const key of prefixKeys) {
+        const value = constants.IDENTIFIABLES.PREFIXES[key] ?? '';
+        lines.push(`            ${renderTsKey(key)}: ${renderTsStringLiteral(value)},`);
+    }
+    lines.push('        },');
+    lines.push('        NAMES: {');
+    for (const key of nameKeys) {
+        const value = constants.IDENTIFIABLES.NAMES[key] ?? '';
+        lines.push(`            ${renderTsKey(key)}: ${renderTsStringLiteral(value)},`);
+    }
+    lines.push('        },');
+    lines.push('    },');
+    lines.push('    ENUMS: {');
+    for (const key of enumKeys) {
+        const members = constants.ENUMS[key] ?? {};
+        lines.push(`        ${renderTsKey(key)}: {`);
+        for (const memberKey of Object.keys(members)) {
+            const value = members[memberKey] ?? '';
+            lines.push(`            ${renderTsKey(memberKey)}: ${renderTsStringLiteral(value)},`);
+        }
+        lines.push('        },');
+    }
+    lines.push('    }');
+    lines.push('} as const;');
+    lines.push('');
+    lines.push('export default CONSTANTS;');
+    lines.push('');
+    return lines.join('\n');
+}
+// IMPURE: Script entrypoint (config + filesystem I/O + console + process exit code).
+function main() {
+    try {
+        const config = getConfig();
+        const inPath = config.getSchemaPath('Genesis.json');
+        const outPath = config.getConstantsPath('constants.ts');
+        if (!fs.existsSync(inPath)) {
+            throw new Error(`Genesis schema not found at ${inPath}. Run extractSchemasFromResourceTypeShells first.`);
+        }
+        const raw = fs.readFileSync(inPath, 'utf8');
+        const doc = JSON.parse(raw);
+        const constants = extractConstants(doc);
+        const ts = renderConstantsTs(constants);
+        fs.mkdirSync(path.dirname(outPath), { recursive: true });
+        fs.writeFileSync(outPath, ts, 'utf8');
+        console.log(`Wrote constants to ${outPath}`);
+    }
+    catch (error) {
+        console.error(`Error generating constants: ${error?.message ?? error}`);
+        process.exitCode = 1;
+    }
+}
+main();

package/dist/scripts/generateSchemaShims.js

@@ -10,7 +10,7 @@ import { getConfig } from './_lib/config.js';
  *
  * Generates shims for:
  * - schemas dir: config.getSchemasDir() (schema files)
- * - standalone schemas dir: config.getSchemasStandaloneDir() (standalone schema files)
+ * - standalone schemas dir: config.getStandaloneSchemaDir() (standalone schema files)
  * - resources dir: config.getResourcesDir() (resource envelope files)
  *
  * Usage: node ./dist/scripts/generateSchemaShims.js
@@ -34,7 +34,7 @@ function main() {
     try {
         const config = getConfig();
         const schemasDir = config.getSchemasDir();
-        const standaloneSchemasDir = config.getSchemasStandaloneDir();
+        const standaloneSchemasDir = config.getStandaloneSchemaDir();
         const resourcesDir = config.getResourcesDir();
         const generatedResourceTypesDir = config.getNormalizedDir();
         let totalCount = 0;

package/dist/scripts/generateStandaloneSchema.js

@@ -154,7 +154,7 @@ async function main() {
         }
         const schemasDir = config.getSchemasDir();
         const genesisPath = path.join(schemasDir, config.getSourceFile());
-        const outPath = config.getSchemaStandalonePath(`${name}.json`);
+        const outPath = config.getStandaloneSchemaPath(`${name}.json`);
         if (!fs.existsSync(genesisPath)) {
             throw new Error(`Genesis.json not found at ${genesisPath}. Run extractSchemasFromResourceTypeShells first.`);
         }

package/dist/scripts/{generateStandaloneTypeTS.js → generateStandaloneType.js}

@@ -4,12 +4,12 @@ import { getConfig } from "./_lib/config.js";
  * Generate a typed Resource variant where `nucleus` is typed to a specific schema
  * extracted under the configured output directory.
  *
- * Usage: node ./dist/scripts/generateStandaloneType.js --name Job
+ * Usage: node ./dist/scripts/generateStandaloneTypes.js --name Job
  */
 // PURE: Generate the content of a standalone Resource type definition file for a given schema name.
 function generateStandaloneTypeLogic(name) {
     const header = "// Auto-generated strict composite type. Do not edit.\n";
-    const ts = `import type { ShellMaterializedBase, ${name} as NucleusSchema } from "../typesTS.js";\n` +
+    const ts = `import type { ShellMaterializedBase, ${name} as NucleusSchema } from "../types.js";\n` +
         `export type Resource_${name} = ShellMaterializedBase & { nucleus: NucleusSchema };\n`;
     return header + ts;
 }
@@ -57,7 +57,7 @@ function main() {
         }
         const inPath = name === "Genesis"
             ? config.getSchemaPath("Genesis.json")
-            : config.getSchemaStandalonePath(`${name}.json`);
+            : config.getStandaloneSchemaPath(`${name}.json`);
         if (!fs.existsSync(inPath)) {
             if (name === "Genesis") {
                 console.error(`Schema file not found: ${inPath}`);
@@ -79,12 +79,12 @@ function main() {
         // Output setup
         const outName = `Resource_${name}.d.ts`;
         const outJsName = `Resource_${name}.js`;
-        const outDir = config.getStandaloneTypeTsSrcDir();
-        const distLibDir = config.getStandaloneTypeTsDistDir();
+        const outDir = config.getStandaloneTypeSrcDir();
+        const distLibDir = config.getStandaloneTypeDistDir();
         // Process src output
         fs.mkdirSync(outDir, { recursive: true });
-        const outPath = config.getStandaloneTypeTsSrcPath(outName);
-        const outJsPath = config.getStandaloneTypeTsSrcPath(outJsName);
+        const outPath = config.getStandaloneTypeSrcPath(outName);
+        const outJsPath = config.getStandaloneTypeSrcPath(outJsName);
         fs.writeFileSync(outPath, tsContent, "utf8");
         console.log(`Wrote ${outPath}`);
         if (!fs.existsSync(outJsPath)) {
@@ -93,8 +93,8 @@ function main() {
         }
         // Process dist output
         fs.mkdirSync(distLibDir, { recursive: true });
-        const distDtsPath = config.getStandaloneTypeTsDistPath(outName);
-        const distJsPath = config.getStandaloneTypeTsDistPath(outJsName);
+        const distDtsPath = config.getStandaloneTypeDistPath(outName);
+        const distJsPath = config.getStandaloneTypeDistPath(outJsName);
         fs.writeFileSync(distDtsPath, tsContent, "utf8");
         fs.writeFileSync(distJsPath, jsContent, "utf8");
         console.log(`Wrote ${distDtsPath}`);

package/dist/scripts/generateTerminals.js

@@ -0,0 +1,58 @@
+import fs from "fs";
+import path from "path";
+import { getConfig } from "./_lib/config.js";
+// PURE: Validate + normalize a dependency map loaded from JSON.
+function normalizeDependencyMap(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("Invalid dependencyMap.json: expected an object");
+    }
+    const input = value;
+    const out = {};
+    // Preserve insertion order from the parsed JSON object.
+    for (const [key, rawDeps] of Object.entries(input)) {
+        if (rawDeps == null) {
+            out[key] = [];
+            continue;
+        }
+        if (!Array.isArray(rawDeps)) {
+            throw new Error(`Invalid dependencyMap.json: value for ${key} must be an array`);
+        }
+        out[key] = rawDeps.filter((d) => typeof d === "string");
+    }
+    return out;
+}
+// PURE: Compute terminals (defs that are not depended-upon by any other def).
+function computeTerminalsInKeyOrder(dependencyMap) {
+    const keys = Object.keys(dependencyMap);
+    const dependedUpon = new Set();
+    for (const key of keys) {
+        for (const dep of dependencyMap[key] ?? []) {
+            dependedUpon.add(dep);
+        }
+    }
+    // Preserve key order from dependencyMap.json.
+    return keys.filter((k) => !dependedUpon.has(k));
+}
+// IMPURE: Script entrypoint (config + filesystem I/O + console + process exit code).
+function main() {
+    try {
+        const config = getConfig();
+        const inPath = config.getDependencyMapPath();
+        const outPath = path.join(path.dirname(inPath), "terminals.json");
+        if (!fs.existsSync(inPath)) {
+            throw new Error(`Dependency map not found at ${inPath}. Run generateDependencies first.`);
+        }
+        const raw = fs.readFileSync(inPath, "utf8");
+        const parsed = JSON.parse(raw);
+        const dependencyMap = normalizeDependencyMap(parsed);
+        const terminals = computeTerminalsInKeyOrder(dependencyMap);
+        fs.mkdirSync(path.dirname(outPath), { recursive: true });
+        fs.writeFileSync(outPath, JSON.stringify(terminals, null, 4), "utf8");
+        console.log(`Wrote terminals to ${outPath}`);
+    }
+    catch (error) {
+        console.error(`Error generating terminals: ${error?.message ?? error}`);
+        process.exitCode = 1;
+    }
+}
+main();

package/dist/scripts/generateTypes.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/{generateTypesTS.js → generateTypes.js}

@@ -322,9 +322,9 @@ function postProcessEmittedTypes(ts, parsedSchema) {
     return ts;
 }
 // PURE: Add banner + formatting/guards to build the final .d.ts content.
-function finalizeOutputDts(emittedTypesTs) {
+function finalizeOutputDts(emittedType) {
     const banner = '// Auto-generated from JSON schemas. Do not edit.\n';
-    let output = banner + '\n' + emittedTypesTs + '\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, '');
@@ -347,8 +347,8 @@ async function main() {
     try {
         const config = getConfig();
         const inputDir = config.getSchemasDir();
-        const srcLibTypesDir = config.getTypesTsSrcDir();
-        const srcLibOutputPath = config.getTypesTsSrcPath('typesTS.d.ts');
+        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);
@@ -389,8 +389,8 @@ async function main() {
             console.warn('Failed to write types to src/_lib:', e);
         }
         // Also write a copy into dist so consumers get the generated declarations
-        const distLibTypesDir = config.getTypesTsDistDir();
-        const distLibOutputPath = config.getTypesTsDistPath('typesTS.d.ts');
+        const distLibTypesDir = config.getTypesDistDir();
+        const distLibOutputPath = config.getTypesDistPath('types.d.ts');
         try {
             fs.mkdirSync(distLibTypesDir, { recursive: true });
             fs.writeFileSync(distLibOutputPath, output, 'utf8');
@@ -400,26 +400,26 @@ async function main() {
             // If copying to dist fails, log but don't crash the generator.
             console.warn('Failed to write types to dist:', e);
         }
-        // Ensure there is a runtime-resolvable module next to `typesTS.d.ts`
+        // Ensure there is a runtime-resolvable module next to `types.d.ts`
         // Some consumers and TS NodeNext resolution expect a concrete .js next to .d.ts
         // The file is intentionally empty as all exports are types-only.
         try {
-            const srcLibTypesJsPath = config.getTypesTsSrcPath('typesTS.js');
+            const srcLibTypesJsPath = config.getTypesSrcPath('types.js');
             if (!fs.existsSync(srcLibTypesJsPath)) {
                 fs.writeFileSync(srcLibTypesJsPath, 'export {}\n', 'utf8');
                 console.log('Wrote', srcLibTypesJsPath);
             }
         }
         catch (e) {
-            console.warn('Failed to write typesTS.js to src/_lib:', e);
+            console.warn('Failed to write types.js to src/_lib:', e);
         }
         try {
-            const distLibTypesJsPath = config.getTypesTsDistPath('typesTS.js');
+            const distLibTypesJsPath = config.getTypesDistPath('types.js');
             fs.writeFileSync(distLibTypesJsPath, 'export {}\n', 'utf8');
             console.log('Wrote', distLibTypesJsPath);
         }
         catch (e) {
-            console.warn('Failed to write typesTS.js to dist/_lib:', e);
+            console.warn('Failed to write types.js to dist/_lib:', e);
         }
     }
     catch (err) {

package/dist/scripts/normalizeAnchorsToPointers.d.ts

@@ -1 +1 @@
-export {};
+export declare function stripAnchors<T>(schema: T): T;

package/dist/scripts/normalizeAnchorsToPointers.js

@@ -1,18 +1,37 @@
 import fs from 'fs';
 import path from 'path';
 import { getConfig } from './_lib/config.js';
-/**
- * Rewrite anchor-style references to JSON Pointer references in Genesis.json
- *
- * Converts #AnchorName to #/$defs/AnchorName for compatibility with strict
- * JSON Schema validators and downstream tooling. This normalization step runs
- * before both schema extraction and resource envelope generation.
- *
- * The rewritten file is saved under src/genesis/generated/resourceTypes/Genesis.json
- * for use by other scripts.
- *
- * Usage: node ./dist/scripts/normalizeAnchorsToPointers.js
- */
+/*
+    * Rewrite anchor-style references to JSON Pointer references in Genesis.json.
+    * We also strip all $anchor fields from the output since they are no longer needed after rewriting refs.
+*/
+// PURE: Remove all `$anchor` keys from a schema tree without rewriting refs.
+export function stripAnchors(schema) {
+    const seen = new WeakMap();
+    function walk(node) {
+        if (!node || typeof node !== 'object')
+            return node;
+        const existing = seen.get(node);
+        if (existing)
+            return existing;
+        if (Array.isArray(node)) {
+            const out = [];
+            seen.set(node, out);
+            for (const item of node)
+                out.push(walk(item));
+            return out;
+        }
+        const out = {};
+        seen.set(node, out);
+        for (const [key, value] of Object.entries(node)) {
+            if (key === '$anchor')
+                continue;
+            out[key] = walk(value);
+        }
+        return out;
+    }
+    return walk(schema);
+}
 // PURE: Rewrite anchor-style `$ref` strings (`#Anchor`) into JSON Pointer refs (`#/$defs/DefName`).
 function normalizeAnchorsToPointers(input) {
     if (!input || typeof input !== "object")
@@ -90,6 +109,8 @@ function main() {
         }
         // Rewrite anchors in the nucleusSchema (pure function call)
         genesis.nucleusSchema = normalizeAnchorsToPointers(genesis.nucleusSchema);
+        // Strip $anchor fields from the schemas (pure function call)
+        genesis.nucleusSchema = stripAnchors(genesis.nucleusSchema);
         // Write normalized version
         fs.mkdirSync(path.dirname(normalizedPath), { recursive: true });
         fs.writeFileSync(normalizedPath, JSON.stringify(genesis, null, 4), 'utf-8');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toolproof-core/schema",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "JSON schemas and TypeScript types for ToolProof",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -34,12 +34,14 @@
     "normalizeAnchorsToPointers": "node ./dist/scripts/normalizeAnchorsToPointers.js",
     "extractSchemasFromResourceTypeShells": "node ./dist/scripts/extractSchemasFromResourceTypeShells.js",
     "generateStandaloneSchema": "node ./dist/scripts/generateStandaloneSchema.js",
-    "generateTypesTS": "node ./dist/scripts/generateTypesTS.js",
-    "generateStandaloneTypeTS": "node ./dist/scripts/generateStandaloneTypeTS.js",
+    "generateTypes": "node ./dist/scripts/generateTypes.js",
+    "generateStandaloneType": "node ./dist/scripts/generateStandaloneType.js",
     "wrapResourceTypesWithResourceShells": "node ./dist/scripts/wrapResourceTypesWithResourceShells.js",
     "generateSchemaShims": "node ./dist/scripts/generateSchemaShims.js",
     "generateDependencies": "node ./dist/scripts/generateDependencies.js",
-    "generateResourceTypeGenesisType": "node ./dist/scripts/generateStandaloneTypeTS.js --name Genesis",
-    "update": "rimraf /s /q dist && pnpm run build:scripts && pnpm run normalizeAnchorsToPointers && pnpm run extractSchemasFromResourceTypeShells && pnpm run generateStandaloneSchema -- --name Job && pnpm run generateStandaloneSchema -- --name ResourceType && pnpm run generateStandaloneSchema -- --name RawStrategy && pnpm run generateStandaloneSchema -- --name RunnableStrategy && pnpm run generateStandaloneSchema -- --name StrategyRun && pnpm run generateStandaloneSchema -- --name Goal && pnpm run wrapResourceTypesWithResourceShells && pnpm run generateSchemaShims && pnpm run generateTypesTS && pnpm run generateStandaloneTypeTS -- --name Job && pnpm run generateStandaloneTypeTS -- --name ResourceType && pnpm run generateStandaloneTypeTS -- --name RawStrategy && pnpm run generateStandaloneTypeTS -- --name RunnableStrategy && pnpm run generateResourceTypeGenesisType && pnpm run generateDependencies && pnpm run build"
+    "generateConstants": "node ./dist/scripts/generateConstants.js",
+    "generateTerminals": "node ./dist/scripts/generateTerminals.js",
+    "generateResourceTypeGenesisType": "node ./dist/scripts/generateStandaloneType.js --name Genesis",
+    "update": "rimraf /s /q dist && pnpm run build:scripts && pnpm run normalizeAnchorsToPointers && pnpm run extractSchemasFromResourceTypeShells && pnpm run generateConstants && pnpm run generateStandaloneSchema -- --name Job && pnpm run generateStandaloneSchema -- --name ResourceType && pnpm run generateStandaloneSchema -- --name RawStrategy && pnpm run generateStandaloneSchema -- --name RunnableStrategy && pnpm run generateStandaloneSchema -- --name StrategyRun && pnpm run generateStandaloneSchema -- --name Goal && pnpm run wrapResourceTypesWithResourceShells && pnpm run generateSchemaShims && pnpm run generateTypes && pnpm run generateStandaloneType -- --name Job && pnpm run generateStandaloneType -- --name ResourceType && pnpm run generateStandaloneType -- --name RawStrategy && pnpm run generateStandaloneType -- --name RunnableStrategy && pnpm run generateResourceTypeGenesisType && pnpm run generateDependencies && pnpm run generateTerminals && pnpm run build"
   }
 }