@toolproof-core/schema 1.0.0 → 1.0.1

package/src/generated/types/types.js

@@ -1 +1 @@
-export {}
+export {}

package/src/scripts/_lib/config.ts

@@ -23,11 +23,11 @@ export class SchemaConfig {
   private readonly sourceDir: string;
   private readonly sourceFile: string;
   private readonly normalizedDir: string;
-  private readonly outputDir: string;
+  private readonly schemasDir: string;
+  private readonly resourcesDir: string;
+  private readonly dependencyMapPath: string;
   private readonly typesSrcDir: string;
   private readonly typesDistDir: string;
-  private readonly generatedResourcesDir: string;
-  private readonly dependencyMapPath: string;
 
   // Schema metadata
   private readonly baseUrl: string;
@@ -38,14 +38,14 @@ 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 rewriteAnchors.
+    // 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/resourceTypes');
-    this.outputDir = getEnv('TP_SCHEMA_OUTPUT_DIR', 'src/generated/schemas');
+    this.normalizedDir = getEnv('TP_SCHEMA_NORMALIZED_DIR', 'src/generated/normalized');
+    this.schemasDir = getEnv('TP_SCHEMA_SCHEMAS_DIR', 'src/generated/schemas');
+    this.resourcesDir = getEnv('TP_SCHEMA_RESOURCES_DIR', 'src/generated/resources');
+    this.dependencyMapPath = getEnv('TP_SCHEMA_DEPENDENCY_MAP_PATH', 'src/generated/dependencyMap.json');
     this.typesSrcDir = getEnv('TP_SCHEMA_TYPES_SRC_DIR', 'src/generated/types');
     this.typesDistDir = getEnv('TP_SCHEMA_TYPES_DIST_DIR', 'dist/generated/types');
-    this.generatedResourcesDir = getEnv('TP_SCHEMA_RESOURCES_DIR', 'src/generated/resources');
-    this.dependencyMapPath = getEnv('TP_SCHEMA_DEPENDENCY_MAP_PATH', 'src/generated/dependencies.json');
     this.baseUrl = getEnv('TP_SCHEMA_BASE_URL', 'https://schemas.toolproof.com');
     this.version = getEnv('TP_SCHEMA_VERSION', 'v0');
   }
@@ -86,14 +86,22 @@ export class SchemaConfig {
     return path.join(this.getNormalizedDir(), this.getNormalizedSourceFile());
   }
 
-  getOutputDir(): string {
-    return path.isAbsolute(this.outputDir)
-      ? this.outputDir
-      : path.join(this.root, this.outputDir);
+  getSchemasDir(): string {
+    return path.isAbsolute(this.schemasDir)
+      ? this.schemasDir
+      : path.join(this.root, this.schemasDir);
+  }
+
+  getSchemaPath(filename: string): string {
+    return path.join(this.getSchemasDir(), filename);
   }
 
-  getOutputPath(filename: string): string {
-    return path.join(this.getOutputDir(), filename);
+  getSchemasStandaloneDir(): string {
+    return path.join(this.getSchemasDir(), 'standalone');
+  }
+
+  getSchemaStandalonePath(filename: string): string {
+    return path.join(this.getSchemasStandaloneDir(), filename);
   }
 
   getTypesSrcDir(): string {
@@ -116,10 +124,26 @@ export class SchemaConfig {
     return path.join(this.getTypesDistDir(), filename);
   }
 
-  getGeneratedResourcesDir(): string {
-    return path.isAbsolute(this.generatedResourcesDir)
-      ? this.generatedResourcesDir
-      : path.join(this.root, this.generatedResourcesDir);
+  getTypesStandaloneSrcDir(): string {
+    return path.join(this.getTypesSrcDir(), 'standalone');
+  }
+
+  getTypesStandaloneDistDir(): string {
+    return path.join(this.getTypesDistDir(), 'standalone');
+  }
+
+  getTypesStandaloneSrcPath(filename: string): string {
+    return path.join(this.getTypesStandaloneSrcDir(), filename);
+  }
+
+  getTypesStandaloneDistPath(filename: string): string {
+    return path.join(this.getTypesStandaloneDistDir(), filename);
+  }
+
+  getResourcesDir(): string {
+    return path.isAbsolute(this.resourcesDir)
+      ? this.resourcesDir
+      : path.join(this.root, this.resourcesDir);
   }
 
   getDependencyMapPath(): string {

package/src/scripts/extractSchemasFromResourceTypeShells.ts

@@ -0,0 +1,218 @@
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { getConfig } from "./_lib/config.js";
+
+type JSONValue = null | boolean | number | string | JSONValue[] | { [k: string]: JSONValue };
+
+interface ExtractOptions {
+    inPath: string;
+    outPath: string;
+    topLevelId?: string;
+}
+
+function parseArgs(): ExtractOptions {
+    const config = getConfig();
+    const argv = process.argv.slice(2);
+    let inPath = "";
+    let outPath = "";
+    let topLevelId: string | undefined;
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "--in" && i + 1 < argv.length) inPath = argv[++i];
+        else if (a === "--out" && i + 1 < argv.length) outPath = argv[++i];
+        else if (a === "--id" && i + 1 < argv.length) {
+            let v = argv[++i];
+            // Strip accidental surrounding quotes from PowerShell/cmd
+            if ((v.startsWith("'") && v.endsWith("'")) || (v.startsWith('"') && v.endsWith('"'))) {
+                v = v.slice(1, -1);
+            }
+            topLevelId = v;
+        }
+    }
+
+    // Use config defaults if not provided via CLI
+    if (!inPath) {
+        // Use generated/normalized version with anchor refs rewritten to pointers
+        inPath = config.getNormalizedSourcePath();
+    }
+    if (!outPath) {
+        outPath = config.getSchemaPath(config.getSourceFile());
+    }
+    if (!topLevelId) {
+        topLevelId = config.getSchemaId('Genesis');
+    }
+
+    // Resolve to absolute paths from project root
+    const cwd = config.getRoot();
+    const wasInRelative = !path.isAbsolute(inPath);
+    const wasOutRelative = !path.isAbsolute(outPath);
+    if (wasInRelative) inPath = path.join(cwd, inPath);
+    if (wasOutRelative) outPath = path.join(cwd, outPath);
+    // Fallback: resolve relative to script directory if not found
+    const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+    if (!fs.existsSync(inPath) && wasInRelative) inPath = path.resolve(scriptDir, inPath);
+    const outDir = path.dirname(outPath);
+    if (!fs.existsSync(outDir) && wasOutRelative) {
+        // Try making directory relative to script dir
+        const altOut = path.resolve(scriptDir, outPath);
+        const altOutDir = path.dirname(altOut);
+        if (!fs.existsSync(path.dirname(outPath))) {
+            // Prefer creating outDir at cwd location if possible; otherwise fallback below when writing
+        } else {
+            outPath = altOut;
+        }
+    }
+    return { inPath, outPath, topLevelId };
+}
+
+// ATTENTION: we don't want heuristic behavior.
+// Heuristic: determine if a node is a Type shell
+function isTypeShell(node: any): boolean {
+    return (
+        node && typeof node === "object" && !Array.isArray(node) &&
+        // Treat any object that has an 'nucleusSchema' AND 'identity' as a Type shell
+        // This prevents false positives where 'nucleusSchema' is just a regular schema property
+        node.nucleusSchema && typeof node.nucleusSchema === "object" &&
+        node.identity && typeof node.identity === "string"
+    );
+}
+
+// Merge $defs into target, without overwriting existing keys unless identical
+function mergeDefs(target: Record<string, JSONValue>, source?: any, label?: string) {
+    if (!source || typeof source !== "object") return;
+    const src = (source as any)["$defs"];
+    if (!src || typeof src !== "object") return;
+    for (const [k, v] of Object.entries(src)) {
+        if (!(k in target)) {
+            target[k] = v as JSONValue;
+        } else {
+            // Best-effort: if duplicate key, require structural equality; otherwise, namespace
+            const existing = JSON.stringify(target[k]);
+            const incoming = JSON.stringify(v);
+            if (existing !== incoming) {
+                const altKey = `${k}__from_${(label || "defs").replace(/[^A-Za-z0-9_]+/g, "_")}`;
+                if (!(altKey in target)) target[altKey] = v as JSONValue;
+            }
+        }
+    }
+}
+
+// Deeply traverse an object replacing any Type shell with its nucleusSchema,
+// and hoist its inner $defs to topDefs. Prevent infinite recursion with a visited set.
+function unwrapTypes(node: JSONValue, topDefs: Record<string, JSONValue>, labelPath: string[] = [], visited = new Set<any>()): JSONValue {
+    if (node && typeof node === "object") {
+        if (visited.has(node)) return node; // avoid cycles
+        visited.add(node);
+    }
+
+    if (isTypeShell(node)) {
+        const env = node as any;
+        const inner = env.nucleusSchema;
+        // Hoist inner $defs before stripping
+        mergeDefs(topDefs, inner, labelPath.join("_"));
+        // Return the inner schema itself, after also unwrapping any nested shells it may contain
+        const unwrappedInner = unwrapTypes(inner as JSONValue, topDefs, labelPath.concat([String(env.identity || "env")]), visited);
+        return unwrappedInner;
+    }
+
+    if (Array.isArray(node)) {
+        return node.map((v, i) => unwrapTypes(v, topDefs, labelPath.concat([String(i)]), visited)) as JSONValue;
+    }
+
+    if (node && typeof node === "object") {
+        const out: Record<string, JSONValue> = {};
+        for (const [k, v] of Object.entries(node)) {
+            if (k === "$defs" && v && typeof v === "object" && !Array.isArray(v)) {
+                // Process nested $defs: unwrap each entry value if it's a Type shell
+                const defsOut: Record<string, JSONValue> = {};
+                for (const [dk, dv] of Object.entries(v as any)) {
+                    const unwrapped = unwrapTypes(dv as JSONValue, topDefs, labelPath.concat(["$defs", dk]), visited);
+                    defsOut[dk] = unwrapped;
+                }
+                out[k] = defsOut;
+            } else {
+                out[k] = unwrapTypes(v as JSONValue, topDefs, labelPath.concat([k]), visited);
+            }
+        }
+        return out;
+    }
+
+    return node;
+}
+
+/**
+ * Pure function that takes a schema document and options, and returns the flattened schema.
+ * Performs no I/O operations.
+ */
+function extractSchemaLogic(doc: any, topLevelId?: string): any {
+    if (!doc || typeof doc !== "object" || !doc.nucleusSchema) {
+        throw new Error("Input must be a Type JSON with an nucleusSchema at the top level");
+    }
+
+    const topSchema = (doc as any).nucleusSchema;
+
+    // Collect $defs so that any '#/$defs/...' pointers can be resolved from the root.
+    const outDefs: Record<string, JSONValue> = {};
+    // Seed with top-level $defs (if any) before unwrapping
+    mergeDefs(outDefs, topSchema, "top");
+
+    // Unwrap the entire top schema tree so that any nested Type shells become raw schemas
+    const flattened = unwrapTypes(topSchema as JSONValue, outDefs, ["nucleusSchema"]);
+
+    // Assemble output: force $schema, optionally set $id, hoist collected $defs
+    let base: any;
+    if (flattened && typeof flattened === "object" && !Array.isArray(flattened)) {
+        base = { ...(flattened as any) };
+    } else {
+        // If flattened is not an object (should be rare for a top-level schema), wrap it
+        base = { const: flattened };
+    }
+    // Assemble, but avoid duplicating $id: if the flattened base already has $id, prefer it.
+    const output: Record<string, JSONValue> = {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        ...base,
+    };
+    if (topLevelId && !(output as any).$id) {
+        (output as any).$id = topLevelId;
+    }
+
+    // Enforce presence of $id: schema must declare an absolute identity.
+    if (!(output as any).$id) {
+        throw new Error(
+            "Flattened schema must define $id. Provide it via CLI --id or include $id in the source nucleusSchema."
+        );
+    }
+
+    // Hoist collected defs into output.$defs, taking care not to clobber any existing
+    if (!("$defs" in output)) output.$defs = {} as any;
+    const finalDefs: Record<string, JSONValue> = (output.$defs as any) || {};
+    for (const [k, v] of Object.entries(outDefs)) {
+        if (!(k in finalDefs)) finalDefs[k] = v;
+    }
+    output.$defs = finalDefs as any;
+
+    // Preserve natural key ordering (do not reorder for readability)
+    return output;
+}
+
+function main() {
+    const { inPath, outPath, topLevelId } = parseArgs();
+
+    if (!fs.existsSync(inPath)) {
+        console.error(`Input file not found at ${inPath}`);
+        process.exit(1);
+    }
+
+    const raw = fs.readFileSync(inPath, "utf8");
+    const doc = JSON.parse(raw);
+
+    // Core logic is now in a pure function
+    const ordered = extractSchemaLogic(doc, topLevelId);
+
+    fs.mkdirSync(path.dirname(outPath), { recursive: true });
+    fs.writeFileSync(outPath, JSON.stringify(ordered, null, 4), "utf8");
+    console.log(`Wrote flattened schema to ${outPath}`);
+}
+
+main();

package/src/scripts/generateDependencies.ts

@@ -91,11 +91,11 @@ function generateDependencyMapLogic(doc: any): Record<string, string[]> {
 async function main() {
   const config = getConfig();
 
-  const inPath = config.getOutputPath("Genesis.json");
+  const inPath = config.getSchemaPath("Genesis.json");
   const outPath = config.getDependencyMapPath();
 
   if (!fs.existsSync(inPath)) {
-    console.error(`Genesis schema not found at ${inPath}. Run extractSchemas first.`);
+    console.error(`Genesis schema not found at ${inPath}. Run extractSchemasFromResourceTypeShells first.`);
     process.exit(1);
   }
 

package/src/scripts/generateSchemaShims.ts

@@ -10,8 +10,9 @@ import { getConfig } from './_lib/config.js';
  * and type inference when importing schemas in TypeScript.
  * 
  * Generates shims for:
- * - src/genesis/generated/schemas/*.json (schema files)
- * - src/genesis/generated/resources/*.json (resource envelope files)
+ * - schemas dir: config.getSchemasDir() (schema files)
+ * - standalone schemas dir: config.getSchemasStandaloneDir() (standalone schema files)
+ * - resources dir: config.getResourcesDir() (resource envelope files)
  * 
  * Usage: node ./dist/scripts/generateSchemaShims.js
  */
@@ -45,8 +46,9 @@ function getShimsForFiles(jsonFiles: string[], variableName: string): Record<str
 
 async function main() {
     const config = getConfig();
-    const schemasDir = config.getOutputDir();
-    const resourcesDir = config.getGeneratedResourcesDir();
+    const schemasDir = config.getSchemasDir();
+    const standaloneSchemasDir = config.getSchemasStandaloneDir();
+    const resourcesDir = config.getResourcesDir();
     const generatedResourceTypesDir = config.getNormalizedDir();
 
     let totalCount = 0;
@@ -69,6 +71,24 @@ async function main() {
         console.warn(`Schemas directory not found at ${schemasDir}`);
     }
 
+    // Process standalone schemas directory
+    if (fs.existsSync(standaloneSchemasDir)) {
+        const files = fs.readdirSync(standaloneSchemasDir);
+        const jsonFiles = files.filter(f => f.endsWith('.json') && !f.startsWith('.'));
+
+        const shims = getShimsForFiles(jsonFiles, 'schema');
+
+        for (const [tsFile, content] of Object.entries(shims)) {
+            const tsPath = path.join(standaloneSchemasDir, tsFile);
+            fs.writeFileSync(tsPath, content, 'utf-8');
+            console.log(`Generated ${tsFile} in ${standaloneSchemasDir}`);
+            totalCount++;
+        }
+        console.log(`Generated ${jsonFiles.length} TypeScript standalone schema shims in ${standaloneSchemasDir}`);
+    } else {
+        // Standalone schemas are optional
+    }
+
     // Process resources directory
     if (fs.existsSync(resourcesDir)) {
         const files = fs.readdirSync(resourcesDir);

package/src/scripts/{extractSubSchemaWithDefs.ts → generateStandaloneSchema.ts}

@@ -3,26 +3,18 @@ import path from 'path';
 import { getConfig } from './_lib/config.js';
 
 /**
- * Generic extractor: given a subschema name that exists under Genesis.json $defs,
- * produce a standalone JSON Schema file that contains that subschema plus an inner $defs
- * object holding all direct & transitive local $defs dependencies (by #/$defs/... $ref).
- *
- * Genesis.json itself is left unchanged.
+ * Create a standalone JSON Schema for a single $defs entry under Genesis.json,
+ * embedding all direct & transitive local $defs dependencies.
  *
  * Usage:
- *   node ./dist/scripts/extractSubschemaWithDefs.js --name <DefName>
- *
- * Writes: src/genesis/generated/schemas/<DefName>.json
+ *   node ./dist/scripts/generateStandaloneSchema.js --name <DefName>
  */
+
 /**
- * Pure function to extract a subschema and its dependencies from a genesis object.
+ * Pure function to extract a subschema and its dependencies from a flattened genesis schema.
  * Performs no I/O operations.
- * 
- * @param genesis The root Genesis schema object
- * @param name The name of the definition to extract
- * @returns The standalone subschema
  */
-function extractSubSchemaLogic(genesis: any, name: string): any {
+function extractStandaloneSubschemaLogic(genesis: any, name: string): any {
   const rootDefs: Record<string, any> | undefined = genesis.$defs;
   if (!rootDefs || typeof rootDefs !== 'object') {
     throw new Error('No $defs object found in Genesis.json');
@@ -33,14 +25,11 @@ function extractSubSchemaLogic(genesis: any, name: string): any {
     throw new Error(`Subschema named '${name}' not found under $defs in Genesis.json`);
   }
 
-  // Collect transitive local $defs names referenced by target
   const needed = collectLocalDefClosure(target, rootDefs);
 
-  // Build output schema: clone target and attach collected subset as $defs
   const targetClone = deepClone(target);
   const defsOut: Record<string, any> = {};
   for (const defName of needed) {
-    // Avoid including the target itself inside its own $defs (mirrors previous pattern)
     if (defName === name) continue;
     const defSchema = rootDefs[defName];
     if (defSchema === undefined) {
@@ -50,7 +39,6 @@ function extractSubSchemaLogic(genesis: any, name: string): any {
     defsOut[defName] = deepClone(defSchema);
   }
 
-  // Merge any pre-existing inner $defs of targetClone (if present) giving precedence to collected ones
   const existingInner = isObject(targetClone.$defs) ? targetClone.$defs : {};
   targetClone.$defs = { ...existingInner, ...defsOut };
 
@@ -65,12 +53,12 @@ async function main() {
     process.exit(1);
   }
 
-  const schemasDir = config.getOutputDir();
+  const schemasDir = config.getSchemasDir();
   const genesisPath = path.join(schemasDir, config.getSourceFile());
-  const outPath = config.getOutputPath(`${name}.json`);
+  const outPath = config.getSchemaStandalonePath(`${name}.json`);
 
   if (!fs.existsSync(genesisPath)) {
-    console.error(`Genesis.json not found at ${genesisPath}`);
+    console.error(`Genesis.json not found at ${genesisPath}. Run extractSchemasFromResourceTypeShells first.`);
     process.exit(1);
   }
 
@@ -78,20 +66,17 @@ async function main() {
   const genesis = JSON.parse(raw);
 
   try {
-    // Call the pure logic function
-    const result = extractSubSchemaLogic(genesis, name);
+    const result = extractStandaloneSubschemaLogic(genesis, name);
 
-    // I/O: Write the result
     fs.mkdirSync(path.dirname(outPath), { recursive: true });
     fs.writeFileSync(outPath, JSON.stringify(result, null, 2) + '\n');
-    console.log(`Extracted subschema '${name}' -> ${outPath}`);
+    console.log(`Created standalone subschema '${name}' -> ${outPath}`);
   } catch (error: any) {
     console.error(error.message);
     process.exit(1);
   }
 }
 
-// ---- Helpers ----
 function parseArgs(args: string[]): { name?: string } {
   let name: string | undefined;
   for (let i = 0; i < args.length; i++) {
@@ -121,30 +106,24 @@ function deepClone<T>(v: T): T {
 }
 
 function extractPointerDefName(ref: string): string | null {
-  // Accept refs like '#/$defs/Name' only (single-level under $defs)
   if (!ref || !ref.startsWith('#/')) return null;
-  const parts = ref.slice(2).split('/'); // remove '#/'
+  const parts = ref.slice(2).split('/');
   if (parts.length !== 2) return null;
   if (parts[0] !== '$defs') return null;
-  // Decode JSON Pointer tokens for the def name
   const name = parts[1].replace(/~1/g, '/').replace(/~0/g, '~');
   return name;
 }
 
 function resolveRefToDefName(ref: string, rootDefs: Record<string, any>): string | null {
   if (!ref) return null;
-  // Case 1: JSON Pointer into $defs: '#/$defs/Name'
   const byPointer = extractPointerDefName(ref);
   if (byPointer) return byPointer;
 
-  // Case 2: Anchor ref: '#Name' -> find a def whose nucleusSchema.$anchor equals 'Name'
   if (ref.startsWith('#') && !ref.startsWith('#/')) {
     const anchor = ref.slice(1);
     if (!anchor) return null;
     for (const [defName, defSchema] of Object.entries(rootDefs)) {
       if (!defSchema || typeof defSchema !== 'object') continue;
-      // Flattened Genesis has defs as the extraction schema itself (with $anchor at the top level).
-      // Unflattened may have { nucleusSchema: { $anchor } } envelopes. Support both.
       const topLevelAnchor = (defSchema as any).$anchor;
       const nested = (defSchema as any).nucleusSchema;
       const nestedAnchor = nested && typeof nested === 'object' ? nested.$anchor : undefined;
@@ -183,7 +162,7 @@ function collectLocalDefClosure(node: any, rootDefs: Record<string, any>): Set<s
   while (queue.length > 0) {
     const name = queue.shift()!;
     const def = rootDefs[name];
-    if (!def) continue; // Missing def handled earlier
+    if (!def) continue;
     visit(def);
   }
 

package/src/scripts/{generateResourceTypeType.ts → generateStandaloneType.ts}

@@ -3,10 +3,10 @@ import path from 'path';
 import { getConfig } from './_lib/config.js';
 
 /**
- * Generate a typed Resource variant where `extractedData` is typed to a specific schema
+ * Generate a typed Resource variant where `nucleus` is typed to a specific schema
  * extracted under the configured output directory.
  *
- * Usage: node ./dist/scripts/generateResourceTypeType.js --name Job
+ * Usage: node ./dist/scripts/generateStandaloneType.js --name Job
  */
 /**
  * Pure function to generate the typed Resource D.TS content.
@@ -14,11 +14,11 @@ import { getConfig } from './_lib/config.js';
  * @param name The name of the schema
  * @returns The TypeScript D.TS file content
  */
-function generateResourceTypeTypeLogic(name: string): string {
+function generateStandaloneTypeLogic(name: string): string {
     const header = '// Auto-generated strict composite type. Do not edit.\n';
     const ts =
-        `import type { ResourceMetaBase, ${name} as ExtractedData } from './types.js';\n` +
-        `export type Resource_${name} = ResourceMetaBase & { extractedData: ExtractedData };\n`;
+        `import type { ShellMaterializedBase, ${name} as NucleusSchema } from '../types.js';\n` +
+        `export type Resource_${name} = ShellMaterializedBase & { nucleus: NucleusSchema };\n`;
     return header + ts;
 }
 
@@ -30,10 +30,19 @@ async function main() {
         process.exit(1);
     }
 
-    const inPath = config.getOutputPath(`${name}.json`);
+    const inPath =
+        name === 'Genesis'
+            ? config.getSchemaPath('Genesis.json')
+            : config.getSchemaStandalonePath(`${name}.json`);
 
     if (!fs.existsSync(inPath)) {
-        console.error(`Schema file not found: ${inPath}`);
+        if (name === 'Genesis') {
+            console.error(`Schema file not found: ${inPath}`);
+            console.error('Run extractSchemasFromResourceTypeShells first.');
+        } else {
+            console.error(`Standalone schema file not found: ${inPath}`);
+            console.error(`Run generateStandaloneSchema -- --name ${name} first.`);
+        }
         process.exit(1);
     }
 
@@ -55,7 +64,7 @@ async function main() {
         console.warn(`Warning: nucleusSchema usually has type: 'object' but this schema has type: '${parsed.type}'. Proceeding.`);
     }
 
-    const tsContent = generateResourceTypeTypeLogic(name);
+    const tsContent = generateStandaloneTypeLogic(name);
     const jsContent = 'export {}\n';
 
     // Output setup
@@ -63,11 +72,11 @@ async function main() {
     const outJsName = `Resource_${name}.js`;
 
     // Process src output
-    const outDir = config.getTypesSrcDir();
+    const outDir = config.getTypesStandaloneSrcDir();
     fs.mkdirSync(outDir, { recursive: true });
 
-    const outPath = config.getTypesSrcPath(outName);
-    const outJsPath = config.getTypesSrcPath(outJsName);
+    const outPath = config.getTypesStandaloneSrcPath(outName);
+    const outJsPath = config.getTypesStandaloneSrcPath(outJsName);
 
     fs.writeFileSync(outPath, tsContent, 'utf8');
     console.log(`Wrote ${outPath}`);
@@ -78,11 +87,11 @@ async function main() {
     }
 
     // Process dist output
-    const distLibDir = config.getTypesDistDir();
+    const distLibDir = config.getTypesStandaloneDistDir();
     fs.mkdirSync(distLibDir, { recursive: true });
 
-    const distDtsPath = config.getTypesDistPath(outName);
-    const distJsPath = config.getTypesDistPath(outJsName);
+    const distDtsPath = config.getTypesStandaloneDistPath(outName);
+    const distJsPath = config.getTypesStandaloneDistPath(outJsName);
 
     fs.writeFileSync(distDtsPath, tsContent, 'utf8');
     fs.writeFileSync(distJsPath, jsContent, 'utf8');

package/src/scripts/generateTypes.ts

@@ -5,7 +5,7 @@ import { getConfig } from './_lib/config.js';
 
 const config = getConfig();
 const projectRoot = config.getRoot();
-const inputDir = config.getOutputDir();
+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');

package/src/scripts/{rewriteAnchors.ts → normalizeAnchorsToPointers.ts}

@@ -12,7 +12,7 @@ import { getConfig } from './_lib/config.js';
  * The rewritten file is saved under src/genesis/generated/resourceTypes/Genesis.json
  * for use by other scripts.
  * 
- * Usage: node ./dist/scripts/rewriteAnchors.js
+ * Usage: node ./dist/scripts/normalizeAnchorsToPointers.js
  */
 
 type JSONValue = null | boolean | number | string | JSONValue[] | { [k: string]: JSONValue };
@@ -25,7 +25,7 @@ type JSONValue = null | boolean | number | string | JSONValue[] | { [k: string]:
  * @param input The schema object to process
  * @returns A new schema object with rewritten references
  */
-function rewriteAnchorsToPointers(input: any): any {
+function normalizeAnchorsToPointersToPointers(input: any): any {
     if (!input || typeof input !== "object") return input;
 
     // Deep clone the input to ensure the function is pure (no side effects on input)
@@ -109,7 +109,7 @@ async function main() {
     }
 
     // Rewrite anchors in the nucleusSchema (pure function call)
-    genesis.nucleusSchema = rewriteAnchorsToPointers(genesis.nucleusSchema);
+    genesis.nucleusSchema = normalizeAnchorsToPointersToPointers(genesis.nucleusSchema);
 
     // Write normalized version
     fs.mkdirSync(path.dirname(normalizedPath), { recursive: true });