@toolproof-core/schema 1.0.8 → 1.0.10

package/dist/scripts/generateConstantsAndMappings.js

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

package/dist/scripts/generateDependencies.js

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

package/dist/scripts/generateTerminals.js

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

package/dist/scripts/generateTypes.js

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

package/dist/scripts/wrapResourceTypesWithResourceShells.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toolproof-core/schema",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "JSON schemas and TypeScript types for ToolProof",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -39,9 +39,9 @@
     "wrapResourceTypesWithResourceShells": "node ./dist/scripts/wrapResourceTypesWithResourceShells.js",
     "generateSchemaShims": "node ./dist/scripts/generateSchemaShims.js",
     "generateDependencies": "node ./dist/scripts/generateDependencies.js",
-    "generateConstants": "node ./dist/scripts/generateConstants.js",
+    "generateConstantsAndMappings": "node ./dist/scripts/generateConstantsAndMappings.js",
     "generateTerminals": "node ./dist/scripts/generateTerminals.js",
     "generateResourceTypeGenesisType": "node ./dist/scripts/generateStandaloneType.js --name Genesis",
-    "update": "rimraf /s /q dist && pnpm run build:scripts && pnpm run normalizeAnchorsToPointers && pnpm run extractSchemasFromResourceTypeShells && pnpm run generateConstants && pnpm run generateStandaloneSchema -- --name Job && pnpm run generateStandaloneSchema -- --name ResourceType && pnpm run generateStandaloneSchema -- --name RawStrategy && pnpm run generateStandaloneSchema -- --name RunnableStrategy && pnpm run generateStandaloneSchema -- --name StrategyRun && pnpm run generateStandaloneSchema -- --name Goal && pnpm run wrapResourceTypesWithResourceShells && pnpm run generateSchemaShims && pnpm run generateTypes && pnpm run generateStandaloneType -- --name Job && pnpm run generateStandaloneType -- --name ResourceType && pnpm run generateStandaloneType -- --name RawStrategy && pnpm run generateStandaloneType -- --name RunnableStrategy && pnpm run generateResourceTypeGenesisType && pnpm run generateDependencies && pnpm run generateTerminals && pnpm run build"
+    "update": "rimraf /s /q dist && pnpm run build:scripts && pnpm run normalizeAnchorsToPointers && pnpm run extractSchemasFromResourceTypeShells && pnpm run generateConstantsAndMappings && pnpm run generateStandaloneSchema -- --name Job && pnpm run generateStandaloneSchema -- --name ResourceType && pnpm run generateStandaloneSchema -- --name RawStrategy && pnpm run generateStandaloneSchema -- --name RunnableStrategy && pnpm run generateStandaloneSchema -- --name StrategyRun && pnpm run generateStandaloneSchema -- --name Goal && pnpm run wrapResourceTypesWithResourceShells && pnpm run generateSchemaShims && pnpm run generateTypes && pnpm run generateStandaloneType -- --name Job && pnpm run generateStandaloneType -- --name ResourceType && pnpm run generateStandaloneType -- --name RawStrategy && pnpm run generateStandaloneType -- --name RunnableStrategy && pnpm run generateResourceTypeGenesisType && pnpm run generateDependencies && pnpm run generateTerminals && pnpm run build"
   }
 }

package/src/Genesis.json

@@ -5,7 +5,7 @@
     "nucleusSchema": {
         "$comment": "This file defines all schemas used internally by ToolProof.",
         "$anchor": "Genesis",
-        "$id": "https://schemas.toolproof.com/v2/Genesis.json",
+        "$id": "https://schemas.toolproof.com/v1/Genesis.json",
         "$schema": "https://json-schema.org/draft/2020-12/schema",
         "$defs": {
             "Name": {
@@ -259,6 +259,7 @@
                                     "$ref": "#RoleMap"
                                 },
                                 {
+                                    "type": "object",
                                     "required": [
                                         "ROLE-ErrorOutput"
                                     ],
@@ -343,6 +344,7 @@
                             "$ref": "#JobIdentity"
                         },
                         "implementationUri": {
+                            "$comment": "Instances of a ResourceType that requires implementationUri are 'executable' ResourceTypes. TYPE-Job is the canonical executable ResourceType in the ecosystem.",
                             "$ref": "#Uri"
                         }
                     },
@@ -756,7 +758,7 @@
                     "required": [
                         "identity",
                         "resourceTypeHandle",
-                        "resourceKind"
+                        "resourceShellKind"
                     ],
                     "properties": {
                         "identity": {
@@ -765,18 +767,18 @@
                         "resourceTypeHandle": {
                             "$ref": "#ResourceTypeIdentity"
                         },
-                        "resourceKind": {
-                            "$ref": "#ResourceKind"
+                        "resourceShellKind": {
+                            "$ref": "#ResourceShellKind"
                         }
                     }
                 }
             },
-            "ResourceKind": {
-                "identity": "TYPE-ResourceKind",
-                "name": "ResourceKind",
+            "ResourceShellKind": {
+                "identity": "TYPE-ResourceShellKind",
+                "name": "ResourceShellKind",
                 "description": "dummy-description",
                 "nucleusSchema": {
-                    "$anchor": "ResourceKind",
+                    "$anchor": "ResourceShellKind",
                     "$schema": "https://json-schema.org/draft/2020-12/schema",
                     "type": "string",
                     "enum": [
@@ -787,20 +789,20 @@
                     ]
                 }
             },
-            "ResourceKindFacet": {
-                "identity": "TYPE-ResourceKindFacet",
-                "name": "ResourceKindFacet",
+            "ResourceShellKindFacet": {
+                "identity": "TYPE-ResourceShellKindFacet",
+                "name": "ResourceShellKindFacet",
                 "description": "dummy-description",
                 "nucleusSchema": {
-                    "$anchor": "ResourceKindFacet",
+                    "$anchor": "ResourceShellKindFacet",
                     "$schema": "https://json-schema.org/draft/2020-12/schema",
                     "type": "object",
                     "required": [
-                        "resourceKind"
+                        "resourceShellKind"
                     ],
                     "properties": {
-                        "resourceKind": {
-                            "$ref": "#ResourceKind"
+                        "resourceShellKind": {
+                            "$ref": "#ResourceShellKind"
                         }
                     }
                 }
@@ -813,8 +815,11 @@
                     "$anchor": "ShellMissing",
                     "$schema": "https://json-schema.org/draft/2020-12/schema",
                     "type": "object",
+                    "required": [
+                        "resourceShellKind"
+                    ],
                     "properties": {
-                        "resourceKind": {
+                        "resourceShellKind": {
                             "const": "missing"
                         }
                     },
@@ -823,7 +828,7 @@
                             "$ref": "#ResourceShellBase"
                         },
                         {
-                            "$ref": "#ResourceKindFacet"
+                            "$ref": "#ResourceShellKindFacet"
                         }
                     ],
                     "unevaluatedProperties": false
@@ -837,8 +842,11 @@
                     "$anchor": "ShellInputPotential",
                     "$schema": "https://json-schema.org/draft/2020-12/schema",
                     "type": "object",
+                    "required": [
+                        "resourceShellKind"
+                    ],
                     "properties": {
-                        "resourceKind": {
+                        "resourceShellKind": {
                             "const": "inputPotential"
                         }
                     },
@@ -850,7 +858,7 @@
                             "$ref": "#CreationContextFacet"
                         },
                         {
-                            "$ref": "#ResourceKindFacet"
+                            "$ref": "#ResourceShellKindFacet"
                         }
                     ],
                     "unevaluatedProperties": false
@@ -864,8 +872,11 @@
                     "$anchor": "ShellOutputPotential",
                     "$schema": "https://json-schema.org/draft/2020-12/schema",
                     "type": "object",
+                    "required": [
+                        "resourceShellKind"
+                    ],
                     "properties": {
-                        "resourceKind": {
+                        "resourceShellKind": {
                             "const": "outputPotential"
                         }
                     },
@@ -877,7 +888,7 @@
                             "$ref": "#CreationContextFacet"
                         },
                         {
-                            "$ref": "#ResourceKindFacet"
+                            "$ref": "#ResourceShellKindFacet"
                         }
                     ],
                     "unevaluatedProperties": false
@@ -950,13 +961,14 @@
                     "$schema": "https://json-schema.org/draft/2020-12/schema",
                     "type": "object",
                     "required": [
-                        "version"
+                        "version",
+                        "resourceShellKind"
                     ],
                     "properties": {
                         "version": {
                             "const": 1
                         },
-                        "resourceKind": {
+                        "resourceShellKind": {
                             "const": "materialized"
                         }
                     },
@@ -968,7 +980,7 @@
                             "$ref": "#CreationContextFacet"
                         },
                         {
-                            "$ref": "#ResourceKindFacet"
+                            "$ref": "#ResourceShellKindFacet"
                         },
                         {
                             "$ref": "#TimestampFacet"
@@ -1027,6 +1039,28 @@
                     "unevaluatedProperties": false
                 }
             },
+            "ResourcePotential": {
+                "identity": "TYPE-ResourcePotential",
+                "name": "ResourcePotential",
+                "description": "dummy-description",
+                "nucleusSchema": {
+                    "$anchor": "ResourcePotential",
+                    "$schema": "https://json-schema.org/draft/2020-12/schema",
+                    "type": "object",
+                    "oneOf": [
+                        {
+                            "$ref": "#ResourceMissing"
+                        },
+                        {
+                            "$ref": "#ResourceInputPotential"
+                        },
+                        {
+                            "$ref": "#ResourceOutputPotential"
+                        }
+                    ],
+                    "unevaluatedProperties": false
+                }
+            },
             "JsonData": {
                 "identity": "TYPE-JsonData",
                 "name": "JsonData",
@@ -1087,32 +1121,10 @@
                         "nucleus"
                     ],
                     "properties": {
-                        "nucleus": {
-                            "$ref": "#Nucleus"
-                        }
+                        "nucleus": true
                     }
                 }
             },
-            "ResourceMaterialized": {
-                "identity": "TYPE-ResourceMaterialized",
-                "name": "ResourceMaterialized",
-                "description": "dummy-description",
-                "nucleusSchema": {
-                    "$anchor": "ResourceMaterialized",
-                    "$schema": "https://json-schema.org/draft/2020-12/schema",
-                    "type": "object",
-                    "allOf": [
-                        {
-                            "$ref": "#ShellMaterializedBase"
-                        },
-                        {
-                            "$comment": "This will be overlayed dynamically to match the data structure of the underlying ResourceType's nucleusSchema.",
-                            "$ref": "#NucleusFacet"
-                        }
-                    ],
-                    "unevaluatedProperties": false
-                }
-            },
             "Resource": {
                 "identity": "TYPE-Resource",
                 "name": "Resource",
@@ -1121,18 +1133,13 @@
                     "$anchor": "Resource",
                     "$schema": "https://json-schema.org/draft/2020-12/schema",
                     "type": "object",
-                    "oneOf": [
-                        {
-                            "$ref": "#ResourceMissing"
-                        },
-                        {
-                            "$ref": "#ResourceInputPotential"
-                        },
+                    "allOf": [
                         {
-                            "$ref": "#ResourceOutputPotential"
+                            "$ref": "#ShellMaterializedBase"
                         },
                         {
-                            "$ref": "#ResourceMaterialized"
+                            "$comment": "This will be overlayed dynamically to match the data structure of the underlying ResourceType's nucleusSchema.",
+                            "$ref": "#NucleusFacet"
                         }
                     ],
                     "unevaluatedProperties": false
@@ -1150,7 +1157,14 @@
                         "$ref": "#ResourceRoleIdentity"
                     },
                     "additionalProperties": {
-                        "$ref": "#Resource"
+                        "oneOf": [
+                            {
+                                "$ref": "#ResourcePotential"
+                            },
+                            {
+                                "$ref": "#Resource"
+                            }
+                        ]
                     }
                 }
             },