@toolproof-npm/schema 0.1.77 → 0.1.79

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

@@ -448,9 +448,7 @@ export interface Named {
  * This interface was referenced by `GenesisJson`'s JSON-Schema
  * via the `definition` "ExecutionSocket".
  */
-export interface ExecutionSocket {
-  [k: string]: ResourceMissing | ResourcePotentialInput | ResourcePotentialOutput | Resource;
-}
+export type ExecutionSocket = Record<ResourceRoleIdentity, ResourceMissing | ResourcePotentialInput | ResourcePotentialOutput | Resource>;
 /**
  * This interface was referenced by `GenesisJson`'s JSON-Schema
  * via the `definition` "ResourceBase".
@@ -484,9 +482,7 @@ export interface Path {
  * This interface was referenced by `GenesisJson`'s JSON-Schema
  * via the `definition` "ExecutionSocketMaterialized".
  */
-export interface ExecutionSocketMaterialized {
-  [k: string]: Resource;
-}
+export type ExecutionSocketMaterialized = Record<ResourceRoleIdentity, Resource>;
 /**
  * This interface was referenced by `GenesisJson`'s JSON-Schema
  * via the `definition` "ExtractionSchemaWrapper".
@@ -591,9 +587,7 @@ export interface StrategyStateWrapper {
  * This interface was referenced by `GenesisJson`'s JSON-Schema
  * via the `definition` "StrategyState".
  */
-export interface StrategyState {
-  [k: string]: ExecutionSocket;
-}
+export type StrategyState = Record<ExecutionIdentity, ExecutionSocket>;
 /**
  * This interface was referenced by `GenesisJson`'s JSON-Schema
  * via the `definition` "StrategyRunContext".
@@ -610,9 +604,7 @@ export interface StrategyThreadMapWrapper {
  * This interface was referenced by `GenesisJson`'s JSON-Schema
  * via the `definition` "StrategyThreadMap".
  */
-export interface StrategyThreadMap {
-  [k: string]: Step[];
-}
+export type StrategyThreadMap = Record<StrategyThreadIdentity, Step[]>;
 export interface StrategyStateWrapper1 {
   strategyState: StrategyState;
 }
@@ -623,12 +615,8 @@ export interface StrategyStateWrapper1 {
 export interface StrategyRunUpdate {
   strategyRun?: StrategyRun1;
   strategyRunRef: StrategyRunIdentity;
-  strategyStateUpdate: {
-    [k: string]: ExecutionSocketMaterialized;
-  };
-  strategyStateUpdateWide?: {
-    [k: string]: ExecutionSocket;
-  };
+  strategyStateUpdate: Record<ExecutionIdentity, ExecutionSocketMaterialized>;
+  strategyStateUpdateWide?: Record<ExecutionIdentity, ExecutionSocket>;
 }
 /**
  * This interface was referenced by `GenesisJson`'s JSON-Schema
@@ -860,12 +848,8 @@ export interface Conditional {
 export interface StrategyStateWrapper {
   strategyState: StrategyState;
 }
-export interface StrategyState {
-  [k: string]: ExecutionSocket;
-}
-export interface ExecutionSocket {
-  [k: string]: ResourceMissing | ResourcePotentialInput | ResourcePotentialOutput | Resource;
-}
+export type StrategyState = Record<ExecutionIdentity, ExecutionSocket>;
+export type ExecutionSocket = Record<ResourceRoleIdentity, ResourceMissing | ResourcePotentialInput | ResourcePotentialOutput | Resource>;
 export interface ResourceBase {
   identity: ResourceIdentity;
   resourceTypeRef: ResourceTypeIdentity;
@@ -1163,9 +1147,7 @@ export interface Timestamp {
 export interface StrategyThreadMapWrapper {
   strategyThreadMap: StrategyThreadMap;
 }
-export interface StrategyThreadMap {
-  [k: string]: Step[];
-}
+export type StrategyThreadMap = Record<StrategyThreadIdentity, Step[]>;
 export interface RoleBindingsWrapper {
   roleBindings: RoleBindings;
 }
@@ -1184,12 +1166,8 @@ export interface Conditional {
 export interface StrategyStateWrapper {
   strategyState: StrategyState;
 }
-export interface StrategyState {
-  [k: string]: ExecutionSocket;
-}
-export interface ExecutionSocket {
-  [k: string]: ResourceMissing | ResourcePotentialInput | ResourcePotentialOutput | Resource;
-}
+export type StrategyState = Record<ExecutionIdentity, ExecutionSocket>;
+export type ExecutionSocket = Record<ResourceRoleIdentity, ResourceMissing | ResourcePotentialInput | ResourcePotentialOutput | Resource>;
 export interface ResourceBase {
   identity: ResourceIdentity;
   resourceTypeRef: ResourceTypeIdentity;

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { WorkStepIdentity, BranchStepIdentity, ForStepIdentity, WhileStepIdentity } from './scripts/brandFactories.js';
+import { WorkStepIdentity, BranchStepIdentity, WhileStepIdentity, ForStepIdentity } from './genesis/generated/types/types.js';
 export { default as SchemaGenesis } from './genesis/generated/schemas/Genesis.js';
 export { default as SchemaJob } from './genesis/generated/schemas/Job.js';
 export { default as ResourceTypeGenesis } from './genesis/generated/resource-type-envelopes/Genesis.js';
@@ -14,20 +14,3 @@ export type { Resource_StrategyRun as Resource_StrategyRunJson } from './genesis
 export type StepIdentityJson = WorkStepIdentity | BranchStepIdentity | WhileStepIdentity | ForStepIdentity;
 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, StepKind as StepKindJson, 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, StrategyRunIdentity as StrategyRunIdentityJson, StrategyRunStatus as StrategyRunStatusJson, StrategyRun as StrategyRunJson, StrategyRunUpdate as StrategyRunUpdateJson, JobIdentity as JobIdentityJson, Job as JobJson, JsonData as JsonDataJson, StrategyThreadIdentity as StrategyThreadIdentityJson, StrategyThreadMap as StrategyThreadMapJson, ExecutionSocket as ExecutionSocketJson, ExecutionSocketMaterialized as ExecutionSocketMaterializedJson, Timestamp as TimestampJson, } from './genesis/generated/types/types.js';
-export { unsafeBrand, asResourceTypeIdentity, asResourceRoleIdentity, asExecutionIdentity, asResourceIdentity, asWorkStepIdentity, asBranchStepIdentity, asForStepIdentity, asResourceFormatIdentity, asWhileStepIdentity, asStatelessStrategyIdentity, asStatefulStrategyIdentity, asJobIdentity, asStrategyRunIdentity, asStrategyThreadIdentity, asResourceTypeIdentities, asResourceRoleIdentities, asExecutionIdentities, asResourceIdentities, asWorkStepIdentities, asBranchStepIdentities, asForStepIdentities, asResourceFormatIdentities, asWhileStepIdentities, asStatelessStrategyIdentities, asStatefulStrategyIdentities, asJobIdentities, asStrategyRunIdentities, asStrategyThreadIdentities, } from './scripts/brandFactories.js';
-export declare const identityFactoriesByPrefix: {
-    readonly format: (s: string) => import("./scripts/brandFactories.js").ResourceFormatIdentity;
-    readonly type: (s: string) => import("./scripts/brandFactories.js").ResourceTypeIdentity;
-    readonly role: (s: string) => import("./scripts/brandFactories.js").ResourceRoleIdentity;
-    readonly job: (s: string) => import("./scripts/brandFactories.js").JobIdentity;
-    readonly execution: (s: string) => import("./scripts/brandFactories.js").ExecutionIdentity;
-    readonly resource: (s: string) => import("./scripts/brandFactories.js").ResourceIdentity;
-    readonly stateless_strategy: (s: string) => import("./scripts/brandFactories.js").StatelessStrategyIdentity;
-    readonly stateful_strategy: (s: string) => import("./scripts/brandFactories.js").StatefulStrategyIdentity;
-    readonly strategy_thread: (s: string) => import("./scripts/brandFactories.js").StrategyThreadIdentity;
-    readonly strategy_run: (s: string) => import("./scripts/brandFactories.js").StrategyRunIdentity;
-};
-export type IdentityPrefix = keyof typeof identityFactoriesByPrefix;
-export type IdentityByPrefix = {
-    [K in IdentityPrefix]: ReturnType<(typeof identityFactoriesByPrefix)[K]>;
-};

package/dist/index.js

@@ -1,23 +1,6 @@
-import { asExecutionIdentity, asJobIdentity, asResourceFormatIdentity, asResourceIdentity, asResourceRoleIdentity, asResourceTypeIdentity, asStatefulStrategyIdentity, asStatelessStrategyIdentity, asStrategyRunIdentity, asStrategyThreadIdentity, } from './scripts/brandFactories.js';
 // Re-export JSON schemas via .ts shims to avoid .json re-exports in declarations
 export { default as SchemaGenesis } from './genesis/generated/schemas/Genesis.js';
 export { default as SchemaJob } from './genesis/generated/schemas/Job.js';
 export { default as ResourceTypeGenesis } from './genesis/generated/resource-type-envelopes/Genesis.js';
 export { default as dependencies } from './genesis/generated/dependencies_ordered.json';
 export { default as terminals } from './genesis/generated/terminals.json';
-// 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, asJobIdentity, asStrategyRunIdentity, asStrategyThreadIdentity, asResourceTypeIdentities, asResourceRoleIdentities, asExecutionIdentities, asResourceIdentities, asWorkStepIdentities, asBranchStepIdentities, asForStepIdentities, asResourceFormatIdentities, asWhileStepIdentities, asStatelessStrategyIdentities, asStatefulStrategyIdentities, asJobIdentities, asStrategyRunIdentities, asStrategyThreadIdentities, } from './scripts/brandFactories.js';
-// Identity prefix -> factory mapping.
-// Consumers can derive types from this (and it centralizes future additions).
-export const identityFactoriesByPrefix = {
-    format: asResourceFormatIdentity,
-    type: asResourceTypeIdentity,
-    role: asResourceRoleIdentity,
-    job: asJobIdentity,
-    execution: asExecutionIdentity,
-    resource: asResourceIdentity,
-    stateless_strategy: asStatelessStrategyIdentity,
-    stateful_strategy: asStatefulStrategyIdentity,
-    strategy_thread: asStrategyThreadIdentity,
-    strategy_run: asStrategyRunIdentity,
-};

package/dist/scripts/generateResourceTypeType.js

@@ -45,7 +45,7 @@ async function main() {
     // IMPORTANT:
     // We intentionally do NOT re-run json-schema-to-typescript here.
     // That path produces self-contained types that degrade schema-patterned identities/refs
-    // into plain `string`, which then becomes incompatible with our canonical branded
+    // into plain `string`, which then becomes incompatible with our canonical
     // identity types in `types.d.ts` (e.g. `ResourceIdentity = `RESOURCE-${string}``).
     //
     // Instead, we generate a tiny module that composes the canonical types:

package/dist/scripts/generateTypes.js

@@ -459,11 +459,7 @@ async function main() {
         }
         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_]*(?:Identity|Ref))(\s*=\s*)Branded<string,\s*'[^']+'>\s*;$/gm, (_m, p1, typeName, p3) => {
-            const tmpl = patternTemplates[typeName];
-            return `${p1}${typeName}${p3}${tmpl ?? 'string'};`;
-        });
+        // Handle the common `= string;` output from json-schema-to-typescript.
         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'};`;
@@ -473,9 +469,20 @@ async function main() {
         const resourceRoleKeyType = 'ResourceRoleIdentity';
         const resourceKeyType = 'ResourceIdentity';
         const executionKeyType = 'ExecutionIdentity';
+        const strategyThreadKeyType = 'StrategyThreadIdentity';
         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}, ResourceMissing | ResourcePotentialInput | ResourcePotentialOutput | Resource>>;`);
+        // 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.
+        const executionSocketValueType = 'ResourceMissing | ResourcePotentialInput | ResourcePotentialOutput | Resource';
+        ts = ts.replace(/export interface ExecutionSocket\s*\{\s*\[k:\s*string\]:\s*[^;]+;\s*\}/g, `export type ExecutionSocket = Record<${resourceRoleKeyType}, ${executionSocketValueType}>;`);
+        ts = ts.replace(/export interface ExecutionSocketMaterialized\s*\{\s*\[k:\s*string\]:\s*Resource;\s*\}/g, `export type ExecutionSocketMaterialized = Record<${resourceRoleKeyType}, Resource>;`);
+        ts = ts.replace(/export interface StrategyState\s*\{\s*\[k:\s*string\]:\s*ExecutionSocket;\s*\}/g, `export type StrategyState = Record<${executionKeyType}, ExecutionSocket>;`);
+        ts = ts.replace(/(strategyStateUpdate:\s*)\{\s*\[k:\s*string\]:\s*ExecutionSocketMaterialized;\s*\};/g, `$1Record<${executionKeyType}, ExecutionSocketMaterialized>;`);
+        ts = ts.replace(/(strategyStateUpdateWide\??:\s*)\{\s*\[k:\s*string\]:\s*ExecutionSocket;\s*\};/g, `$1Record<${executionKeyType}, ExecutionSocket>;`);
+        // Ensure key constraints for strategyThreadMap are preserved as template-literal identity keys.
+        // json-schema-to-typescript emits `[k: string]: Step[];`, but we want keys to be `StrategyThreadIdentity`.
+        ts = ts.replace(/export interface StrategyThreadMap\s*\{\s*\[k:\s*string\]:\s*Step\[\];\s*\}/g, `export type StrategyThreadMap = Record<${strategyThreadKeyType}, Step[]>;`);
         parts.push(ts);
         let output = parts.join('\n');
         // Final guard: strip any lingering `[k: string]: unknown;` that might have been

package/package.json

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

package/dist/scripts/brandFactories.d.ts

@@ -1,48 +0,0 @@
-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'>;
-export type JobIdentity = Brand<'JobIdentity'>;
-export type StrategyRunIdentity = Brand<'StrategyRunIdentity'>;
-export type StrategyThreadIdentity = Brand<'StrategyThreadIdentity'>;
-/** Generic unsafe brand helper when a bespoke factory is not available. */
-export declare function unsafeBrand<T extends string>(s: string): T;
-export declare const asResourceTypeIdentity: (s: string) => ResourceTypeIdentity;
-export declare const asResourceRoleIdentity: (s: string) => ResourceRoleIdentity;
-export declare const asJobIdentity: (s: string) => JobIdentity;
-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 asStrategyRunIdentity: (s: string) => StrategyRunIdentity;
-export declare const asStrategyThreadIdentity: (s: string) => StrategyThreadIdentity;
-export declare const asResourceTypeIdentities: (xs: string[]) => ResourceTypeIdentity[];
-export declare const asResourceRoleIdentities: (xs: string[]) => ResourceRoleIdentity[];
-export declare const asJobIdentities: (xs: string[]) => JobIdentity[];
-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 declare const asStrategyRunIdentities: (xs: string[]) => StrategyRunIdentity[];
-export declare const asStrategyThreadIdentities: (xs: string[]) => StrategyThreadIdentity[];
-export {};

package/dist/scripts/brandFactories.js

@@ -1,54 +0,0 @@
-// 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 &&
-    (process.env.TP_BRAND_VALIDATE === "1" || process.env.NODE_ENV === "development")) ||
-    false;
-function makeFactory(name, pattern) {
-    return (s) => {
-        if (shouldValidate && pattern && !pattern.test(s)) {
-            throw new TypeError(`Invalid ${name}: "${s}" does not match ${String(pattern)}`);
-        }
-        return s;
-    };
-}
-/** Generic unsafe brand helper when a bespoke factory is not available. */
-export function unsafeBrand(s) {
-    return s;
-}
-// Known patterns from schemas (when available)
-const RE_TYPE_IDENTITY = /^TYPE-.+$/;
-const RE_JOB_IDENTITY = /^JOB-.+$/;
-const RE_ROLE_IDENTITY = /^ROLE-.+$/;
-const RE_STRATEGY_RUN_IDENTITY = /^STRATEGY_RUN-.+$/;
-const RE_STRATEGY_THREAD_IDENTITY = /^STRATEGY_THREAD-.+$/;
-// Factories for each Identity-like type
-export const asResourceTypeIdentity = makeFactory("ResourceTypeIdentity", RE_TYPE_IDENTITY);
-export const asResourceRoleIdentity = makeFactory("ResourceRoleIdentity", RE_ROLE_IDENTITY);
-export const asJobIdentity = makeFactory("JobIdentity", RE_JOB_IDENTITY);
-// IDs without strict regex patterns in the current schemas: keep unchecked casts.
-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");
-export const asStrategyRunIdentity = makeFactory("StrategyRunIdentity", RE_STRATEGY_RUN_IDENTITY);
-export const asStrategyThreadIdentity = makeFactory("StrategyThreadIdentity", RE_STRATEGY_THREAD_IDENTITY);
-// Batch helpers
-export const asResourceTypeIdentities = (xs) => xs.map(asResourceTypeIdentity);
-export const asResourceRoleIdentities = (xs) => xs.map(asResourceRoleIdentity);
-export const asJobIdentities = (xs) => xs.map(asJobIdentity);
-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);
-export const asStrategyRunIdentities = (xs) => xs.map(asStrategyRunIdentity);
-export const asStrategyThreadIdentities = (xs) => xs.map(asStrategyThreadIdentity);