pyric 0.1.0-alpha.21 → 0.1.0-alpha.24

package/dist/sandbox/clock.js

@@ -0,0 +1,167 @@
+/**
+ * The sandbox's one source of time.
+ *
+ * Every value the sandbox stamps that claims to be "when this happened" reads
+ * this clock: Firestore `serverTimestamp()` and `request.time`, Realtime
+ * Database `ServerValue.TIMESTAMP` and rules `now`, Storage `timeCreated` /
+ * `updated` and its `request.time`, auth token `iat` / `exp` / `auth_time` and
+ * account metadata, listener dispatch stamps, and the event, checkpoint, and
+ * persistence stamps that record when a sandbox operation happened. Moving the
+ * clock therefore moves every one of those together, which is the whole point:
+ * a rule that reads `request.time` and a document that carries a
+ * `serverTimestamp()` written in the same operation agree about what time it
+ * is.
+ *
+ * ## The model
+ *
+ * Three modes, one number each.
+ *
+ * - `wall` (the default): `now()` is `Date.now()`. Nothing about the sandbox's
+ *   behaviour differs from a build with no clock at all.
+ * - `fixed`: {@link SandboxClock.set} names an instant and **freezes** the
+ *   clock there. `now()` returns that instant until the clock is moved again.
+ *   Naming an exact instant is a request for determinism, so time stops.
+ * - `offset`: {@link SandboxClock.advance} from `wall` shifts the clock by a
+ *   delta and lets it **keep flowing**. Jumping forward a day is a request to
+ *   be a day later, not a request to stop, and monotonic progress is what push
+ *   ids, listener ordering, and elapsed-time bookkeeping rely on.
+ *
+ * `advance` is consistent with whichever mode it finds. From `wall` it opens an
+ * offset; from `offset` it grows that offset; from `fixed` it moves the frozen
+ * instant and stays frozen. {@link SandboxClock.reset} returns to `wall`.
+ *
+ * The clock is deliberately not monotonic across a `set`: a caller who pins an
+ * instant in the past gets an instant in the past, and the sandbox will stamp
+ * it. That is the caller's decision to make.
+ *
+ * Node-safe and browser-safe: it reads `Date.now()` and nothing else.
+ */
+import { SandboxError } from './types/errors.js';
+/**
+ * The key a sandbox carries its clock under. Registered globally
+ * (`Symbol.for`) rather than minted per module, because a workspace can load
+ * this module twice (a package specifier resolving to the built output, a
+ * relative path resolving to the source) and a per-module symbol would make
+ * {@link getClock} fail to recognize a sandbox built by the other copy.
+ */
+export const SANDBOX_CLOCK = Symbol.for('pyric.sandbox.clock');
+/**
+ * Resolve one sandbox's clock. The clock is the sandbox's whole notion of
+ * time: every `serverTimestamp()`, `request.time`, token `iat`, and event stamp
+ * on that sandbox reads it, so moving it here moves all of them.
+ *
+ * The clock survives `sandbox.reset()`, which swaps the Firestore environment
+ * but not the sandbox: a pinned instant is a property of the session, not of
+ * the data in it.
+ *
+ * Throws if `sandbox` was not produced by `initializeSandbox()`, the same guard
+ * `getInternalEnv` applies.
+ */
+export function getClock(sandbox) {
+    const carried = sandbox[SANDBOX_CLOCK];
+    if (carried === undefined) {
+        throw new SandboxError('invalid-argument', 'Sandbox handle was not produced by initializeSandbox(); custom Sandbox implementations are not supported.');
+    }
+    return carried;
+}
+/** The state a clock that has never been moved reports. */
+export function wallClockState() {
+    return { mode: 'wall', fixedAt: 0, offsetMs: 0 };
+}
+function assertFiniteMilliseconds(value, label) {
+    if (!Number.isFinite(value)) {
+        throw new RangeError(`${label} must be a finite number of milliseconds; received ${String(value)}.`);
+    }
+}
+/**
+ * One sandbox's clock. Owned by the sandbox and shared by every service on it,
+ * so `set` / `advance` / `reset` move all of them at once.
+ */
+export class SandboxClock {
+    currentMode = 'wall';
+    fixedAt = 0;
+    offsetMs = 0;
+    listeners = new Set();
+    /**
+     * Watch for a move. A sandbox hosted behind a transport (the SharedWorker
+     * host, say) has readers in another realm that cannot call `now()`
+     * synchronously, so they mirror this state instead and need to be told when
+     * it changes. Returns the function that stops watching.
+     */
+    onChange(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    announce() {
+        const state = this.capture();
+        for (const listener of [...this.listeners]) {
+            listener(state);
+        }
+    }
+    /** Which of the three modes the clock is in. */
+    get mode() {
+        return this.currentMode;
+    }
+    /** The sandbox's current time, in epoch milliseconds. */
+    now() {
+        if (this.currentMode === 'fixed') {
+            return this.fixedAt;
+        }
+        if (this.currentMode === 'offset') {
+            return Date.now() + this.offsetMs;
+        }
+        return Date.now();
+    }
+    /** The sandbox's current time as a `Date`. */
+    date() {
+        return new Date(this.now());
+    }
+    /**
+     * Pin the clock to `epochMs` and freeze it there. Every subsequent `now()`
+     * returns exactly `epochMs` until the clock is advanced, set again, or reset.
+     */
+    set(epochMs) {
+        assertFiniteMilliseconds(epochMs, 'A clock instant');
+        this.currentMode = 'fixed';
+        this.fixedAt = epochMs;
+        this.offsetMs = 0;
+        this.announce();
+    }
+    /**
+     * Move the clock forward (or, with a negative delta, back) by `ms`. A frozen
+     * clock stays frozen at the new instant; a wall or offset clock keeps
+     * flowing, shifted.
+     */
+    advance(ms) {
+        assertFiniteMilliseconds(ms, 'A clock advance');
+        if (this.currentMode === 'fixed') {
+            this.fixedAt += ms;
+            this.announce();
+            return;
+        }
+        this.currentMode = 'offset';
+        this.offsetMs += ms;
+        this.announce();
+    }
+    /** Return to the wall clock, discarding any pin or offset. */
+    reset() {
+        this.currentMode = 'wall';
+        this.fixedAt = 0;
+        this.offsetMs = 0;
+        this.announce();
+    }
+    /** This clock's whole state, as a value a checkpoint or branch can hold. */
+    capture() {
+        return { mode: this.currentMode, fixedAt: this.fixedAt, offsetMs: this.offsetMs };
+    }
+    /** Adopt a captured state wholesale. */
+    restore(state) {
+        this.currentMode = state.mode;
+        this.fixedAt = state.fixedAt;
+        this.offsetMs = state.offsetMs;
+        this.announce();
+    }
+}
+//# sourceMappingURL=clock.js.map

package/dist/sandbox/clock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clock.js","sourceRoot":"","sources":["../../src/sandbox/clock.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAGjD;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,MAAM,CAAC,GAAG,CAAC,qBAAqB,CAAC,CAAC;AAE/D;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,QAAQ,CAAC,OAAgB;IACvC,MAAM,OAAO,GAAI,OAA+D,CAAC,aAAa,CAAC,CAAC;IAChG,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;QAC1B,MAAM,IAAI,YAAY,CACpB,kBAAkB,EAClB,2GAA2G,CAC5G,CAAC;IACJ,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAqBD,2DAA2D;AAC3D,MAAM,UAAU,cAAc;IAC5B,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,CAAC;AACnD,CAAC;AAED,SAAS,wBAAwB,CAAC,KAAa,EAAE,KAAa;IAC5D,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;QAC5B,MAAM,IAAI,UAAU,CAAC,GAAG,KAAK,sDAAsD,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IACvG,CAAC;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,OAAO,YAAY;IACf,WAAW,GAAqB,MAAM,CAAC;IACvC,OAAO,GAAG,CAAC,CAAC;IACZ,QAAQ,GAAG,CAAC,CAAC;IACJ,SAAS,GAAG,IAAI,GAAG,EAAsC,CAAC;IAE3E;;;;;OAKG;IACH,QAAQ,CAAC,QAA4C;QACnD,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QAC7B,OAAO,GAAG,EAAE;YACV,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAClC,CAAC,CAAC;IACJ,CAAC;IAEO,QAAQ;QACd,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;QAC7B,KAAK,MAAM,QAAQ,IAAI,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC;YAC3C,QAAQ,CAAC,KAAK,CAAC,CAAC;QAClB,CAAC;IACH,CAAC;IAED,gDAAgD;IAChD,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IAED,yDAAyD;IACzD,GAAG;QACD,IAAI,IAAI,CAAC,WAAW,KAAK,OAAO,EAAE,CAAC;YACjC,OAAO,IAAI,CAAC,OAAO,CAAC;QACtB,CAAC;QACD,IAAI,IAAI,CAAC,WAAW,KAAK,QAAQ,EAAE,CAAC;YAClC,OAAO,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,QAAQ,CAAC;QACpC,CAAC;QACD,OAAO,IAAI,CAAC,GAAG,EAAE,CAAC;IACpB,CAAC;IAED,8CAA8C;IAC9C,IAAI;QACF,OAAO,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC;IAC9B,CAAC;IAED;;;OAGG;IACH,GAAG,CAAC,OAAe;QACjB,wBAAwB,CAAC,OAAO,EAAE,iBAAiB,CAAC,CAAC;QACrD,IAAI,CAAC,WAAW,GAAG,OAAO,CAAC;QAC3B,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC;QAClB,IAAI,CAAC,QAAQ,EAAE,CAAC;IAClB,CAAC;IAED;;;;OAIG;IACH,OAAO,CAAC,EAAU;QAChB,wBAAwB,CAAC,EAAE,EAAE,iBAAiB,CAAC,CAAC;QAChD,IAAI,IAAI,CAAC,WAAW,KAAK,OAAO,EAAE,CAAC;YACjC,IAAI,CAAC,OAAO,IAAI,EAAE,CAAC;YACnB,IAAI,CAAC,QAAQ,EAAE,CAAC;YAChB,OAAO;QACT,CAAC;QACD,IAAI,CAAC,WAAW,GAAG,QAAQ,CAAC;QAC5B,IAAI,CAAC,QAAQ,IAAI,EAAE,CAAC;QACpB,IAAI,CAAC,QAAQ,EAAE,CAAC;IAClB,CAAC;IAED,8DAA8D;IAC9D,KAAK;QACH,IAAI,CAAC,WAAW,GAAG,MAAM,CAAC;QAC1B,IAAI,CAAC,OAAO,GAAG,CAAC,CAAC;QACjB,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC;QAClB,IAAI,CAAC,QAAQ,EAAE,CAAC;IAClB,CAAC;IAED,4EAA4E;IAC5E,OAAO;QACL,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,WAAW,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,CAAC;IACpF,CAAC;IAED,wCAAwC;IACxC,OAAO,CAAC,KAAwB;QAC9B,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC,IAAI,CAAC;QAC9B,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC;QAC7B,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC;QAC/B,IAAI,CAAC,QAAQ,EAAE,CAAC;IAClB,CAAC;CACF"}

package/dist/sandbox/full-state.d.ts

@@ -0,0 +1,160 @@
+/**
+ * The whole sandbox as one value: capture it, apply it.
+ *
+ * The branch engine forks from a full state and promotes onto one, and a
+ * branch that silently carried only Firestore would be worse than no branch at
+ * all. So this module owns the single definition of what "everything" means:
+ *
+ *   Firestore documents
+ *   the Realtime Database tree, with its priorities
+ *   Storage objects, with their bytes and complete stored metadata
+ *   auth accounts, with the fields the auth sandbox exports, plus provider config
+ *   the three rule sources: Firestore, Realtime Database, and Storage
+ *
+ * {@link captureFullState} is a pure read: it reaches each service's backend
+ * through the same seams persistence already uses, and leaves every one of
+ * those reads unchanged. {@link applyFullState} is a total replace: after it
+ * returns, every read above answers exactly what the captured state holds, and
+ * state the target held that the capture did not is gone.
+ *
+ * The value is plain JSON, so a capture survives a file, a worker message, or
+ * a structured clone without losing a byte. Object bytes travel base64 encoded
+ * because JSON has no byte type.
+ *
+ * Placement: this is cross-surface runtime, not a capability, so it lives in
+ * central `sandbox/` alongside persistence and replay, which reach across the
+ * same services for the same reason.
+ */
+import { type SeedUser } from '../auth/index.js';
+import type { JsonValue } from '../database/sandbox/data-tree.js';
+import { type DocValueEncoding } from '../firestore/internal/value-codec.js';
+import { type StorageStateRecord } from '../storage/internal.js';
+import { type SandboxClockState } from './clock.js';
+import type { LocalSandbox } from './types/service.js';
+/** A Realtime Database ruleset, in the `{ rules: ... }` envelope the SDK takes. */
+export interface DatabaseRuleset {
+    rules: Record<string, unknown>;
+}
+/**
+ * One Storage object, with everything a reader of it can observe. Its bytes are
+ * either inline as base64, or named by SHA-256 in the backend that holds them:
+ * a capture by reference writes the second form, and only a backend that keeps
+ * content-addressed files can apply it.
+ */
+export type StorageObjectState = StorageObjectFields & ({
+    /** The object's bytes, base64 encoded so the state stays JSON. */
+    contentBase64: string;
+} | {
+    /** The SHA-256 of the object's bytes, which the backend holds. */
+    sha256: string;
+    /** The number of bytes. */
+    size: number;
+});
+/** Whether a Storage entry carries its bytes inline. */
+export declare function holdsBytesInline(object: StorageObjectState): object is StorageObjectState & {
+    contentBase64: string;
+};
+/** How a capture records Storage bytes. */
+export interface FullStateCaptureOptions {
+    /** `inline` (the default) carries every object's bytes; `reference` names them by hash. */
+    storage?: 'inline' | 'reference';
+}
+interface StorageObjectFields {
+    /** Full path within the bucket, for example `docs/hello.txt`. */
+    path: string;
+    /** Content type the object reports, absent when it carries none. */
+    contentType?: string;
+    /** The object's custom metadata. Always present, empty when it carries none. */
+    customMetadata: Record<string, string>;
+    /** Remaining persisted metadata; absent in legacy states that only kept upload fields. */
+    metadata?: Omit<StorageStateRecord['metadata'], 'fullPath' | 'contentType' | 'customMetadata'>;
+    /** The stored Blob's MIME type, which can differ from its object metadata. */
+    blobType?: string;
+}
+/** The auth account store: the users and the provider configuration over them. */
+export interface AuthAccountsState {
+    /**
+     * Every account the auth sandbox exports, in the `seedUsers` shape: uid,
+     * email, password, and the optional displayName, customClaims, photoUrl,
+     * phoneNumber, emailVerified, disabled, tenantId, providerId and account
+     * timestamps. Anonymous accounts are included in the same export contract.
+     */
+    users: SeedUser[];
+    /** Which sign-in providers are enabled, by provider id. */
+    providers: Record<string, boolean>;
+}
+/** The three rule sources a sandbox evaluates against. */
+export interface SandboxRuleSources {
+    /** Firestore Security Rules source. The empty source when none is installed. */
+    firestore: string;
+    /** Realtime Database rules, or null when the sandbox runs without them. */
+    database: DatabaseRuleset | null;
+    /** Storage Security Rules source, or null when the sandbox runs without them. */
+    storage: string | null;
+}
+/**
+ * The services a full state carries, in the order every reader walks them.
+ *
+ * One declaration: {@link SandboxService} is derived from it, the branch diff
+ * tags each divergence with one of these names, and the branch store writes one
+ * file per entry. A service added to {@link FullSandboxState} is added here, and
+ * the type, the diff, and the store follow without a second list to edit.
+ */
+export declare const SANDBOX_SERVICES: readonly ["firestore", "database", "storage", "auth", "rules"];
+/** One service a full state carries. */
+export type SandboxService = (typeof SANDBOX_SERVICES)[number];
+/** Everything one sandbox holds, as one plain JSON value. */
+export interface FullSandboxState {
+    /** Firestore documents by full path. */
+    firestore: Record<string, Record<string, unknown>>;
+    /** Declared value encoding; absent in legacy states that carry plain document maps. */
+    firestoreEncoding?: DocValueEncoding;
+    /**
+     * The Realtime Database persistence envelope: the tree and its priorities.
+     * The database's rules travel in {@link SandboxRuleSources} instead, so the
+     * two can never disagree about which ruleset the state carries.
+     */
+    database: JsonValue;
+    /** Every Storage object in the default bucket, ordered by path. */
+    storage: StorageObjectState[];
+    /** The auth account store. */
+    auth: AuthAccountsState;
+    /** The three rule sources. */
+    rules: SandboxRuleSources;
+    /**
+     * The sandbox clock's state at capture. A checkpoint restore and a branch
+     * fork both carry it, so a forked branch reaches the same `request.time`
+     * verdict its base reached and a restored checkpoint stamps the same
+     * `serverTimestamp()` the sandbox was stamping when it was taken.
+     *
+     * Optional: a state written before the clock existed, or by a producer that
+     * does not model time, restores the sandbox to the wall clock.
+     */
+    clock?: SandboxClockState;
+}
+/**
+ * Read one sandbox's entire state.
+ *
+ * A pure read: every service is reached through its own export seam, nothing
+ * is written, and two captures with no intervening write are identical values.
+ */
+export declare function captureFullState(sandbox: LocalSandbox, options?: FullStateCaptureOptions): Promise<FullSandboxState>;
+/**
+ * Whether a captured Storage ruleset is one a target can be given.
+ *
+ * A sandbox captured while Storage ran without rules carries null. There is no
+ * source to install and no way to un-install one, so a null source means no
+ * change. Both writers read this: the total replace below, and the delta a
+ * branch promotion writes.
+ */
+export declare function installsStorageRules(source: string | null): source is string;
+/**
+ * Replace one sandbox's entire state with `state`.
+ *
+ * A total replace, not a merge: state the target holds and the capture does
+ * not is removed. After this returns, every read {@link captureFullState}
+ * covers answers exactly what `state` holds.
+ */
+export declare function applyFullState(sandbox: LocalSandbox, state: FullSandboxState): Promise<void>;
+export {};
+//# sourceMappingURL=full-state.d.ts.map

package/dist/sandbox/full-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"full-state.d.ts","sourceRoot":"","sources":["../../src/sandbox/full-state.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,EAA8C,KAAK,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAG7F,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAClE,OAAO,EAAsB,KAAK,gBAAgB,EAAE,MAAM,sCAAsC,CAAC;AAMjG,OAAO,EAUL,KAAK,kBAAkB,EACxB,MAAM,wBAAwB,CAAC;AAGhC,OAAO,EAAY,KAAK,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAC9D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD,mFAAmF;AACnF,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC;AAED;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAAG,mBAAmB,GAAG,CACnD;IACA,kEAAkE;IAClE,aAAa,EAAE,MAAM,CAAC;CACvB,GACC;IACA,kEAAkE;IAClE,MAAM,EAAE,MAAM,CAAC;IACf,2BAA2B;IAC3B,IAAI,EAAE,MAAM,CAAC;CACd,CACF,CAAC;AAEF,wDAAwD;AACxD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,kBAAkB,GAAG,MAAM,IAAI,kBAAkB,GAAG;IAAE,aAAa,EAAE,MAAM,CAAA;CAAE,CAErH;AAED,2CAA2C;AAC3C,MAAM,WAAW,uBAAuB;IACtC,2FAA2F;IAC3F,OAAO,CAAC,EAAE,QAAQ,GAAG,WAAW,CAAC;CAClC;AAED,UAAU,mBAAmB;IAC3B,iEAAiE;IACjE,IAAI,EAAE,MAAM,CAAC;IACb,oEAAoE;IACpE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gFAAgF;IAChF,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACvC,0FAA0F;IAC1F,QAAQ,CAAC,EAAE,IAAI,CAAC,kBAAkB,CAAC,UAAU,CAAC,EAAE,UAAU,GAAG,aAAa,GAAG,gBAAgB,CAAC,CAAC;IAC/F,8EAA8E;IAC9E,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,kFAAkF;AAClF,MAAM,WAAW,iBAAiB;IAChC;;;;;OAKG;IACH,KAAK,EAAE,QAAQ,EAAE,CAAC;IAClB,2DAA2D;IAC3D,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED,0DAA0D;AAC1D,MAAM,WAAW,kBAAkB;IACjC,gFAAgF;IAChF,SAAS,EAAE,MAAM,CAAC;IAClB,2EAA2E;IAC3E,QAAQ,EAAE,eAAe,GAAG,IAAI,CAAC;IACjC,iFAAiF;IACjF,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,gEAAiE,CAAC;AAE/F,wCAAwC;AACxC,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAC;AAE/D,6DAA6D;AAC7D,MAAM,WAAW,gBAAgB;IAC/B,wCAAwC;IACxC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACnD,uFAAuF;IACvF,iBAAiB,CAAC,EAAE,gBAAgB,CAAC;IACrC;;;;OAIG;IACH,QAAQ,EAAE,SAAS,CAAC;IACpB,mEAAmE;IACnE,OAAO,EAAE,kBAAkB,EAAE,CAAC;IAC9B,8BAA8B;IAC9B,IAAI,EAAE,iBAAiB,CAAC;IACxB,8BAA8B;IAC9B,KAAK,EAAE,kBAAkB,CAAC;IAC1B;;;;;;;;OAQG;IACH,KAAK,CAAC,EAAE,iBAAiB,CAAC;CAC3B;AAgFD;;;;;GAKG;AACH,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,YAAY,EAAE,OAAO,GAAE,uBAA4B,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAwB9H;AAyFD;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,IAAI,MAAM,CAE5E;AAQD;;;;;;GAMG;AACH,wBAAsB,cAAc,CAClC,OAAO,EAAE,YAAY,EACrB,KAAK,EAAE,gBAAgB,GACtB,OAAO,CAAC,IAAI,CAAC,CAQf"}

package/dist/sandbox/full-state.js

@@ -0,0 +1,267 @@
+/**
+ * The whole sandbox as one value: capture it, apply it.
+ *
+ * The branch engine forks from a full state and promotes onto one, and a
+ * branch that silently carried only Firestore would be worse than no branch at
+ * all. So this module owns the single definition of what "everything" means:
+ *
+ *   Firestore documents
+ *   the Realtime Database tree, with its priorities
+ *   Storage objects, with their bytes and complete stored metadata
+ *   auth accounts, with the fields the auth sandbox exports, plus provider config
+ *   the three rule sources: Firestore, Realtime Database, and Storage
+ *
+ * {@link captureFullState} is a pure read: it reaches each service's backend
+ * through the same seams persistence already uses, and leaves every one of
+ * those reads unchanged. {@link applyFullState} is a total replace: after it
+ * returns, every read above answers exactly what the captured state holds, and
+ * state the target held that the capture did not is gone.
+ *
+ * The value is plain JSON, so a capture survives a file, a worker message, or
+ * a structured clone without losing a byte. Object bytes travel base64 encoded
+ * because JSON has no byte type.
+ *
+ * Placement: this is cross-surface runtime, not a capability, so it lives in
+ * central `sandbox/` alongside persistence and replay, which reach across the
+ * same services for the same reason.
+ */
+import { getAuth, sandbox as authSandbox } from '../auth/index.js';
+import { getOrCreateBackend } from '../database/sandbox/backend-for.js';
+import { DOC_VALUE_ENCODING } from '../firestore/internal/value-codec.js';
+import { ref, uploadBytes, } from '../storage/index.js';
+import { base64ToBytes, getAdminStorageSandbox, getStorageRulesResolution, replaceStorageRules, referenceStorageState, resetStorageState, restoreStorageReferences, restoreStorageState, snapshotStorageState, } from '../storage/internal.js';
+import { getInternalEnv } from './internal/sandbox-impl.js';
+import { encodeStateDocument, decodeStateDocument } from './internal/state-values.js';
+import { getClock } from './clock.js';
+/** Whether a Storage entry carries its bytes inline. */
+export function holdsBytesInline(object) {
+    return 'contentBase64' in object;
+}
+/**
+ * The services a full state carries, in the order every reader walks them.
+ *
+ * One declaration: {@link SandboxService} is derived from it, the branch diff
+ * tags each divergence with one of these names, and the branch store writes one
+ * file per entry. A service added to {@link FullSandboxState} is added here, and
+ * the type, the diff, and the store follow without a second list to edit.
+ */
+export const SANDBOX_SERVICES = ['firestore', 'database', 'storage', 'auth', 'rules'];
+/** The auth handle onto one sandbox, created on first reach the way `getAuth` does. */
+function authFor(sandbox) {
+    return getAuth(sandbox);
+}
+/** The default Realtime Database backend behind one sandbox. */
+function databaseBackendFor(sandbox) {
+    return getOrCreateBackend(sandbox);
+}
+/** The rules-bypass Storage handle onto one sandbox's default bucket. */
+function storageFor(sandbox) {
+    return getAdminStorageSandbox(sandbox);
+}
+/**
+ * The database persistence envelope with its rules key removed. The envelope
+ * the backend exports carries the active ruleset inline; the full state names
+ * rules once, under `rules.database`, so a caller editing one rule source can
+ * never leave a second stale copy behind in the tree.
+ */
+function databaseStateWithoutRules(backend) {
+    const exported = backend.exportPersistenceState();
+    const isObject = exported !== null && typeof exported === 'object' && !Array.isArray(exported);
+    if (!isObject)
+        return exported;
+    const envelope = { ...exported };
+    delete envelope.rules;
+    return envelope;
+}
+/** Read every Storage object out of the bucket, with its bytes or with its hash. */
+async function captureStorage(storage, mode) {
+    const byReference = mode === 'reference';
+    if (byReference)
+        return captureStorageReferences(storage);
+    const objects = [];
+    const records = await snapshotStorageState(storage);
+    records.sort((left, right) => {
+        const sortsBefore = left.metadata.fullPath < right.metadata.fullPath;
+        if (sortsBefore)
+            return -1;
+        const sortsAfter = left.metadata.fullPath > right.metadata.fullPath;
+        return sortsAfter ? 1 : 0;
+    });
+    for (const record of records) {
+        const { fullPath, contentType, customMetadata, ...metadata } = record.metadata;
+        const object = {
+            path: fullPath,
+            contentBase64: record.dataBase64,
+            customMetadata: customMetadata ?? {},
+            metadata,
+            blobType: record.blobType,
+        };
+        const hasContentType = contentType !== undefined;
+        if (hasContentType)
+            object.contentType = contentType;
+        objects.push(object);
+    }
+    return objects;
+}
+/** Read every Storage object as a reference to the bytes its backend holds. */
+async function captureStorageReferences(storage) {
+    const records = await referenceStorageState(storage);
+    records.sort((left, right) => (left.metadata.fullPath < right.metadata.fullPath ? -1 : left.metadata.fullPath > right.metadata.fullPath ? 1 : 0));
+    return records.map((record) => {
+        const { fullPath, contentType, customMetadata, ...metadata } = record.metadata;
+        const object = {
+            path: fullPath,
+            sha256: record.sha256,
+            size: record.size,
+            customMetadata: customMetadata ?? {},
+            metadata,
+            blobType: record.blobType,
+        };
+        const hasContentType = contentType !== undefined;
+        if (hasContentType)
+            object.contentType = contentType;
+        return object;
+    });
+}
+/**
+ * Read one sandbox's entire state.
+ *
+ * A pure read: every service is reached through its own export seam, nothing
+ * is written, and two captures with no intervening write are identical values.
+ */
+export async function captureFullState(sandbox, options = {}) {
+    const env = getInternalEnv(sandbox);
+    const database = databaseBackendFor(sandbox);
+    const auth = authFor(sandbox);
+    const storage = storageFor(sandbox);
+    const rules = {
+        firestore: env.getRules(),
+        database: database.getActiveRules(),
+        storage: getStorageRulesResolution(storage)?.source ?? null,
+    };
+    return {
+        firestore: Object.fromEntries(Object.entries(env.snapshot()).map(([path, data]) => [path, encodeStateDocument(data)])),
+        firestoreEncoding: DOC_VALUE_ENCODING,
+        database: databaseStateWithoutRules(database),
+        storage: await captureStorage(storage, options.storage ?? 'inline'),
+        auth: {
+            users: authSandbox.exportUsers(auth),
+            providers: authSandbox.exportProviderConfig(auth),
+        },
+        rules: structuredClone(rules),
+        clock: getClock(sandbox).capture(),
+    };
+}
+/**
+ * Adopt the captured clock, or return the sandbox to the wall clock when the
+ * state carries none. A total replace, like every other service here: applying
+ * a state never leaves the target on a clock the state did not name.
+ */
+function applyClock(sandbox, captured) {
+    const clock = getClock(sandbox);
+    if (captured === undefined) {
+        clock.reset();
+        return;
+    }
+    clock.restore(captured);
+}
+/** Replace the target's Firestore documents with exactly the ones the state holds. */
+function applyFirestoreDocuments(sandbox, documents, encoding) {
+    const env = getInternalEnv(sandbox);
+    for (const path of Object.keys(env.snapshot())) {
+        const isRetained = path in documents;
+        if (isRetained)
+            continue;
+        sandbox.admin.deleteDocument(path);
+    }
+    for (const [path, data] of Object.entries(documents)) {
+        sandbox.admin.setDocument(path, decodeStateDocument(data, encoding));
+    }
+}
+/** Replace the target's Realtime Database tree and install the state's ruleset. */
+function applyDatabase(sandbox, state) {
+    const backend = databaseBackendFor(sandbox);
+    backend.restoreTree(structuredClone(state.database));
+    backend.setRules(structuredClone(state.rules.database));
+}
+/** Replace the target's auth account store with exactly the accounts the state holds. */
+function applyAuth(sandbox, accounts) {
+    const auth = authFor(sandbox);
+    authSandbox.clearUsers(auth);
+    if (accounts.users.length > 0)
+        authSandbox.seedUsers(auth, structuredClone(accounts.users));
+    authSandbox.restoreProviderConfig(auth, { ...accounts.providers });
+}
+/** Replace the target's bucket with exactly the objects the state holds. */
+async function applyStorage(sandbox, objects) {
+    const storage = storageFor(sandbox);
+    await resetStorageState(storage);
+    for (const object of objects) {
+        const metadata = object.metadata;
+        const referenced = !holdsBytesInline(object);
+        if (referenced) {
+            const missingMetadata = metadata === undefined;
+            if (missingMetadata)
+                throw new Error(`Storage object '${object.path}' is a reference without its metadata.`);
+            await restoreStorageReferences(storage, [{
+                    sha256: object.sha256,
+                    size: object.size,
+                    blobType: object.blobType ?? object.contentType ?? '',
+                    metadata: { ...metadata, fullPath: object.path, contentType: object.contentType,
+                        customMetadata: { ...object.customMetadata } },
+                }]);
+            continue;
+        }
+        const hasStoredMetadata = metadata !== undefined;
+        if (hasStoredMetadata) {
+            await restoreStorageState(storage, [{
+                    dataBase64: object.contentBase64,
+                    blobType: object.blobType ?? object.contentType ?? '',
+                    metadata: { ...metadata, fullPath: object.path, contentType: object.contentType,
+                        customMetadata: { ...object.customMetadata } },
+                }]);
+            continue;
+        }
+        const settable = {
+            customMetadata: { ...object.customMetadata },
+        };
+        const hasContentType = object.contentType !== undefined;
+        if (hasContentType)
+            settable.contentType = object.contentType;
+        await uploadBytes(ref(storage, object.path), base64ToBytes(object.contentBase64), settable);
+    }
+}
+/**
+ * Whether a captured Storage ruleset is one a target can be given.
+ *
+ * A sandbox captured while Storage ran without rules carries null. There is no
+ * source to install and no way to un-install one, so a null source means no
+ * change. Both writers read this: the total replace below, and the delta a
+ * branch promotion writes.
+ */
+export function installsStorageRules(source) {
+    return source !== null;
+}
+/** Install the Storage ruleset the state carries, where it carries one. */
+async function applyStorageRules(sandbox, source) {
+    if (!installsStorageRules(source))
+        return;
+    await replaceStorageRules(sandbox, source);
+}
+/**
+ * Replace one sandbox's entire state with `state`.
+ *
+ * A total replace, not a merge: state the target holds and the capture does
+ * not is removed. After this returns, every read {@link captureFullState}
+ * covers answers exactly what `state` holds.
+ */
+export async function applyFullState(sandbox, state) {
+    applyClock(sandbox, state.clock);
+    applyFirestoreDocuments(sandbox, state.firestore, state.firestoreEncoding);
+    getInternalEnv(sandbox).deployRules(state.rules.firestore);
+    applyDatabase(sandbox, state);
+    applyAuth(sandbox, state.auth);
+    await applyStorage(sandbox, state.storage);
+    await applyStorageRules(sandbox, state.rules.storage);
+}
+//# sourceMappingURL=full-state.js.map

package/dist/sandbox/full-state.js.map

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

package/dist/sandbox/index.d.ts

@@ -15,17 +15,24 @@
  * the design rationale for the design rationale.
  */
 import type { LocalSandbox, SandboxConfig } from './types/service.js';
-export type { ActivityEventProvenance, AuthLens, AuthState, DenialContext, DenialEvent, EventActor, EventProvenance, EventService, OperationContext, ListenerLifecycleEvent, LocalSandbox, PersistableService, RequestEvent, RulesDisposition, Sandbox, SandboxConfig, SandboxContext, SandboxCommitEvent, SandboxErrorCode, SandboxEvent, SandboxListenerEvent, SandboxOperationEvent, SandboxRuntimeErrorEvent, SandboxSnapshot, ServiceMutationEvent, SessionBoundaryEvent, SnapshotDeliveryEvent, SnapshotErrorEvent, SnapshotSuppressedEvent, WriteSandboxEvent, } from './types/index.js';
-export { SandboxError } from './types/index.js';
+export type { ActivityEventProvenance, AuthLens, AuthState, DenialContext, DenialEvent, EventActor, EventProvenance, EventService, OperationContext, ListenerLifecycleEvent, ListenerOwner, LocalSandbox, MutationEventService, PersistableService, RequestEvent, RulesDisposition, Sandbox, SandboxConfig, SandboxContext, SandboxCommitEvent, SandboxErrorCode, SandboxEvent, SandboxListenerEvent, SandboxOperationEvent, SandboxObservationGapEvent, SandboxRuntimeErrorEvent, SandboxSnapshot, ServiceEventOperation, ServiceEventRecord, ServiceEventTarget, ServiceMutationEvent, ServiceMutationEventFields, SessionBoundaryEvent, SnapshotDeliveryEvent, SnapshotErrorEvent, SnapshotSuppressedEvent, WriteSandboxEvent, } from './types/index.js';
+export { SandboxError, MUTATION_EVENT_SERVICES, SERVICE_EVENT_RECORDS } from './types/index.js';
 export { SandboxContextImpl, normalizeAuthState, validateAuthState, } from './sandbox-context.js';
-export { isOperationEvent, operationContextFor, rulesDispositionFor, toOperationRecord, } from './operation-record.js';
-export type { OperationRecord } from './operation-record.js';
+export { SandboxClock, wallClockState } from './clock.js';
+export type { SandboxClockMode, SandboxClockState } from './clock.js';
+export { getClock } from './clock.js';
+export { isOperationEvent, operationContextFor, rulesDispositionFor, toListenerRecord, toOperationRecord, trafficOperationEvent, } from './operation-record.js';
+export type { ListenerPhase, OperationRecord } from './operation-record.js';
+export { activeListeners, activeListenerTargetStartsWith } from './active-listeners.js';
+export type { ActiveListener, ActiveListenerTarget } from './active-listeners.js';
 export { REMOTE_SANDBOX, REMOTE_SANDBOX_FACTORY, isRemoteSandbox } from './remote.js';
 export type { RemoteSandbox, RemoteSandboxChannel, RemoteSandboxFactory, RemoteSandboxFactoryOptions, } from './remote.js';
 export { replay } from './replay/index.js';
 export type { Divergence, ReplayOptions, ReplayResult } from './replay/index.js';
-export { apply, discard, diff, fork, promote } from './branches/index.js';
-export type { Branch, DiffTarget } from './branches/index.js';
+export { captureFullState, applyFullState, holdsBytesInline } from './full-state.js';
+export type { AuthAccountsState, DatabaseRuleset, FullSandboxState, FullStateCaptureOptions, SandboxRuleSources, SandboxService, StorageObjectState, } from './full-state.js';
+export { apply, discard, diff, diffFullStates, fork, promote, promoteFullState } from './branches/index.js';
+export type { Branch, BranchCandidateRules, BranchDivergence, DiffTarget, TreeChange, } from './branches/index.js';
 export type { PersistenceBackend, PersistenceController, SandboxPersistenceOptions, WebStorageLike, } from './persistence/index.js';
 export { attachPersistence, createIndexedDBBackend, createMemoryBackend, recordBackendOverBlob, serializeToBuckets, deserializeFromBuckets, bundleRecords, parseBundle, PersistenceSchemaError, rehydrateDocValue, } from './persistence/index.js';
 export type { BroadcastChannelLike, TabSyncOptions } from './tab-sync/index.js';