@toolproof-core/genesis 1.0.53 → 1.0.54

package/src/implementations/tools.ts

@@ -1,214 +0,0 @@
-import type {
-    Boolean,
-    Natural,
-    ResourceType,
-    Tool,
-} from '../../generated-src/types/types.js';
-
-type GenericAssignmentByRoleName<GenericRoleName extends string> = Record<GenericRoleName, ResourceType>;
-
-type InstantiationToolHandleBySpecializationKey = Record<string, Tool>;
-
-type TemplateInputs<GenericRoleName extends string> = {
-    GenericAssignmentByRoleName: GenericAssignmentByRoleName<GenericRoleName>;
-    InstantiationToolHandleBySpecializationKey: InstantiationToolHandleBySpecializationKey;
-};
-
-type TemplateOutputs = {
-    InstantiationTool: Tool;
-};
-
-type OperandTemplateInputs = TemplateInputs<'OperandType'>;
-
-const OPERAND_TYPE_ROLE_NAMES = ['OperandType'] as const;
-
-function assertExactKeys(actualKeys: string[], expectedKeys: readonly string[], label: string): void {
-    const sortedActualKeys = [...actualKeys].sort();
-    const sortedExpectedKeys = [...expectedKeys].sort();
-
-    if (sortedActualKeys.length !== sortedExpectedKeys.length) {
-        throw new Error(
-            `${label} must contain exactly [${sortedExpectedKeys.join(', ')}], got [${sortedActualKeys.join(', ')}]`
-        );
-    }
-
-    for (let index = 0; index < sortedExpectedKeys.length; index += 1) {
-        if (sortedActualKeys[index] !== sortedExpectedKeys[index]) {
-            throw new Error(
-                `${label} must contain exactly [${sortedExpectedKeys.join(', ')}], got [${sortedActualKeys.join(', ')}]`
-            );
-        }
-    }
-}
-
-function asNatural(value: number, label: string): Natural {
-    if (!Number.isInteger(value) || value < 0) {
-        throw new Error(`${label} must be a non-negative integer, got ${value}`);
-    }
-
-    return value as Natural;
-}
-
-export function createSpecializationKey(assignments: Record<string, ResourceType>): string {
-    return JSON.stringify(
-        Object.entries(assignments)
-            .sort(([leftRoleName], [rightRoleName]) => leftRoleName.localeCompare(rightRoleName))
-            .map(([roleName, resourceType]) => [roleName, resourceType.handle])
-    );
-}
-
-function resolveTemplateInstantiation<GenericRoleName extends string>(
-    inputs: TemplateInputs<GenericRoleName>,
-    expectedGenericRoleNames: readonly GenericRoleName[]
-): TemplateOutputs {
-    const { GenericAssignmentByRoleName, InstantiationToolHandleBySpecializationKey } = inputs;
-
-    assertExactKeys(
-        Object.keys(GenericAssignmentByRoleName),
-        expectedGenericRoleNames,
-        'GenericAssignmentByRoleName'
-    );
-
-    const specializationKey = createSpecializationKey(GenericAssignmentByRoleName);
-    const instantiationTool = InstantiationToolHandleBySpecializationKey[specializationKey];
-
-    if (!instantiationTool) {
-        throw new Error(`No instantiation tool registered for specializationKey ${specializationKey}`);
-    }
-
-    return {
-        InstantiationTool: instantiationTool,
-    };
-}
-
-export function Identity(inputs: OperandTemplateInputs): TemplateOutputs {
-    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
-}
-
-export function Add(inputs: OperandTemplateInputs): TemplateOutputs {
-    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
-}
-
-export function Subtract(inputs: OperandTemplateInputs): TemplateOutputs {
-    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
-}
-
-export function Multiply(inputs: OperandTemplateInputs): TemplateOutputs {
-    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
-}
-
-export function Divide(inputs: OperandTemplateInputs): TemplateOutputs {
-    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
-}
-
-export function Double(inputs: OperandTemplateInputs): TemplateOutputs {
-    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
-}
-
-export function LessThan(inputs: OperandTemplateInputs): TemplateOutputs {
-    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
-}
-
-export function BooleanIdentity(inputs: { In: Boolean }): { Out: Boolean } {
-    return {
-        Out: inputs.In,
-    };
-}
-
-export function NaturalIdentity(inputs: { In: Natural }): { Out: Natural } {
-    return {
-        Out: inputs.In,
-    };
-}
-
-export function NaturalLessThan(inputs: {
-    LessThanSource: Natural;
-    LessThanTarget: Natural;
-}): { LessThanDecision: Boolean } {
-    return {
-        LessThanDecision: inputs.LessThanSource < inputs.LessThanTarget,
-    };
-}
-
-export function NaturalAdd(inputs: {
-    AddendOne: Natural;
-    AddendTwo: Natural;
-}): { Sum: Natural } {
-    return {
-        Sum: asNatural(inputs.AddendOne + inputs.AddendTwo, 'Sum'),
-    };
-}
-
-export function NaturalSubtract(inputs: {
-    Minuend: Natural;
-    Subtrahend: Natural;
-}): { Difference: Natural } {
-    return {
-        Difference: asNatural(inputs.Minuend - inputs.Subtrahend, 'Difference'),
-    };
-}
-
-export function NaturalMultiply(inputs: {
-    Multiplicand: Natural;
-    Multiplier: Natural;
-}): { Product: Natural } {
-    return {
-        Product: asNatural(inputs.Multiplicand * inputs.Multiplier, 'Product'),
-    };
-}
-
-export function NaturalDivide(inputs: {
-    Dividend: Natural;
-    Divisor: Natural;
-}): { Quotient: Natural; Remainder: Natural } {
-    if (inputs.Divisor === 0) {
-        throw new Error('Divisor must be non-zero');
-    }
-
-    return {
-        Quotient: asNatural(Math.floor(inputs.Dividend / inputs.Divisor), 'Quotient'),
-        Remainder: asNatural(inputs.Dividend % inputs.Divisor, 'Remainder'),
-    };
-}
-
-export function NaturalDouble(inputs: { N: Natural }): { Doubled: Natural } {
-    return {
-        Doubled: asNatural(inputs.N * 2, 'Doubled'),
-    };
-}
-
-export const TOOL_IMPLEMENTATION_BY_NAME = {
-    Identity,
-    Add,
-    Subtract,
-    Multiply,
-    Divide,
-    Double,
-    LessThan,
-    BooleanIdentity,
-    NaturalIdentity,
-    NaturalLessThan,
-    NaturalAdd,
-    NaturalSubtract,
-    NaturalMultiply,
-    NaturalDivide,
-    NaturalDouble,
-} as const;
-
-export const TOOL_IMPLEMENTATION_BY_HANDLE = {
-    'TOOL-Identity': Identity,
-    'TOOL-Add': Add,
-    'TOOL-Subtract': Subtract,
-    'TOOL-Multiply': Multiply,
-    'TOOL-Divide': Divide,
-    'TOOL-Double': Double,
-    'TOOL-LessThan': LessThan,
-    'TOOL-BooleanIdentity': BooleanIdentity,
-    'TOOL-NaturalIdentity': NaturalIdentity,
-    'TOOL-NaturalLessThan': NaturalLessThan,
-    'TOOL-NaturalAdd': NaturalAdd,
-    'TOOL-NaturalSubtract': NaturalSubtract,
-    'TOOL-NaturalMultiply': NaturalMultiply,
-    'TOOL-NaturalDivide': NaturalDivide,
-    'TOOL-NaturalDouble': NaturalDouble,
-} as const;

package/src/index.ts

@@ -1,131 +0,0 @@
-// Re-export JSON schemas via .ts shims to avoid .json re-exports in declarations
-export { default as Schemas } from '../generated-src/schemas/schemas.js';
-
-export { default as ResourceTypeSchema } from '../generated-src/schemas/standalone/ResourceType.js';
-export { default as ToolSchema } from '../generated-src/schemas/standalone/Tool.js';
-export { default as StrategySchema } from '../generated-src/schemas/standalone/Strategy.js';
-export { default as StrategyTraceSchema } from '../generated-src/schemas/standalone/StrategyTrace.js';
-
-// Re-export generated Zod validators
-export { ToolSchema as ZodToolSchema } from '../generated-src/schemas/zod/Tool.js';
-export { ResourceTypeSchema as ZodResourceTypeSchema } from '../generated-src/schemas/zod/ResourceType.js';
-export { StrategySchema as ZodStrategySchema } from '../generated-src/schemas/zod/Strategy.js';
-export { StrategyTraceSchema as ZodStrategyTraceSchema } from '../generated-src/schemas/zod/StrategyTrace.js';
-export { GoalSchema as ZodGoalSchema } from '../generated-src/schemas/zod/Goal.js';
-export * as ZodSchemas from '../generated-src/schemas/zod/index.js';
-
-export { default as ResourceTypeTimestampedResources } from '../generated-src/timestampedResources/resourceTypes.js';
-
-export {
-    Add,
-    BooleanIdentity,
-    createSpecializationKey,
-    Divide,
-    Double,
-    Identity,
-    LessThan,
-    Multiply,
-    NaturalAdd,
-    NaturalDivide,
-    NaturalDouble,
-    NaturalIdentity,
-    NaturalLessThan,
-    NaturalMultiply,
-    NaturalSubtract,
-    Subtract,
-    TOOL_IMPLEMENTATION_BY_HANDLE,
-    TOOL_IMPLEMENTATION_BY_NAME,
-} from '../generated-src/implementations/tools.js';
-
-export { default as CONSTANTS } from '../generated-src/lookups/constants.js';
-export { default as MAPPINGS } from '../generated-src/lookups/mappings.js';
-
-export type {
-    ResourceTypeResource,
-} from '../generated-src/types/standalone/ResourceTypeResource.js';
-export type {
-    ToolResource,
-} from '../generated-src/types/standalone/ToolResource.js';
-export type {
-    StrategyResource,
-} from '../generated-src/types/standalone/StrategyResource.js';
-export type {
-    StrategyTraceResource,
-} from '../generated-src/types/standalone/StrategyTraceResource.js';
-
-export type {
-    BaseResource,
-    BaseStrategy,
-    BaseToolStepPathSpec,
-    Boolean,
-    BranchStep,
-    Case,
-    ContainerKind,
-    DeferredStrategyProvenance,
-    Description,
-    DescriptionFacet,
-    DocumentationSpec,
-    ExternalInputPotential,
-    GenesisProvenance,
-    Goal,
-    InputPotential,
-    InputResource,
-    InternalInputPotential,
-    JsonSchemaObject,
-    JsonSchemaObject1,
-    JsonSchemaObject2,
-    Name,
-    NameFacet,
-    Natural,
-    OutputAddress,
-    Provenance,
-    ProvenanceFacet,
-    ProvenanceKind,
-    Resource,
-    ResourceId,
-    ResourcePointer,
-    ResourceType,
-    ResourceTypeHandle,
-    RoleBindingSpec,
-    RoleBindingSpecFacet,
-    RoleBindingSpecFacet1,
-    RoleName,
-    RoleNameArray,
-    RoleSpec,
-    RoleSpecFacet,
-    RoleValue,
-    RoleValueByName,
-    Step,
-    StepArray,
-    StepArrayArray,
-    StepKind,
-    StepKindFacet,
-    Strategy,
-    StrategyHandle,
-    StrategyKind,
-    StrategyProvenance,
-    StrategyStateInputEntry,
-    StrategyStateInputEntryByRoleName,
-    StrategyStateInputKind,
-    StrategyTrace,
-    StrategyTraceHandle,
-    ThreadedStrategy,
-    ThreadedStrategyState,
-    ThreadedStrategyStateFacet,
-    ThreadedToolStepPath,
-    ThreadedToolStepPathSpec,
-    Tool,
-    ToolHandle,
-    ToolStep,
-    ToolStepPath,
-    ToolStepPathSlot,
-    ToolStepPathSlotFacet,
-    TypeRef,
-    UnthreadedStrategy,
-    UnthreadedStrategyState,
-    UnthreadedStrategyStateFacet,
-    UnthreadedToolStepPath,
-    UnthreadedToolStepPathSpec,
-    WhileStep,
-    ForStep,
-} from '../generated-src/types/types.js';

package/src/utils/constantsAndMappings.ts

@@ -1,361 +0,0 @@
-type JSONValue = null | boolean | number | string | JSONValue[] | { [k: string]: JSONValue };
-
-type HandleRecord = {
-    handle?: unknown;
-};
-
-type HandleRecordByName = Record<string, HandleRecord>;
-
-type RoleValueByNameRecord = Record<string, unknown>;
-
-type RoleSpecRecord = {
-    inputRoleValueByName?: unknown;
-    outputRoleValueByName?: unknown;
-};
-
-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 = {
-    IdentifierNameToPrefix: Record<string, string>;
-};
-
-function deriveIdPrefixFromPattern(pattern: string): string | undefined {
-    const match = /^\^([^$]+)\.\+\$$/.exec(pattern);
-    if (!match) return undefined;
-
-    const prefix = match[1];
-    if (!prefix || /[`\n\r]/.test(prefix)) return undefined;
-
-    return prefix;
-}
-
-export function extractHandlePrefixes(schema: unknown): Record<string, string> {
-    if (!schema || typeof schema !== 'object') return {};
-
-    const defs = (schema as { $defs?: unknown }).$defs;
-    if (!defs || typeof defs !== 'object') return {};
-
-    const defEntries = Object.entries(defs as Record<string, unknown>);
-    defEntries.sort(([a], [b]) => a.localeCompare(b));
-
-    const out: Record<string, string> = {};
-
-    for (const [defName, defVal] of defEntries) {
-        if (!/(Id|Handle)$/.test(defName)) continue;
-        if (!defVal || typeof defVal !== 'object' || Array.isArray(defVal)) continue;
-
-        const value = defVal as { type?: unknown; pattern?: unknown };
-        if (value.type !== 'string') continue;
-        if (typeof value.pattern !== 'string') continue;
-
-        const prefix = deriveIdPrefixFromPattern(value.pattern);
-        if (!prefix) continue;
-
-        out[defName] = prefix;
-    }
-
-    return out;
-}
-
-export function extractSubschemaNames(schema: unknown): Record<string, string> {
-    if (!schema || typeof schema !== 'object') return {};
-
-    const defs = (schema as { $defs?: unknown }).$defs;
-    if (!defs || typeof defs !== 'object') return {};
-
-    const defEntries = Object.entries(defs as Record<string, unknown>);
-    defEntries.sort(([a], [b]) => a.localeCompare(b));
-
-    const out: Record<string, string> = {};
-    for (const [defName] of defEntries) {
-        if (!defName || /[\n\r`]/.test(defName)) continue;
-        out[defName] = defName;
-    }
-
-    return out;
-}
-
-export function extractEnums(schema: unknown): Record<string, Record<string, string>> {
-    if (!schema || typeof schema !== 'object') return {};
-
-    const defs = (schema as { $defs?: unknown }).$defs;
-    if (!defs || typeof defs !== 'object') return {};
-
-    const defEntries = Object.entries(defs as Record<string, unknown>);
-    defEntries.sort(([a], [b]) => a.localeCompare(b));
-
-    const out: Record<string, Record<string, string>> = {};
-
-    for (const [defName, defVal] of defEntries) {
-        if (!/(Kind|Status)$/.test(defName)) continue;
-        if (!defVal || typeof defVal !== 'object' || Array.isArray(defVal)) continue;
-
-        const value = defVal as { type?: unknown; enum?: unknown };
-        if (value.type !== 'string') continue;
-        if (!Array.isArray(value.enum) || value.enum.length === 0) continue;
-        if (value.enum.some((item) => typeof item !== 'string')) continue;
-
-        const members: Record<string, string> = {};
-        for (const member of value.enum as readonly string[]) {
-            members[member] = member;
-        }
-
-        out[defName] = members;
-    }
-
-    return out;
-}
-
-function toHandleConstantKey(handle: string): string {
-    return handle.replace(/[^A-Za-z0-9]+/g, '_');
-}
-
-export function extractHandles(records: HandleRecordByName): Record<string, string> {
-    const recordEntries = Object.entries(records);
-    recordEntries.sort(([a], [b]) => a.localeCompare(b));
-
-    const out: Record<string, string> = {};
-
-    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: unknown): value is Record<string, unknown> {
-    return !!value && typeof value === 'object' && !Array.isArray(value);
-}
-
-function extractRoleNameMap(roleSpec: unknown): Record<string, string> {
-    if (!isPlainObject(roleSpec)) {
-        return {};
-    }
-
-    const out: Record<string, string> = {};
-    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: ToolRecord): boolean {
-    if (tool.isTemplate === true) {
-        return true;
-    }
-
-    return tool.isTemplate === false && tool.templateToolHandle === undefined;
-}
-
-export function extractToolRoleNames(tools: ToolRecordByName): Record<string, Record<string, string>> {
-    const toolEntries = Object.values(tools)
-        .filter((tool): tool is ToolRecord => isPlainObject(tool))
-        .filter((tool) => typeof tool.handle === 'string' && !!tool.handle)
-        .sort((a, b) => String(a.handle).localeCompare(String(b.handle)));
-
-    const out: Record<string, Record<string, string>> = {};
-
-    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 as string)] = roleNameMap;
-    }
-
-    return out;
-}
-
-export function extractGeneratedConstantsAndMappings(
-    schema: JSONValue,
-    resourceTypeShells: HandleRecordByName,
-    tools: ToolRecordByName,
-): {
-    CONSTANTS: GeneratedConstants;
-    MAPPINGS: GeneratedMappings;
-} {
-    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: {
-            IdentifierNameToPrefix: handlePrefixes,
-        },
-    };
-}
-
-function escapeTsString(value: string): string {
-    return value
-        .replace(/\\/g, '\\\\')
-        .replace(/\r/g, '\\r')
-        .replace(/\n/g, '\\n')
-        .replace(/\t/g, '\\t')
-        .replace(/'/g, "\\'");
-}
-
-function renderTsStringLiteral(value: string): string {
-    return `'${escapeTsString(value)}'`;
-}
-
-function isValidTsIdentifier(key: string): boolean {
-    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key);
-}
-
-function renderTsKey(key: string): string {
-    return isValidTsIdentifier(key) ? key : renderTsStringLiteral(key);
-}
-
-export function renderConstantsTs(constants: GeneratedConstants): string {
-    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: string[] = [];
-    lines.push('const CONSTANTS = {');
-    lines.push('    Names: {');
-
-    for (const key of nameKeys) {
-        const value = constants.Names[key] ?? '';
-        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] ?? {};
-        lines.push(`        ${renderTsKey(key)}: {`);
-
-        for (const memberKey of Object.keys(members)) {
-            const value = members[memberKey] ?? '';
-            lines.push(`            ${renderTsKey(memberKey)}: ${renderTsStringLiteral(value)},`);
-        }
-
-        lines.push('        },');
-    }
-
-    lines.push('    }');
-    lines.push('} as const;');
-    lines.push('');
-    lines.push('export default CONSTANTS;');
-    lines.push('');
-
-    return lines.join('\n');
-}
-
-export function renderMappingsTs(mappings: GeneratedMappings): string {
-    const handleKeys = Object.keys(mappings.IdentifierNameToPrefix).sort((a, b) => a.localeCompare(b));
-
-    const lines: string[] = [];
-    lines.push('const MAPPINGS = {');
-    lines.push('    IdentifierNameToPrefix: {');
-
-    for (const key of handleKeys) {
-        const value = mappings.IdentifierNameToPrefix[key] ?? '';
-        lines.push(`        ${renderTsKey(key)}: ${renderTsStringLiteral(value)},`);
-    }
-
-    lines.push('    },');
-    lines.push('} as const;');
-    lines.push('');
-    lines.push('export default MAPPINGS;');
-    lines.push('');
-
-    return lines.join('\n');
-}