@toolproof-core/schema 1.0.3 → 1.0.5

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 { 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, 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/types/types.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

@@ -28,16 +28,16 @@ export declare class SchemaConfig {
     getNormalizedSourcePath(): string;
     getSchemasDir(): string;
     getSchemaPath(filename: string): string;
-    getSchemasStandaloneDir(): string;
-    getSchemaStandalonePath(filename: string): string;
+    getStandaloneSchemaDir(): string;
+    getStandaloneSchemaPath(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;
+    getStandaloneTypeSrcDir(): string;
+    getStandaloneTypeDistDir(): string;
+    getStandaloneTypeSrcPath(filename: string): string;
+    getStandaloneTypeDistPath(filename: string): string;
     getResourcesDir(): string;
     getDependencyMapPath(): string;
     getBaseUrl(): string;

package/dist/scripts/_lib/config.js

@@ -20,12 +20,10 @@ export class SchemaConfig {
         this.root = getEnv('TP_SCHEMA_ROOT', process.cwd());
         this.sourceDir = getEnv('TP_SCHEMA_SOURCE_DIR', 'src/');
         this.sourceFile = getEnv('TP_SCHEMA_SOURCE_FILE', 'Genesis.json');
-        // Intermediate, generated artifact produced by normalizeAnchorsToPointers.
-        // This should NOT live next to the source-of-truth schemas.
         this.normalizedDir = getEnv('TP_SCHEMA_NORMALIZED_DIR', 'src/generated/normalized');
         this.schemasDir = getEnv('TP_SCHEMA_SCHEMAS_DIR', 'src/generated/schemas');
         this.resourcesDir = getEnv('TP_SCHEMA_RESOURCES_DIR', 'src/generated/resources');
-        this.dependencyMapPath = getEnv('TP_SCHEMA_DEPENDENCY_MAP_PATH', 'src/generated/dependencyMap.json');
+        this.dependencyMapPath = getEnv('TP_SCHEMA_DEPENDENCY_MAP_PATH', 'src/generated/dependencies/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.baseUrl = getEnv('TP_SCHEMA_BASE_URL', 'https://schemas.toolproof.com');
@@ -68,11 +66,11 @@ export class SchemaConfig {
     getSchemaPath(filename) {
         return path.join(this.getSchemasDir(), filename);
     }
-    getSchemasStandaloneDir() {
+    getStandaloneSchemaDir() {
         return path.join(this.getSchemasDir(), 'standalone');
     }
-    getSchemaStandalonePath(filename) {
-        return path.join(this.getSchemasStandaloneDir(), filename);
+    getStandaloneSchemaPath(filename) {
+        return path.join(this.getStandaloneSchemaDir(), filename);
     }
     getTypesSrcDir() {
         return path.isAbsolute(this.typesSrcDir)
@@ -90,17 +88,17 @@ export class SchemaConfig {
     getTypesDistPath(filename) {
         return path.join(this.getTypesDistDir(), filename);
     }
-    getTypesStandaloneSrcDir() {
+    getStandaloneTypeSrcDir() {
         return path.join(this.getTypesSrcDir(), 'standalone');
     }
-    getTypesStandaloneDistDir() {
+    getStandaloneTypeDistDir() {
         return path.join(this.getTypesDistDir(), 'standalone');
     }
-    getTypesStandaloneSrcPath(filename) {
-        return path.join(this.getTypesStandaloneSrcDir(), filename);
+    getStandaloneTypeSrcPath(filename) {
+        return path.join(this.getStandaloneTypeSrcDir(), filename);
     }
-    getTypesStandaloneDistPath(filename) {
-        return path.join(this.getTypesStandaloneDistDir(), filename);
+    getStandaloneTypeDistPath(filename) {
+        return path.join(this.getStandaloneTypeDistDir(), 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();

package/dist/scripts/generateSchemaShims.js

@@ -10,28 +10,16 @@ import { getConfig } from './_lib/config.js';
  *
  * Generates shims for:
  * - schemas dir: config.getSchemasDir() (schema files)
- * - standalone schemas dir: config.getSchemasStandaloneDir() (standalone schema files)
+ * - standalone schemas dir: config.getStandaloneSchemaDir() (standalone schema files)
  * - resources dir: config.getResourcesDir() (resource envelope files)
  *
  * Usage: node ./dist/scripts/generateSchemaShims.js
  */
-/**
- * Pure function to generate the content of a TypeScript shim file.
- *
- * @param jsonFile The name of the JSON file to import
- * @param variableName The name of the variable to use for the import
- * @returns The TypeScript file content
- */
+// PURE: Generate the .ts shim module content for a given .json filename.
 function generateShimContent(jsonFile, variableName) {
     return `import ${variableName} from './${jsonFile}' with { type: 'json' };\nexport default ${variableName};\n`;
 }
-/**
- * Pure function to map a list of JSON files to their corresponding TypeScript shim files and contents.
- *
- * @param jsonFiles List of JSON filenames
- * @param variableName The variable name to use in the shim
- * @returns A record mapping TS filenames to their contents
- */
+// PURE: Map JSON filenames to deterministic shim file contents.
 function getShimsForFiles(jsonFiles, variableName) {
     const shims = {};
     for (const jsonFile of jsonFiles) {
@@ -41,83 +29,87 @@ function getShimsForFiles(jsonFiles, variableName) {
     }
     return shims;
 }
-async function main() {
-    const config = getConfig();
-    const schemasDir = config.getSchemasDir();
-    const standaloneSchemasDir = config.getSchemasStandaloneDir();
-    const resourcesDir = config.getResourcesDir();
-    const generatedResourceTypesDir = config.getNormalizedDir();
-    let totalCount = 0;
-    // Process schemas directory
-    if (fs.existsSync(schemasDir)) {
-        const files = fs.readdirSync(schemasDir);
-        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(schemasDir, tsFile);
-            fs.writeFileSync(tsPath, content, 'utf-8');
-            console.log(`Generated ${tsFile} in ${schemasDir}`);
-            totalCount++;
+// IMPURE: Script entrypoint (config + filesystem I/O + console + process exit code).
+function main() {
+    try {
+        const config = getConfig();
+        const schemasDir = config.getSchemasDir();
+        const standaloneSchemasDir = config.getStandaloneSchemaDir();
+        const resourcesDir = config.getResourcesDir();
+        const generatedResourceTypesDir = config.getNormalizedDir();
+        let totalCount = 0;
+        // Process schemas directory
+        if (fs.existsSync(schemasDir)) {
+            const files = fs.readdirSync(schemasDir);
+            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(schemasDir, tsFile);
+                fs.writeFileSync(tsPath, content, 'utf-8');
+                console.log('Generated ' + tsFile + ' in ' + schemasDir);
+                totalCount++;
+            }
+            console.log('Generated ' + jsonFiles.length + ' TypeScript schema shims in ' + schemasDir);
         }
-        console.log(`Generated ${jsonFiles.length} TypeScript schema shims in ${schemasDir}`);
-    }
-    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++;
+        else {
+            console.warn('Schemas directory not found at ' + schemasDir);
         }
-        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);
-        const jsonFiles = files.filter(f => f.endsWith('.json') && !f.startsWith('.'));
-        const shims = getShimsForFiles(jsonFiles, 'resources');
-        for (const [tsFile, content] of Object.entries(shims)) {
-            const tsPath = path.join(resourcesDir, tsFile);
-            fs.writeFileSync(tsPath, content, 'utf-8');
-            console.log(`Generated ${tsFile} in ${resourcesDir}`);
-            totalCount++;
+        // 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);
         }
-        console.log(`Generated ${jsonFiles.length} TypeScript resource shims in ${resourcesDir}`);
-    }
-    else {
-        console.warn(`Resources directory not found at ${resourcesDir}`);
-    }
-    // Genesis (normalized) shim
-    try {
-        const genesisJsonPath = config.getNormalizedSourcePath();
-        if (fs.existsSync(genesisJsonPath)) {
-            fs.mkdirSync(generatedResourceTypesDir, { recursive: true });
-            const tsFile = 'Genesis.ts';
-            const content = generateShimContent('Genesis.json', 'schema');
-            const tsPath = path.join(generatedResourceTypesDir, tsFile);
-            fs.writeFileSync(tsPath, content, 'utf-8');
-            console.log(`Generated ${tsFile} in ${generatedResourceTypesDir}`);
-            totalCount++;
+        else {
+            // Standalone schemas are optional
+        }
+        // Process resources directory
+        if (fs.existsSync(resourcesDir)) {
+            const files = fs.readdirSync(resourcesDir);
+            const jsonFiles = files.filter((f) => f.endsWith('.json') && !f.startsWith('.'));
+            const shims = getShimsForFiles(jsonFiles, 'resources');
+            for (const [tsFile, content] of Object.entries(shims)) {
+                const tsPath = path.join(resourcesDir, tsFile);
+                fs.writeFileSync(tsPath, content, 'utf-8');
+                console.log('Generated ' + tsFile + ' in ' + resourcesDir);
+                totalCount++;
+            }
+            console.log('Generated ' + jsonFiles.length + ' TypeScript resource shims in ' + resourcesDir);
         }
         else {
-            console.warn(`Genesis source JSON not found at ${genesisJsonPath}; skipping Genesis.ts shim`);
+            console.warn('Resources directory not found at ' + resourcesDir);
+        }
+        // Genesis (normalized) shim
+        try {
+            const genesisJsonPath = config.getNormalizedSourcePath();
+            if (fs.existsSync(genesisJsonPath)) {
+                fs.mkdirSync(generatedResourceTypesDir, { recursive: true });
+                const tsFile = 'Genesis.ts';
+                const content = generateShimContent('Genesis.json', 'schema');
+                const tsPath = path.join(generatedResourceTypesDir, tsFile);
+                fs.writeFileSync(tsPath, content, 'utf-8');
+                console.log('Generated ' + tsFile + ' in ' + generatedResourceTypesDir);
+                totalCount++;
+            }
+            else {
+                console.warn('Genesis source JSON not found at ' + genesisJsonPath + '; skipping Genesis.ts shim');
+            }
+        }
+        catch (e) {
+            console.warn('Failed to generate Genesis.ts shim:', e);
         }
+        console.log('Generated ' + totalCount + ' total TypeScript shims');
     }
     catch (e) {
-        console.warn('Failed to generate Genesis.ts shim:', e);
+        console.error(e);
+        process.exitCode = 1;
     }
-    console.log(`Generated ${totalCount} total TypeScript shims`);
 }
-main().catch((e) => {
-    console.error(e);
-    process.exit(1);
-});
+main();