@toolproof-core/genesis 1.0.49 → 1.0.51

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

@@ -14,10 +14,31 @@ export { StrategyTraceSchema as ZodStrategyTraceSchema } from '../generated-src/
 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 ResourceTypeTimestampedResources } from '../generated-src/timestampedResources/resourceTypes.js';
 
-export { default as CONSTANTS } from '../generated-src/derived/constants.js';
-export { default as MAPPINGS } from '../generated-src/derived/mappings.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,
@@ -36,6 +57,7 @@ export type {
     BaseResource,
     BaseStrategy,
     BaseToolStepPathSpec,
+    Boolean,
     BranchStep,
     Case,
     ContainerKind,
@@ -94,7 +116,6 @@ export type {
     ThreadedToolStepPathSpec,
     Tool,
     ToolHandle,
-    ToolKind,
     ToolStep,
     ToolStepPath,
     ToolStepPathSlot,

package/src/utils/resourceTypes.ts

@@ -8,6 +8,7 @@ type ResourceTypeShell = JsonObject & {
     handle?: unknown;
     name?: unknown;
     description?: unknown;
+    ingestorToolInputSchema?: unknown;
 };
 
 type ResourceTypeShellByName = Record<string, ResourceTypeShell>;
@@ -15,24 +16,55 @@ type ResourceTypeShellByName = Record<string, ResourceTypeShell>;
 export function generateResourceTypes(
     schemasDocument: SchemasDocument,
     resourceTypeShells: ResourceTypeShellByName,
-): ResourceTypeShellByName {
+): ResourceTypeShell[] {
     if (!schemasDocument.$defs || typeof schemasDocument.$defs !== 'object') {
         throw new Error('Schema document must have root $defs');
     }
 
-    const resourceTypes: ResourceTypeShellByName = {};
+    const resourceTypes: ResourceTypeShell[] = [];
 
     for (const [resourceTypeName, resourceTypeShell] of Object.entries(resourceTypeShells)) {
-        const valueSchema = schemasDocument.$defs[resourceTypeName];
+        const projectionSchema = schemasDocument.$defs[resourceTypeName];
+        const ingestorToolInputSchemaDefName = resourceTypeShell.ingestorToolInputSchema;
 
-        if (!valueSchema || typeof valueSchema !== 'object' || Array.isArray(valueSchema)) {
+        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/src/utils/schemaRefNormalization.ts

@@ -42,10 +42,10 @@ export function normalizeAnchorsToPointers<T>(input: T): T {
 
         if (!defValue || typeof defValue !== 'object') continue;
 
-        const envelope = defValue as { valueSchema?: { $anchor?: unknown }; $anchor?: unknown };
-        const valueSchema = envelope.valueSchema;
-        if (valueSchema && typeof valueSchema === 'object') {
-            const anchor = valueSchema.$anchor;
+        const envelope = defValue as { projectionSchema?: { $anchor?: unknown }; $anchor?: unknown };
+        const projectionSchema = envelope.projectionSchema;
+        if (projectionSchema && typeof projectionSchema === 'object') {
+            const anchor = projectionSchema.$anchor;
             if (typeof anchor === 'string' && !anchorToDef[anchor]) {
                 anchorToDef[anchor] = defName;
             }

package/src/utils/standaloneTypes.ts

@@ -3,8 +3,8 @@ export function generateStandaloneTypeContent(name: string): string {
     const standaloneResourceTypeName = `${name}Resource`;
 
     const ts =
-        `import type { ResourcePointer, ${name} as ValueSchema } from "../types.js";\n` +
-        `export type ${standaloneResourceTypeName} = ResourcePointer & { value: ValueSchema };\n`;
+        `import type { ResourcePointer, ${name} as ProjectionSchema } from "../types.js";\n` +
+        `export type ${standaloneResourceTypeName} = ResourcePointer & { projection: ProjectionSchema };\n`;
     return header + ts;
 }
 

package/src/utils/timestampedResources.ts

@@ -0,0 +1,42 @@
+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;
+};
+
+const GENESIS_TIMESTAMP = '2025-11-30T00:00:00.000Z';
+
+export function generateTimestampedResources(
+    declarations: unknown[],
+    options: GenerateTimestampedResourcesOptions,
+): TimestampedResource[] {
+    return declarations.map((projection) => {
+        return createTimestampedResource(projection, options);
+    });
+}
+
+function createTimestampedResource(
+    projection: unknown,
+    options: GenerateTimestampedResourcesOptions,
+): TimestampedResource {
+    return {
+        id: options.getResourceId(projection),
+        resourceTypeHandle: options.resourceTypeHandle,
+        provenance: {
+            resourceProvenanceKind: 'genesis',
+        },
+        timestamp: GENESIS_TIMESTAMP,
+        projection,
+    };
+}

package/src/utils/typeGenerationPostProcess.ts

@@ -53,9 +53,9 @@ function escapeRegExpLiteral(value: string): string {
 }
 
 function deriveStrategyStateInputEntryByRoleNameValueType(parsedSchema: any): string {
-    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)) {

package/src/utils/zodCodegen.ts

@@ -88,8 +88,8 @@ function isRecordLikeObjectSchema(node: any): boolean {
 }
 
 function emitRecordLikeObjectSchema(node: any, ctx: Ctx, path: string): string {
-  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: string | undefined;
@@ -504,7 +504,7 @@ function buildAnchorMap(defs: Record<string, any>): Record<string, string> {
     const top = defSchema.$anchor;
     if (typeof top === 'string' && top) map[top] = defName;
 
-    const nested = (defSchema as any).valueSchema;
+    const nested = (defSchema as any).projectionSchema;
     if (isObject(nested) && typeof nested.$anchor === 'string' && nested.$anchor) {
       map[nested.$anchor] = defName;
     }

package/toolproof.json

@@ -0,0 +1,19 @@
+{
+  "name": {
+    "kind": "json-pointer",
+    "filePath": "package.json",
+    "pointer": "/name"
+  },
+  "version": {
+    "kind": "json-pointer",
+    "filePath": "package.json",
+    "pointer": "/version"
+  },
+  "description": {
+    "kind": "json-pointer",
+    "filePath": "package.json",
+    "pointer": "/description"
+  },
+  "resourceTypesPath": "generated-src/declarations/resourceTypes.json",
+  "toolsPath": "generated-src/declarations/tools.json"
+}

package/dist/src/genesis/resources/implementations/foo.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/genesis/resources/implementations/foo.js

@@ -1,184 +0,0 @@
-export {};
-/* import type { Resource } from '@toolproof-core/genesis';
-import { createMaterializedFromPotential } from '@toolproof-core/lib/create-resource';
-
-function extractNaturalValue(resource: Resource): number {
-    const value: unknown = resource.value;
-    if (typeof value === 'number' && Number.isInteger(value) && value >= 0) {
-        return value;
-    }
-    throw new Error(`Invalid Natural resource: value must be a non-negative integer`);
-}
-
-function createMockOutput(potentialOutput: any, value: number): Resource {
-    const mockPath = `mock://natural/${value}`;
-
-    const materialized = createMaterializedFromPotential(potentialOutput, value);
-
-    return {
-        ...materialized,
-        path: mockPath,
-    };
-}
-
-function createMockErrorOutput(
-    potentialOutput: any,
-    name: string,
-    description: string,
-    details?: Record<string, unknown>
-): Resource {
-    const value: unknown = {
-        name,
-        description,
-        ...(details ? { details } : {}),
-    };
-
-    const mockPath = `mock://error/${encodeURIComponent(name)}`;
-
-    const materialized = createMaterializedFromPotential(potentialOutput, value);
-
-    return {
-        ...materialized,
-        path: mockPath,
-    };
-}
-
-export function mockAdd(inputs: Record<string, Resource | any>): Record<string, Resource> {
-    const addendOne = inputs['AddendOne'] as Resource;
-    const addendTwo = inputs['AddendTwo'] as Resource;
-    const sumOutput = inputs['Sum'] as any;
-
-    const value1 = extractNaturalValue(addendOne);
-    const value2 = extractNaturalValue(addendTwo);
-    const result = value1 + value2;
-
-    return {
-        Sum: createMockOutput(sumOutput, result),
-    };
-}
-
-export function mockSubtract(inputs: Record<string, Resource | any>): Record<string, Resource> {
-    const minuend = inputs['Minuend'] as Resource;
-    const subtrahend = inputs['Subtrahend'] as Resource;
-    const differenceOutput = inputs['Difference'] as any;
-
-    const errorOutput = inputs['ErrorOutput'] as any | undefined;
-
-    const value1 = extractNaturalValue(minuend);
-    const value2 = extractNaturalValue(subtrahend);
-
-    if (value2 > value1) {
-        if (!errorOutput) {
-            throw new Error(
-                `Subtract mock tool cannot emit error: missing 'ErrorOutput' potential output (subtrahend ${value2} > minuend ${value1})`
-            );
-        }
-
-        return {
-            ErrorOutput: createMockErrorOutput(
-                errorOutput,
-                'SubtractInvalidInput',
-                `Subtrahend (${value2}) is larger than minuend (${value1}); subtraction would result in a negative value.`,
-                {
-                    minuend: value1,
-                    subtrahend: value2,
-                }
-            ),
-        };
-    }
-
-    const result = value1 - value2;
-
-    return {
-        Difference: createMockOutput(differenceOutput, result),
-    };
-}
-
-export function mockMultiply(inputs: Record<string, Resource | any>): Record<string, Resource> {
-    const multiplicand = inputs['Multiplicand'] as Resource;
-    const multiplier = inputs['Multiplier'] as Resource;
-    const productOutput = inputs['Product'] as any;
-
-    const value1 = extractNaturalValue(multiplicand);
-    const value2 = extractNaturalValue(multiplier);
-    const result = value1 * value2;
-
-    return {
-        Product: createMockOutput(productOutput, result),
-    };
-}
-
-export function mockDouble(inputs: Record<string, Resource | any>): Record<string, Resource> {
-    const N = inputs['N'] as Resource;
-    const DoubledOutput = inputs['Doubled'] as any;
-
-    const value = extractNaturalValue(N);
-    const result = value * 2;
-
-    return {
-        Doubled: createMockOutput(DoubledOutput, result),
-    };
-}
-
-export function mockDivide(inputs: Record<string, Resource | any>): Record<string, Resource> {
-    const dividend = inputs['Dividend'] as Resource;
-    const divisor = inputs['Divisor'] as Resource;
-    const quotientOutput = inputs['Quotient'] as any;
-    const remainderOutput = inputs['Remainder'] as any;
-
-    const errorOutput = inputs['ErrorOutput'] as any | undefined;
-
-    const value1 = extractNaturalValue(dividend);
-    const value2 = extractNaturalValue(divisor);
-
-    if (value2 === 0) {
-        if (!errorOutput) {
-            throw new Error(
-                `Divide mock tool cannot emit error: missing 'ErrorOutput' potential output (division by zero; dividend ${value1})`
-            );
-        }
-
-        return {
-            ErrorOutput: createMockErrorOutput(
-                errorOutput,
-                'DivideByZero',
-                `Cannot divide by zero (dividend ${value1}, divisor ${value2}).`,
-                {
-                    dividend: value1,
-                    divisor: value2,
-                }
-            ),
-        };
-    }
-
-    const quotient = Math.floor(value1 / value2);
-    const remainder = value1 % value2;
-
-    return {
-        Quotient: createMockOutput(quotientOutput, quotient),
-        Remainder: createMockOutput(remainderOutput, remainder),
-    };
-}
-
-export function executeMockNumericalTool(
-    toolName: string,
-    payload: Record<string, Resource | any>
-): Record<string, Resource> {
-    const normalizedName = toolName.toLowerCase();
-
-    switch (normalizedName) {
-        case 'add':
-            return mockAdd(payload);
-        case 'subtract':
-            return mockSubtract(payload);
-        case 'multiply':
-            return mockMultiply(payload);
-        case 'double':
-            return mockDouble(payload);
-        case 'divide':
-            return mockDivide(payload);
-        default:
-            throw new Error(`Unknown numerical tool: ${toolName}`);
-    }
-}
- */ 

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

@@ -1,5 +0,0 @@
-type JsonObject = Record<string, unknown>;
-type ResourceTypeByName = Record<string, JsonObject>;
-type ResourceByName = Record<string, JsonObject>;
-export declare function generateResources(resourceTypes: ResourceTypeByName): ResourceByName;
-export {};

package/dist/src/utils/resources.js

@@ -1,17 +0,0 @@
-const GENESIS_TIMESTAMP = '2025-11-30T00:00:00.000Z';
-export function generateResources(resourceTypes) {
-    const resources = {};
-    for (const [name, resourceType] of Object.entries(resourceTypes)) {
-        resources[name] = {
-            id: `RESOURCE-${name}`,
-            resourceTypeHandle: 'TYPE-ResourceType',
-            provenance: {
-                resourceProvenanceKind: 'genesis',
-            },
-            version: 1,
-            timestamp: GENESIS_TIMESTAMP,
-            value: resourceType,
-        };
-    }
-    return resources;
-}

package/generated-src/resourceTypes/resourceTypes.ts

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

package/generated-src/resources/resourceTypes.ts

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