@toolproof-core/schema 1.0.0 → 1.0.2

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

@@ -11,11 +11,11 @@ export declare class SchemaConfig {
     private readonly sourceDir;
     private readonly sourceFile;
     private readonly normalizedDir;
-    private readonly outputDir;
+    private readonly schemasDir;
+    private readonly resourcesDir;
+    private readonly dependencyMapPath;
     private readonly typesSrcDir;
     private readonly typesDistDir;
-    private readonly generatedResourcesDir;
-    private readonly dependencyMapPath;
     private readonly baseUrl;
     private readonly version;
     constructor();
@@ -26,13 +26,19 @@ export declare class SchemaConfig {
     getNormalizedDir(): string;
     getNormalizedSourceFile(): string;
     getNormalizedSourcePath(): string;
-    getOutputDir(): string;
-    getOutputPath(filename: string): string;
+    getSchemasDir(): string;
+    getSchemaPath(filename: string): string;
+    getSchemasStandaloneDir(): string;
+    getSchemaStandalonePath(filename: string): string;
     getTypesSrcDir(): string;
     getTypesDistDir(): string;
     getTypesSrcPath(filename: string): string;
     getTypesDistPath(filename: string): string;
-    getGeneratedResourcesDir(): string;
+    getTypesStandaloneSrcDir(): string;
+    getTypesStandaloneDistDir(): string;
+    getTypesStandaloneSrcPath(filename: string): string;
+    getTypesStandaloneDistPath(filename: string): string;
+    getResourcesDir(): string;
     getDependencyMapPath(): string;
     getBaseUrl(): string;
     getVersion(): string;

package/dist/scripts/_lib/config.js

@@ -20,14 +20,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');
     }
@@ -60,13 +60,19 @@ export class SchemaConfig {
     getNormalizedSourcePath() {
         return path.join(this.getNormalizedDir(), this.getNormalizedSourceFile());
     }
-    getOutputDir() {
-        return path.isAbsolute(this.outputDir)
-            ? this.outputDir
-            : path.join(this.root, this.outputDir);
+    getSchemasDir() {
+        return path.isAbsolute(this.schemasDir)
+            ? this.schemasDir
+            : path.join(this.root, this.schemasDir);
     }
-    getOutputPath(filename) {
-        return path.join(this.getOutputDir(), filename);
+    getSchemaPath(filename) {
+        return path.join(this.getSchemasDir(), filename);
+    }
+    getSchemasStandaloneDir() {
+        return path.join(this.getSchemasDir(), 'standalone');
+    }
+    getSchemaStandalonePath(filename) {
+        return path.join(this.getSchemasStandaloneDir(), filename);
     }
     getTypesSrcDir() {
         return path.isAbsolute(this.typesSrcDir)
@@ -84,10 +90,22 @@ export class SchemaConfig {
     getTypesDistPath(filename) {
         return path.join(this.getTypesDistDir(), filename);
     }
-    getGeneratedResourcesDir() {
-        return path.isAbsolute(this.generatedResourcesDir)
-            ? this.generatedResourcesDir
-            : path.join(this.root, this.generatedResourcesDir);
+    getTypesStandaloneSrcDir() {
+        return path.join(this.getTypesSrcDir(), 'standalone');
+    }
+    getTypesStandaloneDistDir() {
+        return path.join(this.getTypesDistDir(), 'standalone');
+    }
+    getTypesStandaloneSrcPath(filename) {
+        return path.join(this.getTypesStandaloneSrcDir(), filename);
+    }
+    getTypesStandaloneDistPath(filename) {
+        return path.join(this.getTypesStandaloneDistDir(), filename);
+    }
+    getResourcesDir() {
+        return path.isAbsolute(this.resourcesDir)
+            ? this.resourcesDir
+            : path.join(this.root, this.resourcesDir);
     }
     getDependencyMapPath() {
         return path.isAbsolute(this.dependencyMapPath)

package/dist/scripts/{extractSchemas.js → extractSchemasFromResourceTypeShells.js}

@@ -29,7 +29,7 @@ function parseArgs() {
         inPath = config.getNormalizedSourcePath();
     }
     if (!outPath) {
-        outPath = config.getOutputPath(config.getSourceFile());
+        outPath = config.getSchemaPath(config.getSourceFile());
     }
     if (!topLevelId) {
         topLevelId = config.getSchemaId('Genesis');
@@ -60,10 +60,11 @@ function parseArgs() {
     }
     return { inPath, outPath, topLevelId };
 }
-// Heuristic: determine if a node is a Type envelope
-function isTypeEnvelope(node) {
+// ATTENTION: we don't want heuristic behavior.
+// Heuristic: determine if a node is a Type shell
+function isTypeShell(node) {
     return (node && typeof node === "object" && !Array.isArray(node) &&
-        // Treat any object that has an 'nucleusSchema' AND 'identity' as a Type envelope
+        // 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");
@@ -91,7 +92,7 @@ function mergeDefs(target, source, label) {
         }
     }
 }
-// Deeply traverse an object replacing any Type envelope with its nucleusSchema,
+// 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, topDefs, labelPath = [], visited = new Set()) {
     if (node && typeof node === "object") {
@@ -99,12 +100,12 @@ function unwrapTypes(node, topDefs, labelPath = [], visited = new Set()) {
             return node; // avoid cycles
         visited.add(node);
     }
-    if (isTypeEnvelope(node)) {
+    if (isTypeShell(node)) {
         const env = node;
         const inner = env.nucleusSchema;
         // Hoist inner $defs before stripping
         mergeDefs(topDefs, inner, labelPath.join("_"));
-        // Return the inner schema itself, after also unwrapping any nested envelopes it may contain
+        // Return the inner schema itself, after also unwrapping any nested shells it may contain
         const unwrappedInner = unwrapTypes(inner, topDefs, labelPath.concat([String(env.identity || "env")]), visited);
         return unwrappedInner;
     }
@@ -115,7 +116,7 @@ function unwrapTypes(node, topDefs, labelPath = [], visited = new Set()) {
         const out = {};
         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 envelope
+                // Process nested $defs: unwrap each entry value if it's a Type shell
                 const defsOut = {};
                 for (const [dk, dv] of Object.entries(v)) {
                     const unwrapped = unwrapTypes(dv, topDefs, labelPath.concat(["$defs", dk]), visited);
@@ -140,10 +141,11 @@ function extractSchemaLogic(doc, topLevelId) {
         throw new Error("Input must be a Type JSON with an nucleusSchema at the top level");
     }
     const topSchema = doc.nucleusSchema;
+    // Collect $defs so that any '#/$defs/...' pointers can be resolved from the root.
     const outDefs = {};
     // Seed with top-level $defs (if any) before unwrapping
     mergeDefs(outDefs, topSchema, "top");
-    // Unwrap the entire top schema tree so that any nested Type envelopes become raw schemas
+    // Unwrap the entire top schema tree so that any nested Type shells become raw schemas
     const flattened = unwrapTypes(topSchema, outDefs, ["nucleusSchema"]);
     // Assemble output: force $schema, optionally set $id, hoist collected $defs
     let base;
@@ -166,7 +168,7 @@ function extractSchemaLogic(doc, topLevelId) {
     if (!output.$id) {
         throw new Error("Flattened schema must define $id. Provide it via CLI --id or include $id in the source nucleusSchema.");
     }
-    // Merge collected defs into output.$defs, taking care not to clobber any existing
+    // Hoist collected defs into output.$defs, taking care not to clobber any existing
     if (!("$defs" in output))
         output.$defs = {};
     const finalDefs = output.$defs || {};
@@ -175,8 +177,8 @@ function extractSchemaLogic(doc, topLevelId) {
             finalDefs[k] = v;
     }
     output.$defs = finalDefs;
-    // Ensure a stable order for readability
-    return orderKeys(output, ["$id", "$schema", "$vocabulary", "$defs", "title", "description", "type", "allOf", "anyOf", "oneOf", "not", "if", "then", "else", "properties", "required", "additionalProperties", "unevaluatedProperties"]);
+    // Preserve natural key ordering (do not reorder for readability)
+    return output;
 }
 function main() {
     const { inPath, outPath, topLevelId } = parseArgs();
@@ -192,19 +194,4 @@ function main() {
     fs.writeFileSync(outPath, JSON.stringify(ordered, null, 4), "utf8");
     console.log(`Wrote flattened schema to ${outPath}`);
 }
-function orderKeys(obj, preferred) {
-    if (Array.isArray(obj))
-        return obj.map((v) => orderKeys(v, preferred));
-    if (!obj || typeof obj !== "object")
-        return obj;
-    const keys = Object.keys(obj);
-    const sorted = [
-        ...preferred.filter((k) => keys.includes(k)),
-        ...keys.filter((k) => !preferred.includes(k)).sort()
-    ];
-    const out = {};
-    for (const k of sorted)
-        out[k] = orderKeys(obj[k], preferred);
-    return out;
-}
 main();

package/dist/scripts/generateDependencies.js

@@ -81,10 +81,10 @@ function generateDependencyMapLogic(doc) {
 }
 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);
     }
     try {

package/dist/scripts/generateSchemaShims.js

@@ -9,8 +9,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
  */
@@ -42,8 +43,9 @@ function getShimsForFiles(jsonFiles, variableName) {
 }
 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;
     // Process schemas directory
@@ -62,6 +64,22 @@ async function main() {
     else {
         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/dist/scripts/{extractSubSchemaWithDefs.js → generateStandaloneSchema.js}

@@ -2,26 +2,17 @@ import fs from 'fs';
 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, name) {
+function extractStandaloneSubschemaLogic(genesis, name) {
     const rootDefs = genesis.$defs;
     if (!rootDefs || typeof rootDefs !== 'object') {
         throw new Error('No $defs object found in Genesis.json');
@@ -30,13 +21,10 @@ function extractSubSchemaLogic(genesis, name) {
     if (!target) {
         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 = {};
     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];
@@ -46,7 +34,6 @@ function extractSubSchemaLogic(genesis, name) {
         }
         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 };
     return targetClone;
@@ -58,29 +45,26 @@ async function main() {
         console.error('Missing --name <DefName> argument');
         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);
     }
     const raw = fs.readFileSync(genesisPath, 'utf-8');
     const genesis = JSON.parse(raw);
     try {
-        // Call the pure logic function
-        const result = extractSubSchemaLogic(genesis, name);
-        // I/O: Write the result
+        const result = extractStandaloneSubschemaLogic(genesis, name);
         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) {
         console.error(error.message);
         process.exit(1);
     }
 }
-// ---- Helpers ----
 function parseArgs(args) {
     let name;
     for (let i = 0; i < args.length; i++) {
@@ -110,26 +94,22 @@ function deepClone(v) {
     return v;
 }
 function extractPointerDefName(ref) {
-    // 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, rootDefs) {
     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)
@@ -137,8 +117,6 @@ function resolveRefToDefName(ref, rootDefs) {
         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.$anchor;
             const nested = defSchema.nucleusSchema;
             const nestedAnchor = nested && typeof nested === 'object' ? nested.$anchor : undefined;
@@ -176,7 +154,7 @@ function collectLocalDefClosure(node, rootDefs) {
         const name = queue.shift();
         const def = rootDefs[name];
         if (!def)
-            continue; // Missing def handled earlier
+            continue;
         visit(def);
     }
     return needed;

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

@@ -1,10 +1,10 @@
 import fs from 'fs';
 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.
@@ -12,10 +12,10 @@ import { getConfig } from './_lib/config.js';
  * @param name The name of the schema
  * @returns The TypeScript D.TS file content
  */
-function generateResourceTypeTypeLogic(name) {
+function generateStandaloneTypeLogic(name) {
     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`;
+    const ts = `import type { ShellMaterializedBase, ${name} as NucleusSchema } from '../types.js';\n` +
+        `export type Resource_${name} = ShellMaterializedBase & { nucleus: NucleusSchema };\n`;
     return header + ts;
 }
 async function main() {
@@ -25,9 +25,18 @@ async function main() {
         console.error('Missing --name <SchemaBasename> argument');
         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);
     }
     // Basic validation against the expected shape of nucleusSchema.
@@ -47,16 +56,16 @@ async function main() {
     if (parsed.type && parsed.type !== 'object') {
         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
     const outName = `Resource_${name}.d.ts`;
     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}`);
     if (!fs.existsSync(outJsPath)) {
@@ -64,10 +73,10 @@ async function main() {
         console.log(`Wrote ${outJsPath}`);
     }
     // 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');
     console.log(`Wrote ${distDtsPath}`);

package/dist/scripts/generateTypes.js

@@ -4,7 +4,7 @@ import { compileFromFile } from 'json-schema-to-typescript';
 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/dist/scripts/{rewriteAnchors.js → normalizeAnchorsToPointers.js}

@@ -9,7 +9,7 @@ import { getConfig } from './_lib/config.js';
  * @param input The schema object to process
  * @returns A new schema object with rewritten references
  */
-function rewriteAnchorsToPointers(input) {
+function normalizeAnchorsToPointersToPointers(input) {
     if (!input || typeof input !== "object")
         return input;
     // Deep clone the input to ensure the function is pure (no side effects on input)
@@ -84,7 +84,7 @@ async function main() {
         process.exit(1);
     }
     // 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 });
     fs.writeFileSync(normalizedPath, JSON.stringify(genesis, null, 4), 'utf-8');

package/dist/scripts/{generateResourceShells.js → wrapResourceTypesWithResourceShells.js}

@@ -2,69 +2,49 @@ import fs from 'fs';
 import path from 'path';
 import { getConfig } from './_lib/config.js';
 /**
- * Generate Resource envelopes for all ResourceTypes defined in Genesis.json
- *
- * This script wraps each ResourceType definition (from $defs) with a Resource envelope
+ * Wrap each ResourceType definition (from Genesis.nucleusSchema.$defs) with a Resource shell
  * that conforms to the Resource.nucleusSchema pattern defined in Genesis.json.
- *
- * For the top-level Genesis ResourceType, extractedData is set to {} to avoid
- * duplicating the entire $defs object.
- *
- * Resource identities follow the pattern RESOURCE-{Name} where Name is the key
- * from the $defs object. Genesis itself uses RESOURCE-Genesis.
- *
- * Usage: node ./dist/scripts/generateResourceEnvelopes.js
  */
-/**
- * Pure function to generate resource envelopes from a Genesis schema.
- *
- * @param genesis The Genesis schema object
- * @returns A record mapping resource names to their envelopes
- */
-function generateResourceEnvelopesLogic(genesis) {
+function generateResourceShellLogic(genesis) {
     if (!genesis.nucleusSchema || !genesis.nucleusSchema.$defs) {
         throw new Error('Genesis.json must have nucleusSchema.$defs');
     }
     const defs = genesis.nucleusSchema.$defs;
     const defKeys = Object.keys(defs);
-    // Generate Resource envelopes
     const resources = {};
     // Genesis timestamp: 2025-11-30T00:00:00.000Z marks the genesis of ToolProof
     const genesisTimestamp = '2025-11-30T00:00:00.000Z';
-    // First entry is Genesis itself with empty extractedData
     resources['Genesis'] = {
         identity: 'RESOURCE-Genesis',
-        resourceTypeRef: 'TYPE-ResourceType',
+        resourceTypeHandle: 'TYPE-ResourceType',
         creationContext: {
-            resourceRoleRef: 'ROLE-Genesis',
-            executionRef: 'EXECUTION-Genesis'
+            resourceRoleHandle: 'ROLE-Genesis',
+            jobStepHandle: 'JOB_STEP-Genesis'
         },
         kind: 'materialized',
         timestamp: genesisTimestamp,
-        extractedData: {}
+        nucleus: {}
     };
-    // Generate resources for all other $defs
     defKeys.forEach((defName) => {
         const defValue = defs[defName];
         resources[defName] = {
             identity: `RESOURCE-${defName}`,
-            resourceTypeRef: 'TYPE-ResourceType',
+            resourceTypeHandle: 'TYPE-ResourceType',
             creationContext: {
-                resourceRoleRef: 'ROLE-Genesis',
-                executionRef: `EXECUTION-${defName}`
+                resourceRoleHandle: 'ROLE-Genesis',
+                jobStepHandle: `JOB_STEP-${defName}`
             },
             kind: 'materialized',
             timestamp: genesisTimestamp,
-            extractedData: defValue
+            nucleus: defValue
         };
     });
     return resources;
 }
 async function main() {
     const config = getConfig();
-    // Use normalized version with anchor refs rewritten to pointers
     const genesisSourcePath = config.getNormalizedSourcePath();
-    const outputPath = path.join(config.getGeneratedResourcesDir(), 'Genesis.json');
+    const outputPath = path.join(config.getResourcesDir(), 'Genesis.json');
     if (!fs.existsSync(genesisSourcePath)) {
         console.error(`Genesis source file not found at ${genesisSourcePath}`);
         process.exit(1);
@@ -72,11 +52,9 @@ async function main() {
     const raw = fs.readFileSync(genesisSourcePath, 'utf-8');
     const genesis = JSON.parse(raw);
     try {
-        const resources = generateResourceEnvelopesLogic(genesis);
-        // Ensure output directory exists
+        const resources = generateResourceShellLogic(genesis);
         const outputDir = path.dirname(outputPath);
         fs.mkdirSync(outputDir, { recursive: true });
-        // Write the generated resources file
         fs.writeFileSync(outputPath, JSON.stringify(resources, null, 4) + '\n', 'utf-8');
         console.log(`Generated ${Object.keys(resources).length} Resource envelopes -> ${outputPath}`);
     }