snapback2 0.0.1

package/dist/token-store.d.ts

@@ -0,0 +1,3 @@
+import type { AuthTokenStore } from "./types.js";
+/** Adapts explicitly supplied browser storage; the client never selects storage itself. */
+export declare function browserTokenStore(storage: Pick<Storage, "getItem" | "setItem" | "removeItem">, key: string): AuthTokenStore;

package/dist/twin-hydrate.d.ts

@@ -0,0 +1,43 @@
+import { type EvaluatorClosureReceipt, type TaggedValue } from "./offline-protocol.js";
+import type { Coverage } from "./store/range-store.js";
+/**
+ * The evaluator's `ClosureReceipt` for a partition's coverage. Rows keep the
+ * pool's order; a range's halo is the pooled row its `haloId` names; `n2Key`
+ * never leaves the server, so it is `null` here as it is on the wire. The
+ * schema hash is recomputed from the schema, never taken from the caller, so
+ * every rebuild proves the hasher against the server's; an expected hash that
+ * disagrees refuses the rebuild — coverage delivered under another schema, or
+ * a hasher drifted from Rust, is `hydrating`, never evaluated (LLP 1012 §8).
+ */
+export declare function closureFromCoverage(coverage: Coverage, schema: any, expectedSchemaHash?: string): EvaluatorClosureReceipt;
+/** Tag one operation argument by the IR's descriptor (`Cursor`, `Optional`, or a column type). */
+export declare function tagArgument(descriptor: unknown, value: unknown, path: string): TaggedValue;
+export declare function tagArguments(descriptors: unknown, args: unknown): Record<string, TaggedValue>;
+export type PartialReason = "never-held" | "evicted" | "computed-key";
+export interface PartialSite {
+    site: string;
+    reason: PartialReason;
+}
+interface TraceLike {
+    ranges: Array<{
+        site: string;
+        table: string;
+        provenance?: string;
+    }>;
+    absences: Array<{
+        site: string;
+        table: string;
+        index: string;
+        key: unknown[];
+        provenance?: string;
+    }>;
+}
+/**
+ * Why a site fell outside coverage: a row a swap evicted (`evicted`: a
+ * primary-key read of an evicted row, or a range over a table one of whose
+ * held pages lost a member), a key the program computed from another row so
+ * no page could have named it (`computed-key`), or a read the store simply
+ * never held (`never-held`).
+ */
+export declare function partialReasons(sites: string[], trace: TraceLike, coverage: Coverage): PartialSite[];
+export {};

package/dist/twin.d.ts

@@ -0,0 +1,70 @@
+import { type PartialSite } from "./twin-hydrate.js";
+import type { Coverage, HeldProgram, OutboxEntry, OutboxTrace, OverlayRow } from "./store/range-store.js";
+export interface TwinSources {
+    /** The certified program held for this partition, if any. */
+    program(): HeldProgram | undefined;
+    coverage(): Promise<Coverage | undefined>;
+    overlay(): Promise<Record<string, OverlayRow[]>>;
+    /** Every durable intent, FIFO; overlays are layered in this order. */
+    entries(): Promise<OutboxEntry[]>;
+    principal(): string | undefined;
+    now(): number;
+    seq(): number;
+}
+/** A query the twin answered locally, in the wire's shape plus its offline facts. */
+export interface LocalAnswer {
+    state: "complete" | "capped" | "partial" | "denied";
+    data?: unknown;
+    next?: string | null;
+    seq: number;
+    reason?: string;
+    rule?: string;
+    /** The first uncovered site (`partial`). */
+    site?: string;
+    /** Every uncovered site with its reason (`partial`). */
+    sites?: PartialSite[];
+    /** Queued intents whose predicted rows are visible in `data`, in order. */
+    predicted?: string[];
+    /** The newest delivery the answer was computed from. */
+    since?: number;
+}
+export interface Prediction {
+    predicted: boolean;
+    overlay: OverlayRow[];
+    trace: OutboxTrace;
+    /** Range reads evaluated over held rows only; ranges re-execute fresh at commit and are never validated. */
+    partialRanges: string[];
+    /** The point reads or rule inputs outside coverage that stopped the prediction. */
+    uncovered: PartialSite[];
+    /**
+     * Engine-owned aggregate targets (`maintain … count`) this write updates on the
+     * server but the overlay omits, because the store does not hold them: named so
+     * a reader can tell an intentionally omitted aggregate from a lost write.
+     */
+    omitted: string[];
+}
+/** Debug seam for the witness: why the twin last declined to evaluate (never part of a result). */
+export declare function twinLastDecline(): string | undefined;
+export declare class Twin {
+    private readonly sources;
+    constructor(sources: TwinSources);
+    /**
+     * The certified program run over coverage. `undefined` when no program is
+     * held, when the coverage was delivered under another generation or schema
+     * (the successor fence: a predecessor's program never evaluates into current
+     * state), or when the operation is not a query the program knows.
+     */
+    evaluate(op: string, args: unknown): Promise<LocalAnswer | undefined>;
+    /**
+     * The mutation run over held rows with the intent's pinned ids as its `new`
+     * envelope, so the prediction and the commit mint the same ids. Predicted
+     * when every point read and rule input was covered; a range the store does
+     * not hold whole is evaluated over the rows it has and named in
+     * `partialRanges` — ranges re-execute at commit and are never validated. An
+     * uncovered point or rule input, or a local refusal, leaves the intent
+     * queued without a prediction and with an empty trace: the server judges.
+     */
+    predict(op: string, args: unknown, ids: string[]): Promise<Prediction>;
+    private context;
+    private hydrate;
+}

package/dist/types.d.ts

@@ -0,0 +1,410 @@
+import type { AssetFetchOptions } from "./store/byte-cache.js";
+import type { Channel as ChannelRef, Op } from "./api.js";
+import type { AssetCache, ByteCacheEntry, ByteCacheStatus, ViewOncePredicate } from "./store/byte-cache.js";
+import type { OutboxEntry, RangeStoreFactory, RowRef, StoredRow } from "./store/range-store.js";
+export type { OutboxEntry, OutboxGrant, OutboxState, OutboxTrace } from "./store/range-store.js";
+export type { AssetCache, ByteCacheEntry, ByteCacheStatus, ViewOncePredicate };
+export type ImageAsset = {
+    readonly __asset: "image";
+    readonly id: string;
+    readonly width: number;
+    readonly height: number;
+};
+export type VideoAsset = {
+    readonly __asset: "video";
+    readonly id: string;
+    readonly width: number;
+    readonly height: number;
+    readonly duration: number;
+};
+/** Server-minted authority subject; structurally compatible with `snapback2.Principal`. */
+export type Principal = string & {
+    readonly __snapbackPrincipal: "Principal";
+};
+export type Cursor = string & {
+    readonly __snapbackCursor: "Cursor";
+};
+export interface RefusalEnvelope {
+    code: string;
+    family: string;
+    message: string;
+    site?: string;
+    rule?: string;
+    rewrite?: string;
+    guide: string;
+    /** Offline resume detail identifying the request member that exceeded a cap. */
+    which?: string;
+    /** Offline resume detail limiting the next bounded request. */
+    cap?: number;
+}
+/** Opt-in body fields for a query request that asks for local-first custody. */
+export interface QueryReceiptRequest {
+    readonly receipt: true;
+    readonly validator?: string;
+}
+/** Opt-in query fields for a subscription request that asks for local-first custody. */
+export interface SubscribeReceiptRequest {
+    readonly receipt: true;
+    readonly validator?: string;
+}
+export type QueryComplete<Result> = {
+    state: "complete";
+    data: Result;
+    seq: number;
+    next: Cursor | null;
+};
+export type QueryCapped<Result> = {
+    state: "capped";
+    data: Result;
+    seq: number;
+    next: Cursor | null;
+};
+export type QueryPartial<Result> = {
+    state: "partial";
+    data?: Result;
+    seq: number;
+    reason: string;
+};
+export type QueryDenied = {
+    state: "denied";
+    seq: number;
+    rule: string;
+};
+export type ServerQueryResult<Result> = QueryComplete<Result> | QueryCapped<Result> | QueryPartial<Result> | QueryDenied;
+export type OfflineFacts = {
+    live: false;
+    connection: "offline";
+    stale: {
+        since: number;
+    };
+    retained?: boolean;
+    caughtUp?: boolean;
+    watermark?: Cursor | null;
+    /** Queued intents whose predicted rows are inside `data`, in order (the twin, LLP 1012 §7). */
+    predicted?: string[];
+    /** A local `partial`: the uncovered site and every uncovered site with its reason. */
+    site?: string;
+    sites?: Array<{
+        site: string;
+        reason: "never-held" | "evicted" | "computed-key";
+    }>;
+};
+export type OfflineQueryResult<Result> = (QueryComplete<Result> & OfflineFacts) | (QueryCapped<Result> & OfflineFacts) | (QueryPartial<Result> & OfflineFacts) | (QueryDenied & OfflineFacts) | {
+    state: "hydrating";
+    live: false;
+    connection: "offline";
+};
+export type QueryResult<Result> = ServerQueryResult<Result> | OfflineQueryResult<Result>;
+export type MutationCommitted<Result> = {
+    state: "committed";
+    seq: number;
+    data: Result;
+    intent?: string;
+};
+export type MutationRejected = {
+    state: "rejected";
+    code: string;
+    family: string;
+    message: string;
+    retryable?: boolean;
+    rewrite?: string;
+    site?: string;
+    rule?: string;
+    guide: string;
+    /** `conflict` when trace validation rolled a replayed write back (LLP 1012 §7). */
+    reason?: string;
+    intent?: string;
+};
+/** The write is durable in this device's outbox and will replay after the next resume. */
+export type MutationQueued = {
+    state: "queued";
+    intent: string;
+    ids: string[];
+};
+export type MutationResult<Result> = MutationCommitted<Result> | MutationRejected | MutationQueued;
+export type LiveQueryDelivery<Result> = ServerQueryResult<Result> & {
+    live: true;
+    caughtUp?: boolean;
+    watermark?: Cursor | null;
+};
+export type StaleDelivery<Result> = {
+    state: "stale";
+    live: false;
+    since: number;
+    data?: Result;
+    seq?: number;
+};
+export type RefusedDelivery = {
+    state: "refused";
+    code: string;
+    family: string;
+    message: string;
+    site?: string;
+    rule?: string;
+    rewrite?: string;
+    guide: string;
+    seq?: number;
+};
+export type QueryRefusedDelivery = RefusedDelivery & {
+    live: false;
+};
+export type SubscriptionDelivery<Result> = LiveQueryDelivery<Result> | (ServerQueryResult<Result> & {
+    live: false;
+    caughtUp?: boolean;
+    watermark?: Cursor | null;
+}) | OfflineQueryResult<Result> | StaleDelivery<Result> | QueryRefusedDelivery;
+export interface Subscription<Event> {
+    close(): void;
+    until(predicate: (event: Event) => boolean, timeoutMs?: number): Promise<Event>;
+}
+export interface AuthSession {
+    token: string;
+    viewer: Principal;
+}
+export interface AuthMe {
+    viewer: Principal;
+    kind: string;
+}
+export interface AuthApi {
+    signup(input: {
+        email: string;
+        password: string;
+    }): Promise<AuthSession>;
+    login(input: {
+        email: string;
+        password: string;
+    }): Promise<AuthSession>;
+    guest(): Promise<AuthSession>;
+    logout(): Promise<{
+        ok: boolean;
+    }>;
+    me(): Promise<AuthMe>;
+}
+export interface ChannelEvent<Payload = unknown> {
+    from: Principal;
+    payload: Payload;
+    at: number;
+}
+export type ChannelDelivery<Payload = unknown> = ChannelEvent<Payload> | RefusedDelivery;
+export type ChannelPublishResult = {
+    ok: true;
+} | ({
+    state: "refused";
+} & RefusalEnvelope);
+export interface ChannelHandle<Payload = unknown> {
+    publish(payload: Payload): Promise<ChannelPublishResult>;
+    subscribe(callback: (event: ChannelDelivery<Payload>) => void): Subscription<ChannelDelivery<Payload>>;
+}
+export interface ManifestOperation {
+    kind: string;
+    args: unknown;
+    planHash: string;
+}
+export interface ManifestTable {
+    retain?: "until-revoked" | "delivered-history";
+    [key: string]: unknown;
+}
+export interface Manifest {
+    generation: string;
+    programGeneration: string;
+    ops: Record<string, ManifestOperation>;
+    channels: Record<string, unknown>;
+    auth: Record<string, unknown>;
+    schemaHash?: string;
+    tables?: Record<string, ManifestTable>;
+    schema?: {
+        tables?: Record<string, ManifestTable>;
+        [key: string]: unknown;
+    };
+}
+export type AssetRecord = ImageAsset | VideoAsset;
+export interface NativeAssetSource {
+    readonly uri: string;
+    readonly size?: number;
+    readonly fileSize?: number;
+    readonly type?: string;
+    readonly mimeType?: string;
+}
+export type AssetUploadSource = File | NativeAssetSource;
+export interface UploadProgress {
+    readonly loaded: number;
+    readonly total: number;
+}
+export type AssetKind = "image" | "video";
+export interface AssetUploadOptions {
+    /**
+     * The nominal record expected back. The server sniffs the bytes and decides the
+     * kind; when `kind` is given the client verifies the returned record and refuses
+     * `E_ASSET_TYPE` on a mismatch, so the result can flow straight into a generated
+     * `image`/`video` argument (LLP 1006 §10). Without it the result is the union.
+     */
+    readonly kind?: AssetKind;
+    /**
+     * Reports streamed byte progress where the runtime supports request streams.
+     * Expo native File uploads use expo/fetch's direct File body and report only
+     * whole-body start and successful completion (0, then total).
+     */
+    readonly onProgress?: (progress: UploadProgress) => void;
+}
+export interface AssetUrlOptions {
+    readonly width?: number;
+    readonly carrier?: boolean;
+    readonly download?: boolean;
+}
+/** Replaces generated asset leaves with the browser/native upload convenience accepted by the SDK. */
+export type AssetInput<Value> = Value extends VideoAsset ? Value | File | NativeAssetSource : Value extends ImageAsset ? Value | File | NativeAssetSource : Value extends File ? Value : Value extends readonly (infer Item)[] ? AssetInput<Item>[] : Value extends object ? {
+    [Key in keyof Value]: AssetInput<Value[Key]>;
+} : Value;
+export type ConnectionState = "connected" | "reconnecting" | "offline";
+export interface ClientSnapshot {
+    /** Client-local cache/transport partition; never a server bearer or epoch. */
+    authGeneration: number;
+    token?: string;
+    persona?: string;
+    connection: ConnectionState;
+    generation?: string;
+    lastRefusal?: RefusalEnvelope;
+}
+export interface AuthTokenStore {
+    /** Restores the bearer before `client.ready` settles. */
+    load(): string | null | undefined | Promise<string | null | undefined>;
+    /** Persists a bearer, or clears custody with `null`. */
+    save(token: string | null): void | Promise<void>;
+    /** Optional companion custody needed to reopen a per-principal offline partition before network I/O. */
+    loadPrincipal?(): string | null | undefined | Promise<string | null | undefined>;
+    savePrincipal?(principal: string | null): void | Promise<void>;
+}
+interface ClientLocationOptions {
+    url: string;
+    fetch?: typeof globalThis.fetch;
+    offline?: OfflineClientOptions;
+}
+export interface OfflineClientOptions {
+    store: RangeStoreFactory;
+    fenceDays?: number;
+    /** Ceiling on cached asset bytes per partition, LRU by each rendition's own last read; default 256 MiB. */
+    maxAssetBytes?: number;
+    onTombstone?: (row: StoredRow) => RowRef[];
+    /**
+     * Names the rows whose media renders once: a viewed row is excluded from every
+     * later offline answer and its bytes are never cached (LLP 1012 §9). This stands
+     * in for LLP 1006's one-use delivery until that lands on the server.
+     */
+    viewOnce?: ViewOncePredicate;
+}
+/** A client has exactly one authority source: a dev persona or bearer custody. */
+export type CreateClientOptions = ClientLocationOptions & ({
+    as: string;
+    token?: never;
+    tokenStore?: never;
+} | {
+    as?: never;
+    token?: string;
+    tokenStore?: AuthTokenStore;
+});
+export type OutboxSettlement = void | {
+    stopped: "fence";
+};
+export interface OutboxApi {
+    /** Every durable intent of the open partition, FIFO; empty without a store. */
+    entries(): Promise<OutboxEntry[]>;
+    /** Drops one settled entry; queued intents cannot be dismissed. */
+    dismiss(intent: string): Promise<void>;
+    /** Observes the outbox; called with the current entries at once and after every change. */
+    subscribe(listener: (entries: OutboxEntry[]) => void): () => void;
+    /**
+     * Without an op, true when a write will not refuse `E_OFFLINE_ID_BLOCK` for
+     * want of a replay grant: no partition is open (today's bytes), or the open
+     * partition holds a current, unexpired grant — minted by a login, a guest
+     * call, or the first drain reaching its watermark. The fence gates replay and
+     * prediction, not this (see `fence`). With an op, also means this write would
+     * not refuse `E_OFFLINE_ID_BLOCK` for want of a known bound or capacity for
+     * `1 + maxNewIds`. Grant, bound, fence, and expiry changes are observable
+     * through `subscribe` even when the entries are unchanged (LLP 1012 §7).
+     */
+    ready<Args = unknown, Result = unknown>(op?: Op<Args, Result>): Promise<boolean>;
+    /** Past means replay waits for this partition's successful resume; enqueue remains ready. */
+    fence(): Promise<"inside" | "past">;
+    /** Replays FIFO; a fence stop returns { stopped: "fence" } with the intents still queued. */
+    drain(): Promise<OutboxSettlement>;
+    /**
+     * Resolves once the in-flight replay, if any, emptied the queue or a retryable
+     * transport failure stopped it; returns { stopped: "fence" } if resume is
+     * required, and rejects with a non-retryable refusal that stopped it.
+     */
+    settled(): Promise<OutboxSettlement>;
+}
+export interface SnapbackClient {
+    readonly auth: AuthApi;
+    readonly outbox: OutboxApi;
+    /** Settles only after explicit token restoration and any initial persistence. */
+    readonly ready: Promise<void>;
+    readonly snapshot: ClientSnapshot;
+    query<Args, Result>(ref: Op<Args, Result>, args: NoInfer<Args>): Promise<QueryResult<Result>>;
+    mutation<Args, Result>(ref: Op<Args, Result>, args: NoInfer<AssetInput<Args>>): Promise<MutationResult<Result>>;
+    /** Uploads one browser File or Expo URI-backed File and returns its closed asset record. */
+    upload(source: AssetUploadSource, options: AssetUploadOptions & {
+        readonly kind: "image";
+    }): Promise<ImageAsset>;
+    upload(source: AssetUploadSource, options: AssetUploadOptions & {
+        readonly kind: "video";
+    }): Promise<VideoAsset>;
+    upload(source: AssetUploadSource, options?: AssetUploadOptions): Promise<AssetRecord>;
+    assetUrl(asset: AssetRecord | null | undefined, options?: AssetUrlOptions): Promise<string | undefined>;
+    assetUrl(assets: readonly AssetRecord[], options?: AssetUrlOptions): Promise<string[]>;
+    /** Authentication headers for a native image source; carriers stay reserved for players/downloads. */
+    assetHeaders(): Promise<Record<string, string>>;
+    /** Fetches a client-issued asset URL: the byte cache under the row's lease first, then the network with the header credential. */
+    assetBlob(url: string, options?: AssetFetchOptions): Promise<Blob>;
+    /** Native byte path: cache first, then an authenticated ArrayBuffer response; no Blob. */
+    assetBytes(url: string, options?: AssetFetchOptions): Promise<import("./store/byte-cache.js").AssetBytes>;
+    /** The partition's byte cache when the client has an offline store; components read it before the network. */
+    readonly assetCache: AssetCache | undefined;
+    /** Delivers validated query receipt states with `live: true`; transport loss is client-made `stale`. */
+    subscribe<Args, Result>(ref: Op<Args, Result>, args: NoInfer<Args>, callback: (delivery: SubscriptionDelivery<Result>) => void, options?: {
+        drain?: boolean;
+    }): Subscription<SubscriptionDelivery<Result>>;
+    channel<Args, Payload = unknown>(ref: ChannelRef<Args, Payload>, args: NoInfer<Args>): ChannelHandle<Payload>;
+    manifest(): Promise<Manifest>;
+    subscribeStatus(callback: (snapshot: ClientSnapshot) => void): () => void;
+    /** Cut only this client's transport; the owner remains running. */
+    offline(): Promise<void>;
+    /** Restore transport and perform resume before new subscription opens. */
+    online(): Promise<void>;
+    /** Close and reopen this logical device on the same durable partition. */
+    restart(): Promise<SnapbackClient>;
+    /** Resolves when the offline carrier is quiet; safe to remove the store after. */
+    close(): Promise<void>;
+}
+type ViewFacts = {
+    live: boolean;
+    stale?: {
+        since: number;
+    };
+    retained?: boolean;
+    caughtUp?: boolean;
+    watermark?: Cursor | null;
+    predicted?: string[];
+};
+export type QueryView<Result> = (QueryComplete<Result> & ViewFacts) | (QueryCapped<Result> & ViewFacts) | (QueryPartial<Result> & ViewFacts) | (QueryDenied & ViewFacts) | {
+    state: "refused";
+    live: false;
+    refusal: RefusalEnvelope;
+} | {
+    state: "stale";
+    live: false;
+    data?: Result;
+    seq?: number;
+    since: number;
+} | {
+    state: "hydrating";
+    live: false;
+};
+export type QueryViewState = QueryView<unknown>["state"];
+export type QueryHookResult<Result> = QueryView<Result> & {
+    connection: ConnectionState;
+};
+export type QueryMachineEvent<Result> = QueryResult<Result> | SubscriptionDelivery<Result>;
+export declare function initialQueryState<Result>(): QueryView<Result>;
+export declare function stableSerialize(value: unknown): string;
+export declare function reduceQueryState<Result>(current: QueryView<Result>, event: QueryMachineEvent<Result>): QueryView<Result>;

package/dist/witness-test.mjs

@@ -0,0 +1,2 @@
+var Le=Object.defineProperty;var y=(t,e)=>()=>(t&&(e=t(t=0)),e);var Be=(t,e)=>{for(var n in e)Le(t,n,{get:e[n],enumerable:!0})};import ne,{useCallback as R}from"react";import{AssetImage as Ve,AssetVideo as Me}from"snapback2/react-native";function W({media:t}){let e=R((o,i)=>{t.uri=o,t.hidden&&i&&t.resolve({loaded:t.loaded,uri:o})},[t]),n=R(o=>{let i=t.uri;if(!i){t.resolve({loaded:!1});return}o&&o!==i||(t.loaded=!0,(t.once?i.startsWith("data:"):i.startsWith("file://"))&&t.resolve({loaded:!0,uri:i,..."duration"in t.asset?{playing:!0}:{}}))},[t]),r=R(o=>t.resolve({loaded:!1,refusal:o.envelope}),[t]);return"duration"in t.asset?ne.createElement(Me,{asset:t.asset,width:64,autoPlay:!t.hidden,testID:"witness-media",onSourceChange:e,onPlaybackStart:n,onRefusal:r}):ne.createElement(Ve,{asset:t.asset,width:64,testID:"witness-media",onSourceChange:e,onLoad:o=>n(o?.nativeEvent?.source?.uri),onRefusal:r})}var U=y(()=>{"use strict"});import{Directory as j,File as H,Paths as re}from"expo-file-system";import{expoSqliteDriver as Ne}from"snapback2/expo";function ae(){let t=ie();return t.exists?t.list().filter(e=>e instanceof H&&/\/\d{16}\.json$/.test(e.uri)).sort((e,n)=>e.uri.localeCompare(n.uri)):[]}async function O(){let t=ae().at(-1);return t?JSON.parse(await t.text()):qe()}function S(t){let e=oe.then(async()=>{let n=ie();n.create({intermediates:!0,idempotent:!0});let r=ae(),o=r.at(-1),i=o?Number(o.uri.match(/(\d{16})\.json$/)[1])+1:1,p=new H(n,"next.tmp");p.write(JSON.stringify({...await O(),...t})),p.move(new H(n,`${String(i).padStart(16,"0")}.json`));for(let x of r)x.delete()});return oe=e.catch(()=>{}),e}function v(t=new j(re.cache,"snapback2")){return t.exists?t.list().flatMap(e=>e instanceof j?v(e):[e.uri]):[]}async function Q(){let t=Ne(q),e={};try{for(let n of["state","rows","answers","outbox","bytes"]){let r=await t.all(`SELECT * FROM ${n} ORDER BY partition${n==="state"?"":", key"}`);e[n]=r.map(o=>Object.fromEntries(Object.entries(o).map(([i,p])=>[i,p instanceof Uint8Array?Array.from(p):p])))}return e}finally{await t.close()}}async function de(t,e,n){if(!n[0])throw new Error("enqueue both messages before the atomicity marker");let r=e==="pre"?11:22,o={deliveries:[{op:"deliveries.thread",args:{conversationId:"witness-marker",c:null},seq:e==="pre"?1:2,state:"complete",next:null,data:{$row:{table:"messages",id:"witness-marker"}},rows:[{table:"messages",id:"witness-marker",row:{id:"witness-marker",conversationId:"witness-marker",authorId:"witness",body:e,photo:{id:se,width:1,height:1},at:1}}],receipt:{ranges:[],absences:[],verdicts:[]}}],outbox:{put:[{...n[0],intent:"__witness",state:"committed",op:"deliveries.post",args:{conversationId:"witness-marker",body:e},predicted:!1}]},bytes:{put:[{assetId:se,width:null,type:`witness/${e}`,bytes:new Uint8Array([r])}]}};await t.commit(o)}var q,ie,qe,oe,se,z=y(()=>{"use strict";q="snapback2-witness.db",ie=()=>new j(re.document,"snapback2-witness-config"),qe=()=>({offline:!1,fault:"none",name:"alice",once:[],assets:[]});oe=Promise.resolve();se="s2id-eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee-0000000000000001"});function ce(t){let e=new Map;for(let n of t){let r=e.get(n.conversationId)??{conversationId:n.conversationId,latestAt:n.at,latestBody:void 0,messages:0};n.kind==="message"&&(r.messages+=1),n.at>=r.latestAt&&(r.latestAt=n.at,r.latestBody=n.message?.body??r.latestBody),e.set(n.conversationId,r)}return[...e.values()].sort((n,r)=>r.latestAt-n.latestAt)}function J(t){let e=t.args;return t.op==="deliveries.post"&&e&&typeof e.conversationId=="string"&&typeof e.body=="string"?{conversationId:e.conversationId,body:e.body}:void 0}function De(t){let e=t.args;return t.op==="deliveries.edit"&&e&&typeof e.messageId=="string"&&typeof e.body=="string"?{messageId:e.messageId,body:e.body,baseBody:e.baseBody??""}:void 0}function le(t){switch(t.state){case"queued":return t.reason==="fence"?"Will be checked by the server":"Sending\u2026";case"committed":return"Sent";case"expired":return"Expired";case"rejected":{let e=t.response;return e?.reason==="conflict"||e?.code==="CONFLICT"?"Not sent \xB7 Message changed":`Not sent \xB7 ${e?.rewrite??e?.message??e?.code??"refused"}`}}}function D(t,e,n){let r=new Set(t.filter(s=>s.kind==="removed"||s.kind==="expired").map(s=>s.messageId)),o=new Map(e.map(s=>[De(s)?.messageId,s]).filter(([s])=>s!==void 0)),i=new Set,p=[],x=new Map(e.filter(s=>s.state==="queued"&&J(s)!==void 0).map(s=>[s.ids[0]??s.intent,s])),f=[...t].sort((s,m)=>s.at-m.at||(s.messageId<m.messageId?-1:s.messageId>m.messageId?1:0));for(let s of f){if(s.kind!=="message"||!s.message||r.has(s.messageId)||i.has(s.messageId))continue;i.add(s.messageId);let m=x.get(s.messageId);if(m){p.push({key:s.messageId,kind:"pending",entry:m,body:J(m).body});continue}let w=o.get(s.messageId);p.push({key:s.messageId,kind:"row",message:s.message,at:s.at,...w?{edit:w}:{}})}for(let s of e){let m=J(s);if(!m||m.conversationId!==n)continue;let w=s.ids[0]??s.intent;i.has(w)||p.push({key:w,kind:"pending",entry:s,body:m.body})}return p}function $(t,e){let n=e.trim().toLowerCase();if(!n)return[];let r=new Set;return t.filter(o=>{let i=o.message?.body;return o.kind!=="message"||!i||r.has(o.messageId)||!i.toLowerCase().includes(n)?!1:(r.add(o.messageId),!0)})}var P=y(()=>{});import L from"react";import{Pressable as $e,Text as K,View as _e}from"react-native";function ue({rows:t,onSelect:e}){return L.createElement(_e,{accessibilityLabel:"Inbox"},ce(t).map(n=>L.createElement($e,{key:n.conversationId,onPress:()=>e(n.conversationId),style:{paddingVertical:16}},L.createElement(K,{style:{fontWeight:"600"}},n.conversationId),L.createElement(K,null,n.latestBody??`${n.messages} messages`))),t.length===0?L.createElement(K,null,"No downloaded messages yet."):null)}var fe=y(()=>{"use strict";P()});import k,{useState as pe}from"react";import{Button as Fe,Text as X,TextInput as Re,View as We}from"react-native";import{api as Ue,isSnapbackRefusal as je}from"snapback2/client";import{useMutation as He,useOutbox as Qe}from"snapback2/react-native";function me({conversationId:t}){let e=He(Ue.deliveries.post),{fence:n}=Qe(),[r,o]=pe(""),[i,p]=pe(""),x=async()=>{if(!(!r.trim()||!e.ready))try{let f=await e.run({conversationId:t,body:r.trim()});f.state==="rejected"?p(f.rewrite??f.message):(o(""),p(f.state==="queued"?"Queued until the next sync.":""))}catch(f){p(je(f)?f.envelope.rewrite??f.message:String(f))}};return k.createElement(We,{style:{padding:16}},k.createElement(Re,{accessibilityLabel:"Message",placeholder:"Message",value:r,onChangeText:o,multiline:!0}),k.createElement(Fe,{title:"Send",disabled:!e.ready||e.inFlight||!r.trim(),onPress:()=>{x()}}),e.ready?n==="past"?k.createElement(X,null,"Queued until the next sync."):null:k.createElement(X,null,"Sending opens once the log has downloaded."),i?k.createElement(X,{accessibilityRole:"alert"},i):null)}var ge=y(()=>{"use strict"});import g from"react";import{ScrollView as ze,Text as I,View as we}from"react-native";import{api as Je}from"snapback2/client";import{AssetImage as Ke,AssetVideo as Xe,useOutbox as Ye,useQuery as Ge}from"snapback2/react-native";function ye({conversationId:t}){let e=Ge(Je.deliveries.thread,{conversationId:t,c:null}),{entries:n}=Ye(),r="data"in e&&Array.isArray(e.data)?e.data:[];return g.createElement(we,{style:{flex:1}},g.createElement(ze,{contentContainerStyle:{padding:16}},e.state==="partial"?g.createElement(I,null,"Some messages are not downloaded."):null,e.state==="refused"?g.createElement(I,null,e.refusal.rewrite??e.refusal.message):null,D(r,n,t).map(o=>g.createElement(we,{key:o.key,testID:`message-${o.key}`,style:{padding:12,marginVertical:4,backgroundColor:"#e7edff",borderRadius:12}},o.kind==="pending"?g.createElement(g.Fragment,null,g.createElement(I,null,o.body),g.createElement(I,null,le(o.entry))):g.createElement(g.Fragment,null,g.createElement(I,null,o.message.body),o.message.photo?g.createElement(Ke,{asset:o.message.photo,width:240}):null,o.message.clip?g.createElement(Xe,{asset:o.message.clip,width:240}):null,g.createElement(I,null,new Date(o.at).toLocaleTimeString()))))),g.createElement(me,{conversationId:t}))}var be=y(()=>{"use strict";P();ge()});import B,{useState as Ze}from"react";import{Pressable as et,Text as xe,TextInput as tt,View as nt}from"react-native";function he({rows:t,onOpen:e}){let[n,r]=Ze("");return B.createElement(nt,null,B.createElement(tt,{accessibilityLabel:"Search downloaded messages",placeholder:"Search",value:n,onChangeText:r}),n?B.createElement(xe,null,"in downloaded messages"):null,$(t,n).map(o=>B.createElement(et,{key:o.messageId,onPress:()=>e(o.conversationId)},B.createElement(xe,null,o.message?.body))))}var ve=y(()=>{"use strict";P()});import b,{useState as ot}from"react";import{SafeAreaView as st,ScrollView as rt,Text as Se,Button as it}from"react-native";import{api as at}from"snapback2/client";import{useConnection as dt,useQuery as ct}from"snapback2/react-native";function _(){let t=dt(),e=ct(at.deliveries.inbox,{c:null},{drain:!0}),n="data"in e&&Array.isArray(e.data)?e.data:[],[r,o]=ot();return b.createElement(st,{style:{flex:1,backgroundColor:"#f7f7fb"}},b.createElement(Se,{style:{fontSize:24,padding:16}},"Snapback Chat \xB7 ",t),r?b.createElement(b.Fragment,null,b.createElement(it,{title:"Inbox",onPress:()=>o(void 0)}),b.createElement(ye,{conversationId:r})):b.createElement(rt,{contentContainerStyle:{padding:16}},b.createElement(he,{rows:n,onOpen:o}),b.createElement(ue,{rows:n,onSelect:o}),e.state==="refused"?b.createElement(Se,null,e.refusal.rewrite??e.refusal.message):null))}var Y=y(()=>{"use strict";fe();be();ve()});var V,G=y(()=>{V={onTombstone:t=>t.table==="deliveries"&&(t.row.kind==="removed"||t.row.kind==="expired")&&typeof t.row.messageId=="string"?[{table:"messages",id:t.row.messageId}]:[],viewOnce:(t,e)=>t==="messages"&&e.viewOnce===!0}});var Ae={};Be(Ae,{default:()=>Ie});import{twinLastDecline as lt}from"snapback2/expo/witness";import M,{useEffect as ut,useState as Z}from"react";import{Text as ft,View as pt}from"react-native";import{api as A,SnapbackRefusal as mt}from"snapback2/client";import{createExpoClient as gt,expoSqliteStore as ke,expoSqliteDriver as wt,SnapbackProvider as yt}from"snapback2/expo";import{witnessControl as bt,runSqliteDriverConformance as xt}from"snapback2/expo/witness";function Ie({url:t,controlUrl:e}){let[n,r]=Z(),[o,i]=Z(),[p,x]=Z();return ut(()=>{let f,s,m="conversation-1",w=[],C,Ee=0,te=async()=>{for(let d of w)d.close();w=[],await f?.close(),f=void 0,r(void 0)},Oe=bt({construct:async(d,u)=>{if(await te(),u.fresh===!0){let a=ke(q)();try{await a.wipe("dev:alice")}finally{await a.close?.()}await S({name:"alice",offline:!1,fault:"none"})}typeof u.name=="string"&&await S({name:u.name}),(Array.isArray(u.once)||Array.isArray(u.assets))&&await S({...Array.isArray(u.once)?{once:u.once}:{},...Array.isArray(u.assets)?{assets:u.assets}:{}});let c=await O();s=ke(q,{beforeCommit:d.beforeCommit})(),c.fault==="carrier"&&(s.open=async()=>{throw new mt({code:"E_OFFLINE_CARRIER",family:"offline",site:"witness construct",message:"persisted witness carrier fault",rewrite:"send fault(none), then construct",guide:"offline"})}),f=gt({url:t,as:c.name,startOffline:c.offline,offline:{...V,store:()=>s,viewOnce:(a,l)=>V.viewOnce(a,l)||a==="messages"&&c.once.includes(String(l.id))}});try{return await f.ready,r(f),x(void 0),f}catch(a){throw x(String(a)),a}},persist:S,async command(d,u,c){if(u==="stores")return{stores:await Q(),files:v()};if(!d||!s)throw new Error("construct first");if(u==="drain"){let a=d.subscribe(A.deliveries.inbox,{c:null},()=>{},{drain:!0});return w.push(a),a.until(l=>"caughtUp"in l&&l.caughtUp===!0)}if(u==="open"){m=String(c.conversationId);let a=d.subscribe(A.deliveries.thread,{conversationId:m,c:null},()=>{});return w.push(a),await a.until(l=>l.state==="complete"),await d.query(A.messages.thread,{conversationId:m,c:null}),d.query(A.deliveries.thread,{conversationId:m,c:null})}if(u==="send")return d.mutation(A.deliveries.post,{conversationId:typeof c.conversationId=="string"?c.conversationId:m,body:String(c.body)});if(u==="view"){let l=(await O()).assets.find(h=>h.id===c.assetId);if(!l)throw new Error("unknown witness asset");let T=!!(await d.assetCache?.viewOnce(l.id)||await d.assetCache?.viewed(l.id)),N=await new Promise(h=>{C={asset:l,nonce:++Ee,once:T,hidden:c.hidden===!0,loaded:!1,resolve:F=>h(F)},i(C)});if(!T&&N.loaded===!0){let h=E=>decodeURIComponent(E).replace(/\/+$/,""),F=h(String(N.uri)),Pe=Date.now()+1e4;for(;!v().some(E=>h(E)===F);){if(Date.now()>=Pe)throw new Error(`ordinary media did not materialize a file: served ${N.uri}; listed ${JSON.stringify(v().slice(0,6))}`);await new Promise(E=>setTimeout(E,10))}}return{...N,viewed:await d.assetCache?.viewed(l.id),files:v().filter(h=>h.includes(l.id))}}if(u==="swap"){if(c.phase!=="pre"&&c.phase!=="post")throw new Error("swap needs pre or post");return await de(s,c.phase,await d.outbox.entries()),{phase:c.phase}}if(u==="conformance")return xt(()=>wt("snapback2-conformance.db"));if(u==="settled"){await d.outbox.settled(),(await d.outbox.entries()).some(l=>l.state==="queued")&&(await d.outbox.drain(),await d.outbox.settled());let a=await d.outbox.entries();if(a.some(l=>l.state==="queued"))throw new Error("outbox did not settle");return a}if(u==="state"){let a=typeof c.conversationId=="string"?await d.query(A.deliveries.thread,{conversationId:c.conversationId,c:null}):void 0,l=await d.outbox.entries(),T=a&&"data"in a&&Array.isArray(a.data)?a.data:[];return{snapshot:d.snapshot,coverage:await s.coverage(),outbox:l,bubbles:typeof c.conversationId=="string"?D(T,l,c.conversationId):[],search:typeof c.search=="string"?$(T,c.search):[],answer:a,twin:lt(),stores:await Q(),files:v(),media:C?{loaded:C.loaded,uri:C.uri}:null}}throw new Error(`unknown witness command ${u}`)}},e);return()=>{Oe.close(),te()}},[t,e]),n?M.createElement(yt,{client:n},M.createElement(pt,{style:{flex:1}},M.createElement(_,null),o?M.createElement(W,{key:o.nonce,media:o}):null)):M.createElement(ft,null,p??"Witness connected; waiting for construct.")}var Ce=y(()=>{"use strict";U();G();P();z();Y()});U();z();Y();G();import ee,{lazy as ht,Suspense as An,useEffect as vt,useState as Te}from"react";import{createExpoClient as St,SnapbackProvider as kt}from"snapback2/expo";import{Text as It}from"react-native";var At=process.env.EXPO_PUBLIC_SNAPBACK_URL??"http://127.0.0.1:3210",Ct=process.env.EXPO_PUBLIC_SNAPBACK_WITNESS,Pn=Ct?ht(()=>Promise.resolve().then(()=>(Ce(),Ae))):void 0;function Tt(){let[t,e]=Te(),[n,r]=Te();return vt(()=>{let o=St({url:At,as:"alice",offline:V});return e(o),o.ready.catch(i=>r(String(i))),()=>{o.close()}},[]),!t||n?ee.createElement(It,{accessibilityLiveRegion:"polite"},n??"Connecting\u2026"):ee.createElement(kt,{client:t},ee.createElement(_,null))}export{W as MediaView,Tt as NormalApp,O as configuration,S as persist};
+//# sourceMappingURL=witness-test.mjs.map