@toolproof-npm/schema 0.1.44 → 0.1.45

package/dist/index.d.ts

@@ -1,9 +1,9 @@
 export { default as GenesisSchema } from './genesis/generated/schemas/Genesis.js';
 export { default as Genesis } from './genesis/resourceTypes/Genesis.js';
 export { default as JobSchema } from './genesis/generated/schemas/Job.js';
-export type { Resource_ResourceFormat as Resource_ResourceFormatJson } from './_lib/types/Resource_ResourceFormat.js';
-export type { Resource_ResourceType as Resource_ResourceTypeJson } from './_lib/types/Resource_ResourceType.js';
-export type { Resource_Job as Resource_JobJson } from './_lib/types/Resource_Job.js';
-export type { Documented as DocumentedJson, ResourceFormatId as ResourceFormatIdJson, ResourceFormat as ResourceFormatJson, ExtractionSchema as ExtractionSchemaJson, ExtractionSchemaValue as ExtractionSchemaValueJson, IdentityProp as IdentityPropJson, MeritProp as MeritPropJson, ResourceTypeId as ResourceTypeIdJson, ResourceType as ResourceTypeJson, ResourceRoleId as ResourceRoleIdJson, ResourceRoleValue as ResourceRoleValueJson, ExecutionId as ExecutionIdJson, Execution as ExecutionJson, ConditionalWrapper as ConditionalWrapperJson, RoleMap as RoleMapJson, RolesOuter as RolesOuterJson, RoleBindingMap as RoleBindingMapJson, RoleBindingsOuter as RoleBindingsOuterJson, ResourceId as ResourceIdJson, WorkStepId as WorkStepIdJson, BranchStepId as BranchStepIdJson, WhileStepId as WhileStepIdJson, ForStepId as ForStepIdJson, WorkStep as WorkStepJson, BranchStep as BranchStepJson, WhileStep as WhileStepJson, ForStep as ForStepJson, Step as StepJson, CreationContextValue as CreationContextValueJson, ResourceMissing as ResourceMissingJson, ResourcePotentialInput as ResourcePotentialInputJson, ResourcePotentialOutput as ResourcePotentialOutputJson, ResourceMetaBase as ResourceMetaJson, // ATTENTION: type not generated for ResourceMeta
-Resource as ResourceJson, StrategyState as StrategyStateJson, StrategyStateValue as StrategyStateValueJson, StatelessStrategyId as StatelessStrategyIdJson, StatelessStrategy as StatelessStrategyJson, StatefulStrategyId as StatefulStrategyIdJson, StatefulStrategy as StatefulStrategyJson, JobId as JobIdJson, Job as JobJson, JsonValue as JsonValueJson, } from './_lib/types/types.js';
-export { unsafeBrand, asResourceTypeId, asResourceRoleId, asExecutionId, asResourceId, asWorkStepId, asBranchStepId, asForStepId, asResourceFormatId, asWhileStepId, asStatelessStrategyId, asStatefulStrategyId, asResourceTypeIds, asResourceRoleIds, asExecutionIds, asResourceIds, asWorkStepIds, asBranchStepIds, asForStepIds, asResourceFormatIds, asWhileStepIds, asStatelessStrategyIds, asStatefulStrategyIds, } from './scripts/brandFactories.js';
+export type { Resource_ResourceFormat as Resource_ResourceFormatJson } from './genesis/generated/types/Resource_ResourceFormat.js';
+export type { Resource_ResourceType as Resource_ResourceTypeJson } from './genesis/generated/types/Resource_ResourceType.js';
+export type { Resource_Job as Resource_JobJson } from './genesis/generated/types/Resource_Job.js';
+export type { Documented as DocumentedJson, ResourceFormatIdentity as ResourceFormatIdentityJson, ResourceFormat as ResourceFormatJson, ExtractionSchema as ExtractionSchemaJson, IdentityProp as IdentityPropJson, MeritProp as MeritPropJson, ResourceTypeIdentity as ResourceTypeIdentityJson, ResourceType as ResourceTypeJson, ResourceRoleIdentity as ResourceRoleIdentityJson, ResourceRoleValue as ResourceRoleValueJson, ExecutionIdentity as ExecutionIdentityJson, Execution as ExecutionJson, Conditional as ConditionalJson, RoleMap as RoleMapJson, Roles as RolesJson, RoleBindingMap as RoleBindingMapJson, RoleBindings as RoleBindingsJson, ResourceIdentity as ResourceIdentityJson, WorkStepIdentity as WorkStepIdentityJson, BranchStepIdentity as BranchStepIdentityJson, WhileStepIdentity as WhileStepIdentityJson, ForStepIdentity as ForStepIdentityJson, WorkStep as WorkStepJson, BranchStep as BranchStepJson, WhileStep as WhileStepJson, ForStep as ForStepJson, Step as StepJson, CreationContext as CreationContextJson, ResourceMissing as ResourceMissingJson, ResourcePotentialInput as ResourcePotentialInputJson, ResourcePotentialOutput as ResourcePotentialOutputJson, ResourceMetaBase as ResourceMetaJson, // ATTENTION: type not generated for ResourceMeta
+Resource as ResourceJson, StrategyState as StrategyStateJson, StatelessStrategyIdentity as StatelessStrategyIdentityJson, StatelessStrategy as StatelessStrategyJson, StatefulStrategyIdentity as StatefulStrategyIdentityJson, StatefulStrategy as StatefulStrategyJson, JobIdentity as JobIdentityJson, Job as JobJson, JsonData as JsonDataJson, } from './genesis/generated/types/types.js';
+export { unsafeBrand, asResourceTypeIdentity, asResourceRoleIdentity, asExecutionIdentity, asResourceIdentity, asWorkStepIdentity, asBranchStepIdentity, asForStepIdentity, asResourceFormatIdentity, asWhileStepIdentity, asStatelessStrategyIdentity, asStatefulStrategyIdentity, asResourceTypeIdentities, asResourceRoleIdentities, asExecutionIdentities, asResourceIdentities, asWorkStepIdentities, asBranchStepIdentities, asForStepIdentities, asResourceFormatIdentities, asWhileStepIdentities, asStatelessStrategyIdentities, asStatefulStrategyIdentities, } from './scripts/brandFactories.js';

package/dist/index.js

@@ -2,5 +2,5 @@
 export { default as GenesisSchema } from './genesis/generated/schemas/Genesis.js';
 export { default as Genesis } from './genesis/resourceTypes/Genesis.js';
 export { default as JobSchema } from './genesis/generated/schemas/Job.js';
-// Re-export brand factories so consumers can construct branded IDs at runtime.
-export { unsafeBrand, asResourceTypeId, asResourceRoleId, asExecutionId, asResourceId, asWorkStepId, asBranchStepId, asForStepId, asResourceFormatId, asWhileStepId, asStatelessStrategyId, asStatefulStrategyId, asResourceTypeIds, asResourceRoleIds, asExecutionIds, asResourceIds, asWorkStepIds, asBranchStepIds, asForStepIds, asResourceFormatIds, asWhileStepIds, asStatelessStrategyIds, asStatefulStrategyIds, } from './scripts/brandFactories.js';
+// Re-export brand factories so consumers can construct branded identities at runtime.
+export { unsafeBrand, asResourceTypeIdentity, asResourceRoleIdentity, asExecutionIdentity, asResourceIdentity, asWorkStepIdentity, asBranchStepIdentity, asForStepIdentity, asResourceFormatIdentity, asWhileStepIdentity, asStatelessStrategyIdentity, asStatefulStrategyIdentity, asResourceTypeIdentities, asResourceRoleIdentities, asExecutionIdentities, asResourceIdentities, asWorkStepIdentities, asBranchStepIdentities, asForStepIdentities, asResourceFormatIdentities, asWhileStepIdentities, asStatelessStrategyIdentities, asStatefulStrategyIdentities, } from './scripts/brandFactories.js';

package/dist/scripts/_lib/config.js

@@ -21,8 +21,8 @@ export class SchemaConfig {
         this.sourceDir = getEnv('TP_SCHEMA_SOURCE_DIR', 'src/genesis/resourceTypes');
         this.sourceFile = getEnv('TP_SCHEMA_SOURCE_FILE', 'Genesis.json');
         this.outputDir = getEnv('TP_SCHEMA_OUTPUT_DIR', 'src/genesis/generated/schemas');
-        this.typesSrcDir = getEnv('TP_SCHEMA_TYPES_SRC_DIR', 'src/_lib/types');
-        this.typesDistDir = getEnv('TP_SCHEMA_TYPES_DIST_DIR', 'dist/_lib/types');
+        this.typesSrcDir = getEnv('TP_SCHEMA_TYPES_SRC_DIR', 'src/genesis/generated/types');
+        this.typesDistDir = getEnv('TP_SCHEMA_TYPES_DIST_DIR', 'dist/genesis/generated/types');
         this.baseUrl = getEnv('TP_SCHEMA_BASE_URL', 'https://schemas.toolproof.com');
         this.version = getEnv('TP_SCHEMA_VERSION', 'v0');
     }

package/dist/scripts/brandFactories.d.ts

@@ -1,25 +1,39 @@
-import type { ExecutionId, ResourceId, WorkStepId, BranchStepId, ForStepId, ResourceFormatId, ResourceTypeId, ResourceRoleId, WhileStepId, StatelessStrategyId, StatefulStrategyId } from "../_lib/types/types.js";
+type Brand<K extends string> = string & {
+    readonly __brand: K;
+};
+export type ExecutionIdentity = Brand<'ExecutionIdentity'>;
+export type ResourceIdentity = Brand<'ResourceIdentity'>;
+export type WorkStepIdentity = Brand<'WorkStepIdentity'>;
+export type BranchStepIdentity = Brand<'BranchStepIdentity'>;
+export type ForStepIdentity = Brand<'ForStepIdentity'>;
+export type WhileStepIdentity = Brand<'WhileStepIdentity'>;
+export type ResourceFormatIdentity = Brand<'ResourceFormatIdentity'>;
+export type ResourceTypeIdentity = Brand<'ResourceTypeIdentity'>;
+export type ResourceRoleIdentity = Brand<'ResourceRoleIdentity'>;
+export type StatelessStrategyIdentity = Brand<'StatelessStrategyIdentity'>;
+export type StatefulStrategyIdentity = Brand<'StatefulStrategyIdentity'>;
 /** Generic unsafe brand helper when a bespoke factory is not available. */
 export declare function unsafeBrand<T extends string>(s: string): T;
-export declare const asResourceTypeId: (s: string) => string;
-export declare const asResourceRoleId: (s: string) => string;
-export declare const asExecutionId: (s: string) => string;
-export declare const asResourceId: (s: string) => string;
-export declare const asWorkStepId: (s: string) => string;
-export declare const asBranchStepId: (s: string) => string;
-export declare const asForStepId: (s: string) => string;
-export declare const asResourceFormatId: (s: string) => string;
-export declare const asWhileStepId: (s: string) => string;
-export declare const asStatelessStrategyId: (s: string) => string;
-export declare const asStatefulStrategyId: (s: string) => string;
-export declare const asResourceTypeIds: (xs: string[]) => ResourceTypeId[];
-export declare const asResourceRoleIds: (xs: string[]) => ResourceRoleId[];
-export declare const asExecutionIds: (xs: string[]) => ExecutionId[];
-export declare const asResourceIds: (xs: string[]) => ResourceId[];
-export declare const asWorkStepIds: (xs: string[]) => WorkStepId[];
-export declare const asBranchStepIds: (xs: string[]) => BranchStepId[];
-export declare const asForStepIds: (xs: string[]) => ForStepId[];
-export declare const asResourceFormatIds: (xs: string[]) => ResourceFormatId[];
-export declare const asWhileStepIds: (xs: string[]) => WhileStepId[];
-export declare const asStatelessStrategyIds: (xs: string[]) => StatelessStrategyId[];
-export declare const asStatefulStrategyIds: (xs: string[]) => StatefulStrategyId[];
+export declare const asResourceTypeIdentity: (s: string) => ResourceTypeIdentity;
+export declare const asResourceRoleIdentity: (s: string) => ResourceRoleIdentity;
+export declare const asExecutionIdentity: (s: string) => ExecutionIdentity;
+export declare const asResourceIdentity: (s: string) => ResourceIdentity;
+export declare const asWorkStepIdentity: (s: string) => WorkStepIdentity;
+export declare const asBranchStepIdentity: (s: string) => BranchStepIdentity;
+export declare const asForStepIdentity: (s: string) => ForStepIdentity;
+export declare const asResourceFormatIdentity: (s: string) => ResourceFormatIdentity;
+export declare const asWhileStepIdentity: (s: string) => WhileStepIdentity;
+export declare const asStatelessStrategyIdentity: (s: string) => StatelessStrategyIdentity;
+export declare const asStatefulStrategyIdentity: (s: string) => StatefulStrategyIdentity;
+export declare const asResourceTypeIdentities: (xs: string[]) => ResourceTypeIdentity[];
+export declare const asResourceRoleIdentities: (xs: string[]) => ResourceRoleIdentity[];
+export declare const asExecutionIdentities: (xs: string[]) => ExecutionIdentity[];
+export declare const asResourceIdentities: (xs: string[]) => ResourceIdentity[];
+export declare const asWorkStepIdentities: (xs: string[]) => WorkStepIdentity[];
+export declare const asBranchStepIdentities: (xs: string[]) => BranchStepIdentity[];
+export declare const asForStepIdentities: (xs: string[]) => ForStepIdentity[];
+export declare const asResourceFormatIdentities: (xs: string[]) => ResourceFormatIdentity[];
+export declare const asWhileStepIdentities: (xs: string[]) => WhileStepIdentity[];
+export declare const asStatelessStrategyIdentities: (xs: string[]) => StatelessStrategyIdentity[];
+export declare const asStatefulStrategyIdentities: (xs: string[]) => StatefulStrategyIdentity[];
+export {};

package/dist/scripts/brandFactories.js

@@ -1,6 +1,3 @@
-// Runtime factories for branded ID string types.
-// Note: The branded types are declared in src/types/types.d.ts by the generator.
-// We import them as type-only so there is no runtime dependency on the .d.ts file.
 // Optional runtime validation toggle. Off by default.
 // Enable by setting TP_BRAND_VALIDATE=1 (or NODE_ENV=development) when running.
 const shouldValidate = (typeof process !== "undefined" && !!process.env &&
@@ -19,31 +16,31 @@ export function unsafeBrand(s) {
     return s;
 }
 // Known patterns from schemas (when available)
-const RE_TYPE_ID = /^TYPE-.+$/;
-const RE_JOB_ID = /^JOB-.+$/;
-const RE_ROLE_ID = /^ROLE-.+$/;
-// Factories for each Id-like type
-export const asResourceTypeId = makeFactory("ResourceTypeId", RE_TYPE_ID);
-export const asResourceRoleId = makeFactory("ResourceRoleId", RE_ROLE_ID);
+const RE_TYPE_IDENTITY = /^TYPE-.+$/;
+const RE_JOB_IDENTITY = /^JOB-.+$/;
+const RE_ROLE_IDENTITY = /^ROLE-.+$/;
+// Factories for each Identity-like type
+export const asResourceTypeIdentity = makeFactory("ResourceTypeIdentity", RE_TYPE_IDENTITY);
+export const asResourceRoleIdentity = makeFactory("ResourceRoleIdentity", RE_ROLE_IDENTITY);
 // IDs without strict regex patterns in the current schemas: keep unchecked casts.
-export const asExecutionId = makeFactory("ExecutionId");
-export const asResourceId = makeFactory("ResourceId");
-export const asWorkStepId = makeFactory("WorkStepId");
-export const asBranchStepId = makeFactory("BranchStepId");
-export const asForStepId = makeFactory("ForStepId");
-export const asResourceFormatId = makeFactory("ResourceFormatId");
-export const asWhileStepId = makeFactory("WhileStepId");
-export const asStatelessStrategyId = makeFactory("StatelessStrategyId");
-export const asStatefulStrategyId = makeFactory("StatefulStrategyId");
+export const asExecutionIdentity = makeFactory("ExecutionIdentity");
+export const asResourceIdentity = makeFactory("ResourceIdentity");
+export const asWorkStepIdentity = makeFactory("WorkStepIdentity");
+export const asBranchStepIdentity = makeFactory("BranchStepIdentity");
+export const asForStepIdentity = makeFactory("ForStepIdentity");
+export const asResourceFormatIdentity = makeFactory("ResourceFormatIdentity");
+export const asWhileStepIdentity = makeFactory("WhileStepIdentity");
+export const asStatelessStrategyIdentity = makeFactory("StatelessStrategyIdentity");
+export const asStatefulStrategyIdentity = makeFactory("StatefulStrategyIdentity");
 // Batch helpers
-export const asResourceTypeIds = (xs) => xs.map(asResourceTypeId);
-export const asResourceRoleIds = (xs) => xs.map(asResourceRoleId);
-export const asExecutionIds = (xs) => xs.map(asExecutionId);
-export const asResourceIds = (xs) => xs.map(asResourceId);
-export const asWorkStepIds = (xs) => xs.map(asWorkStepId);
-export const asBranchStepIds = (xs) => xs.map(asBranchStepId);
-export const asForStepIds = (xs) => xs.map(asForStepId);
-export const asResourceFormatIds = (xs) => xs.map(asResourceFormatId);
-export const asWhileStepIds = (xs) => xs.map(asWhileStepId);
-export const asStatelessStrategyIds = (xs) => xs.map(asStatelessStrategyId);
-export const asStatefulStrategyIds = (xs) => xs.map(asStatefulStrategyId);
+export const asResourceTypeIdentities = (xs) => xs.map(asResourceTypeIdentity);
+export const asResourceRoleIdentities = (xs) => xs.map(asResourceRoleIdentity);
+export const asExecutionIdentities = (xs) => xs.map(asExecutionIdentity);
+export const asResourceIdentities = (xs) => xs.map(asResourceIdentity);
+export const asWorkStepIdentities = (xs) => xs.map(asWorkStepIdentity);
+export const asBranchStepIdentities = (xs) => xs.map(asBranchStepIdentity);
+export const asForStepIdentities = (xs) => xs.map(asForStepIdentity);
+export const asResourceFormatIdentities = (xs) => xs.map(asResourceFormatIdentity);
+export const asWhileStepIdentities = (xs) => xs.map(asWhileStepIdentity);
+export const asStatelessStrategyIdentities = (xs) => xs.map(asStatelessStrategyIdentity);
+export const asStatefulStrategyIdentities = (xs) => xs.map(asStatefulStrategyIdentity);

package/dist/scripts/extractSchemas.js

@@ -105,7 +105,7 @@ function unwrapTypes(node, topDefs, labelPath = [], visited = new Set()) {
         // Hoist inner $defs before stripping
         mergeDefs(topDefs, inner, labelPath.join("_"));
         // Return the inner schema itself, after also unwrapping any nested envelopes it may contain
-        const unwrappedInner = unwrapTypes(inner, topDefs, labelPath.concat([String(env.id || "env")]), visited);
+        const unwrappedInner = unwrapTypes(inner, topDefs, labelPath.concat([String(env.identity || "env")]), visited);
         return unwrappedInner;
     }
     if (Array.isArray(node)) {

package/dist/scripts/generateResourceEnvelopes.js

@@ -40,10 +40,10 @@ async function main() {
     // First entry is Genesis itself with empty extractedData
     resources['Genesis'] = {
         identity: 'RESOURCE-Genesis',
-        resourceTypeId: 'TYPE-ResourceType',
+        resourceTypeRef: 'TYPE-ResourceType',
         creationContext: {
-            resourceRoleId: 'ROLE-Genesis',
-            executionId: 'EXECUTION-Genesis'
+            resourceRoleRef: 'ROLE-Genesis',
+            executionRef: 'EXECUTION-Genesis'
         },
         kind: 'materialized',
         timestamp: genesisTimestamp,
@@ -54,10 +54,10 @@ async function main() {
         const defValue = defs[defName];
         resources[defName] = {
             identity: `RESOURCE-${defName}`,
-            resourceTypeId: 'TYPE-ResourceType',
+            resourceTypeRef: 'TYPE-ResourceType',
             creationContext: {
-                resourceRoleId: 'ROLE-Genesis',
-                executionId: `EXECUTION-${defName}`
+                resourceRoleRef: 'ROLE-Genesis',
+                executionRef: `EXECUTION-${defName}`
             },
             kind: 'materialized',
             timestamp: genesisTimestamp,

package/dist/scripts/generateTypes.js

@@ -5,7 +5,7 @@ import { getConfig } from './_lib/config.js';
 const config = getConfig();
 const projectRoot = config.getRoot();
 const inputDir = config.getOutputDir();
-// We emit under src/_lib/types and dist/_lib/types
+// We emit under src/genesis/generated/types and dist/genesis/generated/types
 const srcLibTypesDir = config.getTypesSrcDir();
 const srcLibOutputPath = config.getTypesSrcPath('types.d.ts');
 // Build an index of all schema files by their basename
@@ -25,8 +25,13 @@ function buildSchemaIndex(root) {
                 stack.push(full);
             }
             else if (entry.isFile() && entry.name.endsWith('.json')) {
+                // Ignore temp files that can be left behind after crashes
                 if (entry.name === '.combined-schema.json')
-                    continue; // ignore temp file
+                    continue;
+                if (entry.name.startsWith('.normalized.'))
+                    continue;
+                if (entry.name.startsWith('.'))
+                    continue;
                 const baseName = entry.name; // keep extension for direct mapping
                 if (index.has(baseName)) {
                     // Hard fail on collisions so they can be fixed explicitly
@@ -59,8 +64,13 @@ function listAllSchemaFiles(root) {
                 stack.push(full);
             }
             else if (entry.isFile() && entry.name.endsWith('.json')) {
+                // Ignore temp files that can be left behind after crashes
                 if (entry.name === '.combined-schema.json')
-                    continue; // ignore temp
+                    continue;
+                if (entry.name.startsWith('.normalized.'))
+                    continue;
+                if (entry.name.startsWith('.'))
+                    continue;
                 // produce path relative to root with posix separators
                 const rel = path.relative(root, full).split(path.sep).join('/');
                 files.push(rel);
@@ -71,7 +81,7 @@ function listAllSchemaFiles(root) {
     return files;
 }
 async function main() {
-    // Ensure src/_lib/types exists (we no longer write to src/types to avoid duplication)
+    // Ensure types output folder exists
     fs.mkdirSync(srcLibTypesDir, { recursive: true });
     const parts = [];
     parts.push('// Auto-generated from JSON schemas. Do not edit.\n');
@@ -316,10 +326,9 @@ async function main() {
         if (!ts || !ts.trim()) {
             ts = '// (No concrete types emitted by generator)\nexport {}\n';
         }
-        // Overlay Id aliases with template literal types inferred from Genesis.json patterns.
-        // For each $defs entry ending with "Id" or specific key types that provide a `pattern`,
-        // we derive a TS template literal. If no recognizable pattern exists,
-        // we fall back to plain `string` (moving away from branded types).
+        // Overlay Identity/Ref aliases with template literal types inferred from Genesis.json patterns.
+        // For each $defs entry ending with "Identity" or "Ref", and that provides a `pattern`,
+        // derive a TS template literal; otherwise fall back to plain `string`.
         function deriveTemplateFromPattern(pattern) {
             // Common form: ^PREFIX-.+$ => PREFIX-${string}
             const m1 = /^\^([^$]+)\.\+\$/.exec(pattern);
@@ -339,7 +348,7 @@ async function main() {
             }
             return undefined;
         }
-        function loadIdTemplates() {
+        function loadPatternTemplates() {
             const map = {};
             try {
                 const genesisPath = path.join(inputDir, config.getSourceFile());
@@ -348,9 +357,10 @@ async function main() {
                     const parsed = JSON.parse(raw);
                     const defs = parsed?.$defs && typeof parsed.$defs === 'object' ? parsed.$defs : {};
                     for (const [defName, defVal] of Object.entries(defs)) {
-                        // Process Id types
-                        const isIdType = /Id$/.test(defName);
-                        if (!isIdType)
+                        // Process pattern-bearing string types.
+                        // Supports "...Identity" / "...Ref" conventions.
+                        const isPatternType = /(?:Identity|Ref)$/.test(defName);
+                        if (!isPatternType)
                             continue;
                         const v = defVal;
                         if (v && v.type === 'string' && typeof v.pattern === 'string') {
@@ -366,22 +376,25 @@ async function main() {
             }
             return map;
         }
-        const idTemplates = loadIdTemplates();
-        // Replace any exported Id aliases to use the inferred template literals where available.
+        const patternTemplates = loadPatternTemplates();
+        // Replace any exported Identity/Ref aliases to use the inferred template literals where available.
         // Handle both `= string;` and any pre-existing branded alias `= Branded<string, 'X'>;`.
-        ts = ts.replace(/^(export\s+type\s+)([A-Za-z_][A-Za-z0-9_]*Id)(\s*=\s*)Branded<string,\s*'[^']+'>\s*;$/gm, (_m, p1, typeName, p3) => {
-            const tmpl = idTemplates[typeName];
+        ts = ts.replace(/^(export\s+type\s+)([A-Za-z_][A-Za-z0-9_]*(?:Identity|Ref))(\s*=\s*)Branded<string,\s*'[^']+'>\s*;$/gm, (_m, p1, typeName, p3) => {
+            const tmpl = patternTemplates[typeName];
             return `${p1}${typeName}${p3}${tmpl ?? 'string'};`;
         });
-        ts = ts.replace(/^(export\s+type\s+)([A-Za-z_][A-ZaZ0-9_]*Id)(\s*=\s*)string\s*;$/gm, (_m, p1, typeName, p3) => {
-            const tmpl = idTemplates[typeName];
+        ts = ts.replace(/^(export\s+type\s+)([A-Za-z_][A-Za-z0-9_]*(?:Identity|Ref))(\s*=\s*)string\s*;$/gm, (_m, p1, typeName, p3) => {
+            const tmpl = patternTemplates[typeName];
             return `${p1}${typeName}${p3}${tmpl ?? 'string'};`;
         });
-        // Post-process map-like interfaces to enforce key constraints via template literal Id types.
-        // Replace index-signature interfaces with Record<IdType, ValueType> so object literal keys are checked.
-        ts = ts.replace(/export interface RoleMap\s*{[^}]*}/g, 'export type RoleMap = Record<ResourceRoleId, ResourceRoleValue>;');
-        ts = ts.replace(/export interface RoleBindingMap\s*{[^}]*}/g, 'export type RoleBindingMap = Record<ResourceRoleId, ResourceId>;');
-        ts = ts.replace(/export interface StrategyState\s*\{[^}]*\{[^}]*\}[^}]*\}/gs, 'export type StrategyState = Record<ExecutionId, Record<ResourceRoleId, ResourcePotentialInput | ResourcePotentialOutput | Resource>>;');
+        // Post-process map-like interfaces to enforce key constraints via template literal Identity types.
+        // Replace index-signature interfaces with Record<KeyType, ValueType> so object literal keys are checked.
+        const resourceRoleKeyType = 'ResourceRoleIdentity';
+        const resourceKeyType = 'ResourceIdentity';
+        const executionKeyType = 'ExecutionIdentity';
+        ts = ts.replace(/export interface RoleMap\s*{[^}]*}/g, `export type RoleMap = Record<${resourceRoleKeyType}, ResourceRoleValue>;`);
+        ts = ts.replace(/export interface RoleBindingMap\s*{[^}]*}/g, `export type RoleBindingMap = Record<${resourceRoleKeyType}, ${resourceKeyType}>;`);
+        ts = ts.replace(/export interface StrategyState\s*\{[^}]*\{[^}]*\}[^}]*\}/gs, `export type StrategyState = Record<${executionKeyType}, Record<${resourceRoleKeyType}, ResourcePotentialInput | ResourcePotentialOutput | Resource>>;`);
         parts.push(ts);
         let output = parts.join('\n');
         // Final guard: strip any lingering `[k: string]: unknown;` that might have been
@@ -399,7 +412,7 @@ async function main() {
         if (!/\bexport\b|\bdeclare\s+module\b|\bdeclare\s+namespace\b/.test(output)) {
             output += '\nexport {}\n';
         }
-        // Write only under src/_lib/types to avoid duplicate src/types folder
+        // Write only under configured types output folder
         try {
             fs.writeFileSync(srcLibOutputPath, output, 'utf8');
             console.log('Wrote', srcLibOutputPath);
@@ -408,7 +421,6 @@ async function main() {
             console.warn('Failed to write types to src/_lib:', e);
         }
         // Also write a copy into dist so consumers get the generated declarations
-        // Write only to dist/_lib/types to keep the same path structure under dist
         const distLibTypesDir = config.getTypesDistDir();
         const distLibOutputPath = config.getTypesDistPath('types.d.ts');
         try {
@@ -420,7 +432,7 @@ async function main() {
             // If copying to dist fails, log but don't crash the generator.
             console.warn('Failed to write types to dist:', e);
         }
-        // Ensure there is a runtime-resolvable module for './_lib/types/types.js'
+        // Ensure there is a runtime-resolvable module next to `types.d.ts`
         // Some consumers and TS NodeNext resolution expect a concrete .js next to .d.ts
         // The file is intentionally empty as all exports are types-only.
         try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toolproof-npm/schema",
-  "version": "0.1.44",
+  "version": "0.1.45",
   "description": "JSON schemas and TypeScript types for ToolProof",
   "keywords": [
     "toolproof",