@toolproof-core/genesis 1.0.48 → 1.0.50

package/dist/src/implementations/tools.d.ts

@@ -0,0 +1,100 @@
+import type { Boolean, Natural, ResourceType, Tool } from '../../generated-src/types/types.js';
+type GenericAssignmentByRoleName<GenericRoleName extends string> = Record<GenericRoleName, ResourceType>;
+type InstantiationToolHandleBySpecializationKey = Record<string, Tool>;
+type TemplateInputs<GenericRoleName extends string> = {
+    GenericAssignmentByRoleName: GenericAssignmentByRoleName<GenericRoleName>;
+    InstantiationToolHandleBySpecializationKey: InstantiationToolHandleBySpecializationKey;
+};
+type TemplateOutputs = {
+    InstantiationTool: Tool;
+};
+type OperandTemplateInputs = TemplateInputs<'OperandType'>;
+export declare function createSpecializationKey(assignments: Record<string, ResourceType>): string;
+export declare function Identity(inputs: OperandTemplateInputs): TemplateOutputs;
+export declare function Add(inputs: OperandTemplateInputs): TemplateOutputs;
+export declare function Subtract(inputs: OperandTemplateInputs): TemplateOutputs;
+export declare function Multiply(inputs: OperandTemplateInputs): TemplateOutputs;
+export declare function Divide(inputs: OperandTemplateInputs): TemplateOutputs;
+export declare function Double(inputs: OperandTemplateInputs): TemplateOutputs;
+export declare function LessThan(inputs: OperandTemplateInputs): TemplateOutputs;
+export declare function BooleanIdentity(inputs: {
+    In: Boolean;
+}): {
+    Out: Boolean;
+};
+export declare function NaturalIdentity(inputs: {
+    In: Natural;
+}): {
+    Out: Natural;
+};
+export declare function NaturalLessThan(inputs: {
+    LessThanSource: Natural;
+    LessThanTarget: Natural;
+}): {
+    LessThanDecision: Boolean;
+};
+export declare function NaturalAdd(inputs: {
+    AddendOne: Natural;
+    AddendTwo: Natural;
+}): {
+    Sum: Natural;
+};
+export declare function NaturalSubtract(inputs: {
+    Minuend: Natural;
+    Subtrahend: Natural;
+}): {
+    Difference: Natural;
+};
+export declare function NaturalMultiply(inputs: {
+    Multiplicand: Natural;
+    Multiplier: Natural;
+}): {
+    Product: Natural;
+};
+export declare function NaturalDivide(inputs: {
+    Dividend: Natural;
+    Divisor: Natural;
+}): {
+    Quotient: Natural;
+    Remainder: Natural;
+};
+export declare function NaturalDouble(inputs: {
+    N: Natural;
+}): {
+    Doubled: Natural;
+};
+export declare const TOOL_IMPLEMENTATION_BY_NAME: {
+    readonly Identity: typeof Identity;
+    readonly Add: typeof Add;
+    readonly Subtract: typeof Subtract;
+    readonly Multiply: typeof Multiply;
+    readonly Divide: typeof Divide;
+    readonly Double: typeof Double;
+    readonly LessThan: typeof LessThan;
+    readonly BooleanIdentity: typeof BooleanIdentity;
+    readonly NaturalIdentity: typeof NaturalIdentity;
+    readonly NaturalLessThan: typeof NaturalLessThan;
+    readonly NaturalAdd: typeof NaturalAdd;
+    readonly NaturalSubtract: typeof NaturalSubtract;
+    readonly NaturalMultiply: typeof NaturalMultiply;
+    readonly NaturalDivide: typeof NaturalDivide;
+    readonly NaturalDouble: typeof NaturalDouble;
+};
+export declare const TOOL_IMPLEMENTATION_BY_HANDLE: {
+    readonly 'TOOL-Identity': typeof Identity;
+    readonly 'TOOL-Add': typeof Add;
+    readonly 'TOOL-Subtract': typeof Subtract;
+    readonly 'TOOL-Multiply': typeof Multiply;
+    readonly 'TOOL-Divide': typeof Divide;
+    readonly 'TOOL-Double': typeof Double;
+    readonly 'TOOL-LessThan': typeof LessThan;
+    readonly 'TOOL-BooleanIdentity': typeof BooleanIdentity;
+    readonly 'TOOL-NaturalIdentity': typeof NaturalIdentity;
+    readonly 'TOOL-NaturalLessThan': typeof NaturalLessThan;
+    readonly 'TOOL-NaturalAdd': typeof NaturalAdd;
+    readonly 'TOOL-NaturalSubtract': typeof NaturalSubtract;
+    readonly 'TOOL-NaturalMultiply': typeof NaturalMultiply;
+    readonly 'TOOL-NaturalDivide': typeof NaturalDivide;
+    readonly 'TOOL-NaturalDouble': typeof NaturalDouble;
+};
+export {};

package/dist/src/implementations/tools.js

@@ -0,0 +1,135 @@
+const OPERAND_TYPE_ROLE_NAMES = ['OperandType'];
+function assertExactKeys(actualKeys, expectedKeys, label) {
+    const sortedActualKeys = [...actualKeys].sort();
+    const sortedExpectedKeys = [...expectedKeys].sort();
+    if (sortedActualKeys.length !== sortedExpectedKeys.length) {
+        throw new Error(`${label} must contain exactly [${sortedExpectedKeys.join(', ')}], got [${sortedActualKeys.join(', ')}]`);
+    }
+    for (let index = 0; index < sortedExpectedKeys.length; index += 1) {
+        if (sortedActualKeys[index] !== sortedExpectedKeys[index]) {
+            throw new Error(`${label} must contain exactly [${sortedExpectedKeys.join(', ')}], got [${sortedActualKeys.join(', ')}]`);
+        }
+    }
+}
+function asNatural(value, label) {
+    if (!Number.isInteger(value) || value < 0) {
+        throw new Error(`${label} must be a non-negative integer, got ${value}`);
+    }
+    return value;
+}
+export function createSpecializationKey(assignments) {
+    return JSON.stringify(Object.entries(assignments)
+        .sort(([leftRoleName], [rightRoleName]) => leftRoleName.localeCompare(rightRoleName))
+        .map(([roleName, resourceType]) => [roleName, resourceType.handle]));
+}
+function resolveTemplateInstantiation(inputs, expectedGenericRoleNames) {
+    const { GenericAssignmentByRoleName, InstantiationToolHandleBySpecializationKey } = inputs;
+    assertExactKeys(Object.keys(GenericAssignmentByRoleName), expectedGenericRoleNames, 'GenericAssignmentByRoleName');
+    const specializationKey = createSpecializationKey(GenericAssignmentByRoleName);
+    const instantiationTool = InstantiationToolHandleBySpecializationKey[specializationKey];
+    if (!instantiationTool) {
+        throw new Error(`No instantiation tool registered for specializationKey ${specializationKey}`);
+    }
+    return {
+        InstantiationTool: instantiationTool,
+    };
+}
+export function Identity(inputs) {
+    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
+}
+export function Add(inputs) {
+    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
+}
+export function Subtract(inputs) {
+    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
+}
+export function Multiply(inputs) {
+    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
+}
+export function Divide(inputs) {
+    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
+}
+export function Double(inputs) {
+    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
+}
+export function LessThan(inputs) {
+    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
+}
+export function BooleanIdentity(inputs) {
+    return {
+        Out: inputs.In,
+    };
+}
+export function NaturalIdentity(inputs) {
+    return {
+        Out: inputs.In,
+    };
+}
+export function NaturalLessThan(inputs) {
+    return {
+        LessThanDecision: inputs.LessThanSource < inputs.LessThanTarget,
+    };
+}
+export function NaturalAdd(inputs) {
+    return {
+        Sum: asNatural(inputs.AddendOne + inputs.AddendTwo, 'Sum'),
+    };
+}
+export function NaturalSubtract(inputs) {
+    return {
+        Difference: asNatural(inputs.Minuend - inputs.Subtrahend, 'Difference'),
+    };
+}
+export function NaturalMultiply(inputs) {
+    return {
+        Product: asNatural(inputs.Multiplicand * inputs.Multiplier, 'Product'),
+    };
+}
+export function NaturalDivide(inputs) {
+    if (inputs.Divisor === 0) {
+        throw new Error('Divisor must be non-zero');
+    }
+    return {
+        Quotient: asNatural(Math.floor(inputs.Dividend / inputs.Divisor), 'Quotient'),
+        Remainder: asNatural(inputs.Dividend % inputs.Divisor, 'Remainder'),
+    };
+}
+export function NaturalDouble(inputs) {
+    return {
+        Doubled: asNatural(inputs.N * 2, 'Doubled'),
+    };
+}
+export const TOOL_IMPLEMENTATION_BY_NAME = {
+    Identity,
+    Add,
+    Subtract,
+    Multiply,
+    Divide,
+    Double,
+    LessThan,
+    BooleanIdentity,
+    NaturalIdentity,
+    NaturalLessThan,
+    NaturalAdd,
+    NaturalSubtract,
+    NaturalMultiply,
+    NaturalDivide,
+    NaturalDouble,
+};
+export const TOOL_IMPLEMENTATION_BY_HANDLE = {
+    'TOOL-Identity': Identity,
+    'TOOL-Add': Add,
+    'TOOL-Subtract': Subtract,
+    'TOOL-Multiply': Multiply,
+    'TOOL-Divide': Divide,
+    'TOOL-Double': Double,
+    'TOOL-LessThan': LessThan,
+    'TOOL-BooleanIdentity': BooleanIdentity,
+    'TOOL-NaturalIdentity': NaturalIdentity,
+    'TOOL-NaturalLessThan': NaturalLessThan,
+    'TOOL-NaturalAdd': NaturalAdd,
+    'TOOL-NaturalSubtract': NaturalSubtract,
+    'TOOL-NaturalMultiply': NaturalMultiply,
+    'TOOL-NaturalDivide': NaturalDivide,
+    'TOOL-NaturalDouble': NaturalDouble,
+};

package/dist/src/index.d.ts

@@ -9,11 +9,12 @@ export { StrategySchema as ZodStrategySchema } from '../generated-src/schemas/zo
 export { StrategyTraceSchema as ZodStrategyTraceSchema } from '../generated-src/schemas/zod/StrategyTrace.js';
 export { GoalSchema as ZodGoalSchema } from '../generated-src/schemas/zod/Goal.js';
 export * as ZodSchemas from '../generated-src/schemas/zod/index.js';
-export { default as ResourceTypes } from '../generated-src/resources/resourceTypes.js';
-export { default as CONSTANTS } from '../generated-src/derived/constants.js';
-export { default as MAPPINGS } from '../generated-src/derived/mappings.js';
-export type * from '../generated-src/types/types.js';
-export type * from '../generated-src/types/standalone/ResourceTypeResource.js';
-export type * from '../generated-src/types/standalone/ToolResource.js';
-export type * from '../generated-src/types/standalone/StrategyResource.js';
-export type * from '../generated-src/types/standalone/StrategyTraceResource.js';
+export { default as ResourceTypeTimestampedResources } from '../generated-src/timestampedResources/resourceTypes.js';
+export { Add, BooleanIdentity, createSpecializationKey, Divide, Double, Identity, LessThan, Multiply, NaturalAdd, NaturalDivide, NaturalDouble, NaturalIdentity, NaturalLessThan, NaturalMultiply, NaturalSubtract, Subtract, TOOL_IMPLEMENTATION_BY_HANDLE, TOOL_IMPLEMENTATION_BY_NAME, } from '../generated-src/implementations/tools.js';
+export { default as CONSTANTS } from '../generated-src/lookups/constants.js';
+export { default as MAPPINGS } from '../generated-src/lookups/mappings.js';
+export type { ResourceTypeResource, } from '../generated-src/types/standalone/ResourceTypeResource.js';
+export type { ToolResource, } from '../generated-src/types/standalone/ToolResource.js';
+export type { StrategyResource, } from '../generated-src/types/standalone/StrategyResource.js';
+export type { StrategyTraceResource, } from '../generated-src/types/standalone/StrategyTraceResource.js';
+export type { BaseResource, BaseStrategy, BaseToolStepPathSpec, Boolean, BranchStep, Case, ContainerKind, DeferredStrategyProvenance, Description, DescriptionFacet, DocumentationSpec, ExternalInputPotential, GenesisProvenance, Goal, InputPotential, InputResource, InternalInputPotential, JsonSchemaObject, JsonSchemaObject1, JsonSchemaObject2, Name, NameFacet, Natural, OutputAddress, Provenance, ProvenanceFacet, ProvenanceKind, Resource, ResourceId, ResourcePointer, ResourceType, ResourceTypeHandle, RoleBindingSpec, RoleBindingSpecFacet, RoleBindingSpecFacet1, RoleName, RoleNameArray, RoleSpec, RoleSpecFacet, RoleValue, RoleValueByName, Step, StepArray, StepArrayArray, StepKind, StepKindFacet, Strategy, StrategyHandle, StrategyKind, StrategyProvenance, StrategyStateInputEntry, StrategyStateInputEntryByRoleName, StrategyStateInputKind, StrategyTrace, StrategyTraceHandle, ThreadedStrategy, ThreadedStrategyState, ThreadedStrategyStateFacet, ThreadedToolStepPath, ThreadedToolStepPathSpec, Tool, ToolHandle, ToolStep, ToolStepPath, ToolStepPathSlot, ToolStepPathSlotFacet, TypeRef, UnthreadedStrategy, UnthreadedStrategyState, UnthreadedStrategyStateFacet, UnthreadedToolStepPath, UnthreadedToolStepPathSpec, WhileStep, ForStep, } from '../generated-src/types/types.js';

package/dist/src/index.js

@@ -11,6 +11,7 @@ export { StrategySchema as ZodStrategySchema } from '../generated-src/schemas/zo
 export { StrategyTraceSchema as ZodStrategyTraceSchema } from '../generated-src/schemas/zod/StrategyTrace.js';
 export { GoalSchema as ZodGoalSchema } from '../generated-src/schemas/zod/Goal.js';
 export * as ZodSchemas from '../generated-src/schemas/zod/index.js';
-export { default as ResourceTypes } from '../generated-src/resources/resourceTypes.js';
-export { default as CONSTANTS } from '../generated-src/derived/constants.js';
-export { default as MAPPINGS } from '../generated-src/derived/mappings.js';
+export { default as ResourceTypeTimestampedResources } from '../generated-src/timestampedResources/resourceTypes.js';
+export { Add, BooleanIdentity, createSpecializationKey, Divide, Double, Identity, LessThan, Multiply, NaturalAdd, NaturalDivide, NaturalDouble, NaturalIdentity, NaturalLessThan, NaturalMultiply, NaturalSubtract, Subtract, TOOL_IMPLEMENTATION_BY_HANDLE, TOOL_IMPLEMENTATION_BY_NAME, } from '../generated-src/implementations/tools.js';
+export { default as CONSTANTS } from '../generated-src/lookups/constants.js';
+export { default as MAPPINGS } from '../generated-src/lookups/mappings.js';

package/dist/src/utils/resourceTypes.d.ts

@@ -6,7 +6,8 @@ type ResourceTypeShell = JsonObject & {
     handle?: unknown;
     name?: unknown;
     description?: unknown;
+    ingestorToolInputSchema?: unknown;
 };
 type ResourceTypeShellByName = Record<string, ResourceTypeShell>;
-export declare function generateResourceTypes(schemasDocument: SchemasDocument, resourceTypeShells: ResourceTypeShellByName): ResourceTypeShellByName;
+export declare function generateResourceTypes(schemasDocument: SchemasDocument, resourceTypeShells: ResourceTypeShellByName): ResourceTypeShell[];
 export {};

package/dist/src/utils/resourceTypes.js

@@ -2,16 +2,32 @@ export function generateResourceTypes(schemasDocument, resourceTypeShells) {
     if (!schemasDocument.$defs || typeof schemasDocument.$defs !== 'object') {
         throw new Error('Schema document must have root $defs');
     }
-    const resourceTypes = {};
+    const resourceTypes = [];
     for (const [resourceTypeName, resourceTypeShell] of Object.entries(resourceTypeShells)) {
-        const valueSchema = schemasDocument.$defs[resourceTypeName];
-        if (!valueSchema || typeof valueSchema !== 'object' || Array.isArray(valueSchema)) {
+        const projectionSchema = schemasDocument.$defs[resourceTypeName];
+        const ingestorToolInputSchemaDefName = resourceTypeShell.ingestorToolInputSchema;
+        if (!projectionSchema || typeof projectionSchema !== 'object' || Array.isArray(projectionSchema)) {
             throw new Error(`Missing matching schema for resource type record ${resourceTypeName}`);
         }
-        resourceTypes[resourceTypeName] = {
+        if (ingestorToolInputSchemaDefName !== undefined &&
+            typeof ingestorToolInputSchemaDefName !== 'string') {
+            throw new Error(`ingestorToolInputSchema for resource type record ${resourceTypeName} must be a schema definition name when present`);
+        }
+        const ingestorToolInputSchema = typeof ingestorToolInputSchemaDefName === 'string'
+            ? schemasDocument.$defs[ingestorToolInputSchemaDefName]
+            : undefined;
+        if (typeof ingestorToolInputSchemaDefName === 'string' && !ingestorToolInputSchema) {
+            throw new Error(`Missing ingestor input schema ${ingestorToolInputSchemaDefName} for resource type record ${resourceTypeName}`);
+        }
+        if (ingestorToolInputSchema !== undefined &&
+            (typeof ingestorToolInputSchema !== 'object' || Array.isArray(ingestorToolInputSchema))) {
+            throw new Error(`Ingestor input schema ${ingestorToolInputSchemaDefName} for resource type record ${resourceTypeName} must be an object`);
+        }
+        resourceTypes.push({
             ...resourceTypeShell,
-            valueSchema,
-        };
+            projectionSchema,
+            ...(ingestorToolInputSchema ? { ingestorToolInputSchema } : {}),
+        });
     }
     return resourceTypes;
 }

package/dist/src/utils/schemaRefNormalization.js

@@ -37,9 +37,9 @@ export function normalizeAnchorsToPointers(input) {
         if (!defValue || typeof defValue !== 'object')
             continue;
         const envelope = defValue;
-        const valueSchema = envelope.valueSchema;
-        if (valueSchema && typeof valueSchema === 'object') {
-            const anchor = valueSchema.$anchor;
+        const projectionSchema = envelope.projectionSchema;
+        if (projectionSchema && typeof projectionSchema === 'object') {
+            const anchor = projectionSchema.$anchor;
             if (typeof anchor === 'string' && !anchorToDef[anchor]) {
                 anchorToDef[anchor] = defName;
             }

package/dist/src/utils/standaloneTypes.js

@@ -1,8 +1,8 @@
 export function generateStandaloneTypeContent(name) {
     const header = '// Auto-generated strict composite type. Do not edit.\n';
     const standaloneResourceTypeName = `${name}Resource`;
-    const ts = `import type { ResourcePointer, ${name} as ValueSchema } from "../types.js";\n` +
-        `export type ${standaloneResourceTypeName} = ResourcePointer & { value: ValueSchema };\n`;
+    const ts = `import type { ResourcePointer, ${name} as ProjectionSchema } from "../types.js";\n` +
+        `export type ${standaloneResourceTypeName} = ResourcePointer & { projection: ProjectionSchema };\n`;
     return header + ts;
 }
 export function validateStandaloneSchemaForWarnings(schema) {

package/dist/src/utils/timestampedResources.d.ts

@@ -0,0 +1,16 @@
+type JsonObject = Record<string, unknown>;
+type TimestampedResource = JsonObject & {
+    id: string;
+    resourceTypeHandle: string;
+    provenance: {
+        resourceProvenanceKind: 'genesis';
+    };
+    timestamp: string;
+    projection: unknown;
+};
+type GenerateTimestampedResourcesOptions = {
+    resourceTypeHandle: string;
+    getResourceId: (projection: unknown) => string;
+};
+export declare function generateTimestampedResources(declarations: unknown[], options: GenerateTimestampedResourcesOptions): TimestampedResource[];
+export {};

package/dist/src/utils/timestampedResources.js

@@ -0,0 +1,17 @@
+const GENESIS_TIMESTAMP = '2025-11-30T00:00:00.000Z';
+export function generateTimestampedResources(declarations, options) {
+    return declarations.map((projection) => {
+        return createTimestampedResource(projection, options);
+    });
+}
+function createTimestampedResource(projection, options) {
+    return {
+        id: options.getResourceId(projection),
+        resourceTypeHandle: options.resourceTypeHandle,
+        provenance: {
+            resourceProvenanceKind: 'genesis',
+        },
+        timestamp: GENESIS_TIMESTAMP,
+        projection,
+    };
+}

package/dist/src/utils/typeGenerationPostProcess.js

@@ -53,9 +53,9 @@ function escapeRegExpLiteral(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 function deriveStrategyStateInputEntryByRoleNameValueType(parsedSchema) {
-    const defs = parsedSchema?.$defs ?? parsedSchema?.valueSchema?.$defs;
+    const defs = parsedSchema?.$defs ?? parsedSchema?.projectionSchema?.$defs;
     const def = defs?.StrategyStateInputEntryByRoleName;
-    const schemaNode = def?.valueSchema ?? def;
+    const schemaNode = def?.projectionSchema ?? def;
     const additionalProperties = schemaNode?.additionalProperties;
     if (!additionalProperties || typeof additionalProperties !== 'object' || Array.isArray(additionalProperties)) {
         return 'StrategyStateInputEntry';

package/dist/src/utils/zodCodegen.js

@@ -66,8 +66,8 @@ function isRecordLikeObjectSchema(node) {
     return !hasFixedProps && hasPropertyNames && hasAdditionalSchema;
 }
 function emitRecordLikeObjectSchema(node, ctx, path) {
-    const valueSchemaNode = node.additionalProperties;
-    const valueExpr = emitSchema(valueSchemaNode, ctx, pathJoin(path, 'additionalProperties'));
+    const projectionSchemaNode = node.additionalProperties;
+    const valueExpr = emitSchema(projectionSchemaNode, ctx, pathJoin(path, 'additionalProperties'));
     const pn = node.propertyNames;
     let keyPattern;
     if (isObject(pn)) {
@@ -481,7 +481,7 @@ function buildAnchorMap(defs) {
         const top = defSchema.$anchor;
         if (typeof top === 'string' && top)
             map[top] = defName;
-        const nested = defSchema.valueSchema;
+        const nested = defSchema.projectionSchema;
         if (isObject(nested) && typeof nested.$anchor === 'string' && nested.$anchor) {
             map[nested.$anchor] = defName;
         }

package/generated-src/declarations/booleans.json

@@ -0,0 +1,4 @@
+[
+    false,
+    true
+]

package/generated-src/declarations/booleans.ts

@@ -0,0 +1,2 @@
+import declarations from './booleans.json' with { type: 'json' };
+export default declarations;

package/generated-src/declarations/naturals.json

@@ -0,0 +1,13 @@
+[
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9,
+    100
+]

package/generated-src/declarations/naturals.ts

@@ -0,0 +1,2 @@
+import declarations from './naturals.json' with { type: 'json' };
+export default declarations;