@toolproof-npm/schema 0.1.34 → 0.1.35

package/dist/index.d.ts

@@ -1,5 +1,8 @@
-export { default as GenesisSchema } from './schemas/Genesis.js';
-export { default as JobSchema } from './schemas/Job.js';
-export type { ResourceData_Job as ResourceData_JobJson } from './_lib/types/ResourceData_Job.js';
-export type { Identifiable as IdentifiableJson, Documented as DocumentedJson, IdentifiableDocumented as IdentifiableDocumentedJson, ResourceFormatId as ResourceFormatIdJson, ResourceFormatMeta as ResourceFormatMetaJson, ResourceFormatData as ResourceFormatDataJson, ExtractionSchema as ExtractionSchemaJson, ExtractionSchemaValue as ExtractionSchemaValueJson, IdentityProp as IdentityPropJson, MeritProp as MeritPropJson, ResourceTypeId as ResourceTypeIdJson, ResourceTypeMeta as ResourceTypeMetaJson, ResourceTypeData as ResourceTypeDataJson, ResourceRoleId as ResourceRoleIdJson, ResourceRoleValue as ResourceRoleValueJson, ExecutionId as ExecutionIdJson, Execution as ExecutionJson, ConditionalWrapper as ConditionalWrapperJson, RoleMap as RoleMapJson, RolesOuter as RolesOuterJson, RoleBindingMap as RoleBindingMapJson, RoleBindingsOuter as RoleBindingsOuterJson, ResourceId as ResourceIdJson, WorkStepId as WorkStepIdJson, BranchStepId as BranchStepIdJson, WhileStepId as WhileStepIdJson, ForStepId as ForStepIdJson, WorkStep as WorkStepJson, BranchStep as BranchStepJson, WhileStep as WhileStepJson, ForStep as ForStepJson, StepId as StepIdJson, Step as StepJson, ResourceSocket as ResourceSocketJson, ResourcePotentialInput as ResourcePotentialInputJson, ResourcePotentialOutput as ResourcePotentialOutputJson, ResourceRawMeta as ResourceRawMetaJson, ResourceMeta as ResourceMetaJson, ResourceData as ResourceDataJson, ResourceMap as ResourceMapJson, WorkflowId as WorkflowIdJson, Workflow as WorkflowJson, WorkflowSpecId as WorkflowSpecIdJson, WorkflowSpec as WorkflowSpecJson, Job as JobJson, JsonValue as JsonValueJson, } from './_lib/types/types.js';
-export { unsafeBrand, asResourceTypeId, asResourceRoleId, asExecutionId, asResourceId, asWorkStepId, asBranchStepId, asForStepId, asResourceFormatId, asWhileStepId, asWorkflowId, asWorkflowSpecId, asResourceTypeIds, asResourceRoleIds, asExecutionIds, asResourceIds, asWorkStepIds, asBranchStepIds, asForStepIds, asResourceFormatIds, asWhileStepIds, asWorkflowIds, asWorkflowSpecIds, } from './scripts/brandFactories.js';
+export { default as GenesisSchema } from './genesis/generated/schemas/Genesis.js';
+export { default as Genesis } from './genesis/resourceTypes/Genesis.js';
+export { default as JobSchema } from './genesis/generated/schemas/Job.js';
+export type { Resource_ResourceFormat as Resource_ResourceFormatJson } from './_lib/types/Resource_ResourceFormat.js';
+export type { Resource_ResourceType as Resource_ResourceTypeJson } from './_lib/types/Resource_ResourceType.js';
+export type { Resource_Job as Resource_JobJson } from './_lib/types/Resource_Job.js';
+export type { Documented as DocumentedJson, ResourceFormatId as ResourceFormatIdJson, ResourceFormat as ResourceFormatJson, ExtractionSchema as ExtractionSchemaJson, ExtractionSchemaValue as ExtractionSchemaValueJson, IdentityProp as IdentityPropJson, MeritProp as MeritPropJson, ResourceTypeId as ResourceTypeIdJson, ResourceType as ResourceTypeJson, ResourceRoleId as ResourceRoleIdJson, ResourceRoleValue as ResourceRoleValueJson, ExecutionId as ExecutionIdJson, Execution as ExecutionJson, ConditionalWrapper as ConditionalWrapperJson, RoleMap as RoleMapJson, RolesOuter as RolesOuterJson, RoleBindingMap as RoleBindingMapJson, RoleBindingsOuter as RoleBindingsOuterJson, ResourceId as ResourceIdJson, WorkStepId as WorkStepIdJson, BranchStepId as BranchStepIdJson, WhileStepId as WhileStepIdJson, ForStepId as ForStepIdJson, WorkStep as WorkStepJson, BranchStep as BranchStepJson, WhileStep as WhileStepJson, ForStep as ForStepJson, Step as StepJson, ResourceSocket as ResourceSocketJson, ResourcePotentialInput as ResourcePotentialInputJson, ResourcePotentialOutput as ResourcePotentialOutputJson, ResourceRawMeta as ResourceRawMetaJson, Resource as ResourceJson, StrategyState as StrategyStateJson, StrategyStateValue as StrategyStateValueJson, StatelessStrategy as StatelessStrategyIdJson, StatelessStrategy as StatelessStrategyJson, StatefulStrategyId as StatefulStrategyIdJson, StatefulStrategy as StatefulStrategyJson, Job as JobJson, JsonValue as JsonValueJson, } from './_lib/types/types.js';
+export { unsafeBrand, asResourceTypeId, asResourceRoleId, asExecutionId, asResourceId, asWorkStepId, asBranchStepId, asForStepId, asResourceFormatId, asWhileStepId, asStatelessStrategyId, asStatefulStrategyId, asResourceTypeIds, asResourceRoleIds, asExecutionIds, asResourceIds, asWorkStepIds, asBranchStepIds, asForStepIds, asResourceFormatIds, asWhileStepIds, asStatelessStrategyIds, asStatefulStrategyIds, } from './scripts/brandFactories.js';

package/dist/index.js

@@ -1,5 +1,6 @@
 // Re-export JSON schemas via .ts shims to avoid .json re-exports in declarations
-export { default as GenesisSchema } from './schemas/Genesis.js';
-export { default as JobSchema } from './schemas/Job.js';
+export { default as GenesisSchema } from './genesis/generated/schemas/Genesis.js';
+export { default as Genesis } from './genesis/resourceTypes/Genesis.js';
+export { default as JobSchema } from './genesis/generated/schemas/Job.js';
 // Re-export brand factories so consumers can construct branded IDs at runtime.
-export { unsafeBrand, asResourceTypeId, asResourceRoleId, asExecutionId, asResourceId, asWorkStepId, asBranchStepId, asForStepId, asResourceFormatId, asWhileStepId, asWorkflowId, asWorkflowSpecId, asResourceTypeIds, asResourceRoleIds, asExecutionIds, asResourceIds, asWorkStepIds, asBranchStepIds, asForStepIds, asResourceFormatIds, asWhileStepIds, asWorkflowIds, asWorkflowSpecIds, } from './scripts/brandFactories.js';
+export { unsafeBrand, asResourceTypeId, asResourceRoleId, asExecutionId, asResourceId, asWorkStepId, asBranchStepId, asForStepId, asResourceFormatId, asWhileStepId, asStatelessStrategyId, asStatefulStrategyId, asResourceTypeIds, asResourceRoleIds, asExecutionIds, asResourceIds, asWorkStepIds, asBranchStepIds, asForStepIds, asResourceFormatIds, asWhileStepIds, asStatelessStrategyIds, asStatefulStrategyIds, } from './scripts/brandFactories.js';

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

@@ -0,0 +1,45 @@
+/**
+ * Configuration for schema generation scripts
+ * All paths are configurable via environment variables
+ * Provides sensible defaults for standard project structure
+ */
+/**
+ * Schema configuration with required environment variables
+ */
+export declare class SchemaConfig {
+    private readonly root;
+    private readonly sourceDir;
+    private readonly sourceFile;
+    private readonly outputDir;
+    private readonly typesSrcDir;
+    private readonly typesDistDir;
+    private readonly baseUrl;
+    private readonly version;
+    constructor();
+    getRoot(): string;
+    getSourceDir(): string;
+    getSourceFile(): string;
+    getSourcePath(): string;
+    getOutputDir(): string;
+    getOutputPath(filename: string): string;
+    getTypesSrcDir(): string;
+    getTypesDistDir(): string;
+    getTypesSrcPath(filename: string): string;
+    getTypesDistPath(filename: string): string;
+    getBaseUrl(): string;
+    getVersion(): string;
+    getSchemaId(schemaName: string): string;
+    /**
+     * Check if a URL matches the configured schema base URL pattern
+     */
+    isSchemaUrl(url: string): boolean;
+    /**
+     * Extract schema name from URL (removes base URL and version prefix)
+     */
+    extractSchemaName(url: string): string;
+}
+/**
+ * Get the schema configuration singleton
+ * Throws error if required environment variables are not set
+ */
+export declare function getConfig(): SchemaConfig;

package/dist/scripts/_lib/config.js

@@ -0,0 +1,109 @@
+/**
+ * Configuration for schema generation scripts
+ * All paths are configurable via environment variables
+ * Provides sensible defaults for standard project structure
+ */
+import path from 'path';
+/**
+ * Get environment variable with optional default
+ */
+function getEnv(name, defaultValue) {
+    const value = process.env[name];
+    return value || defaultValue;
+}
+/**
+ * Schema configuration with required environment variables
+ */
+export class SchemaConfig {
+    constructor() {
+        // Environment variables with sensible defaults
+        this.root = getEnv('TP_SCHEMA_ROOT', process.cwd());
+        this.sourceDir = getEnv('TP_SCHEMA_SOURCE_DIR', 'src/genesis/resourceTypes');
+        this.sourceFile = getEnv('TP_SCHEMA_SOURCE_FILE', 'Genesis.json');
+        this.outputDir = getEnv('TP_SCHEMA_OUTPUT_DIR', 'src/genesis/generated/schemas');
+        this.typesSrcDir = getEnv('TP_SCHEMA_TYPES_SRC_DIR', 'src/_lib/types');
+        this.typesDistDir = getEnv('TP_SCHEMA_TYPES_DIST_DIR', 'dist/_lib/types');
+        this.baseUrl = getEnv('TP_SCHEMA_BASE_URL', 'https://schemas.toolproof.com');
+        this.version = getEnv('TP_SCHEMA_VERSION', 'v0');
+    }
+    // Path getters
+    getRoot() {
+        return this.root;
+    }
+    getSourceDir() {
+        return path.isAbsolute(this.sourceDir)
+            ? this.sourceDir
+            : path.join(this.root, this.sourceDir);
+    }
+    getSourceFile() {
+        return this.sourceFile;
+    }
+    getSourcePath() {
+        return path.join(this.getSourceDir(), this.sourceFile);
+    }
+    getOutputDir() {
+        return path.isAbsolute(this.outputDir)
+            ? this.outputDir
+            : path.join(this.root, this.outputDir);
+    }
+    getOutputPath(filename) {
+        return path.join(this.getOutputDir(), filename);
+    }
+    getTypesSrcDir() {
+        return path.isAbsolute(this.typesSrcDir)
+            ? this.typesSrcDir
+            : path.join(this.root, this.typesSrcDir);
+    }
+    getTypesDistDir() {
+        return path.isAbsolute(this.typesDistDir)
+            ? this.typesDistDir
+            : path.join(this.root, this.typesDistDir);
+    }
+    getTypesSrcPath(filename) {
+        return path.join(this.getTypesSrcDir(), filename);
+    }
+    getTypesDistPath(filename) {
+        return path.join(this.getTypesDistDir(), filename);
+    }
+    // Schema URL methods
+    getBaseUrl() {
+        return this.baseUrl;
+    }
+    getVersion() {
+        return this.version;
+    }
+    getSchemaId(schemaName) {
+        return `${this.baseUrl}/${this.version}/${schemaName}.json`;
+    }
+    /**
+     * Check if a URL matches the configured schema base URL pattern
+     */
+    isSchemaUrl(url) {
+        const baseUrlPattern = this.baseUrl.replace('https://', 'https?://');
+        return new RegExp(`^${baseUrlPattern}/`, 'i').test(url);
+    }
+    /**
+     * Extract schema name from URL (removes base URL and version prefix)
+     */
+    extractSchemaName(url) {
+        // Remove base URL
+        let name = url.replace(new RegExp(`^${this.baseUrl}/`, 'i'), '');
+        // Remove version prefix (v0/, v1/, etc.)
+        name = name.replace(/^v\d+\//, '');
+        // Remove .json extension
+        name = name.replace(/\.json$/, '');
+        return name;
+    }
+}
+// Singleton instance
+let configInstance = null;
+/**
+ * Get the schema configuration singleton
+ * Throws error if required environment variables are not set
+ */
+export function getConfig() {
+    if (!configInstance) {
+        configInstance = new SchemaConfig();
+    }
+    return configInstance;
+}

package/dist/scripts/brandFactories.d.ts

@@ -1,4 +1,4 @@
-import type { ExecutionId, ResourceId, WorkStepId, BranchStepId, ForStepId, ResourceFormatId, ResourceTypeId, ResourceRoleId, WhileStepId, WorkflowId, WorkflowSpecId } from "../_lib/types/types.js";
+import type { ExecutionId, ResourceId, WorkStepId, BranchStepId, ForStepId, ResourceFormatId, ResourceTypeId, ResourceRoleId, WhileStepId, StatelessStrategyId, StatefulStrategyId } from "../_lib/types/types.js";
 /** Generic unsafe brand helper when a bespoke factory is not available. */
 export declare function unsafeBrand<T extends string>(s: string): T;
 export declare const asResourceTypeId: (s: string) => string;
@@ -10,8 +10,8 @@ export declare const asBranchStepId: (s: string) => string;
 export declare const asForStepId: (s: string) => string;
 export declare const asResourceFormatId: (s: string) => string;
 export declare const asWhileStepId: (s: string) => string;
-export declare const asWorkflowId: (s: string) => string;
-export declare const asWorkflowSpecId: (s: string) => string;
+export declare const asStatelessStrategyId: (s: string) => string;
+export declare const asStatefulStrategyId: (s: string) => string;
 export declare const asResourceTypeIds: (xs: string[]) => ResourceTypeId[];
 export declare const asResourceRoleIds: (xs: string[]) => ResourceRoleId[];
 export declare const asExecutionIds: (xs: string[]) => ExecutionId[];
@@ -21,5 +21,5 @@ export declare const asBranchStepIds: (xs: string[]) => BranchStepId[];
 export declare const asForStepIds: (xs: string[]) => ForStepId[];
 export declare const asResourceFormatIds: (xs: string[]) => ResourceFormatId[];
 export declare const asWhileStepIds: (xs: string[]) => WhileStepId[];
-export declare const asWorkflowIds: (xs: string[]) => WorkflowId[];
-export declare const asWorkflowSpecIds: (xs: string[]) => WorkflowSpecId[];
+export declare const asStatelessStrategyIds: (xs: string[]) => StatelessStrategyId[];
+export declare const asStatefulStrategyIds: (xs: string[]) => StatefulStrategyId[];

package/dist/scripts/brandFactories.js

@@ -20,7 +20,6 @@ export function unsafeBrand(s) {
 }
 // Known patterns from schemas (when available)
 const RE_TYPE_ID = /^TYPE-.+$/;
-const RE_SIGNATURE_ID = /^SIGNATURE-.+$/;
 const RE_JOB_ID = /^JOB-.+$/;
 const RE_ROLE_ID = /^ROLE-.+$/;
 // Factories for each Id-like type
@@ -34,8 +33,8 @@ export const asBranchStepId = makeFactory("BranchStepId");
 export const asForStepId = makeFactory("ForStepId");
 export const asResourceFormatId = makeFactory("ResourceFormatId");
 export const asWhileStepId = makeFactory("WhileStepId");
-export const asWorkflowId = makeFactory("WorkflowId");
-export const asWorkflowSpecId = makeFactory("WorkflowSpecId");
+export const asStatelessStrategyId = makeFactory("StatelessStrategyId");
+export const asStatefulStrategyId = makeFactory("StatefulStrategyId");
 // Batch helpers
 export const asResourceTypeIds = (xs) => xs.map(asResourceTypeId);
 export const asResourceRoleIds = (xs) => xs.map(asResourceRoleId);
@@ -46,5 +45,5 @@ export const asBranchStepIds = (xs) => xs.map(asBranchStepId);
 export const asForStepIds = (xs) => xs.map(asForStepId);
 export const asResourceFormatIds = (xs) => xs.map(asResourceFormatId);
 export const asWhileStepIds = (xs) => xs.map(asWhileStepId);
-export const asWorkflowIds = (xs) => xs.map(asWorkflowId);
-export const asWorkflowSpecIds = (xs) => xs.map(asWorkflowSpecId);
+export const asStatelessStrategyIds = (xs) => xs.map(asStatelessStrategyId);
+export const asStatefulStrategyIds = (xs) => xs.map(asStatefulStrategyId);

package/dist/scripts/extractSchemas.js

@@ -1,7 +1,9 @@
 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 = "";
@@ -12,15 +14,28 @@ function parseArgs() {
             inPath = argv[++i];
         else if (a === "--out" && i + 1 < argv.length)
             outPath = argv[++i];
-        else if (a === "--id" && i + 1 < argv.length)
-            topLevelId = argv[++i];
+        else if (a === "--id" && i + 1 < argv.length) {
+            let v = argv[++i];
+            // Strip accidental surrounding quotes from PowerShell/cmd
+            if ((v.startsWith("'") && v.endsWith("'")) || (v.startsWith('"') && v.endsWith('"'))) {
+                v = v.slice(1, -1);
+            }
+            topLevelId = v;
+        }
+    }
+    // Use config defaults if not provided via CLI
+    if (!inPath) {
+        // Use normalized version with anchor refs rewritten to pointers
+        inPath = config.getSourcePath().replace('.json', '.normalized.json');
     }
-    if (!inPath || !outPath) {
-        console.error("Usage: node extractSchemas.js --in <Genesis.json> --out <flattened.json> [--id <schemaId>]");
-        process.exit(1);
+    if (!outPath) {
+        outPath = config.getOutputPath(config.getSourceFile());
+    }
+    if (!topLevelId) {
+        topLevelId = config.getSchemaId('Genesis');
     }
     // Resolve to absolute paths from project root
-    const cwd = process.cwd();
+    const cwd = config.getRoot();
     const wasInRelative = !path.isAbsolute(inPath);
     const wasOutRelative = !path.isAbsolute(outPath);
     if (wasInRelative)
@@ -48,7 +63,10 @@ function parseArgs() {
 // Heuristic: determine if a node is a Type envelope
 function isTypeEnvelope(node) {
     return (node && typeof node === "object" && !Array.isArray(node) &&
-        typeof node.id === "string" && node.name && node.extractionSchema && typeof node.extractionSchema === "object");
+        // Treat any object that has an 'extractionSchema' AND 'identity' as a Type envelope
+        // This prevents false positives where 'extractionSchema' is just a regular schema property
+        node.extractionSchema && typeof node.extractionSchema === "object" &&
+        node.identity && typeof node.identity === "string");
 }
 // Merge $defs into target, without overwriting existing keys unless identical
 function mergeDefs(target, source, label) {
@@ -135,11 +153,18 @@ function main() {
         // If flattened is not an object (should be rare for a top-level schema), wrap it
         base = { const: flattened };
     }
+    // Assemble, but avoid duplicating $id: if the flattened base already has $id, prefer it.
     const output = {
         $schema: "https://json-schema.org/draft/2020-12/schema",
-        ...(topLevelId ? { $id: topLevelId } : {}),
         ...base,
     };
+    if (topLevelId && !output.$id) {
+        output.$id = topLevelId;
+    }
+    // Enforce presence of $id: schema must declare an absolute identity.
+    if (!output.$id) {
+        throw new Error("Flattened schema must define $id. Provide it via CLI --id or include $id in the source extractionSchema.");
+    }
     // Merge collected defs into output.$defs, taking care not to clobber any existing
     if (!("$defs" in output))
         output.$defs = {};

package/dist/scripts/extractSubschemaWithDefs.js

@@ -1,5 +1,6 @@
 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
@@ -10,18 +11,18 @@ import path from 'path';
  * Usage:
  *   node ./dist/scripts/extractSubschemaWithDefs.js --name <DefName>
  *
- * Writes: src/schemas/<DefName>.json
+ * Writes: src/genesis/generated/schemas/<DefName>.json
  */
 async function main() {
+    const config = getConfig();
     const { name } = parseArgs(process.argv.slice(2));
     if (!name) {
         console.error('Missing --name <DefName> argument');
         process.exit(1);
     }
-    const projectRoot = process.cwd();
-    const schemasDir = path.join(projectRoot, 'src', 'schemas');
-    const genesisPath = path.join(schemasDir, 'Genesis.json');
-    const outPath = path.join(schemasDir, `${name}.json`);
+    const schemasDir = config.getOutputDir();
+    const genesisPath = path.join(schemasDir, config.getSourceFile());
+    const outPath = config.getOutputPath(`${name}.json`);
     if (!fs.existsSync(genesisPath)) {
         console.error(`Genesis.json not found at ${genesisPath}`);
         process.exit(1);
@@ -89,7 +90,7 @@ function deepClone(v) {
     }
     return v;
 }
-function extractLocalDefName(ref) {
+function extractPointerDefName(ref) {
     // Accept refs like '#/$defs/Name' only (single-level under $defs)
     if (!ref || !ref.startsWith('#/'))
         return null;
@@ -102,6 +103,34 @@ function extractLocalDefName(ref) {
     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 extractionSchema.$anchor equals 'Name'
+    if (ref.startsWith('#') && !ref.startsWith('#/')) {
+        const anchor = ref.slice(1);
+        if (!anchor)
+            return null;
+        for (const [defName, defSchema] of Object.entries(rootDefs)) {
+            if (!defSchema || typeof defSchema !== 'object')
+                continue;
+            // Flattened Genesis has defs as the extraction schema itself (with $anchor at the top level).
+            // Unflattened may have { extractionSchema: { $anchor } } envelopes. Support both.
+            const topLevelAnchor = defSchema.$anchor;
+            const nested = defSchema.extractionSchema;
+            const nestedAnchor = nested && typeof nested === 'object' ? nested.$anchor : undefined;
+            const defAnchor = typeof topLevelAnchor === 'string' ? topLevelAnchor : (typeof nestedAnchor === 'string' ? nestedAnchor : undefined);
+            if (defAnchor === anchor) {
+                return defName;
+            }
+        }
+    }
+    return null;
+}
 function collectLocalDefClosure(node, rootDefs) {
     const needed = new Set();
     const queue = [];
@@ -114,7 +143,7 @@ function collectLocalDefClosure(node, rootDefs) {
         if (!isObject(n))
             return;
         if (typeof n.$ref === 'string') {
-            const name = extractLocalDefName(n.$ref);
+            const name = resolveRefToDefName(n.$ref, rootDefs);
             if (name && !needed.has(name)) {
                 needed.add(name);
                 queue.push(name);

package/dist/scripts/generateResourceEnvelopes.js

@@ -0,0 +1,77 @@
+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
+ * that conforms to the Resource.extractionSchema 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
+ */
+async function main() {
+    const config = getConfig();
+    // Use normalized version with anchor refs rewritten to pointers
+    const genesisSourcePath = config.getSourcePath().replace('.json', '.normalized.json');
+    const outputPath = path.join(config.getRoot(), 'src', 'genesis', 'generated', 'resources', 'Genesis.json');
+    if (!fs.existsSync(genesisSourcePath)) {
+        console.error(`Genesis source file not found at ${genesisSourcePath}`);
+        process.exit(1);
+    }
+    const raw = fs.readFileSync(genesisSourcePath, 'utf-8');
+    const genesis = JSON.parse(raw);
+    // Validate that this is a ResourceType with extractionSchema
+    if (!genesis.extractionSchema || !genesis.extractionSchema.$defs) {
+        console.error('Genesis.json must have extractionSchema.$defs');
+        process.exit(1);
+    }
+    const defs = genesis.extractionSchema.$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',
+        resourceTypeId: 'TYPE-ResourceType',
+        creationContext: {
+            resourceRoleId: 'ROLE-Genesis',
+            executionId: 'EXECUTION-Genesis'
+        },
+        kind: 'materialized',
+        timestamp: genesisTimestamp,
+        extractedData: {}
+    };
+    // Generate resources for all other $defs
+    defKeys.forEach((defName) => {
+        const defValue = defs[defName];
+        resources[defName] = {
+            identity: `RESOURCE-${defName}`,
+            resourceTypeId: 'TYPE-ResourceType',
+            creationContext: {
+                resourceRoleId: 'ROLE-Genesis',
+                executionId: `EXECUTION-${defName}`
+            },
+            kind: 'materialized',
+            timestamp: genesisTimestamp,
+            extractedData: defValue
+        };
+    });
+    // Ensure output directory exists
+    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 ${defKeys.length + 1} Resource envelopes -> ${outputPath}`);
+}
+main().catch((e) => {
+    console.error(e);
+    process.exit(1);
+});

package/dist/scripts/generateResourceTypeType.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -1,21 +1,23 @@
 import fs from 'fs';
 import path from 'path';
 import { compileFromFile } from 'json-schema-to-typescript';
+import { getConfig } from './_lib/config.js';
 /**
- * Generate a typed ResourceData variant where `extractedData` is typed to a specific schema
- * extracted under `src/schemas/<name>.json`.
+ * Generate a typed Resource variant where `extractedData` is typed to a specific schema
+ * extracted under the configured output directory.
  *
- * Usage: node ./dist/scripts/generateResourceData_js --name Job
+ * Usage: node ./dist/scripts/generateResourceTypeType.js --name Job
  */
 async function main() {
+    const config = getConfig();
     const { name } = parseArgs(process.argv.slice(2));
     if (!name) {
         console.error('Missing --name <SchemaBasename> argument');
         process.exit(1);
     }
-    const projectRoot = process.cwd();
-    const schemasDir = path.join(projectRoot, 'src', 'schemas');
-    const inPath = path.join(schemasDir, `${name}.json`);
+    const projectRoot = config.getRoot();
+    const schemasDir = config.getOutputDir();
+    const inPath = config.getOutputPath(`${name}.json`);
     if (!fs.existsSync(inPath)) {
         console.error(`Schema file not found: ${inPath}`);
         process.exit(1);
@@ -38,21 +40,21 @@ async function main() {
         console.warn(`Warning: ExtractionSchema usually has type: 'object' but this schema has type: '${parsed.type}'. Proceeding.`);
     }
     // Ensure output folder exists
-    const outDir = path.join(projectRoot, 'src', '_lib', 'types');
+    const outDir = config.getTypesSrcDir();
     fs.mkdirSync(outDir, { recursive: true });
-    const outName = `ResourceData_${name}.d.ts`;
-    const outPath = path.join(outDir, outName);
-    const outJsName = `ResourceData_${name}.js`;
-    const outJsPath = path.join(outDir, outJsName);
-    // Build a composite schema in src/schemas so that local $ref paths are simple
-    const schemasOutDir = path.join(projectRoot, 'src', 'schemas');
-    const compositePath = path.join(schemasOutDir, `.composite.ResourceData_${name}.json`);
+    const outName = `Resource_${name}.d.ts`;
+    const outPath = config.getTypesSrcPath(outName);
+    const outJsName = `Resource_${name}.js`;
+    const outJsPath = config.getTypesSrcPath(outJsName);
+    // Build a composite schema in output directory so that local $ref paths are simple
+    const schemasOutDir = config.getOutputDir();
+    const compositePath = path.join(schemasOutDir, `.composite.Resource_${name}.json`);
     const compositeSchema = {
         $schema: 'https://json-schema.org/draft/2020-12/schema',
-        title: `ResourceData_${name}`,
+        title: `Resource_${name}`,
         type: 'object',
         allOf: [
-            { $ref: './Genesis.json#/$defs/ResourceMetaBase' },
+            { $ref: `./${config.getSourceFile()}#/$defs/ResourceMetaBase` },
             {
                 type: 'object',
                 required: ['extractedData'],
@@ -95,10 +97,10 @@ async function main() {
             console.log(`Wrote ${outJsPath}`);
         }
         // Also copy both files into dist so consumers can resolve the module and its types
-        const distLibDir = path.join(projectRoot, 'dist', '_lib', 'types');
+        const distLibDir = config.getTypesDistDir();
         fs.mkdirSync(distLibDir, { recursive: true });
-        const distDtsPath = path.join(distLibDir, outName);
-        const distJsPath = path.join(distLibDir, outJsName);
+        const distDtsPath = config.getTypesDistPath(outName);
+        const distJsPath = config.getTypesDistPath(outJsName);
         fs.writeFileSync(distDtsPath, header + ts, 'utf8');
         fs.writeFileSync(distJsPath, 'export {}\n', 'utf8');
         console.log(`Wrote ${distDtsPath}`);

package/dist/scripts/generateSchemaShims.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/generateSchemaShims.js

@@ -0,0 +1,63 @@
+import fs from 'fs';
+import path from 'path';
+import { getConfig } from './_lib/config.js';
+/**
+ * Generate TypeScript shim files for all JSON schemas and resources
+ *
+ * Creates .ts files that import and re-export .json files using
+ * the JSON import assertion syntax. This enables proper dependency resolution
+ * 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)
+ *
+ * Usage: node ./dist/scripts/generateSchemaShims.js
+ */
+async function main() {
+    const config = getConfig();
+    const schemasDir = config.getOutputDir();
+    const resourcesDir = path.join(path.dirname(schemasDir), 'resources');
+    // Process schemas directory
+    let totalCount = 0;
+    if (fs.existsSync(schemasDir)) {
+        const files = fs.readdirSync(schemasDir);
+        const jsonFiles = files.filter(f => f.endsWith('.json') && !f.startsWith('.'));
+        for (const jsonFile of jsonFiles) {
+            const baseName = path.basename(jsonFile, '.json');
+            const tsFile = `${baseName}.ts`;
+            const tsPath = path.join(schemasDir, tsFile);
+            const content = `import schema from './${jsonFile}' with { type: 'json' };\nexport default schema;\n`;
+            fs.writeFileSync(tsPath, content, 'utf-8');
+            console.log(`Generated ${tsFile}`);
+            totalCount++;
+        }
+        console.log(`Generated ${jsonFiles.length} TypeScript schema shims in ${schemasDir}`);
+    }
+    else {
+        console.warn(`Schemas directory not found at ${schemasDir}`);
+    }
+    // Process resources directory
+    if (fs.existsSync(resourcesDir)) {
+        const files = fs.readdirSync(resourcesDir);
+        const jsonFiles = files.filter(f => f.endsWith('.json') && !f.startsWith('.'));
+        for (const jsonFile of jsonFiles) {
+            const baseName = path.basename(jsonFile, '.json');
+            const tsFile = `${baseName}.ts`;
+            const tsPath = path.join(resourcesDir, tsFile);
+            const content = `import resources from './${jsonFile}' with { type: 'json' };\nexport default resources;\n`;
+            fs.writeFileSync(tsPath, content, 'utf-8');
+            console.log(`Generated ${tsFile}`);
+            totalCount++;
+        }
+        console.log(`Generated ${jsonFiles.length} TypeScript resource shims in ${resourcesDir}`);
+    }
+    else {
+        console.warn(`Resources directory not found at ${resourcesDir}`);
+    }
+    console.log(`Generated ${totalCount} total TypeScript shims`);
+}
+main().catch((e) => {
+    console.error(e);
+    process.exit(1);
+});