@zipbul/baker 5.1.0 → 5.2.0

package/dist/src/seal/circular-placeholder.d.ts

@@ -0,0 +1,20 @@
+import type { RuntimeOptions } from '../common';
+import type { SealedExecutors } from './interfaces';
+/**
+ * @internal Placeholder executor parked in the baker's map while a class is mid-seal, to break circular
+ * references. The instance IS the placeholder: it holds the still-sealing class name as private state
+ * and its executor members throw if invoked before sealing completes.
+ *
+ * The three executor members are writable OWN (arrow) fields, not prototype methods, so sealOne can
+ * replace them in place via `Object.assign(placeholder, { deserialize, … })` once compilation finishes
+ * (reference identity is load-bearing — nested refs already hold this object).
+ */
+export declare class CircularPlaceholder implements SealedExecutors<unknown> {
+    #private;
+    isAsync: boolean;
+    isSerializeAsync: boolean;
+    constructor(className: string);
+    deserialize: (_input: unknown, _options?: RuntimeOptions) => never;
+    serialize: (_instance: unknown, _options?: RuntimeOptions) => never;
+    validate: (_input: unknown, _options?: RuntimeOptions) => never;
+}

package/dist/src/seal/circular-placeholder.js

@@ -0,0 +1 @@
+export class CircularPlaceholder{#q;isAsync=!1;isSerializeAsync=!1;constructor(q){this.#q=`Circular dependency during seal: ${q} is still being sealed`}deserialize=(q,C)=>{throw new A(this.#q)};serialize=(q,C)=>{throw new A(this.#q)};validate=(q,C)=>{throw new A(this.#q)}}import{BakerError as A}from"../common/index.js";

package/dist/src/seal/codegen-utils.d.ts

@@ -1,5 +1,20 @@
+import type { RawPropertyMeta } from '../metadata';
+import { Direction } from '../common';
 /** Convert key to a valid JS identifier suffix (encode non-alphanumeric chars via charCode to prevent collisions) */
 export declare function sanitizeKey(key: string): string;
+/**
+ * Resolve the rename target for a field in `direction`: the @Expose `name` from a same-direction-only
+ * entry if present, else a bidirectional @Expose `name`, else the field key itself. The single source
+ * of truth for both deserialize extract-key and serialize output-key resolution (they are mirror images
+ * differing only in which directional flag they honour).
+ */
+export declare function resolveExposeName(fieldKey: string, exposeStack: RawPropertyMeta['expose'], direction: Direction): string;
+/**
+ * Resolve a field's expose groups for `direction` — undefined (no restriction) if any unconditional
+ * expose entry exists. Single source of truth for both directions: serialize skips deserialize-only
+ * entries, deserialize skips serialize-only entries.
+ */
+export declare function resolveExposeGroups(exposeStack: RawPropertyMeta['expose'], direction: Direction): string[] | undefined;
 /**
  * Generate a groups-has expression for the fast-path single-group / Set pattern.
  * Checks if any of the given groups match the runtime groups.

package/dist/src/seal/codegen-utils.js

@@ -1 +1 @@
-export function sanitizeKey(d){return d.replace(/[^a-zA-Z0-9_]/g,(b)=>`$${b.charCodeAt(0)}$`)}export function buildGroupsHasExpr(d,b,w){return w.map((z)=>{const j=JSON.stringify(z);return`(${d}===${j} || (${b} && ${b}.has(${j})))`}).join(" || ")}
+import{Direction as F}from"../common/index.js";export function sanitizeKey(B){return B.replace(/[^a-zA-Z0-9_]/g,(w)=>`$${w.charCodeAt(0)}$`)}export function resolveExposeName(B,w,z){const A=z===F.Serialize?w.find((j)=>j.serializeOnly&&j.name):w.find((j)=>j.deserializeOnly&&j.name);if(A)return A.name;const E=w.find((j)=>!j.deserializeOnly&&!j.serializeOnly&&j.name);if(E)return E.name;return B}export function resolveExposeGroups(B,w){let z=null;for(const A of B){if(w===F.Serialize?A.deserializeOnly:A.serializeOnly)continue;if(!A.groups||A.groups.length===0)return;if(z===null)z=new Set;for(const E of A.groups)z.add(E)}return z===null?void 0:[...z]}export function buildGroupsHasExpr(B,w,z){return z.map((E)=>{const j=JSON.stringify(E);return`(${B}===${j} || (${w} && ${w}.has(${j})))`}).join(" || ")}

package/dist/src/seal/compile-cache.d.ts

@@ -0,0 +1,38 @@
+import type { SealOptions, SealedExecutors } from './interfaces';
+/**
+ * A class's generated executor is a pure function of (its RAW metadata, the seal config). So two
+ * bakers with the SAME config compile byte-identical executors — memoize globally by
+ * `(class, configFingerprint)` so they share one executor (compiled once) instead of N copies, while
+ * different-config bakers stay isolated (distinct fingerprint → distinct entry). Behaviour is
+ * unchanged either way: executors are pure (no per-call mutable state), so sharing is invisible.
+ *
+ * `WeakMap<class>` so an entry is reclaimed when its class is GC'd. The inner `Map` retains one
+ * executor per (class, config) for the class's lifetime — bounded for a fixed DTO/config set (the
+ * intended "seal once at startup" usage); a program that dynamically generates classes/configs would
+ * grow it without eviction.
+ *
+ * The cache owns its WeakMap as a private field (no module-level mutable state) and is exposed as a
+ * single process-global instance, `compileCache` — the single source of truth for compiled executors.
+ */
+declare class CompileCache {
+    #private;
+    constructor();
+    /**
+     * Canonical fingerprint of a SealOptions — the seal-affecting booleans in fixed order. `{}` and a
+     * fully-defaulted object both map to "00000", so `new Baker()` and `new Baker({})` share a cache key.
+     */
+    fingerprint(o: SealOptions): string;
+    get(cls: Function, fp: string): SealedExecutors<unknown> | undefined;
+    set(cls: Function, fp: string, exec: SealedExecutors<unknown>): void;
+    /** Test-only: drop a single class's cached executors so a re-seal recompiles it. */
+    clear(cls: Function): void;
+    /**
+     * Test-only: drop the ENTIRE cache. Used by `unseal()` so a test that re-seals classes starts from a
+     * clean slate — a whole-cache reset (vs per-class) is the only way to avoid the partial-clear state
+     * where a cached root still references a nested whose entry was dropped (a root + its nested are
+     * always compiled together, so they must be invalidated together).
+     */
+    clearAll(): void;
+}
+export declare const compileCache: CompileCache;
+export {};

package/dist/src/seal/compile-cache.js

@@ -0,0 +1 @@
+class D{#j;constructor(){this.#j=new WeakMap}fingerprint(j){let q="";for(const B of F)q+=j[B]?"1":"0";return q}get(j,q){return this.#j.get(j)?.get(q)}set(j,q,B){let z=this.#j.get(j);if(z===void 0){z=new Map;this.#j.set(j,z)}z.set(q,B)}clear(j){this.#j.delete(j)}clearAll(){this.#j=new WeakMap}}import{SEAL_OPTION_KEYS as F}from"./constants.js";export const compileCache=new D;

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

@@ -0,0 +1,62 @@
+import type { SealOptions } from './interfaces';
+/** Built-in constructors that are NOT treated as nested DTOs during seal. */
+export declare const PRIMITIVE_CTORS: Set<Function>;
+/**
+ * The runtime key list of {@link SealOptions}, in fixed order. Built from a `Record<keyof SealOptions,
+ * true>` so a new (or removed) SealOptions field is a COMPILE error here until covered. Single source
+ * for the compile-cache fingerprint (its bit order) and the runtime per-call seal-time-key rejection.
+ */
+export declare const SEAL_OPTION_KEYS: (keyof SealOptions)[];
+/**
+ * Property names that must never be used as a field key, an @Expose wire name, or a discriminator
+ * property — writing them onto the output object corrupts its prototype/shape (prototype pollution).
+ * Single source shared by every seal-time gate (seal.ts, expose-validator.ts, meta-validator.ts).
+ */
+export declare const RESERVED_PROPERTY_NAMES: Set<string>;
+/** Deserialize codegen variable-name table (imported as `GEN` by the deserialize builder/codegen). */
+export declare const DES_GEN: {
+    readonly field: "__bk$f_";
+    readonly index: "__bk$i_";
+    readonly setIdx: "__bk$si_";
+    readonly setVal: "__bk$sv_";
+    readonly mapIdx: "__bk$mi_";
+    readonly mapVal: "__bk$mv_";
+    readonly mark: "__bk$mark_";
+    readonly skip: "__bk$skip_";
+    readonly result: "__bk$r_";
+    readonly errors: "__bk$re_";
+    readonly arr: "__bk$arr_";
+    readonly disc: "__bk$dt_";
+    readonly nestedIdx: "__bk$j_";
+    readonly out: "__bk$out";
+    readonly errList: "__bk$errors";
+    readonly groups: "__bk$groups";
+    readonly group0: "__bk$group0";
+    readonly groupsSet: "__bk$groupsSet";
+    readonly key: "__bk$k";
+};
+/** Serialize codegen variable-name table (imported as `GEN` by the serialize builder). */
+export declare const SER_GEN: {
+    readonly out: "__bk$out";
+    readonly fieldVal: "__bk$fv_";
+    readonly groups: "__bk$groups";
+    readonly group0: "__bk$group0";
+    readonly groupsSet: "__bk$groupsSet";
+    readonly setArr: "__bk$sa";
+    readonly setItem: "__bk$si";
+    readonly mapObj: "__bk$m";
+    readonly mapEntry: "__bk$me";
+    readonly serResult: "__bk$sr";
+    readonly outItem: "__bk$out_item";
+    readonly discArr: "__bk$da";
+    readonly discIdx: "__bk$di";
+    readonly nestedArr: "__bk$na";
+    readonly nestedIdx: "__bk$ni";
+    readonly nestedItem: "__bk$nitem";
+};
+/** `@Type`() primitive builtin → target type mapping */
+export declare const PRIMITIVE_TYPE_HINTS: Record<string, string>;
+/** Asserter rule name → gate type mapping */
+export declare const ASSERTER_TO_GATE: Record<string, string>;
+/** Asserters whose gate check fully subsumes the rule (skip emit inside gate) */
+export declare const GATE_ONLY_ASSERTERS: Set<string>;

package/dist/src/seal/constants.js

@@ -0,0 +1 @@
+export const PRIMITIVE_CTORS=new Set([Number,String,Boolean,Date]);export const SEAL_OPTION_KEYS=Object.keys({enableImplicitConversion:!0,exposeDefaultValues:!0,stopAtFirstError:!0,whitelist:!0,debug:!0});export const RESERVED_PROPERTY_NAMES=new Set(["__proto__","constructor","prototype"]);export const DES_GEN={field:"__bk$f_",index:"__bk$i_",setIdx:"__bk$si_",setVal:"__bk$sv_",mapIdx:"__bk$mi_",mapVal:"__bk$mv_",mark:"__bk$mark_",skip:"__bk$skip_",result:"__bk$r_",errors:"__bk$re_",arr:"__bk$arr_",disc:"__bk$dt_",nestedIdx:"__bk$j_",out:"__bk$out",errList:"__bk$errors",groups:"__bk$groups",group0:"__bk$group0",groupsSet:"__bk$groupsSet",key:"__bk$k"};export const SER_GEN={out:"__bk$out",fieldVal:"__bk$fv_",groups:"__bk$groups",group0:"__bk$group0",groupsSet:"__bk$groupsSet",setArr:"__bk$sa",setItem:"__bk$si",mapObj:"__bk$m",mapEntry:"__bk$me",serResult:"__bk$sr",outItem:"__bk$out_item",discArr:"__bk$da",discIdx:"__bk$di",nestedArr:"__bk$na",nestedIdx:"__bk$ni",nestedItem:"__bk$nitem"};export const PRIMITIVE_TYPE_HINTS={Number:"number",Boolean:"boolean",String:"string",Date:"date"};export const ASSERTER_TO_GATE={isString:"string",isNumber:"number",isBoolean:"boolean",isDate:"date",isInt:"number",isArray:"array",isObject:"object"};export const GATE_ONLY_ASSERTERS=new Set(["isString","isBoolean","isDate","isArray","isObject"]);

package/dist/src/seal/deserialize-builder.d.ts

@@ -1,9 +1,6 @@
-import type { Result, ResultAsync } from '@zipbul/result';
-import type { SealOptions, RuntimeOptions } from '../interfaces';
-import type { RawClassMeta, SealedExecutors } from '../types';
-import { type BakerIssue } from '../errors';
-type DeserializeExecutor<T> = (input: unknown, opts?: RuntimeOptions) => Result<T, BakerIssue[]> | ResultAsync<T, BakerIssue[]>;
-type ValidateExecutor = (input: unknown, opts?: RuntimeOptions) => BakerIssue[] | null | Promise<BakerIssue[] | null>;
+import type { RawClassMeta } from '../metadata';
+import type { SealOptions, SealedExecutors } from './interfaces';
+import type { DeserializeExecutor, ValidateExecutor } from './types';
 declare function buildDeserializeCode<T>(Class: Function, merged: RawClassMeta, options: SealOptions | undefined, needsCircularCheck: boolean, isAsync: boolean, resolve: (cls: Function) => SealedExecutors<unknown> | undefined): DeserializeExecutor<T>;
 declare function buildDeserializeCode(Class: Function, merged: RawClassMeta, options: SealOptions | undefined, needsCircularCheck: boolean, isAsync: boolean, resolve: (cls: Function) => SealedExecutors<unknown> | undefined, validateOnly: true): ValidateExecutor;
 declare function buildValidateCode(Class: Function, merged: RawClassMeta, options: SealOptions | undefined, needsCircularCheck: boolean, isAsync: boolean, resolve: (cls: Function) => SealedExecutors<unknown> | undefined): ValidateExecutor;