@zipbul/baker 2.2.0 → 3.0.1

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

@@ -1,10 +1,16 @@
 import type { RuntimeOptions } from '../interfaces';
 /**
  * Converts a Class instance to a plain object.
- * - Auto-seals on first call (batches entire globalRegistry)
+ * - Requires `seal()` to be called beforehand; throws `BakerError` if not sealed
  * - Sync DTOs return directly; async DTOs return Promise
  * - No validation — always returns Record<string, unknown>
- * - Class without decorators: throws SealError
  */
-export declare function serialize<T>(instance: T, options?: RuntimeOptions): Record<string, unknown>;
-export declare function serialize<T>(instance: T, options?: RuntimeOptions): Promise<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

@@ -0,0 +1,52 @@
+import { BakerError } from '../errors.js';
+import { ensureSealed } from '../seal/seal.js';
+import { checkCallOptions } from './check-call-options.js';
+// ─────────────────────────────────────────────────────────────────────────────
+// serialize — Public API (§5.2)
+// ─────────────────────────────────────────────────────────────────────────────
+/** Boundary check shared by serialize / serializeSync / serializeAsync. */
+function resolveSerializer(instance, fnName) {
+    if (instance == null || typeof instance !== 'object') {
+        throw new BakerError(`${fnName}: expected a class instance, got ${instance === null ? 'null' : typeof instance}`);
+    }
+    const Class = instance.constructor;
+    if (typeof Class !== 'function') {
+        throw new BakerError(`${fnName}: instance has no constructor`);
+    }
+    // Reject plain objects and forged ones (e.g. `{ constructor: SomeDto }`): a real instance is
+    // `instanceof` its own constructor via the prototype chain; the `constructor` property alone
+    // (which anyone can set) is not trusted.
+    if (Class === Object || !(instance instanceof Class)) {
+        throw new BakerError(`${fnName}: received a plain object. Pass an instance of a DTO class decorated with @Field.`);
+    }
+    return ensureSealed(Class);
+}
+export function serialize(instance, options) {
+    const checkedOpts = checkCallOptions(options);
+    const sealed = resolveSerializer(instance, 'serialize');
+    return sealed.isSerializeAsync
+        ? sealed.serialize(instance, checkedOpts)
+        : sealed.serialize(instance, checkedOpts);
+}
+/**
+ * Sync-asserted serialize. Throws `BakerError` if Class has any async transform on the serialize side.
+ */
+export function serializeSync(instance, options) {
+    const checkedOpts = checkCallOptions(options);
+    const sealed = resolveSerializer(instance, 'serializeSync');
+    if (sealed.isSerializeAsync) {
+        const className = instance.constructor.name;
+        throw new BakerError(`serializeSync(${className}): DTO has async serialize transforms. Use serializeAsync() instead.`);
+    }
+    return sealed.serialize(instance, checkedOpts);
+}
+/**
+ * Async-asserted serialize. Always returns Promise (sync DTOs are wrapped via Promise.resolve).
+ */
+export function serializeAsync(instance, options) {
+    const checkedOpts = checkCallOptions(options);
+    const sealed = resolveSerializer(instance, 'serializeAsync');
+    return sealed.isSerializeAsync
+        ? sealed.serialize(instance, checkedOpts)
+        : Promise.resolve(sealed.serialize(instance, checkedOpts));
+}

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

@@ -1,15 +1,18 @@
-import type { BakerErrors } from '../errors';
-import type { EmittableRule } from '../types';
+import type { BakerIssueSet } from '../errors';
 import type { RuntimeOptions } from '../interfaces';
 /**
- * DTO-level validation — validates input against a decorated class.
- * Sync DTOs return directly; async DTOs return Promise.
+ * 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)`).
  */
-export declare function validate<T>(Class: new (...args: any[]) => T, input: unknown, options?: RuntimeOptions): true | BakerErrors;
-export declare function validate<T>(Class: new (...args: any[]) => T, input: unknown, options?: RuntimeOptions): Promise<true | BakerErrors>;
+declare function validate<T>(Class: new (...args: never[]) => T, input: unknown, options?: RuntimeOptions): true | BakerIssueSet | Promise<true | BakerIssueSet>;
 /**
- * Ad-hoc validation — validates a single value against one or more rules.
- * Sync rules return directly; async rules return Promise.
+ * Sync-asserted validate. Throws `BakerError` if Class has any async rule/transform
+ * on the deserialize/validate side. Use when caller code assumes sync return.
  */
-export declare function validate(input: unknown, ...rules: EmittableRule[]): true | BakerErrors;
-export declare function validate(input: unknown, ...rules: EmittableRule[]): Promise<true | BakerErrors>;
+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

@@ -0,0 +1,49 @@
+import { toBakerIssueSet, BakerError } from '../errors.js';
+import { ensureSealed } from '../seal/seal.js';
+import { checkCallOptions } from './check-call-options.js';
+// ─────────────────────────────────────────────────────────────────────────────
+// validate — Public API (§5.3)
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * 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)`).
+ */
+function validate(Class, input, options) {
+    const checkedOpts = checkCallOptions(options);
+    const sealed = ensureSealed(Class);
+    if (sealed.isAsync) {
+        return sealed.validate(input, checkedOpts).then((result) => result === null ? true : toBakerIssueSet(result));
+    }
+    const result = sealed.validate(input, checkedOpts);
+    return result === null ? true : toBakerIssueSet(result);
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// W14: strict sync/async variants — explicit intent at call site
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Sync-asserted validate. Throws `BakerError` if Class has any async rule/transform
+ * on the deserialize/validate side. Use when caller code assumes sync return.
+ */
+function validateSync(Class, input, options) {
+    const checkedOpts = checkCallOptions(options);
+    const sealed = ensureSealed(Class);
+    if (sealed.isAsync) {
+        throw new BakerError(`validateSync(${Class.name}): DTO has async rules/transforms. Use validateAsync() instead.`);
+    }
+    const result = sealed.validate(input, checkedOpts);
+    return result === null ? true : toBakerIssueSet(result);
+}
+/**
+ * Async-asserted validate. Always returns Promise (sync DTOs are wrapped via Promise.resolve).
+ */
+function validateAsync(Class, input, options) {
+    const checkedOpts = checkCallOptions(options);
+    const sealed = ensureSealed(Class);
+    if (sealed.isAsync) {
+        return sealed.validate(input, checkedOpts).then((r) => r === null ? true : toBakerIssueSet(r));
+    }
+    const result = sealed.validate(input, checkedOpts);
+    return Promise.resolve(result === null ? true : toBakerIssueSet(result));
+}
+export { validate, validateSync, validateAsync };

package/dist/src/interfaces.d.ts

@@ -16,7 +16,7 @@ export interface SealOptions {
     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.
+     * `@Exclude` fields are also included in the whitelist — their presence is allowed but they are excluded from the result.
      * @default false
      */
     whitelist?: boolean;

package/dist/src/interfaces.js

@@ -0,0 +1,4 @@
+// ─────────────────────────────────────────────────────────────────────────────
+// SealOptions — seal() global options (§1.4)
+// ─────────────────────────────────────────────────────────────────────────────
+export {};

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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,75 @@
+import { RAW, SEALED } from './symbols.js';
+/** Returns the metadata object visible on cls (own or inherited via the class prototype chain). */
+function metaOf(cls) {
+    return cls[Symbol.metadata] ?? undefined;
+}
+/** Returns the class's own metadata object, creating one if absent. */
+function ensureOwnMeta(cls) {
+    if (!Object.hasOwn(cls, Symbol.metadata)) {
+        Object.defineProperty(cls, Symbol.metadata, {
+            value: {},
+            writable: true,
+            configurable: true,
+            enumerable: false,
+        });
+    }
+    return cls[Symbol.metadata];
+}
+export function getSealed(cls) {
+    return cls[SEALED];
+}
+/** Same as getSealed but throws if the class is not sealed — for callers that establish the invariant elsewhere. */
+export function requireSealed(cls) {
+    const v = cls[SEALED];
+    if (v === undefined) {
+        throw new Error(`${cls.name || '<anonymous>'}: class is not sealed`);
+    }
+    return v;
+}
+export function setSealed(cls, exec) {
+    cls[SEALED] = exec;
+}
+export function hasSealedOwn(cls) {
+    return Object.hasOwn(cls, SEALED);
+}
+export function deleteSealed(cls) {
+    delete cls[SEALED];
+}
+export function deleteRaw(cls) {
+    if (Object.hasOwn(cls, Symbol.metadata)) {
+        delete cls[Symbol.metadata][RAW];
+    }
+}
+export function getRaw(cls) {
+    return metaOf(cls)?.[RAW];
+}
+/** Same as getRaw but throws if the class has no @Field decorators — for callers that establish the invariant elsewhere. */
+export function requireRaw(cls) {
+    const v = getRaw(cls);
+    if (v === undefined) {
+        throw new Error(`${cls.name || '<anonymous>'}: class has no @Field decorators`);
+    }
+    return v;
+}
+export function setRaw(cls, raw) {
+    ensureOwnMeta(cls)[RAW] = raw;
+}
+/**
+ * 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 function hasRawOwn(cls) {
+    if (!Object.hasOwn(cls, Symbol.metadata)) {
+        return false;
+    }
+    const meta = cls[Symbol.metadata];
+    return meta != null && Object.hasOwn(meta, RAW);
+}
+export function freezeRaw(cls) {
+    // Guard on own RAW: an inherited-only subclass must not freeze the parent's RAW.
+    if (!hasRawOwn(cls)) {
+        return;
+    }
+    Object.freeze(getRaw(cls));
+}

package/dist/src/registry.js

@@ -0,0 +1,8 @@
+/**
+ * Global registry — automatically registers classes with at least one decorator attached
+ *
+ * - Automatically called from ensureMeta()
+ * - seal() iterates this Set to seal all DTOs
+ * - Metadata is not stored here — used only as an index (which classes are registered)
+ */
+export const globalRegistry = new Set();

package/dist/src/rule-metadata.d.ts

@@ -0,0 +1,11 @@
+import type { EmittableRule, InternalRule, RulePlan } from './types';
+interface RuleMetadata {
+    emit: EmittableRule['emit'];
+    ruleName: string;
+    requiresType?: EmittableRule['requiresType'];
+    constraints?: Record<string, unknown>;
+    isAsync?: boolean;
+    plan?: RulePlan;
+}
+export declare function defineRuleMetadata(fn: InternalRule, meta: RuleMetadata): void;
+export {};

package/dist/src/rule-metadata.js

@@ -0,0 +1,17 @@
+export function defineRuleMetadata(fn, meta) {
+    const target = fn;
+    target.emit = meta.emit;
+    target.ruleName = meta.ruleName;
+    if (meta.requiresType !== undefined) {
+        target.requiresType = meta.requiresType;
+    }
+    if (meta.constraints !== undefined) {
+        target.constraints = meta.constraints;
+    }
+    if (meta.isAsync !== undefined) {
+        target.isAsync = meta.isAsync;
+    }
+    if (meta.plan) {
+        target.plan = meta.plan;
+    }
+}

package/dist/src/rule-plan.d.ts

@@ -3,21 +3,20 @@ type RulePlanCache = {
     length?: string;
     time?: string;
 };
-export declare const planValue: () => RulePlanExpr;
-export declare const planLength: (object?: RulePlanExpr) => RulePlanExpr;
-export declare const planTime: (object?: RulePlanExpr) => RulePlanExpr;
-export declare const planLiteral: (value: number) => RulePlanExpr;
-export declare const planCompare: (left: RulePlanExpr, op: "<" | "<=" | ">" | ">=" | "===" | "!==", right: number | RulePlanExpr) => RulePlanCheck;
-export declare const planAnd: (...checks: RulePlanCheck[]) => RulePlanCheck;
-export declare const planOr: (...checks: RulePlanCheck[]) => RulePlanCheck;
-export declare function makePlannedRule(options: {
+declare const planValue: () => RulePlanExpr;
+declare const planLength: (object?: RulePlanExpr) => RulePlanExpr;
+declare const planTime: (object?: RulePlanExpr) => RulePlanExpr;
+declare const planLiteral: (value: number) => RulePlanExpr;
+declare const planCompare: (left: RulePlanExpr, op: "<" | "<=" | ">" | ">=" | "===" | "!==", right: number | RulePlanExpr) => RulePlanCheck;
+declare const planOr: (...checks: RulePlanCheck[]) => RulePlanCheck;
+declare function makePlannedRule(options: {
     name: string;
     requiresType: 'string' | 'number' | 'boolean' | 'date' | 'array' | 'object';
     constraints?: Record<string, unknown>;
     plan: RulePlan;
     validate: (value: unknown) => boolean;
 }): InternalRule;
-export declare function makeRule(options: {
+declare function makeRule(options: {
     name: string;
     validate: (value: unknown) => boolean | Promise<boolean>;
     emit: (varName: string, ctx: EmitContext) => string;
@@ -26,5 +25,5 @@ export declare function makeRule(options: {
     isAsync?: boolean;
     plan?: RulePlan;
 }): InternalRule;
-export declare function emitRulePlan(varName: string, ctx: EmitContext, ruleName: string, plan: RulePlan, cache?: RulePlanCache, insideTypeGate?: boolean): string;
-export {};
+declare function emitRulePlan(varName: string, ctx: EmitContext, ruleName: string, plan: RulePlan, cache?: RulePlanCache, insideTypeGate?: boolean): string;
+export { planValue, planLength, planTime, planLiteral, planCompare, planOr, makePlannedRule, makeRule, emitRulePlan };

package/dist/src/rule-plan.js

@@ -0,0 +1,117 @@
+import { defineRuleMetadata } from './rule-metadata.js';
+const planValue = () => ({ kind: 'value' });
+const planLength = (object = planValue()) => ({
+    kind: 'member',
+    object,
+    property: 'length',
+});
+const planTime = (object = planValue()) => ({
+    kind: 'call0',
+    object,
+    method: 'getTime',
+});
+const planLiteral = (value) => ({ kind: 'literal', value });
+const planCompare = (left, op, right) => ({
+    kind: 'compare',
+    left,
+    op,
+    right: typeof right === 'number' ? planLiteral(right) : right,
+});
+const planOr = (...checks) => ({ kind: 'or', checks });
+function makePlannedRule(options) {
+    const inner = {
+        name: options.name,
+        requiresType: options.requiresType,
+        plan: options.plan,
+        validate: options.validate,
+        emit: (varName, ctx) => emitRulePlan(varName, ctx, options.name, options.plan, undefined, ctx.insideTypeGate),
+    };
+    if (options.constraints !== undefined) {
+        inner.constraints = options.constraints;
+    }
+    return makeRule(inner);
+}
+function makeRule(options) {
+    const fn = ((value) => options.validate(value));
+    const meta = {
+        emit: options.emit,
+        ruleName: options.name,
+        constraints: options.constraints ?? {},
+    };
+    if (options.requiresType !== undefined) {
+        meta.requiresType = options.requiresType;
+    }
+    if (options.isAsync !== undefined) {
+        meta.isAsync = options.isAsync;
+    }
+    if (options.plan !== undefined) {
+        meta.plan = options.plan;
+    }
+    defineRuleMetadata(fn, meta);
+    return fn;
+}
+function emitRulePlan(varName, ctx, ruleName, plan, cache, insideTypeGate) {
+    const failure = insideTypeGate ? stripSelfComparison(plan.failure) : plan.failure;
+    return `if (${emitPlanCheck(failure, varName, cache)}) ${ctx.fail(ruleName)};`;
+}
+/** Strip `x !== x` / `getTime() !== getTime()` self-comparison guards — redundant inside type gate */
+function stripSelfComparison(check) {
+    if (check.kind === 'compare') {
+        return check;
+    }
+    const filtered = check.checks.filter(c => !isSelfComparison(c));
+    if (filtered.length === 0) {
+        return check;
+    } // safety: don't strip everything
+    if (filtered.length === 1) {
+        return filtered[0];
+    }
+    return { kind: check.kind, checks: filtered };
+}
+function isSelfComparison(check) {
+    if (check.kind !== 'compare' || check.op !== '!==') {
+        return false;
+    }
+    return exprEqual(check.left, check.right);
+}
+function exprEqual(a, b) {
+    if (a.kind !== b.kind) {
+        return false;
+    }
+    switch (a.kind) {
+        case 'value':
+            return true;
+        case 'literal':
+            return a.value === b.value;
+        case 'member':
+            return exprEqual(a.object, b.object);
+        case 'call0':
+            return a.method === b.method && exprEqual(a.object, b.object);
+        default:
+            // Compile-time exhaustiveness: adding a RulePlanExpr.kind without a case fails to compile here.
+            return a;
+    }
+}
+function emitPlanCheck(check, varName, cache) {
+    if (check.kind === 'compare') {
+        return `${emitPlanExpr(check.left, varName, cache)} ${check.op} ${emitPlanExpr(check.right, varName, cache)}`;
+    }
+    const joiner = check.kind === 'and' ? ' && ' : ' || ';
+    return `(${check.checks.map(part => emitPlanCheck(part, varName, cache)).join(joiner)})`;
+}
+function emitPlanExpr(expr, varName, cache) {
+    switch (expr.kind) {
+        case 'value':
+            return varName;
+        case 'literal':
+            return String(expr.value);
+        case 'member':
+            return cache?.length ?? `${emitPlanExpr(expr.object, varName, cache)}.length`;
+        case 'call0':
+            return cache?.time ?? `${emitPlanExpr(expr.object, varName, cache)}.getTime()`;
+        default:
+            // Compile-time exhaustiveness: adding a RulePlanExpr.kind without a case fails to compile here.
+            return expr;
+    }
+}
+export { planValue, planLength, planTime, planLiteral, planCompare, planOr, makePlannedRule, makeRule, emitRulePlan };

package/dist/src/rules/array.d.ts

@@ -1,7 +1,8 @@
 import type { EmittableRule } from '../types';
-export declare function arrayContains(values: unknown[]): EmittableRule;
-export declare function arrayNotContains(values: unknown[]): EmittableRule;
-export declare function arrayMinSize(min: number): EmittableRule;
-export declare function arrayMaxSize(max: number): EmittableRule;
-export declare function arrayUnique(identifier?: (val: unknown) => unknown): EmittableRule;
-export declare const arrayNotEmpty: import("../types").InternalRule;
+declare function arrayContains(values: unknown[]): EmittableRule;
+declare function arrayNotContains(values: unknown[]): EmittableRule;
+declare function arrayMinSize(min: number): EmittableRule;
+declare function arrayMaxSize(max: number): EmittableRule;
+declare function arrayUnique(identifier?: (val: unknown) => unknown): EmittableRule;
+declare const arrayNotEmpty: import("../types").InternalRule;
+export { arrayContains, arrayNotContains, arrayMinSize, arrayMaxSize, arrayUnique, arrayNotEmpty };

package/dist/src/rules/array.js

@@ -0,0 +1,96 @@
+import { makePlannedRule, makeRule, planCompare, planLength } from '../rule-plan.js';
+// ─────────────────────────────────────────────────────────────────────────────
+// arrayContains(values) — array contains all specified values
+// ─────────────────────────────────────────────────────────────────────────────
+function arrayContains(values) {
+    return makeRule({
+        name: 'arrayContains',
+        requiresType: 'array',
+        constraints: { values },
+        validate: value => Array.isArray(value) && values.every(v => value.includes(v)),
+        emit: (varName, ctx) => {
+            const i = ctx.addRef(values);
+            return `if (!refs[${i}].every(function(v){return ${varName}.includes(v);})) ${ctx.fail('arrayContains')};`;
+        },
+    });
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// arrayNotContains(values) — array does not contain any of the specified values
+// ─────────────────────────────────────────────────────────────────────────────
+function arrayNotContains(values) {
+    return makeRule({
+        name: 'arrayNotContains',
+        requiresType: 'array',
+        constraints: { values },
+        validate: value => Array.isArray(value) && values.every(v => !value.includes(v)),
+        emit: (varName, ctx) => {
+            const i = ctx.addRef(values);
+            return `if (refs[${i}].some(function(v){return ${varName}.includes(v);})) ${ctx.fail('arrayNotContains')};`;
+        },
+    });
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// arrayMinSize(min) — minimum array length
+// ─────────────────────────────────────────────────────────────────────────────
+function arrayMinSize(min) {
+    const plan = { cacheKey: 'length', failure: planCompare(planLength(), '<', min) };
+    return makePlannedRule({
+        name: 'arrayMinSize',
+        requiresType: 'array',
+        constraints: { min },
+        plan,
+        validate: value => Array.isArray(value) && value.length >= min,
+    });
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// arrayMaxSize(max) — maximum array length
+// ─────────────────────────────────────────────────────────────────────────────
+function arrayMaxSize(max) {
+    const plan = { cacheKey: 'length', failure: planCompare(planLength(), '>', max) };
+    return makePlannedRule({
+        name: 'arrayMaxSize',
+        requiresType: 'array',
+        constraints: { max },
+        plan,
+        validate: value => Array.isArray(value) && value.length <= max,
+    });
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// arrayUnique(identifier?) — no duplicates in array
+// ─────────────────────────────────────────────────────────────────────────────
+function arrayUnique(identifier) {
+    return makeRule({
+        name: 'arrayUnique',
+        requiresType: 'array',
+        constraints: {},
+        validate: value => {
+            if (!Array.isArray(value)) {
+                return false;
+            }
+            if (identifier) {
+                const keys = value.map(identifier);
+                return new Set(keys).size === keys.length;
+            }
+            return new Set(value).size === value.length;
+        },
+        emit: (varName, ctx) => {
+            if (identifier) {
+                const i = ctx.addRef(identifier);
+                return `{var keys=${varName}.map(refs[${i}]);if(new Set(keys).size!==keys.length)${ctx.fail('arrayUnique')};}`;
+            }
+            return `if(new Set(${varName}).size!==${varName}.length)${ctx.fail('arrayUnique')};`;
+        },
+    });
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// arrayNotEmpty — array is not empty (singleton)
+// ─────────────────────────────────────────────────────────────────────────────
+const arrayNotEmptyPlan = { cacheKey: 'length', failure: planCompare(planLength(), '===', 0) };
+const arrayNotEmpty = makePlannedRule({
+    name: 'arrayNotEmpty',
+    requiresType: 'array',
+    constraints: {},
+    plan: arrayNotEmptyPlan,
+    validate: value => Array.isArray(value) && value.length > 0,
+});
+export { arrayContains, arrayNotContains, arrayMinSize, arrayMaxSize, arrayUnique, arrayNotEmpty };