@toolproof-core/schema 1.0.9 → 1.0.10

package/dist/scripts/generateConstantsAndMappings.js

@@ -0,0 +1,243 @@
+import fs from 'fs';
+import path from 'path';
+import { getConfig } from './_lib/config.js';
+// PURE: Convert a string enum member into PascalCase.
+// Examples: 'job' -> 'Job', 'graph_start' -> 'GraphStart'
+function toPascalCase(value) {
+    return value
+        .split(/[^A-Za-z0-9]+/g)
+        .filter(Boolean)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join('');
+}
+// PURE: Attempt to derive a canonical identity prefix from a canonical identity regex pattern.
+function deriveIdentityPrefixFromPattern(pattern) {
+    // Canonical (currently used across schemas): ^PREFIX-.+$
+    const match = /^\^([^$]+)\.\+\$$/.exec(pattern);
+    if (!match)
+        return undefined;
+    const prefix = match[1];
+    if (!prefix || /[`\n\r]/.test(prefix))
+        return undefined;
+    return prefix;
+}
+// PURE: Extract all identity prefixes from `$defs/*Identity` string-pattern definitions.
+export function extractIdentityPrefixes(schema) {
+    if (!schema || typeof schema !== 'object')
+        return {};
+    const defs = schema.$defs;
+    if (!defs || typeof defs !== 'object')
+        return {};
+    const defEntries = Object.entries(defs);
+    defEntries.sort(([a], [b]) => a.localeCompare(b));
+    const out = {};
+    for (const [defName, defVal] of defEntries) {
+        if (!/Identity$/.test(defName))
+            continue;
+        if (!defVal || typeof defVal !== 'object' || Array.isArray(defVal))
+            continue;
+        const v = defVal;
+        if (v.type !== 'string')
+            continue;
+        if (typeof v.pattern !== 'string')
+            continue;
+        const prefix = deriveIdentityPrefixFromPattern(v.pattern);
+        if (!prefix)
+            continue;
+        out[defName] = prefix;
+    }
+    return out;
+}
+// PURE: Extract all subschema names from `$defs/*`.
+// Shape: { JobStep: 'JobStep', StepKind: 'StepKind', ... }
+export function extractSubschemaNames(schema) {
+    if (!schema || typeof schema !== 'object')
+        return {};
+    const defs = schema.$defs;
+    if (!defs || typeof defs !== 'object')
+        return {};
+    const defEntries = Object.entries(defs);
+    defEntries.sort(([a], [b]) => a.localeCompare(b));
+    const out = {};
+    for (const [defName] of defEntries) {
+        if (!defName || /[\n\r`]/.test(defName))
+            continue;
+        out[defName] = defName;
+    }
+    return out;
+}
+// PURE: Extract all string enums from `$defs/*Kind|*Status` definitions.
+// Shape: { StepKind: { job: 'job', ... }, ResourceShellKind: { inputPotential': 'inputPotential', ... } }
+export function extractEnums(schema) {
+    if (!schema || typeof schema !== 'object')
+        return {};
+    const defs = schema.$defs;
+    if (!defs || typeof defs !== 'object')
+        return {};
+    const defEntries = Object.entries(defs);
+    defEntries.sort(([a], [b]) => a.localeCompare(b));
+    const out = {};
+    for (const [defName, defVal] of defEntries) {
+        if (!/(Kind|Status)$/.test(defName))
+            continue;
+        if (!defVal || typeof defVal !== 'object' || Array.isArray(defVal))
+            continue;
+        const v = defVal;
+        if (v.type !== 'string')
+            continue;
+        if (!Array.isArray(v.enum) || v.enum.length === 0)
+            continue;
+        if (v.enum.some((x) => typeof x !== 'string'))
+            continue;
+        const members = {};
+        for (const member of v.enum) {
+            members[member] = member;
+        }
+        out[defName] = members;
+    }
+    return out;
+}
+// PURE: Derive a StepKind -> StepIdentityPrefix mapping.
+// Example: { job: 'job' } + IdentityNameToIdentityPrefix['JobStepIdentity']='JOB_STEP-' => { job: 'JOB_STEP-' }
+export function deriveStepKindToStepIdentityPrefix(enums, identityNameToIdentityPrefix) {
+    const stepKindEnum = enums.StepKind;
+    if (!stepKindEnum || typeof stepKindEnum !== 'object')
+        return { mapping: {}, missing: [] };
+    const stepKinds = Object.keys(stepKindEnum).sort((a, b) => a.localeCompare(b));
+    const mapping = {};
+    const missing = [];
+    for (const stepKind of stepKinds) {
+        const identityName = `${toPascalCase(stepKind)}StepIdentity`;
+        const prefix = identityNameToIdentityPrefix[identityName];
+        if (!prefix) {
+            missing.push({ stepKind, identityName });
+            continue;
+        }
+        mapping[stepKind] = prefix;
+    }
+    return { mapping, missing };
+}
+// PURE: Extract generated CONSTANTS + MAPPINGS from a parsed schema.
+export function extractGeneratedConstantsAndMappings(schema) {
+    const names = extractSubschemaNames(schema);
+    const enums = extractEnums(schema);
+    const identityPrefixes = extractIdentityPrefixes(schema);
+    const derivedStepKind = deriveStepKindToStepIdentityPrefix(enums, identityPrefixes);
+    return {
+        CONSTANTS: {
+            Names: names,
+            Enums: enums,
+        },
+        MAPPINGS: {
+            IdentityNameToIdentityPrefix: identityPrefixes,
+            StepKindToStepIdentityPrefix: derivedStepKind.mapping,
+        },
+        DIAGNOSTICS: {
+            missingStepKindIdentityPrefixes: derivedStepKind.missing,
+        },
+    };
+}
+// PURE: Render helpers for TS keys/strings.
+function escapeTsString(value) {
+    return value
+        .replace(/\\/g, '\\\\')
+        .replace(/\r/g, '\\r')
+        .replace(/\n/g, '\\n')
+        .replace(/\t/g, '\\t')
+        .replace(/'/g, "\\'");
+}
+function renderTsStringLiteral(value) {
+    return `'${escapeTsString(value)}'`;
+}
+function isValidTsIdentifier(key) {
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key);
+}
+function renderTsKey(key) {
+    return isValidTsIdentifier(key) ? key : renderTsStringLiteral(key);
+}
+// PURE: Render constants TypeScript source.
+export function renderConstantsTs(constants) {
+    const nameKeys = Object.keys(constants.Names).sort((a, b) => a.localeCompare(b));
+    const enumKeys = Object.keys(constants.Enums).sort((a, b) => a.localeCompare(b));
+    const lines = [];
+    lines.push('const CONSTANTS = {');
+    lines.push('    Names: {');
+    for (const key of nameKeys) {
+        const value = constants.Names[key] ?? '';
+        lines.push(`        ${renderTsKey(key)}: ${renderTsStringLiteral(value)},`);
+    }
+    lines.push('    },');
+    lines.push('    Enums: {');
+    for (const key of enumKeys) {
+        const members = constants.Enums[key] ?? {};
+        lines.push(`        ${renderTsKey(key)}: {`);
+        for (const memberKey of Object.keys(members)) {
+            const value = members[memberKey] ?? '';
+            lines.push(`            ${renderTsKey(memberKey)}: ${renderTsStringLiteral(value)},`);
+        }
+        lines.push('        },');
+    }
+    lines.push('    }');
+    lines.push('} as const;');
+    lines.push('');
+    lines.push('export default CONSTANTS;');
+    lines.push('');
+    return lines.join('\n');
+}
+// PURE: Render mappings TypeScript source.
+export function renderMappingsTs(mappings) {
+    const identityKeys = Object.keys(mappings.IdentityNameToIdentityPrefix).sort((a, b) => a.localeCompare(b));
+    const stepKindKeys = Object.keys(mappings.StepKindToStepIdentityPrefix).sort((a, b) => a.localeCompare(b));
+    const lines = [];
+    lines.push('const MAPPINGS = {');
+    lines.push('    IdentityNameToIdentityPrefix: {');
+    for (const key of identityKeys) {
+        const value = mappings.IdentityNameToIdentityPrefix[key] ?? '';
+        lines.push(`        ${renderTsKey(key)}: ${renderTsStringLiteral(value)},`);
+    }
+    lines.push('    },');
+    lines.push('    StepKindToStepIdentityPrefix: {');
+    for (const key of stepKindKeys) {
+        const value = mappings.StepKindToStepIdentityPrefix[key] ?? '';
+        lines.push(`        ${renderTsKey(key)}: ${renderTsStringLiteral(value)},`);
+    }
+    lines.push('    },');
+    lines.push('} as const;');
+    lines.push('');
+    lines.push('export default MAPPINGS;');
+    lines.push('');
+    return lines.join('\n');
+}
+// IMPURE: Script entrypoint (config + filesystem I/O + console + process exit code).
+function main() {
+    try {
+        const config = getConfig();
+        const inPath = config.getSchemaPath('Genesis.json');
+        const outConstantsPath = config.getArtifactsPath('constants.ts');
+        const outMappingsPath = config.getArtifactsPath('mappings.ts');
+        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 { CONSTANTS, MAPPINGS, DIAGNOSTICS } = extractGeneratedConstantsAndMappings(doc);
+        if (DIAGNOSTICS.missingStepKindIdentityPrefixes.length) {
+            const rows = DIAGNOSTICS.missingStepKindIdentityPrefixes
+                .map(({ stepKind, identityName }) => `${stepKind} -> ${identityName}`)
+                .join(', ');
+            throw new Error(`Missing IdentityNameToIdentityPrefix entries required for StepKindToStepIdentityPrefix: ${rows}`);
+        }
+        const constantsTs = renderConstantsTs(CONSTANTS);
+        const mappingsTs = renderMappingsTs(MAPPINGS);
+        fs.mkdirSync(path.dirname(outConstantsPath), { recursive: true });
+        fs.writeFileSync(outConstantsPath, constantsTs, 'utf8');
+        fs.writeFileSync(outMappingsPath, mappingsTs, 'utf8');
+        console.log(`Wrote constants to ${outConstantsPath}`);
+        console.log(`Wrote mappings to ${outMappingsPath}`);
+    }
+    catch (error) {
+        console.error(`Error generating constants/mappings: ${error?.message ?? error}`);
+        process.exitCode = 1;
+    }
+}
+main();

package/dist/scripts/generateDependencies.js

@@ -88,7 +88,7 @@ function main() {
     try {
         const config = getConfig();
         const inPath = config.getSchemaPath("Genesis.json");
-        const outPath = config.getDependencyMapPath();
+        const outPath = config.getArtifactsPath("dependencyMap.json");
         if (!fs.existsSync(inPath)) {
             throw new Error(`Genesis schema not found at ${inPath}. Run extractSchemasFromResourceTypeShells first.`);
         }

package/dist/scripts/generateTerminals.js

@@ -37,8 +37,8 @@ function computeTerminalsInKeyOrder(dependencyMap) {
 function main() {
     try {
         const config = getConfig();
-        const inPath = config.getDependencyMapPath();
-        const outPath = path.join(path.dirname(inPath), "terminals.json");
+        const inPath = config.getArtifactsPath("dependencyMap.json");
+        const outPath = config.getArtifactsPath("terminals.json");
         if (!fs.existsSync(inPath)) {
             throw new Error(`Dependency map not found at ${inPath}. Run generateDependencies first.`);
         }

package/dist/scripts/generateTypes.js

@@ -227,6 +227,48 @@ function removeDuplicateUnionEntries(ts) {
 function escapeRegExpLiteral(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
+// PURE: Derive the TS value type for JobStepSocket from Genesis.json.
+// We prefer to match the schema shape:
+//   JobStepSocket.additionalProperties.oneOf = [#ResourcePotential, #Resource]
+// so the emitted TS becomes:
+//   Record<ResourceRoleIdentity, Resource | ResourcePotential>
+function deriveJobStepSocketValueType(parsedSchema) {
+    // NOTE: The generator reads from `src/generated/schemas/Genesis.json`, where `$defs.*`
+    // entries are plain JSON-Schema objects.
+    // The source-of-truth `src/Genesis.json` uses a wrapper shape:
+    //   $defs.X = { identity, name, description, nucleusSchema: { ...actual schema... } }
+    // Support both.
+    const defs = parsedSchema?.$defs ?? parsedSchema?.nucleusSchema?.$defs;
+    const def = defs?.JobStepSocket;
+    const schemaNode = def?.nucleusSchema ?? def;
+    const additionalProperties = schemaNode?.additionalProperties;
+    if (!additionalProperties || typeof additionalProperties !== 'object' || Array.isArray(additionalProperties)) {
+        return 'Resource';
+    }
+    const union = additionalProperties.oneOf ??
+        additionalProperties.anyOf;
+    if (!Array.isArray(union) || union.length === 0) {
+        return 'Resource';
+    }
+    const names = [];
+    for (const item of union) {
+        const ref = item && typeof item === 'object' ? item.$ref : undefined;
+        if (typeof ref !== 'string')
+            continue;
+        // Accept both internal anchor refs like "#Resource" and JSON Pointer refs like "#/$defs/Resource".
+        const m = /^#(?:\/(?:\$defs|definitions)\/)?([A-Za-z_][A-Za-z0-9_]*)$/.exec(ref);
+        if (m)
+            names.push(m[1]);
+    }
+    const unique = Array.from(new Set(names));
+    if (!unique.length)
+        return 'Resource';
+    // Preserve an intentional ordering when we recognize the canonical pair.
+    if (unique.includes('Resource') && unique.includes('ResourcePotential')) {
+        return 'Resource | ResourcePotential';
+    }
+    return unique.join(' | ');
+}
 // PURE: Fix a known json-schema-to-typescript edge case where a JSON-like recursive value union
 // accidentally includes a direct self-reference (`| JsonData`) instead of the intended array case (`| JsonData[]`).
 function fixJsonDataSelfReference(ts) {
@@ -309,10 +351,13 @@ function postProcessEmittedTypes(ts, parsedSchema) {
     ts = ts.replace(/export interface RoleMap\s*{[^}]*}/g, `export type RoleMap = Record<${resourceRoleKeyType}, ResourceRoleValue>;`);
     // Normalize StrategyState & related socket maps to identity-keyed Records.
     // These are emitted as `[k: string]` by json-schema-to-typescript but are identity-keyed in practice.
-    // Per schema: JobStepSocket: Record<ResourceRoleIdentity, Resource>
+    // Per schema: JobStepSocket: Record<ResourceRoleIdentity, Resource | ResourcePotential>
     //            StrategyState: Record<JobStepIdentity, JobStepSocket>
-    const jobStepSocketValueType = 'Resource';
+    const jobStepSocketValueType = deriveJobStepSocketValueType(parsedSchema);
     ts = ts.replace(/export interface JobStepSocket\s*\{\s*\[k:\s*string\]:\s*[^;]+;\s*\}/g, `export type JobStepSocket = Record<${resourceRoleKeyType}, ${jobStepSocketValueType}>;`);
+    // If the upstream generator (or earlier passes) already emitted a Record-based alias,
+    // force its value type to match the schema-derived union.
+    ts = ts.replace(/export\s+type\s+JobStepSocket\s*=\s*Record<\s*ResourceRoleIdentity\s*,\s*[^>]+>\s*;/g, `export type JobStepSocket = Record<${resourceRoleKeyType}, ${jobStepSocketValueType}>;`);
     ts = ts.replace(/export interface StrategyState\s*\{\s*\[k:\s*string\]:\s*JobStepSocket;\s*\}/g, `export type StrategyState = Record<${jobStepKeyType}, JobStepSocket>;`);
     ts = ts.replace(/(strategyStateUpdate\??:\s*)\{\s*\[k:\s*string\]:\s*JobStepSocket;\s*\};/g, `$1Record<${jobStepKeyType}, JobStepSocket>;`);
     // Ensure key constraints for strategyThreadMap are preserved as template-literal identity keys.

package/dist/scripts/wrapResourceTypesWithResourceShells.js

@@ -22,8 +22,10 @@ function generateResourceShellLogic(genesis) {
             resourceRoleHandle: 'ROLE-Genesis',
             jobStepHandle: 'JOB_STEP-Genesis'
         },
-        kind: 'materialized',
+        resourceShellKind: 'materialized',
+        version: 1,
         timestamp: genesisTimestamp,
+        path: 'https://schemas.toolproof.com/v1/Genesis.json',
         nucleus: {}
     };
     defKeys.forEach((defName) => {
@@ -33,10 +35,12 @@ function generateResourceShellLogic(genesis) {
             resourceTypeHandle: 'TYPE-ResourceType',
             creationContext: {
                 resourceRoleHandle: 'ROLE-Genesis',
-                jobStepHandle: `JOB_STEP-${defName}`
+                jobStepHandle: 'JOB_STEP-Genesis'
             },
-            kind: 'materialized',
+            resourceShellKind: 'materialized',
+            version: 1,
             timestamp: genesisTimestamp,
+            path: `https://schemas.toolproof.com/v1/Genesis.json#/$defs/${defName}`,
             nucleus: defValue
         };
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toolproof-core/schema",
-  "version": "1.0.9",
+  "version": "1.0.10",
   "description": "JSON schemas and TypeScript types for ToolProof",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -18,10 +18,15 @@
   "keywords": [],
   "author": "",
   "license": "ISC",
-  "packageManager": "pnpm@10.15.0",
   "publishConfig": {
     "access": "public"
   },
+  "devDependencies": {
+    "@types/node": "^20.8.1",
+    "json-schema-to-typescript": "^15.0.4",
+    "rimraf": "^5.0.0",
+    "typescript": "^5.9.3"
+  },
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
     "build": "tsc -b",
@@ -34,15 +39,9 @@
     "wrapResourceTypesWithResourceShells": "node ./dist/scripts/wrapResourceTypesWithResourceShells.js",
     "generateSchemaShims": "node ./dist/scripts/generateSchemaShims.js",
     "generateDependencies": "node ./dist/scripts/generateDependencies.js",
-    "generateConstants": "node ./dist/scripts/generateConstants.js",
+    "generateConstantsAndMappings": "node ./dist/scripts/generateConstantsAndMappings.js",
     "generateTerminals": "node ./dist/scripts/generateTerminals.js",
     "generateResourceTypeGenesisType": "node ./dist/scripts/generateStandaloneType.js --name Genesis",
-    "update": "rimraf /s /q dist && pnpm run build:scripts && pnpm run normalizeAnchorsToPointers && pnpm run extractSchemasFromResourceTypeShells && pnpm run generateConstants && pnpm run generateStandaloneSchema -- --name Job && pnpm run generateStandaloneSchema -- --name ResourceType && pnpm run generateStandaloneSchema -- --name RawStrategy && pnpm run generateStandaloneSchema -- --name RunnableStrategy && pnpm run generateStandaloneSchema -- --name StrategyRun && pnpm run generateStandaloneSchema -- --name Goal && pnpm run wrapResourceTypesWithResourceShells && pnpm run generateSchemaShims && pnpm run generateTypes && pnpm run generateStandaloneType -- --name Job && pnpm run generateStandaloneType -- --name ResourceType && pnpm run generateStandaloneType -- --name RawStrategy && pnpm run generateStandaloneType -- --name RunnableStrategy && pnpm run generateResourceTypeGenesisType && pnpm run generateDependencies && pnpm run generateTerminals && pnpm run build"
-  },
-  "devDependencies": {
-    "@types/node": "^20.8.1",
-    "json-schema-to-typescript": "^15.0.4",
-    "rimraf": "^5.0.0",
-    "typescript": "^5.9.3"
+    "update": "rimraf /s /q dist && pnpm run build:scripts && pnpm run normalizeAnchorsToPointers && pnpm run extractSchemasFromResourceTypeShells && pnpm run generateConstantsAndMappings && pnpm run generateStandaloneSchema -- --name Job && pnpm run generateStandaloneSchema -- --name ResourceType && pnpm run generateStandaloneSchema -- --name RawStrategy && pnpm run generateStandaloneSchema -- --name RunnableStrategy && pnpm run generateStandaloneSchema -- --name StrategyRun && pnpm run generateStandaloneSchema -- --name Goal && pnpm run wrapResourceTypesWithResourceShells && pnpm run generateSchemaShims && pnpm run generateTypes && pnpm run generateStandaloneType -- --name Job && pnpm run generateStandaloneType -- --name ResourceType && pnpm run generateStandaloneType -- --name RawStrategy && pnpm run generateStandaloneType -- --name RunnableStrategy && pnpm run generateResourceTypeGenesisType && pnpm run generateDependencies && pnpm run generateTerminals && pnpm run build"
   }
 }