pyric 0.0.1 → 0.1.0-alpha.7

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

@@ -0,0 +1,145 @@
+/**
+ * Reference wrapper — Item 3 of simulator-prod-parity.md.
+ *
+ * Reference surface (rules.Reference):
+ *   - `.path`   — relative document path string ('users/u1')
+ *   - `.id`     — last segment of the path ('u1')
+ *   - `.parent` — parent collection path string ('users')
+ *   - `is reference` — type test
+ *   - `==` / `!=` against another Reference
+ *
+ * Per 0.B per-wrapper table:
+ *   typeName: 'reference'
+ *   valueOf:  NaN          (no meaningful numeric coercion — like Path/LatLng)
+ *   toString: 'users/u1'   (relative path; round-trips with the admin SDK
+ *                          DocumentReference.path getter)
+ *   equals:   path-string equality (project/database not significant in
+ *             the simulator — every Reference lives in the same logical DB)
+ *   binaryOp: NO_OP (== / != route through equals)
+ *
+ * Why a relative-path-only wrapper rather than a full project/database/doc
+ * model: Firestore rules see references as opaque path values. The
+ * `referenceValue` wire encoding *does* need a fully-qualified
+ * `projects/<p>/databases/<d>/documents/<path>` string for round-trip
+ * with discover/wire.ts, but that's a write-out concern — the wire
+ * encoder synthesizes a default qualifier on the way out. Inside the
+ * simulator, two references are the same reference iff their relative
+ * paths match.
+ *
+ * The admin SDK DocumentReference exposes more (e.g., `.firestore`,
+ * `formattedName`); the rules language does not — we deliberately
+ * shrink to the rules-visible surface so accidental `ref.firestore`
+ * reads in a rule (which production would silently null out) match
+ * the simulator.
+ */
+import { RulesValue, NO_OP } from './base.js';
+export class Reference extends RulesValue {
+    typeName = 'reference';
+    /** Relative document path, e.g. 'users/u1' or 'users/u1/posts/p1'. */
+    path;
+    constructor(path) {
+        super();
+        // Normalize: strip any leading slash, trailing slash, or fully-qualified
+        // `projects/.../documents/` prefix so internal compares are uniform.
+        this.path = normalizeRelativePath(path);
+    }
+    /**
+     * Construct from an admin-SDK-style fully-qualified resource name like
+     * `projects/p/databases/(default)/documents/users/u1`. The fully-
+     * qualified form is what `referenceValue` emits on the wire; using this
+     * helper at the decode boundary keeps the relative-path invariant.
+     */
+    static fromResourceName(resourceName) {
+        return new Reference(stripDocumentsPrefix(resourceName));
+    }
+    /** Last path segment; '' for an empty path. */
+    get id() {
+        const i = this.path.lastIndexOf('/');
+        return i === -1 ? this.path : this.path.slice(i + 1);
+    }
+    /**
+     * Parent collection path as a string. For `users/u1` returns `users`;
+     * for `users/u1/posts/p1` returns `users/u1/posts`. An empty string
+     * if there is no parent (a root-level reference is degenerate, but
+     * we don't throw to keep diagnostics-friendly).
+     *
+     * Returning a string (not a Reference) matches Firestore rules' lack of
+     * a CollectionReference type — collections aren't first-class values in
+     * rules. Agents that want to compare against a collection path do so by
+     * string equality, which this supports.
+     */
+    get parent() {
+        const i = this.path.lastIndexOf('/');
+        return i === -1 ? '' : this.path.slice(0, i);
+    }
+    // ─── RulesValue contract ─────────────────────────────────────────────
+    valueOf() {
+        return NaN; // No meaningful numeric coercion (matches Path, LatLng).
+    }
+    toString() {
+        // Relative path matches the admin SDK DocumentReference.path getter
+        // exactly, so a rule that does `string(ref) == 'users/u1'` works
+        // without needing the fully-qualified form.
+        return this.path;
+    }
+    toJSON() {
+        return { __type: 'reference', path: this.path };
+    }
+    equals(other) {
+        if (!(other instanceof Reference))
+            return false;
+        return this.path === other.path;
+    }
+    /**
+     * Property dispatch. Mirrors the admin SDK read surface: `.path`,
+     * `.id`, `.parent`. Anything else returns null (Firestore rules
+     * "missing map key" shape, consistent with other wrappers).
+     */
+    field(name) {
+        switch (name) {
+            case 'path': return this.path;
+            case 'id': return this.id;
+            case 'parent': return this.parent;
+            default: return null;
+        }
+    }
+    callMethod(_method, _args) {
+        // References have no callable methods in the rules language — the
+        // admin SDK's get/set/update aren't exposed to rules. Returning
+        // NO_OP triggers UnsupportedError so a rule like `ref.get()` fails
+        // loudly rather than silently denying.
+        return NO_OP;
+    }
+}
+// ─── Helpers ─────────────────────────────────────────────────────────────
+/**
+ * Strip leading slash and any `projects/<p>/databases/<d>/documents/`
+ * prefix to produce the relative path. Tolerates both forms because
+ * agents may seed either shape.
+ */
+function normalizeRelativePath(path) {
+    let p = stripDocumentsPrefix(path);
+    if (p.startsWith('/'))
+        p = p.slice(1);
+    if (p.endsWith('/'))
+        p = p.slice(0, -1);
+    return p;
+}
+function stripDocumentsPrefix(s) {
+    const marker = '/documents/';
+    const idx = s.indexOf(marker);
+    if (idx === -1)
+        return s;
+    return s.slice(idx + marker.length);
+}
+/**
+ * Build the fully-qualified resource name used by Firestore's
+ * `referenceValue` wire field. The simulator doesn't carry a real
+ * project ID, so callers (the wire encoder) supply one — defaulting
+ * to `'sim'` and database `'(default)'` keeps the round-trip intact
+ * without inventing fake projects in the wrapper itself.
+ */
+export function referenceToResourceName(ref, projectId = 'sim', databaseId = '(default)') {
+    return `projects/${projectId}/databases/${databaseId}/documents/${ref.path}`;
+}
+//# sourceMappingURL=reference.js.map

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

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

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

@@ -0,0 +1,86 @@
+/**
+ * Timestamp wrapper for Firestore Rules `timestamp` type — Item 1.3.
+ *
+ * Closes the entire `Timestamp` type gap (was "❌ entire type" in the
+ * REBUILD_PLAN Reference Inventory) and the `request.time` type bug
+ * (was an ISO string — see REBUILD_PLAN Risk 1).
+ *
+ * Reference surface (12 instance methods):
+ *   date, day, dayOfWeek, dayOfYear, hours, minutes, month, nanos,
+ *   seconds, time, toMillis, year
+ *
+ * Construction (atomic flip per REBUILD_PLAN Risk 3):
+ *   - timestamp.date(y, m, d)            month is 1-based
+ *   - timestamp.value(epochMs)            millis since Unix epoch
+ *   - request.time                        wrapped by handler.ts
+ *   - serverTimestamp sentinel resolution wrapped by handler.ts
+ *
+ * Internal storage per 0.C: plain `{ seconds, nanos }` Numbers.
+ * Comparison and arithmetic go field-wise via binaryOp; valueOf() is a
+ * legacy-fallback only and silently truncates sub-ms precision.
+ *
+ * Canonical form: nanos in `[0, 999_999_999]` non-negative (protobuf
+ * Timestamp spec). Negative epoch seconds are allowed (pre-1970) but
+ * nanos always normalize positive — `equals()` is a straight field
+ * compare without per-call normalization.
+ */
+import { RulesValue, type NoOp } from './base.js';
+export declare class Timestamp extends RulesValue {
+    readonly typeName = "timestamp";
+    readonly seconds: number;
+    readonly nanos: number;
+    constructor(seconds: number, nanos: number);
+    /** `timestamp.value(epochMs)` — milliseconds since Unix epoch. */
+    static fromMillis(ms: number): Timestamp;
+    /** `timestamp.date(y, m, d)` — midnight UTC; month is 1-based. */
+    static fromYMD(year: number, month: number, day: number): Timestamp;
+    /**
+     * Parse an ISO-8601 string into a Timestamp. Used by `handler.ts` to
+     * convert `tc.requestTime` (kept as ISO string for backwards-compat
+     * with the prod Test API) into the wrapper. Sub-millisecond precision
+     * in the input string is dropped because `Date.parse` only sees ms —
+     * acceptable here because `tc.requestTime` is a developer-facing pin
+     * (no nanosecond precision test exists for it).
+     */
+    static fromIsoString(iso: string): Timestamp;
+    toMillis(): number;
+    /**
+     * Convert to a JavaScript `Date` (millisecond precision).
+     * Sub-millisecond nanos are dropped — same behaviour as the real
+     * `firebase/firestore` `Timestamp.toDate()`.
+     */
+    toDate(): Date;
+    valueOf(): number;
+    /**
+     * ISO-8601 UTC with 9-digit nanosecond precision. Standard
+     * `Date.toISOString()` only carries millisecond precision; we
+     * substitute the full nanos to preserve sub-ms detail for
+     * debugMessages.
+     */
+    toString(): string;
+    toJSON(): unknown;
+    equals(other: unknown): boolean;
+    /**
+     * Date components (year/month/day/hours/etc.) derive from JS `Date`
+     * which only handles millisecond precision. The Timestamp's `seconds`
+     * field already encodes whole-seconds, so date math is exact even
+     * when sub-ms nanos are present. `dayOfWeek` follows ISO 8601:
+     * Monday = 1, Sunday = 7.
+     */
+    callMethod(method: string, _args: unknown[]): unknown | NoOp;
+    private asDate;
+    /**
+     * Cross-type arithmetic per REBUILD_PLAN Operators table:
+     *   Timestamp + Duration → Timestamp
+     *   Timestamp - Duration → Timestamp
+     *   Timestamp - Timestamp → Duration
+     * Plus `< <= > >=` for two Timestamps via field-wise compareTo.
+     *
+     * `Duration + Timestamp` (commutative) is reachable through the
+     * evaluator's right-side dispatch on `+` — Duration.binaryOp returns
+     * NO_OP, then `rv` (Timestamp).binaryOp(+, lv) lands here.
+     */
+    binaryOp(op: string, other: unknown): unknown | NoOp;
+    private compareTo;
+}
+//# sourceMappingURL=timestamp.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"timestamp.d.ts","sourceRoot":"","sources":["../../../../src/rules/simulator/wrappers/timestamp.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,OAAO,EAAE,UAAU,EAAS,KAAK,IAAI,EAAE,MAAM,WAAW,CAAC;AAoBzD,qBAAa,SAAU,SAAQ,UAAU;IACvC,QAAQ,CAAC,QAAQ,eAAe;IAChC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;gBAEX,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IAO1C,kEAAkE;IAClE,MAAM,CAAC,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS;IAMxC,kEAAkE;IAClE,MAAM,CAAC,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,SAAS;IAInE;;;;;;;OAOG;IACH,MAAM,CAAC,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS;IAI5C,QAAQ,IAAI,MAAM;IAIlB;;;;OAIG;IACH,MAAM,IAAI,IAAI;IAId,OAAO,IAAI,MAAM;IAIjB;;;;;OAKG;IACH,QAAQ,IAAI,MAAM;IAMlB,MAAM,IAAI,OAAO;IAIjB,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO;IAQ/B;;;;;;OAMG;IACH,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,OAAO,GAAG,IAAI;IAgD5D,OAAO,CAAC,MAAM;IAId;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,GAAG,IAAI;IA8BpD,OAAO,CAAC,SAAS;CAIlB"}

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

@@ -0,0 +1,207 @@
+/**
+ * Timestamp wrapper for Firestore Rules `timestamp` type — Item 1.3.
+ *
+ * Closes the entire `Timestamp` type gap (was "❌ entire type" in the
+ * REBUILD_PLAN Reference Inventory) and the `request.time` type bug
+ * (was an ISO string — see REBUILD_PLAN Risk 1).
+ *
+ * Reference surface (12 instance methods):
+ *   date, day, dayOfWeek, dayOfYear, hours, minutes, month, nanos,
+ *   seconds, time, toMillis, year
+ *
+ * Construction (atomic flip per REBUILD_PLAN Risk 3):
+ *   - timestamp.date(y, m, d)            month is 1-based
+ *   - timestamp.value(epochMs)            millis since Unix epoch
+ *   - request.time                        wrapped by handler.ts
+ *   - serverTimestamp sentinel resolution wrapped by handler.ts
+ *
+ * Internal storage per 0.C: plain `{ seconds, nanos }` Numbers.
+ * Comparison and arithmetic go field-wise via binaryOp; valueOf() is a
+ * legacy-fallback only and silently truncates sub-ms precision.
+ *
+ * Canonical form: nanos in `[0, 999_999_999]` non-negative (protobuf
+ * Timestamp spec). Negative epoch seconds are allowed (pre-1970) but
+ * nanos always normalize positive — `equals()` is a straight field
+ * compare without per-call normalization.
+ */
+import { RulesValue, NO_OP } from './base.js';
+import { Duration } from './duration.js';
+const NANOS_PER_SECOND = 1_000_000_000;
+const MS_PER_DAY = 86_400_000;
+const SECONDS_PER_DAY = 86_400;
+/**
+ * Roll over-/under-flow nanos into seconds and force nanos non-negative.
+ * Uses `Math.floor` (not truncation) so negative nanos correctly borrow
+ * a second: `(0, -1)` → `(-1, 999_999_999)` rather than `(0, -1)`.
+ */
+function normalize(seconds, nanos) {
+    const carry = Math.floor(nanos / NANOS_PER_SECOND);
+    return {
+        seconds: seconds + carry,
+        nanos: nanos - carry * NANOS_PER_SECOND,
+    };
+}
+export class Timestamp extends RulesValue {
+    typeName = 'timestamp';
+    seconds;
+    nanos;
+    constructor(seconds, nanos) {
+        super();
+        const norm = normalize(seconds, nanos);
+        this.seconds = norm.seconds;
+        this.nanos = norm.nanos;
+    }
+    /** `timestamp.value(epochMs)` — milliseconds since Unix epoch. */
+    static fromMillis(ms) {
+        const seconds = Math.floor(ms / 1000);
+        const remainderMs = ms - seconds * 1000;
+        return new Timestamp(seconds, remainderMs * 1_000_000);
+    }
+    /** `timestamp.date(y, m, d)` — midnight UTC; month is 1-based. */
+    static fromYMD(year, month, day) {
+        return Timestamp.fromMillis(Date.UTC(year, month - 1, day));
+    }
+    /**
+     * Parse an ISO-8601 string into a Timestamp. Used by `handler.ts` to
+     * convert `tc.requestTime` (kept as ISO string for backwards-compat
+     * with the prod Test API) into the wrapper. Sub-millisecond precision
+     * in the input string is dropped because `Date.parse` only sees ms —
+     * acceptable here because `tc.requestTime` is a developer-facing pin
+     * (no nanosecond precision test exists for it).
+     */
+    static fromIsoString(iso) {
+        return Timestamp.fromMillis(Date.parse(iso));
+    }
+    toMillis() {
+        return this.seconds * 1000 + Math.floor(this.nanos / 1_000_000);
+    }
+    /**
+     * Convert to a JavaScript `Date` (millisecond precision).
+     * Sub-millisecond nanos are dropped — same behaviour as the real
+     * `firebase/firestore` `Timestamp.toDate()`.
+     */
+    toDate() {
+        return new Date(this.toMillis());
+    }
+    valueOf() {
+        return this.toMillis();
+    }
+    /**
+     * ISO-8601 UTC with 9-digit nanosecond precision. Standard
+     * `Date.toISOString()` only carries millisecond precision; we
+     * substitute the full nanos to preserve sub-ms detail for
+     * debugMessages.
+     */
+    toString() {
+        const isoMs = new Date(this.toMillis()).toISOString();
+        const nanoStr = this.nanos.toString().padStart(9, '0');
+        return isoMs.replace(/\.\d{3}Z$/, `.${nanoStr}Z`);
+    }
+    toJSON() {
+        return { __type: 'timestamp', seconds: this.seconds, nanos: this.nanos };
+    }
+    equals(other) {
+        return (other instanceof Timestamp &&
+            this.seconds === other.seconds &&
+            this.nanos === other.nanos);
+    }
+    /**
+     * Date components (year/month/day/hours/etc.) derive from JS `Date`
+     * which only handles millisecond precision. The Timestamp's `seconds`
+     * field already encodes whole-seconds, so date math is exact even
+     * when sub-ms nanos are present. `dayOfWeek` follows ISO 8601:
+     * Monday = 1, Sunday = 7.
+     */
+    callMethod(method, _args) {
+        switch (method) {
+            case 'seconds':
+                return this.seconds;
+            case 'nanos':
+                return this.nanos;
+            case 'toMillis':
+                return this.toMillis();
+            case 'year':
+                return this.asDate().getUTCFullYear();
+            case 'month':
+                return this.asDate().getUTCMonth() + 1;
+            case 'day':
+                return this.asDate().getUTCDate();
+            case 'hours':
+                return this.asDate().getUTCHours();
+            case 'minutes':
+                return this.asDate().getUTCMinutes();
+            case 'dayOfWeek': {
+                const jsDay = this.asDate().getUTCDay(); // 0=Sun .. 6=Sat
+                return jsDay === 0 ? 7 : jsDay;
+            }
+            case 'dayOfYear': {
+                const d = this.asDate();
+                const startOfYear = Date.UTC(d.getUTCFullYear(), 0, 1);
+                return Math.floor((this.toMillis() - startOfYear) / MS_PER_DAY) + 1;
+            }
+            case 'date':
+                // Same year/month/day, time-of-day zeroed.
+                return Timestamp.fromYMD(this.asDate().getUTCFullYear(), this.asDate().getUTCMonth() + 1, this.asDate().getUTCDate());
+            case 'time': {
+                // Time-of-day as Duration. Compute from seconds field directly
+                // so sub-ms nanos survive (JS Date would truncate them).
+                const secOfDay = ((this.seconds % SECONDS_PER_DAY) + SECONDS_PER_DAY) % SECONDS_PER_DAY;
+                const h = Math.floor(secOfDay / 3600);
+                const m = Math.floor((secOfDay % 3600) / 60);
+                const s = secOfDay % 60;
+                return Duration.fromTime(h, m, s, this.nanos);
+            }
+            default:
+                return NO_OP;
+        }
+    }
+    asDate() {
+        return new Date(this.toMillis());
+    }
+    /**
+     * Cross-type arithmetic per REBUILD_PLAN Operators table:
+     *   Timestamp + Duration → Timestamp
+     *   Timestamp - Duration → Timestamp
+     *   Timestamp - Timestamp → Duration
+     * Plus `< <= > >=` for two Timestamps via field-wise compareTo.
+     *
+     * `Duration + Timestamp` (commutative) is reachable through the
+     * evaluator's right-side dispatch on `+` — Duration.binaryOp returns
+     * NO_OP, then `rv` (Timestamp).binaryOp(+, lv) lands here.
+     */
+    binaryOp(op, other) {
+        if (other instanceof Timestamp) {
+            switch (op) {
+                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;
+            }
+        }
+        if (other instanceof Duration) {
+            switch (op) {
+                case '+':
+                    return new Timestamp(this.seconds + other.seconds, this.nanos + other.nanos);
+                case '-':
+                    return new Timestamp(this.seconds - other.seconds, this.nanos - other.nanos);
+                default:
+                    return NO_OP;
+            }
+        }
+        return NO_OP;
+    }
+    compareTo(other) {
+        if (this.seconds !== other.seconds)
+            return this.seconds - other.seconds;
+        return this.nanos - other.nanos;
+    }
+}
+//# sourceMappingURL=timestamp.js.map

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

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

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

@@ -0,0 +1,43 @@
+/**
+ * Vector wrapper — Item 5 of simulator-prod-parity.md.
+ *
+ * Vector surface (rules side):
+ *   The Firestore Rules language does NOT expose a `vector` type test
+ *   or any vector-specific properties. Vectors exist purely on the data
+ *   side — they round-trip through wire encoding so that the discover
+ *   crawler reports `kind: 'vector', dimension: N`, and so that rules
+ *   that treat the field as an opaque map (`field is map`, etc.) see
+ *   the sentinel shape live Firestore would expose.
+ *
+ *   Because there's no `is vector` in the grammar, the wrapper's
+ *   typeName isn't a parser-visible token; it's still recorded for
+ *   diagnostics and the toJSON debug shape.
+ *
+ * Per 0.B per-wrapper table:
+ *   typeName: 'vector'
+ *   valueOf:  NaN          (no meaningful numeric coercion)
+ *   toString: '[v0, v1, ...]'  (human-readable, no parser round-trip)
+ *   equals:   element-wise equality on .value arrays
+ *   binaryOp: NO_OP (no defined cross-type ops)
+ *
+ * Why a class wrapper rather than a plain `{__type__: '__vector__'}`
+ * object: the write-boundary resolver descends into plain objects but
+ * skips class instances. Wrapping in a class is what makes "agent
+ * passes admin SDK VectorValue" round-trip cleanly without having to
+ * detect the sentinel map at every read site too.
+ */
+import { RulesValue, type NoOp } from './base.js';
+export declare class Vector extends RulesValue {
+    readonly typeName = "vector";
+    /** Defensive copy of the input array — Vector instances are immutable. */
+    readonly value: readonly number[];
+    constructor(value: readonly number[]);
+    /** Length of the vector — how many components it has. */
+    get dimension(): number;
+    valueOf(): number;
+    toString(): string;
+    toJSON(): unknown;
+    equals(other: unknown): boolean;
+    callMethod(_method: string, _args: unknown[]): unknown | NoOp;
+}
+//# sourceMappingURL=vector.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"vector.d.ts","sourceRoot":"","sources":["../../../../src/rules/simulator/wrappers/vector.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,OAAO,EAAE,UAAU,EAAS,KAAK,IAAI,EAAE,MAAM,WAAW,CAAC;AAEzD,qBAAa,MAAO,SAAQ,UAAU;IACpC,QAAQ,CAAC,QAAQ,YAAY;IAE7B,0EAA0E;IAC1E,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;gBAEtB,KAAK,EAAE,SAAS,MAAM,EAAE;IAgBpC,yDAAyD;IACzD,IAAI,SAAS,IAAI,MAAM,CAEtB;IAID,OAAO,IAAI,MAAM;IAIjB,QAAQ,IAAI,MAAM;IAIlB,MAAM,IAAI,OAAO;IAOjB,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO;IAS/B,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,OAAO,GAAG,IAAI;CAI9D"}

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

@@ -0,0 +1,80 @@
+/**
+ * Vector wrapper — Item 5 of simulator-prod-parity.md.
+ *
+ * Vector surface (rules side):
+ *   The Firestore Rules language does NOT expose a `vector` type test
+ *   or any vector-specific properties. Vectors exist purely on the data
+ *   side — they round-trip through wire encoding so that the discover
+ *   crawler reports `kind: 'vector', dimension: N`, and so that rules
+ *   that treat the field as an opaque map (`field is map`, etc.) see
+ *   the sentinel shape live Firestore would expose.
+ *
+ *   Because there's no `is vector` in the grammar, the wrapper's
+ *   typeName isn't a parser-visible token; it's still recorded for
+ *   diagnostics and the toJSON debug shape.
+ *
+ * Per 0.B per-wrapper table:
+ *   typeName: 'vector'
+ *   valueOf:  NaN          (no meaningful numeric coercion)
+ *   toString: '[v0, v1, ...]'  (human-readable, no parser round-trip)
+ *   equals:   element-wise equality on .value arrays
+ *   binaryOp: NO_OP (no defined cross-type ops)
+ *
+ * Why a class wrapper rather than a plain `{__type__: '__vector__'}`
+ * object: the write-boundary resolver descends into plain objects but
+ * skips class instances. Wrapping in a class is what makes "agent
+ * passes admin SDK VectorValue" round-trip cleanly without having to
+ * detect the sentinel map at every read site too.
+ */
+import { RulesValue, NO_OP } from './base.js';
+export class Vector extends RulesValue {
+    typeName = 'vector';
+    /** Defensive copy of the input array — Vector instances are immutable. */
+    value;
+    constructor(value) {
+        super();
+        if (!Array.isArray(value)) {
+            throw new TypeError('Vector: value must be a number[]');
+        }
+        for (let i = 0; i < value.length; i++) {
+            if (typeof value[i] !== 'number') {
+                throw new TypeError(`Vector: element at index ${i} is not a number (got ${typeof value[i]})`);
+            }
+        }
+        // Freeze a copy so callers can't mutate the wrapper after construction.
+        this.value = Object.freeze(value.slice());
+    }
+    /** Length of the vector — how many components it has. */
+    get dimension() {
+        return this.value.length;
+    }
+    // ─── RulesValue contract ─────────────────────────────────────────────
+    valueOf() {
+        return NaN; // No meaningful numeric coercion.
+    }
+    toString() {
+        return `[${this.value.join(', ')}]`;
+    }
+    toJSON() {
+        // Mirrors the wire sentinel shape (`__type__`/`value`) so a
+        // JSON.stringify round-trip looks like the encoded form a
+        // discover crawler would see.
+        return { __type__: '__vector__', value: this.value.slice() };
+    }
+    equals(other) {
+        if (!(other instanceof Vector))
+            return false;
+        if (other.value.length !== this.value.length)
+            return false;
+        for (let i = 0; i < this.value.length; i++) {
+            if (other.value[i] !== this.value[i])
+                return false;
+        }
+        return true;
+    }
+    callMethod(_method, _args) {
+        // No methods exposed to rules.
+        return NO_OP;
+    }
+}
+//# sourceMappingURL=vector.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"vector.js","sourceRoot":"","sources":["../../../../src/rules/simulator/wrappers/vector.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,OAAO,EAAE,UAAU,EAAE,KAAK,EAAa,MAAM,WAAW,CAAC;AAEzD,MAAM,OAAO,MAAO,SAAQ,UAAU;IAC3B,QAAQ,GAAG,QAAQ,CAAC;IAE7B,0EAA0E;IACjE,KAAK,CAAoB;IAElC,YAAY,KAAwB;QAClC,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YAC1B,MAAM,IAAI,SAAS,CAAC,kCAAkC,CAAC,CAAC;QAC1D,CAAC;QACD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACtC,IAAI,OAAO,KAAK,CAAC,CAAC,CAAC,KAAK,QAAQ,EAAE,CAAC;gBACjC,MAAM,IAAI,SAAS,CACjB,4BAA4B,CAAC,yBAAyB,OAAO,KAAK,CAAC,CAAC,CAAC,GAAG,CACzE,CAAC;YACJ,CAAC;QACH,CAAC;QACD,wEAAwE;QACxE,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC;IAC5C,CAAC;IAED,yDAAyD;IACzD,IAAI,SAAS;QACX,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;IAC3B,CAAC;IAED,wEAAwE;IAExE,OAAO;QACL,OAAO,GAAG,CAAC,CAAC,kCAAkC;IAChD,CAAC;IAED,QAAQ;QACN,OAAO,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC;IACtC,CAAC;IAED,MAAM;QACJ,4DAA4D;QAC5D,0DAA0D;QAC1D,8BAA8B;QAC9B,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC;IAC/D,CAAC;IAED,MAAM,CAAC,KAAc;QACnB,IAAI,CAAC,CAAC,KAAK,YAAY,MAAM,CAAC;YAAE,OAAO,KAAK,CAAC;QAC7C,IAAI,KAAK,CAAC,KAAK,CAAC,MAAM,KAAK,IAAI,CAAC,KAAK,CAAC,MAAM;YAAE,OAAO,KAAK,CAAC;QAC3D,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAC3C,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;gBAAE,OAAO,KAAK,CAAC;QACrD,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,UAAU,CAAC,OAAe,EAAE,KAAgB;QAC1C,+BAA+B;QAC/B,OAAO,KAAK,CAAC;IACf,CAAC;CACF"}

package/dist/rules/simulator-tools-impl.d.ts

@@ -0,0 +1,64 @@
+/**
+ * `createFirestoreSimulatorTools` factory — extracted from `tools.ts`
+ * so it can run in both Node and the browser without forcing the
+ * Node-only `resolveModules` (which reads stdlib off disk) into the
+ * browser bundle.
+ *
+ * The factory takes `resolveModulesFn` as an injected dep:
+ *  - `pyric/rules/node` wires `resolveModules` from `./modules/resolver.js`
+ *    — Node's disk-reading version.
+ *  - `./simulator.ts` wires `resolveModulesBrowser` from
+ *    `./modules/resolver-browser.js`, which pre-supplies the stdlib content
+ *    inlined at build time.
+ *  - When the dep is absent, the `firestore_simulator_create` tool
+ *    returns a clear error if a caller seeds `'2+modules'` rules.
+ *
+ * Why this matters: prior to the extraction, `@pyric/dev`'s browser
+ * client hand-coded a parallel dispatcher that mirrored these tool
+ * shapes. Any new simulator tool added to `tools.ts` silently
+ * diverged from the dispatcher. Now both sides consume this single
+ * source of truth.
+ */
+import type { ToolHandler } from '@inbrowser/agent';
+import type { LocalEnvironment } from 'pyric/sandbox/internal';
+import type { ResolveResult } from './modules/resolver.js';
+export interface FirestoreSimulatorToolDeps {
+    /**
+     * Per-dispatch resolver returning the session's LocalEnvironment.
+     * Per F4, handlers call this inside `execute` — hosts that reset
+     * or swap the sandbox transparently get fresh environments
+     * without re-registering tools.
+     *
+     * For sessions that need a single long-lived env, the host can
+     * pass `() => singletonEnv`; for fleets that isolate per-session,
+     * `() => sessionContext.env`.
+     */
+    resolveSandbox: () => LocalEnvironment | Promise<LocalEnvironment>;
+    /**
+     * Resolver for `rules_version = '2+modules'` sources. Wire one of:
+     *   - `resolveModules` from `./modules/resolver.js` (Node; disk).
+     *   - `resolveModulesBrowser` from `./modules/resolver-browser.js`
+     *     (browser; inlined stdlib).
+     * When absent, attempts to seed `2+modules` rules error cleanly.
+     */
+    resolveModulesFn?: (source: string) => ResolveResult;
+}
+/**
+ * Stateful simulator tools — operate against a session-scoped
+ * `LocalEnvironment`. The nine-tool family — `_create`, `_execute`,
+ * `_read`, `_batch`, `_create_with_auto_id`, `_undo`, `_redo`,
+ * `_events`, `_transaction` — is the factory-shaped simulator tool group.
+ *
+ * Key shape difference vs legacy: there is no `environmentId`. In
+ * factory mode the resolved `LocalEnvironment` IS the environment —
+ * one per session. Hosts that need multi-env semantics can layer
+ * registry/context above the resolver. `firestore_simulator_create`
+ * therefore acts as a re-seed: it overwrites whatever the resolved
+ * env held before.
+ *
+ * `resolveSandbox` is awaited inside each handler so hosts that swap
+ * environments transparently (per-session fleets, hot-reload pipes)
+ * get fresh refs without re-registering tools.
+ */
+export declare function createFirestoreSimulatorTools(deps: FirestoreSimulatorToolDeps): ToolHandler[];
+//# sourceMappingURL=simulator-tools-impl.d.ts.map

package/dist/rules/simulator-tools-impl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simulator-tools-impl.d.ts","sourceRoot":"","sources":["../../src/rules/simulator-tools-impl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAW3D,MAAM,WAAW,0BAA0B;IACzC;;;;;;;;;OASG;IACH,cAAc,EAAE,MAAM,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;IACnE;;;;;;OAMG;IACH,gBAAgB,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,aAAa,CAAC;CACtD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,0BAA0B,GAC/B,WAAW,EAAE,CAmdf"}