pyric 0.0.1 → 0.1.0-alpha.10

package/dist/rules/simulator/wrappers/base.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Wrapper class contract for Firestore Rules value types — see
+ * REBUILD_PLAN.md Item 0.B + Item 1.
+ *
+ * Why an abstract base instead of duck typing: the evaluator dispatches
+ * through six different code paths (rulesValuesEqual, memberAccess,
+ * bracketAccess, evaluateMethodCall, evaluateBinaryOp, isExpr, inExpr).
+ * Without a single base class, every new wrapper would have to be
+ * registered at six sites — and forgetting one is the exact failure mode
+ * 0.B is designed to prevent ("two `Timestamp` instances wrapping the
+ * same millis weren't `===`, so `request.time == otherTime` always
+ * denied in sim"). With this base class, every wrapper inherits all six
+ * dispatch hooks for free.
+ *
+ * Concrete subclasses (Timestamp, Duration, Bytes, LatLng) land in
+ * Item 1.1–1.4. Path lands in Item 5. This file is intentionally
+ * dead code until 1.1 — landing it first makes each wrapper sub-task
+ * a "fill in the blanks" exercise instead of a structural change.
+ */
+/**
+ * Sentinel returned by `binaryOp` / `callMethod` when the wrapper does
+ * not handle the requested operation/method. The evaluator interprets
+ * NO_OP as "fall through" — for `binaryOp` that means try the generic
+ * numeric path; for `callMethod` it means throw `UnsupportedError`.
+ *
+ * `Symbol.for` (registered symbol) survives module duplication that
+ * can happen across bun + esbuild + node test runners — `===` checks
+ * stay reliable even if `base.ts` is loaded under two different module
+ * specifiers.
+ */
+export declare const NO_OP: unique symbol;
+export type NoOp = typeof NO_OP;
+export declare abstract class RulesValue {
+    /**
+     * Stable type tag for `isExpr` dispatch — must match the names emitted
+     * by the parser for `is timestamp`, `is duration`, `is bytes`,
+     * `is latlng`, `is path`. Lowercase, single token.
+     */
+    abstract readonly typeName: string;
+    /**
+     * Numeric coercion for any code path that bypasses `binaryOp` and
+     * casts to number (legacy `as number` sites in evaluator.ts and any
+     * future `String(x)` / `Number(x)` calls). The 0.B per-wrapper table
+     * documents what each type returns:
+     *   Timestamp / Duration → seconds*1000 + Math.round(nanos/1e6) (millis)
+     *   Bytes                → data.length (byte count)
+     *   LatLng / Path        → NaN (no meaningful numeric coercion)
+     *
+     * Returning NaN for LatLng/Path is intentional — any rule that does
+     * arithmetic on them is buggy, and NaN propagation makes the failure
+     * loud rather than silent. The binary op hook (`binaryOp`) catches
+     * the supported cases above this fallback.
+     */
+    abstract valueOf(): number;
+    /**
+     * String coercion for map keys, regex args, path segments, the
+     * `string()` builtin, and template-style concatenation. Must
+     * round-trip through value-equality where the wrapper has a literal
+     * form: `parseRules(toString(x)).equals(x)` for Timestamp/Duration/
+     * LatLng/Path. Bytes is exempt (literal form is the base64 string,
+     * but the parser side will land with hashing.* in Item 5).
+     */
+    abstract toString(): string;
+    /**
+     * JSON-serializable form for debug output and any consumer that
+     * runs `JSON.stringify` on a TestResult. Returns a plain object with
+     * a `__type` discriminator so the serialized form is stable across
+     * releases — crucial for the parity stress harness's debugMessages.
+     */
+    abstract toJSON(): unknown;
+    /**
+     * Value equality. THE single source of truth for `==` / `!=` /
+     * `rulesValuesEqual`. `===` reference equality is intentionally
+     * insufficient (the 0.B failure: two `timestamp.value(1234)` calls
+     * produce two distinct instances; `===` is false; rule denies).
+     */
+    abstract equals(other: unknown): boolean;
+    /**
+     * Property access for `x.field` and `x[field]`. Default returns null
+     * (no such field) — the same shape Firestore rules use for missing
+     * map keys, so denial behavior is consistent.
+     *
+     * Wrappers override only for named properties they expose. Methods
+     * are NOT exposed via `field` — `x.size` evaluates the property to
+     * `null`, and `x.size()` goes through `callMethod` instead.
+     */
+    field(_name: string): unknown;
+    /**
+     * Method dispatch for `x.method(args)`. Default returns NO_OP — the
+     * evaluator turns NO_OP into `UnsupportedError`, which the handler
+     * maps to TestResult.state = 'UNSUPPORTED' (Item 0.A). That gives
+     * agents a clear "sim gap" signal rather than a silent DENY when a
+     * wrapper hasn't implemented a method yet.
+     *
+     * Wrappers override with a switch on `method` and dispatch to their
+     * own private methods. The dispatch table is intentionally not a
+     * `Record<string, Function>` — keeping it as a switch lets each
+     * wrapper apply its own arg validation and return-type promises
+     * inline rather than forcing a uniform signature.
+     */
+    callMethod(_method: string, _args: unknown[]): unknown | NoOp;
+    /**
+     * Cross-type binary operator dispatch. Default returns NO_OP — the
+     * evaluator falls through to generic numeric ops via `valueOf()`.
+     *
+     * Wrappers override for the operators they support. The 0.B
+     * "Required dispatch changes" table specifies the cross-type
+     * arithmetic each wrapper claims:
+     *   Timestamp + Duration → Timestamp
+     *   Timestamp - Timestamp → Duration
+     *   Timestamp - Duration → Timestamp
+     *   Duration ± Duration → Duration
+     *   Bytes < <= > >= Bytes → lexicographic byte compare
+     *
+     * `==` and `!=` do NOT route through this hook — they go through
+     * `rulesValuesEqual` which calls `equals()`. This split keeps the
+     * "is this the same value?" question separate from "what does
+     * `lhs OP rhs` evaluate to?".
+     *
+     * Dispatch is left-operand-only. For commutative ops where the
+     * right operand is a wrapper but the left isn't (e.g. `1 + duration`),
+     * the wrapper is responsible for handling reversed arguments via
+     * its own `binaryOp` when called from the right — the evaluator
+     * detects this by re-dispatching when `lv` isn't a wrapper but
+     * `rv` is, for the symmetric ops `==`, `!=`, `+`, `*`.
+     */
+    binaryOp(_op: string, _other: unknown): unknown | NoOp;
+}
+//# sourceMappingURL=base.d.ts.map

package/dist/rules/simulator/wrappers/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../../src/rules/simulator/wrappers/base.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,KAAK,EAAE,OAAO,MAAsD,CAAC;AAClF,MAAM,MAAM,IAAI,GAAG,OAAO,KAAK,CAAC;AAEhC,8BAAsB,UAAU;IAC9B;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAEnC;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,OAAO,IAAI,MAAM;IAE1B;;;;;;;OAOG;IACH,QAAQ,CAAC,QAAQ,IAAI,MAAM;IAE3B;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,IAAI,OAAO;IAE1B;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO;IAExC;;;;;;;;OAQG;IACH,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAI7B;;;;;;;;;;;;OAYG;IACH,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,OAAO,GAAG,IAAI;IAI7D;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,OAAO,GAAG,IAAI;CAGvD"}

package/dist/rules/simulator/wrappers/base.js

@@ -0,0 +1,90 @@
+/**
+ * Wrapper class contract for Firestore Rules value types — see
+ * REBUILD_PLAN.md Item 0.B + Item 1.
+ *
+ * Why an abstract base instead of duck typing: the evaluator dispatches
+ * through six different code paths (rulesValuesEqual, memberAccess,
+ * bracketAccess, evaluateMethodCall, evaluateBinaryOp, isExpr, inExpr).
+ * Without a single base class, every new wrapper would have to be
+ * registered at six sites — and forgetting one is the exact failure mode
+ * 0.B is designed to prevent ("two `Timestamp` instances wrapping the
+ * same millis weren't `===`, so `request.time == otherTime` always
+ * denied in sim"). With this base class, every wrapper inherits all six
+ * dispatch hooks for free.
+ *
+ * Concrete subclasses (Timestamp, Duration, Bytes, LatLng) land in
+ * Item 1.1–1.4. Path lands in Item 5. This file is intentionally
+ * dead code until 1.1 — landing it first makes each wrapper sub-task
+ * a "fill in the blanks" exercise instead of a structural change.
+ */
+/**
+ * Sentinel returned by `binaryOp` / `callMethod` when the wrapper does
+ * not handle the requested operation/method. The evaluator interprets
+ * NO_OP as "fall through" — for `binaryOp` that means try the generic
+ * numeric path; for `callMethod` it means throw `UnsupportedError`.
+ *
+ * `Symbol.for` (registered symbol) survives module duplication that
+ * can happen across bun + esbuild + node test runners — `===` checks
+ * stay reliable even if `base.ts` is loaded under two different module
+ * specifiers.
+ */
+export const NO_OP = Symbol.for('pyric.RulesValue.NO_OP');
+export class RulesValue {
+    /**
+     * Property access for `x.field` and `x[field]`. Default returns null
+     * (no such field) — the same shape Firestore rules use for missing
+     * map keys, so denial behavior is consistent.
+     *
+     * Wrappers override only for named properties they expose. Methods
+     * are NOT exposed via `field` — `x.size` evaluates the property to
+     * `null`, and `x.size()` goes through `callMethod` instead.
+     */
+    field(_name) {
+        return null;
+    }
+    /**
+     * Method dispatch for `x.method(args)`. Default returns NO_OP — the
+     * evaluator turns NO_OP into `UnsupportedError`, which the handler
+     * maps to TestResult.state = 'UNSUPPORTED' (Item 0.A). That gives
+     * agents a clear "sim gap" signal rather than a silent DENY when a
+     * wrapper hasn't implemented a method yet.
+     *
+     * Wrappers override with a switch on `method` and dispatch to their
+     * own private methods. The dispatch table is intentionally not a
+     * `Record<string, Function>` — keeping it as a switch lets each
+     * wrapper apply its own arg validation and return-type promises
+     * inline rather than forcing a uniform signature.
+     */
+    callMethod(_method, _args) {
+        return NO_OP;
+    }
+    /**
+     * Cross-type binary operator dispatch. Default returns NO_OP — the
+     * evaluator falls through to generic numeric ops via `valueOf()`.
+     *
+     * Wrappers override for the operators they support. The 0.B
+     * "Required dispatch changes" table specifies the cross-type
+     * arithmetic each wrapper claims:
+     *   Timestamp + Duration → Timestamp
+     *   Timestamp - Timestamp → Duration
+     *   Timestamp - Duration → Timestamp
+     *   Duration ± Duration → Duration
+     *   Bytes < <= > >= Bytes → lexicographic byte compare
+     *
+     * `==` and `!=` do NOT route through this hook — they go through
+     * `rulesValuesEqual` which calls `equals()`. This split keeps the
+     * "is this the same value?" question separate from "what does
+     * `lhs OP rhs` evaluate to?".
+     *
+     * Dispatch is left-operand-only. For commutative ops where the
+     * right operand is a wrapper but the left isn't (e.g. `1 + duration`),
+     * the wrapper is responsible for handling reversed arguments via
+     * its own `binaryOp` when called from the right — the evaluator
+     * detects this by re-dispatching when `lv` isn't a wrapper but
+     * `rv` is, for the symmetric ops `==`, `!=`, `+`, `*`.
+     */
+    binaryOp(_op, _other) {
+        return NO_OP;
+    }
+}
+//# sourceMappingURL=base.js.map

package/dist/rules/simulator/wrappers/base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.js","sourceRoot":"","sources":["../../../../src/rules/simulator/wrappers/base.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,KAAK,GAAkB,MAAM,CAAC,GAAG,CAAC,wBAAwB,CAAU,CAAC;AAGlF,MAAM,OAAgB,UAAU;IAkD9B;;;;;;;;OAQG;IACH,KAAK,CAAC,KAAa;QACjB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;;;;;;;OAYG;IACH,UAAU,CAAC,OAAe,EAAE,KAAgB;QAC1C,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,QAAQ,CAAC,GAAW,EAAE,MAAe;QACnC,OAAO,KAAK,CAAC;IACf,CAAC;CACF"}

package/dist/rules/simulator/wrappers/bytes.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Bytes wrapper — Item 5.3 of REBUILD_PLAN.md.
+ *
+ * Per type table:
+ *   size() → Integer       byte count
+ *   toBase64() → String    Base64url per RFC 4648 (URL-safe, no padding)
+ *   toHexString() → String lowercase hex
+ *
+ * Per 0.B per-wrapper table:
+ *   typeName: 'bytes'
+ *   valueOf:  data.length (byte count)
+ *   toString: base64url encoding (round-trips with hashing.* receipts)
+ *   equals:   byte-by-byte
+ *   binaryOp: lexicographic compare for < <= > >=
+ *
+ * Bytes was deferred from Item 1 because it has no JSON-test-data
+ * sentinel form — it only enters the evaluator via String.toUtf8() and
+ * hashing.*, both of which land in this same item (5.3). Landing the
+ * wrapper now means the constructors immediately have a real type to
+ * return.
+ */
+import { RulesValue, type NoOp } from './base.js';
+export declare class Bytes extends RulesValue {
+    readonly typeName = "bytes";
+    /** Raw byte data. Held as Uint8Array for predictable ordering and length. */
+    readonly data: Uint8Array;
+    constructor(data: Uint8Array);
+    /** Construct from a UTF-8 string. */
+    static fromUtf8(s: string): Bytes;
+    /** Construct from a hex string (e.g. 'deadbeef'). */
+    static fromHex(hex: string): Bytes;
+    /** Byte count — exposed via callMethod('size'). Also drives valueOf(). */
+    size(): number;
+    /** Base64url per RFC 4648 (URL-safe, no padding). */
+    toBase64(): string;
+    /** Lowercase hex. */
+    toHexString(): string;
+    valueOf(): number;
+    toString(): string;
+    toJSON(): unknown;
+    equals(other: unknown): boolean;
+    callMethod(method: string, _args: unknown[]): unknown | NoOp;
+    binaryOp(op: string, other: unknown): unknown | NoOp;
+}
+//# sourceMappingURL=bytes.d.ts.map

package/dist/rules/simulator/wrappers/bytes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytes.d.ts","sourceRoot":"","sources":["../../../../src/rules/simulator/wrappers/bytes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,EAAE,UAAU,EAAS,KAAK,IAAI,EAAE,MAAM,WAAW,CAAC;AAkCzD,qBAAa,KAAM,SAAQ,UAAU;IACnC,QAAQ,CAAC,QAAQ,WAAW;IAE5B,6EAA6E;IAC7E,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;gBAEd,IAAI,EAAE,UAAU;IAK5B,qCAAqC;IACrC,MAAM,CAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,KAAK;IAIjC,qDAAqD;IACrD,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK;IAWlC,0EAA0E;IAC1E,IAAI,IAAI,MAAM;IAId,qDAAqD;IACrD,QAAQ,IAAI,MAAM;IAIlB,qBAAqB;IACrB,WAAW,IAAI,MAAM;IAMrB,OAAO,IAAI,MAAM;IAIjB,QAAQ,IAAI,MAAM;IAIlB,MAAM,IAAI,OAAO;IAIjB,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO;IAS/B,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,OAAO,GAAG,IAAI;IAS5D,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,GAAG,IAAI;CAWrD"}

package/dist/rules/simulator/wrappers/bytes.js

@@ -0,0 +1,130 @@
+/**
+ * Bytes wrapper — Item 5.3 of REBUILD_PLAN.md.
+ *
+ * Per type table:
+ *   size() → Integer       byte count
+ *   toBase64() → String    Base64url per RFC 4648 (URL-safe, no padding)
+ *   toHexString() → String lowercase hex
+ *
+ * Per 0.B per-wrapper table:
+ *   typeName: 'bytes'
+ *   valueOf:  data.length (byte count)
+ *   toString: base64url encoding (round-trips with hashing.* receipts)
+ *   equals:   byte-by-byte
+ *   binaryOp: lexicographic compare for < <= > >=
+ *
+ * Bytes was deferred from Item 1 because it has no JSON-test-data
+ * sentinel form — it only enters the evaluator via String.toUtf8() and
+ * hashing.*, both of which land in this same item (5.3). Landing the
+ * wrapper now means the constructors immediately have a real type to
+ * return.
+ */
+import { RulesValue, NO_OP } from './base.js';
+// Base64url + hex encoders. Browser-safe — no Buffer, no node:crypto.
+// Behavior pinned by bytes.test.ts to match the previous Buffer-based
+// output across UTF-8 / arbitrary-byte / empty fixtures.
+const HEX = '0123456789abcdef';
+function toHex(bytes) {
+    let out = '';
+    for (let i = 0; i < bytes.length; i++) {
+        const b = bytes[i];
+        out += HEX[b >>> 4] + HEX[b & 0x0f];
+    }
+    return out;
+}
+function toBase64Url(bytes) {
+    // btoa exists in browsers and Node 16+; we encode the byte string
+    // through it, then map the standard alphabet to URL-safe (- _) and
+    // strip padding per RFC 4648 section 5.
+    let bin = '';
+    for (let i = 0; i < bytes.length; i++)
+        bin += String.fromCharCode(bytes[i]);
+    const std = btoa(bin);
+    return std.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+}
+function lexicographicCompare(a, b) {
+    const len = Math.min(a.length, b.length);
+    for (let i = 0; i < len; i++) {
+        if (a[i] !== b[i])
+            return a[i] < b[i] ? -1 : 1;
+    }
+    return a.length === b.length ? 0 : (a.length < b.length ? -1 : 1);
+}
+export class Bytes extends RulesValue {
+    typeName = 'bytes';
+    /** Raw byte data. Held as Uint8Array for predictable ordering and length. */
+    data;
+    constructor(data) {
+        super();
+        this.data = data;
+    }
+    /** Construct from a UTF-8 string. */
+    static fromUtf8(s) {
+        return new Bytes(new TextEncoder().encode(s));
+    }
+    /** Construct from a hex string (e.g. 'deadbeef'). */
+    static fromHex(hex) {
+        if (hex.length % 2 !== 0) {
+            throw new Error(`Invalid hex string length: ${hex.length}`);
+        }
+        const out = new Uint8Array(hex.length / 2);
+        for (let i = 0; i < out.length; i++) {
+            out[i] = parseInt(hex.substr(i * 2, 2), 16);
+        }
+        return new Bytes(out);
+    }
+    /** Byte count — exposed via callMethod('size'). Also drives valueOf(). */
+    size() {
+        return this.data.length;
+    }
+    /** Base64url per RFC 4648 (URL-safe, no padding). */
+    toBase64() {
+        return toBase64Url(this.data);
+    }
+    /** Lowercase hex. */
+    toHexString() {
+        return toHex(this.data);
+    }
+    // ─── RulesValue contract ─────────────────────────────────────────────
+    valueOf() {
+        return this.data.length;
+    }
+    toString() {
+        return this.toBase64();
+    }
+    toJSON() {
+        return { __type: 'bytes', base64: this.toBase64() };
+    }
+    equals(other) {
+        if (!(other instanceof Bytes))
+            return false;
+        if (this.data.length !== other.data.length)
+            return false;
+        for (let i = 0; i < this.data.length; i++) {
+            if (this.data[i] !== other.data[i])
+                return false;
+        }
+        return true;
+    }
+    callMethod(method, _args) {
+        switch (method) {
+            case 'size': return this.size();
+            case 'toBase64': return this.toBase64();
+            case 'toHexString': return this.toHexString();
+        }
+        return NO_OP;
+    }
+    binaryOp(op, other) {
+        if (!(other instanceof Bytes))
+            return NO_OP;
+        const cmp = lexicographicCompare(this.data, other.data);
+        switch (op) {
+            case '<': return cmp < 0;
+            case '<=': return cmp <= 0;
+            case '>': return cmp > 0;
+            case '>=': return cmp >= 0;
+        }
+        return NO_OP;
+    }
+}
+//# sourceMappingURL=bytes.js.map

package/dist/rules/simulator/wrappers/bytes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytes.js","sourceRoot":"","sources":["../../../../src/rules/simulator/wrappers/bytes.ts"],"names":[],"mappings":"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"}

package/dist/rules/simulator/wrappers/duration.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Duration wrapper for Firestore Rules `duration` type — Item 1.2.
+ *
+ * Closes the entire `Duration` type gap from REBUILD_PLAN.md (was
+ * "❌ entire type" in the Reference Inventory) and the `duration.abs`
+ * namespace gap.
+ *
+ * Reference surface (from REBUILD_PLAN.md "Reference Inventory"):
+ *   - seconds() → Integer (signed, [-315_576_000_000, +315_576_000_000])
+ *   - nanos()   → Integer (signed, [-999_999_999, +999_999_999])
+ *   - Operators: ==, !=, <, <=, >, >=, Duration ± Duration → Duration
+ *
+ * Construction (all flip atomically per REBUILD_PLAN Risk 3):
+ *   - duration.value(magnitude, unit)  unit ∈ w|d|h|m|s|ms|ns
+ *   - duration.time(h, m, s, ns)
+ *   - duration.abs(d)
+ *
+ * Internal storage per 0.C: plain `{ seconds, nanos }` Numbers, *not*
+ * a single millis number — the millis path silently truncates
+ * sub-millisecond precision. Comparison and arithmetic go through
+ * field-wise math; valueOf() exists only for legacy `as number` sites
+ * that don't route through binaryOp.
+ *
+ * Canonical form: same sign for `seconds` and `nanos`, with
+ * `|nanos| < 1_000_000_000`. This matches Google's protobuf Duration
+ * canonical form so `equals()` is a straight field compare without
+ * normalizing on every call.
+ */
+import { RulesValue, type NoOp } from './base.js';
+export declare class Duration extends RulesValue {
+    readonly typeName = "duration";
+    readonly seconds: number;
+    readonly nanos: number;
+    constructor(seconds: number, nanos: number);
+    /**
+     * `duration.value(magnitude, unit)` — magnitude is Integer per spec.
+     * For `ms` and `ns` we route through integer math so a magnitude of
+     * `2500` ns doesn't become `2.5e-6` seconds (float artifact); for
+     * larger units the seconds-per-unit factor is exact.
+     */
+    static fromValue(magnitude: number, unit: string): Duration;
+    /** `duration.time(h, m, s, ns)`. */
+    static fromTime(h: number, m: number, s: number, ns: number): Duration;
+    /**
+     * `duration.abs(d)`. Because canonical form forces same sign for
+     * both fields, we can safely take `Math.abs` of each independently
+     * — there's no field-pair like `(1, -500_000_000)` to worry about.
+     */
+    static abs(d: Duration): Duration;
+    /**
+     * Millisecond approximation. Used only by legacy `as number` sites
+     * that bypass binaryOp; comparison/arithmetic go through binaryOp's
+     * field-wise path so sub-ms precision survives. See REBUILD_PLAN 0.C.
+     */
+    valueOf(): number;
+    /**
+     * `${signedSeconds}.${absNanos}s` with 9-digit zero-padded fractional.
+     * Negative durations carry a single leading minus on the integer part
+     * — `Number(toString(d))` does not need to round-trip (no parser
+     * support for duration literals); this format mirrors protobuf's
+     * canonical text form for debugging readability.
+     */
+    toString(): string;
+    toJSON(): unknown;
+    equals(other: unknown): boolean;
+    callMethod(method: string, _args: unknown[]): unknown | NoOp;
+    /**
+     * Duration ± Duration → Duration; Duration cmp Duration via field
+     * compare. Cross-type with Timestamp lands in 1.3. NO_OP for any
+     * other operand pair so the evaluator's Risk 2 guard surfaces
+     * `duration + 1` etc. as a real type error, not silent NaN.
+     */
+    binaryOp(op: string, other: unknown): unknown | NoOp;
+    private compareTo;
+}
+//# sourceMappingURL=duration.d.ts.map

package/dist/rules/simulator/wrappers/duration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duration.d.ts","sourceRoot":"","sources":["../../../../src/rules/simulator/wrappers/duration.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,OAAO,EAAE,UAAU,EAAS,KAAK,IAAI,EAAE,MAAM,WAAW,CAAC;AAmCzD,qBAAa,QAAS,SAAQ,UAAU;IACtC,QAAQ,CAAC,QAAQ,cAAc;IAC/B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;gBAEX,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IAO1C;;;;;OAKG;IACH,MAAM,CAAC,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,QAAQ;IAmB3D,oCAAoC;IACpC,MAAM,CAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,QAAQ;IAItE;;;;OAIG;IACH,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,QAAQ,GAAG,QAAQ;IAIjC;;;;OAIG;IACH,OAAO,IAAI,MAAM;IAIjB;;;;;;OAMG;IACH,QAAQ,IAAI,MAAM;IAOlB,MAAM,IAAI,OAAO;IAIjB,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO;IAQ/B,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,OAAO,GAAG,IAAI;IAW5D;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,GAAG,IAAI;IAoBpD,OAAO,CAAC,SAAS;CAIlB"}

package/dist/rules/simulator/wrappers/duration.js

@@ -0,0 +1,176 @@
+/**
+ * Duration wrapper for Firestore Rules `duration` type — Item 1.2.
+ *
+ * Closes the entire `Duration` type gap from REBUILD_PLAN.md (was
+ * "❌ entire type" in the Reference Inventory) and the `duration.abs`
+ * namespace gap.
+ *
+ * Reference surface (from REBUILD_PLAN.md "Reference Inventory"):
+ *   - seconds() → Integer (signed, [-315_576_000_000, +315_576_000_000])
+ *   - nanos()   → Integer (signed, [-999_999_999, +999_999_999])
+ *   - Operators: ==, !=, <, <=, >, >=, Duration ± Duration → Duration
+ *
+ * Construction (all flip atomically per REBUILD_PLAN Risk 3):
+ *   - duration.value(magnitude, unit)  unit ∈ w|d|h|m|s|ms|ns
+ *   - duration.time(h, m, s, ns)
+ *   - duration.abs(d)
+ *
+ * Internal storage per 0.C: plain `{ seconds, nanos }` Numbers, *not*
+ * a single millis number — the millis path silently truncates
+ * sub-millisecond precision. Comparison and arithmetic go through
+ * field-wise math; valueOf() exists only for legacy `as number` sites
+ * that don't route through binaryOp.
+ *
+ * Canonical form: same sign for `seconds` and `nanos`, with
+ * `|nanos| < 1_000_000_000`. This matches Google's protobuf Duration
+ * canonical form so `equals()` is a straight field compare without
+ * normalizing on every call.
+ */
+import { RulesValue, NO_OP } from './base.js';
+const NANOS_PER_SECOND = 1_000_000_000;
+const SECONDS_PER_UNIT = {
+    w: 7 * 24 * 60 * 60,
+    d: 24 * 60 * 60,
+    h: 60 * 60,
+    m: 60,
+    s: 1,
+};
+/**
+ * Roll over-/under-flow nanos into seconds and force same sign for both
+ * fields. Two normalization passes:
+ *   1. Carry whole seconds out of nanos.
+ *   2. Reconcile sign mismatch between seconds and nanos.
+ *
+ * Without step 2, `(1, -500_000_000)` would survive as a non-canonical
+ * form, breaking `equals()` against the equivalent `(0, 500_000_000)`
+ * produced by a different construction path.
+ */
+function normalize(seconds, nanos) {
+    let s = seconds + Math.trunc(nanos / NANOS_PER_SECOND);
+    let n = nanos % NANOS_PER_SECOND;
+    if (s > 0 && n < 0) {
+        s -= 1;
+        n += NANOS_PER_SECOND;
+    }
+    else if (s < 0 && n > 0) {
+        s += 1;
+        n -= NANOS_PER_SECOND;
+    }
+    return { seconds: s, nanos: n };
+}
+export class Duration extends RulesValue {
+    typeName = 'duration';
+    seconds;
+    nanos;
+    constructor(seconds, nanos) {
+        super();
+        const norm = normalize(seconds, nanos);
+        this.seconds = norm.seconds;
+        this.nanos = norm.nanos;
+    }
+    /**
+     * `duration.value(magnitude, unit)` — magnitude is Integer per spec.
+     * For `ms` and `ns` we route through integer math so a magnitude of
+     * `2500` ns doesn't become `2.5e-6` seconds (float artifact); for
+     * larger units the seconds-per-unit factor is exact.
+     */
+    static fromValue(magnitude, unit) {
+        if (unit in SECONDS_PER_UNIT) {
+            return new Duration(magnitude * SECONDS_PER_UNIT[unit], 0);
+        }
+        if (unit === 'ms') {
+            const wholeSec = Math.trunc(magnitude / 1000);
+            const remainderMs = magnitude - wholeSec * 1000;
+            return new Duration(wholeSec, remainderMs * 1_000_000);
+        }
+        if (unit === 'ns') {
+            const wholeSec = Math.trunc(magnitude / NANOS_PER_SECOND);
+            const remainderNs = magnitude - wholeSec * NANOS_PER_SECOND;
+            return new Duration(wholeSec, remainderNs);
+        }
+        throw new Error(`Unknown duration unit '${unit}' (expected one of: w, d, h, m, s, ms, ns)`);
+    }
+    /** `duration.time(h, m, s, ns)`. */
+    static fromTime(h, m, s, ns) {
+        return new Duration(h * 3600 + m * 60 + s, ns);
+    }
+    /**
+     * `duration.abs(d)`. Because canonical form forces same sign for
+     * both fields, we can safely take `Math.abs` of each independently
+     * — there's no field-pair like `(1, -500_000_000)` to worry about.
+     */
+    static abs(d) {
+        return new Duration(Math.abs(d.seconds), Math.abs(d.nanos));
+    }
+    /**
+     * Millisecond approximation. Used only by legacy `as number` sites
+     * that bypass binaryOp; comparison/arithmetic go through binaryOp's
+     * field-wise path so sub-ms precision survives. See REBUILD_PLAN 0.C.
+     */
+    valueOf() {
+        return this.seconds * 1000 + Math.round(this.nanos / 1e6);
+    }
+    /**
+     * `${signedSeconds}.${absNanos}s` with 9-digit zero-padded fractional.
+     * Negative durations carry a single leading minus on the integer part
+     * — `Number(toString(d))` does not need to round-trip (no parser
+     * support for duration literals); this format mirrors protobuf's
+     * canonical text form for debugging readability.
+     */
+    toString() {
+        const negative = this.seconds < 0 || this.nanos < 0;
+        const absSec = Math.abs(this.seconds);
+        const absNanos = Math.abs(this.nanos);
+        return `${negative ? '-' : ''}${absSec}.${absNanos.toString().padStart(9, '0')}s`;
+    }
+    toJSON() {
+        return { __type: 'duration', seconds: this.seconds, nanos: this.nanos };
+    }
+    equals(other) {
+        return (other instanceof Duration &&
+            this.seconds === other.seconds &&
+            this.nanos === other.nanos);
+    }
+    callMethod(method, _args) {
+        switch (method) {
+            case 'seconds':
+                return this.seconds;
+            case 'nanos':
+                return this.nanos;
+            default:
+                return NO_OP;
+        }
+    }
+    /**
+     * Duration ± Duration → Duration; Duration cmp Duration via field
+     * compare. Cross-type with Timestamp lands in 1.3. NO_OP for any
+     * other operand pair so the evaluator's Risk 2 guard surfaces
+     * `duration + 1` etc. as a real type error, not silent NaN.
+     */
+    binaryOp(op, other) {
+        if (!(other instanceof Duration))
+            return NO_OP;
+        switch (op) {
+            case '+':
+                return new Duration(this.seconds + other.seconds, this.nanos + other.nanos);
+            case '-':
+                return new Duration(this.seconds - other.seconds, this.nanos - other.nanos);
+            case '<':
+                return this.compareTo(other) < 0;
+            case '<=':
+                return this.compareTo(other) <= 0;
+            case '>':
+                return this.compareTo(other) > 0;
+            case '>=':
+                return this.compareTo(other) >= 0;
+            default:
+                return NO_OP;
+        }
+    }
+    compareTo(other) {
+        if (this.seconds !== other.seconds)
+            return this.seconds - other.seconds;
+        return this.nanos - other.nanos;
+    }
+}
+//# sourceMappingURL=duration.js.map