@toolproof-core/genesis 1.0.52 → 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/src/utils/constantsAndMappings.d.ts

@@ -1,17 +1,35 @@
 type JSONValue = null | boolean | number | string | JSONValue[] | {
     [k: string]: JSONValue;
 };
+type HandleRecord = {
+    handle?: unknown;
+};
+type HandleRecordByName = Record<string, HandleRecord>;
+type ToolRecord = HandleRecord & {
+    isTemplate?: unknown;
+    templateToolHandle?: unknown;
+    instantiationRoleSpec?: unknown;
+    roleSpec?: unknown;
+};
+type ToolRecordByName = Record<string, ToolRecord>;
 export type GeneratedConstants = {
     Names: Record<string, string>;
+    Handles: {
+        ResourceTypes: Record<string, string>;
+        Tools: Record<string, string>;
+    };
+    ToolRoleNames: Record<string, Record<string, string>>;
     Enums: Record<string, Record<string, string>>;
 };
 export type GeneratedMappings = {
-    HandleNameToPrefix: Record<string, string>;
+    IdentifierNameToPrefix: Record<string, string>;
 };
 export declare function extractHandlePrefixes(schema: unknown): Record<string, string>;
 export declare function extractSubschemaNames(schema: unknown): Record<string, string>;
 export declare function extractEnums(schema: unknown): Record<string, Record<string, string>>;
-export declare function extractGeneratedConstantsAndMappings(schema: JSONValue): {
+export declare function extractHandles(records: HandleRecordByName): Record<string, string>;
+export declare function extractToolRoleNames(tools: ToolRecordByName): Record<string, Record<string, string>>;
+export declare function extractGeneratedConstantsAndMappings(schema: JSONValue, resourceTypeShells: HandleRecordByName, tools: ToolRecordByName): {
     CONSTANTS: GeneratedConstants;
     MAPPINGS: GeneratedMappings;
 };

package/dist/src/utils/constantsAndMappings.js

@@ -78,17 +78,96 @@ export function extractEnums(schema) {
     }
     return out;
 }
-export function extractGeneratedConstantsAndMappings(schema) {
+function toHandleConstantKey(handle) {
+    return handle.replace(/[^A-Za-z0-9]+/g, '_');
+}
+export function extractHandles(records) {
+    const recordEntries = Object.entries(records);
+    recordEntries.sort(([a], [b]) => a.localeCompare(b));
+    const out = {};
+    for (const [, record] of recordEntries) {
+        if (!record || typeof record !== 'object')
+            continue;
+        if (typeof record.handle !== 'string')
+            continue;
+        if (!record.handle || /[\n\r`]/.test(record.handle))
+            continue;
+        out[toHandleConstantKey(record.handle)] = record.handle;
+    }
+    return out;
+}
+function isPlainObject(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function extractRoleNameMap(roleSpec) {
+    if (!isPlainObject(roleSpec)) {
+        return {};
+    }
+    const out = {};
+    const groups = [
+        roleSpec.inputRoleValueByName,
+        roleSpec.outputRoleValueByName,
+    ];
+    for (const group of groups) {
+        if (!isPlainObject(group)) {
+            continue;
+        }
+        const entries = Object.keys(group).sort((a, b) => a.localeCompare(b));
+        for (const roleName of entries) {
+            if (!roleName || /[\n\r`]/.test(roleName)) {
+                continue;
+            }
+            out[roleName] = roleName;
+        }
+    }
+    return out;
+}
+function isCanonicalToolRecord(tool) {
+    if (tool.isTemplate === true) {
+        return true;
+    }
+    return tool.isTemplate === false && tool.templateToolHandle === undefined;
+}
+export function extractToolRoleNames(tools) {
+    const toolEntries = Object.values(tools)
+        .filter((tool) => isPlainObject(tool))
+        .filter((tool) => typeof tool.handle === 'string' && !!tool.handle)
+        .sort((a, b) => String(a.handle).localeCompare(String(b.handle)));
+    const out = {};
+    for (const tool of toolEntries) {
+        if (!isCanonicalToolRecord(tool)) {
+            continue;
+        }
+        const roleSpec = tool.isTemplate === true
+            ? tool.instantiationRoleSpec
+            : tool.roleSpec;
+        const roleNameMap = extractRoleNameMap(roleSpec);
+        if (Object.keys(roleNameMap).length === 0) {
+            continue;
+        }
+        out[toHandleConstantKey(tool.handle)] = roleNameMap;
+    }
+    return out;
+}
+export function extractGeneratedConstantsAndMappings(schema, resourceTypeShells, tools) {
     const names = extractSubschemaNames(schema);
+    const resourceTypeHandles = extractHandles(resourceTypeShells);
+    const toolHandles = extractHandles(tools);
+    const toolRoleNames = extractToolRoleNames(tools);
     const enums = extractEnums(schema);
     const handlePrefixes = extractHandlePrefixes(schema);
     return {
         CONSTANTS: {
             Names: names,
+            Handles: {
+                ResourceTypes: resourceTypeHandles,
+                Tools: toolHandles,
+            },
+            ToolRoleNames: toolRoleNames,
             Enums: enums,
         },
         MAPPINGS: {
-            HandleNameToPrefix: handlePrefixes,
+            IdentifierNameToPrefix: handlePrefixes,
         },
     };
 }
@@ -111,6 +190,9 @@ function renderTsKey(key) {
 }
 export function renderConstantsTs(constants) {
     const nameKeys = Object.keys(constants.Names).sort((a, b) => a.localeCompare(b));
+    const resourceTypeHandleKeys = Object.keys(constants.Handles.ResourceTypes).sort((a, b) => a.localeCompare(b));
+    const toolHandleKeys = Object.keys(constants.Handles.Tools).sort((a, b) => a.localeCompare(b));
+    const toolRoleNameKeys = Object.keys(constants.ToolRoleNames).sort((a, b) => a.localeCompare(b));
     const enumKeys = Object.keys(constants.Enums).sort((a, b) => a.localeCompare(b));
     const lines = [];
     lines.push('const CONSTANTS = {');
@@ -120,6 +202,32 @@ export function renderConstantsTs(constants) {
         lines.push(`        ${renderTsKey(key)}: ${renderTsStringLiteral(value)},`);
     }
     lines.push('    },');
+    lines.push('    Handles: {');
+    lines.push('        ResourceTypes: {');
+    for (const key of resourceTypeHandleKeys) {
+        const value = constants.Handles.ResourceTypes[key] ?? '';
+        lines.push(`            ${renderTsKey(key)}: ${renderTsStringLiteral(value)},`);
+    }
+    lines.push('        },');
+    lines.push('        Tools: {');
+    for (const key of toolHandleKeys) {
+        const value = constants.Handles.Tools[key] ?? '';
+        lines.push(`            ${renderTsKey(key)}: ${renderTsStringLiteral(value)},`);
+    }
+    lines.push('        },');
+    lines.push('    },');
+    lines.push('    ToolRoleNames: {');
+    for (const toolKey of toolRoleNameKeys) {
+        const roleNames = constants.ToolRoleNames[toolKey] ?? {};
+        const roleKeys = Object.keys(roleNames).sort((a, b) => a.localeCompare(b));
+        lines.push(`        ${renderTsKey(toolKey)}: {`);
+        for (const roleKey of roleKeys) {
+            const value = roleNames[roleKey] ?? '';
+            lines.push(`            ${renderTsKey(roleKey)}: ${renderTsStringLiteral(value)},`);
+        }
+        lines.push('        },');
+    }
+    lines.push('    },');
     lines.push('    Enums: {');
     for (const key of enumKeys) {
         const members = constants.Enums[key] ?? {};
@@ -138,12 +246,12 @@ export function renderConstantsTs(constants) {
     return lines.join('\n');
 }
 export function renderMappingsTs(mappings) {
-    const handleKeys = Object.keys(mappings.HandleNameToPrefix).sort((a, b) => a.localeCompare(b));
+    const handleKeys = Object.keys(mappings.IdentifierNameToPrefix).sort((a, b) => a.localeCompare(b));
     const lines = [];
     lines.push('const MAPPINGS = {');
-    lines.push('    HandleNameToPrefix: {');
+    lines.push('    IdentifierNameToPrefix: {');
     for (const key of handleKeys) {
-        const value = mappings.HandleNameToPrefix[key] ?? '';
+        const value = mappings.IdentifierNameToPrefix[key] ?? '';
         lines.push(`        ${renderTsKey(key)}: ${renderTsStringLiteral(value)},`);
     }
     lines.push('    },');

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.52",
+  "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": [],