@toolproof-core/genesis 1.0.52 → 1.0.54

package/dist/scripts/_lib/config.js

@@ -0,0 +1,269 @@
+import * as path from 'node:path';
+function getEnv(name, defaultValue) {
+    const value = process.env[name];
+    return value || defaultValue;
+}
+function toPosixPath(value) {
+    return value.split(path.sep).join('/');
+}
+export class SchemaConfig {
+    root;
+    coreRepoRoot;
+    declarationsSourceDir;
+    resourceTypesSourceDir;
+    implementationsSourceDir;
+    schemasSourceFile;
+    resourceTypeShellsSourceFile;
+    toolsSourceFile;
+    booleansSourceFile;
+    naturalsSourceFile;
+    schemasDir;
+    lookupsDir;
+    metadataDir;
+    zodSchemasDir;
+    standaloneSchemasDir;
+    declarationsDir;
+    implementationsDir;
+    timestampedResourcesDir;
+    typesSrcDir;
+    typesDistDir;
+    standaloneTypeSrcDir;
+    standaloneTypeDistDir;
+    constructor() {
+        this.root = getEnv('TP_SCHEMA_ROOT', process.cwd());
+        this.coreRepoRoot = getEnv('TP_SCHEMA_CORE_REPO_ROOT', path.resolve(this.root, '..', '..'));
+        this.declarationsSourceDir = getEnv('TP_SCHEMA_DECLARATIONS_SOURCE_DIR', 'src/declarations');
+        this.resourceTypesSourceDir = getEnv('TP_SCHEMA_RESOURCE_TYPES_SOURCE_DIR', 'src/declarations/resourceTypes');
+        this.implementationsSourceDir = getEnv('TP_SCHEMA_IMPLEMENTATIONS_SOURCE_DIR', 'src/implementations');
+        this.schemasSourceFile = getEnv('TP_SCHEMA_SOURCE_FILE', 'schemas.json');
+        this.resourceTypeShellsSourceFile = getEnv('TP_SCHEMA_RESOURCE_TYPE_RECORDS_FILE', 'resourceTypeShells.json');
+        this.toolsSourceFile = getEnv('TP_SCHEMA_TOOLS_SOURCE_FILE', 'tools.json');
+        this.booleansSourceFile = getEnv('TP_SCHEMA_BOOLEANS_SOURCE_FILE', 'booleans.json');
+        this.naturalsSourceFile = getEnv('TP_SCHEMA_NATURALS_SOURCE_FILE', 'naturals.json');
+        this.schemasDir = getEnv('TP_SCHEMA_SCHEMAS_DIR', 'generated-src/schemas');
+        this.lookupsDir = getEnv('TP_SCHEMA_LOOKUPS_DIR', 'generated-src/lookups');
+        this.metadataDir = getEnv('TP_SCHEMA_METADATA_DIR', 'generated-src/metadata');
+        this.zodSchemasDir = getEnv('TP_SCHEMA_ZOD_SCHEMAS_DIR', 'generated-src/schemas/zod');
+        this.standaloneSchemasDir = getEnv('TP_SCHEMA_STANDALONE_SCHEMAS_DIR', 'generated-src/schemas/standalone');
+        this.declarationsDir = getEnv('TP_SCHEMA_DECLARATIONS_DIR', 'generated-src/declarations');
+        this.implementationsDir = getEnv('TP_SCHEMA_IMPLEMENTATIONS_DIR', 'generated-src/implementations');
+        this.timestampedResourcesDir = getEnv('TP_SCHEMA_TIMESTAMPED_RESOURCES_DIR', 'generated-src/timestampedResources');
+        this.typesSrcDir = getEnv('TP_SCHEMA_TYPES_SRC_DIR', 'generated-src/types');
+        this.typesDistDir = getEnv('TP_SCHEMA_TYPES_DIST_DIR', 'dist/generated-src/types');
+        this.standaloneTypeSrcDir = getEnv('TP_SCHEMA_STANDALONE_TYPE_SRC_DIR', 'generated-src/types/standalone');
+        this.standaloneTypeDistDir = getEnv('TP_SCHEMA_STANDALONE_TYPE_DIST_DIR', 'dist/generated-src/types/standalone');
+    }
+    getRoot() {
+        return this.root;
+    }
+    getCoreRepoRoot() {
+        return path.isAbsolute(this.coreRepoRoot)
+            ? this.coreRepoRoot
+            : path.join(this.root, this.coreRepoRoot);
+    }
+    getDeclarationsSourceDir() {
+        return path.isAbsolute(this.declarationsSourceDir)
+            ? this.declarationsSourceDir
+            : path.join(this.root, this.declarationsSourceDir);
+    }
+    getResourceTypesSourceDir() {
+        return path.isAbsolute(this.resourceTypesSourceDir)
+            ? this.resourceTypesSourceDir
+            : path.join(this.root, this.resourceTypesSourceDir);
+    }
+    getImplementationsSourceDir() {
+        return path.isAbsolute(this.implementationsSourceDir)
+            ? this.implementationsSourceDir
+            : path.join(this.root, this.implementationsSourceDir);
+    }
+    getSchemasSourceFile() {
+        return this.schemasSourceFile;
+    }
+    getSchemasSourcePath() {
+        return path.join(this.getResourceTypesSourceDir(), this.getSchemasSourceFile());
+    }
+    getResourceTypeShellsSourceFile() {
+        return this.resourceTypeShellsSourceFile;
+    }
+    getResourceTypeShellsSourcePath() {
+        return path.join(this.getResourceTypesSourceDir(), this.getResourceTypeShellsSourceFile());
+    }
+    getToolsSourcePath() {
+        return path.join(this.getDeclarationsSourceDir(), this.toolsSourceFile);
+    }
+    getBooleansSourcePath() {
+        return path.join(this.getDeclarationsSourceDir(), this.booleansSourceFile);
+    }
+    getNaturalsSourcePath() {
+        return path.join(this.getDeclarationsSourceDir(), this.naturalsSourceFile);
+    }
+    getSchemasDir() {
+        return path.isAbsolute(this.schemasDir)
+            ? this.schemasDir
+            : path.join(this.root, this.schemasDir);
+    }
+    getSchemasPath() {
+        return path.join(this.getSchemasDir(), this.getSchemasSourceFile());
+    }
+    getZodSchemasDir() {
+        return path.isAbsolute(this.zodSchemasDir)
+            ? this.zodSchemasDir
+            : path.join(this.root, this.zodSchemasDir);
+    }
+    getZodSchemaPath(filename) {
+        return path.join(this.getZodSchemasDir(), filename);
+    }
+    getZodIndexPath() {
+        return this.getZodSchemaPath('index.ts');
+    }
+    getLookupsDir() {
+        return path.isAbsolute(this.lookupsDir)
+            ? this.lookupsDir
+            : path.join(this.root, this.lookupsDir);
+    }
+    getLookupsPath(filename) {
+        return path.join(this.getLookupsDir(), filename);
+    }
+    getConstantsPath() {
+        return this.getLookupsPath('constants.ts');
+    }
+    getMappingsPath() {
+        return this.getLookupsPath('mappings.ts');
+    }
+    getMetadataDir() {
+        return path.isAbsolute(this.metadataDir)
+            ? this.metadataDir
+            : path.join(this.root, this.metadataDir);
+    }
+    getMetadataPath(filename) {
+        return path.join(this.getMetadataDir(), filename);
+    }
+    getDependencyMapPath() {
+        return this.getMetadataPath('dependencyMap.json');
+    }
+    getTerminalsPath() {
+        return this.getMetadataPath('terminals.json');
+    }
+    getCoreProjectionPath() {
+        return this.getMetadataPath('Core.json');
+    }
+    getLegacyGeneratedDir() {
+        return path.join(this.root, 'generated-src');
+    }
+    getGeneratedDir() {
+        return path.dirname(this.getSchemasDir());
+    }
+    getCoreProjectionExcludedRelativePrefixes() {
+        const coreRepoRoot = this.getCoreRepoRoot();
+        return [this.getLegacyGeneratedDir(), this.getGeneratedDir()].map((dirPath) => {
+            return toPosixPath(path.relative(coreRepoRoot, dirPath));
+        });
+    }
+    getStandaloneSchemasDir() {
+        return path.isAbsolute(this.standaloneSchemasDir)
+            ? this.standaloneSchemasDir
+            : path.join(this.root, this.standaloneSchemasDir);
+    }
+    getStandaloneSchemaPath(filename) {
+        return path.join(this.getStandaloneSchemasDir(), filename);
+    }
+    getDeclarationsDir() {
+        return path.isAbsolute(this.declarationsDir)
+            ? this.declarationsDir
+            : path.join(this.root, this.declarationsDir);
+    }
+    getImplementationsDir() {
+        return path.isAbsolute(this.implementationsDir)
+            ? this.implementationsDir
+            : path.join(this.root, this.implementationsDir);
+    }
+    getDeclarationPath(filename) {
+        return path.join(this.getDeclarationsDir(), filename);
+    }
+    getImplementationPath(filename) {
+        return path.join(this.getImplementationsDir(), filename);
+    }
+    getResourceTypesDeclarationPath() {
+        return this.getDeclarationPath('resourceTypes.json');
+    }
+    getToolsDeclarationPath() {
+        return this.getDeclarationPath('tools.json');
+    }
+    getBooleansDeclarationPath() {
+        return this.getDeclarationPath('booleans.json');
+    }
+    getNaturalsDeclarationPath() {
+        return this.getDeclarationPath('naturals.json');
+    }
+    getTimestampedResourcesDir() {
+        return path.isAbsolute(this.timestampedResourcesDir)
+            ? this.timestampedResourcesDir
+            : path.join(this.root, this.timestampedResourcesDir);
+    }
+    getTimestampedResourcePath(filename) {
+        return path.join(this.getTimestampedResourcesDir(), filename);
+    }
+    getResourceTypeTimestampedResourcesPath() {
+        return this.getTimestampedResourcePath('resourceTypes.json');
+    }
+    getToolTimestampedResourcesPath() {
+        return this.getTimestampedResourcePath('tools.json');
+    }
+    getBooleanTimestampedResourcesPath() {
+        return this.getTimestampedResourcePath('booleans.json');
+    }
+    getNaturalTimestampedResourcesPath() {
+        return this.getTimestampedResourcePath('naturals.json');
+    }
+    getTypesSrcDir() {
+        return path.isAbsolute(this.typesSrcDir)
+            ? this.typesSrcDir
+            : path.join(this.root, this.typesSrcDir);
+    }
+    getTypesDistDir() {
+        return path.isAbsolute(this.typesDistDir)
+            ? this.typesDistDir
+            : path.join(this.root, this.typesDistDir);
+    }
+    getTypesSrcPath(filename) {
+        return path.join(this.getTypesSrcDir(), filename);
+    }
+    getTypesDistPath(filename) {
+        return path.join(this.getTypesDistDir(), filename);
+    }
+    getTypesDtsSrcPath() {
+        return this.getTypesSrcPath('types.d.ts');
+    }
+    getTypesDtsDistPath() {
+        return this.getTypesDistPath('types.d.ts');
+    }
+    getTypesJsSrcPath() {
+        return this.getTypesSrcPath('types.js');
+    }
+    getTypesJsDistPath() {
+        return this.getTypesDistPath('types.js');
+    }
+    getStandaloneTypeSrcDir() {
+        return path.isAbsolute(this.standaloneTypeSrcDir)
+            ? this.standaloneTypeSrcDir
+            : path.join(this.root, this.standaloneTypeSrcDir);
+    }
+    getStandaloneTypeDistDir() {
+        return path.isAbsolute(this.standaloneTypeDistDir)
+            ? this.standaloneTypeDistDir
+            : path.join(this.root, this.standaloneTypeDistDir);
+    }
+    getStandaloneTypeSrcPath(filename) {
+        return path.join(this.getStandaloneTypeSrcDir(), filename);
+    }
+    getStandaloneTypeDistPath(filename) {
+        return path.join(this.getStandaloneTypeDistDir(), filename);
+    }
+}
+let configInstance = null;
+export function getConfig() {
+    if (!configInstance) {
+        configInstance = new SchemaConfig();
+    }
+    return configInstance;
+}

package/dist/scripts/generateConstantsAndMappings.d.ts

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

package/dist/scripts/generateConstantsAndMappings.js

@@ -0,0 +1,41 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { getConfig } from './_lib/config.js';
+import { extractGeneratedConstantsAndMappings, renderConstantsTs, renderMappingsTs, } from '../src/utils/constantsAndMappings.js';
+function main() {
+    try {
+        const config = getConfig();
+        const inPath = config.getSchemasPath();
+        const resourceTypeShellsPath = config.getResourceTypeShellsSourcePath();
+        const toolsPath = config.getToolsSourcePath();
+        const outConstantsPath = config.getConstantsPath();
+        const outMappingsPath = config.getMappingsPath();
+        if (!fs.existsSync(inPath)) {
+            throw new Error(`Generated schemas file not found at ${inPath}. Run normalizeAnchorsToPointers first.`);
+        }
+        if (!fs.existsSync(resourceTypeShellsPath)) {
+            throw new Error(`Resource type records source file not found at ${resourceTypeShellsPath}`);
+        }
+        if (!fs.existsSync(toolsPath)) {
+            throw new Error(`Tools source file not found at ${toolsPath}`);
+        }
+        const raw = fs.readFileSync(inPath, 'utf8');
+        const doc = JSON.parse(raw);
+        const resourceTypeShells = JSON.parse(fs.readFileSync(resourceTypeShellsPath, 'utf8'));
+        const tools = JSON.parse(fs.readFileSync(toolsPath, 'utf8'));
+        const toolRecords = Object.fromEntries(tools.map((tool, index) => [String(index), tool]));
+        const { CONSTANTS, MAPPINGS } = extractGeneratedConstantsAndMappings(doc, resourceTypeShells, toolRecords);
+        const constantsTs = renderConstantsTs(CONSTANTS);
+        const mappingsTs = renderMappingsTs(MAPPINGS);
+        fs.mkdirSync(path.dirname(outConstantsPath), { recursive: true });
+        fs.writeFileSync(outConstantsPath, constantsTs, 'utf8');
+        fs.writeFileSync(outMappingsPath, mappingsTs, 'utf8');
+        console.log(`Wrote constants to ${outConstantsPath}`);
+        console.log(`Wrote mappings to ${outMappingsPath}`);
+    }
+    catch (error) {
+        console.error(`Error generating constants/mappings: ${error?.message ?? error}`);
+        process.exitCode = 1;
+    }
+}
+main();

package/dist/scripts/generateCoreProjection.d.ts

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

package/dist/scripts/generateCoreProjection.js

@@ -0,0 +1,56 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { getConfig } from './_lib/config.js';
+import { compareNodes, shouldExclude, toPosixPath, } from '../src/utils/coreProjection.js';
+function readProjectionNode(rootPath, currentPath, excludedRelativePathPrefixes) {
+    const relativePath = currentPath === rootPath
+        ? '.'
+        : toPosixPath(path.relative(rootPath, currentPath));
+    const children = [];
+    const entries = fs.readdirSync(currentPath, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(currentPath, entry.name);
+        const entryRelativePath = toPosixPath(path.relative(rootPath, fullPath));
+        if (shouldExclude(entryRelativePath, entry.isDirectory(), excludedRelativePathPrefixes)) {
+            continue;
+        }
+        if (entry.isDirectory()) {
+            children.push(readProjectionNode(rootPath, fullPath, excludedRelativePathPrefixes));
+            continue;
+        }
+        if (entry.isFile()) {
+            children.push({
+                kind: 'file',
+                name: entry.name,
+                path: entryRelativePath,
+            });
+        }
+    }
+    children.sort(compareNodes);
+    return {
+        kind: 'directory',
+        name: path.basename(currentPath),
+        path: relativePath,
+        children,
+    };
+}
+function main() {
+    try {
+        const config = getConfig();
+        const rootPath = config.getCoreRepoRoot();
+        const outPath = config.getCoreProjectionPath();
+        const excludedRelativePathPrefixes = config.getCoreProjectionExcludedRelativePrefixes();
+        if (!fs.existsSync(rootPath)) {
+            throw new Error(`Core repo root not found at ${rootPath}`);
+        }
+        const projection = readProjectionNode(rootPath, rootPath, excludedRelativePathPrefixes);
+        fs.mkdirSync(path.dirname(outPath), { recursive: true });
+        fs.writeFileSync(outPath, `${JSON.stringify(projection, null, 4)}\n`, 'utf8');
+        console.log(`Wrote Core projection to ${outPath}`);
+    }
+    catch (error) {
+        console.error(error?.message ?? error);
+        process.exitCode = 1;
+    }
+}
+main();

package/dist/scripts/generateDeclarations.d.ts

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

package/dist/scripts/generateDeclarations.js

@@ -0,0 +1,43 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { getConfig } from './_lib/config.js';
+import { generateResourceTypes } from '../src/utils/resourceTypes.js';
+// IMPURE: Script entrypoint (config + filesystem I/O + console + process exit code).
+function main() {
+    try {
+        const config = getConfig();
+        const schemasPath = config.getSchemasPath();
+        const resourceTypeShellsPath = config.getResourceTypeShellsSourcePath();
+        if (!fs.existsSync(schemasPath)) {
+            throw new Error(`Generated schemas file not found at ${schemasPath}`);
+        }
+        if (!fs.existsSync(resourceTypeShellsPath)) {
+            throw new Error(`Resource type records source file not found at ${resourceTypeShellsPath}`);
+        }
+        const schemas = JSON.parse(fs.readFileSync(schemasPath, 'utf-8'));
+        const resourceTypeShells = JSON.parse(fs.readFileSync(resourceTypeShellsPath, 'utf-8'));
+        const resourceTypes = generateResourceTypes(schemas, resourceTypeShells);
+        writeJsonFile(config.getResourceTypesDeclarationPath(), resourceTypes);
+        console.log(`Generated ${resourceTypes.length} resource type declarations -> ${config.getResourceTypesDeclarationPath()}`);
+        projectDeclaration(config.getToolsSourcePath(), config.getToolsDeclarationPath(), 'tool');
+        projectDeclaration(config.getBooleansSourcePath(), config.getBooleansDeclarationPath(), 'boolean');
+        projectDeclaration(config.getNaturalsSourcePath(), config.getNaturalsDeclarationPath(), 'natural');
+    }
+    catch (error) {
+        console.error(error?.message ?? error);
+        process.exitCode = 1;
+    }
+}
+function projectDeclaration(sourcePath, outPath, label) {
+    if (!fs.existsSync(sourcePath)) {
+        throw new Error(`${label} declarations source file not found at ${sourcePath}`);
+    }
+    const parsed = JSON.parse(fs.readFileSync(sourcePath, 'utf-8'));
+    writeJsonFile(outPath, parsed);
+    console.log(`Projected ${label} declarations -> ${outPath}`);
+}
+function writeJsonFile(outPath, value) {
+    fs.mkdirSync(path.dirname(outPath), { recursive: true });
+    fs.writeFileSync(outPath, JSON.stringify(value, null, 4), 'utf-8');
+}
+main();

package/dist/scripts/generateDependencies.d.ts

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

package/dist/scripts/generateDependencies.js

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

package/dist/scripts/generateImplementations.d.ts

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

package/dist/scripts/generateImplementations.js

@@ -0,0 +1,45 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { getConfig } from './_lib/config.js';
+function main() {
+    try {
+        const config = getConfig();
+        const sourceDir = config.getImplementationsSourceDir();
+        const outDir = config.getImplementationsDir();
+        if (!fs.existsSync(sourceDir)) {
+            throw new Error(`Implementations source directory not found at ${sourceDir}`);
+        }
+        const copiedFileCount = copyImplementationDirectory(sourceDir, outDir);
+        console.log(`Projected ${copiedFileCount} implementation file(s) -> ${outDir}`);
+    }
+    catch (error) {
+        console.error(error?.message ?? error);
+        process.exitCode = 1;
+    }
+}
+function copyImplementationDirectory(sourceDir, outDir) {
+    fs.mkdirSync(outDir, { recursive: true });
+    let copiedFileCount = 0;
+    for (const dirent of fs.readdirSync(sourceDir, { withFileTypes: true })) {
+        const sourcePath = path.join(sourceDir, dirent.name);
+        const outPath = path.join(outDir, dirent.name);
+        if (dirent.isDirectory()) {
+            copiedFileCount += copyImplementationDirectory(sourcePath, outPath);
+            continue;
+        }
+        if (!dirent.isFile() || !dirent.name.endsWith('.ts')) {
+            continue;
+        }
+        const sourceContent = fs.readFileSync(sourcePath, 'utf8');
+        const outContent = rewriteGeneratedImportPaths(sourceContent);
+        fs.mkdirSync(path.dirname(outPath), { recursive: true });
+        fs.writeFileSync(outPath, outContent, 'utf8');
+        console.log(`Projected implementation -> ${outPath}`);
+        copiedFileCount += 1;
+    }
+    return copiedFileCount;
+}
+function rewriteGeneratedImportPaths(source) {
+    return source.replaceAll('../../generated-src/', '../');
+}
+main();

package/dist/scripts/generateResourceTypes.d.ts

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

package/dist/scripts/generateResourceTypes.js

@@ -0,0 +1,33 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { getConfig } from './_lib/config.js';
+import { generateResourceTypes } from '../src/utils/resourceTypes.js';
+/**
+ * Combine resource type records with matching schemas as projectionSchema.
+ */
+// IMPURE: Script entrypoint (config + filesystem I/O + console + process exit code).
+function main() {
+    try {
+        const config = getConfig();
+        const schemasPath = config.getSchemasPath();
+        const resourceTypeShellsPath = config.getResourceTypeShellsSourcePath();
+        const outPath = config.getResourceTypesDeclarationPath();
+        if (!fs.existsSync(schemasPath)) {
+            throw new Error(`Generated schemas file not found at ${schemasPath}`);
+        }
+        if (!fs.existsSync(resourceTypeShellsPath)) {
+            throw new Error(`Resource type records source file not found at ${resourceTypeShellsPath}`);
+        }
+        const schemas = JSON.parse(fs.readFileSync(schemasPath, 'utf-8'));
+        const resourceTypeShells = JSON.parse(fs.readFileSync(resourceTypeShellsPath, 'utf-8'));
+        const resourceTypes = generateResourceTypes(schemas, resourceTypeShells);
+        fs.mkdirSync(path.dirname(outPath), { recursive: true });
+        fs.writeFileSync(outPath, JSON.stringify(resourceTypes, null, 4), 'utf-8');
+        console.log(`Generated ${Object.keys(resourceTypes).length} resource types -> ${outPath}`);
+    }
+    catch (error) {
+        console.error(error?.message ?? error);
+        process.exitCode = 1;
+    }
+}
+main();

package/dist/scripts/generateSchemaShims.d.ts

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

package/dist/scripts/generateSchemaShims.js

@@ -0,0 +1,39 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { getConfig } from './_lib/config.js';
+import { getShimsForFiles } from '../src/utils/schemaShims.js';
+function main() {
+    try {
+        const config = getConfig();
+        let totalCount = 0;
+        totalCount += writeShimsForDirectory(config.getSchemasDir(), 'schema', 'schema');
+        totalCount += writeShimsForDirectory(config.getStandaloneSchemasDir(), 'schema', 'standalone schema');
+        totalCount += writeShimsForDirectory(config.getDeclarationsDir(), 'declarations', 'declaration');
+        totalCount += writeShimsForDirectory(config.getTimestampedResourcesDir(), 'timestampedResources', 'timestamped resource');
+        console.log(`Generated ${totalCount} total TypeScript shims`);
+    }
+    catch (error) {
+        console.error(error?.message ?? error);
+        process.exitCode = 1;
+    }
+}
+function listJsonFiles(dirPath) {
+    if (!fs.existsSync(dirPath)) {
+        return [];
+    }
+    return fs
+        .readdirSync(dirPath)
+        .filter((fileName) => fileName.endsWith('.json') && !fileName.startsWith('.'));
+}
+function writeShimsForDirectory(dirPath, variableName, label) {
+    const jsonFiles = listJsonFiles(dirPath);
+    const shims = getShimsForFiles(jsonFiles, variableName);
+    for (const [tsFile, content] of Object.entries(shims)) {
+        const outPath = path.join(dirPath, tsFile);
+        fs.writeFileSync(outPath, content, 'utf8');
+        console.log(`Generated ${tsFile} in ${dirPath}`);
+    }
+    console.log(`Generated ${jsonFiles.length} TypeScript ${label} shims in ${dirPath}`);
+    return jsonFiles.length;
+}
+void main();

package/dist/scripts/generateStandaloneSchemas.d.ts

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

package/dist/scripts/generateStandaloneSchemas.js

@@ -0,0 +1,37 @@
+import * as fs from 'node:fs';
+import { getConfig } from './_lib/config.js';
+import { generateStandaloneSchemas } from '../src/utils/standaloneSchemas.js';
+/**
+ * Create standalone JSON Schemas for each resource type record.
+ */
+// IMPURE: Script entrypoint (config + filesystem I/O + console + process exit code).
+function main() {
+    try {
+        const config = getConfig();
+        const schemasPath = config.getSchemasPath();
+        const resourceTypeShellsPath = config.getResourceTypeShellsSourcePath();
+        if (!fs.existsSync(schemasPath)) {
+            throw new Error(`Generated schemas file not found at ${schemasPath}`);
+        }
+        if (!fs.existsSync(resourceTypeShellsPath)) {
+            throw new Error(`Resource type records source file not found at ${resourceTypeShellsPath}`);
+        }
+        const schemasDocument = JSON.parse(fs.readFileSync(schemasPath, 'utf-8'));
+        const resourceTypeShells = JSON.parse(fs.readFileSync(resourceTypeShellsPath, 'utf-8'));
+        const names = Object.keys(resourceTypeShells);
+        const { standaloneSchemas, warnings } = generateStandaloneSchemas(schemasDocument, names);
+        for (const warning of warnings)
+            console.warn(warning);
+        fs.mkdirSync(config.getStandaloneSchemasDir(), { recursive: true });
+        for (const [name, standaloneSchema] of Object.entries(standaloneSchemas)) {
+            const outPath = config.getStandaloneSchemaPath(`${name}.json`);
+            fs.writeFileSync(outPath, JSON.stringify(standaloneSchema, null, 2) + '\n');
+            console.log(`Created standalone schema '${name}' -> ${outPath}`);
+        }
+    }
+    catch (error) {
+        console.error(error?.message ?? error);
+        process.exitCode = 1;
+    }
+}
+main();

package/dist/scripts/generateStandaloneTypes.d.ts

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

package/dist/scripts/generateStandaloneTypes.js

@@ -0,0 +1,39 @@
+import * as fs from 'node:fs';
+import { getConfig } from './_lib/config.js';
+import { generateStandaloneTypeArtifacts, validateStandaloneSchemaForWarnings, } from '../src/utils/standaloneTypes.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);
+        fs.mkdirSync(config.getStandaloneTypeSrcDir(), { recursive: true });
+        fs.mkdirSync(config.getStandaloneTypeDistDir(), { recursive: true });
+        for (const name of names) {
+            const schemaPath = config.getStandaloneSchemaPath(`${name}.json`);
+            if (!fs.existsSync(schemaPath)) {
+                throw new Error(`Standalone schema file not found at ${schemaPath}. Run generateStandaloneSchemas first.`);
+            }
+            const parsed = JSON.parse(fs.readFileSync(schemaPath, 'utf8'));
+            for (const warning of validateStandaloneSchemaForWarnings(parsed))
+                console.warn(warning);
+            const artifacts = generateStandaloneTypeArtifacts(name);
+            fs.writeFileSync(config.getStandaloneTypeSrcPath(artifacts.dtsFileName), artifacts.dtsContent, 'utf8');
+            fs.writeFileSync(config.getStandaloneTypeDistPath(artifacts.dtsFileName), artifacts.dtsContent, 'utf8');
+            fs.writeFileSync(config.getStandaloneTypeSrcPath(artifacts.jsFileName), artifacts.jsContent, 'utf8');
+            fs.writeFileSync(config.getStandaloneTypeDistPath(artifacts.jsFileName), artifacts.jsContent, 'utf8');
+            console.log(`Wrote ${config.getStandaloneTypeSrcPath(artifacts.dtsFileName)}`);
+            console.log(`Wrote ${config.getStandaloneTypeSrcPath(artifacts.jsFileName)}`);
+            console.log(`Wrote ${config.getStandaloneTypeDistPath(artifacts.dtsFileName)}`);
+            console.log(`Wrote ${config.getStandaloneTypeDistPath(artifacts.jsFileName)}`);
+        }
+    }
+    catch (error) {
+        console.error(error?.message ?? error);
+        process.exitCode = 1;
+    }
+}
+main();

package/dist/scripts/generateStandaloneZodSchemas.d.ts

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