pyric 0.0.1 → 0.1.0-alpha.10

package/dist/firestore/snapshots.js

@@ -0,0 +1,160 @@
+/**
+ * `pyric/firestore` — shared sandbox snapshot rehydration.
+ *
+ * The read-path snapshot helpers used by BOTH `reads` (`getDoc` /
+ * `getDocs`) and `listeners` (`onSnapshot`): value finalization wrappers,
+ * ref tagging, and the `.exists` property→method normalization that makes
+ * sandbox snapshots match Firebase's modular-SDK shape.
+ *
+ * Package-internal — the barrel re-exports none of these; the public
+ * snapshot TYPES live in `types.ts`.
+ */
+import { tag, sandboxDb, sandboxLiveRebuild, refToUnderlying, finalizeSandboxData, } from './state.js';
+/**
+ * Wrap a raw sandbox `DocumentSnapshot` so `.data()` runs the final
+ * value translation (rules wrappers → `firebase/firestore` types).
+ * Other surface (id / ref / exists) passes through unchanged so
+ * `tagSnapshotRefs` still operates on the original snap object.
+ */
+export function wrapSandboxDocSnap(snap) {
+    const s = snap;
+    const original = s.data.bind(snap);
+    Object.defineProperty(s, 'data', {
+        value: () => finalizeSandboxData(original()),
+        configurable: true,
+        writable: true,
+    });
+    return snap;
+}
+/**
+ * Wrap a plain sandbox `DocumentSnapshot` so `.data()` runs the
+ * converter's `fromFirestore`. Identity / `exists` pass through.
+ */
+export function applyConverterToDocSnap(snap, conv) {
+    return {
+        id: snap.id,
+        exists: snap.exists,
+        data: () => {
+            // Sandbox snaps expose `exists` as a property (Admin shape).
+            const exists = typeof snap.exists === 'function'
+                ? snap.exists()
+                : snap.exists;
+            if (!exists)
+                return undefined;
+            const raw = finalizeSandboxData(snap.data());
+            // fromFirestore receives a QueryDocumentSnapshot-narrowed view —
+            // doc is known to exist at this branch, so `data()` returns the
+            // raw value (never undefined).
+            const queryDocSnap = {
+                id: snap.id,
+                exists: true,
+                data: () => raw,
+            };
+            return conv.fromFirestore(queryDocSnap);
+        },
+    };
+}
+/**
+ * Walk a snapshot and tag every ref-shaped field in `refToTarget`,
+ * AND normalize `.exists` to method form so consumer code targeting
+ * Firebase's modular SDK (`if (snap.exists())`) works uniformly.
+ *
+ * The chainable adapter exposes `exists` as a property (Admin SDK
+ * shape — `if (snap.exists)`). Firebase's modular SDK exposes it as
+ * a method (`if (snap.exists())`). Without this normalization, user
+ * code written against the documented Firebase API crashes against
+ * the sandbox with "snap.exists is not a function" — a parity bug
+ * agents and developers all rediscover by hand.
+ *
+ * Both forms remain readable on the returned object — the function
+ * branch in any "did the existing FirestoreTab handle both shapes"
+ * code still works.
+ *
+ * Idempotent — tagging an already-tagged object is a no-op, and the
+ * `exists` getter we install is a no-op when one already exists.
+ */
+export function tagSnapshotRefs(snap, target) {
+    if (!snap || typeof snap !== 'object')
+        return snap;
+    const s = snap;
+    if (s.ref) {
+        tag(s.ref, target);
+        wireSnapshotRefToUnderlying(s.ref, target);
+    }
+    normalizeExists(s);
+    if (Array.isArray(s.docs)) {
+        for (const doc of s.docs) {
+            if (doc?.ref) {
+                tag(doc.ref, target);
+                wireSnapshotRefToUnderlying(doc.ref, target);
+            }
+            if (doc)
+                normalizeExists(doc);
+        }
+    }
+    return snap;
+}
+/**
+ * Snapshot `.ref` objects from the sandbox carry only `{ id, path }`
+ * — no `.onSnapshot`, `.get`, `.set`, etc. — so a follow-up
+ * `onSnapshot(snap.ref)` would crash with "ref.onSnapshot is not a
+ * function." Bind the snapshot ref to a full chainable doc ref via
+ * `refToUnderlying`; `underlyingOf(snap.ref)` then returns the real
+ * ref the chainable adapter exposes its op methods on. No-op for refs that
+ * already have a registered underlying.
+ */
+export function wireSnapshotRefToUnderlying(snapRef, target) {
+    if (typeof snapRef.path !== 'string' || snapRef.path.length === 0)
+        return;
+    if (refToUnderlying.has(snapRef))
+        return;
+    const path = snapRef.path;
+    try {
+        // Build a concrete chainable doc to back the snap-ref via
+        // `refToUnderlying`. For sandbox-live, also record a rebuild
+        // closure so subsequent ops on the snap ref re-resolve against
+        // the *current* `sandbox.currentUser` (rather than re-using the
+        // listener-time auth that was frozen into the chainable).
+        const full = sandboxDb(target).doc(path);
+        refToUnderlying.set(snapRef, full);
+        if (target.kind === 'sandbox-live') {
+            sandboxLiveRebuild.set(full, (fresh) => fresh.doc(path));
+        }
+    }
+    catch {
+        // path → doc resolution can throw if the path is malformed
+        // (odd segment count, etc.). Best-effort — leave the snap ref
+        // pointing at itself; the next op call will surface a clear
+        // "ref.onSnapshot is not a function" instead of mangling state.
+    }
+}
+/**
+ * If `obj.exists` is a boolean property, replace it with a function
+ * that returns that value — so consumer code can do `snap.exists()`
+ * uniformly across the sandbox + Firebase backends. Idempotent: if
+ * `exists` is already a function, leave it alone.
+ *
+ * `configurable: true` so a later normalize (over a re-yielded
+ * snapshot from the same listener) can re-install cleanly.
+ */
+export function normalizeExists(obj) {
+    const current = obj.exists;
+    if (typeof current === 'function')
+        return;
+    const value = current === true;
+    try {
+        Object.defineProperty(obj, 'exists', {
+            value: () => value,
+            writable: true,
+            configurable: true,
+            enumerable: true,
+        });
+    }
+    catch {
+        // Some snapshot impls might freeze the object. Best-effort —
+        // a frozen snap already provides the property reading the user
+        // can do `if (snap.exists)` against; the call-site failure is
+        // surfaced via the error boundary.
+    }
+}
+//# sourceMappingURL=snapshots.js.map

package/dist/firestore/snapshots.js.map

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

package/dist/firestore/state.d.ts

@@ -0,0 +1,168 @@
+/**
+ * `pyric/firestore` — shared routing + branding state.
+ *
+ * The sandbox routing machinery every family module depends on: the
+ * {@link TARGET_SYMBOL} brand, the ref→target / converter / underlying
+ * WeakMaps, the tag / resolve helpers, and the sandbox read-path value
+ * finalizers. Hoisted out of the former single-file entry first (see the
+ * barrel `index.ts`) so the per-family moves that follow are clean.
+ *
+ * Only {@link TARGET_SYMBOL} is part of the published `pyric/firestore`
+ * surface (re-exported by the barrel). Every other export here is
+ * package-internal: it is imported by the family modules but never
+ * re-exported by the barrel, so it stays off the public subpath.
+ */
+import { type SandboxFirestore, type DocumentReference as ChainDocRef, type CollectionReference as ChainCollRef, type Query as ChainQuery, type DocumentData } from 'pyric/sandbox/admin-firestore';
+import type { Sandbox } from 'pyric/sandbox';
+import type { FirestoreDataConverter } from './types.js';
+/**
+ * Hidden property on every {@link Firestore} handle. Discriminates
+ * the sandbox backend so free functions can recover their owner.
+ */
+export declare const TARGET_SYMBOL: unique symbol;
+export type SandboxTarget = {
+    kind: 'sandbox';
+    db: SandboxFirestore;
+    sandbox: Sandbox;
+};
+/**
+ * Live-identity sandbox target — built by `getFirestore(sandbox)`.
+ *
+ * Unlike {@link SandboxTarget} (a frozen `SandboxContext` chosen at
+ * `getFirestore(ctx)` time), this variant reads `sandbox.currentUser`
+ * per operation via {@link getDb}. Every op constructs a fresh
+ * `SandboxContext` from the sandbox's *current* `currentUser` and
+ * obtains a chainable handle bound to that ctx.
+ *
+ * Wired into the modular surface so app code that uses both
+ * `pyric/auth` and `pyric/firestore` against the same `Sandbox` sees
+ * live auth-state changes: a `signInAnonymously` / `setUser` call on
+ * the auth side mutates `sandbox.currentUser`, and the next Firestore
+ * op evaluates rules under the new identity.
+ *
+ * `withAuth(null)` is anonymous; `withAuth(state)` is signed-in.
+ */
+export type SandboxLiveTarget = {
+    kind: 'sandbox-live';
+    sandbox: Sandbox;
+    getDb: () => SandboxFirestore;
+    authScope?: object;
+    own?: (cleanup: () => void) => () => void;
+    assertUsable?: () => void;
+};
+export type Target = SandboxTarget | SandboxLiveTarget;
+/**
+ * Resolve a sandbox-flavored target to its chainable Firestore handle.
+ *
+ * `sandbox` targets carry a frozen handle from `getFirestore(ctx)` time;
+ * `sandbox-live` targets build a fresh handle bound to the sandbox's
+ * current `currentUser` at every call. Callers that issue multiple ops
+ * in a row should cache the result into a local — every `getDb()` call
+ * rebuilds the chainable, which is correct but wasteful when the auth
+ * state hasn't moved between adjacent ops.
+ */
+export declare function sandboxDb(target: SandboxTarget | SandboxLiveTarget): SandboxFirestore;
+/**
+ * Map from refs / queries to their owning target. Populated by every
+ * factory + chaining operation; consulted by every free function.
+ *
+ * WeakMap keys let entries GC alongside the refs that produced them.
+ */
+export declare const refToTarget: WeakMap<object, Target>;
+export declare function tag<T extends object>(obj: T, target: Target): T;
+/**
+ * For `sandbox-live` refs/queries, record a closure that rebuilds the
+ * chainable ref against a fresh `SandboxFirestore` handle. Used by
+ * every dispatch site to re-resolve the ref under the sandbox's
+ * *current* `currentUser` rather than the auth that was active when
+ * the ref was first built.
+ *
+ * Necessary because `pyric-admin`'s chainable refs capture auth at
+ * construction time — calling `chainRef.get()` on a held ref runs
+ * under the auth from when the ref was built, not from when the op
+ * fires. For sandbox-live, every op must construct a fresh chainable
+ * ref bound to the current ctx before issuing the op.
+ *
+ * The closure form supports the full chain: `doc(coll, id)` rebuilds
+ * via `rebuild(coll)(db).doc(id)`; `query(coll, where(...))` rebuilds
+ * via `apply(constraints)` over the rebuilt source. Stored only for
+ * sandbox-live refs; frozen `sandbox` refs keep held-ref semantics.
+ */
+export declare const sandboxLiveRebuild: WeakMap<object, (db: SandboxFirestore) => object>;
+export declare function tagLive<T extends object>(obj: T, target: SandboxLiveTarget, rebuild: (db: SandboxFirestore) => object): T;
+/** Resolve the chainable doc ref to use for an op against `ref`. For
+ *  `sandbox`, returns the held chainable; for `sandbox-live`, runs
+ *  the recorded rebuild closure against a fresh handle. */
+export declare function chainDocFor(target: SandboxTarget | SandboxLiveTarget, ref: object): ChainDocRef;
+/** Same as {@link chainDocFor} but typed for collection refs. */
+export declare function chainCollFor(target: SandboxTarget | SandboxLiveTarget, ref: object): ChainCollRef;
+/** Same as {@link chainDocFor} but typed for queries. */
+export declare function chainQueryFor(target: SandboxTarget | SandboxLiveTarget, q: object): ChainQuery;
+/**
+ * Tag a sandbox-flavored ref + (optionally) record its rebuild
+ * closure. Routes to {@link tag} for frozen-ctx targets and
+ * {@link tagLive} for live targets. Centralizes the per-factory
+ * "record rebuild on live, plain tag on frozen" decision.
+ */
+export declare function tagSandboxRef<T extends object>(obj: T, target: SandboxTarget | SandboxLiveTarget, rebuild: (db: SandboxFirestore) => object): T;
+/** Resolve a sandbox-flavored parent's rebuild closure. For
+ *  sandbox-live, the parent must have been tagged via
+ *  {@link tagSandboxRef}; for sandbox, returns a no-op stand-in
+ *  since the held chainable is the only ref the dispatch sites use.
+ *
+ *  Used by chaining factories (`doc(coll, …)`, `collection(doc, …)`,
+ *  `query(coll, …)`) to derive a rebuild that reads the parent's
+ *  rebuild and applies one more step. */
+export declare function parentRebuild(parent: object): (db: SandboxFirestore) => object;
+export declare function targetOf(refOrDb: object): Target;
+export declare const refToConverter: WeakMap<object, FirestoreDataConverter<unknown, DocumentData> | null>;
+export declare const refToUnderlying: WeakMap<object, object>;
+export declare function converterOf(obj: object): FirestoreDataConverter<unknown> | null | undefined;
+/** Resolve to the plain chain / fb ref. `withConverter` shells point
+ *  at the underlying; everything else is its own underlying. */
+export declare function underlyingOf<T extends object>(obj: T): object;
+/** Build a new sandbox shell that points at `underlying` and carries
+ *  `converter`. Inherits routing + identity (id/path) from underlying.
+ *
+ *  Accepts both `SandboxTarget` and `SandboxLiveTarget`: the shell
+ *  exists at the modular layer (above the chainable), so it only
+ *  needs to record routing for `targetOf` and the underlying pointer
+ *  for `underlyingOf`. The chain re-resolution (under current auth)
+ *  happens at op time via {@link chainDocFor} / {@link chainCollFor}
+ *  / {@link chainQueryFor} on the underlying. */
+export declare function buildSandboxShell(underlying: {
+    id?: string;
+    path?: string;
+}, target: SandboxTarget | SandboxLiveTarget, converter: FirestoreDataConverter<unknown>): object;
+export declare function asChainDoc(r: object): ChainDocRef;
+export declare function asChainColl(r: object): ChainCollRef;
+export declare function asChainQuery(r: object): ChainQuery;
+export declare function isNumberArray(a: unknown): a is number[];
+/**
+ * A vector read from the sandbox may arrive as a live `Vector` wrapper, a
+ * prototype-stripped plain object (`{typeName:'vector', value}`), or the wire
+ * sentinel (`{__type__:'__vector__', value}`). Duck-type all three; `instanceof`
+ * alone misses the stripped form the read path hands back. Returns the
+ * components, or null if `value` isn't a vector.
+ */
+export declare function vectorValuesOf(value: unknown): number[] | null;
+/**
+ * Final read-path translation for sandbox-target snapshots.
+ *
+ * The admin-compat read-path walker (in `pyric/sandbox`'s admin-compat
+ * `snapshots.ts`) leaves `pyric/rules` wrappers (`Bytes`,
+ * `LatLng`) as identity. The modular mirror owns the final conversion to
+ * its public scalar classes.
+ *
+ * Walk the value tree and convert recognized rules wrappers into the
+ * corresponding local modular value class so `instanceof` survives a
+ * sandbox round trip.
+ *
+ * Closes firestore COMPAT rows #109 (`Bytes`) and #110 (`GeoPoint`).
+ * Vectors (#111, `VectorValue` / `vector()`) round-trip the same way as of
+ * Phase 0-F; the formal COMPAT ✓ + oracle observation land with the
+ * conformance phase (Phase 5b). Vector SEARCH (`findNearest`) is separate.
+ */
+export declare function finalizeSandboxValue(value: unknown): unknown;
+export declare function finalizeSandboxData(data: DocumentData | undefined): DocumentData | undefined;
+//# sourceMappingURL=state.d.ts.map

package/dist/firestore/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../src/firestore/state.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,IAAI,WAAW,EACrC,KAAK,mBAAmB,IAAI,YAAY,EACxC,KAAK,KAAK,IAAI,UAAU,EACxB,KAAK,YAAY,EAClB,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAM7C,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAKzD;;;GAGG;AACH,eAAO,MAAM,aAAa,EAAE,OAAO,MAAyC,CAAC;AAE7E,MAAM,MAAM,aAAa,GAAG;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,EAAE,EAAE,gBAAgB,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CAAC;AACxF;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE,cAAc,CAAC;IACrB,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,MAAM,gBAAgB,CAAC;IAC9B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,GAAG,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,IAAI,KAAK,MAAM,IAAI,CAAC;IAC1C,YAAY,CAAC,EAAE,MAAM,IAAI,CAAC;CAC3B,CAAC;AACF,MAAM,MAAM,MAAM,GAAG,aAAa,GAAG,iBAAiB,CAAC;AAEvD;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,aAAa,GAAG,iBAAiB,GAAG,gBAAgB,CAErF;AAED;;;;;GAKG;AACH,eAAO,MAAM,WAAW,yBAAgC,CAAC;AAEzD,wBAAgB,GAAG,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,GAAG,CAAC,CAG/D;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,kBAAkB,uBAA4B,gBAAgB,KAAK,MAAM,CAAG,CAAC;AAE1F,wBAAgB,OAAO,CAAC,CAAC,SAAS,MAAM,EACtC,GAAG,EAAE,CAAC,EACN,MAAM,EAAE,iBAAiB,EACzB,OAAO,EAAE,CAAC,EAAE,EAAE,gBAAgB,KAAK,MAAM,GACxC,CAAC,CAIH;AAED;;2DAE2D;AAC3D,wBAAgB,WAAW,CACzB,MAAM,EAAE,aAAa,GAAG,iBAAiB,EACzC,GAAG,EAAE,MAAM,GACV,WAAW,CAUb;AAED,iEAAiE;AACjE,wBAAgB,YAAY,CAC1B,MAAM,EAAE,aAAa,GAAG,iBAAiB,EACzC,GAAG,EAAE,MAAM,GACV,YAAY,CAUd;AAED,yDAAyD;AACzD,wBAAgB,aAAa,CAC3B,MAAM,EAAE,aAAa,GAAG,iBAAiB,EACzC,CAAC,EAAE,MAAM,GACR,UAAU,CAUZ;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,MAAM,EAC5C,GAAG,EAAE,CAAC,EACN,MAAM,EAAE,aAAa,GAAG,iBAAiB,EACzC,OAAO,EAAE,CAAC,EAAE,EAAE,gBAAgB,KAAK,MAAM,GACxC,CAAC,CAKH;AAED;;;;;;;yCAOyC;AACzC,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,CAAC,EAAE,EAAE,gBAAgB,KAAK,MAAM,CAQ9E;AAED,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAchD;AAED,eAAO,MAAM,cAAc,uEAAgE,CAAC;AAC5F,eAAO,MAAM,eAAe,yBAAgC,CAAC;AAE7D,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,sBAAsB,CAAC,OAAO,CAAC,GAAG,IAAI,GAAG,SAAS,CAE3F;AAED;gEACgE;AAChE,wBAAgB,YAAY,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,MAAM,CAE7D;AAED;;;;;;;;iDAQiD;AACjD,wBAAgB,iBAAiB,CAC/B,UAAU,EAAE;IAAE,EAAE,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,EAC1C,MAAM,EAAE,aAAa,GAAG,iBAAiB,EACzC,SAAS,EAAE,sBAAsB,CAAC,OAAO,CAAC,GACzC,MAAM,CASR;AAKD,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,WAAW,CAA6B;AAC/E,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,YAAY,CAA8B;AAClF,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,UAAU,CAA4B;AAE/E,wBAAgB,aAAa,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,MAAM,EAAE,CAEvD;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,GAAG,IAAI,CAO9D;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CA6B5D;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,YAAY,GAAG,SAAS,GAAG,YAAY,GAAG,SAAS,CAG5F"}

package/dist/firestore/state.js

@@ -0,0 +1,260 @@
+/**
+ * `pyric/firestore` — shared routing + branding state.
+ *
+ * The sandbox routing machinery every family module depends on: the
+ * {@link TARGET_SYMBOL} brand, the ref→target / converter / underlying
+ * WeakMaps, the tag / resolve helpers, and the sandbox read-path value
+ * finalizers. Hoisted out of the former single-file entry first (see the
+ * barrel `index.ts`) so the per-family moves that follow are clean.
+ *
+ * Only {@link TARGET_SYMBOL} is part of the published `pyric/firestore`
+ * surface (re-exported by the barrel). Every other export here is
+ * package-internal: it is imported by the family modules but never
+ * re-exported by the barrel, so it stays off the public subpath.
+ */
+import { Bytes as RulesBytes, LatLng as RulesLatLng, Vector as RulesVector, } from 'pyric/rules/internal';
+import { Bytes, GeoPoint, vector } from './field-values.js';
+// ─── Branding + routing ───────────────────────────────────────────────
+/**
+ * Hidden property on every {@link Firestore} handle. Discriminates
+ * the sandbox backend so free functions can recover their owner.
+ */
+export const TARGET_SYMBOL = Symbol('pyric/firestore/target');
+/**
+ * Resolve a sandbox-flavored target to its chainable Firestore handle.
+ *
+ * `sandbox` targets carry a frozen handle from `getFirestore(ctx)` time;
+ * `sandbox-live` targets build a fresh handle bound to the sandbox's
+ * current `currentUser` at every call. Callers that issue multiple ops
+ * in a row should cache the result into a local — every `getDb()` call
+ * rebuilds the chainable, which is correct but wasteful when the auth
+ * state hasn't moved between adjacent ops.
+ */
+export function sandboxDb(target) {
+    return target.kind === 'sandbox' ? target.db : target.getDb();
+}
+/**
+ * Map from refs / queries to their owning target. Populated by every
+ * factory + chaining operation; consulted by every free function.
+ *
+ * WeakMap keys let entries GC alongside the refs that produced them.
+ */
+export const refToTarget = new WeakMap();
+export function tag(obj, target) {
+    refToTarget.set(obj, target);
+    return obj;
+}
+/**
+ * For `sandbox-live` refs/queries, record a closure that rebuilds the
+ * chainable ref against a fresh `SandboxFirestore` handle. Used by
+ * every dispatch site to re-resolve the ref under the sandbox's
+ * *current* `currentUser` rather than the auth that was active when
+ * the ref was first built.
+ *
+ * Necessary because `pyric-admin`'s chainable refs capture auth at
+ * construction time — calling `chainRef.get()` on a held ref runs
+ * under the auth from when the ref was built, not from when the op
+ * fires. For sandbox-live, every op must construct a fresh chainable
+ * ref bound to the current ctx before issuing the op.
+ *
+ * The closure form supports the full chain: `doc(coll, id)` rebuilds
+ * via `rebuild(coll)(db).doc(id)`; `query(coll, where(...))` rebuilds
+ * via `apply(constraints)` over the rebuilt source. Stored only for
+ * sandbox-live refs; frozen `sandbox` refs keep held-ref semantics.
+ */
+export const sandboxLiveRebuild = new WeakMap();
+export function tagLive(obj, target, rebuild) {
+    refToTarget.set(obj, target);
+    sandboxLiveRebuild.set(obj, rebuild);
+    return obj;
+}
+/** Resolve the chainable doc ref to use for an op against `ref`. For
+ *  `sandbox`, returns the held chainable; for `sandbox-live`, runs
+ *  the recorded rebuild closure against a fresh handle. */
+export function chainDocFor(target, ref) {
+    const underlying = underlyingOf(ref);
+    if (target.kind === 'sandbox')
+        return underlying;
+    const rebuild = sandboxLiveRebuild.get(underlying);
+    if (!rebuild) {
+        throw new TypeError('pyric/firestore: live ref missing rebuild closure — was it produced by a factory in this package?');
+    }
+    return rebuild(sandboxDb(target));
+}
+/** Same as {@link chainDocFor} but typed for collection refs. */
+export function chainCollFor(target, ref) {
+    const underlying = underlyingOf(ref);
+    if (target.kind === 'sandbox')
+        return underlying;
+    const rebuild = sandboxLiveRebuild.get(underlying);
+    if (!rebuild) {
+        throw new TypeError('pyric/firestore: live collection ref missing rebuild closure.');
+    }
+    return rebuild(sandboxDb(target));
+}
+/** Same as {@link chainDocFor} but typed for queries. */
+export function chainQueryFor(target, q) {
+    const underlying = underlyingOf(q);
+    if (target.kind === 'sandbox')
+        return underlying;
+    const rebuild = sandboxLiveRebuild.get(underlying);
+    if (!rebuild) {
+        throw new TypeError('pyric/firestore: live query missing rebuild closure.');
+    }
+    return rebuild(sandboxDb(target));
+}
+/**
+ * Tag a sandbox-flavored ref + (optionally) record its rebuild
+ * closure. Routes to {@link tag} for frozen-ctx targets and
+ * {@link tagLive} for live targets. Centralizes the per-factory
+ * "record rebuild on live, plain tag on frozen" decision.
+ */
+export function tagSandboxRef(obj, target, rebuild) {
+    if (target.kind === 'sandbox-live') {
+        return tagLive(obj, target, rebuild);
+    }
+    return tag(obj, target);
+}
+/** Resolve a sandbox-flavored parent's rebuild closure. For
+ *  sandbox-live, the parent must have been tagged via
+ *  {@link tagSandboxRef}; for sandbox, returns a no-op stand-in
+ *  since the held chainable is the only ref the dispatch sites use.
+ *
+ *  Used by chaining factories (`doc(coll, …)`, `collection(doc, …)`,
+ *  `query(coll, …)`) to derive a rebuild that reads the parent's
+ *  rebuild and applies one more step. */
+export function parentRebuild(parent) {
+    const underlying = underlyingOf(parent);
+    const fn = sandboxLiveRebuild.get(underlying);
+    if (fn)
+        return fn;
+    // Frozen-ctx target. The chainable parent ref is bound to the same
+    // ctx for life; returning it as-is is correct because frozen-ctx
+    // chaining is what `pyric-admin`'s adapter already supports.
+    return () => underlying;
+}
+export function targetOf(refOrDb) {
+    let target;
+    if (TARGET_SYMBOL in refOrDb) {
+        target = refOrDb[TARGET_SYMBOL];
+    }
+    else {
+        target = refToTarget.get(refOrDb);
+    }
+    if (!target) {
+        throw new TypeError('pyric/firestore: unrecognized reference — was it produced by a factory in this package?');
+    }
+    if (target.kind === 'sandbox-live')
+        target.assertUsable?.();
+    return target;
+}
+export const refToConverter = new WeakMap();
+export const refToUnderlying = new WeakMap();
+export function converterOf(obj) {
+    return refToConverter.get(obj);
+}
+/** Resolve to the plain chain / fb ref. `withConverter` shells point
+ *  at the underlying; everything else is its own underlying. */
+export function underlyingOf(obj) {
+    return refToUnderlying.get(obj) ?? obj;
+}
+/** Build a new sandbox shell that points at `underlying` and carries
+ *  `converter`. Inherits routing + identity (id/path) from underlying.
+ *
+ *  Accepts both `SandboxTarget` and `SandboxLiveTarget`: the shell
+ *  exists at the modular layer (above the chainable), so it only
+ *  needs to record routing for `targetOf` and the underlying pointer
+ *  for `underlyingOf`. The chain re-resolution (under current auth)
+ *  happens at op time via {@link chainDocFor} / {@link chainCollFor}
+ *  / {@link chainQueryFor} on the underlying. */
+export function buildSandboxShell(underlying, target, converter) {
+    const shell = {
+        id: underlying.id ?? '',
+        path: underlying.path ?? '',
+    };
+    refToConverter.set(shell, converter);
+    refToUnderlying.set(shell, underlying);
+    refToTarget.set(shell, target);
+    return shell;
+}
+// Shorthand: cast helpers used inside route arms. The runtime objects
+// match these shapes precisely; the casts let the routing keep its
+// single-typed public surface.
+export function asChainDoc(r) { return r; }
+export function asChainColl(r) { return r; }
+export function asChainQuery(r) { return r; }
+export function isNumberArray(a) {
+    return Array.isArray(a) && a.every((n) => typeof n === 'number');
+}
+/**
+ * A vector read from the sandbox may arrive as a live `Vector` wrapper, a
+ * prototype-stripped plain object (`{typeName:'vector', value}`), or the wire
+ * sentinel (`{__type__:'__vector__', value}`). Duck-type all three; `instanceof`
+ * alone misses the stripped form the read path hands back. Returns the
+ * components, or null if `value` isn't a vector.
+ */
+export function vectorValuesOf(value) {
+    if (value instanceof RulesVector)
+        return Array.from(value.value);
+    if (value === null || typeof value !== 'object')
+        return null;
+    const o = value;
+    if (o.typeName === 'vector' && isNumberArray(o.value))
+        return o.value;
+    if (o.__type__ === '__vector__' && isNumberArray(o.value))
+        return o.value;
+    return null;
+}
+/**
+ * Final read-path translation for sandbox-target snapshots.
+ *
+ * The admin-compat read-path walker (in `pyric/sandbox`'s admin-compat
+ * `snapshots.ts`) leaves `pyric/rules` wrappers (`Bytes`,
+ * `LatLng`) as identity. The modular mirror owns the final conversion to
+ * its public scalar classes.
+ *
+ * Walk the value tree and convert recognized rules wrappers into the
+ * corresponding local modular value class so `instanceof` survives a
+ * sandbox round trip.
+ *
+ * Closes firestore COMPAT rows #109 (`Bytes`) and #110 (`GeoPoint`).
+ * Vectors (#111, `VectorValue` / `vector()`) round-trip the same way as of
+ * Phase 0-F; the formal COMPAT ✓ + oracle observation land with the
+ * conformance phase (Phase 5b). Vector SEARCH (`findNearest`) is separate.
+ */
+export function finalizeSandboxValue(value) {
+    if (value instanceof RulesBytes) {
+        return Bytes.fromUint8Array(value.data);
+    }
+    if (value instanceof RulesLatLng) {
+        return new GeoPoint(value.lat, value.lng);
+    }
+    const vectorValues = vectorValuesOf(value);
+    if (vectorValues) {
+        return vector(vectorValues);
+    }
+    if (Array.isArray(value)) {
+        return value.map(finalizeSandboxValue);
+    }
+    // Only walk plain objects (`{...}` literals + `Object.create(null)`).
+    // Class instances we don't recognize pass through as identity so we
+    // don't accidentally destructure their private state (the same gap
+    // that motivated #109/#110 in the first place).
+    if (value !== null && typeof value === 'object') {
+        const proto = Object.getPrototypeOf(value);
+        if (proto === Object.prototype || proto === null) {
+            const out = {};
+            for (const [k, v] of Object.entries(value)) {
+                out[k] = finalizeSandboxValue(v);
+            }
+            return out;
+        }
+    }
+    return value;
+}
+export function finalizeSandboxData(data) {
+    if (data === undefined)
+        return undefined;
+    return finalizeSandboxValue(data);
+}
+//# sourceMappingURL=state.js.map

package/dist/firestore/state.js.map

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