@toolproof-core/schema 1.0.9 → 1.0.10

package/src/scripts/normalizeAnchorsToPointers.ts

@@ -1,141 +1,141 @@
-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.
-    * 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 {
-    if (!input || typeof input !== "object") return input;
-
-    // Deep clone the input to ensure the function is pure (no side effects on input)
-    const root = JSON.parse(JSON.stringify(input));
-
-    // Build a map of anchors to their definition names
-    const defs: Record<string, any> = root.$defs && typeof root.$defs === "object" ? root.$defs : {};
-    const anchorToDef: Record<string, string> = {};
-
-    // For Genesis structure: each def is a Type envelope with nucleusSchema.$anchor
-    for (const [defName, defValue] of Object.entries(defs)) {
-        if (!defValue || typeof defValue !== "object") continue;
-
-        // Check if this is a Type envelope (has nucleusSchema property)
-        const nucleusSchema = (defValue as any).nucleusSchema;
-        if (nucleusSchema && typeof nucleusSchema === "object") {
-            // Look for $anchor inside the nucleusSchema
-            const anchor = nucleusSchema.$anchor;
-            if (typeof anchor === "string" && !anchorToDef[anchor]) {
-                anchorToDef[anchor] = defName;
-            }
-        } else {
-            // Fallback: check for $anchor at the def level (non-envelope case)
-            const anchor = (defValue as any).$anchor;
-            if (typeof anchor === "string" && !anchorToDef[anchor]) {
-                anchorToDef[anchor] = defName;
-            }
-        }
-    }
-
-    // Walk the entire tree and rewrite anchor refs to pointer refs
-    function walk(node: any): void {
-        if (Array.isArray(node)) {
-            for (const item of node) walk(item);
-            return;
-        }
-        if (!node || typeof node !== "object") return;
-
-        // Rewrite $ref if it's an anchor-style reference
-        if (typeof node.$ref === "string") {
-            const ref: string = node.$ref;
-            // Match anchor refs: starts with # but not #/ (JSON Pointer syntax)
-            if (ref.startsWith("#") && !ref.startsWith("#/")) {
-                const anchor = ref.slice(1);
-                const defName = anchorToDef[anchor];
-                if (defName) {
-                    node.$ref = `#/$defs/${defName}`;
-                }
-            }
-        }
-
-        // Recursively walk all properties
-        for (const val of Object.values(node)) {
-            walk(val);
-        }
-    }
-
-    walk(root);
-    return root;
-}
-
-// IMPURE: Script entrypoint (config + filesystem I/O + console + process exit code).
-function main() {
-    try {
-        const config = getConfig();
-        const genesisSourcePath = config.getSourcePath();
-
-        // Create a generated/normalized version (anchor refs rewritten to pointers)
-        const normalizedPath = config.getNormalizedSourcePath();
-
-        if (!fs.existsSync(genesisSourcePath)) {
-            throw new Error(`Genesis source file not found at ${genesisSourcePath}`);
-        }
-
-        const raw = fs.readFileSync(genesisSourcePath, 'utf-8');
-        const genesis = JSON.parse(raw);
-
-        // Validate structure
-        if (!genesis.nucleusSchema || !genesis.nucleusSchema.$defs) {
-            throw new Error('Genesis.json must have nucleusSchema.$defs');
-        }
-
-        // 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');
-        console.log(`Wrote normalized Genesis with pointer refs to ${normalizedPath}`);
-    } catch (e) {
-        console.error(e);
-        process.exitCode = 1;
-    }
-}
-
-main();
+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.
+    * 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 {
+    if (!input || typeof input !== "object") return input;
+
+    // Deep clone the input to ensure the function is pure (no side effects on input)
+    const root = JSON.parse(JSON.stringify(input));
+
+    // Build a map of anchors to their definition names
+    const defs: Record<string, any> = root.$defs && typeof root.$defs === "object" ? root.$defs : {};
+    const anchorToDef: Record<string, string> = {};
+
+    // For Genesis structure: each def is a Type envelope with nucleusSchema.$anchor
+    for (const [defName, defValue] of Object.entries(defs)) {
+        if (!defValue || typeof defValue !== "object") continue;
+
+        // Check if this is a Type envelope (has nucleusSchema property)
+        const nucleusSchema = (defValue as any).nucleusSchema;
+        if (nucleusSchema && typeof nucleusSchema === "object") {
+            // Look for $anchor inside the nucleusSchema
+            const anchor = nucleusSchema.$anchor;
+            if (typeof anchor === "string" && !anchorToDef[anchor]) {
+                anchorToDef[anchor] = defName;
+            }
+        } else {
+            // Fallback: check for $anchor at the def level (non-envelope case)
+            const anchor = (defValue as any).$anchor;
+            if (typeof anchor === "string" && !anchorToDef[anchor]) {
+                anchorToDef[anchor] = defName;
+            }
+        }
+    }
+
+    // Walk the entire tree and rewrite anchor refs to pointer refs
+    function walk(node: any): void {
+        if (Array.isArray(node)) {
+            for (const item of node) walk(item);
+            return;
+        }
+        if (!node || typeof node !== "object") return;
+
+        // Rewrite $ref if it's an anchor-style reference
+        if (typeof node.$ref === "string") {
+            const ref: string = node.$ref;
+            // Match anchor refs: starts with # but not #/ (JSON Pointer syntax)
+            if (ref.startsWith("#") && !ref.startsWith("#/")) {
+                const anchor = ref.slice(1);
+                const defName = anchorToDef[anchor];
+                if (defName) {
+                    node.$ref = `#/$defs/${defName}`;
+                }
+            }
+        }
+
+        // Recursively walk all properties
+        for (const val of Object.values(node)) {
+            walk(val);
+        }
+    }
+
+    walk(root);
+    return root;
+}
+
+// IMPURE: Script entrypoint (config + filesystem I/O + console + process exit code).
+function main() {
+    try {
+        const config = getConfig();
+        const genesisSourcePath = config.getSourcePath();
+
+        // Create a generated/normalized version (anchor refs rewritten to pointers)
+        const normalizedPath = config.getNormalizedSourcePath();
+
+        if (!fs.existsSync(genesisSourcePath)) {
+            throw new Error(`Genesis source file not found at ${genesisSourcePath}`);
+        }
+
+        const raw = fs.readFileSync(genesisSourcePath, 'utf-8');
+        const genesis = JSON.parse(raw);
+
+        // Validate structure
+        if (!genesis.nucleusSchema || !genesis.nucleusSchema.$defs) {
+            throw new Error('Genesis.json must have nucleusSchema.$defs');
+        }
+
+        // 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');
+        console.log(`Wrote normalized Genesis with pointer refs to ${normalizedPath}`);
+    } catch (e) {
+        console.error(e);
+        process.exitCode = 1;
+    }
+}
+
+main();

package/src/scripts/wrapResourceTypesWithResourceShells.ts

@@ -1,82 +1,86 @@
-import fs from 'fs';
-import path from 'path';
-import { getConfig } from './_lib/config.js';
-
-/**
- * Wrap each ResourceType definition (from Genesis.nucleusSchema.$defs) with a Resource shell
- * that conforms to the Resource.nucleusSchema pattern defined in Genesis.json.
- */
-
-// PURE: Build Resource shell envelopes for each $defs entry (no I/O, no mutation of inputs).
-function generateResourceShellLogic(genesis: any): Record<string, any> {
-    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);
-
-    const resources: Record<string, any> = {};
-
-    // Genesis timestamp: 2025-11-30T00:00:00.000Z marks the genesis of ToolProof
-    const genesisTimestamp = '2025-11-30T00:00:00.000Z';
-
-    resources['Genesis'] = {
-        identity: 'RESOURCE-Genesis',
-        resourceTypeHandle: 'TYPE-ResourceType',
-        creationContext: {
-            resourceRoleHandle: 'ROLE-Genesis',
-            jobStepHandle: 'JOB_STEP-Genesis'
-        },
-        kind: 'materialized',
-        timestamp: genesisTimestamp,
-        nucleus: {}
-    };
-
-    defKeys.forEach((defName) => {
-        const defValue = defs[defName];
-
-        resources[defName] = {
-            identity: `RESOURCE-${defName}`,
-            resourceTypeHandle: 'TYPE-ResourceType',
-            creationContext: {
-                resourceRoleHandle: 'ROLE-Genesis',
-                jobStepHandle: `JOB_STEP-${defName}`
-            },
-            kind: 'materialized',
-            timestamp: genesisTimestamp,
-            nucleus: defValue
-        };
-    });
-
-    return resources;
-}
-
-// IMPURE: Script entrypoint (config + filesystem I/O + console + process exit code).
-function main() {
-    try {
-        const config = getConfig();
-        const genesisSourcePath = config.getNormalizedSourcePath();
-        const outputPath = path.join(config.getResourcesDir(), 'Genesis.json');
-
-        if (!fs.existsSync(genesisSourcePath)) {
-            throw new Error(`Genesis source file not found at ${genesisSourcePath}`);
-        }
-
-        const raw = fs.readFileSync(genesisSourcePath, 'utf-8');
-        const genesis = JSON.parse(raw);
-
-        const resources = generateResourceShellLogic(genesis);
-
-        const outputDir = path.dirname(outputPath);
-        fs.mkdirSync(outputDir, { recursive: true });
-
-        fs.writeFileSync(outputPath, JSON.stringify(resources, null, 4) + '\n', 'utf-8');
-        console.log(`Generated ${Object.keys(resources).length} Resource envelopes -> ${outputPath}`);
-    } catch (error: any) {
-        console.error(error?.message ?? error);
-        process.exitCode = 1;
-    }
-}
-
-main();
+import fs from 'fs';
+import path from 'path';
+import { getConfig } from './_lib/config.js';
+
+/**
+ * Wrap each ResourceType definition (from Genesis.nucleusSchema.$defs) with a Resource shell
+ * that conforms to the Resource.nucleusSchema pattern defined in Genesis.json.
+ */
+
+// PURE: Build Resource shell envelopes for each $defs entry (no I/O, no mutation of inputs).
+function generateResourceShellLogic(genesis: any): Record<string, any> {
+    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);
+
+    const resources: Record<string, any> = {};
+
+    // Genesis timestamp: 2025-11-30T00:00:00.000Z marks the genesis of ToolProof
+    const genesisTimestamp = '2025-11-30T00:00:00.000Z';
+
+    resources['Genesis'] = {
+        identity: 'RESOURCE-Genesis',
+        resourceTypeHandle: 'TYPE-ResourceType',
+        creationContext: {
+            resourceRoleHandle: 'ROLE-Genesis',
+            jobStepHandle: 'JOB_STEP-Genesis'
+        },
+        resourceShellKind: 'materialized',
+        version: 1,
+        timestamp: genesisTimestamp,
+        path: 'https://schemas.toolproof.com/v1/Genesis.json',
+        nucleus: {}
+    };
+
+    defKeys.forEach((defName) => {
+        const defValue = defs[defName];
+
+        resources[defName] = {
+            identity: `RESOURCE-${defName}`,
+            resourceTypeHandle: 'TYPE-ResourceType',
+            creationContext: {
+                resourceRoleHandle: 'ROLE-Genesis',
+                jobStepHandle: 'JOB_STEP-Genesis'
+            },
+            resourceShellKind: 'materialized',
+            version: 1,
+            timestamp: genesisTimestamp,
+            path: `https://schemas.toolproof.com/v1/Genesis.json#/$defs/${defName}`,
+            nucleus: defValue
+        };
+    });
+
+    return resources;
+}
+
+// IMPURE: Script entrypoint (config + filesystem I/O + console + process exit code).
+function main() {
+    try {
+        const config = getConfig();
+        const genesisSourcePath = config.getNormalizedSourcePath();
+        const outputPath = path.join(config.getResourcesDir(), 'Genesis.json');
+
+        if (!fs.existsSync(genesisSourcePath)) {
+            throw new Error(`Genesis source file not found at ${genesisSourcePath}`);
+        }
+
+        const raw = fs.readFileSync(genesisSourcePath, 'utf-8');
+        const genesis = JSON.parse(raw);
+
+        const resources = generateResourceShellLogic(genesis);
+
+        const outputDir = path.dirname(outputPath);
+        fs.mkdirSync(outputDir, { recursive: true });
+
+        fs.writeFileSync(outputPath, JSON.stringify(resources, null, 4) + '\n', 'utf-8');
+        console.log(`Generated ${Object.keys(resources).length} Resource envelopes -> ${outputPath}`);
+    } catch (error: any) {
+        console.error(error?.message ?? error);
+        process.exitCode = 1;
+    }
+}
+
+main();

package/dist/generated/constants/constants.d.ts

@@ -1,60 +0,0 @@
-declare const CONSTANTS: {
-    readonly IDENTIFIABLES: {
-        readonly PREFIXES: {
-            readonly BranchStepIdentity: "BRANCH_STEP-";
-            readonly ForStepIdentity: "FOR_STEP-";
-            readonly GoalIdentity: "GOAL-";
-            readonly JobIdentity: "JOB-";
-            readonly JobStepIdentity: "JOB_STEP-";
-            readonly ResourceIdentity: "RESOURCE-";
-            readonly ResourceRoleIdentity: "ROLE-";
-            readonly ResourceTypeIdentity: "TYPE-";
-            readonly RunnableStrategyIdentity: "RUNNABLE_STRATEGY-";
-            readonly StrategyRunIdentity: "STRATEGY_RUN-";
-            readonly StrategyThreadIdentity: "STRATEGY_THREAD-";
-            readonly WhileStepIdentity: "WHILE_STEP-";
-        };
-        readonly NAMES: {
-            readonly BranchStep: "BranchStep";
-            readonly ForStep: "ForStep";
-            readonly Goal: "Goal";
-            readonly Job: "Job";
-            readonly JobStep: "JobStep";
-            readonly Resource: "Resource";
-            readonly ResourceRole: "ResourceRole";
-            readonly ResourceType: "ResourceType";
-            readonly RunnableStrategy: "RunnableStrategy";
-            readonly StrategyRun: "StrategyRun";
-            readonly StrategyThread: "StrategyThread";
-            readonly WhileStep: "WhileStep";
-        };
-    };
-    readonly ENUMS: {
-        readonly ResourceKind: {
-            readonly missing: "missing";
-            readonly inputPotential: "inputPotential";
-            readonly outputPotential: "outputPotential";
-            readonly materialized: "materialized";
-        };
-        readonly RunEventKind: {
-            readonly graph_start: "graph_start";
-            readonly tick: "tick";
-            readonly interrupt: "interrupt";
-            readonly graph_end: "graph_end";
-        };
-        readonly RunnableStrategyStatus: {
-            readonly pending: "pending";
-            readonly running: "running";
-            readonly completed: "completed";
-            readonly failed: "failed";
-            readonly cancelled: "cancelled";
-        };
-        readonly StepKind: {
-            readonly job: "job";
-            readonly branch: "branch";
-            readonly while: "while";
-            readonly for: "for";
-        };
-    };
-};
-export default CONSTANTS;

package/dist/generated/constants/constants.js

@@ -1,60 +0,0 @@
-const CONSTANTS = {
-    IDENTIFIABLES: {
-        PREFIXES: {
-            BranchStepIdentity: 'BRANCH_STEP-',
-            ForStepIdentity: 'FOR_STEP-',
-            GoalIdentity: 'GOAL-',
-            JobIdentity: 'JOB-',
-            JobStepIdentity: 'JOB_STEP-',
-            ResourceIdentity: 'RESOURCE-',
-            ResourceRoleIdentity: 'ROLE-',
-            ResourceTypeIdentity: 'TYPE-',
-            RunnableStrategyIdentity: 'RUNNABLE_STRATEGY-',
-            StrategyRunIdentity: 'STRATEGY_RUN-',
-            StrategyThreadIdentity: 'STRATEGY_THREAD-',
-            WhileStepIdentity: 'WHILE_STEP-',
-        },
-        NAMES: {
-            BranchStep: 'BranchStep',
-            ForStep: 'ForStep',
-            Goal: 'Goal',
-            Job: 'Job',
-            JobStep: 'JobStep',
-            Resource: 'Resource',
-            ResourceRole: 'ResourceRole',
-            ResourceType: 'ResourceType',
-            RunnableStrategy: 'RunnableStrategy',
-            StrategyRun: 'StrategyRun',
-            StrategyThread: 'StrategyThread',
-            WhileStep: 'WhileStep',
-        },
-    },
-    ENUMS: {
-        ResourceKind: {
-            missing: 'missing',
-            inputPotential: 'inputPotential',
-            outputPotential: 'outputPotential',
-            materialized: 'materialized',
-        },
-        RunEventKind: {
-            graph_start: 'graph_start',
-            tick: 'tick',
-            interrupt: 'interrupt',
-            graph_end: 'graph_end',
-        },
-        RunnableStrategyStatus: {
-            pending: 'pending',
-            running: 'running',
-            completed: 'completed',
-            failed: 'failed',
-            cancelled: 'cancelled',
-        },
-        StepKind: {
-            job: 'job',
-            branch: 'branch',
-            while: 'while',
-            for: 'for',
-        },
-    }
-};
-export default CONSTANTS;

package/dist/scripts/generateConstants.d.ts

@@ -1,12 +0,0 @@
-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;