@toolproof-core/schema 1.0.5 → 1.0.6

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

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

package/dist/generated/constants/constants.js

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

package/dist/generated/normalized/Genesis.json

@@ -1332,10 +1332,6 @@
                     "properties": {
                         "runnableStrategyHandle": {
                             "$ref": "#/$defs/RunnableStrategyIdentity"
-                        },
-                        "runnableStrategy": {
-                            "$comment": "Optional embedded snapshot; runnableStrategyHandle remains the canonical pointer.",
-                            "$ref": "#/$defs/RunnableStrategy"
                         }
                     },
                     "allOf": [

package/dist/generated/resources/Genesis.json

@@ -2034,10 +2034,6 @@
                 "properties": {
                     "runnableStrategyHandle": {
                         "$ref": "#/$defs/RunnableStrategyIdentity"
-                    },
-                    "runnableStrategy": {
-                        "$comment": "Optional embedded snapshot; runnableStrategyHandle remains the canonical pointer.",
-                        "$ref": "#/$defs/RunnableStrategy"
                     }
                 },
                 "allOf": [

package/dist/generated/schemas/Genesis.json

@@ -977,10 +977,6 @@
             "properties": {
                 "runnableStrategyHandle": {
                     "$ref": "#/$defs/RunnableStrategyIdentity"
-                },
-                "runnableStrategy": {
-                    "$comment": "Optional embedded snapshot; runnableStrategyHandle remains the canonical pointer.",
-                    "$ref": "#/$defs/RunnableStrategy"
                 }
             },
             "allOf": [

package/dist/generated/types/types.d.ts

@@ -361,14 +361,7 @@ export type RunnableStrategy =
 export type RunnableStrategyUpdate =
  {
   runnableStrategyHandle: RunnableStrategyIdentity;
-  runnableStrategy?: RunnableStrategy1;
 } & StrategyStateDelta;
-export type RunnableStrategy1 =
- {
-  identity: RunnableStrategyIdentity;
-  runnableStrategyContext: RunnableStrategyContext;
-} & StrategyThreadMapFacet1 &
-  StrategyStateFacet1;
 /**
  * This interface was referenced by `Genesis`'s JSON-Schema
  * via the `definition` "RunEventUpdates".

package/dist/index.d.ts

@@ -2,9 +2,10 @@ 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 CONSTANTS } from './generated/constants/constants.js';
 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 { 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';
+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, StrategyRunIdentity as StrategyRunIdentityJson, GoalIdentity as GoalIdentityJson, Goal as GoalJson, } from './generated/types/types.js';

package/dist/index.js

@@ -3,3 +3,4 @@ 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 CONSTANTS } from './generated/constants/constants.js';

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

@@ -12,6 +12,7 @@ export declare class SchemaConfig {
     private readonly sourceFile;
     private readonly normalizedDir;
     private readonly schemasDir;
+    private readonly constantsDir;
     private readonly resourcesDir;
     private readonly dependencyMapPath;
     private readonly typesSrcDir;
@@ -28,6 +29,8 @@ export declare class SchemaConfig {
     getNormalizedSourcePath(): string;
     getSchemasDir(): string;
     getSchemaPath(filename: string): string;
+    getConstantsDir(): string;
+    getConstantsPath(filename: string): string;
     getStandaloneSchemaDir(): string;
     getStandaloneSchemaPath(filename: string): string;
     getTypesSrcDir(): string;

package/dist/scripts/_lib/config.js

@@ -22,6 +22,7 @@ export class SchemaConfig {
         this.sourceFile = getEnv('TP_SCHEMA_SOURCE_FILE', 'Genesis.json');
         this.normalizedDir = getEnv('TP_SCHEMA_NORMALIZED_DIR', 'src/generated/normalized');
         this.schemasDir = getEnv('TP_SCHEMA_SCHEMAS_DIR', 'src/generated/schemas');
+        this.constantsDir = getEnv('TP_SCHEMA_CONSTANTS_DIR', 'src/generated/constants');
         this.resourcesDir = getEnv('TP_SCHEMA_RESOURCES_DIR', 'src/generated/resources');
         this.dependencyMapPath = getEnv('TP_SCHEMA_DEPENDENCY_MAP_PATH', 'src/generated/dependencies/dependencyMap.json');
         this.typesSrcDir = getEnv('TP_SCHEMA_TYPES_SRC_DIR', 'src/generated/types');
@@ -66,6 +67,14 @@ export class SchemaConfig {
     getSchemaPath(filename) {
         return path.join(this.getSchemasDir(), filename);
     }
+    getConstantsDir() {
+        return path.isAbsolute(this.constantsDir)
+            ? this.constantsDir
+            : path.join(this.root, this.constantsDir);
+    }
+    getConstantsPath(filename) {
+        return path.join(this.getConstantsDir(), filename);
+    }
     getStandaloneSchemaDir() {
         return path.join(this.getSchemasDir(), 'standalone');
     }

package/dist/scripts/generateConstants.d.ts

@@ -0,0 +1,12 @@
+export type GeneratedConstants = {
+    IDENTIFIABLES: {
+        PREFIXES: Record<string, string>;
+        NAMES: Record<string, string>;
+    };
+    ENUMS: Record<string, Record<string, string>>;
+};
+export declare function extractIdentityPrefixes(schema: unknown): Record<string, string>;
+export declare function deriveIdentifiablesFromIdentityPrefixes(identityPrefixes: Record<string, string>): Record<string, string>;
+export declare function extractEnums(schema: unknown): Record<string, Record<string, string>>;
+export declare function extractConstants(schema: unknown): GeneratedConstants;
+export declare function renderConstantsTs(constants: GeneratedConstants): string;

package/dist/scripts/generateConstants.js

@@ -0,0 +1,179 @@
+import fs from 'fs';
+import path from 'path';
+import { getConfig } from './_lib/config.js';
+// 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: Derive identifiables from extracted Identity def names.
+// Example: { BranchStepIdentity: 'BRANCH_STEP-' } => { BranchStep: 'BranchStep' }
+export function deriveIdentifiablesFromIdentityPrefixes(identityPrefixes) {
+    const keys = Object.keys(identityPrefixes).sort((a, b) => a.localeCompare(b));
+    const out = {};
+    for (const key of keys) {
+        if (!key.endsWith('Identity'))
+            continue;
+        const name = key.slice(0, -'Identity'.length);
+        if (!name)
+            continue;
+        out[name] = name;
+    }
+    return out;
+}
+// PURE: Extract all string enums from `$defs/*Kind|*Status` definitions.
+// Shape: { StepKind: { job: 'job', ... }, ResourceKind: { 'input-potential': 'input-potential', ... } }
+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: Extract all generated constants from a parsed schema.
+export function extractConstants(schema) {
+    const identityPrefixes = extractIdentityPrefixes(schema);
+    const identifiables = deriveIdentifiablesFromIdentityPrefixes(identityPrefixes);
+    const enums = extractEnums(schema);
+    return {
+        IDENTIFIABLES: {
+            PREFIXES: identityPrefixes,
+            NAMES: identifiables,
+        },
+        ENUMS: enums,
+    };
+}
+// 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 prefixKeys = Object.keys(constants.IDENTIFIABLES.PREFIXES).sort((a, b) => a.localeCompare(b));
+    const nameKeys = Object.keys(constants.IDENTIFIABLES.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('    IDENTIFIABLES: {');
+    lines.push('        PREFIXES: {');
+    for (const key of prefixKeys) {
+        const value = constants.IDENTIFIABLES.PREFIXES[key] ?? '';
+        lines.push(`            ${renderTsKey(key)}: ${renderTsStringLiteral(value)},`);
+    }
+    lines.push('        },');
+    lines.push('        NAMES: {');
+    for (const key of nameKeys) {
+        const value = constants.IDENTIFIABLES.NAMES[key] ?? '';
+        lines.push(`            ${renderTsKey(key)}: ${renderTsStringLiteral(value)},`);
+    }
+    lines.push('        },');
+    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');
+}
+// 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.getConstantsPath('constants.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 = extractConstants(doc);
+        const ts = renderConstantsTs(constants);
+        fs.mkdirSync(path.dirname(outPath), { recursive: true });
+        fs.writeFileSync(outPath, ts, 'utf8');
+        console.log(`Wrote constants to ${outPath}`);
+    }
+    catch (error) {
+        console.error(`Error generating constants: ${error?.message ?? error}`);
+        process.exitCode = 1;
+    }
+}
+main();

package/dist/scripts/generateTerminals.d.ts

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

package/dist/scripts/generateTerminals.js

@@ -0,0 +1,58 @@
+import fs from "fs";
+import path from "path";
+import { getConfig } from "./_lib/config.js";
+// PURE: Validate + normalize a dependency map loaded from JSON.
+function normalizeDependencyMap(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("Invalid dependencyMap.json: expected an object");
+    }
+    const input = value;
+    const out = {};
+    // Preserve insertion order from the parsed JSON object.
+    for (const [key, rawDeps] of Object.entries(input)) {
+        if (rawDeps == null) {
+            out[key] = [];
+            continue;
+        }
+        if (!Array.isArray(rawDeps)) {
+            throw new Error(`Invalid dependencyMap.json: value for ${key} must be an array`);
+        }
+        out[key] = rawDeps.filter((d) => typeof d === "string");
+    }
+    return out;
+}
+// PURE: Compute terminals (defs that are not depended-upon by any other def).
+function computeTerminalsInKeyOrder(dependencyMap) {
+    const keys = Object.keys(dependencyMap);
+    const dependedUpon = new Set();
+    for (const key of keys) {
+        for (const dep of dependencyMap[key] ?? []) {
+            dependedUpon.add(dep);
+        }
+    }
+    // Preserve key order from dependencyMap.json.
+    return keys.filter((k) => !dependedUpon.has(k));
+}
+// IMPURE: Script entrypoint (config + filesystem I/O + console + process exit code).
+function main() {
+    try {
+        const config = getConfig();
+        const inPath = config.getDependencyMapPath();
+        const outPath = path.join(path.dirname(inPath), "terminals.json");
+        if (!fs.existsSync(inPath)) {
+            throw new Error(`Dependency map not found at ${inPath}. Run generateDependencies first.`);
+        }
+        const raw = fs.readFileSync(inPath, "utf8");
+        const parsed = JSON.parse(raw);
+        const dependencyMap = normalizeDependencyMap(parsed);
+        const terminals = computeTerminalsInKeyOrder(dependencyMap);
+        fs.mkdirSync(path.dirname(outPath), { recursive: true });
+        fs.writeFileSync(outPath, JSON.stringify(terminals, null, 4), "utf8");
+        console.log(`Wrote terminals to ${outPath}`);
+    }
+    catch (error) {
+        console.error(`Error generating terminals: ${error?.message ?? error}`);
+        process.exitCode = 1;
+    }
+}
+main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toolproof-core/schema",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "description": "JSON schemas and TypeScript types for ToolProof",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -39,7 +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",
+    "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 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 build"
+    "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"
   }
 }

package/src/Genesis.json

@@ -1403,10 +1403,6 @@
                     "properties": {
                         "runnableStrategyHandle": {
                             "$ref": "#RunnableStrategyIdentity"
-                        },
-                        "runnableStrategy": {
-                            "$comment": "Optional embedded snapshot; runnableStrategyHandle remains the canonical pointer.",
-                            "$ref": "#RunnableStrategy"
                         }
                     },
                     "allOf": [

package/src/generated/constants/constants.ts

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

package/src/generated/dependencies/dependencyMap.json

@@ -218,7 +218,6 @@
     ],
     "RunnableStrategyUpdate": [
         "RunnableStrategyIdentity",
-        "RunnableStrategy",
         "StrategyStateDelta"
     ],
     "RunEventCounters": [],

package/src/generated/dependencies/terminals.json

@@ -0,0 +1,12 @@
+[
+    "ResourceType",
+    "Error",
+    "Job",
+    "ShellMaterialized",
+    "RawStrategy",
+    "RunnableStrategyUpdate",
+    "StrategyRun",
+    "Goal",
+    "Natural",
+    "Boolean"
+]

package/src/generated/normalized/Genesis.json

@@ -1332,10 +1332,6 @@
                     "properties": {
                         "runnableStrategyHandle": {
                             "$ref": "#/$defs/RunnableStrategyIdentity"
-                        },
-                        "runnableStrategy": {
-                            "$comment": "Optional embedded snapshot; runnableStrategyHandle remains the canonical pointer.",
-                            "$ref": "#/$defs/RunnableStrategy"
                         }
                     },
                     "allOf": [

package/src/generated/resources/Genesis.json

@@ -2034,10 +2034,6 @@
                 "properties": {
                     "runnableStrategyHandle": {
                         "$ref": "#/$defs/RunnableStrategyIdentity"
-                    },
-                    "runnableStrategy": {
-                        "$comment": "Optional embedded snapshot; runnableStrategyHandle remains the canonical pointer.",
-                        "$ref": "#/$defs/RunnableStrategy"
                     }
                 },
                 "allOf": [

package/src/generated/schemas/Genesis.json

@@ -977,10 +977,6 @@
             "properties": {
                 "runnableStrategyHandle": {
                     "$ref": "#/$defs/RunnableStrategyIdentity"
-                },
-                "runnableStrategy": {
-                    "$comment": "Optional embedded snapshot; runnableStrategyHandle remains the canonical pointer.",
-                    "$ref": "#/$defs/RunnableStrategy"
                 }
             },
             "allOf": [

package/src/generated/types/types.d.ts

@@ -361,14 +361,7 @@ export type RunnableStrategy =
 export type RunnableStrategyUpdate =
  {
   runnableStrategyHandle: RunnableStrategyIdentity;
-  runnableStrategy?: RunnableStrategy1;
 } & StrategyStateDelta;
-export type RunnableStrategy1 =
- {
-  identity: RunnableStrategyIdentity;
-  runnableStrategyContext: RunnableStrategyContext;
-} & StrategyThreadMapFacet1 &
-  StrategyStateFacet1;
 /**
  * This interface was referenced by `Genesis`'s JSON-Schema
  * via the `definition` "RunEventUpdates".

package/src/index.ts

@@ -3,6 +3,7 @@ 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 CONSTANTS } from './generated/constants/constants.js';
 
 
 export type {
@@ -62,5 +63,7 @@ export type {
   StrategyThreadMap as StrategyThreadMapJson,
   JobStepSocket as JobStepSocketJson,
   Timestamp as TimestampJson,
+  StrategyRunIdentity as StrategyRunIdentityJson,
+  GoalIdentity as GoalIdentityJson,
   Goal as GoalJson,
-} from './generated/types/types.js';
+} from './generated/types/types.js';

package/src/scripts/_lib/config.ts

@@ -24,6 +24,7 @@ export class SchemaConfig {
   private readonly sourceFile: string;
   private readonly normalizedDir: string;
   private readonly schemasDir: string;
+  private readonly constantsDir: string;
   private readonly resourcesDir: string;
   private readonly dependencyMapPath: string;
   private readonly typesSrcDir: string;
@@ -40,6 +41,7 @@ export class SchemaConfig {
     this.sourceFile = getEnv('TP_SCHEMA_SOURCE_FILE', 'Genesis.json');
     this.normalizedDir = getEnv('TP_SCHEMA_NORMALIZED_DIR', 'src/generated/normalized');
     this.schemasDir = getEnv('TP_SCHEMA_SCHEMAS_DIR', 'src/generated/schemas');
+    this.constantsDir = getEnv('TP_SCHEMA_CONSTANTS_DIR', 'src/generated/constants');
     this.resourcesDir = getEnv('TP_SCHEMA_RESOURCES_DIR', 'src/generated/resources');
     this.dependencyMapPath = getEnv('TP_SCHEMA_DEPENDENCY_MAP_PATH', 'src/generated/dependencies/dependencyMap.json');
     this.typesSrcDir = getEnv('TP_SCHEMA_TYPES_SRC_DIR', 'src/generated/types');
@@ -94,6 +96,16 @@ export class SchemaConfig {
     return path.join(this.getSchemasDir(), filename);
   }
 
+  getConstantsDir(): string {
+    return path.isAbsolute(this.constantsDir)
+      ? this.constantsDir
+      : path.join(this.root, this.constantsDir);
+  }
+
+  getConstantsPath(filename: string): string {
+    return path.join(this.getConstantsDir(), filename);
+  }
+
   getStandaloneSchemaDir(): string {
     return path.join(this.getSchemasDir(), 'standalone');
   }

package/src/scripts/generateConstants.ts

@@ -0,0 +1,217 @@
+import fs from 'fs';
+import path from 'path';
+import { getConfig } from './_lib/config.js';
+
+type JSONValue = null | boolean | number | string | JSONValue[] | { [k: string]: JSONValue };
+
+export type GeneratedConstants = {
+    IDENTIFIABLES: {
+        PREFIXES: Record<string, string>;
+        NAMES: Record<string, string>;
+    };
+    ENUMS: Record<string, Record<string, string>>;
+};
+
+// PURE: Attempt to derive a canonical identity prefix from a canonical identity regex pattern.
+function deriveIdentityPrefixFromPattern(pattern: string): string | undefined {
+    // 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: unknown): Record<string, string> {
+    if (!schema || typeof schema !== 'object') return {};
+
+    const defs = (schema as any).$defs;
+    if (!defs || typeof defs !== 'object') return {};
+
+    const defEntries = Object.entries(defs as Record<string, unknown>);
+    defEntries.sort(([a], [b]) => a.localeCompare(b));
+
+    const out: Record<string, string> = {};
+
+    for (const [defName, defVal] of defEntries) {
+        if (!/Identity$/.test(defName)) continue;
+        if (!defVal || typeof defVal !== 'object' || Array.isArray(defVal)) continue;
+
+        const v: any = 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: Derive identifiables from extracted Identity def names.
+// Example: { BranchStepIdentity: 'BRANCH_STEP-' } => { BranchStep: 'BranchStep' }
+export function deriveIdentifiablesFromIdentityPrefixes(identityPrefixes: Record<string, string>): Record<string, string> {
+    const keys = Object.keys(identityPrefixes).sort((a, b) => a.localeCompare(b));
+    const out: Record<string, string> = {};
+
+    for (const key of keys) {
+        if (!key.endsWith('Identity')) continue;
+        const name = key.slice(0, -'Identity'.length);
+        if (!name) continue;
+        out[name] = name;
+    }
+
+    return out;
+}
+
+// PURE: Extract all string enums from `$defs/*Kind|*Status` definitions.
+// Shape: { StepKind: { job: 'job', ... }, ResourceKind: { 'input-potential': 'input-potential', ... } }
+export function extractEnums(schema: unknown): Record<string, Record<string, string>> {
+    if (!schema || typeof schema !== 'object') return {};
+
+    const defs = (schema as any).$defs;
+    if (!defs || typeof defs !== 'object') return {};
+
+    const defEntries = Object.entries(defs as Record<string, unknown>);
+    defEntries.sort(([a], [b]) => a.localeCompare(b));
+
+    const out: Record<string, Record<string, string>> = {};
+
+    for (const [defName, defVal] of defEntries) {
+        if (!/(Kind|Status)$/.test(defName)) continue;
+        if (!defVal || typeof defVal !== 'object' || Array.isArray(defVal)) continue;
+
+        const v: any = defVal;
+        if (v.type !== 'string') continue;
+        if (!Array.isArray(v.enum) || v.enum.length === 0) continue;
+        if (v.enum.some((x: unknown) => typeof x !== 'string')) continue;
+
+        const members: Record<string, string> = {};
+        for (const member of v.enum as readonly string[]) {
+            members[member] = member;
+        }
+
+        out[defName] = members;
+    }
+
+    return out;
+}
+
+// PURE: Extract all generated constants from a parsed schema.
+export function extractConstants(schema: unknown): GeneratedConstants {
+    const identityPrefixes = extractIdentityPrefixes(schema);
+    const identifiables = deriveIdentifiablesFromIdentityPrefixes(identityPrefixes);
+    const enums = extractEnums(schema);
+    return {
+        IDENTIFIABLES: {
+            PREFIXES: identityPrefixes,
+            NAMES: identifiables,
+        },
+        ENUMS: enums,
+    };
+}
+
+// PURE: Render helpers for TS keys/strings.
+function escapeTsString(value: string): string {
+    return value
+        .replace(/\\/g, '\\\\')
+        .replace(/\r/g, '\\r')
+        .replace(/\n/g, '\\n')
+        .replace(/\t/g, '\\t')
+        .replace(/'/g, "\\'");
+}
+
+function renderTsStringLiteral(value: string): string {
+    return `'${escapeTsString(value)}'`;
+}
+
+function isValidTsIdentifier(key: string): boolean {
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key);
+}
+
+function renderTsKey(key: string): string {
+    return isValidTsIdentifier(key) ? key : renderTsStringLiteral(key);
+}
+
+// PURE: Render constants TypeScript source.
+export function renderConstantsTs(constants: GeneratedConstants): string {
+    const prefixKeys = Object.keys(constants.IDENTIFIABLES.PREFIXES).sort((a, b) => a.localeCompare(b));
+    const nameKeys = Object.keys(constants.IDENTIFIABLES.NAMES).sort((a, b) => a.localeCompare(b));
+    const enumKeys = Object.keys(constants.ENUMS).sort((a, b) => a.localeCompare(b));
+
+    const lines: string[] = [];
+    lines.push('const CONSTANTS = {');
+    lines.push('    IDENTIFIABLES: {');
+    lines.push('        PREFIXES: {');
+
+    for (const key of prefixKeys) {
+        const value = constants.IDENTIFIABLES.PREFIXES[key] ?? '';
+        lines.push(`            ${renderTsKey(key)}: ${renderTsStringLiteral(value)},`);
+    }
+
+    lines.push('        },');
+    lines.push('        NAMES: {');
+
+    for (const key of nameKeys) {
+        const value = constants.IDENTIFIABLES.NAMES[key] ?? '';
+        lines.push(`            ${renderTsKey(key)}: ${renderTsStringLiteral(value)},`);
+    }
+
+    lines.push('        },');
+    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');
+}
+
+// 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.getConstantsPath('constants.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: JSONValue = JSON.parse(raw);
+
+        const constants = extractConstants(doc);
+        const ts = renderConstantsTs(constants);
+
+        fs.mkdirSync(path.dirname(outPath), { recursive: true });
+        fs.writeFileSync(outPath, ts, 'utf8');
+        console.log(`Wrote constants to ${outPath}`);
+    } catch (error: any) {
+        console.error(`Error generating constants: ${error?.message ?? error}`);
+        process.exitCode = 1;
+    }
+}
+
+main();

package/src/scripts/generateTerminals.ts

@@ -0,0 +1,73 @@
+import fs from "fs";
+import path from "path";
+import { getConfig } from "./_lib/config.js";
+
+type DependencyMap = Record<string, string[]>;
+
+// PURE: Validate + normalize a dependency map loaded from JSON.
+function normalizeDependencyMap(value: unknown): DependencyMap {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Invalid dependencyMap.json: expected an object");
+  }
+
+  const input = value as Record<string, unknown>;
+  const out: DependencyMap = {};
+
+  // Preserve insertion order from the parsed JSON object.
+  for (const [key, rawDeps] of Object.entries(input)) {
+    if (rawDeps == null) {
+      out[key] = [];
+      continue;
+    }
+    if (!Array.isArray(rawDeps)) {
+      throw new Error(`Invalid dependencyMap.json: value for ${key} must be an array`);
+    }
+    out[key] = rawDeps.filter((d): d is string => typeof d === "string");
+  }
+
+  return out;
+}
+
+// PURE: Compute terminals (defs that are not depended-upon by any other def).
+function computeTerminalsInKeyOrder(dependencyMap: DependencyMap): string[] {
+  const keys = Object.keys(dependencyMap);
+  const dependedUpon = new Set<string>();
+
+  for (const key of keys) {
+    for (const dep of dependencyMap[key] ?? []) {
+      dependedUpon.add(dep);
+    }
+  }
+
+  // Preserve key order from dependencyMap.json.
+  return keys.filter((k) => !dependedUpon.has(k));
+}
+
+// IMPURE: Script entrypoint (config + filesystem I/O + console + process exit code).
+function main() {
+  try {
+    const config = getConfig();
+
+    const inPath = config.getDependencyMapPath();
+    const outPath = path.join(path.dirname(inPath), "terminals.json");
+
+    if (!fs.existsSync(inPath)) {
+      throw new Error(`Dependency map not found at ${inPath}. Run generateDependencies first.`);
+    }
+
+    const raw = fs.readFileSync(inPath, "utf8");
+    const parsed = JSON.parse(raw) as unknown;
+
+    const dependencyMap = normalizeDependencyMap(parsed);
+    const terminals = computeTerminalsInKeyOrder(dependencyMap);
+
+    fs.mkdirSync(path.dirname(outPath), { recursive: true });
+    fs.writeFileSync(outPath, JSON.stringify(terminals, null, 4), "utf8");
+    console.log(`Wrote terminals to ${outPath}`);
+  } catch (error: any) {
+    console.error(`Error generating terminals: ${error?.message ?? error}`);
+    process.exitCode = 1;
+  }
+}
+
+main();