@toolproof-core/schema 1.0.10 → 1.0.11

package/dist/index.d.ts

@@ -11,4 +11,4 @@ export type { Resource_ResourceType as Resource_ResourceTypeJson } from './gener
 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, ResourceInputPotential as ResourceInputPotentialJson, ResourceOutputPotential as ResourceOutputPotentialJson, ShellMaterializedBase as ShellMaterializedBaseJson, 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';
+export type { DocumentationFacetJson, NucleusFacetJson, ResourceTypeIdentityJson, ResourceTypeJson, ResourceRoleIdentityJson, ResourceRoleValueJson, ResourceRoleJson, ConditionalJson, RoleDictJson, RolesJson, RoleBindingsJson, ResourceIdentityJson, JobStepIdentityJson, BranchStepIdentityJson, WhileStepIdentityJson, ForStepIdentityJson, JobStepJson, BranchStepJson, WhileStepJson, ForStepJson, StepKindJson, StepIdentityJson, StepJson, CreationContextJson, ResourceMissingJson, ResourceInputPotentialJson, ResourceOutputPotentialJson, ShellMaterializedBaseJson, ResourceJson, StrategyStateJson, StepsFacetJson, RawStrategyJson, RunnableStrategyIdentityJson, RunnableStrategyStatusJson, RunnableStrategyJson, RunnableStrategyUpdateJson, JobIdentityJson, JobJson, JsonDataJson, StrategyThreadIdentityJson, StrategyThreadDictJson, JobStepSocketJson, TimestampJson, StrategyRunIdentityJson, GoalIdentityJson, GoalJson, ErrorJson, } from './generated/types/types.js';

package/dist/scripts/generateStandaloneType.js

@@ -9,7 +9,8 @@ import { getConfig } from "./_lib/config.js";
 // PURE: Generate the content of a standalone Resource type definition file for a given schema name.
 function generateStandaloneTypeLogic(name) {
     const header = "// Auto-generated strict composite type. Do not edit.\n";
-    const ts = `import type { ShellMaterializedBase, ${name} as NucleusSchema } from "../types.js";\n` +
+    const nucleusTypeName = name.endsWith("Json") ? name : `${name}Json`;
+    const ts = `import type { ShellMaterializedBaseJson as ShellMaterializedBase, ${nucleusTypeName} as NucleusSchema } from "../types.js";\n` +
         `export type Resource_${name} = ShellMaterializedBase & { nucleus: NucleusSchema };\n`;
     return header + ts;
 }

package/dist/scripts/generateTypes.js

@@ -227,6 +227,136 @@ function removeDuplicateUnionEntries(ts) {
 function escapeRegExpLiteral(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
+// PURE: Rename exported top-level generated declarations to canonical `*Json` names.
+// This makes editor hover/inference prefer `FooJson` because the underlying declared
+// symbol is `FooJson` (not `Foo` with a re-export alias).
+function applyReplacementsOutsideStringsAndComments(text, replaceCodeSegment) {
+    const len = text.length;
+    let out = '';
+    let i = 0;
+    let codeStart = 0;
+    const flushCode = (end) => {
+        if (end > codeStart)
+            out += replaceCodeSegment(text.slice(codeStart, end));
+        codeStart = end;
+    };
+    const startsWith = (s) => text.startsWith(s, i);
+    while (i < len) {
+        // Line comment
+        if (startsWith('//')) {
+            flushCode(i);
+            const start = i;
+            i += 2;
+            while (i < len && text[i] !== '\n')
+                i++;
+            if (i < len && text[i] === '\n')
+                i++;
+            out += text.slice(start, i);
+            codeStart = i;
+            continue;
+        }
+        // Block comment
+        if (startsWith('/*')) {
+            flushCode(i);
+            const start = i;
+            i += 2;
+            while (i < len && !text.startsWith('*/', i))
+                i++;
+            if (i < len)
+                i += 2;
+            out += text.slice(start, i);
+            codeStart = i;
+            continue;
+        }
+        const ch = text[i];
+        // Single-quoted string
+        if (ch === "'") {
+            flushCode(i);
+            const start = i;
+            i++;
+            while (i < len) {
+                const c = text[i];
+                if (c === '\\') {
+                    i += 2;
+                    continue;
+                }
+                i++;
+                if (c === "'")
+                    break;
+            }
+            out += text.slice(start, i);
+            codeStart = i;
+            continue;
+        }
+        // Double-quoted string
+        if (ch === '"') {
+            flushCode(i);
+            const start = i;
+            i++;
+            while (i < len) {
+                const c = text[i];
+                if (c === '\\') {
+                    i += 2;
+                    continue;
+                }
+                i++;
+                if (c === '"')
+                    break;
+            }
+            out += text.slice(start, i);
+            codeStart = i;
+            continue;
+        }
+        // Template literal (backticks). We conservatively treat the whole template as a string.
+        // The generated .d.ts uses these primarily for template-literal *value* types like `TYPE-${string}`
+        // and we do not want to rewrite their raw text.
+        if (ch === '`') {
+            flushCode(i);
+            const start = i;
+            i++;
+            while (i < len) {
+                const c = text[i];
+                if (c === '\\') {
+                    i += 2;
+                    continue;
+                }
+                i++;
+                if (c === '`')
+                    break;
+            }
+            out += text.slice(start, i);
+            codeStart = i;
+            continue;
+        }
+        i++;
+    }
+    flushCode(len);
+    return out;
+}
+function renameExportedTopLevelTypesToJson(tsText) {
+    // Collect exported type/interface names.
+    const exportedDeclRegex = /^export\s+(?:type|interface)\s+([A-Za-z_][A-Za-z0-9_]*)\b/gm;
+    const exportedNames = new Set();
+    for (let m = exportedDeclRegex.exec(tsText); m; m = exportedDeclRegex.exec(tsText)) {
+        exportedNames.add(m[1]);
+    }
+    const renamePairs = Array.from(exportedNames)
+        .filter((name) => !name.endsWith('Json'))
+        .map((name) => ({ from: name, to: `${name}Json` }));
+    if (!renamePairs.length)
+        return tsText;
+    // Replace longer names first to reduce any accidental partial-match risk.
+    renamePairs.sort((a, b) => b.from.length - a.from.length);
+    const replaceCode = (code) => {
+        let out = code;
+        for (const { from, to } of renamePairs) {
+            const re = new RegExp(`\\b${escapeRegExpLiteral(from)}\\b`, 'g');
+            out = out.replace(re, to);
+        }
+        return out;
+    };
+    return applyReplacementsOutsideStringsAndComments(tsText, replaceCode);
+}
 // PURE: Derive the TS value type for JobStepSocket from Genesis.json.
 // We prefer to match the schema shape:
 //   JobStepSocket.additionalProperties.oneOf = [#ResourcePotential, #Resource]
@@ -348,7 +478,7 @@ function postProcessEmittedTypes(ts, parsedSchema) {
     const resourceRoleKeyType = 'ResourceRoleIdentity';
     const jobStepKeyType = 'JobStepIdentity';
     const strategyThreadKeyType = 'StrategyThreadIdentity';
-    ts = ts.replace(/export interface RoleMap\s*{[^}]*}/g, `export type RoleMap = Record<${resourceRoleKeyType}, ResourceRoleValue>;`);
+    ts = ts.replace(/export interface RoleDict\s*{[^}]*}/g, `export type RoleDict = 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 | ResourcePotential>
@@ -360,10 +490,13 @@ function postProcessEmittedTypes(ts, parsedSchema) {
     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.
+    // Ensure key constraints for strategyThreadDict are preserved as template-literal identity keys.
     // json-schema-to-typescript emits `[k: string]: StepArray;`, but we want keys to be `StrategyThreadIdentity`.
-    ts = ts.replace(/export interface StrategyThreadMap\s*\{\s*\[k:\s*string\]:\s*StepArray;\s*\}/g, `export type StrategyThreadMap = Record<${strategyThreadKeyType}, StepArray>;`);
+    ts = ts.replace(/export interface StrategyThreadDict\s*\{\s*\[k:\s*string\]:\s*StepArray;\s*\}/g, `export type StrategyThreadDict = Record<${strategyThreadKeyType}, StepArray>;`);
     ts = fixJsonDataSelfReference(ts);
+    // IMPORTANT: do this last so earlier post-processing regexes can target
+    // the generator's original names (without `Json` suffixes).
+    ts = renameExportedTopLevelTypesToJson(ts);
     return ts;
 }
 // PURE: Add banner + formatting/guards to build the final .d.ts content.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toolproof-core/schema",
-  "version": "1.0.10",
+  "version": "1.0.11",
   "description": "JSON schemas and TypeScript types for ToolProof",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/Genesis.json

@@ -128,7 +128,7 @@
                             "$ref": "#ResourceTypeIdentity"
                         },
                         "nucleusSchema": true,
-                        "embeddingUriMap": {
+                        "embeddingUriDict": {
                             "type": "object",
                             "propertyNames": {
                                 "type": "string",
@@ -138,9 +138,9 @@
                                 "$ref": "#Uri"
                             },
                             "minProperties": 1,
-                            "$comment": "A ResourceType may specify a set of embedding models that convert the raw data (or one of its alternative representations) into vector embeddings. The build process enforces that the keys of this map are members of a set of predefined embedding models."
+                            "$comment": "A ResourceType may specify a set of embedding models that convert the raw data (or one of its alternative representations) into vector embeddings. The build process enforces that the keys of this dict are members of a set of predefined embedding models."
                         },
-                        "generatorUriMap": {
+                        "generatorUriDict": {
                             "type": "object",
                             "propertyNames": {
                                 "type": "string",
@@ -150,7 +150,7 @@
                                 "$ref": "#Uri"
                             },
                             "minProperties": 1,
-                            "$comment": "A ResourceType may specify a set of generators that generate different representations of its instances from the raw file. A ToolProof Resource is always backed by a raw file. This is also true for the Resources (of type ResourceType) defined in this file! The build process enforces that the keys of this map are members of a set of predefined generators. GENERATOR-Json is an identifier for a generator that generates JSON data from the raw file. If the raw file is a JSON file, GENERATOR-Json is an implicit identity operation (i.e. an operation that does nothing) and must not be present in the map. A ResourceType may also specify other generators, such as GENERATOR-LeanTerm, which generates an instance (or 'term' in Lean jargon) of a corresponding Lean type from the raw file. ResourceTypes that specify GENERATOR-LeanTerm must also specify a corresponding GENERATOR-LeanType. While the term-version runs when data instances enter the ecosystem, the type-version runs when the ResourceType itself enters the ecosystem."
+                            "$comment": "A ResourceType may specify a set of generators that generate different representations of its instances from the raw file. A ToolProof Resource is always backed by a raw file. This is also true for the Resources (of type ResourceType) defined in this file! The build process enforces that the keys of this dict are members of a set of predefined generators. GENERATOR-Json is an identifier for a generator that generates JSON data from the raw file. If the raw file is a JSON file, GENERATOR-Json is an implicit identity operation (i.e. an operation that does nothing) and must not be present in the dict. A ResourceType may also specify other generators, such as GENERATOR-LeanTerm, which generates an instance (or 'term' in Lean jargon) of a corresponding Lean type from the raw file. ResourceTypes that specify GENERATOR-LeanTerm must also specify a corresponding GENERATOR-LeanType. While the term-version runs when data instances enter the ecosystem, the type-version runs when the ResourceType itself enters the ecosystem."
                         }
                     },
                     "allOf": [
@@ -181,7 +181,6 @@
                     "type": "object",
                     "allOf": [
                         {
-                            "$comment": "A ResourceRole does not have a self-contained identity, as it is always defined in the context of a RoleMap. ResourceRoleValue uses the Value suffix to mean 'the value stored in this map' (RoleMap.additionalProperties).",
                             "required": [
                                 "resourceTypeHandle"
                             ],
@@ -198,12 +197,39 @@
                 },
                 "unevaluatedProperties": false
             },
-            "RoleMap": {
-                "identity": "TYPE-RoleMap",
-                "name": "RoleMap",
+            "ResourceRole": {
+                "identity": "TYPE-ResourceRole",
+                "name": "ResourceRole",
                 "description": "dummy-description",
                 "nucleusSchema": {
-                    "$anchor": "RoleMap",
+                    "$anchor": "ResourceRole",
+                    "$schema": "https://json-schema.org/draft/2020-12/schema",
+                    "type": "object",
+                    "allOf": [
+                        {
+                            "type": "object",
+                            "required": [
+                                "identity"
+                            ],
+                            "properties": {
+                                "identity": {
+                                    "$ref": "#ResourceRoleIdentity"
+                                }
+                            }
+                        },
+                        {
+                            "$ref": "#ResourceRoleValue"
+                        }
+                    ]
+                },
+                "unevaluatedProperties": false
+            },
+            "RoleDict": {
+                "identity": "TYPE-RoleDict",
+                "name": "RoleDict",
+                "description": "dummy-description",
+                "nucleusSchema": {
+                    "$anchor": "RoleDict",
                     "$schema": "https://json-schema.org/draft/2020-12/schema",
                     "type": "object",
                     "propertyNames": {
@@ -246,17 +272,17 @@
                     "$schema": "https://json-schema.org/draft/2020-12/schema",
                     "type": "object",
                     "required": [
-                        "inputMap",
-                        "outputMap"
+                        "inputDict",
+                        "outputDict"
                     ],
                     "properties": {
-                        "inputMap": {
-                            "$ref": "#RoleMap"
+                        "inputDict": {
+                            "$ref": "#RoleDict"
                         },
-                        "outputMap": {
+                        "outputDict": {
                             "allOf": [
                                 {
-                                    "$ref": "#RoleMap"
+                                    "$ref": "#RoleDict"
                                 },
                                 {
                                     "type": "object",
@@ -1317,12 +1343,12 @@
                     "pattern": "^STRATEGY_THREAD-.+$"
                 }
             },
-            "StrategyThreadMap": {
-                "identity": "TYPE-StrategyThreadMap",
-                "name": "StrategyThreadMap",
+            "StrategyThreadDict": {
+                "identity": "TYPE-StrategyThreadDict",
+                "name": "StrategyThreadDict",
                 "description": "dummy-description",
                 "nucleusSchema": {
-                    "$anchor": "StrategyThreadMap",
+                    "$anchor": "StrategyThreadDict",
                     "$schema": "https://json-schema.org/draft/2020-12/schema",
                     "type": "object",
                     "propertyNames": {
@@ -1334,20 +1360,20 @@
                     "$comment": "Each thread contains an array of steps, allowing for sequential execution within a thread while supporting parallel execution across multiple threads."
                 }
             },
-            "StrategyThreadMapFacet": {
-                "identity": "TYPE-StrategyThreadMapFacet",
-                "name": "StrategyThreadMapFacet",
+            "StrategyThreadDictFacet": {
+                "identity": "TYPE-StrategyThreadDictFacet",
+                "name": "StrategyThreadDictFacet",
                 "description": "dummy-description",
                 "nucleusSchema": {
-                    "$anchor": "StrategyThreadMapFacet",
+                    "$anchor": "StrategyThreadDictFacet",
                     "$schema": "https://json-schema.org/draft/2020-12/schema",
                     "type": "object",
                     "required": [
-                        "strategyThreadMap"
+                        "strategyThreadDict"
                     ],
                     "properties": {
-                        "strategyThreadMap": {
-                            "$ref": "#StrategyThreadMap"
+                        "strategyThreadDict": {
+                            "$ref": "#StrategyThreadDict"
                         }
                     }
                 }
@@ -1374,8 +1400,8 @@
                     },
                     "allOf": [
                         {
-                            "$comment": "The Engine runs jobs specified by steps in strategyThreadMap. The Engine  also injects repeted steps when encountering loops.",
-                            "$ref": "#StrategyThreadMapFacet"
+                            "$comment": "The Engine runs jobs specified by steps in strategyThreadDict. The Engine  also injects repeted steps when encountering loops.",
+                            "$ref": "#StrategyThreadDictFacet"
                         },
                         {
                             "$comment": "The Engine updates strategyState with materialized Resources upon job completions and runtime-provided input events. It also inserts inputPotential and outputPotential Resources upon step injections.",

package/src/generated/artifacts/constants.ts

@@ -1,121 +1,122 @@
-const CONSTANTS = {
-    Names: {
-        Boolean: 'Boolean',
-        BooleanIdentity: 'BooleanIdentity',
-        BranchStep: 'BranchStep',
-        BranchStepIdentity: 'BranchStepIdentity',
-        Conditional: 'Conditional',
-        CreationContext: 'CreationContext',
-        CreationContextFacet: 'CreationContextFacet',
-        Description: 'Description',
-        DescriptionFacet: 'DescriptionFacet',
-        DocumentationFacet: 'DocumentationFacet',
-        Error: 'Error',
-        ForStep: 'ForStep',
-        ForStepIdentity: 'ForStepIdentity',
-        Goal: 'Goal',
-        GoalIdentity: 'GoalIdentity',
-        GraphEndRunEvent: 'GraphEndRunEvent',
-        GraphStartRunEvent: 'GraphStartRunEvent',
-        InterruptRunEvent: 'InterruptRunEvent',
-        Job: 'Job',
-        JobIdentity: 'JobIdentity',
-        JobStep: 'JobStep',
-        JobStepIdentity: 'JobStepIdentity',
-        JobStepSocket: 'JobStepSocket',
-        JsonData: 'JsonData',
-        Name: 'Name',
-        NameFacet: 'NameFacet',
-        Natural: 'Natural',
-        NaturalIdentity: 'NaturalIdentity',
-        Nucleus: 'Nucleus',
-        NucleusFacet: 'NucleusFacet',
-        Path: 'Path',
-        PathFacet: 'PathFacet',
-        RawStrategy: 'RawStrategy',
-        Resource: 'Resource',
-        ResourceIdentity: 'ResourceIdentity',
-        ResourceInputPotential: 'ResourceInputPotential',
-        ResourceMissing: 'ResourceMissing',
-        ResourceOutputPotential: 'ResourceOutputPotential',
-        ResourcePotential: 'ResourcePotential',
-        ResourceRoleIdentity: 'ResourceRoleIdentity',
-        ResourceRoleValue: 'ResourceRoleValue',
-        ResourceShellBase: 'ResourceShellBase',
-        ResourceShellKind: 'ResourceShellKind',
-        ResourceShellKindFacet: 'ResourceShellKindFacet',
-        ResourceType: 'ResourceType',
-        ResourceTypeIdentity: 'ResourceTypeIdentity',
-        RoleBindingArray: 'RoleBindingArray',
-        RoleBindings: 'RoleBindings',
-        RoleBindingsFacet: 'RoleBindingsFacet',
-        RoleMap: 'RoleMap',
-        Roles: 'Roles',
-        RolesFacet: 'RolesFacet',
-        RunEvent: 'RunEvent',
-        RunEventBase: 'RunEventBase',
-        RunEventCounters: 'RunEventCounters',
-        RunEventKind: 'RunEventKind',
-        RunEventStepMetadata: 'RunEventStepMetadata',
-        RunEventUpdates: 'RunEventUpdates',
-        RunnableStrategy: 'RunnableStrategy',
-        RunnableStrategyContext: 'RunnableStrategyContext',
-        RunnableStrategyIdentity: 'RunnableStrategyIdentity',
-        RunnableStrategyStatus: 'RunnableStrategyStatus',
-        RunnableStrategyUpdate: 'RunnableStrategyUpdate',
-        ShellInputPotential: 'ShellInputPotential',
-        ShellMaterialized: 'ShellMaterialized',
-        ShellMaterializedBase: 'ShellMaterializedBase',
-        ShellMissing: 'ShellMissing',
-        ShellOutputPotential: 'ShellOutputPotential',
-        Step: 'Step',
-        StepArray: 'StepArray',
-        StepIdentity: 'StepIdentity',
-        StepKind: 'StepKind',
-        StepKindFacet: 'StepKindFacet',
-        StepsFacet: 'StepsFacet',
-        StrategyRun: 'StrategyRun',
-        StrategyRunIdentity: 'StrategyRunIdentity',
-        StrategyState: 'StrategyState',
-        StrategyStateDelta: 'StrategyStateDelta',
-        StrategyStateFacet: 'StrategyStateFacet',
-        StrategyThreadIdentity: 'StrategyThreadIdentity',
-        StrategyThreadMap: 'StrategyThreadMap',
-        StrategyThreadMapFacet: 'StrategyThreadMapFacet',
-        TickRunEvent: 'TickRunEvent',
-        Timestamp: 'Timestamp',
-        TimestampFacet: 'TimestampFacet',
-        Uri: 'Uri',
-        WhileStep: 'WhileStep',
-        WhileStepIdentity: 'WhileStepIdentity',
-    },
-    Enums: {
-        ResourceShellKind: {
-            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',
-        },
-    }
-} as const;
-
-export default CONSTANTS;
+const CONSTANTS = {
+    Names: {
+        Boolean: 'Boolean',
+        BooleanIdentity: 'BooleanIdentity',
+        BranchStep: 'BranchStep',
+        BranchStepIdentity: 'BranchStepIdentity',
+        Conditional: 'Conditional',
+        CreationContext: 'CreationContext',
+        CreationContextFacet: 'CreationContextFacet',
+        Description: 'Description',
+        DescriptionFacet: 'DescriptionFacet',
+        DocumentationFacet: 'DocumentationFacet',
+        Error: 'Error',
+        ForStep: 'ForStep',
+        ForStepIdentity: 'ForStepIdentity',
+        Goal: 'Goal',
+        GoalIdentity: 'GoalIdentity',
+        GraphEndRunEvent: 'GraphEndRunEvent',
+        GraphStartRunEvent: 'GraphStartRunEvent',
+        InterruptRunEvent: 'InterruptRunEvent',
+        Job: 'Job',
+        JobIdentity: 'JobIdentity',
+        JobStep: 'JobStep',
+        JobStepIdentity: 'JobStepIdentity',
+        JobStepSocket: 'JobStepSocket',
+        JsonData: 'JsonData',
+        Name: 'Name',
+        NameFacet: 'NameFacet',
+        Natural: 'Natural',
+        NaturalIdentity: 'NaturalIdentity',
+        Nucleus: 'Nucleus',
+        NucleusFacet: 'NucleusFacet',
+        Path: 'Path',
+        PathFacet: 'PathFacet',
+        RawStrategy: 'RawStrategy',
+        Resource: 'Resource',
+        ResourceIdentity: 'ResourceIdentity',
+        ResourceInputPotential: 'ResourceInputPotential',
+        ResourceMissing: 'ResourceMissing',
+        ResourceOutputPotential: 'ResourceOutputPotential',
+        ResourcePotential: 'ResourcePotential',
+        ResourceRole: 'ResourceRole',
+        ResourceRoleIdentity: 'ResourceRoleIdentity',
+        ResourceRoleValue: 'ResourceRoleValue',
+        ResourceShellBase: 'ResourceShellBase',
+        ResourceShellKind: 'ResourceShellKind',
+        ResourceShellKindFacet: 'ResourceShellKindFacet',
+        ResourceType: 'ResourceType',
+        ResourceTypeIdentity: 'ResourceTypeIdentity',
+        RoleBindingArray: 'RoleBindingArray',
+        RoleBindings: 'RoleBindings',
+        RoleBindingsFacet: 'RoleBindingsFacet',
+        RoleDict: 'RoleDict',
+        Roles: 'Roles',
+        RolesFacet: 'RolesFacet',
+        RunEvent: 'RunEvent',
+        RunEventBase: 'RunEventBase',
+        RunEventCounters: 'RunEventCounters',
+        RunEventKind: 'RunEventKind',
+        RunEventStepMetadata: 'RunEventStepMetadata',
+        RunEventUpdates: 'RunEventUpdates',
+        RunnableStrategy: 'RunnableStrategy',
+        RunnableStrategyContext: 'RunnableStrategyContext',
+        RunnableStrategyIdentity: 'RunnableStrategyIdentity',
+        RunnableStrategyStatus: 'RunnableStrategyStatus',
+        RunnableStrategyUpdate: 'RunnableStrategyUpdate',
+        ShellInputPotential: 'ShellInputPotential',
+        ShellMaterialized: 'ShellMaterialized',
+        ShellMaterializedBase: 'ShellMaterializedBase',
+        ShellMissing: 'ShellMissing',
+        ShellOutputPotential: 'ShellOutputPotential',
+        Step: 'Step',
+        StepArray: 'StepArray',
+        StepIdentity: 'StepIdentity',
+        StepKind: 'StepKind',
+        StepKindFacet: 'StepKindFacet',
+        StepsFacet: 'StepsFacet',
+        StrategyRun: 'StrategyRun',
+        StrategyRunIdentity: 'StrategyRunIdentity',
+        StrategyState: 'StrategyState',
+        StrategyStateDelta: 'StrategyStateDelta',
+        StrategyStateFacet: 'StrategyStateFacet',
+        StrategyThreadDict: 'StrategyThreadDict',
+        StrategyThreadDictFacet: 'StrategyThreadDictFacet',
+        StrategyThreadIdentity: 'StrategyThreadIdentity',
+        TickRunEvent: 'TickRunEvent',
+        Timestamp: 'Timestamp',
+        TimestampFacet: 'TimestampFacet',
+        Uri: 'Uri',
+        WhileStep: 'WhileStep',
+        WhileStepIdentity: 'WhileStepIdentity',
+    },
+    Enums: {
+        ResourceShellKind: {
+            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',
+        },
+    }
+} as const;
+
+export default CONSTANTS;