@toolproof-core/schema 1.0.8 → 1.0.10

package/src/index.ts

@@ -1,9 +1,12 @@
 // Re-export JSON schemas via .ts shims to avoid .json re-exports in declarations
 export { default as SchemaGenesis } from './generated/schemas/Genesis.js';
+export { default as SchemaResourceType } from './generated/schemas/standalone/ResourceType.js';
 export { default as SchemaJob } from './generated/schemas/standalone/Job.js';
+export { default as SchemaRunnableStrategy } from './generated/schemas/standalone/RunnableStrategy.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 { default as ResourceGenesis } from './generated/resources/Genesis.js';
+export { default as CONSTANTS } from './generated/artifacts/constants.js';
+export { default as MAPPINGS } from './generated/artifacts/mappings.js';
 
 
 export type {
@@ -48,6 +51,9 @@ export type {
   Step as StepJson,
   CreationContext as CreationContextJson,
   ResourceMissing as ResourceMissingJson,
+  ResourceInputPotential as ResourceInputPotentialJson,
+  ResourceOutputPotential as ResourceOutputPotentialJson,
+  ShellMaterializedBase as ShellMaterializedBaseJson,
   Resource as ResourceJson,
   StrategyState as StrategyStateJson,
   StepsFacet as StepsFacetJson,

package/src/scripts/_lib/config.ts

@@ -24,9 +24,8 @@ export class SchemaConfig {
   private readonly sourceFile: string;
   private readonly normalizedDir: string;
   private readonly schemasDir: string;
-  private readonly constantsDir: string;
+  private readonly artifactsDir: string;
   private readonly resourcesDir: string;
-  private readonly dependencyMapPath: string;
   private readonly typesSrcDir: string;
   private readonly typesDistDir: string;
 
@@ -41,13 +40,12 @@ 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.artifactsDir = getEnv('TP_SCHEMA_ARTIFACTS_DIR', 'src/generated/artifacts');
     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');
     this.typesDistDir = getEnv('TP_SCHEMA_TYPES_DIST_DIR', 'dist/generated/types');
     this.baseUrl = getEnv('TP_SCHEMA_BASE_URL', 'https://schemas.toolproof.com');
-    this.version = getEnv('TP_SCHEMA_VERSION', 'v0');
+    this.version = getEnv('TP_SCHEMA_VERSION', 'v1');
   }
 
   // Path getters
@@ -96,14 +94,14 @@ export class SchemaConfig {
     return path.join(this.getSchemasDir(), filename);
   }
 
-  getConstantsDir(): string {
-    return path.isAbsolute(this.constantsDir)
-      ? this.constantsDir
-      : path.join(this.root, this.constantsDir);
+  getArtifactsDir(): string {
+    return path.isAbsolute(this.artifactsDir)
+      ? this.artifactsDir
+      : path.join(this.root, this.artifactsDir);
   }
 
-  getConstantsPath(filename: string): string {
-    return path.join(this.getConstantsDir(), filename);
+  getArtifactsPath(filename: string): string {
+    return path.join(this.getArtifactsDir(), filename);
   }
 
   getStandaloneSchemaDir(): string {
@@ -156,12 +154,6 @@ export class SchemaConfig {
       : path.join(this.root, this.resourcesDir);
   }
 
-  getDependencyMapPath(): string {
-    return path.isAbsolute(this.dependencyMapPath)
-      ? this.dependencyMapPath
-      : path.join(this.root, this.dependencyMapPath);
-  }
-
   // Schema URL methods
   getBaseUrl(): string {
     return this.baseUrl;

package/src/scripts/generateConstantsAndMappings.ts

@@ -0,0 +1,309 @@
+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 = {
+    Names: Record<string, string>;
+    Enums: Record<string, Record<string, string>>;
+};
+
+export type GeneratedMappings = {
+    IdentityNameToIdentityPrefix: Record<string, string>;
+    StepKindToStepIdentityPrefix: Record<string, string>;
+};
+
+export type DeriveStepKindToStepIdentityPrefixResult = {
+    mapping: Record<string, string>;
+    missing: Array<{ stepKind: string; identityName: string }>;
+};
+
+// PURE: Convert a string enum member into PascalCase.
+// Examples: 'job' -> 'Job', 'graph_start' -> 'GraphStart'
+function toPascalCase(value: string): string {
+    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: 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: Extract all subschema names from `$defs/*`.
+// Shape: { JobStep: 'JobStep', StepKind: 'StepKind', ... }
+export function extractSubschemaNames(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] 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: 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: Derive a StepKind -> StepIdentityPrefix mapping.
+// Example: { job: 'job' } + IdentityNameToIdentityPrefix['JobStepIdentity']='JOB_STEP-' => { job: 'JOB_STEP-' }
+export function deriveStepKindToStepIdentityPrefix(
+    enums: Record<string, Record<string, string>>,
+    identityNameToIdentityPrefix: Record<string, string>
+): DeriveStepKindToStepIdentityPrefixResult {
+    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: Record<string, string> = {};
+    const missing: Array<{ stepKind: string; identityName: string }> = [];
+
+    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: unknown): {
+    CONSTANTS: GeneratedConstants;
+    MAPPINGS: GeneratedMappings;
+    DIAGNOSTICS: {
+        missingStepKindIdentityPrefixes: Array<{ stepKind: string; identityName: string }>;
+    };
+} {
+    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: 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 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: string[] = [];
+    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: GeneratedMappings): string {
+    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: string[] = [];
+    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: JSONValue = 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: any) {
+        console.error(`Error generating constants/mappings: ${error?.message ?? error}`);
+        process.exitCode = 1;
+    }
+}
+
+main();

package/src/scripts/generateDependencies.ts

@@ -98,7 +98,7 @@ function main() {
     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/src/scripts/generateTerminals.ts

@@ -48,8 +48,8 @@ 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/src/scripts/generateTypes.ts

@@ -260,6 +260,55 @@ function escapeRegExpLiteral(value: string): string {
     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: any): string {
+    // 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 as any).oneOf ??
+        (additionalProperties as any).anyOf;
+
+    if (!Array.isArray(union) || union.length === 0) {
+        return 'Resource';
+    }
+
+    const names: string[] = [];
+    for (const item of union) {
+        const ref = item && typeof item === 'object' ? (item as any).$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: string): string {
@@ -378,13 +427,20 @@ function postProcessEmittedTypes(ts: string, parsedSchema: any): string {
     );
     // 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>;`

package/src/scripts/wrapResourceTypesWithResourceShells.ts

@@ -28,8 +28,10 @@ function generateResourceShellLogic(genesis: any): Record<string, any> {
             resourceRoleHandle: 'ROLE-Genesis',
             jobStepHandle: 'JOB_STEP-Genesis'
         },
-        kind: 'materialized',
+        resourceShellKind: 'materialized',
+        version: 1,
         timestamp: genesisTimestamp,
+        path: 'https://schemas.toolproof.com/v1/Genesis.json',
         nucleus: {}
     };
 
@@ -41,10 +43,12 @@ function generateResourceShellLogic(genesis: any): Record<string, any> {
             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/dist/generated/constants/constants.d.ts

@@ -1,60 +0,0 @@
-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 inputPotential: "inputPotential";
-            readonly outputPotential: "outputPotential";
-            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

@@ -1,60 +0,0 @@
-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',
-            inputPotential: 'inputPotential',
-            outputPotential: 'outputPotential',
-            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/scripts/generateConstants.d.ts

@@ -1,12 +0,0 @@
-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;