@toolproof-core/schema 1.0.3 → 1.0.4

package/dist/index.d.ts

@@ -1,13 +1,10 @@
-import { JobStepIdentity, BranchStepIdentity, WhileStepIdentity, ForStepIdentity } from './generated/types/types.js';
 export { default as SchemaGenesis } from './generated/schemas/Genesis.js';
 export { default as SchemaJob } from './generated/schemas/standalone/Job.js';
 export { default as SchemaStrategyRun } from './generated/schemas/standalone/StrategyRun.js';
 export { default as ResourceTypeGenesis } from './generated/resources/Genesis.js';
-export { default as dependencies } from './generated/dependencyMap.json';
-export type { Resource_Genesis as Resource_GenesisJson } from './generated/types/standalone/Resource_Genesis.js';
-export type { Resource_ResourceType as Resource_ResourceTypeJson } from './generated/types/standalone/Resource_ResourceType.js';
-export type { Resource_Job as Resource_JobJson } from './generated/types/standalone/Resource_Job.js';
-export type { Resource_RawStrategy as Resource_RawStrategyJson } from './generated/types/standalone/Resource_RawStrategy.js';
-export type { Resource_RunnableStrategy as Resource_RunnableStrategyJson } from './generated/types/standalone/Resource_RunnableStrategy.js';
-export type StepIdentityJson = JobStepIdentity | BranchStepIdentity | WhileStepIdentity | ForStepIdentity;
-export type { DocumentationFacet as DocumentationFacetJson, NucleusFacet as NucleusFacetJson, ResourceTypeIdentity as ResourceTypeIdentityJson, ResourceType as ResourceTypeJson, ResourceRoleIdentity as ResourceRoleIdentityJson, ResourceRoleValue as ResourceRoleValueJson, Conditional as ConditionalJson, RoleMap as RoleMapJson, Roles as RolesJson, RoleBindings as RoleBindingsJson, ResourceIdentity as ResourceIdentityJson, JobStepIdentity as JobStepIdentityJson, BranchStepIdentity as BranchStepIdentityJson, WhileStepIdentity as WhileStepIdentityJson, ForStepIdentity as ForStepIdentityJson, JobStep as JobStepJson, BranchStep as BranchStepJson, WhileStep as WhileStepJson, ForStep as ForStepJson, StepKind as StepKindJson, Step as StepJson, CreationContext as CreationContextJson, ResourceMissing as ResourceMissingJson, Resource as ResourceJson, StrategyState as StrategyStateJson, StepsFacet as StepsFacetJson, RawStrategy as RawStrategyJson, RunnableStrategyIdentity as RunnableStrategyIdentityJson, RunnableStrategyStatus as RunnableStrategyStatusJson, RunnableStrategy as RunnableStrategyJson, RunnableStrategyUpdate as RunnableStrategyUpdateJson, Domain as DomainJson, JobIdentity as JobIdentityJson, Job as JobJson, JsonData as JsonDataJson, StrategyThreadIdentity as StrategyThreadIdentityJson, StrategyThreadMap as StrategyThreadMapJson, Timestamp as TimestampJson, Goal as GoalJson, } from './generated/types/types.js';
+export type { Resource_Genesis as Resource_GenesisJson } from './generated/typesTS/standalone/Resource_Genesis.js';
+export type { Resource_ResourceType as Resource_ResourceTypeJson } from './generated/typesTS/standalone/Resource_ResourceType.js';
+export type { Resource_Job as Resource_JobJson } from './generated/typesTS/standalone/Resource_Job.js';
+export type { Resource_RawStrategy as Resource_RawStrategyJson } from './generated/typesTS/standalone/Resource_RawStrategy.js';
+export type { Resource_RunnableStrategy as Resource_RunnableStrategyJson } from './generated/typesTS/standalone/Resource_RunnableStrategy.js';
+export type { DocumentationFacet as DocumentationFacetJson, NucleusFacet as NucleusFacetJson, ResourceTypeIdentity as ResourceTypeIdentityJson, ResourceType as ResourceTypeJson, ResourceRoleIdentity as ResourceRoleIdentityJson, ResourceRoleValue as ResourceRoleValueJson, Conditional as ConditionalJson, RoleMap as RoleMapJson, Roles as RolesJson, RoleBindings as RoleBindingsJson, ResourceIdentity as ResourceIdentityJson, JobStepIdentity as JobStepIdentityJson, BranchStepIdentity as BranchStepIdentityJson, WhileStepIdentity as WhileStepIdentityJson, ForStepIdentity as ForStepIdentityJson, JobStep as JobStepJson, BranchStep as BranchStepJson, WhileStep as WhileStepJson, ForStep as ForStepJson, StepKind as StepKindJson, StepIdentity as StepIdentityJson, Step as StepJson, CreationContext as CreationContextJson, ResourceMissing as ResourceMissingJson, Resource as ResourceJson, StrategyState as StrategyStateJson, StepsFacet as StepsFacetJson, RawStrategy as RawStrategyJson, RunnableStrategyIdentity as RunnableStrategyIdentityJson, RunnableStrategyStatus as RunnableStrategyStatusJson, RunnableStrategy as RunnableStrategyJson, RunnableStrategyUpdate as RunnableStrategyUpdateJson, Domain as DomainJson, JobIdentity as JobIdentityJson, Job as JobJson, JsonData as JsonDataJson, StrategyThreadIdentity as StrategyThreadIdentityJson, StrategyThreadMap as StrategyThreadMapJson, JobStepSocket as JobStepSocketJson, Timestamp as TimestampJson, Goal as GoalJson, } from './generated/typesTS/typesTS.js';

package/dist/index.js

@@ -3,5 +3,3 @@ export { default as SchemaGenesis } from './generated/schemas/Genesis.js';
 export { default as SchemaJob } from './generated/schemas/standalone/Job.js';
 export { default as SchemaStrategyRun } from './generated/schemas/standalone/StrategyRun.js';
 export { default as ResourceTypeGenesis } from './generated/resources/Genesis.js';
-export { default as dependencies } from './generated/dependencyMap.json';
-// export { isResourceRoleIdentityJson, isStrategyThreadIdentityJson } from './identityGuards.js';

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

@@ -14,8 +14,8 @@ export declare class SchemaConfig {
     private readonly schemasDir;
     private readonly resourcesDir;
     private readonly dependencyMapPath;
-    private readonly typesSrcDir;
-    private readonly typesDistDir;
+    private readonly typesTsSrcDir;
+    private readonly typesTsDistDir;
     private readonly baseUrl;
     private readonly version;
     constructor();
@@ -30,14 +30,14 @@ export declare class SchemaConfig {
     getSchemaPath(filename: string): string;
     getSchemasStandaloneDir(): string;
     getSchemaStandalonePath(filename: string): string;
-    getTypesSrcDir(): string;
-    getTypesDistDir(): string;
-    getTypesSrcPath(filename: string): string;
-    getTypesDistPath(filename: string): string;
-    getTypesStandaloneSrcDir(): string;
-    getTypesStandaloneDistDir(): string;
-    getTypesStandaloneSrcPath(filename: string): string;
-    getTypesStandaloneDistPath(filename: string): string;
+    getTypesTsSrcDir(): string;
+    getTypesTsDistDir(): string;
+    getTypesTsSrcPath(filename: string): string;
+    getTypesTsDistPath(filename: string): string;
+    getStandaloneTypeTsSrcDir(): string;
+    getStandaloneTypeTsDistDir(): string;
+    getStandaloneTypeTsSrcPath(filename: string): string;
+    getStandaloneTypeTsDistPath(filename: string): string;
     getResourcesDir(): string;
     getDependencyMapPath(): string;
     getBaseUrl(): string;

package/dist/scripts/_lib/config.js

@@ -25,9 +25,9 @@ export class SchemaConfig {
         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.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.baseUrl = getEnv('TP_SCHEMA_BASE_URL', 'https://schemas.toolproof.com');
         this.version = getEnv('TP_SCHEMA_VERSION', 'v0');
     }
@@ -74,33 +74,33 @@ export class SchemaConfig {
     getSchemaStandalonePath(filename) {
         return path.join(this.getSchemasStandaloneDir(), filename);
     }
-    getTypesSrcDir() {
-        return path.isAbsolute(this.typesSrcDir)
-            ? this.typesSrcDir
-            : path.join(this.root, this.typesSrcDir);
+    getTypesTsSrcDir() {
+        return path.isAbsolute(this.typesTsSrcDir)
+            ? this.typesTsSrcDir
+            : path.join(this.root, this.typesTsSrcDir);
     }
-    getTypesDistDir() {
-        return path.isAbsolute(this.typesDistDir)
-            ? this.typesDistDir
-            : path.join(this.root, this.typesDistDir);
+    getTypesTsDistDir() {
+        return path.isAbsolute(this.typesTsDistDir)
+            ? this.typesTsDistDir
+            : path.join(this.root, this.typesTsDistDir);
     }
-    getTypesSrcPath(filename) {
-        return path.join(this.getTypesSrcDir(), filename);
+    getTypesTsSrcPath(filename) {
+        return path.join(this.getTypesTsSrcDir(), filename);
     }
-    getTypesDistPath(filename) {
-        return path.join(this.getTypesDistDir(), filename);
+    getTypesTsDistPath(filename) {
+        return path.join(this.getTypesTsDistDir(), filename);
     }
-    getTypesStandaloneSrcDir() {
-        return path.join(this.getTypesSrcDir(), 'standalone');
+    getStandaloneTypeTsSrcDir() {
+        return path.join(this.getTypesTsSrcDir(), 'standalone');
     }
-    getTypesStandaloneDistDir() {
-        return path.join(this.getTypesDistDir(), 'standalone');
+    getStandaloneTypeTsDistDir() {
+        return path.join(this.getTypesTsDistDir(), 'standalone');
     }
-    getTypesStandaloneSrcPath(filename) {
-        return path.join(this.getTypesStandaloneSrcDir(), filename);
+    getStandaloneTypeTsSrcPath(filename) {
+        return path.join(this.getStandaloneTypeTsSrcDir(), filename);
     }
-    getTypesStandaloneDistPath(filename) {
-        return path.join(this.getTypesStandaloneDistDir(), filename);
+    getStandaloneTypeTsDistPath(filename) {
+        return path.join(this.getStandaloneTypeTsDistDir(), filename);
     }
     getResourcesDir() {
         return path.isAbsolute(this.resourcesDir)

package/dist/scripts/extractSchemasFromResourceTypeShells.js

@@ -1,12 +1,10 @@
 import fs from "fs";
 import path from "path";
-import { fileURLToPath } from "url";
 import { getConfig } from "./_lib/config.js";
-function parseArgs() {
-    const config = getConfig();
-    const argv = process.argv.slice(2);
-    let inPath = "";
-    let outPath = "";
+// PURE: Parse CLI args (no defaults, no filesystem probing).
+function parseArgs(argv) {
+    let inPath;
+    let outPath;
     let topLevelId;
     for (let i = 0; i < argv.length; i++) {
         const a = argv[i];
@@ -23,45 +21,23 @@ function parseArgs() {
             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
+// PURE: Apply defaults for any missing values.
+function applyDefaults(args, defaults) {
+    return {
+        inPath: args.inPath?.trim() ? args.inPath : defaults.inPath,
+        outPath: args.outPath?.trim() ? args.outPath : defaults.outPath,
+        topLevelId: args.topLevelId?.trim() ? args.topLevelId : defaults.topLevelId
+    };
+}
+// PURE: Resolve relative paths against a root directory (no heuristics).
+function resolvePaths(options, rootDir) {
+    const inPath = path.isAbsolute(options.inPath) ? options.inPath : path.join(rootDir, options.inPath);
+    const outPath = path.isAbsolute(options.outPath) ? options.outPath : path.join(rootDir, options.outPath);
+    return { ...options, inPath, outPath };
+}
+// PURE: Determine whether 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 shell
@@ -69,84 +45,99 @@ function isTypeShell(node) {
         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, source, label) {
+// PURE: Sanitize labels for use in deterministic collision keys.
+function sanitizeLabel(label) {
+    return (label || "defs").replace(/[^A-Za-z0-9_]+/g, "_");
+}
+// PURE: Extract a `$defs` object from a schema node, if present.
+function getDefsObject(source) {
     if (!source || typeof source !== "object")
-        return;
+        return undefined;
     const src = source["$defs"];
-    if (!src || typeof src !== "object")
-        return;
-    for (const [k, v] of Object.entries(src)) {
-        if (!(k in target)) {
-            target[k] = v;
-        }
-        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;
-            }
+    if (!src || typeof src !== "object" || Array.isArray(src))
+        return undefined;
+    return src;
+}
+// PURE: Merge defs without mutating inputs; collisions are namespaced deterministically.
+function mergeDefs(existing, incoming, label) {
+    if (!incoming)
+        return { ...existing };
+    const merged = { ...existing };
+    for (const [k, v] of Object.entries(incoming)) {
+        if (!(k in merged)) {
+            merged[k] = v;
+            continue;
         }
-    }
+        const current = merged[k];
+        const same = JSON.stringify(current) === JSON.stringify(v);
+        if (same)
+            continue;
+        const altKey = `${k}__from_${sanitizeLabel(label)}`;
+        if (!(altKey in merged))
+            merged[altKey] = v;
+    }
+    return merged;
 }
-// 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") {
-        if (visited.has(node))
-            return node; // avoid cycles
-        visited.add(node);
-    }
+// PURE: Unwrap Type shells and collect any encountered inner `$defs` hoist events.
+function traverseTypes(node, labelPath = []) {
     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 shells it may contain
-        const unwrappedInner = unwrapTypes(inner, topDefs, labelPath.concat([String(env.identity || "env")]), visited);
-        return unwrappedInner;
+        const label = labelPath.join("_");
+        const innerDefs = getDefsObject(inner);
+        const innerResult = traverseTypes(inner, labelPath.concat([String(env.identity || "env")]));
+        const events = [];
+        if (innerDefs)
+            events.push({ defs: innerDefs, label });
+        events.push(...innerResult.hoistEvents);
+        return { value: innerResult.value, hoistEvents: events };
     }
     if (Array.isArray(node)) {
-        return node.map((v, i) => unwrapTypes(v, topDefs, labelPath.concat([String(i)]), visited));
+        const events = [];
+        const mapped = node.map((v, i) => {
+            const r = traverseTypes(v, labelPath.concat([String(i)]));
+            events.push(...r.hoistEvents);
+            return r.value;
+        });
+        return { value: mapped, hoistEvents: events };
     }
     if (node && typeof node === "object") {
+        const events = [];
         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 shell
                 const defsOut = {};
                 for (const [dk, dv] of Object.entries(v)) {
-                    const unwrapped = unwrapTypes(dv, topDefs, labelPath.concat(["$defs", dk]), visited);
-                    defsOut[dk] = unwrapped;
+                    const r = traverseTypes(dv, labelPath.concat(["$defs", dk]));
+                    events.push(...r.hoistEvents);
+                    defsOut[dk] = r.value;
                 }
                 out[k] = defsOut;
+                continue;
             }
-            else {
-                out[k] = unwrapTypes(v, topDefs, labelPath.concat([k]), visited);
-            }
+            const r = traverseTypes(v, labelPath.concat([k]));
+            events.push(...r.hoistEvents);
+            out[k] = r.value;
         }
-        return out;
+        return { value: out, hoistEvents: events };
     }
-    return node;
+    return { value: node, hoistEvents: [] };
 }
-/**
- * Pure function that takes a schema document and options, and returns the flattened schema.
- * Performs no I/O operations.
- */
+// PURE: Flatten a Type shell JSON into a single JSON Schema document.
 function extractSchemaLogic(doc, topLevelId) {
     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.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");
+    const seededDefs = mergeDefs({}, getDefsObject(topSchema), "top");
     // Unwrap the entire top schema tree so that any nested Type shells become raw schemas
-    const flattened = unwrapTypes(topSchema, outDefs, ["nucleusSchema"]);
+    const traversal = traverseTypes(topSchema, ["nucleusSchema"]);
+    const flattened = traversal.value;
+    let outDefs = seededDefs;
+    for (const ev of traversal.hoistEvents) {
+        outDefs = mergeDefs(outDefs, ev.defs, ev.label);
+    }
     // Assemble output: force $schema, optionally set $id, hoist collected $defs
     let base;
     if (flattened && typeof flattened === "object" && !Array.isArray(flattened)) {
@@ -180,18 +171,33 @@ function extractSchemaLogic(doc, topLevelId) {
     // Preserve natural key ordering (do not reorder for readability)
     return output;
 }
+// IMPURE: Script entrypoint (config + filesystem I/O + console + process exit code).
 function main() {
-    const { inPath, outPath, topLevelId } = parseArgs();
-    if (!fs.existsSync(inPath)) {
-        console.error(`Input file not found at ${inPath}`);
-        process.exit(1);
+    try {
+        const config = getConfig();
+        const defaults = {
+            // Use generated/normalized version with anchor refs rewritten to pointers
+            inPath: config.getNormalizedSourcePath(),
+            outPath: config.getSchemaPath(config.getSourceFile()),
+            topLevelId: config.getSchemaId("Genesis")
+        };
+        const cli = parseArgs(process.argv.slice(2));
+        const opts = resolvePaths(applyDefaults(cli, defaults), config.getRoot());
+        const { inPath, outPath, topLevelId } = opts;
+        if (!fs.existsSync(inPath)) {
+            throw new Error(`Input file not found at ${inPath}`);
+        }
+        const raw = fs.readFileSync(inPath, "utf8");
+        const doc = JSON.parse(raw);
+        // Core logic is now in a pure function
+        const extracted = extractSchemaLogic(doc, topLevelId);
+        fs.mkdirSync(path.dirname(outPath), { recursive: true });
+        fs.writeFileSync(outPath, JSON.stringify(extracted, null, 4), "utf8");
+        console.log(`Wrote flattened schema to ${outPath}`);
+    }
+    catch (e) {
+        console.error(e);
+        process.exitCode = 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/dist/scripts/generateDependencies.js

@@ -1,10 +1,12 @@
 import fs from "fs";
 import path from "path";
 import { getConfig } from "./_lib/config.js";
+// PURE: Decode a single JSON Pointer segment.
 function decodeJsonPointerSegment(segment) {
     // JSON Pointer decoding: ~1 => / and ~0 => ~
     return segment.replace(/~1/g, "/").replace(/~0/g, "~");
 }
+// PURE: Collect all `$ref` strings from a JSON-ish tree.
 function collectRefs(node, out) {
     if (Array.isArray(node)) {
         for (const item of node)
@@ -21,6 +23,7 @@ function collectRefs(node, out) {
         collectRefs(value, out);
     }
 }
+// PURE: Resolve an internal ref (pointer or anchor) to a root $defs key, if possible.
 function resolveInternalRefToDefKey(ref, defKeys, anchorToDef) {
     if (!ref.startsWith("#"))
         return null;
@@ -49,6 +52,7 @@ function resolveInternalRefToDefKey(ref, defKeys, anchorToDef) {
  * @param doc The source JSON Schema document
  * @returns A record mapping definition names to their dependency lists
  */
+// PURE: Generate a $defs dependency map from a JSON Schema document (no I/O).
 function generateDependencyMapLogic(doc) {
     const defs = doc?.$defs && typeof doc.$defs === "object" ? doc.$defs : {};
     const defKeys = new Set(Object.keys(defs));
@@ -79,15 +83,15 @@ function generateDependencyMapLogic(doc) {
     }
     return dependencyMap;
 }
-async function main() {
-    const config = getConfig();
-    const inPath = config.getSchemaPath("Genesis.json");
-    const outPath = config.getDependencyMapPath();
-    if (!fs.existsSync(inPath)) {
-        console.error(`Genesis schema not found at ${inPath}. Run extractSchemasFromResourceTypeShells first.`);
-        process.exit(1);
-    }
+// 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.getDependencyMapPath();
+        if (!fs.existsSync(inPath)) {
+            throw new Error(`Genesis schema not found at ${inPath}. Run extractSchemasFromResourceTypeShells first.`);
+        }
         const raw = fs.readFileSync(inPath, "utf8");
         const doc = JSON.parse(raw);
         const dependencyMap = generateDependencyMapLogic(doc);
@@ -96,11 +100,8 @@ async function main() {
         console.log(`Wrote dependency map to ${outPath}`);
     }
     catch (error) {
-        console.error(`Error generating dependency map: ${error.message}`);
-        process.exit(1);
+        console.error(`Error generating dependency map: ${error?.message ?? error}`);
+        process.exitCode = 1;
     }
 }
-main().catch((e) => {
-    console.error(e);
-    process.exit(1);
-});
+main();