pyric 0.0.1 → 0.1.0-alpha.8

package/dist/sandbox/firestore/errors.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Item 6 — typed error codes for `LocalEnvironment` results.
+ *
+ * The simulator previously surfaced denials as `allowed: false` plus an
+ * unstructured `debugMessages: string[]`. Agents had to grep the string
+ * to tell "rule denied" apart from "doc didn't exist" apart from "the
+ * sentinel was rejected", which is exactly the affordance Firestore's
+ * `FirestoreError.code` gives them in production.
+ *
+ * The codes here are the canonical set the firebase-admin SDK throws
+ * (a subset of gRPC status names). They're string-literal values so
+ * downstream consumers can switch on them without importing an enum.
+ *
+ * Mapping the simulator emits today (Item 6 first cut):
+ *   - rule denied                       → 'permission-denied'
+ *   - update of missing doc             → 'not-found'
+ *   - create of existing doc            → 'already-exists'
+ *   - sentinel-resolution failure       → 'invalid-argument'
+ *     (admin SDK also throws this for malformed FieldValue use; see
+ *      the increment converter's "prior is not numeric" path)
+ *
+ * Codes defined-but-unused today (`failed-precondition`,
+ * `unauthenticated`) are reserved so adding their wiring later is a
+ * pure callsite change, no error-set churn.
+ */
+export declare const FIRESTORE_ERROR_CODES: readonly ["permission-denied", "not-found", "already-exists", "failed-precondition", "invalid-argument", "unauthenticated", "unimplemented"];
+export type FirestoreErrorCode = typeof FIRESTORE_ERROR_CODES[number];
+/**
+ * Eval-time request shape, populated on `permission-denied` so callers
+ * can inspect exactly what the rule saw — `request.auth`, the operation
+ * method+path, and (for writes) the resolved `request.resource.data`.
+ *
+ * Sentinels in `resourceData` are resolved (e.g., `serverTimestamp()` →
+ * Timestamp), matching what the rule actually evaluated against.
+ */
+export interface FirestoreEvalRequest {
+    method: 'get' | 'list' | 'create' | 'update' | 'delete';
+    path: string;
+    auth: {
+        uid: string;
+        token?: Record<string, unknown>;
+    } | null;
+    /** `request.resource.data` after sentinel resolution. Absent for reads. */
+    resourceData?: Record<string, unknown>;
+}
+/**
+ * Eval-time existing-document state, populated on `permission-denied`
+ * for doc operations so callers can see what `resource.data` evaluated
+ * to. `null` data with `exists: false` mirrors how Firestore rules see
+ * an absent document (resource itself is null).
+ */
+export interface FirestoreEvalResource {
+    data: Record<string, unknown> | null;
+    exists: boolean;
+}
+export interface FirestoreSimError {
+    code: FirestoreErrorCode;
+    message: string;
+    /**
+     * Eval-time request shape — populated for `permission-denied` so
+     * callers don't have to re-derive `request.auth` / `request.resource`
+     * from out-of-band state. Absent for non-denial codes.
+     */
+    request?: FirestoreEvalRequest;
+    /**
+     * Eval-time existing doc — populated for `permission-denied` on
+     * single-doc operations. Absent for collection ops (`list`) and
+     * non-denial codes.
+     */
+    resource?: FirestoreEvalResource;
+}
+/**
+ * Build a structured error record. The optional `extras` carries
+ * eval-time context that downstream layers (admin-compat, sandbox,
+ * playground) surface so a denial reads like a debugger frame instead
+ * of an opaque "denied by rules".
+ */
+export declare function makeError(code: FirestoreErrorCode, message: string, extras?: {
+    request?: FirestoreEvalRequest;
+    resource?: FirestoreEvalResource;
+}): FirestoreSimError;
+//# sourceMappingURL=errors.d.ts.map

package/dist/sandbox/firestore/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/sandbox/firestore/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,eAAO,MAAM,qBAAqB,8IAaxB,CAAC;AAEX,MAAM,MAAM,kBAAkB,GAAG,OAAO,qBAAqB,CAAC,MAAM,CAAC,CAAC;AAEtE;;;;;;;GAOG;AACH,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,KAAK,GAAG,MAAM,GAAG,QAAQ,GAAG,QAAQ,GAAG,QAAQ,CAAC;IACxD,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,GAAG,IAAI,CAAC;IAC9D,2EAA2E;IAC3E,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACxC;AAED;;;;;GAKG;AACH,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IACrC,MAAM,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,kBAAkB,CAAC;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,OAAO,CAAC,EAAE,oBAAoB,CAAC;IAC/B;;;;OAIG;IACH,QAAQ,CAAC,EAAE,qBAAqB,CAAC;CAClC;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,kBAAkB,EACxB,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,oBAAoB,CAAC;IAAC,QAAQ,CAAC,EAAE,qBAAqB,CAAA;CAAE,GAC5E,iBAAiB,CAKnB"}

package/dist/sandbox/firestore/errors.js

@@ -0,0 +1,54 @@
+/**
+ * Item 6 — typed error codes for `LocalEnvironment` results.
+ *
+ * The simulator previously surfaced denials as `allowed: false` plus an
+ * unstructured `debugMessages: string[]`. Agents had to grep the string
+ * to tell "rule denied" apart from "doc didn't exist" apart from "the
+ * sentinel was rejected", which is exactly the affordance Firestore's
+ * `FirestoreError.code` gives them in production.
+ *
+ * The codes here are the canonical set the firebase-admin SDK throws
+ * (a subset of gRPC status names). They're string-literal values so
+ * downstream consumers can switch on them without importing an enum.
+ *
+ * Mapping the simulator emits today (Item 6 first cut):
+ *   - rule denied                       → 'permission-denied'
+ *   - update of missing doc             → 'not-found'
+ *   - create of existing doc            → 'already-exists'
+ *   - sentinel-resolution failure       → 'invalid-argument'
+ *     (admin SDK also throws this for malformed FieldValue use; see
+ *      the increment converter's "prior is not numeric" path)
+ *
+ * Codes defined-but-unused today (`failed-precondition`,
+ * `unauthenticated`) are reserved so adding their wiring later is a
+ * pure callsite change, no error-set churn.
+ */
+export const FIRESTORE_ERROR_CODES = [
+    'permission-denied',
+    'not-found',
+    'already-exists',
+    'failed-precondition',
+    'invalid-argument',
+    'unauthenticated',
+    // 'unimplemented' is the gRPC status the real Admin SDK throws for
+    // surfaces it doesn't implement. The admin-compat wrapper uses it for
+    // (a) slice-1-stub methods that aren't wired yet, and (b) typed-value
+    // inputs (GeoPoint/Bytes/Vector/DocumentReference) the simulator
+    // doesn't yet accept — both lit up incrementally as parity work lands.
+    'unimplemented',
+];
+/**
+ * Build a structured error record. The optional `extras` carries
+ * eval-time context that downstream layers (admin-compat, sandbox,
+ * playground) surface so a denial reads like a debugger frame instead
+ * of an opaque "denied by rules".
+ */
+export function makeError(code, message, extras) {
+    const out = { code, message };
+    if (extras?.request)
+        out.request = extras.request;
+    if (extras?.resource)
+        out.resource = extras.resource;
+    return out;
+}
+//# sourceMappingURL=errors.js.map

package/dist/sandbox/firestore/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../../src/sandbox/firestore/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,MAAM,CAAC,MAAM,qBAAqB,GAAG;IACnC,mBAAmB;IACnB,WAAW;IACX,gBAAgB;IAChB,qBAAqB;IACrB,kBAAkB;IAClB,iBAAiB;IACjB,mEAAmE;IACnE,sEAAsE;IACtE,sEAAsE;IACtE,iEAAiE;IACjE,uEAAuE;IACvE,eAAe;CACP,CAAC;AAgDX;;;;;GAKG;AACH,MAAM,UAAU,SAAS,CACvB,IAAwB,EACxB,OAAe,EACf,MAA6E;IAE7E,MAAM,GAAG,GAAsB,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC;IACjD,IAAI,MAAM,EAAE,OAAO;QAAE,GAAG,CAAC,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC;IAClD,IAAI,MAAM,EAAE,QAAQ;QAAE,GAAG,CAAC,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC;IACrD,OAAO,GAAG,CAAC;AACb,CAAC"}

package/dist/sandbox/firestore/event-log.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Event Log — append-only audit trail for the local environment.
+ *
+ * Every operation (allowed or denied) is recorded. Undo is implemented
+ * via state snapshots — no need to replay events.
+ */
+import type { DocumentData } from './local-state.js';
+export interface AgentEvent {
+    id: number;
+    timestamp: string;
+    type: 'single' | 'batch' | 'transaction';
+    method: string;
+    path: string;
+    auth: {
+        uid: string;
+    } | null;
+    allowed: boolean;
+    /** For writes: the data that was written */
+    data?: DocumentData;
+    /** For batch/transaction: individual operations */
+    operations?: Array<{
+        method: string;
+        path: string;
+        data?: DocumentData;
+        allowed: boolean;
+    }>;
+    /**
+     * For transactions: the read-set captured by tx.get / tx.getAll inside
+     * the callback. Surfaced for diagnostic value (production doesn't
+     * expose this, but agents debugging "why did my tx commit nothing"
+     * benefit from seeing what the callback saw).
+     */
+    reads?: Array<{
+        path: string;
+        data: DocumentData | null;
+    }>;
+    /**
+     * For transactions: true iff the callback threw (read-after-write
+     * violation, ambiguous post-delete, or any user error). Aborted
+     * transactions are NOT undoable — they had no effect, popping them as
+     * undoable would skip a real prior write.
+     */
+    aborted?: boolean;
+    /**
+     * For transactions: the error that aborted the callback (when
+     * `aborted: true`). Recorded for forensic value; the original Error
+     * is also re-thrown synchronously to the caller (probe 0.G —
+     * exceptions propagate unchanged).
+     */
+    error?: {
+        name: string;
+        message: string;
+        code?: string;
+    };
+    /**
+     * Prior state of the AFFECTED paths only, captured before this event, for
+     * undo (single-write + batch). `null` means the doc did not exist (undo
+     * deletes it). Replaces the whole-keyspace {@link snapshot} for the common
+     * write paths so the undo stack is O(affected) not O(keyspace).
+     */
+    priorDocs?: Record<string, DocumentData | null>;
+    /**
+     * Whole-keyspace snapshot BEFORE this event (for undo). Still used by
+     * transactions, whose affected paths aren't known until the callback runs.
+     */
+    snapshot?: Record<string, DocumentData>;
+    /** Debug messages from rules evaluation */
+    debugMessages: string[];
+}
+export declare class EventLog {
+    private events;
+    private nextId;
+    private undoneEvents;
+    /** Append an event. Clears redo stack unless preserveRedo is true. */
+    append(event: Omit<AgentEvent, 'id' | 'timestamp'>, preserveRedo?: boolean): AgentEvent;
+    /** Get all events. */
+    getEvents(): AgentEvent[];
+    /** Get write events only (create, update, delete, set — not reads). */
+    getWriteEvents(): AgentEvent[];
+    /** Get the last write event (for undo). */
+    lastWriteEvent(): AgentEvent | null;
+    /**
+     * Pop the last write event for undo. Pushes to redo stack.
+     *
+     * Aborted transactions are skipped — they had no effect on state, so
+     * popping one as if it were undoable would silently leave a real
+     * prior write in place while the agent thinks it has been reverted.
+     * Aborted events stay in the log for forensic value (`getEvents()`
+     * still returns them) but do not enter the undo stack.
+     */
+    popLastWrite(): AgentEvent | null;
+    /** Get the last undone event (for redo). */
+    popLastUndo(): AgentEvent | null;
+    /** Total event count. */
+    size(): number;
+    /** Clear all events. */
+    clear(): void;
+}
+//# sourceMappingURL=event-log.d.ts.map

package/dist/sandbox/firestore/event-log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-log.d.ts","sourceRoot":"","sources":["../../../src/sandbox/firestore/event-log.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAErD,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,QAAQ,GAAG,OAAO,GAAG,aAAa,CAAC;IACzC,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IAC7B,OAAO,EAAE,OAAO,CAAC;IACjB,4CAA4C;IAC5C,IAAI,CAAC,EAAE,YAAY,CAAC;IACpB,mDAAmD;IACnD,UAAU,CAAC,EAAE,KAAK,CAAC;QACjB,MAAM,EAAE,MAAM,CAAC;QACf,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,CAAC,EAAE,YAAY,CAAC;QACpB,OAAO,EAAE,OAAO,CAAC;KAClB,CAAC,CAAC;IACH;;;;;OAKG;IACH,KAAK,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,YAAY,GAAG,IAAI,CAAA;KAAE,CAAC,CAAC;IAC3D;;;;;OAKG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;;OAKG;IACH,KAAK,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACzD;;;;;OAKG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI,CAAC,CAAC;IAChD;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IACxC,2CAA2C;IAC3C,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB;AAED,qBAAa,QAAQ;IACnB,OAAO,CAAC,MAAM,CAAoB;IAClC,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,YAAY,CAAoB;IAExC,sEAAsE;IACtE,MAAM,CAAC,KAAK,EAAE,IAAI,CAAC,UAAU,EAAE,IAAI,GAAG,WAAW,CAAC,EAAE,YAAY,UAAQ,GAAG,UAAU;IAWrF,sBAAsB;IACtB,SAAS,IAAI,UAAU,EAAE;IAIzB,uEAAuE;IACvE,cAAc,IAAI,UAAU,EAAE;IAI9B,2CAA2C;IAC3C,cAAc,IAAI,UAAU,GAAG,IAAI;IAKnC;;;;;;;;OAQG;IACH,YAAY,IAAI,UAAU,GAAG,IAAI;IAajC,4CAA4C;IAC5C,WAAW,IAAI,UAAU,GAAG,IAAI;IAIhC,yBAAyB;IACzB,IAAI,IAAI,MAAM;IAId,wBAAwB;IACxB,KAAK,IAAI,IAAI;CAKd"}

package/dist/sandbox/firestore/event-log.js

@@ -0,0 +1,67 @@
+export class EventLog {
+    events = [];
+    nextId = 1;
+    undoneEvents = [];
+    /** Append an event. Clears redo stack unless preserveRedo is true. */
+    append(event, preserveRedo = false) {
+        const full = {
+            ...event,
+            id: this.nextId++,
+            timestamp: new Date().toISOString(),
+        };
+        this.events.push(full);
+        if (!preserveRedo)
+            this.undoneEvents = [];
+        return full;
+    }
+    /** Get all events. */
+    getEvents() {
+        return [...this.events];
+    }
+    /** Get write events only (create, update, delete, set — not reads). */
+    getWriteEvents() {
+        return this.events.filter(e => e.allowed && e.method !== 'get' && e.method !== 'list');
+    }
+    /** Get the last write event (for undo). */
+    lastWriteEvent() {
+        const writes = this.getWriteEvents();
+        return writes.length > 0 ? writes[writes.length - 1] : null;
+    }
+    /**
+     * Pop the last write event for undo. Pushes to redo stack.
+     *
+     * Aborted transactions are skipped — they had no effect on state, so
+     * popping one as if it were undoable would silently leave a real
+     * prior write in place while the agent thinks it has been reverted.
+     * Aborted events stay in the log for forensic value (`getEvents()`
+     * still returns them) but do not enter the undo stack.
+     */
+    popLastWrite() {
+        for (let i = this.events.length - 1; i >= 0; i--) {
+            const e = this.events[i];
+            if (e.aborted)
+                continue;
+            if (e.allowed && e.method !== 'get' && e.method !== 'list') {
+                this.events.splice(i, 1);
+                this.undoneEvents.push(e);
+                return e;
+            }
+        }
+        return null;
+    }
+    /** Get the last undone event (for redo). */
+    popLastUndo() {
+        return this.undoneEvents.pop() ?? null;
+    }
+    /** Total event count. */
+    size() {
+        return this.events.length;
+    }
+    /** Clear all events. */
+    clear() {
+        this.events = [];
+        this.undoneEvents = [];
+        this.nextId = 1;
+    }
+}
+//# sourceMappingURL=event-log.js.map

package/dist/sandbox/firestore/event-log.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-log.js","sourceRoot":"","sources":["../../../src/sandbox/firestore/event-log.ts"],"names":[],"mappings":"AA8DA,MAAM,OAAO,QAAQ;IACX,MAAM,GAAiB,EAAE,CAAC;IAC1B,MAAM,GAAG,CAAC,CAAC;IACX,YAAY,GAAiB,EAAE,CAAC;IAExC,sEAAsE;IACtE,MAAM,CAAC,KAA2C,EAAE,YAAY,GAAG,KAAK;QACtE,MAAM,IAAI,GAAe;YACvB,GAAG,KAAK;YACR,EAAE,EAAE,IAAI,CAAC,MAAM,EAAE;YACjB,SAAS,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;SACpC,CAAC;QACF,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACvB,IAAI,CAAC,YAAY;YAAE,IAAI,CAAC,YAAY,GAAG,EAAE,CAAC;QAC1C,OAAO,IAAI,CAAC;IACd,CAAC;IAED,sBAAsB;IACtB,SAAS;QACP,OAAO,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;IAC1B,CAAC;IAED,uEAAuE;IACvE,cAAc;QACZ,OAAO,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,IAAI,CAAC,CAAC,MAAM,KAAK,KAAK,IAAI,CAAC,CAAC,MAAM,KAAK,MAAM,CAAC,CAAC;IACzF,CAAC;IAED,2CAA2C;IAC3C,cAAc;QACZ,MAAM,MAAM,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC;QACrC,OAAO,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IAC9D,CAAC;IAED;;;;;;;;OAQG;IACH,YAAY;QACV,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YACjD,MAAM,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;YACzB,IAAI,CAAC,CAAC,OAAO;gBAAE,SAAS;YACxB,IAAI,CAAC,CAAC,OAAO,IAAI,CAAC,CAAC,MAAM,KAAK,KAAK,IAAI,CAAC,CAAC,MAAM,KAAK,MAAM,EAAE,CAAC;gBAC3D,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;gBACzB,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;gBAC1B,OAAO,CAAC,CAAC;YACX,CAAC;QACH,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,4CAA4C;IAC5C,WAAW;QACT,OAAO,IAAI,CAAC,YAAY,CAAC,GAAG,EAAE,IAAI,IAAI,CAAC;IACzC,CAAC;IAED,yBAAyB;IACzB,IAAI;QACF,OAAO,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC;IAC5B,CAAC;IAED,wBAAwB;IACxB,KAAK;QACH,IAAI,CAAC,MAAM,GAAG,EAAE,CAAC;QACjB,IAAI,CAAC,YAAY,GAAG,EAAE,CAAC;QACvB,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;IAClB,CAAC;CACF"}

package/dist/sandbox/firestore/field-merge.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Field-path merge engine (FS-B5 + FS-B6).
+ *
+ * Firestore's `updateDoc` and `setDoc(..., {merge})` are not shallow
+ * object spreads. They build a *field mask* of leaf paths and set each
+ * leaf into the existing document, creating intermediate maps as needed
+ * and preserving sibling fields. This mirrors
+ * `clones/firebase-js-sdk/packages/firestore/src/model/object_value.ts`
+ * (`ObjectValue.set` / `getFieldsMap`) and `lite-api/user_data_reader.ts`
+ * (`parseUpdateData` — every top-level `updateDoc` key is parsed as a
+ * dot-separated FieldPath; `parseSetData` with `merge` extracts the mask
+ * from the data's nested maps).
+ *
+ * Two entry points feed the same leaf-set engine:
+ *
+ *   - {@link applyUpdate} — `updateDoc(data)`. Each TOP-LEVEL key is a
+ *     dot-separated FieldPath, so `{'a.b': 2}` sets leaf `a.b` (preserving
+ *     `a.c`). A nested *map value* (`{a: {b: 2}}`) is a single-segment
+ *     path `a` whose value is the whole map — it REPLACES `a` wholesale,
+ *     matching prod (`updateDoc` does not deep-merge map values; only
+ *     dot-paths reach into a map). `DELETE_MARKER` leaves delete the leaf.
+ *
+ *   - {@link applyMerge} — `setDoc(data, {merge:true})` /
+ *     `{mergeFields}`. The mask is every leaf path reachable by walking
+ *     the data's nested plain maps, so `{a:{b:2}}` sets leaf `a.b`
+ *     (preserving `a.c`) — i.e. maps DEEP-merge. `mergeFields` restricts
+ *     the mask to the listed (dot-separated) field paths.
+ *
+ * Both operate on a freshly cloned copy of `existing` and never mutate
+ * the input. The resolved write tree is expected to have already run
+ * through the value-resolver (sentinels resolved, deleteField → marker).
+ */
+import { type DocumentData } from './value-resolver.js';
+/**
+ * `updateDoc` semantics — top-level keys are dot-separated FieldPaths.
+ * `resolved` is the value-resolved write tree (its keys may contain dots;
+ * `DELETE_MARKER` leaves mean deleteField()). Returns the merged doc.
+ */
+export declare function applyUpdate(existing: DocumentData, resolved: DocumentData): DocumentData;
+/**
+ * FS-B13 — thrown when a `deleteField()` sentinel appears below the top
+ * level of an `updateDoc` (or anywhere in a non-merge `set`). The write
+ * layer maps this to an `invalid-argument` FirestoreError.
+ */
+export declare class DeleteFieldNestedError extends Error {
+    constructor();
+}
+/**
+ * FS-B13 — validate an `updateDoc` payload: a `deleteField()` (DELETE_MARKER)
+ * is legal only as a whole top-level value or via a dot-path key (the
+ * top-level entry value === DELETE_MARKER). Nested inside a map literal it
+ * throws {@link DeleteFieldNestedError}. Called pre-rules in
+ * `LocalEnvironment.execute` so the denial reads like prod's parse-time
+ * `invalid-argument`.
+ */
+export declare function assertNoNestedDeleteField(resolved: DocumentData): void;
+/**
+ * `setDoc(merge:true)` semantics — recursively extract the leaf-path mask
+ * from `resolved` (nested maps deep-merge), then set each leaf. When
+ * `mergeFields` is supplied, only those (dot-separated) top-level field
+ * paths are written; everything else in `resolved` is ignored.
+ */
+export declare function applyMerge(existing: DocumentData, resolved: DocumentData, mergeFields?: readonly string[]): DocumentData;
+//# sourceMappingURL=field-merge.d.ts.map

package/dist/sandbox/firestore/field-merge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"field-merge.d.ts","sourceRoot":"","sources":["../../../src/sandbox/firestore/field-merge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,OAAO,EAIL,KAAK,YAAY,EAClB,MAAM,qBAAqB,CAAC;AA0E7B;;;;GAIG;AACH,wBAAgB,WAAW,CACzB,QAAQ,EAAE,YAAY,EACtB,QAAQ,EAAE,YAAY,GACrB,YAAY,CAcd;AAED;;;;GAIG;AACH,qBAAa,sBAAuB,SAAQ,KAAK;;CAKhD;AAYD;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,YAAY,GAAG,IAAI,CAMtE;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CACxB,QAAQ,EAAE,YAAY,EACtB,QAAQ,EAAE,YAAY,EACtB,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,GAC9B,YAAY,CAoBd"}

package/dist/sandbox/firestore/field-merge.js

@@ -0,0 +1,221 @@
+/**
+ * Field-path merge engine (FS-B5 + FS-B6).
+ *
+ * Firestore's `updateDoc` and `setDoc(..., {merge})` are not shallow
+ * object spreads. They build a *field mask* of leaf paths and set each
+ * leaf into the existing document, creating intermediate maps as needed
+ * and preserving sibling fields. This mirrors
+ * `clones/firebase-js-sdk/packages/firestore/src/model/object_value.ts`
+ * (`ObjectValue.set` / `getFieldsMap`) and `lite-api/user_data_reader.ts`
+ * (`parseUpdateData` — every top-level `updateDoc` key is parsed as a
+ * dot-separated FieldPath; `parseSetData` with `merge` extracts the mask
+ * from the data's nested maps).
+ *
+ * Two entry points feed the same leaf-set engine:
+ *
+ *   - {@link applyUpdate} — `updateDoc(data)`. Each TOP-LEVEL key is a
+ *     dot-separated FieldPath, so `{'a.b': 2}` sets leaf `a.b` (preserving
+ *     `a.c`). A nested *map value* (`{a: {b: 2}}`) is a single-segment
+ *     path `a` whose value is the whole map — it REPLACES `a` wholesale,
+ *     matching prod (`updateDoc` does not deep-merge map values; only
+ *     dot-paths reach into a map). `DELETE_MARKER` leaves delete the leaf.
+ *
+ *   - {@link applyMerge} — `setDoc(data, {merge:true})` /
+ *     `{mergeFields}`. The mask is every leaf path reachable by walking
+ *     the data's nested plain maps, so `{a:{b:2}}` sets leaf `a.b`
+ *     (preserving `a.c`) — i.e. maps DEEP-merge. `mergeFields` restricts
+ *     the mask to the listed (dot-separated) field paths.
+ *
+ * Both operate on a freshly cloned copy of `existing` and never mutate
+ * the input. The resolved write tree is expected to have already run
+ * through the value-resolver (sentinels resolved, deleteField → marker).
+ */
+import { DELETE_MARKER, isPlainObject, stripMarkers, } from './value-resolver.js';
+/** Split a dot-separated FieldPath string into segments. */
+function splitPath(key) {
+    return key.split('.');
+}
+/** Field-path segments that must never be walked or written. The merge
+ *  engine sets leaves into plain JS objects, and `isPlainObject` treats
+ *  `Object.prototype` (its `proto === null` branch) as plain — so a
+ *  segment named `__proto__` (or, defence-in-depth, `constructor`/
+ *  `prototype`) would let a rule-permitted `updateDoc`/`setDoc(merge)`
+ *  walk into and pollute the shared prototype process-wide. Field names
+ *  arrive via JSON transports that preserve `__proto__` as a genuine own
+ *  key, so this is reachable with ordinary data. These are not valid
+ *  Firestore field-path segments, so rejecting them is sandbox-only
+ *  safety, not a parity regression. */
+const UNSAFE_SEGMENTS = new Set(['__proto__', 'prototype', 'constructor']);
+function assertSafeSegment(seg) {
+    if (UNSAFE_SEGMENTS.has(seg)) {
+        throw new Error(`Invalid field-path segment '${seg}': the keys __proto__, prototype, ` +
+            'and constructor are reserved and cannot appear in a field path.');
+    }
+}
+/** Deep clone a plain document tree, leaving class instances by reference
+ *  (Timestamp, Bytes, etc. are immutable wrappers — safe to share). */
+function cloneDoc(data) {
+    const out = {};
+    for (const [k, v] of Object.entries(data)) {
+        out[k] = cloneValue(v);
+    }
+    return out;
+}
+function cloneValue(v) {
+    if (Array.isArray(v))
+        return v.map(cloneValue);
+    if (isPlainObject(v))
+        return cloneDoc(v);
+    return v;
+}
+/**
+ * Navigate to the parent map of `segments`, creating (or replacing
+ * non-map intermediates with) plain maps along the way, then set or
+ * delete the leaf. Mirrors `ObjectValue.getFieldsMap` + `applyChanges`.
+ */
+function setLeaf(root, segments, value) {
+    let cursor = root;
+    for (let i = 0; i < segments.length - 1; i++) {
+        const seg = segments[i];
+        assertSafeSegment(seg);
+        // Own-property read only: bare `cursor[seg]` would resolve an
+        // unvalidated `__proto__` segment to the shared object prototype
+        // (which `isPlainObject` accepts as a walkable map).
+        const next = Object.hasOwn(cursor, seg) ? cursor[seg] : undefined;
+        if (!isPlainObject(next)) {
+            // Intermediate is missing or not a map — prod creates a fresh map
+            // (the old value at this path is shadowed by the deeper write).
+            cursor[seg] = {};
+        }
+        cursor = cursor[seg];
+    }
+    const leaf = segments[segments.length - 1];
+    assertSafeSegment(leaf);
+    if (value === DELETE_MARKER) {
+        delete cursor[leaf];
+    }
+    else {
+        cursor[leaf] = stripMarkers(value);
+    }
+}
+/**
+ * `updateDoc` semantics — top-level keys are dot-separated FieldPaths.
+ * `resolved` is the value-resolved write tree (its keys may contain dots;
+ * `DELETE_MARKER` leaves mean deleteField()). Returns the merged doc.
+ */
+export function applyUpdate(existing, resolved) {
+    const out = cloneDoc(existing);
+    for (const [key, value] of Object.entries(resolved)) {
+        // FS-B13 — `deleteField()` may only appear at the top level of an update
+        // (as a whole field value or via a dot-path key). Nested inside a map
+        // literal it is invalid; prod throws `invalid-argument` rather than
+        // silently destroying the sibling data. Mirrors
+        // `clones/.../lite-api/user_data_reader.ts:DeleteFieldValueImpl`.
+        if (value !== DELETE_MARKER && containsDeleteMarker(value)) {
+            throw new DeleteFieldNestedError();
+        }
+        setLeaf(out, splitPath(key), value);
+    }
+    return out;
+}
+/**
+ * FS-B13 — thrown when a `deleteField()` sentinel appears below the top
+ * level of an `updateDoc` (or anywhere in a non-merge `set`). The write
+ * layer maps this to an `invalid-argument` FirestoreError.
+ */
+export class DeleteFieldNestedError extends Error {
+    constructor() {
+        super('FieldValue.delete() can only appear at the top level of your update data');
+        this.name = 'DeleteFieldNestedError';
+    }
+}
+/** True when `value` contains a {@link DELETE_MARKER} anywhere in its tree. */
+function containsDeleteMarker(value) {
+    if (value === DELETE_MARKER)
+        return true;
+    if (Array.isArray(value))
+        return value.some(containsDeleteMarker);
+    if (isPlainObject(value)) {
+        return Object.values(value).some(containsDeleteMarker);
+    }
+    return false;
+}
+/**
+ * FS-B13 — validate an `updateDoc` payload: a `deleteField()` (DELETE_MARKER)
+ * is legal only as a whole top-level value or via a dot-path key (the
+ * top-level entry value === DELETE_MARKER). Nested inside a map literal it
+ * throws {@link DeleteFieldNestedError}. Called pre-rules in
+ * `LocalEnvironment.execute` so the denial reads like prod's parse-time
+ * `invalid-argument`.
+ */
+export function assertNoNestedDeleteField(resolved) {
+    for (const value of Object.values(resolved)) {
+        if (value !== DELETE_MARKER && containsDeleteMarker(value)) {
+            throw new DeleteFieldNestedError();
+        }
+    }
+}
+/**
+ * `setDoc(merge:true)` semantics — recursively extract the leaf-path mask
+ * from `resolved` (nested maps deep-merge), then set each leaf. When
+ * `mergeFields` is supplied, only those (dot-separated) top-level field
+ * paths are written; everything else in `resolved` is ignored.
+ */
+export function applyMerge(existing, resolved, mergeFields) {
+    const out = cloneDoc(existing);
+    const mask = [];
+    if (mergeFields !== undefined) {
+        // Restrict to the listed field paths. Each is a dot-separated path
+        // into `resolved`; read the value at that path (skip absent ones).
+        for (const field of mergeFields) {
+            const segments = splitPath(field);
+            const value = readPath(resolved, segments);
+            if (value !== ABSENT)
+                mask.push({ segments, value });
+        }
+    }
+    else {
+        collectLeaves(resolved, [], mask);
+    }
+    for (const { segments, value } of mask) {
+        setLeaf(out, segments, value);
+    }
+    return out;
+}
+const ABSENT = Symbol('field-merge:ABSENT');
+/** Read the value at a segment path, or ABSENT if any segment is missing. */
+function readPath(data, segments) {
+    let cursor = data;
+    for (const seg of segments) {
+        // `Object.hasOwn` (not `seg in cursor`) so an unvalidated `__proto__`
+        // segment can't follow the inherited chain into `Object.prototype`.
+        if (!isPlainObject(cursor) || !Object.hasOwn(cursor, seg))
+            return ABSENT;
+        cursor = cursor[seg];
+    }
+    return cursor;
+}
+/**
+ * Walk `data` collecting every leaf path. A leaf is a non-map value (or
+ * an empty map — prod preserves an empty map as a set leaf). `DELETE_MARKER`
+ * leaves are collected too so a merge can carry deleteField().
+ */
+function collectLeaves(data, prefix, out) {
+    const keys = Object.keys(data);
+    if (keys.length === 0 && prefix.length > 0) {
+        // Empty map at a nested path — set it as an empty-map leaf.
+        out.push({ segments: prefix, value: {} });
+        return;
+    }
+    for (const key of keys) {
+        const value = data[key];
+        const segments = [...prefix, key];
+        if (isPlainObject(value) && value !== DELETE_MARKER) {
+            collectLeaves(value, segments, out);
+        }
+        else {
+            out.push({ segments, value });
+        }
+    }
+}
+//# sourceMappingURL=field-merge.js.map

package/dist/sandbox/firestore/field-merge.js.map

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