@toolproof-core/genesis 1.0.53 → 1.0.54

package/dist/scripts/generateStandaloneZodSchemas.js

@@ -0,0 +1,36 @@
+import * as fs from 'node:fs';
+import { getConfig } from './_lib/config.js';
+import { generateStandaloneZodBarrel, generateStandaloneZodModule, } from '../src/utils/standaloneZodSchemas.js';
+function main() {
+    try {
+        const config = getConfig();
+        const resourceTypeShellsPath = config.getResourceTypeShellsSourcePath();
+        if (!fs.existsSync(resourceTypeShellsPath)) {
+            throw new Error(`Resource type records source file not found at ${resourceTypeShellsPath}`);
+        }
+        const resourceTypeShells = JSON.parse(fs.readFileSync(resourceTypeShellsPath, 'utf8'));
+        const names = Object.keys(resourceTypeShells);
+        const zodDir = config.getZodSchemasDir();
+        fs.mkdirSync(zodDir, { recursive: true });
+        for (const name of names) {
+            const inPath = config.getStandaloneSchemaPath(`${name}.json`);
+            if (!fs.existsSync(inPath)) {
+                throw new Error(`Standalone schema not found at ${inPath}. Run generateStandaloneSchemas first.`);
+            }
+            const parsed = JSON.parse(fs.readFileSync(inPath, 'utf8'));
+            const generated = generateStandaloneZodModule(name, parsed);
+            const outPath = config.getZodSchemaPath(generated.fileName);
+            fs.writeFileSync(outPath, generated.content, 'utf8');
+            if (generated.warnings.length > 0) {
+                console.warn(`Generated Zod schema '${name}' with ${generated.warnings.length} warning(s).`);
+            }
+            console.log(`Wrote ${outPath}`);
+        }
+        fs.writeFileSync(config.getZodIndexPath(), generateStandaloneZodBarrel(names), 'utf8');
+    }
+    catch (error) {
+        console.error(error?.message ?? error);
+        process.exitCode = 1;
+    }
+}
+void main();

package/dist/scripts/generateTerminals.d.ts

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

package/dist/scripts/generateTerminals.js

@@ -0,0 +1,26 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { getConfig } from './_lib/config.js';
+import { computeTerminalsInKeyOrder, normalizeDependencyMap, } from '../src/utils/schemaDependencies.js';
+function main() {
+    try {
+        const config = getConfig();
+        const inPath = config.getDependencyMapPath();
+        const outPath = config.getTerminalsPath();
+        if (!fs.existsSync(inPath)) {
+            throw new Error(`Dependency map not found at ${inPath}. Run generateDependencies first.`);
+        }
+        const raw = fs.readFileSync(inPath, 'utf8');
+        const parsed = JSON.parse(raw);
+        const dependencyMap = normalizeDependencyMap(parsed);
+        const terminals = computeTerminalsInKeyOrder(dependencyMap);
+        fs.mkdirSync(path.dirname(outPath), { recursive: true });
+        fs.writeFileSync(outPath, JSON.stringify(terminals, null, 4), 'utf8');
+        console.log(`Wrote terminals to ${outPath}`);
+    }
+    catch (error) {
+        console.error(error?.message ?? error);
+        process.exitCode = 1;
+    }
+}
+main();

package/dist/scripts/generateTimestampedResources.d.ts

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

package/dist/scripts/generateTimestampedResources.js

@@ -0,0 +1,79 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { getConfig } from './_lib/config.js';
+import { generateTimestampedResources } from '../src/utils/timestampedResources.js';
+/**
+ * Wrap canonical declarations with TimestampedResource records.
+ */
+// IMPURE: Script entrypoint (config + filesystem I/O + console + process exit code).
+function main() {
+    try {
+        const config = getConfig();
+        const jobs = [
+            {
+                inPath: config.getResourceTypesDeclarationPath(),
+                outPath: config.getResourceTypeTimestampedResourcesPath(),
+                label: 'resource type',
+                resourceTypeHandle: 'TYPE-ResourceType',
+                getResourceId: (value) => getResourceIdFromHandle(value),
+            },
+            {
+                inPath: config.getToolsDeclarationPath(),
+                outPath: config.getToolTimestampedResourcesPath(),
+                label: 'tool',
+                resourceTypeHandle: 'TYPE-Tool',
+                getResourceId: (value) => getResourceIdFromHandle(value),
+            },
+            {
+                inPath: config.getBooleansDeclarationPath(),
+                outPath: config.getBooleanTimestampedResourcesPath(),
+                label: 'boolean',
+                resourceTypeHandle: 'TYPE-Boolean',
+                getResourceId: (value) => `RESOURCE-BOOLEAN:${value === true ? 'True' : 'False'}`,
+            },
+            {
+                inPath: config.getNaturalsDeclarationPath(),
+                outPath: config.getNaturalTimestampedResourcesPath(),
+                label: 'natural',
+                resourceTypeHandle: 'TYPE-Natural',
+                getResourceId: (value) => `RESOURCE-NATURAL:${String(value)}`,
+            },
+        ];
+        for (const job of jobs) {
+            if (!fs.existsSync(job.inPath)) {
+                throw new Error(`Generated ${job.label} declarations file not found at ${job.inPath}`);
+            }
+            const declarations = JSON.parse(fs.readFileSync(job.inPath, 'utf-8'));
+            if (!Array.isArray(declarations)) {
+                throw new Error(`Generated ${job.label} declarations file must be an array at ${job.inPath}`);
+            }
+            const timestampedResources = generateTimestampedResources(declarations, {
+                resourceTypeHandle: job.resourceTypeHandle,
+                getResourceId: job.getResourceId,
+            });
+            fs.mkdirSync(path.dirname(job.outPath), { recursive: true });
+            fs.writeFileSync(job.outPath, JSON.stringify(timestampedResources, null, 4), 'utf-8');
+            console.log(`Generated ${timestampedResources.length} ${job.label} timestamped resources -> ${job.outPath}`);
+        }
+    }
+    catch (error) {
+        console.error(error?.message ?? error);
+        process.exitCode = 1;
+    }
+}
+function getResourceIdFromHandle(value) {
+    if (value && typeof value === 'object' && 'handle' in value && typeof value.handle === 'string') {
+        return formatResourceIdFromHandle(value.handle);
+    }
+    throw new Error('Timestamped resource generation requires declaration values with a string handle.');
+}
+function formatResourceIdFromHandle(handle) {
+    const separatorIndex = handle.indexOf('-');
+    if (separatorIndex === -1) {
+        return `RESOURCE-${handle}`;
+    }
+    const namespace = handle.slice(0, separatorIndex);
+    const localPart = handle.slice(separatorIndex + 1);
+    return `RESOURCE-${namespace}:${localPart}`;
+}
+main();

package/dist/scripts/generateTypes.d.ts

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

package/dist/scripts/generateTypes.js

@@ -0,0 +1,40 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { getConfig } from './_lib/config.js';
+import { generateTypeDeclarations } from '../src/utils/typeGeneration.js';
+async function main() {
+    try {
+        const config = getConfig();
+        const schemaPath = config.getSchemasPath();
+        const srcTypesDir = config.getTypesSrcDir();
+        const distTypesDir = config.getTypesDistDir();
+        const srcOutputPath = config.getTypesDtsSrcPath();
+        const distOutputPath = config.getTypesDtsDistPath();
+        const srcJsPath = config.getTypesJsSrcPath();
+        const distJsPath = config.getTypesJsDistPath();
+        if (!fs.existsSync(schemaPath)) {
+            throw new Error(`Generated schemas file not found at ${schemaPath}\n` +
+                'Run the normalization step first (for example: pnpm run normalizeAnchorsToPointers).');
+        }
+        const parsedSchema = JSON.parse(fs.readFileSync(schemaPath, 'utf8'));
+        const rootName = path.basename(schemaPath, path.extname(schemaPath));
+        const output = await generateTypeDeclarations(parsedSchema, rootName);
+        fs.mkdirSync(srcTypesDir, { recursive: true });
+        fs.writeFileSync(srcOutputPath, output, 'utf8');
+        console.log(`Wrote ${srcOutputPath}`);
+        fs.mkdirSync(distTypesDir, { recursive: true });
+        fs.writeFileSync(distOutputPath, output, 'utf8');
+        console.log(`Wrote ${distOutputPath}`);
+        if (!fs.existsSync(srcJsPath)) {
+            fs.writeFileSync(srcJsPath, 'export {}\n', 'utf8');
+            console.log(`Wrote ${srcJsPath}`);
+        }
+        fs.writeFileSync(distJsPath, 'export {}\n', 'utf8');
+        console.log(`Wrote ${distJsPath}`);
+    }
+    catch (error) {
+        console.error(error?.message ?? error);
+        process.exitCode = 1;
+    }
+}
+void main();

package/dist/scripts/normalizeAnchorsToPointers.d.ts

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

package/dist/scripts/normalizeAnchorsToPointers.js

@@ -0,0 +1,32 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { getConfig } from './_lib/config.js';
+import { normalizeAnchorsToPointers } from '../src/utils/schemaRefNormalization.js';
+/**
+ * Rewrite local anchor refs in the configured source schema document to JSON pointers.
+ */
+// IMPURE: Script entrypoint (config + filesystem I/O + console + process exit code).
+function main() {
+    try {
+        const config = getConfig();
+        const inPath = config.getSchemasSourcePath();
+        const outPath = config.getSchemasPath();
+        if (!fs.existsSync(inPath)) {
+            throw new Error(`Schema source file not found at ${inPath}`);
+        }
+        const raw = fs.readFileSync(inPath, 'utf-8');
+        const schemas = JSON.parse(raw);
+        if (!schemas.$defs || typeof schemas.$defs !== 'object') {
+            throw new Error('Source schema document must have root $defs');
+        }
+        const normalizedSchemas = normalizeAnchorsToPointers(schemas);
+        fs.mkdirSync(path.dirname(outPath), { recursive: true });
+        fs.writeFileSync(outPath, JSON.stringify(normalizedSchemas, null, 4), 'utf-8');
+        console.log(`Wrote generated schemas with pointer refs to ${outPath}`);
+    }
+    catch (error) {
+        console.error(error?.message ?? error);
+        process.exitCode = 1;
+    }
+}
+main();

package/dist/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../index.ts","../src/index.ts","../src/implementations/tools.ts","../src/utils/constantsandmappings.ts","../src/utils/coreprojection.ts","../src/utils/resourcetypes.ts","../src/utils/schemadependencies.ts","../src/utils/schemaobjectnormalization.ts","../src/utils/schemarefnormalization.ts","../src/utils/schemashims.ts","../src/utils/standaloneschemas.ts","../src/utils/standalonetypes.ts","../src/utils/standalonezodschemas.ts","../src/utils/timestampedresources.ts","../src/utils/typegeneration.ts","../src/utils/typegenerationpostprocess.ts","../src/utils/typegenerationpreflight.ts","../src/utils/zodcodegen.ts","../generated-src/declarations/booleans.ts","../generated-src/declarations/naturals.ts","../generated-src/declarations/resourcetypes.ts","../generated-src/declarations/tools.ts","../generated-src/implementations/tools.ts","../generated-src/lookups/constants.ts","../generated-src/lookups/mappings.ts","../generated-src/schemas/schemas.ts","../generated-src/schemas/standalone/boolean.ts","../generated-src/schemas/standalone/error.ts","../generated-src/schemas/standalone/goal.ts","../generated-src/schemas/standalone/natural.ts","../generated-src/schemas/standalone/resource.ts","../generated-src/schemas/standalone/resourcetype.ts","../generated-src/schemas/standalone/strategy.ts","../generated-src/schemas/standalone/strategytrace.ts","../generated-src/schemas/standalone/suite.ts","../generated-src/schemas/standalone/tool.ts","../generated-src/schemas/zod/boolean.ts","../generated-src/schemas/zod/error.ts","../generated-src/schemas/zod/goal.ts","../generated-src/schemas/zod/natural.ts","../generated-src/schemas/zod/resource.ts","../generated-src/schemas/zod/resourcetype.ts","../generated-src/schemas/zod/strategy.ts","../generated-src/schemas/zod/strategytrace.ts","../generated-src/schemas/zod/suite.ts","../generated-src/schemas/zod/tool.ts","../generated-src/schemas/zod/index.ts","../generated-src/timestampedresources/booleans.ts","../generated-src/timestampedresources/naturals.ts","../generated-src/timestampedresources/resourcetypes.ts","../generated-src/timestampedresources/tools.ts","../generated-src/types/types.d.ts","../generated-src/types/standalone/booleanresource.d.ts","../generated-src/types/standalone/errorresource.d.ts","../generated-src/types/standalone/goalresource.d.ts","../generated-src/types/standalone/naturalresource.d.ts","../generated-src/types/standalone/resourceresource.d.ts","../generated-src/types/standalone/resourcetyperesource.d.ts","../generated-src/types/standalone/strategyresource.d.ts","../generated-src/types/standalone/strategytraceresource.d.ts","../generated-src/types/standalone/suiteresource.d.ts","../generated-src/types/standalone/toolresource.d.ts","../scripts/generateconstantsandmappings.ts","../scripts/generatecoreprojection.ts","../scripts/generatedeclarations.ts","../scripts/generatedependencies.ts","../scripts/generateimplementations.ts","../scripts/generateresourcetypes.ts","../scripts/generateschemashims.ts","../scripts/generatestandaloneschemas.ts","../scripts/generatestandalonetypes.ts","../scripts/generatestandalonezodschemas.ts","../scripts/generateterminals.ts","../scripts/generatetimestampedresources.ts","../scripts/generatetypes.ts","../scripts/normalizeanchorstopointers.ts","../scripts/_lib/config.ts"],"version":"5.9.3"}

package/package.json

@@ -1,20 +1,54 @@
 {
   "name": "@toolproof-core/genesis",
-  "version": "1.0.53",
+  "version": "1.0.54",
   "description": "Core ToolProof ontology, schemas, declarations, implementations, and generated type artifacts.",
-  "main": "dist/src/index.js",
-  "types": "dist/src/index.d.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "exports": {
     ".": {
-      "import": "./dist/src/index.js",
-      "types": "./dist/src/index.d.ts"
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./lookups/constants": {
+      "import": "./dist/generated-src/lookups/constants.js",
+      "types": "./dist/generated-src/lookups/constants.d.ts"
+    },
+    "./lookups/mappings": {
+      "import": "./dist/generated-src/lookups/mappings.js",
+      "types": "./dist/generated-src/lookups/mappings.d.ts"
+    },
+    "./types": {
+      "import": "./dist/generated-src/types/types.js",
+      "types": "./dist/generated-src/types/types.d.ts"
+    },
+    "./schemas": {
+      "import": "./dist/generated-src/schemas/schemas.js",
+      "types": "./dist/generated-src/schemas/schemas.d.ts"
+    },
+    "./implementations/tools": {
+      "import": "./dist/generated-src/implementations/tools.js",
+      "types": "./dist/generated-src/implementations/tools.d.ts"
+    },
+    "./timestamped-resources/resource-types": {
+      "import": "./dist/generated-src/timestampedResources/resourceTypes.js",
+      "types": "./dist/generated-src/timestampedResources/resourceTypes.d.ts"
+    },
+    "./timestamped-resources/tools": {
+      "import": "./dist/generated-src/timestampedResources/tools.js",
+      "types": "./dist/generated-src/timestampedResources/tools.d.ts"
+    },
+    "./timestamped-resources/booleans": {
+      "import": "./dist/generated-src/timestampedResources/booleans.js",
+      "types": "./dist/generated-src/timestampedResources/booleans.d.ts"
+    },
+    "./timestamped-resources/naturals": {
+      "import": "./dist/generated-src/timestampedResources/naturals.js",
+      "types": "./dist/generated-src/timestampedResources/naturals.d.ts"
     }
   },
   "files": [
     "toolproof.json",
-    "dist/src",
-    "src",
-    "generated-src"
+    "dist"
   ],
   "type": "module",
   "keywords": [],

package/generated-src/implementations/tools.ts

@@ -1,214 +0,0 @@
-import type {
-    Boolean,
-    Natural,
-    ResourceType,
-    Tool,
-} from '../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;