runtypex 0.1.13 → 0.2.1

package/dist/esm/core/emitMapperFromSpec.js

@@ -0,0 +1,189 @@
+import ts from "typescript";
+import { emitGuardFromType } from "./index.js";
+import { emitPathAccess } from "./path.js";
+export function emitMapperFromSpec(params) {
+    // Resolve the concrete object literal so generated code does not retain DSL calls.
+    const specObject = resolveMapSpecObject(params.checker, params.specNode);
+    if (!specObject)
+        return null;
+    handleMapPolicyViolations(findMapPolicyViolations(params.checker, specObject, params.options?.mappingPolicy), params.options?.policyMode ?? "warn");
+    const rules = readMapRules(params.checker, specObject);
+    const props = params.checker.getPropertiesOfType(params.domainType);
+    const fields = [];
+    for (const prop of props) {
+        const rule = rules.get(prop.name);
+        if (!rule)
+            return null;
+        fields.push(`${JSON.stringify(prop.name)}:R(${JSON.stringify(prop.name)},${emitPathAccess("input", rule.from)})`);
+    }
+    const specText = _emitRuntimeSpecText(specObject, params.sourceFile);
+    const dtoGuard = params.options?.validateDto === false ? null : emitGuardFromType(params.checker, params.dtoType);
+    const domainGuard = params.options?.validateDomain === false ? null : emitGuardFromType(params.checker, params.domainType);
+    return [
+        `(function(){const S=${specText};`,
+        dtoGuard ? `const VD=${dtoGuard};` : "",
+        domainGuard ? `const VO=${domainGuard};` : "",
+        `return(input)=>{`,
+        dtoGuard ? `if(!VD(input))throw new TypeError("[runtypex] DTO validation failed.");` : "",
+        `const R=(key,raw)=>{const rule=S[key];const value=raw===undefined&&Object.prototype.hasOwnProperty.call(rule,"default")?rule.default:raw;return typeof rule.transform==="function"?rule.transform(value,input):value;};`,
+        `const output={${fields.join(",")}};`,
+        domainGuard ? `if(!VO(output))throw new TypeError("[runtypex] Domain validation failed.");` : "",
+        `return output;};})()`,
+    ].join("");
+}
+export function readMapRules(checker, specNode) {
+    const object = resolveMapSpecObject(checker, specNode);
+    const rules = new Map();
+    if (!object)
+        return rules;
+    for (const prop of object.properties) {
+        if (!ts.isPropertyAssignment(prop))
+            continue;
+        const key = _propertyName(prop.name);
+        const rule = _readRule(prop.initializer);
+        if (key && rule)
+            rules.set(key, { key, ...rule });
+    }
+    return rules;
+}
+export function findMapPolicyViolations(checker, specNode, policyNode) {
+    if (!policyNode)
+        return [];
+    const rules = readMapRules(checker, specNode);
+    const policyRules = readMapRules(checker, policyNode);
+    const canonicalByPath = new Map();
+    const violations = [];
+    for (const rule of policyRules.values()) {
+        const existing = canonicalByPath.get(rule.from);
+        if (existing && existing !== rule.key) {
+            violations.push({ from: rule.from, expectedKey: existing, actualKey: rule.key });
+            continue;
+        }
+        canonicalByPath.set(rule.from, rule.key);
+    }
+    violations.push(...Array.from(rules.values()).flatMap((rule) => {
+        const expected = canonicalByPath.get(rule.from);
+        return expected && expected !== rule.key
+            ? [{ from: rule.from, expectedKey: expected, actualKey: rule.key }]
+            : [];
+    }));
+    return violations;
+}
+export function handleMapPolicyViolations(violations, mode) {
+    if (!violations.length)
+        return;
+    const details = violations
+        .map((item) => `DTO path "${item.from}" is canonically mapped as "${item.expectedKey}", but this map uses "${item.actualKey}".`)
+        .join("\n");
+    const message = `[runtypex/mapper] Mapping policy violation:\n${details}`;
+    if (mode === "error")
+        throw new Error(message);
+    console.warn(message);
+}
+/** Finds the mapping object behind inline, defineMap-wrapped, or identifier specs. */
+export function resolveMapSpecObject(checker, node) {
+    const expr = _skip(node);
+    if (ts.isObjectLiteralExpression(expr))
+        return expr;
+    if (ts.isCallExpression(expr) && expr.arguments[0]) {
+        const arg = _skip(expr.arguments[0]);
+        if (ts.isObjectLiteralExpression(arg))
+            return arg;
+    }
+    if (ts.isCallExpression(expr) && ts.isCallExpression(expr.expression)) {
+        return resolveMapSpecObject(checker, expr.expression);
+    }
+    if (ts.isIdentifier(expr)) {
+        const symbol = checker.getShorthandAssignmentValueSymbol?.(expr) ?? checker.getSymbolAtLocation(expr);
+        const declaration = symbol?.valueDeclaration ?? symbol?.declarations?.[0];
+        if (declaration && ts.isVariableDeclaration(declaration) && declaration.initializer) {
+            return resolveMapSpecObject(checker, declaration.initializer);
+        }
+        const variable = _findVariableDeclaration(expr.getSourceFile(), expr.text, expr.getStart(expr.getSourceFile()));
+        if (variable?.initializer)
+            return resolveMapSpecObject(checker, variable.initializer);
+    }
+    return null;
+}
+function _readRule(node) {
+    const expr = _skip(node);
+    if (ts.isObjectLiteralExpression(expr)) {
+        return _readRuleObject(expr);
+    }
+    if (ts.isCallExpression(expr) && expr.arguments[0]) {
+        const from = _stringValue(expr.arguments[0]);
+        const metadata = expr.arguments.length > 2 ? expr.arguments[2] : expr.arguments[1];
+        if (!from)
+            return null;
+        return { from, ..._readMetadata(metadata) };
+    }
+    return null;
+}
+function _readRuleObject(object) {
+    const from = _readStringProperty(object, "from");
+    if (!from)
+        return null;
+    return {
+        from,
+        db: _readStringProperty(object, "db") ?? undefined,
+        description: _readStringProperty(object, "description") ?? undefined,
+        dtoDescription: _readStringProperty(object, "dtoDescription") ?? undefined,
+    };
+}
+function _readMetadata(node) {
+    const expr = node ? _skip(node) : null;
+    if (!expr || !ts.isObjectLiteralExpression(expr))
+        return {};
+    return {
+        db: _readStringProperty(expr, "db") ?? undefined,
+        description: _readStringProperty(expr, "description") ?? undefined,
+        dtoDescription: _readStringProperty(expr, "dtoDescription") ?? undefined,
+    };
+}
+function _readStringProperty(object, name) {
+    const prop = object.properties.find((item) => ts.isPropertyAssignment(item) && _propertyName(item.name) === name);
+    return prop ? _stringValue(prop.initializer) : null;
+}
+function _skip(node) {
+    let expr = node;
+    while (ts.isParenthesizedExpression(expr) || ts.isAsExpression(expr) || ts.isTypeAssertionExpression(expr)) {
+        expr = expr.expression;
+    }
+    return expr;
+}
+function _propertyName(name) {
+    if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name))
+        return name.text;
+    return null;
+}
+function _stringValue(node) {
+    if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node))
+        return node.text;
+    return null;
+}
+function _findVariableDeclaration(sourceFile, name, before) {
+    let found = null;
+    const visit = (node) => {
+        if (ts.isVariableDeclaration(node) &&
+            ts.isIdentifier(node.name) &&
+            node.name.text === name &&
+            node.getStart(sourceFile) < before) {
+            found = node;
+        }
+        node.forEachChild(visit);
+    };
+    visit(sourceFile);
+    return found;
+}
+function _emitRuntimeSpecText(specObject, sourceFile) {
+    // Remove TypeScript-only syntax from inline transform callbacks before embedding.
+    const marker = "__runtypexSpec";
+    const output = ts.transpileModule(`const ${marker} = ${specObject.getText(sourceFile)};`, {
+        compilerOptions: {
+            module: ts.ModuleKind.ESNext,
+            target: ts.ScriptTarget.ESNext,
+        },
+    }).outputText.trim();
+    const prefix = `const ${marker} = `;
+    return output.startsWith(prefix) ? output.slice(prefix.length).replace(/;$/, "") : specObject.getText(sourceFile);
+}

package/dist/esm/core/emitObject.d.ts

@@ -1,5 +1,5 @@
 import ts from "typescript";
-import type { GenContext } from "./index";
+import type { GenContext } from "./index.js";
 /**
  * Handles interfaces, classes, and object-like structures.
  */

package/dist/esm/core/emitObject.js

@@ -1,4 +1,5 @@
 import ts from "typescript";
+import { emitPropertyAccess } from "./path.js";
 /**
  * Handles interfaces, classes, and object-like structures.
  */
@@ -14,8 +15,9 @@ export function emitObject(ctx, expr, t) {
             continue;
         const propType = ctx.checker.getTypeOfSymbolAtLocation(prop, declaration);
         const isOptional = (prop.getFlags() & ts.SymbolFlags.Optional) !== 0;
-        const condition = ctx.emit(`${expr}.${prop.name}`, propType);
-        const checkExpr = isOptional ? `(${expr}.${prop.name}===undefined||${condition})` : condition;
+        const propExpr = emitPropertyAccess(expr, prop.name);
+        const condition = ctx.emit(propExpr, propType);
+        const checkExpr = isOptional ? `(${propExpr}===undefined||${condition})` : condition;
         parts.push(checkExpr);
     }
     return `(${parts.join("&&")})`;

package/dist/esm/core/emitPrimitive.d.ts

@@ -1,5 +1,5 @@
 import ts from "typescript";
-import type { GenContext } from "./index";
+import type { GenContext } from "./index.js";
 /**
  * Handles primitive types like number, string, boolean...
  */

package/dist/esm/core/emitUnionOrIntersection.d.ts

@@ -1,5 +1,5 @@
 import ts from "typescript";
-import type { GenContext } from "./index";
+import type { GenContext } from "./index.js";
 /**
  * Handles union (A | B) and intersection (A & B) types.
  */

package/dist/esm/core/path.d.ts

@@ -0,0 +1,9 @@
+export type PathSegment = string | number;
+/** Splits a mapper path into object keys and numeric array indexes. */
+export declare function parsePath(path: string): PathSegment[];
+/** Runtime fallback reader used when mapper calls are not transformed. */
+export declare function getByPath(value: unknown, path: string): unknown;
+/** Emits bracket-only access for user-authored DTO paths. */
+export declare function emitPathAccess(root: string, path: string): string;
+/** Emits compact dot access when safe, with bracket fallback for quoted keys. */
+export declare function emitPropertyAccess(root: string, property: string | number): string;

package/dist/esm/core/path.js

@@ -0,0 +1,36 @@
+/** Splits a mapper path into object keys and numeric array indexes. */
+export function parsePath(path) {
+    if (!path)
+        return [];
+    return path.split(".").map((segment) => {
+        if (/^(0|[1-9]\d*)$/.test(segment))
+            return Number(segment);
+        return segment;
+    });
+}
+/** Runtime fallback reader used when mapper calls are not transformed. */
+export function getByPath(value, path) {
+    let current = value;
+    for (const segment of parsePath(path)) {
+        if (current == null)
+            return undefined;
+        current = current[segment];
+    }
+    return current;
+}
+/** Emits bracket-only access for user-authored DTO paths. */
+export function emitPathAccess(root, path) {
+    return parsePath(path).reduce((expr, segment) => {
+        if (typeof segment === "number")
+            return `${expr}[${segment}]`;
+        return `${expr}[${JSON.stringify(segment)}]`;
+    }, root);
+}
+/** Emits compact dot access when safe, with bracket fallback for quoted keys. */
+export function emitPropertyAccess(root, property) {
+    if (typeof property === "number")
+        return `${root}[${property}]`;
+    if (/^[A-Za-z_$][\w$]*$/.test(property))
+        return `${root}.${property}`;
+    return `${root}[${JSON.stringify(property)}]`;
+}

package/dist/esm/generator/generate-jsdoc.d.ts

@@ -0,0 +1,13 @@
+import ts from "typescript";
+export type GenerateJSDocOptions = {
+    name?: string;
+    mappingPolicy?: ts.Expression;
+    policyMode?: "warn" | "error";
+};
+export declare function generateJSDocFromSpec(params: {
+    checker: ts.TypeChecker;
+    dtoType: ts.Type;
+    domainType: ts.Type;
+    specNode: ts.Expression;
+    options?: GenerateJSDocOptions;
+}): string;

package/dist/esm/generator/generate-jsdoc.js

@@ -0,0 +1,97 @@
+import ts from "typescript";
+import { parsePath } from "../core/path.js";
+import { findMapPolicyViolations, handleMapPolicyViolations, readMapRules } from "../core/emitMapperFromSpec.js";
+const JSDOC_CONTENT_WIDTH = 76;
+export function generateJSDocFromSpec(params) {
+    const checker = params.checker;
+    const dtoName = params.dtoType.symbol?.name ?? "Dto";
+    const name = params.options?.name ?? params.domainType.symbol?.name ?? "GeneratedDomain";
+    const rules = readMapRules(checker, params.specNode);
+    const lines = [`export interface ${name} {`];
+    handleMapPolicyViolations(findMapPolicyViolations(checker, params.specNode, params.options?.mappingPolicy), params.options?.policyMode ?? "warn");
+    // Each domain property gets source metadata that editors can show on hover.
+    for (const prop of checker.getPropertiesOfType(params.domainType)) {
+        const rule = rules.get(prop.name);
+        if (!rule)
+            throw new Error(`[runtypex/generator] ${name}.${prop.name} is not mapped.`);
+        const declaration = prop.valueDeclaration ?? prop.declarations?.[0];
+        const domainType = declaration ? checker.getTypeOfSymbolAtLocation(prop, declaration) : checker.getAnyType();
+        const dtoPathType = _getTypeAtPath(checker, params.dtoType, rule.from);
+        const description = _getDomainDescription(checker, prop) ?? rule.description;
+        const optional = (prop.getFlags() & ts.SymbolFlags.Optional) !== 0 ? "?" : "";
+        lines.push("  /**");
+        if (description) {
+            _pushJSDocText(lines, _escapeComment(description));
+            lines.push("   *");
+        }
+        _pushJSDocField(lines, "DTO", `${dtoName}.${rule.from}`);
+        if (rule.dtoDescription) {
+            _pushJSDocText(lines, _escapeComment(rule.dtoDescription), "     ");
+        }
+        _pushJSDocField(lines, "DTO type", dtoPathType ? checker.typeToString(dtoPathType) : "unknown");
+        if (rule.db)
+            _pushJSDocField(lines, "DB", _escapeComment(rule.db));
+        _pushJSDocField(lines, "Domain type", checker.typeToString(domainType));
+        lines.push("   */");
+        lines.push(`  ${_propertyName(prop.name)}${optional}: ${checker.typeToString(domainType)};`);
+        lines.push("");
+    }
+    lines.push("}");
+    return lines.join("\n");
+}
+/** Resolves the DTO type reached by a mapping path such as profile.name or items.0.id. */
+function _getTypeAtPath(checker, root, path) {
+    let current = root;
+    for (const segment of parsePath(path)) {
+        if (!current)
+            return null;
+        if (typeof segment === "number") {
+            current =
+                checker.getElementTypeOfArrayType?.(current) ??
+                    current.typeArguments?.[segment] ??
+                    current.getNumberIndexType?.() ??
+                    null;
+            continue;
+        }
+        const prop = checker.getPropertyOfType(current, segment);
+        const declaration = prop?.valueDeclaration ?? prop?.declarations?.[0];
+        current = prop && declaration ? checker.getTypeOfSymbolAtLocation(prop, declaration) : null;
+    }
+    return current;
+}
+function _propertyName(name) {
+    return /^[A-Za-z_$][\w$]*$/.test(name) ? name : JSON.stringify(name);
+}
+function _escapeComment(value) {
+    return value.replace(/\*\//g, "* /");
+}
+function _getDomainDescription(checker, prop) {
+    const description = ts.displayPartsToString(prop.getDocumentationComment(checker)).trim();
+    return description || null;
+}
+function _pushJSDocField(lines, label, value) {
+    _pushJSDocText(lines, `${label}: ${value}`, "", " ".repeat(label.length + 2));
+}
+function _pushJSDocText(lines, text, firstIndent = "", continuationIndent = firstIndent) {
+    for (const line of _wrapJSDocText(text, firstIndent, continuationIndent)) {
+        lines.push(`   * ${line}`);
+    }
+}
+function _wrapJSDocText(text, firstIndent, continuationIndent) {
+    const words = text.replace(/\s+/g, " ").trim().split(" ").filter(Boolean);
+    if (!words.length)
+        return [firstIndent.trimEnd()];
+    const lines = [];
+    let current = firstIndent;
+    for (const word of words) {
+        const candidate = current.trim().length ? `${current} ${word}` : `${current}${word}`;
+        if (candidate.length <= JSDOC_CONTENT_WIDTH || !current.trim().length) {
+            current = candidate;
+            continue;
+        }
+        lines.push(current.trimEnd());
+        current = `${continuationIndent}${word}`;
+    }
+    lines.push(current.trimEnd());
+    return lines;
+}

package/dist/esm/generator/index.d.ts

@@ -0,0 +1 @@
+export * from "./generate-jsdoc.js";

package/dist/esm/generator/index.js

@@ -0,0 +1 @@
+export * from "./generate-jsdoc.js";

package/dist/esm/index.d.ts

@@ -1,3 +1,4 @@
-export { makeValidate, makeAssert, type ValidateFn, type AssertFn } from "./runtime/validate";
-export { default as vitePlugin } from "./transformer/vite-plugin";
-export { default as tsTransformer } from "./transformer/ts-transformer";
+export { makeValidate, makeAssert, type ValidateFn, type AssertFn } from "./runtime/validate.js";
+export { defineMap, defineMappingPolicy, mapperHelpers, makeMapper, source, transform, type DefinedMap, type Mapper, type MapperOptions, type MapperMetadata, type MapRule, type MapSpec, type MappingPolicy, type MappingPolicyMode, type PathOf, } from "./runtime/mapper.js";
+export { default as vitePlugin } from "./transformer/vite-plugin.js";
+export { default as tsTransformer } from "./transformer/ts-transformer.js";

package/dist/esm/index.js

@@ -1,3 +1,4 @@
 export { makeValidate, makeAssert } from "./runtime/validate.js";
+export { defineMap, defineMappingPolicy, mapperHelpers, makeMapper, source, transform, } from "./runtime/mapper.js";
 export { default as vitePlugin } from "./transformer/vite-plugin.js";
 export { default as tsTransformer } from "./transformer/ts-transformer.js";

package/dist/esm/mapper/index.d.ts

@@ -0,0 +1 @@
+export * from "../runtime/mapper.js";

package/dist/esm/mapper/index.js

@@ -0,0 +1 @@
+export * from "../runtime/mapper.js";

package/dist/esm/runtime/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./validate.js";
+export * from "./mapper.js";

package/dist/esm/runtime/index.js

@@ -0,0 +1,2 @@
+export * from "./validate.js";
+export * from "./mapper.js";

package/dist/esm/runtime/mapper.d.ts

@@ -0,0 +1,72 @@
+type Primitive = string | number | boolean | bigint | symbol | null | undefined | Date;
+export type PathOf<T> = T extends Primitive ? never : T extends readonly (infer U)[] ? `${number}` | `${number}.${PathOf<U>}` : {
+    [K in Extract<keyof T, string>]: T[K] extends Primitive ? K : T[K] extends readonly (infer U)[] ? K | `${K}.${number}` | `${K}.${number}.${PathOf<U>}` : K | `${K}.${PathOf<T[K]>}`;
+}[Extract<keyof T, string>];
+export type Mapper<TDto, TDomain> = (dto: TDto) => TDomain;
+export type MapperMetadata<TValue = never> = {
+    db?: string;
+    /** @deprecated Prefer domain property JSDoc for domain field descriptions. */
+    description?: string;
+    dtoDescription?: string;
+    default?: TValue;
+};
+export type MapRule<TDto, TValue> = MapperMetadata<TValue> & {
+    from: PathOf<TDto>;
+    transform?: (value: unknown, dto: TDto) => TValue;
+};
+export type MapSpec<TDto, TDomain> = {
+    [K in keyof TDomain]-?: MapRule<TDto, TDomain[K]>;
+};
+export type MappingPolicy<TDto> = Record<string, MapRule<TDto, unknown>>;
+export type MappingPolicyMode = "warn" | "error";
+export type MapperOptions<TDto> = {
+    policy?: MappingPolicy<TDto>;
+    policyMode?: MappingPolicyMode;
+};
+declare const DTO_TYPE: unique symbol;
+declare const DOMAIN_TYPE: unique symbol;
+export type DefinedMap<TDto, TDomain> = MapSpec<TDto, TDomain> & {
+    readonly [DTO_TYPE]?: TDto;
+    readonly [DOMAIN_TYPE]?: TDomain;
+};
+export declare function defineMap<TDto, TDomain>(): <const TSpec extends MapSpec<TDto, TDomain>>(spec: TSpec) => TSpec & DefinedMap<TDto, TDomain>;
+/** Declares canonical DTO path -> Domain field names for consistency checks. */
+export declare function defineMappingPolicy<TDto>(): <const TSpec extends MappingPolicy<TDto>>(spec: TSpec) => TSpec;
+/** Shorthand rule for direct DTO path reads. */
+export declare function source<const TPath extends string, TValue = never>(from: TPath, metadata?: MapperMetadata<TValue>): {
+    db?: string;
+    description?: string;
+    dtoDescription?: string;
+    default?: TValue | undefined;
+    from: TPath;
+};
+/** Shorthand rule for DTO path reads that require a value conversion. */
+export declare function transform<const TPath extends string, TValue>(from: TPath, transform: (value: unknown, dto: unknown) => TValue, metadata?: MapperMetadata<TValue>): {
+    db?: string;
+    description?: string;
+    dtoDescription?: string;
+    default?: TValue | undefined;
+    from: TPath;
+    transform: (value: unknown, dto: unknown) => TValue;
+};
+/** Typed helpers for callbacks that need access to the source DTO shape. */
+export declare function mapperHelpers<TDto>(): {
+    source: <const TPath extends PathOf<TDto>, TValue = never>(from: TPath, metadata?: MapperMetadata<TValue>) => {
+        db?: string;
+        description?: string;
+        dtoDescription?: string;
+        default?: TValue | undefined;
+        from: TPath;
+    };
+    transform: <const TPath extends PathOf<TDto>, TValue>(from: TPath, transform: (value: unknown, dto: TDto) => TValue, metadata?: MapperMetadata<TValue>) => {
+        db?: string;
+        description?: string;
+        dtoDescription?: string;
+        default?: TValue | undefined;
+        from: TPath;
+        transform: (value: unknown, dto: TDto) => TValue;
+    };
+};
+/** Runtime interpreter used as fallback when the transformer is not configured. */
+export declare function makeMapper<TDto, TDomain>(spec: DefinedMap<TDto, TDomain> | MapSpec<TDto, TDomain>, options?: MapperOptions<TDto>): Mapper<TDto, TDomain>;
+export {};

package/dist/esm/runtime/mapper.js

@@ -0,0 +1,71 @@
+import { getByPath } from "../core/path.js";
+export function defineMap() {
+    return (spec) => spec;
+}
+/** Declares canonical DTO path -> Domain field names for consistency checks. */
+export function defineMappingPolicy() {
+    return (spec) => spec;
+}
+/** Shorthand rule for direct DTO path reads. */
+export function source(from, metadata) {
+    return { from, ...metadata };
+}
+/** Shorthand rule for DTO path reads that require a value conversion. */
+export function transform(from, transform, metadata) {
+    return { from, transform, ...metadata };
+}
+/** Typed helpers for callbacks that need access to the source DTO shape. */
+export function mapperHelpers() {
+    return {
+        source: (from, metadata) => source(from, metadata),
+        transform: (from, transform, metadata) => ({ from, transform, ...metadata }),
+    };
+}
+/** Runtime interpreter used as fallback when the transformer is not configured. */
+export function makeMapper(spec, options) {
+    _handlePolicyViolations(_findPolicyViolations(spec, options?.policy), options?.policyMode ?? "warn");
+    return ((dto) => {
+        const output = {};
+        for (const key of Object.keys(spec)) {
+            const rule = spec[key];
+            const raw = getByPath(dto, String(rule.from));
+            const value = raw === undefined && _hasOwn(rule, "default") ? rule.default : raw;
+            output[key] = rule.transform ? rule.transform(value, dto) : value;
+        }
+        return output;
+    });
+}
+function _hasOwn(value, key) {
+    return Object.prototype.hasOwnProperty.call(value, key);
+}
+function _findPolicyViolations(spec, policy) {
+    if (!policy)
+        return [];
+    const canonicalByPath = new Map();
+    const violations = [];
+    for (const key of Object.keys(policy)) {
+        const from = String(policy[key].from);
+        const existing = canonicalByPath.get(from);
+        if (existing && existing !== key) {
+            violations.push(`DTO path "${from}" is canonically mapped as "${existing}", but this map uses "${key}".`);
+            continue;
+        }
+        canonicalByPath.set(from, key);
+    }
+    violations.push(...Object.keys(spec).flatMap((key) => {
+        const from = String(spec[key].from);
+        const expected = canonicalByPath.get(from);
+        return expected && expected !== key
+            ? [`DTO path "${from}" is canonically mapped as "${expected}", but this map uses "${key}".`]
+            : [];
+    }));
+    return violations;
+}
+function _handlePolicyViolations(violations, mode) {
+    if (!violations.length)
+        return;
+    const message = `[runtypex/mapper] Mapping policy violation:\n${violations.join("\n")}`;
+    if (mode === "error")
+        throw new Error(message);
+    console.warn(message);
+}

package/dist/esm/transformer/index.d.ts

@@ -0,0 +1,3 @@
+export { default } from "./ts-transformer.js";
+export { default as tsTransformer } from "./ts-transformer.js";
+export { default as vitePlugin } from "./vite-plugin.js";

package/dist/esm/transformer/index.js

@@ -0,0 +1,3 @@
+export { default } from "./ts-transformer.js";
+export { default as tsTransformer } from "./ts-transformer.js";
+export { default as vitePlugin } from "./vite-plugin.js";

package/dist/esm/transformer/ts-transformer.d.ts

@@ -1,4 +1,10 @@
 import ts from "typescript";
+type TransformerOptions = {
+    program: ts.Program;
+    removeInProd?: boolean;
+    validateDto?: boolean;
+    validateDomain?: boolean;
+};
 /**
  * 🧩 tsTransformer
  * TypeScript custom transformer (BEFORE) factory.
@@ -19,7 +25,5 @@ import ts from "typescript";
  *   ✅ Validation logic embedded at build-time
  *   ✅ Optionally removed in production builds
  */
-export default function tsTransformer(options: {
-    program: ts.Program;
-    removeInProd?: boolean;
-}): (context: ts.TransformationContext) => (sf: ts.SourceFile) => ts.Node | undefined;
+export default function tsTransformer(options: TransformerOptions): ts.TransformerFactory<ts.SourceFile>;
+export {};