pyric 0.0.1 → 0.1.0-alpha.7

package/dist/sandbox/firestore/converters/fieldvalue.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Item 2 — FieldValue sentinel converters.
+ *
+ * Four converters resolve the Firestore FieldValue sentinels at the
+ * write boundary, alongside the Date/serverTimestamp converters from
+ * Item 1:
+ *
+ *   - `increment`     — `{ __type:'increment', value:n }` → prior + n
+ *   - `arrayUnion`    — `{ __type:'arrayUnion', values:[…] }` →
+ *                       prior array with new values appended (deduped)
+ *   - `arrayRemove`   — `{ __type:'arrayRemove', values:[…] }` →
+ *                       prior array with listed values removed
+ *   - `deleteField`   — `{ __type:'deleteField' }` → {@link DELETE_MARKER}
+ *                       sentinel symbol; the resolver hands it to the
+ *                       write layer which partitions it out (see
+ *                       {@link partitionDeletes} in value-resolver.ts)
+ *
+ * Sentinel shape:
+ *   Plain `{ __type: '<name>', ... }` objects mirror the existing
+ *   serverTimestamp convention so producers (admin SDK shim, agent
+ *   tools, seeded literals) all use one shape. The exported
+ *   `INCREMENT()`, `ARRAY_UNION()`, `ARRAY_REMOVE()`, `DELETE_FIELD`
+ *   helpers are the canonical constructors.
+ *
+ * Prior lookup:
+ *   `ctx.fieldPath` and `ctx.prior` together identify what value to
+ *   read from the existing doc. {@link readPrior} walks the dotted
+ *   path with bracketed array indices ("tags[0]", "user.profile.name"),
+ *   returning `undefined` for any missing segment.
+ *
+ * Idempotency:
+ *   Each converter only claims its own sentinel shape. The output —
+ *   a number, an array, or {@link DELETE_MARKER} — is not a sentinel,
+ *   so the second resolver pass is a no-op. The Item 0 contract
+ *   verifies this.
+ *
+ * Type mismatch (FS-B11):
+ *   Firestore OVERWRITES a mismatched prior rather than erroring —
+ *   `increment(n)` on a non-number uses a base value of 0 (result `n`);
+ *   `arrayUnion`/`arrayRemove` on a non-array coerce the base to `[]`.
+ *   Mirrors `clones/.../model/transform_operation.ts`
+ *   (`computeTransformOperationBaseValue`, `coercedFieldValuesArray`).
+ */
+import { type ValueConverter } from '../value-resolver.js';
+interface IncrementSentinel {
+    __type: 'increment';
+    value: number;
+}
+interface ArrayUnionSentinel {
+    __type: 'arrayUnion';
+    values: unknown[];
+}
+interface ArrayRemoveSentinel {
+    __type: 'arrayRemove';
+    values: unknown[];
+}
+interface DeleteFieldSentinel {
+    __type: 'deleteField';
+}
+export declare function INCREMENT(value: number): IncrementSentinel;
+export declare function ARRAY_UNION(...values: unknown[]): ArrayUnionSentinel;
+export declare function ARRAY_REMOVE(...values: unknown[]): ArrayRemoveSentinel;
+export declare const DELETE_FIELD: DeleteFieldSentinel;
+export declare const incrementConverter: ValueConverter;
+export declare const arrayUnionConverter: ValueConverter;
+export declare const arrayRemoveConverter: ValueConverter;
+export declare const deleteFieldConverter: ValueConverter;
+export {};
+//# sourceMappingURL=fieldvalue.d.ts.map

package/dist/sandbox/firestore/converters/fieldvalue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fieldvalue.d.ts","sourceRoot":"","sources":["../../../../src/sandbox/firestore/converters/fieldvalue.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,OAAO,EAAuB,KAAK,cAAc,EAAuB,MAAM,sBAAsB,CAAC;AAKrG,UAAU,iBAAiB;IAAG,MAAM,EAAE,WAAW,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE;AAClE,UAAU,kBAAkB;IAAG,MAAM,EAAE,YAAY,CAAC;IAAC,MAAM,EAAE,OAAO,EAAE,CAAA;CAAE;AACxE,UAAU,mBAAmB;IAAG,MAAM,EAAE,aAAa,CAAC;IAAC,MAAM,EAAE,OAAO,EAAE,CAAA;CAAE;AAC1E,UAAU,mBAAmB;IAAG,MAAM,EAAE,aAAa,CAAA;CAAE;AAwBvD,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,iBAAiB,CAE1D;AACD,wBAAgB,WAAW,CAAC,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,kBAAkB,CAEpE;AACD,wBAAgB,YAAY,CAAC,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,mBAAmB,CAEtE;AACD,eAAO,MAAM,YAAY,EAAE,mBAA+C,CAAC;AAsC3E,eAAO,MAAM,kBAAkB,EAAE,cAahC,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,cAcjC,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,cAUlC,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,cAMlC,CAAC"}

package/dist/sandbox/firestore/converters/fieldvalue.js

@@ -0,0 +1,166 @@
+/**
+ * Item 2 — FieldValue sentinel converters.
+ *
+ * Four converters resolve the Firestore FieldValue sentinels at the
+ * write boundary, alongside the Date/serverTimestamp converters from
+ * Item 1:
+ *
+ *   - `increment`     — `{ __type:'increment', value:n }` → prior + n
+ *   - `arrayUnion`    — `{ __type:'arrayUnion', values:[…] }` →
+ *                       prior array with new values appended (deduped)
+ *   - `arrayRemove`   — `{ __type:'arrayRemove', values:[…] }` →
+ *                       prior array with listed values removed
+ *   - `deleteField`   — `{ __type:'deleteField' }` → {@link DELETE_MARKER}
+ *                       sentinel symbol; the resolver hands it to the
+ *                       write layer which partitions it out (see
+ *                       {@link partitionDeletes} in value-resolver.ts)
+ *
+ * Sentinel shape:
+ *   Plain `{ __type: '<name>', ... }` objects mirror the existing
+ *   serverTimestamp convention so producers (admin SDK shim, agent
+ *   tools, seeded literals) all use one shape. The exported
+ *   `INCREMENT()`, `ARRAY_UNION()`, `ARRAY_REMOVE()`, `DELETE_FIELD`
+ *   helpers are the canonical constructors.
+ *
+ * Prior lookup:
+ *   `ctx.fieldPath` and `ctx.prior` together identify what value to
+ *   read from the existing doc. {@link readPrior} walks the dotted
+ *   path with bracketed array indices ("tags[0]", "user.profile.name"),
+ *   returning `undefined` for any missing segment.
+ *
+ * Idempotency:
+ *   Each converter only claims its own sentinel shape. The output —
+ *   a number, an array, or {@link DELETE_MARKER} — is not a sentinel,
+ *   so the second resolver pass is a no-op. The Item 0 contract
+ *   verifies this.
+ *
+ * Type mismatch (FS-B11):
+ *   Firestore OVERWRITES a mismatched prior rather than erroring —
+ *   `increment(n)` on a non-number uses a base value of 0 (result `n`);
+ *   `arrayUnion`/`arrayRemove` on a non-array coerce the base to `[]`.
+ *   Mirrors `clones/.../model/transform_operation.ts`
+ *   (`computeTransformOperationBaseValue`, `coercedFieldValuesArray`).
+ */
+import { KEEP, DELETE_MARKER } from '../value-resolver.js';
+import { firestoreValuesEqual } from '../value-equality.js';
+function isIncrement(v) {
+    return typeof v === 'object' && v !== null
+        && v.__type === 'increment'
+        && typeof v.value === 'number';
+}
+function isArrayUnion(v) {
+    return typeof v === 'object' && v !== null
+        && v.__type === 'arrayUnion'
+        && Array.isArray(v.values);
+}
+function isArrayRemove(v) {
+    return typeof v === 'object' && v !== null
+        && v.__type === 'arrayRemove'
+        && Array.isArray(v.values);
+}
+function isDeleteField(v) {
+    return typeof v === 'object' && v !== null
+        && v.__type === 'deleteField';
+}
+// ═══ Sentinel constructors (canonical producers) ═══
+export function INCREMENT(value) {
+    return { __type: 'increment', value };
+}
+export function ARRAY_UNION(...values) {
+    return { __type: 'arrayUnion', values };
+}
+export function ARRAY_REMOVE(...values) {
+    return { __type: 'arrayRemove', values };
+}
+export const DELETE_FIELD = { __type: 'deleteField' };
+// ═══ Prior lookup ═══
+/**
+ * Read `ctx.prior.<fieldPath>` where fieldPath uses dot+bracket
+ * notation as set by value-resolver.ts (`users.profile.name`,
+ * `tags[0]`). Returns `undefined` for any missing segment so callers
+ * can apply "missing prior" defaults (e.g., increment treats absent
+ * as 0; arrayUnion treats absent as []).
+ */
+function readPrior(ctx) {
+    if (ctx.prior === null)
+        return undefined;
+    if (ctx.fieldPath === '')
+        return ctx.prior;
+    let cursor = ctx.prior;
+    // Split on '.' but keep bracketed indices attached. Then for each
+    // segment, peel any [n] suffixes after the dotted name.
+    for (const segment of ctx.fieldPath.split('.')) {
+        // segment may be like "tags[0][1]" — pull out the name first.
+        const nameMatch = /^([^\[]*)/.exec(segment);
+        const name = nameMatch ? nameMatch[1] : segment;
+        if (name) {
+            if (typeof cursor !== 'object' || cursor === null)
+                return undefined;
+            cursor = cursor[name];
+        }
+        // Then walk any bracket indices.
+        const bracketRE = /\[(\d+)\]/g;
+        let m;
+        while ((m = bracketRE.exec(segment)) !== null) {
+            if (!Array.isArray(cursor))
+                return undefined;
+            cursor = cursor[Number(m[1])];
+        }
+    }
+    return cursor;
+}
+// ═══ Converters ═══
+export const incrementConverter = {
+    name: 'increment-sentinel',
+    convert(value, ctx) {
+        if (!isIncrement(value))
+            return KEEP;
+        const prior = readPrior(ctx);
+        // FS-B11 — Firestore OVERWRITES a mismatched prior rather than throwing:
+        // `increment(n)` on a non-numeric (or absent) prior uses a base value of
+        // 0, so the result is just `n`. Mirrors
+        // `clones/.../model/transform_operation.ts`
+        // `computeTransformOperationBaseValue` (`isNumber(prev) ? prev : 0`).
+        const base = typeof prior === 'number' ? prior : 0;
+        return base + value.value;
+    },
+};
+export const arrayUnionConverter = {
+    name: 'array-union-sentinel',
+    convert(value, ctx) {
+        if (!isArrayUnion(value))
+            return KEEP;
+        const prior = readPrior(ctx);
+        // FS-B11 — a non-array (or absent) prior is coerced to `[]` rather than
+        // throwing (upstream `coercedFieldValuesArray`).
+        const base = Array.isArray(prior) ? prior.slice() : [];
+        for (const v of value.values) {
+            const exists = base.some((b) => firestoreValuesEqual(b, v));
+            if (!exists)
+                base.push(v);
+        }
+        return base;
+    },
+};
+export const arrayRemoveConverter = {
+    name: 'array-remove-sentinel',
+    convert(value, ctx) {
+        if (!isArrayRemove(value))
+            return KEEP;
+        const prior = readPrior(ctx);
+        // FS-B11 — a non-array (or absent) prior coerces to `[]` (so the result
+        // is `[]`), rather than throwing.
+        if (!Array.isArray(prior))
+            return [];
+        return prior.filter((b) => !value.values.some((v) => firestoreValuesEqual(b, v)));
+    },
+};
+export const deleteFieldConverter = {
+    name: 'delete-field-sentinel',
+    convert(value) {
+        if (!isDeleteField(value))
+            return KEEP;
+        return DELETE_MARKER;
+    },
+};
+//# sourceMappingURL=fieldvalue.js.map

package/dist/sandbox/firestore/converters/fieldvalue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fieldvalue.js","sourceRoot":"","sources":["../../../../src/sandbox/firestore/converters/fieldvalue.ts"],"names":[],"mappings":"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"}

package/dist/sandbox/firestore/converters/reference.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Item 3 — DocumentReference converter.
+ *
+ * Wraps `firebase-admin` `DocumentReference` instances into our
+ * {@link Reference} wrapper at the write boundary. Without this, a
+ * rule like `resource.data.author is reference` returns false because
+ * the evaluator detects references via `instanceof Reference`, not
+ * via the admin SDK's class.
+ *
+ * Detection strategy — duck typing on the admin SDK shape:
+ *   - has a `_path` private member (set in DocumentReference.constructor)
+ *   - exposes a `path` getter that returns a string
+ *   - exposes an `id` getter that returns a string
+ *   - has a `_firestore` reference back to the Firestore client
+ *
+ * We don't `import { DocumentReference } from 'firebase-admin/firestore'`
+ * and use `instanceof` because:
+ *   1. The simulator package shouldn't take a hard dependency on
+ *      firebase-admin (it's not a runtime requirement — only the
+ *      consumer that seeds the simulator may choose to use admin
+ *      types); and
+ *   2. Multiple admin SDK versions can coexist in a workspace and
+ *      `instanceof` would miss instances from a different copy.
+ *
+ * Idempotency: the converter only matches the admin SDK shape, never
+ * our own {@link Reference} wrapper (which has no `_path` field), so
+ * a second resolver pass is a no-op.
+ */
+import { type ValueConverter } from '../value-resolver.js';
+export declare const documentReferenceConverter: ValueConverter;
+//# sourceMappingURL=reference.d.ts.map

package/dist/sandbox/firestore/converters/reference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reference.d.ts","sourceRoot":"","sources":["../../../../src/sandbox/firestore/converters/reference.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,OAAO,EAAQ,KAAK,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAwBjE,eAAO,MAAM,0BAA0B,EAAE,cAMxC,CAAC"}

package/dist/sandbox/firestore/converters/reference.js

@@ -0,0 +1,51 @@
+/**
+ * Item 3 — DocumentReference converter.
+ *
+ * Wraps `firebase-admin` `DocumentReference` instances into our
+ * {@link Reference} wrapper at the write boundary. Without this, a
+ * rule like `resource.data.author is reference` returns false because
+ * the evaluator detects references via `instanceof Reference`, not
+ * via the admin SDK's class.
+ *
+ * Detection strategy — duck typing on the admin SDK shape:
+ *   - has a `_path` private member (set in DocumentReference.constructor)
+ *   - exposes a `path` getter that returns a string
+ *   - exposes an `id` getter that returns a string
+ *   - has a `_firestore` reference back to the Firestore client
+ *
+ * We don't `import { DocumentReference } from 'firebase-admin/firestore'`
+ * and use `instanceof` because:
+ *   1. The simulator package shouldn't take a hard dependency on
+ *      firebase-admin (it's not a runtime requirement — only the
+ *      consumer that seeds the simulator may choose to use admin
+ *      types); and
+ *   2. Multiple admin SDK versions can coexist in a workspace and
+ *      `instanceof` would miss instances from a different copy.
+ *
+ * Idempotency: the converter only matches the admin SDK shape, never
+ * our own {@link Reference} wrapper (which has no `_path` field), so
+ * a second resolver pass is a no-op.
+ */
+import { KEEP } from '../value-resolver.js';
+import { Reference } from 'pyric/rules';
+function isAdminDocumentReference(v) {
+    if (v === null || typeof v !== 'object')
+        return false;
+    // Must NOT be one of our own wrappers — those are already converted.
+    if (v instanceof Reference)
+        return false;
+    const o = v;
+    return (typeof o.path === 'string' &&
+        typeof o.id === 'string' &&
+        o._path !== undefined &&
+        o._firestore !== undefined);
+}
+export const documentReferenceConverter = {
+    name: 'document-reference',
+    convert(value) {
+        if (!isAdminDocumentReference(value))
+            return KEEP;
+        return new Reference(value.path);
+    },
+};
+//# sourceMappingURL=reference.js.map

package/dist/sandbox/firestore/converters/reference.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reference.js","sourceRoot":"","sources":["../../../../src/sandbox/firestore/converters/reference.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,OAAO,EAAE,IAAI,EAAuB,MAAM,sBAAsB,CAAC;AACjE,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAUxC,SAAS,wBAAwB,CAAC,CAAU;IAC1C,IAAI,CAAC,KAAK,IAAI,IAAI,OAAO,CAAC,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAC;IACtD,qEAAqE;IACrE,IAAI,CAAC,YAAY,SAAS;QAAE,OAAO,KAAK,CAAC;IACzC,MAAM,CAAC,GAAG,CAA4B,CAAC;IACvC,OAAO,CACL,OAAO,CAAC,CAAC,IAAI,KAAK,QAAQ;QAC1B,OAAO,CAAC,CAAC,EAAE,KAAK,QAAQ;QACxB,CAAC,CAAC,KAAK,KAAK,SAAS;QACrB,CAAC,CAAC,UAAU,KAAK,SAAS,CAC3B,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,MAAM,0BAA0B,GAAmB;IACxD,IAAI,EAAE,oBAAoB;IAC1B,OAAO,CAAC,KAAK;QACX,IAAI,CAAC,wBAAwB,CAAC,KAAK,CAAC;YAAE,OAAO,IAAI,CAAC;QAClD,OAAO,IAAI,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IACnC,CAAC;CACF,CAAC"}

package/dist/sandbox/firestore/converters/timestamp.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Item 1 — Timestamp + serverTimestamp converters.
+ *
+ * Two converters plug into the value-resolver registry:
+ *
+ * 1. `date-to-timestamp` — JS `Date` instances become {@link Timestamp}
+ *    wrappers at the write boundary. Without this, a rule like
+ *    `resource.data.createdAt is timestamp` returns false against seeded
+ *    Date data because the evaluator detects timestamps via `instanceof
+ *    Timestamp`, not Date.
+ *
+ * 2. `server-timestamp-sentinel` — the literal `{ __type:
+ *    'serverTimestamp' }` sentinel becomes a {@link Timestamp} reflecting
+ *    "now". When `ctx.serverTime` is provided, every sentinel in the
+ *    tree resolves to that SAME Timestamp instance; this matters for
+ *    rules that compare `data.createdAt == request.time`. Direct
+ *    `LocalState.write` calls (no LocalEnvironment) get a fresh
+ *    `Timestamp.fromMillis(Date.now())` per sentinel — small drift, but
+ *    no rules are evaluated in that path so it doesn't matter.
+ *
+ * Both converters are idempotent on their own output:
+ *   - `date-to-timestamp` checks `instanceof Date` only, so the
+ *     {@link Timestamp} it emits is not re-claimed on a second pass.
+ *   - `server-timestamp-sentinel` checks the `__type` discriminator;
+ *     a Timestamp instance does not have it.
+ *
+ * Both converters preserve unrelated values via {@link KEEP}.
+ */
+import { type ValueConverter } from '../value-resolver.js';
+export declare const dateConverter: ValueConverter;
+export declare const serverTimestampConverter: ValueConverter;
+//# sourceMappingURL=timestamp.d.ts.map

package/dist/sandbox/firestore/converters/timestamp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timestamp.d.ts","sourceRoot":"","sources":["../../../../src/sandbox/firestore/converters/timestamp.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,OAAO,EAAQ,KAAK,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAgBjE,eAAO,MAAM,aAAa,EAAE,cAQ3B,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,cAUtC,CAAC"}

package/dist/sandbox/firestore/converters/timestamp.js

@@ -0,0 +1,63 @@
+/**
+ * Item 1 — Timestamp + serverTimestamp converters.
+ *
+ * Two converters plug into the value-resolver registry:
+ *
+ * 1. `date-to-timestamp` — JS `Date` instances become {@link Timestamp}
+ *    wrappers at the write boundary. Without this, a rule like
+ *    `resource.data.createdAt is timestamp` returns false against seeded
+ *    Date data because the evaluator detects timestamps via `instanceof
+ *    Timestamp`, not Date.
+ *
+ * 2. `server-timestamp-sentinel` — the literal `{ __type:
+ *    'serverTimestamp' }` sentinel becomes a {@link Timestamp} reflecting
+ *    "now". When `ctx.serverTime` is provided, every sentinel in the
+ *    tree resolves to that SAME Timestamp instance; this matters for
+ *    rules that compare `data.createdAt == request.time`. Direct
+ *    `LocalState.write` calls (no LocalEnvironment) get a fresh
+ *    `Timestamp.fromMillis(Date.now())` per sentinel — small drift, but
+ *    no rules are evaluated in that path so it doesn't matter.
+ *
+ * Both converters are idempotent on their own output:
+ *   - `date-to-timestamp` checks `instanceof Date` only, so the
+ *     {@link Timestamp} it emits is not re-claimed on a second pass.
+ *   - `server-timestamp-sentinel` checks the `__type` discriminator;
+ *     a Timestamp instance does not have it.
+ *
+ * Both converters preserve unrelated values via {@link KEEP}.
+ */
+import { KEEP } from '../value-resolver.js';
+import { Timestamp } from 'pyric/rules';
+/**
+ * Detect plain `{ __type: 'serverTimestamp' }` objects. Mirrors
+ * `handler.ts:isServerTimestampSentinel` so the two layers agree on
+ * sentinel shape — refactor either, refactor both.
+ */
+function isServerTimestampSentinel(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        value.__type === 'serverTimestamp');
+}
+export const dateConverter = {
+    name: 'date-to-timestamp',
+    convert(value) {
+        if (value instanceof Date) {
+            return Timestamp.fromMillis(value.getTime());
+        }
+        return KEEP;
+    },
+};
+export const serverTimestampConverter = {
+    name: 'server-timestamp-sentinel',
+    convert(value, ctx) {
+        if (!isServerTimestampSentinel(value))
+            return KEEP;
+        // Use the caller-supplied serverTime when present so every sentinel
+        // in this write resolves to the same instance. Otherwise fall back
+        // to a fresh wallclock read.
+        if (ctx.serverTime instanceof Timestamp)
+            return ctx.serverTime;
+        return Timestamp.fromMillis(Date.now());
+    },
+};
+//# sourceMappingURL=timestamp.js.map

package/dist/sandbox/firestore/converters/timestamp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"timestamp.js","sourceRoot":"","sources":["../../../../src/sandbox/firestore/converters/timestamp.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,OAAO,EAAE,IAAI,EAAuB,MAAM,sBAAsB,CAAC;AACjE,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExC;;;;GAIG;AACH,SAAS,yBAAyB,CAAC,KAAc;IAC/C,OAAO,CACL,OAAO,KAAK,KAAK,QAAQ;QACzB,KAAK,KAAK,IAAI;QACb,KAAiC,CAAC,MAAM,KAAK,iBAAiB,CAChE,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,MAAM,aAAa,GAAmB;IAC3C,IAAI,EAAE,mBAAmB;IACzB,OAAO,CAAC,KAAK;QACX,IAAI,KAAK,YAAY,IAAI,EAAE,CAAC;YAC1B,OAAO,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;QAC/C,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;CACF,CAAC;AAEF,MAAM,CAAC,MAAM,wBAAwB,GAAmB;IACtD,IAAI,EAAE,2BAA2B;IACjC,OAAO,CAAC,KAAK,EAAE,GAAG;QAChB,IAAI,CAAC,yBAAyB,CAAC,KAAK,CAAC;YAAE,OAAO,IAAI,CAAC;QACnD,oEAAoE;QACpE,mEAAmE;QACnE,6BAA6B;QAC7B,IAAI,GAAG,CAAC,UAAU,YAAY,SAAS;YAAE,OAAO,GAAG,CAAC,UAAU,CAAC;QAC/D,OAAO,SAAS,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC;IAC1C,CAAC;CACF,CAAC"}

package/dist/sandbox/firestore/converters/user-timestamp.d.ts

@@ -0,0 +1,46 @@
+/**
+ * User-Timestamp write-boundary converter (FS-B4).
+ *
+ * Unifies Timestamp storage. The simulator stores resolved timestamps as
+ * rules-internal {@link Timestamp} (`pyric/rules`, `{seconds, nanos}`,
+ * carrying evaluator hooks). The `serverTimestamp()` sentinel and `Date`
+ * inputs already resolve to that internal class (see `timestamp.ts`). But
+ * a timestamp the user *writes directly* — via the modular SDK's
+ * `Timestamp` (the admin-compat `{seconds, nanoseconds}` class re-exported
+ * as `Timestamp` from `pyric/firestore`) or a raw `firebase/firestore`
+ * `Timestamp` — has no converter, so it lands in storage as the compat
+ * class instance. Two problems with that split storage:
+ *
+ *   1. The rules evaluator detects timestamps via `value instanceof
+ *      RulesValue && typeName === 'timestamp'`. A compat `Timestamp` is
+ *      neither, so `data.createdAt is timestamp` returns false — a user
+ *      `Timestamp` is rejected by the very `is timestamp` rule that a
+ *      `serverTimestamp()` write passes.
+ *   2. Range filters / cursors / `orderBy` compare against stored values.
+ *      The FS-B3 comparator was taught both timestamp shapes, so ordering
+ *      mostly works — but the read-path translator only rewrites the
+ *      internal class to compat shape, so a user-written compat Timestamp
+ *      never gets the `nanos`→`nanoseconds` normalization round-trip and
+ *      `serverTimestamp()`-written and user-written timestamps live as two
+ *      different classes in the same collection. Normalizing both to the
+ *      internal class at the write boundary collapses the split.
+ *
+ * Detection strategy — duck typing on the compat / `firebase/firestore`
+ * Timestamp shape, exactly like {@link bytesConverter} /
+ * {@link geoPointConverter}:
+ *   - numeric `seconds`
+ *   - numeric `nanoseconds`  (the compat / fb field name — distinct from
+ *     the internal class's `nanos`, which is how we reject our own output)
+ *   - method `toMillis`
+ *
+ * We deliberately don't `instanceof fb.Timestamp` — the simulator package
+ * must not take a hard dependency on `firebase/firestore`, and multiple
+ * `firebase` copies in a workspace would defeat `instanceof` anyway.
+ *
+ * Idempotency: the internal {@link Timestamp} has `nanos`, not
+ * `nanoseconds`, and `value instanceof RulesTimestamp` short-circuits
+ * first — so a second resolver pass over our own output is a no-op.
+ */
+import { type ValueConverter } from '../value-resolver.js';
+export declare const userTimestampConverter: ValueConverter;
+//# sourceMappingURL=user-timestamp.d.ts.map

package/dist/sandbox/firestore/converters/user-timestamp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-timestamp.d.ts","sourceRoot":"","sources":["../../../../src/sandbox/firestore/converters/user-timestamp.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,OAAO,EAAQ,KAAK,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAsBjE,eAAO,MAAM,sBAAsB,EAAE,cAMpC,CAAC"}

package/dist/sandbox/firestore/converters/user-timestamp.js

@@ -0,0 +1,65 @@
+/**
+ * User-Timestamp write-boundary converter (FS-B4).
+ *
+ * Unifies Timestamp storage. The simulator stores resolved timestamps as
+ * rules-internal {@link Timestamp} (`pyric/rules`, `{seconds, nanos}`,
+ * carrying evaluator hooks). The `serverTimestamp()` sentinel and `Date`
+ * inputs already resolve to that internal class (see `timestamp.ts`). But
+ * a timestamp the user *writes directly* — via the modular SDK's
+ * `Timestamp` (the admin-compat `{seconds, nanoseconds}` class re-exported
+ * as `Timestamp` from `pyric/firestore`) or a raw `firebase/firestore`
+ * `Timestamp` — has no converter, so it lands in storage as the compat
+ * class instance. Two problems with that split storage:
+ *
+ *   1. The rules evaluator detects timestamps via `value instanceof
+ *      RulesValue && typeName === 'timestamp'`. A compat `Timestamp` is
+ *      neither, so `data.createdAt is timestamp` returns false — a user
+ *      `Timestamp` is rejected by the very `is timestamp` rule that a
+ *      `serverTimestamp()` write passes.
+ *   2. Range filters / cursors / `orderBy` compare against stored values.
+ *      The FS-B3 comparator was taught both timestamp shapes, so ordering
+ *      mostly works — but the read-path translator only rewrites the
+ *      internal class to compat shape, so a user-written compat Timestamp
+ *      never gets the `nanos`→`nanoseconds` normalization round-trip and
+ *      `serverTimestamp()`-written and user-written timestamps live as two
+ *      different classes in the same collection. Normalizing both to the
+ *      internal class at the write boundary collapses the split.
+ *
+ * Detection strategy — duck typing on the compat / `firebase/firestore`
+ * Timestamp shape, exactly like {@link bytesConverter} /
+ * {@link geoPointConverter}:
+ *   - numeric `seconds`
+ *   - numeric `nanoseconds`  (the compat / fb field name — distinct from
+ *     the internal class's `nanos`, which is how we reject our own output)
+ *   - method `toMillis`
+ *
+ * We deliberately don't `instanceof fb.Timestamp` — the simulator package
+ * must not take a hard dependency on `firebase/firestore`, and multiple
+ * `firebase` copies in a workspace would defeat `instanceof` anyway.
+ *
+ * Idempotency: the internal {@link Timestamp} has `nanos`, not
+ * `nanoseconds`, and `value instanceof RulesTimestamp` short-circuits
+ * first — so a second resolver pass over our own output is a no-op.
+ */
+import { KEEP } from '../value-resolver.js';
+import { Timestamp as RulesTimestamp } from 'pyric/rules';
+function isUserTimestamp(v) {
+    if (v === null || typeof v !== 'object')
+        return false;
+    // Our own output (the internal wrapper) is already normalized.
+    if (v instanceof RulesTimestamp)
+        return false;
+    const o = v;
+    return (typeof o.seconds === 'number' &&
+        typeof o.nanoseconds === 'number' &&
+        typeof o.toMillis === 'function');
+}
+export const userTimestampConverter = {
+    name: 'user-timestamp-to-rules-timestamp',
+    convert(value) {
+        if (!isUserTimestamp(value))
+            return KEEP;
+        return new RulesTimestamp(value.seconds, value.nanoseconds);
+    },
+};
+//# sourceMappingURL=user-timestamp.js.map

package/dist/sandbox/firestore/converters/user-timestamp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-timestamp.js","sourceRoot":"","sources":["../../../../src/sandbox/firestore/converters/user-timestamp.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,OAAO,EAAE,IAAI,EAAuB,MAAM,sBAAsB,CAAC;AACjE,OAAO,EAAE,SAAS,IAAI,cAAc,EAAE,MAAM,aAAa,CAAC;AAS1D,SAAS,eAAe,CAAC,CAAU;IACjC,IAAI,CAAC,KAAK,IAAI,IAAI,OAAO,CAAC,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAC;IACtD,+DAA+D;IAC/D,IAAI,CAAC,YAAY,cAAc;QAAE,OAAO,KAAK,CAAC;IAC9C,MAAM,CAAC,GAAG,CAA4B,CAAC;IACvC,OAAO,CACL,OAAO,CAAC,CAAC,OAAO,KAAK,QAAQ;QAC7B,OAAO,CAAC,CAAC,WAAW,KAAK,QAAQ;QACjC,OAAO,CAAC,CAAC,QAAQ,KAAK,UAAU,CACjC,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,MAAM,sBAAsB,GAAmB;IACpD,IAAI,EAAE,mCAAmC;IACzC,OAAO,CAAC,KAAK;QACX,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC;YAAE,OAAO,IAAI,CAAC;QACzC,OAAO,IAAI,cAAc,CAAC,KAAK,CAAC,OAAO,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC;IAC9D,CAAC;CACF,CAAC"}

package/dist/sandbox/firestore/converters/vector.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Item 5 — VectorValue converter.
+ *
+ * Wraps `firebase-admin` `VectorValue` instances into our {@link Vector}
+ * wrapper at the write boundary. Without this, the wire encoder would
+ * walk the admin VectorValue as a plain object and emit garbage that
+ * `discover/wire.ts` cannot recognize as a vector sentinel.
+ *
+ * Detection strategy — duck typing on the admin SDK shape:
+ *   - has a `_values` private member that's an Array of numbers
+ *   - exposes a `toArray` function
+ *
+ * We deliberately don't `instanceof VectorValue` because:
+ *   1. The simulator package shouldn't take a hard dependency on
+ *      firebase-admin (it's a consumer concern), and
+ *   2. Multiple admin SDK copies in a workspace would defeat instanceof.
+ *
+ * Idempotency: the converter only matches the admin SDK shape, never
+ * our own {@link Vector} wrapper (which has no `_values` field and uses
+ * a frozen `value` array instead). A second resolver pass is a no-op.
+ */
+import { type ValueConverter } from '../value-resolver.js';
+export declare const vectorValueConverter: ValueConverter;
+//# sourceMappingURL=vector.d.ts.map

package/dist/sandbox/firestore/converters/vector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector.d.ts","sourceRoot":"","sources":["../../../../src/sandbox/firestore/converters/vector.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,EAAQ,KAAK,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAsBjE,eAAO,MAAM,oBAAoB,EAAE,cAOlC,CAAC"}

package/dist/sandbox/firestore/converters/vector.js

@@ -0,0 +1,53 @@
+/**
+ * Item 5 — VectorValue converter.
+ *
+ * Wraps `firebase-admin` `VectorValue` instances into our {@link Vector}
+ * wrapper at the write boundary. Without this, the wire encoder would
+ * walk the admin VectorValue as a plain object and emit garbage that
+ * `discover/wire.ts` cannot recognize as a vector sentinel.
+ *
+ * Detection strategy — duck typing on the admin SDK shape:
+ *   - has a `_values` private member that's an Array of numbers
+ *   - exposes a `toArray` function
+ *
+ * We deliberately don't `instanceof VectorValue` because:
+ *   1. The simulator package shouldn't take a hard dependency on
+ *      firebase-admin (it's a consumer concern), and
+ *   2. Multiple admin SDK copies in a workspace would defeat instanceof.
+ *
+ * Idempotency: the converter only matches the admin SDK shape, never
+ * our own {@link Vector} wrapper (which has no `_values` field and uses
+ * a frozen `value` array instead). A second resolver pass is a no-op.
+ */
+import { KEEP } from '../value-resolver.js';
+import { Vector } from 'pyric/rules';
+function isNumberArray(a) {
+    return Array.isArray(a) && a.every((n) => typeof n === 'number');
+}
+/**
+ * Extract a VectorValue's components, or null if `v` isn't one. The brand is a
+ * numeric `_values` AND a `toArray` method: both the firebase web SDK and the
+ * admin SDK `VectorValue` expose both, so requiring both is what distinguishes a
+ * real vector from a plain object that merely has one of them.
+ */
+function extractVectorValues(v) {
+    if (v === null || typeof v !== 'object')
+        return null;
+    // Must NOT be one of our own wrappers; those are already converted.
+    if (v instanceof Vector)
+        return null;
+    const o = v;
+    if (isNumberArray(o._values) && typeof o.toArray === 'function')
+        return o._values;
+    return null;
+}
+export const vectorValueConverter = {
+    name: 'vector-value',
+    convert(value) {
+        const values = extractVectorValues(value);
+        if (values === null)
+            return KEEP;
+        return new Vector(values);
+    },
+};
+//# sourceMappingURL=vector.js.map

package/dist/sandbox/firestore/converters/vector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector.js","sourceRoot":"","sources":["../../../../src/sandbox/firestore/converters/vector.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,EAAE,IAAI,EAAuB,MAAM,sBAAsB,CAAC;AACjE,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,SAAS,aAAa,CAAC,CAAU;IAC/B,OAAO,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC,CAAC;AACnE,CAAC;AAED;;;;;GAKG;AACH,SAAS,mBAAmB,CAAC,CAAU;IACrC,IAAI,CAAC,KAAK,IAAI,IAAI,OAAO,CAAC,KAAK,QAAQ;QAAE,OAAO,IAAI,CAAC;IACrD,oEAAoE;IACpE,IAAI,CAAC,YAAY,MAAM;QAAE,OAAO,IAAI,CAAC;IACrC,MAAM,CAAC,GAAG,CAA4B,CAAC;IACvC,IAAI,aAAa,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,OAAO,CAAC,CAAC,OAAO,KAAK,UAAU;QAAE,OAAO,CAAC,CAAC,OAAO,CAAC;IAClF,OAAO,IAAI,CAAC;AACd,CAAC;AAED,MAAM,CAAC,MAAM,oBAAoB,GAAmB;IAClD,IAAI,EAAE,cAAc;IACpB,OAAO,CAAC,KAAK;QACX,MAAM,MAAM,GAAG,mBAAmB,CAAC,KAAK,CAAC,CAAC;QAC1C,IAAI,MAAM,KAAK,IAAI;YAAE,OAAO,IAAI,CAAC;QACjC,OAAO,IAAI,MAAM,CAAC,MAAM,CAAC,CAAC;IAC5B,CAAC;CACF,CAAC"}