@toolproof-core/schema 1.0.4 → 1.0.6

package/src/scripts/_lib/config.ts

@@ -24,10 +24,11 @@ export class SchemaConfig {
   private readonly sourceFile: string;
   private readonly normalizedDir: string;
   private readonly schemasDir: string;
+  private readonly constantsDir: string;
   private readonly resourcesDir: string;
   private readonly dependencyMapPath: string;
-  private readonly typesTsSrcDir: string;
-  private readonly typesTsDistDir: string;
+  private readonly typesSrcDir: string;
+  private readonly typesDistDir: string;
 
   // Schema metadata
   private readonly baseUrl: string;
@@ -38,14 +39,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');
   }
@@ -96,48 +96,58 @@ export class SchemaConfig {
     return path.join(this.getSchemasDir(), filename);
   }
 
-  getSchemasStandaloneDir(): string {
+  getConstantsDir(): string {
+    return path.isAbsolute(this.constantsDir)
+      ? this.constantsDir
+      : path.join(this.root, this.constantsDir);
+  }
+
+  getConstantsPath(filename: string): string {
+    return path.join(this.getConstantsDir(), filename);
+  }
+
+  getStandaloneSchemaDir(): string {
     return path.join(this.getSchemasDir(), 'standalone');
   }
 
-  getSchemaStandalonePath(filename: string): string {
-    return path.join(this.getSchemasStandaloneDir(), filename);
+  getStandaloneSchemaPath(filename: string): string {
+    return path.join(this.getStandaloneSchemaDir(), filename);
   }
 
-  getTypesTsSrcDir(): string {
-    return path.isAbsolute(this.typesTsSrcDir)
-      ? this.typesTsSrcDir
-      : path.join(this.root, this.typesTsSrcDir);
+  getTypesSrcDir(): string {
+    return path.isAbsolute(this.typesSrcDir)
+      ? this.typesSrcDir
+      : path.join(this.root, this.typesSrcDir);
   }
 
-  getTypesTsDistDir(): string {
-    return path.isAbsolute(this.typesTsDistDir)
-      ? this.typesTsDistDir
-      : path.join(this.root, this.typesTsDistDir);
+  getTypesDistDir(): string {
+    return path.isAbsolute(this.typesDistDir)
+      ? this.typesDistDir
+      : path.join(this.root, this.typesDistDir);
   }
 
-  getTypesTsSrcPath(filename: string): string {
-    return path.join(this.getTypesTsSrcDir(), filename);
+  getTypesSrcPath(filename: string): string {
+    return path.join(this.getTypesSrcDir(), filename);
   }
 
-  getTypesTsDistPath(filename: string): string {
-    return path.join(this.getTypesTsDistDir(), filename);
+  getTypesDistPath(filename: string): string {
+    return path.join(this.getTypesDistDir(), filename);
   }
 
-  getStandaloneTypeTsSrcDir(): string {
-    return path.join(this.getTypesTsSrcDir(), 'standalone');
+  getStandaloneTypeSrcDir(): string {
+    return path.join(this.getTypesSrcDir(), 'standalone');
   }
 
-  getStandaloneTypeTsDistDir(): string {
-    return path.join(this.getTypesTsDistDir(), 'standalone');
+  getStandaloneTypeDistDir(): string {
+    return path.join(this.getTypesDistDir(), 'standalone');
   }
 
-  getStandaloneTypeTsSrcPath(filename: string): string {
-    return path.join(this.getStandaloneTypeTsSrcDir(), filename);
+  getStandaloneTypeSrcPath(filename: string): string {
+    return path.join(this.getStandaloneTypeSrcDir(), filename);
   }
 
-  getStandaloneTypeTsDistPath(filename: string): string {
-    return path.join(this.getStandaloneTypeTsDistDir(), filename);
+  getStandaloneTypeDistPath(filename: string): string {
+    return path.join(this.getStandaloneTypeDistDir(), filename);
   }
 
   getResourcesDir(): string {

package/src/scripts/generateConstants.ts

@@ -0,0 +1,217 @@
+import fs from 'fs';
+import path from 'path';
+import { getConfig } from './_lib/config.js';
+
+type JSONValue = null | boolean | number | string | JSONValue[] | { [k: string]: JSONValue };
+
+export type GeneratedConstants = {
+    IDENTIFIABLES: {
+        PREFIXES: Record<string, string>;
+        NAMES: Record<string, string>;
+    };
+    ENUMS: Record<string, Record<string, string>>;
+};
+
+// PURE: Attempt to derive a canonical identity prefix from a canonical identity regex pattern.
+function deriveIdentityPrefixFromPattern(pattern: string): string | undefined {
+    // 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: unknown): Record<string, string> {
+    if (!schema || typeof schema !== 'object') return {};
+
+    const defs = (schema as any).$defs;
+    if (!defs || typeof defs !== 'object') return {};
+
+    const defEntries = Object.entries(defs as Record<string, unknown>);
+    defEntries.sort(([a], [b]) => a.localeCompare(b));
+
+    const out: Record<string, string> = {};
+
+    for (const [defName, defVal] of defEntries) {
+        if (!/Identity$/.test(defName)) continue;
+        if (!defVal || typeof defVal !== 'object' || Array.isArray(defVal)) continue;
+
+        const v: any = 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: Record<string, string>): Record<string, string> {
+    const keys = Object.keys(identityPrefixes).sort((a, b) => a.localeCompare(b));
+    const out: Record<string, string> = {};
+
+    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: unknown): Record<string, Record<string, string>> {
+    if (!schema || typeof schema !== 'object') return {};
+
+    const defs = (schema as any).$defs;
+    if (!defs || typeof defs !== 'object') return {};
+
+    const defEntries = Object.entries(defs as Record<string, unknown>);
+    defEntries.sort(([a], [b]) => a.localeCompare(b));
+
+    const out: Record<string, Record<string, string>> = {};
+
+    for (const [defName, defVal] of defEntries) {
+        if (!/(Kind|Status)$/.test(defName)) continue;
+        if (!defVal || typeof defVal !== 'object' || Array.isArray(defVal)) continue;
+
+        const v: any = defVal;
+        if (v.type !== 'string') continue;
+        if (!Array.isArray(v.enum) || v.enum.length === 0) continue;
+        if (v.enum.some((x: unknown) => typeof x !== 'string')) continue;
+
+        const members: Record<string, string> = {};
+        for (const member of v.enum as readonly string[]) {
+            members[member] = member;
+        }
+
+        out[defName] = members;
+    }
+
+    return out;
+}
+
+// PURE: Extract all generated constants from a parsed schema.
+export function extractConstants(schema: unknown): GeneratedConstants {
+    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: string): string {
+    return value
+        .replace(/\\/g, '\\\\')
+        .replace(/\r/g, '\\r')
+        .replace(/\n/g, '\\n')
+        .replace(/\t/g, '\\t')
+        .replace(/'/g, "\\'");
+}
+
+function renderTsStringLiteral(value: string): string {
+    return `'${escapeTsString(value)}'`;
+}
+
+function isValidTsIdentifier(key: string): boolean {
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key);
+}
+
+function renderTsKey(key: string): string {
+    return isValidTsIdentifier(key) ? key : renderTsStringLiteral(key);
+}
+
+// PURE: Render constants TypeScript source.
+export function renderConstantsTs(constants: GeneratedConstants): string {
+    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: string[] = [];
+    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: JSONValue = 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: any) {
+        console.error(`Error generating constants: ${error?.message ?? error}`);
+        process.exitCode = 1;
+    }
+}
+
+main();

package/src/scripts/generateSchemaShims.ts

@@ -11,7 +11,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
@@ -38,7 +38,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();
 

package/src/scripts/generateStandaloneSchema.ts

@@ -161,7 +161,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/src/scripts/{generateStandaloneTypeTS.ts → generateStandaloneType.ts}

@@ -5,14 +5,14 @@ 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: string): string {
     const header = "// Auto-generated strict composite type. Do not edit.\n";
     const ts =
-        `import type { ShellMaterializedBase, ${name} as NucleusSchema } from "../typesTS.js";\n` +
+        `import type { ShellMaterializedBase, ${name} as NucleusSchema } from "../types.js";\n` +
         `export type Resource_${name} = ShellMaterializedBase & { nucleus: NucleusSchema };\n`;
     return header + ts;
 }
@@ -70,7 +70,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") {
@@ -95,13 +95,13 @@ 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}`);
 
@@ -112,8 +112,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/src/scripts/generateTerminals.ts

@@ -0,0 +1,73 @@
+import fs from "fs";
+import path from "path";
+import { getConfig } from "./_lib/config.js";
+
+type DependencyMap = Record<string, string[]>;
+
+// PURE: Validate + normalize a dependency map loaded from JSON.
+function normalizeDependencyMap(value: unknown): DependencyMap {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Invalid dependencyMap.json: expected an object");
+  }
+
+  const input = value as Record<string, unknown>;
+  const out: DependencyMap = {};
+
+  // 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): d is string => typeof d === "string");
+  }
+
+  return out;
+}
+
+// PURE: Compute terminals (defs that are not depended-upon by any other def).
+function computeTerminalsInKeyOrder(dependencyMap: DependencyMap): string[] {
+  const keys = Object.keys(dependencyMap);
+  const dependedUpon = new Set<string>();
+
+  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) as unknown;
+
+    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: any) {
+    console.error(`Error generating terminals: ${error?.message ?? error}`);
+    process.exitCode = 1;
+  }
+}
+
+main();

package/src/scripts/{generateTypesTS.ts → generateTypes.ts}

@@ -407,10 +407,10 @@ function postProcessEmittedTypes(ts: string, parsedSchema: any): string {
 }
 
 // PURE: Add banner + formatting/guards to build the final .d.ts content.
-function finalizeOutputDts(emittedTypesTs: string): string {
+function finalizeOutputDts(emittedType: string): string {
     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.
@@ -438,8 +438,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 });
 
@@ -493,8 +493,8 @@ async function main() {
         }
 
         // 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');
@@ -504,24 +504,24 @@ async function main() {
             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) {
         console.error(err);

package/src/scripts/normalizeAnchorsToPointers.ts

@@ -2,18 +2,41 @@ 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<T>(schema: T): T {
+    const seen = new WeakMap<object, unknown>();
+
+    function walk(node: unknown): unknown {
+        if (!node || typeof node !== 'object') return node;
+
+        const existing = seen.get(node as object);
+        if (existing) return existing;
+
+        if (Array.isArray(node)) {
+            const out: unknown[] = [];
+            seen.set(node, out);
+            for (const item of node) out.push(walk(item));
+            return out;
+        }
+
+        const out: Record<string, unknown> = {};
+        seen.set(node as object, out);
+
+        for (const [key, value] of Object.entries(node as Record<string, unknown>)) {
+            if (key === '$anchor') continue;
+            out[key] = walk(value);
+        }
+
+        return out;
+    }
+
+    return walk(schema) as T;
+}
 
 // PURE: Rewrite anchor-style `$ref` strings (`#Anchor`) into JSON Pointer refs (`#/$defs/DefName`).
 function normalizeAnchorsToPointers(input: any): any {
@@ -102,6 +125,9 @@ 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');