@toolproof-core/genesis 1.0.48 → 1.0.50

package/src/implementations/tools.ts

@@ -0,0 +1,214 @@
+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'>;
+
+const OPERAND_TYPE_ROLE_NAMES = ['OperandType'] as const;
+
+function assertExactKeys(actualKeys: string[], expectedKeys: readonly string[], label: string): void {
+    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: number, label: string): Natural {
+    if (!Number.isInteger(value) || value < 0) {
+        throw new Error(`${label} must be a non-negative integer, got ${value}`);
+    }
+
+    return value as Natural;
+}
+
+export function createSpecializationKey(assignments: Record<string, ResourceType>): string {
+    return JSON.stringify(
+        Object.entries(assignments)
+            .sort(([leftRoleName], [rightRoleName]) => leftRoleName.localeCompare(rightRoleName))
+            .map(([roleName, resourceType]) => [roleName, resourceType.handle])
+    );
+}
+
+function resolveTemplateInstantiation<GenericRoleName extends string>(
+    inputs: TemplateInputs<GenericRoleName>,
+    expectedGenericRoleNames: readonly GenericRoleName[]
+): TemplateOutputs {
+    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: OperandTemplateInputs): TemplateOutputs {
+    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
+}
+
+export function Add(inputs: OperandTemplateInputs): TemplateOutputs {
+    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
+}
+
+export function Subtract(inputs: OperandTemplateInputs): TemplateOutputs {
+    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
+}
+
+export function Multiply(inputs: OperandTemplateInputs): TemplateOutputs {
+    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
+}
+
+export function Divide(inputs: OperandTemplateInputs): TemplateOutputs {
+    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
+}
+
+export function Double(inputs: OperandTemplateInputs): TemplateOutputs {
+    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
+}
+
+export function LessThan(inputs: OperandTemplateInputs): TemplateOutputs {
+    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
+}
+
+export function BooleanIdentity(inputs: { In: Boolean }): { Out: Boolean } {
+    return {
+        Out: inputs.In,
+    };
+}
+
+export function NaturalIdentity(inputs: { In: Natural }): { Out: Natural } {
+    return {
+        Out: inputs.In,
+    };
+}
+
+export function NaturalLessThan(inputs: {
+    LessThanSource: Natural;
+    LessThanTarget: Natural;
+}): { LessThanDecision: Boolean } {
+    return {
+        LessThanDecision: inputs.LessThanSource < inputs.LessThanTarget,
+    };
+}
+
+export function NaturalAdd(inputs: {
+    AddendOne: Natural;
+    AddendTwo: Natural;
+}): { Sum: Natural } {
+    return {
+        Sum: asNatural(inputs.AddendOne + inputs.AddendTwo, 'Sum'),
+    };
+}
+
+export function NaturalSubtract(inputs: {
+    Minuend: Natural;
+    Subtrahend: Natural;
+}): { Difference: Natural } {
+    return {
+        Difference: asNatural(inputs.Minuend - inputs.Subtrahend, 'Difference'),
+    };
+}
+
+export function NaturalMultiply(inputs: {
+    Multiplicand: Natural;
+    Multiplier: Natural;
+}): { Product: Natural } {
+    return {
+        Product: asNatural(inputs.Multiplicand * inputs.Multiplier, 'Product'),
+    };
+}
+
+export function NaturalDivide(inputs: {
+    Dividend: Natural;
+    Divisor: Natural;
+}): { Quotient: Natural; Remainder: Natural } {
+    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: { N: Natural }): { Doubled: Natural } {
+    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,
+} as const;
+
+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,
+} as const;

package/src/index.ts

@@ -1,27 +1,131 @@
-// Re-export JSON schemas via .ts shims to avoid .json re-exports in declarations
-export { default as Schemas } from '../generated-src/schemas/schemas.js';
-
-export { default as ResourceTypeSchema } from '../generated-src/schemas/standalone/ResourceType.js';
-export { default as ToolSchema } from '../generated-src/schemas/standalone/Tool.js';
-export { default as StrategySchema } from '../generated-src/schemas/standalone/Strategy.js';
-export { default as StrategyTraceSchema } from '../generated-src/schemas/standalone/StrategyTrace.js';
-
-// Re-export generated Zod validators
-export { ToolSchema as ZodToolSchema } from '../generated-src/schemas/zod/Tool.js';
-export { ResourceTypeSchema as ZodResourceTypeSchema } from '../generated-src/schemas/zod/ResourceType.js';
-export { StrategySchema as ZodStrategySchema } from '../generated-src/schemas/zod/Strategy.js';
-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';
+// Re-export JSON schemas via .ts shims to avoid .json re-exports in declarations
+export { default as Schemas } from '../generated-src/schemas/schemas.js';
+
+export { default as ResourceTypeSchema } from '../generated-src/schemas/standalone/ResourceType.js';
+export { default as ToolSchema } from '../generated-src/schemas/standalone/Tool.js';
+export { default as StrategySchema } from '../generated-src/schemas/standalone/Strategy.js';
+export { default as StrategyTraceSchema } from '../generated-src/schemas/standalone/StrategyTrace.js';
+
+// Re-export generated Zod validators
+export { ToolSchema as ZodToolSchema } from '../generated-src/schemas/zod/Tool.js';
+export { ResourceTypeSchema as ZodResourceTypeSchema } from '../generated-src/schemas/zod/ResourceType.js';
+export { StrategySchema as ZodStrategySchema } from '../generated-src/schemas/zod/Strategy.js';
+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 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';