@zipbul/baker 5.0.0 → 5.2.0

package/dist/src/symbols.d.ts

@@ -1,8 +1,6 @@
 /**
- * 2 Symbols — zero external storage, zero global pollution
- * Uses Symbol.for: allows AOT code and runtime code to share the same Symbol via the global registry
+ * RAW symbol — zero external storage, zero global pollution.
+ * Uses Symbol.for: allows AOT code and runtime code to share the same Symbol via the global registry.
  */
 /** Tier 1 collection metadata (stored on Class[Symbol.metadata] by decorators) */
 export declare const RAW: unique symbol;
-/** Tier 2 seal result (dual executor stored on Class at seal time) */
-export declare const SEALED: unique symbol;

package/dist/src/symbols.js

@@ -1 +1 @@
-Symbol.metadata??=Symbol.for("Symbol.metadata");export const RAW=Symbol.for("baker:raw");export const SEALED=Symbol.for("baker:sealed");
+Symbol.metadata??=Symbol.for("Symbol.metadata");export const RAW=Symbol.for("baker:raw");

package/dist/src/transformers/{collection.transformer.d.ts → collection.d.ts}

@@ -1,3 +1,3 @@
-import type { Transformer } from '../types';
+import type { Transformer } from './interfaces';
 export declare function csvTransformer(separator?: string): Transformer;
 export declare const jsonTransformer: Transformer;

package/dist/src/transformers/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const LUXON_MISSING = "luxonTransformer requires the optional peer dependency 'luxon'. Install it with: bun add luxon";
+export declare const MOMENT_MISSING = "momentTransformer requires the optional peer dependency 'moment'. Install it with: bun add moment";

package/dist/src/transformers/constants.js

@@ -0,0 +1 @@
+export const LUXON_MISSING="luxonTransformer requires the optional peer dependency 'luxon'. Install it with: bun add luxon";export const MOMENT_MISSING="momentTransformer requires the optional peer dependency 'moment'. Install it with: bun add moment";

package/dist/src/transformers/{date.transformer.d.ts → date.d.ts}

@@ -1,4 +1,4 @@
-import type { Transformer } from '../types';
+import type { Transformer } from './interfaces';
 export declare const unixSecondsTransformer: Transformer;
 export declare const unixMillisTransformer: Transformer;
 export declare const isoStringTransformer: Transformer;

package/dist/src/transformers/date.js

@@ -0,0 +1 @@
+export const unixSecondsTransformer={deserialize:({value:b})=>{if(typeof b!=="number")return b;const j=new Date(b*1000);return Number.isNaN(j.getTime())?b:j},serialize:({value:b})=>b instanceof Date?Math.floor(b.getTime()/1000):b};export const unixMillisTransformer={deserialize:({value:b})=>{if(typeof b!=="number")return b;const j=new Date(b);return Number.isNaN(j.getTime())?b:j},serialize:({value:b})=>b instanceof Date?b.getTime():b};export const isoStringTransformer={deserialize:({value:b})=>{if(typeof b!=="string")return b;const j=new Date(b);return Number.isNaN(j.getTime())?b:j},serialize:({value:b})=>b instanceof Date?b.toISOString():b};

package/dist/src/transformers/index.d.ts

@@ -1,8 +1,3 @@
-export { trimTransformer, toLowerCaseTransformer, toUpperCaseTransformer } from './string.transformer';
-export { roundTransformer } from './number.transformer';
-export { unixSecondsTransformer, unixMillisTransformer, isoStringTransformer } from './date.transformer';
-export { csvTransformer, jsonTransformer } from './collection.transformer';
-export { luxonTransformer } from './luxon.transformer';
-export type { LuxonTransformerOptions } from './luxon.transformer';
-export { momentTransformer } from './moment.transformer';
-export type { MomentTransformerOptions } from './moment.transformer';
+export * from './public';
+export type { Transformer, TransformParams } from './interfaces';
+export type { TransformFunction } from './types';

package/dist/src/transformers/index.js

@@ -1 +1 @@
-export{trimTransformer,toLowerCaseTransformer,toUpperCaseTransformer}from"./string.transformer.js";export{roundTransformer}from"./number.transformer.js";export{unixSecondsTransformer,unixMillisTransformer,isoStringTransformer}from"./date.transformer.js";export{csvTransformer,jsonTransformer}from"./collection.transformer.js";export{luxonTransformer}from"./luxon.transformer.js";export{momentTransformer}from"./moment.transformer.js";
+export*from"./public.js";

package/dist/src/transformers/interfaces.d.ts

@@ -0,0 +1,26 @@
+export interface TransformParams {
+    value: unknown;
+    key: string;
+    obj: Record<string, unknown>;
+}
+export interface Transformer {
+    deserialize(params: TransformParams): unknown;
+    serialize(params: TransformParams): unknown;
+}
+export interface LuxonTransformerOptions {
+    format?: string;
+    zone?: string;
+}
+/** Structural shape of a Luxon DateTime — both methods required so an unrelated object isn't mangled. */
+export interface LuxonLike {
+    toISO(): string;
+    toFormat(f: string): string;
+}
+export interface MomentTransformerOptions {
+    format?: string;
+}
+/** Structural shape of a Moment — both methods required so an unrelated object isn't mangled. */
+export interface MomentLike {
+    toISOString(): string;
+    format(f: string): string;
+}

package/dist/src/transformers/luxon.d.ts

@@ -0,0 +1,3 @@
+import type { LuxonTransformerOptions, Transformer } from './interfaces';
+declare function luxonTransformer(opts?: LuxonTransformerOptions): Promise<Transformer>;
+export { luxonTransformer };

package/dist/src/transformers/luxon.js

@@ -0,0 +1 @@
+import{BakerError as F}from"../common/index.js";import{LUXON_MISSING as H}from"./constants.js";async function luxonTransformer(q){let w;try{w=await import("luxon")}catch(b){throw b.code==="ERR_MODULE_NOT_FOUND"?new F(H,{cause:b}):b}const{DateTime:y}=w,A=q?.zone??"utc",C=q?.format;return{deserialize:({value:b})=>{if(typeof b==="string"){const j=y.fromISO(b,{zone:A});return j.isValid?j:b}if(b instanceof Date){const j=y.fromJSDate(b,{zone:A});return j.isValid?j:b}return b},serialize:({value:b})=>{if(b&&typeof b==="object"&&typeof b.toISO==="function"&&typeof b.toFormat==="function"){const j=b;return C?j.toFormat(C):j.toISO()}return b}}}export{luxonTransformer};

package/dist/src/transformers/moment.d.ts

@@ -0,0 +1,3 @@
+import type { MomentTransformerOptions, Transformer } from './interfaces';
+declare function momentTransformer(opts?: MomentTransformerOptions): Promise<Transformer>;
+export { momentTransformer };

package/dist/src/transformers/moment.js

@@ -0,0 +1 @@
+import{BakerError as y}from"../common/index.js";import{MOMENT_MISSING as z}from"./constants.js";async function momentTransformer(x){let q;try{q=(await import("moment")).default}catch(b){throw b.code==="ERR_MODULE_NOT_FOUND"?new y(z,{cause:b}):b}const w=x?.format;return{deserialize:({value:b})=>{if(typeof b==="string"||b instanceof Date){const j=q.utc(b);return j.isValid()?j:b}return b},serialize:({value:b})=>{if(b&&typeof b==="object"&&typeof b.toISOString==="function"&&typeof b.format==="function"){const j=b;return w?j.format(w):j.toISOString()}return b}}}export{momentTransformer};

package/dist/src/transformers/{number.transformer.d.ts → number.d.ts}

@@ -1,2 +1,2 @@
-import type { Transformer } from '../types';
+import type { Transformer } from './interfaces';
 export declare function roundTransformer(precision?: number): Transformer;

package/dist/src/transformers/public.d.ts

@@ -0,0 +1,7 @@
+export { trimTransformer, toLowerCaseTransformer, toUpperCaseTransformer } from './string';
+export { roundTransformer } from './number';
+export { unixSecondsTransformer, unixMillisTransformer, isoStringTransformer } from './date';
+export { csvTransformer, jsonTransformer } from './collection';
+export { luxonTransformer } from './luxon';
+export { momentTransformer } from './moment';
+export type { LuxonTransformerOptions, MomentTransformerOptions } from './interfaces';

package/dist/src/transformers/public.js

@@ -0,0 +1 @@
+export{trimTransformer,toLowerCaseTransformer,toUpperCaseTransformer}from"./string.js";export{roundTransformer}from"./number.js";export{unixSecondsTransformer,unixMillisTransformer,isoStringTransformer}from"./date.js";export{csvTransformer,jsonTransformer}from"./collection.js";export{luxonTransformer}from"./luxon.js";export{momentTransformer}from"./moment.js";

package/dist/src/transformers/{string.transformer.d.ts → string.d.ts}

@@ -1,4 +1,4 @@
-import type { Transformer } from '../types';
+import type { Transformer } from './interfaces';
 export declare const trimTransformer: Transformer;
 export declare const toLowerCaseTransformer: Transformer;
 export declare const toUpperCaseTransformer: Transformer;

package/dist/src/transformers/types.d.ts

@@ -0,0 +1,3 @@
+import type { TransformParams } from './interfaces';
+/** Internal — direction-specific transform function stored after @Field processing */
+export type TransformFunction = (params: TransformParams) => unknown;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zipbul/baker",
-  "version": "5.0.0",
+  "version": "5.2.0",
   "description": "Bun-only AOT decorator-based DTO validation & serialization. class-validator DX, sealed code generation, zero reflect-metadata.",
   "keywords": [
     "aot",
@@ -50,20 +50,20 @@
       "import": "./dist/index.js"
     },
     "./decorators": {
-      "types": "./dist/src/decorators/index.d.ts",
-      "import": "./dist/src/decorators/index.js"
+      "types": "./dist/src/decorators/public.d.ts",
+      "import": "./dist/src/decorators/public.js"
     },
     "./rules": {
-      "types": "./dist/src/rules/index.d.ts",
-      "import": "./dist/src/rules/index.js"
+      "types": "./dist/src/rules/public.d.ts",
+      "import": "./dist/src/rules/public.js"
     },
     "./symbols": {
       "types": "./dist/src/symbols.d.ts",
       "import": "./dist/src/symbols.js"
     },
     "./transformers": {
-      "types": "./dist/src/transformers/index.d.ts",
-      "import": "./dist/src/transformers/index.js"
+      "types": "./dist/src/transformers/public.d.ts",
+      "import": "./dist/src/transformers/public.js"
     }
   },
   "publishConfig": {

package/dist/src/collect.d.ts

@@ -1,15 +0,0 @@
-import type { RawClassMeta, RawPropertyMeta } from './types';
-import { RAW } from './symbols';
-type MetaObject = Record<PropertyKey, unknown> & {
-    [RAW]?: RawClassMeta;
-};
-/**
- * Returns the RawPropertyMeta for the given propertyKey on the class's decorator metadata.
- * Creates the RAW slot and the per-key default meta if absent.
- *
- * The own-RAW check is required: a subclass's metadata inherits the parent's RAW via the
- * metadata prototype chain, so a bare assignment would pollute the parent. Creating a fresh
- * own RAW (null prototype) keeps child fields isolated.
- */
-export declare function ensureMeta(metadata: MetaObject, key: string): RawPropertyMeta;
-export {};

package/dist/src/collect.js

@@ -1 +0,0 @@
-import{RAW as x}from"./symbols.js";export function ensureMeta(j,z){if(!Object.hasOwn(j,x))j[x]=Object.create(null);const B=j[x];return B[z]??={validation:[],transform:[],expose:[],exclude:null,type:null,flags:{}}}

package/dist/src/configure.js

@@ -1 +0,0 @@
-import{BakerError as u}from"./errors.js";const v=new Set(["autoConvert","allowClassDefaults","stopAtFirstError","forbidUnknown","debug"]);function normalizeConfig(j){if(j===null||typeof j!=="object"||Array.isArray(j))throw new u(`[baker] config requires a plain object. Received: ${j===null?"null":Array.isArray(j)?"array":typeof j}.`);for(const q of Object.keys(j))if(!v.has(q))throw new u(`[baker] unknown key '${q}'. Valid keys: ${[...v].join(", ")}.`);return Object.freeze({enableImplicitConversion:j.autoConvert??!1,exposeDefaultValues:j.allowClassDefaults??!1,stopAtFirstError:j.stopAtFirstError??!1,whitelist:j.forbidUnknown??!1,debug:j.debug??!1})}export{normalizeConfig};

package/dist/src/create-rule.js

@@ -1 +0,0 @@
-import{BakerError as K}from"./errors.js";import{defineRuleMetadata as U}from"./rule-metadata.js";import{isAsyncFunction as V,isPromiseLike as W}from"./utils.js";export function createRule(b,Q){const z=typeof b==="string"?b:b.name,C=typeof b==="string"?Q:b.validate;if(typeof C!=="function")throw new K(`createRule(${z}): a validate function is required.`);const I=typeof b==="object"?b.constraints:void 0,J=typeof b==="object"?b.requiresType:void 0,D=V(C),j=function(H){const w=C(H);if(!D&&W(w))throw new K(`createRule(${z}): sync rule returned Promise. Declare the validator with async if it is asynchronous.`);return w};j.emit=function(H,w){const S=w.addRef(j);return`if(!(${D?"await ":""}refs[${S}](${H}))) ${w.fail(z)};`};const G={emit:j.emit,ruleName:z,isAsync:D};if(I!==void 0)G.constraints=I;if(J!==void 0)G.requiresType=J;U(j,G);return j}

package/dist/src/enums.js

@@ -1 +0,0 @@
-export var RequiredType;((b)=>{b.String="string";b.Number="number";b.Boolean="boolean";b.Date="date";b.Array="array";b.Object="object"})(RequiredType||={});export var Direction;((g)=>{g.Deserialize="deserialize";g.Serialize="serialize"})(Direction||={});export var CollectionType;((g)=>{g.Map="Map";g.Set="Set"})(CollectionType||={});export var CacheKey;((g)=>{g.Length="length";g.Time="time"})(CacheKey||={});export var RulePlanExprKind;((j)=>{j.Value="value";j.Member="member";j.Call0="call0";j.Literal="literal"})(RulePlanExprKind||={});export var RulePlanCheckKind;((m)=>{m.Compare="compare";m.And="and";m.Or="or"})(RulePlanCheckKind||={});export var RuleOp;((b)=>{b.Lt="<";b.Lte="<=";b.Gt=">";b.Gte=">=";b.Eq="===";b.Neq="!=="})(RuleOp||={});export var ExcludeMode;((g)=>{g.DeserializeOnly="deserializeOnly";g.SerializeOnly="serializeOnly"})(ExcludeMode||={});

package/dist/src/functions/check-call-options.js

@@ -1 +0,0 @@
-import{BakerError as v}from"../errors.js";const x=new Set(["groups"]);const F=new Set(["autoConvert","allowClassDefaults","stopAtFirstError","forbidUnknown","debug","enableImplicitConversion","exposeDefaultValues","whitelist"]);export function checkCallOptions(d){if(d===void 0||d===null)return;if(typeof d!=="object"||Array.isArray(d))throw new v(`Call options must be a plain object. Received: ${Array.isArray(d)?"array":typeof d}.`);const D=Object.getPrototypeOf(d);if(D!==null&&D!==Object.prototype){const q=d.constructor?.name??"unknown";throw new v(`Call options must be a plain object literal. Received instance of ${q}.`)}for(const q of Object.keys(d)){if(x.has(q))continue;if(F.has(q))throw new v(`Option '${q}' is a seal-time setting and cannot be passed per-call. Move it to new Baker({ ${q}: ... }) at app startup. Per-call options: ${[...x].join(", ")}.`);throw new v(`Unknown per-call option '${q}'. Valid per-call options: ${[...x].join(", ")}. Seal-time options go to new Baker({...}).`)}return d}

package/dist/src/functions/deserialize.d.ts

@@ -1,19 +0,0 @@
-import type { RuntimeOptions } from '../interfaces';
-import { type BakerIssueSet } from '../errors';
-/**
- * Converts input to a Class instance + validates.
- * - Requires the class's baker to be sealed (`new Baker().seal()`) beforehand; throws `BakerError` if not sealed
- * - Sync DTOs return directly; async DTOs return Promise
- * - Success: T
- * - Validation failure: BakerIssueSet (use isBakerIssueSet() to narrow)
- */
-export declare function deserialize<T>(Class: new (...args: never[]) => T, input: unknown, options?: RuntimeOptions): T | BakerIssueSet | Promise<T | BakerIssueSet>;
-/**
- * Sync-asserted deserialize. Throws `BakerError` if Class has any async rule/transform
- * on the deserialize side.
- */
-export declare function deserializeSync<T>(Class: new (...args: never[]) => T, input: unknown, options?: RuntimeOptions): T | BakerIssueSet;
-/**
- * Async-asserted deserialize. Always returns Promise (sync DTOs are wrapped via Promise.resolve).
- */
-export declare function deserializeAsync<T>(Class: new (...args: never[]) => T, input: unknown, options?: RuntimeOptions): Promise<T | BakerIssueSet>;

package/dist/src/functions/deserialize.js

@@ -1 +0,0 @@
-import{isErr as H}from"@zipbul/result";import{toBakerIssueSet as J,BakerError as M}from"../errors.js";import{ensureSealed as K}from"../seal/seal.js";import{checkCallOptions as L}from"./check-call-options.js";export function deserialize(F,j,G){const q=L(G),g=K(F);if(g.isAsync)return g.deserialize(j,q).then((x)=>{if(H(x))return J(x.data);return x});const f=g.deserialize(j,q);if(H(f))return J(f.data);return f}export function deserializeSync(F,j,G){const q=L(G),g=K(F);if(g.isAsync)throw new M(`deserializeSync(${F.name}): DTO has async rules/transforms. Use deserializeAsync() instead.`);const f=g.deserialize(j,q);if(H(f))return J(f.data);return f}export function deserializeAsync(F,j,G){const q=L(G),g=K(F);if(g.isAsync)return g.deserialize(j,q).then((x)=>{if(H(x))return J(x.data);return x});const f=g.deserialize(j,q);if(H(f))return Promise.resolve(J(f.data));return Promise.resolve(f)}

package/dist/src/functions/serialize.d.ts

@@ -1,16 +0,0 @@
-import type { RuntimeOptions } from '../interfaces';
-/**
- * Converts a Class instance to a plain object.
- * - Requires the class's baker to be sealed (`new Baker().seal()`) beforehand; throws `BakerError` if not sealed
- * - Sync DTOs return directly; async DTOs return Promise
- * - No validation — always returns Record<string, unknown>
- */
-export declare function serialize<T>(instance: T, options?: RuntimeOptions): Record<string, unknown> | Promise<Record<string, unknown>>;
-/**
- * Sync-asserted serialize. Throws `BakerError` if Class has any async transform on the serialize side.
- */
-export declare function serializeSync<T>(instance: T, options?: RuntimeOptions): Record<string, unknown>;
-/**
- * Async-asserted serialize. Always returns Promise (sync DTOs are wrapped via Promise.resolve).
- */
-export declare function serializeAsync<T>(instance: T, options?: RuntimeOptions): Promise<Record<string, unknown>>;

package/dist/src/functions/serialize.js

@@ -1 +0,0 @@
-import{BakerError as x}from"../errors.js";import{ensureSealed as I}from"../seal/seal.js";import{checkCallOptions as F}from"./check-call-options.js";function G(b,q){if(b==null||typeof b!=="object")throw new x(`${q}: expected a class instance, got ${b===null?"null":typeof b}`);const g=b.constructor;if(typeof g!=="function")throw new x(`${q}: instance has no constructor`);if(g===Object||!(b instanceof g))throw new x(`${q}: received a plain object. Pass an instance of a DTO class decorated with @Field.`);return I(g)}export function serialize(b,q){const g=F(q),j=G(b,"serialize");return j.isSerializeAsync?j.serialize(b,g):j.serialize(b,g)}export function serializeSync(b,q){const g=F(q),j=G(b,"serializeSync");if(j.isSerializeAsync){const H=b.constructor.name;throw new x(`serializeSync(${H}): DTO has async serialize transforms. Use serializeAsync() instead.`)}return j.serialize(b,g)}export function serializeAsync(b,q){const g=F(q),j=G(b,"serializeAsync");return j.isSerializeAsync?j.serialize(b,g):Promise.resolve(j.serialize(b,g))}

package/dist/src/functions/validate.d.ts

@@ -1,18 +0,0 @@
-import type { BakerIssueSet } from '../errors';
-import type { RuntimeOptions } from '../interfaces';
-/**
- * DTO-level validation — validates `input` against a decorated class's schema.
- * Sync DTOs return directly; async DTOs return Promise. To validate a single primitive without a
- * DTO, call the rule directly (e.g. `isEmail()(value)`).
- */
-declare function validate<T>(Class: new (...args: never[]) => T, input: unknown, options?: RuntimeOptions): true | BakerIssueSet | Promise<true | BakerIssueSet>;
-/**
- * Sync-asserted validate. Throws `BakerError` if Class has any async rule/transform
- * on the deserialize/validate side. Use when caller code assumes sync return.
- */
-declare function validateSync<T>(Class: new (...args: never[]) => T, input: unknown, options?: RuntimeOptions): true | BakerIssueSet;
-/**
- * Async-asserted validate. Always returns Promise (sync DTOs are wrapped via Promise.resolve).
- */
-declare function validateAsync<T>(Class: new (...args: never[]) => T, input: unknown, options?: RuntimeOptions): Promise<true | BakerIssueSet>;
-export { validate, validateSync, validateAsync };

package/dist/src/functions/validate.js

@@ -1 +0,0 @@
-import{toBakerIssueSet as F,BakerError as J}from"../errors.js";import{ensureSealed as G}from"../seal/seal.js";import{checkCallOptions as H}from"./check-call-options.js";function validate(q,g,x){const j=H(x),b=G(q);if(b.isAsync)return b.validate(g,j).then((z)=>z===null?!0:F(z));const f=b.validate(g,j);return f===null?!0:F(f)}function validateSync(q,g,x){const j=H(x),b=G(q);if(b.isAsync)throw new J(`validateSync(${q.name}): DTO has async rules/transforms. Use validateAsync() instead.`);const f=b.validate(g,j);return f===null?!0:F(f)}function validateAsync(q,g,x){const j=H(x),b=G(q);if(b.isAsync)return b.validate(g,j).then((z)=>z===null?!0:F(z));const f=b.validate(g,j);return Promise.resolve(f===null?!0:F(f))}export{validate,validateSync,validateAsync};

package/dist/src/interfaces.d.ts

@@ -1,32 +0,0 @@
-export interface SealOptions {
-    /**
-     * Automatic conversion using validation decorators as type hints.
-     * @default false
-     */
-    enableImplicitConversion?: boolean;
-    /**
-     * Use class default values when the key is missing from input.
-     * @default false
-     */
-    exposeDefaultValues?: boolean;
-    /**
-     * true: return immediately on first error. false (default): collect all errors.
-     * @default false
-     */
-    stopAtFirstError?: boolean;
-    /**
-     * true: reject undeclared fields. Uses the key set from mergeInheritance(Class) as the allowlist.
-     * `@Exclude` fields are also included in the whitelist — their presence is allowed but they are excluded from the result.
-     * @default false
-     */
-    whitelist?: boolean;
-    /**
-     * true: include field exclusion reasons as comments in generated code.
-     * @default false
-     */
-    debug?: boolean;
-}
-export interface RuntimeOptions {
-    /** Per-request groups — passed at runtime since they may vary per request */
-    groups?: string[];
-}

package/dist/src/meta-access.d.ts

@@ -1,19 +0,0 @@
-import type { RawClassMeta, SealedExecutors } from './types';
-export declare function getSealed(cls: Function): SealedExecutors<unknown> | undefined;
-/** Same as getSealed but throws if the class is not sealed — for callers that establish the invariant elsewhere. */
-export declare function requireSealed(cls: Function): SealedExecutors<unknown>;
-export declare function setSealed(cls: Function, exec: SealedExecutors<unknown>): void;
-export declare function hasSealedOwn(cls: Function): boolean;
-export declare function deleteSealed(cls: Function): void;
-export declare function deleteRaw(cls: Function): void;
-export declare function getRaw(cls: Function): RawClassMeta | undefined;
-/** Same as getRaw but throws if the class has no @Field decorators — for callers that establish the invariant elsewhere. */
-export declare function requireRaw(cls: Function): RawClassMeta;
-export declare function setRaw(cls: Function, raw: RawClassMeta): void;
-/**
- * True only when cls has its OWN RAW slot. A subclass without its own @Field decorators
- * resolves Class[Symbol.metadata] to the parent's metadata via the class prototype chain;
- * the dual own-check keeps mergeInheritance from double-counting inherited fields.
- */
-export declare function hasRawOwn(cls: Function): boolean;
-export declare function freezeRaw(cls: Function): void;

package/dist/src/meta-access.js

@@ -1 +0,0 @@
-import{RAW as B,SEALED as q}from"./symbols.js";function C(j){return j[Symbol.metadata]??void 0}function F(j){if(!Object.hasOwn(j,Symbol.metadata))Object.defineProperty(j,Symbol.metadata,{value:{},writable:!0,configurable:!0,enumerable:!1});return j[Symbol.metadata]}export function getSealed(j){return j[q]}export function requireSealed(j){const k=j[q];if(k===void 0)throw Error(`${j.name||"<anonymous>"}: class is not sealed`);return k}export function setSealed(j,k){j[q]=k}export function hasSealedOwn(j){return Object.hasOwn(j,q)}export function deleteSealed(j){delete j[q]}export function deleteRaw(j){if(Object.hasOwn(j,Symbol.metadata))delete j[Symbol.metadata][B]}export function getRaw(j){return C(j)?.[B]}export function requireRaw(j){const k=getRaw(j);if(k===void 0)throw Error(`${j.name||"<anonymous>"}: class has no @Field decorators`);return k}export function setRaw(j,k){F(j)[B]=k}export function hasRawOwn(j){if(!Object.hasOwn(j,Symbol.metadata))return!1;const k=j[Symbol.metadata];return k!=null&&Object.hasOwn(k,B)}export function freezeRaw(j){if(!hasRawOwn(j))return;Object.freeze(getRaw(j))}

package/dist/src/rule-plan.js

@@ -1 +0,0 @@
-import{RuleOp as Y,RulePlanCheckKind as H,RulePlanExprKind as D}from"./enums.js";import{defineRuleMetadata as Z}from"./rule-metadata.js";const planValue=()=>({kind:D.Value});const planLength=(z=planValue())=>({kind:D.Member,object:z,property:"length"});const planTime=(z=planValue())=>({kind:D.Call0,object:z,method:"getTime"});const planLiteral=(z)=>({kind:D.Literal,value:z});const planCompare=(z,A,B)=>({kind:H.Compare,left:z,op:A,right:typeof B==="number"?planLiteral(B):B});const planOr=(...z)=>({kind:H.Or,checks:z});function makePlannedRule(z){const A={name:z.name,requiresType:z.requiresType,plan:z.plan,validate:z.validate,emit:(B,F)=>emitRulePlan(B,F,z.name,z.plan,void 0,F.insideTypeGate)};if(z.constraints!==void 0)A.constraints=z.constraints;return makeRule(A)}function makeRule(z){const A=(F)=>z.validate(F),B={emit:z.emit,ruleName:z.name,constraints:z.constraints??{}};if(z.requiresType!==void 0)B.requiresType=z.requiresType;if(z.isAsync!==void 0)B.isAsync=z.isAsync;if(z.plan!==void 0)B.plan=z.plan;Z(A,B);return A}function emitRulePlan(z,A,B,F,J,W){const X=W?_(F.failure):F.failure;return`if (${U(X,z,J)}) ${A.fail(B)};`}function _(z){if(z.kind===H.Compare)return z;const A=z.checks.filter((B)=>!$(B));if(A.length===0)return z;if(A.length===1)return A[0];return{kind:z.kind,checks:A}}function $(z){if(z.kind!==H.Compare||z.op!==Y.Neq)return!1;return Q(z.left,z.right)}function Q(z,A){if(z.kind!==A.kind)return!1;switch(z.kind){case D.Value:return!0;case D.Literal:return z.value===A.value;case D.Member:return Q(z.object,A.object);case D.Call0:return z.method===A.method&&Q(z.object,A.object);default:return z}}function U(z,A,B){if(z.kind===H.Compare)return`${I(z.left,A,B)} ${z.op} ${I(z.right,A,B)}`;const F=z.kind===H.And?" && ":" || ";return`(${z.checks.map((J)=>U(J,A,B)).join(F)})`}function I(z,A,B){switch(z.kind){case D.Value:return A;case D.Literal:return String(z.value);case D.Member:return B?.length??`${I(z.object,A,B)}.length`;case D.Call0:return B?.time??`${I(z.object,A,B)}.getTime()`;default:return z}}export{planValue,planLength,planTime,planLiteral,planCompare,planOr,makePlannedRule,makeRule,emitRulePlan};

package/dist/src/seal/validate-meta.d.ts

@@ -1,13 +0,0 @@
-import type { RawClassMeta } from '../types';
-/**
- * @internal — seal-time invariant checks invoked from sealOne after merge + type normalization,
- * before codegen. Throws BakerError on the first violation.
- *
- * Covers W2 (D7 + D9):
- * - Discriminator shape: empty subTypes / invalid subType entry / name collision / missing property
- * - Set/Map pairing: Set without setValue, Map without mapValue, setValue/mapValue target missing @Field metadata
- * - async-in-sync: a DTO that mixes async rules/transforms with sync rules/transforms in such a way
- *   that the caller cannot easily tell — this throws BakerError so the user makes the intent explicit.
- *   (Per W2 decision: throw, not warn.)
- */
-export declare function validateMeta(Class: Function, merged: RawClassMeta): void;

package/dist/src/seal/validate-meta.js

@@ -1 +0,0 @@
-import{CollectionType as K}from"../enums.js";import{BakerError as z}from"../errors.js";import{hasRawOwn as H}from"../meta-access.js";export function validateMeta(I,J){const q=I.name;for(const[x,D]of Object.entries(J)){if(D.type?.discriminator){const f=D.type.discriminator;if(typeof f.property!=="string"||f.property.length===0)throw new z(`${q}.${x}: discriminator.property must be a non-empty string.`);if(!Array.isArray(f.subTypes)||f.subTypes.length===0)throw new z(`${q}.${x}: discriminator.subTypes must be a non-empty array of { value, name } entries.`);const F=new Set;for(let A=0;A<f.subTypes.length;A++){const j=f.subTypes[A];if(typeof j.name!=="string"||j.name.length===0)throw new z(`${q}.${x}: discriminator.subTypes[${A}].name must be a non-empty string.`);if(typeof j.value!=="function")throw new z(`${q}.${x}: discriminator.subTypes[${A}].value must be a class constructor (got ${typeof j.value}).`);if(F.has(j.name))throw new z(`${q}.${x}: discriminator.subTypes has duplicate name '${j.name}'. Each subType must have a unique name.`);F.add(j.name);if(!H(j.value))throw new z(`${q}.${x}: discriminator.subTypes[${A}].value (${j.value.name}) has no @Field decorators.`)}}const G=D.type?.collection;if(G!==void 0&&D.type?.resolvedCollectionValue){const f=D.type.resolvedCollectionValue;if(!H(f)){const F=G===K.Set?"setValue":"mapValue";throw new z(`${q}.${x}: ${F} target (${f.name}) has no @Field decorators.`)}}}}

package/dist/src/transformers/date.transformer.js

@@ -1 +0,0 @@
-export const unixSecondsTransformer={deserialize:({value:r})=>typeof r==="number"?new Date(r*1000):r,serialize:({value:r})=>r instanceof Date?Math.floor(r.getTime()/1000):r};export const unixMillisTransformer={deserialize:({value:r})=>typeof r==="number"?new Date(r):r,serialize:({value:r})=>r instanceof Date?r.getTime():r};export const isoStringTransformer={deserialize:({value:r})=>{if(typeof r!=="string")return r;const e=new Date(r);return Number.isNaN(e.getTime())?r:e},serialize:({value:r})=>r instanceof Date?r.toISOString():r};

package/dist/src/transformers/luxon.transformer.d.ts

@@ -1,8 +0,0 @@
-import type { Transformer } from '../types';
-interface LuxonTransformerOptions {
-    format?: string;
-    zone?: string;
-}
-declare function luxonTransformer(opts?: LuxonTransformerOptions): Promise<Transformer>;
-export type { LuxonTransformerOptions };
-export { luxonTransformer };

package/dist/src/transformers/luxon.transformer.js

@@ -1 +0,0 @@
-import{BakerError as C}from"../errors.js";const F="luxonTransformer requires the optional peer dependency 'luxon'. Install it with: bun add luxon";async function luxonTransformer(g){let j;try{j=await import("luxon")}catch(b){throw new C(F,{cause:b})}const{DateTime:q}=j,w=g?.zone??"utc",y=g?.format;return{deserialize:({value:b})=>{if(typeof b==="string")return q.fromISO(b,{zone:w});if(b instanceof Date)return q.fromJSDate(b,{zone:w});return b},serialize:({value:b})=>{if(b&&typeof b==="object"&&typeof b.toISO==="function"){const A=b;return y?A.toFormat(y):A.toISO()}return b}}}export{luxonTransformer};

package/dist/src/transformers/moment.transformer.d.ts

@@ -1,7 +0,0 @@
-import type { Transformer } from '../types';
-interface MomentTransformerOptions {
-    format?: string;
-}
-declare function momentTransformer(opts?: MomentTransformerOptions): Promise<Transformer>;
-export type { MomentTransformerOptions };
-export { momentTransformer };

package/dist/src/transformers/moment.transformer.js

@@ -1 +0,0 @@
-import{BakerError as x}from"../errors.js";const y="momentTransformer requires the optional peer dependency 'moment'. Install it with: bun add moment";async function momentTransformer(w){let g;try{g=(await import("moment")).default}catch(b){throw new x(y,{cause:b})}const j=w?.format;return{deserialize:({value:b})=>{if(typeof b==="string"||b instanceof Date)return g(b);return b},serialize:({value:b})=>{if(b&&typeof b==="object"&&typeof b.toISOString==="function"&&typeof b.format==="function"){const q=b;return j?q.format(j):q.toISOString()}return b}}}export{momentTransformer};

package/dist/src/types.d.ts

@@ -1,177 +0,0 @@
-import type { Result, ResultAsync } from '@zipbul/result';
-import type { CacheKey, CollectionType, RequiredType, RuleOp, RulePlanCheckKind, RulePlanExprKind } from './enums';
-import type { BakerIssue } from './errors';
-import type { RuntimeOptions } from './interfaces';
-export interface EmitContext {
-    /** Register a RegExp in the reference array, return its index */
-    addRegex(re: RegExp): number;
-    /** Register in the reference array, return its index — functions, arrays, Sets, primitives, etc. */
-    addRef(value: unknown): number;
-    /** Register a SealedExecutors object in the reference array — for nested @Type DTOs */
-    addExecutor(executor: SealedExecutors<unknown>): number;
-    /** Generate a failure code string from an error code — path is bound by the builder */
-    fail(code: string): string;
-    /** Whether error collection mode is enabled (= !stopAtFirstError) */
-    collectErrors: boolean;
-    /** Whether this emit runs inside a type gate (typeof/instanceof already verified) */
-    insideTypeGate?: boolean;
-    /** @internal Path expression for inline nested — used by makeRuleEmitCtx */
-    pathExpr?: string;
-}
-export interface EmittableRule {
-    (value: unknown): boolean | Promise<boolean>;
-    emit(varName: string, ctx: EmitContext): string;
-    readonly ruleName: string;
-    /**
-     * Meta for the builder to determine whether to insert a typeof guard.
-     * Only set for rules that assume a specific type (e.g., isEmail → 'string').
-     * `@IsString` itself is undefined (it includes its own typeof check).
-     */
-    readonly requiresType?: RequiredType;
-    /** Expose rule parameters for external reading */
-    readonly constraints?: Record<string, unknown>;
-    /** true when the rule is explicitly async and must be awaited */
-    readonly isAsync?: boolean;
-}
-/** @internal internal rule shape used by builders for optimization metadata */
-export interface InternalRule extends EmittableRule {
-    readonly plan?: RulePlan;
-}
-export type RulePlanExpr = {
-    kind: RulePlanExprKind.Value;
-} | {
-    kind: RulePlanExprKind.Member;
-    object: RulePlanExpr;
-    property: 'length';
-} | {
-    kind: RulePlanExprKind.Call0;
-    object: RulePlanExpr;
-    method: 'getTime';
-} | {
-    kind: RulePlanExprKind.Literal;
-    value: number;
-};
-export type RulePlanCheck = {
-    kind: RulePlanCheckKind.Compare;
-    left: RulePlanExpr;
-    op: RuleOp;
-    right: RulePlanExpr;
-} | {
-    kind: RulePlanCheckKind.And | RulePlanCheckKind.Or;
-    checks: RulePlanCheck[];
-};
-export interface RulePlan {
-    cacheKey?: CacheKey;
-    failure: RulePlanCheck;
-}
-/** Arguments for user-defined message callback */
-export interface MessageArgs {
-    property: string;
-    value: unknown;
-    constraints: Record<string, unknown>;
-}
-export interface RuleDef {
-    rule: InternalRule;
-    each?: boolean;
-    groups?: string[];
-    /** Value to include in BakerIssue.message on validation failure */
-    message?: string | ((args: MessageArgs) => string);
-    /** Arbitrary value to include in BakerIssue.context on validation failure */
-    context?: unknown;
-}
-export interface TransformParams {
-    value: unknown;
-    key: string;
-    obj: Record<string, unknown>;
-}
-export interface Transformer {
-    deserialize(params: TransformParams): unknown | Promise<unknown>;
-    serialize(params: TransformParams): unknown | Promise<unknown>;
-}
-/** Internal — direction-specific transform function stored after @Field processing */
-export type TransformFunction = (params: TransformParams) => unknown | Promise<unknown>;
-export interface TransformDef {
-    fn: TransformFunction;
-    isAsync?: boolean;
-    options?: {
-        groups?: string[];
-        deserializeOnly?: boolean;
-        serializeOnly?: boolean;
-    };
-}
-export interface ExposeDef {
-    name?: string;
-    groups?: string[];
-    deserializeOnly?: boolean;
-    serializeOnly?: boolean;
-}
-export interface ExcludeDef {
-    deserializeOnly?: boolean;
-    serializeOnly?: boolean;
-}
-/** Generic class constructor — contravariant `never[]` args accept any user constructor */
-export type ClassCtor<T = object> = new (...args: never[]) => T;
-export interface TypeDef {
-    fn: () => ClassCtor | ClassCtor[] | MapConstructor | SetConstructor;
-    discriminator?: {
-        property: string;
-        subTypes: {
-            value: Function;
-            name: string;
-        }[];
-    };
-    keepDiscriminatorProperty?: boolean;
-    /** seal-time normalization result — true if fn() returns an array */
-    isArray?: boolean;
-    /** seal-time normalization result — cached class after resolving fn() (DTOs only, excluding primitives) */
-    resolvedClass?: ClassCtor;
-    /** seal-time normalization result — Map or Set collection type */
-    collection?: CollectionType;
-    /** Nested DTO class thunk for Map value / Set element */
-    collectionValue?: () => ClassCtor;
-    /** seal-time normalization result — cached class after resolving collectionValue */
-    resolvedCollectionValue?: ClassCtor;
-}
-export interface PropertyFlags {
-    /** `@IsOptional`() — skip all validation when undefined/null */
-    isOptional?: boolean;
-    /** `@IsDefined`() — disallow undefined (overrides @IsOptional). Current code rejects only undefined; null is delegated to subsequent validation */
-    isDefined?: boolean;
-    /** `@IsNullable`() — allow and assign null, reject undefined */
-    isNullable?: boolean;
-    /** `@ValidateIf`(cond) — skip all field validation when false */
-    validateIf?: (obj: Record<string, unknown>) => boolean;
-    /** `@ValidateNested`() — trigger recursive validation for nested DTOs. Used with @Type */
-    validateNested?: boolean;
-    /** `@ValidateNested`({ each: true }) — validate nested DTOs per array element */
-    validateNestedEach?: boolean;
-}
-export interface RawPropertyMeta {
-    validation: RuleDef[];
-    transform: TransformDef[];
-    expose: ExposeDef[];
-    exclude: ExcludeDef | null;
-    type: TypeDef | null;
-    flags: PropertyFlags;
-    /** Field-level message applied to ALL failures of this field (gate/structural/required/conversion/rule) */
-    message?: string | ((args: MessageArgs) => string);
-    /** Field-level context attached to ALL failures of this field */
-    context?: unknown;
-}
-export interface RawClassMeta {
-    [propertyKey: string]: RawPropertyMeta;
-}
-export interface SealedExecutors<T> {
-    /** Internal executor — Result pattern. deserialize() wraps and converts to throw */
-    deserialize(input: unknown, options?: RuntimeOptions): Result<T, BakerIssue[]> | ResultAsync<T, BakerIssue[]>;
-    /** Internal executor — always succeeds. serialize assumes no validation */
-    serialize(instance: T, options?: RuntimeOptions): Record<string, unknown> | Promise<Record<string, unknown>>;
-    /** Internal executor — validate-only (no object creation). Returns null on success, BakerIssue[] on failure */
-    validate(input: unknown, options?: RuntimeOptions): BakerIssue[] | null | Promise<BakerIssue[] | null>;
-    /** true if the deserialize direction has async rules/transforms/nested */
-    isAsync: boolean;
-    /** true if the serialize direction has async transforms/nested */
-    isSerializeAsync: boolean;
-    /** Merged metadata cache — used internally by unseal helper */
-    merged?: RawClassMeta;
-}