@aigne/afs-did-space 1.12.0-beta.5

package/dist/sync-engine.d.mts

@@ -0,0 +1,473 @@
+import { ChangelogEntry } from "./tree-index.mjs";
+import { LocalChangelog } from "./local-changelog.mjs";
+import { CommitUploadEntryInput, DownloadGrant, PrepareDownloadEntryInput, PrepareDownloadResult, PrepareUploadEntryInput, PrepareUploadResult, RpcBatchResult, UploadGrant } from "./remote-afs.mjs";
+import { SyncStateStore } from "./sync-state.mjs";
+import { AFSBatchDeleteEntry, AFSBatchWriteEntry, AFSDeleteOptions, AFSDeleteResult, AFSListOptions, AFSListResult, AFSReadOptions, AFSReadResult, AFSWriteEntryPayload, AFSWriteOptions, AFSWriteResult } from "@aigne/afs";
+
+//#region src/sync-engine.d.ts
+/**
+ * Narrow AFS surface consumed by SyncEngine. Production wires this to a
+ * full `AFS` instance (which structurally satisfies the four methods);
+ * tests wire it to {@link InMemoryCloudProvider} so the engine never
+ * speaks to a real HTTP transport.
+ *
+ * Restricting the type to four methods keeps the test surface tractable
+ * (the AFS root has ~20 methods, most irrelevant to sync) and keeps the
+ * "this is the only I/O surface SyncEngine touches" contract visible
+ * at the type level.
+ */
+interface SyncCloudAFS {
+  list(path: string, options?: AFSListOptions): Promise<AFSListResult>;
+  read(path: string, options?: AFSReadOptions): Promise<AFSReadResult>;
+  write(path: string, payload: AFSWriteEntryPayload, options?: AFSWriteOptions): Promise<AFSWriteResult>;
+  delete(path: string, options?: AFSDeleteOptions): Promise<AFSDeleteResult>;
+  batchWrite?(entries: AFSBatchWriteEntry[]): Promise<RpcBatchResult>;
+  batchDelete?(entries: AFSBatchDeleteEntry[]): Promise<RpcBatchResult>;
+  batchRead?(entries: Array<{
+    path: string;
+    optional?: boolean;
+  }>): Promise<RpcBatchResult>;
+  uploadGrantCapability?(): Promise<boolean>;
+  prepareUpload?(entries: PrepareUploadEntryInput[]): Promise<PrepareUploadResult>;
+  commitUpload?(sessionId: string, entries: CommitUploadEntryInput[]): Promise<RpcBatchResult>;
+  /** Out-of-band PUT of object bytes via a grant; returns the HTTP status. */
+  uploadObject?(grant: UploadGrant, bytes: Uint8Array): Promise<number>;
+  downloadGrantCapability?(): Promise<boolean>;
+  prepareDownload?(entries: PrepareDownloadEntryInput[]): Promise<PrepareDownloadResult>;
+  /** Out-of-band GET of object bytes via a grant; returns the raw bytes. */
+  downloadObject?(grant: DownloadGrant): Promise<Uint8Array>;
+}
+/**
+ * Push batch size. Each round, push() fetches up to this many unpushed
+ * changelog rows in a single SQLite query and uploads them one by one.
+ * Lower than PULL_BATCH_LIMIT because each row is a separate PUT/DELETE
+ * round-trip (vs. PULL which fetches many change rows in a single call).
+ */
+declare const PUSH_BATCH_LIMIT = 100;
+/**
+ * Flush local_seq to SQLite every N successful pushes. Trade-off: lower
+ * = less progress lost on crash, higher = fewer DB writes. 10 is the
+ * round-trip frequency Task 3.6 spec mandates.
+ */
+declare const PUSH_PROGRESS_FLUSH_INTERVAL = 10;
+/**
+ * Pull batch size. Each `.changelog` cursor list call fetches up to this
+ * many rows. Matches the server's MAX_LIMIT hard cap
+ * (`services/arc-computer/src/handlers/space-api.ts` — .changelog list
+ * branch inside `_createSpaceHandler`).
+ */
+declare const PULL_BATCH_LIMIT = 1000;
+/**
+ * Concurrency cap for `.objects/{cid}` reads inside pull(). Higher = faster
+ * under large pulls, but risks server-side rate limits and memory
+ * pressure on the client. 4 is the spec default.
+ */
+declare const PULL_FETCH_CONCURRENCY = 4;
+/**
+ * Wall-clock budget for a single sync() call. Protects against runaway
+ * pulls on wildly out-of-date clients. pull() checks Date.now() against
+ * the deadline at the top of every batch loop iteration.
+ */
+declare const SYNC_WALL_CLOCK_BUDGET_MS = 25000;
+/**
+ * Narrow provider interface consumed by SyncEngine.
+ *
+ * The production mobile runtimes implement this directly on
+ * DIDSpaceProvider; tests use a mock. Only `internalWrite`,
+ * `internalDelete`, and `readBytes` are exercised — SyncEngine does
+ * NOT need list/stat/search.
+ *
+ * `readBytes` is the push-side counterpart: SyncEngine needs the raw
+ * bytes of a locally-stored cid so it can upload them via
+ * `cloudAfs.write`. Tests wire this to an in-memory map.
+ */
+interface SyncEngineProviderHandle {
+  internalWrite(path: string, opts: {
+    content: Uint8Array;
+    deviceId: string;
+    mtime?: number;
+    mimeType?: string;
+    /**
+     * Application metadata (e.g. `createdAt`) the SyncEngine derived from the
+     * bytes via `readApplicationMetadata` BEFORE calling internalWrite
+     * (feed-sort §5.1). The provider stamps the local-copy ctime from
+     * `metadata.createdAt` (Rule R1/R2) and persists it — it NEVER parses the
+     * bytes itself. Absent ⇒ ctime falls back to the write time.
+     */
+    metadata?: Record<string, unknown>;
+  }): Promise<void>;
+  internalDelete(path: string, opts: {
+    deviceId: string;
+    mtime?: number;
+  }): Promise<void>;
+  /**
+   * Fetch the raw bytes for a locally stored path. Used by push() to
+   * upload the file content referenced by a `put` changelog row.
+   *
+   * Returning `null` signals "the file is no longer on disk" (e.g. the
+   * user deleted it after the changelog row was written but before the
+   * sync picked it up). push() treats null as "skip this row,
+   * advance cursor" because the DELETE row that will follow is what
+   * the cloud needs to see.
+   */
+  readBytes(path: string): Promise<Uint8Array | null>;
+  /**
+   * List all currently-stored file paths for the scope. Only used by
+   * fullResync() to diff the cloud manifest against local state. Paths
+   * returned here are NOT slash-prefixed (they match the internal
+   * entries table shape); SyncEngine normalises before calling
+   * internalDelete.
+   */
+  listAllPaths(): Promise<string[]>;
+  /**
+   * Derive application metadata (e.g. Aside's `createdAt`) from a file's own
+   * bytes (did-space-metadata G3). The engine is format-agnostic, so the
+   * provider decides how to extract it (parse the record JSON). Attached to the
+   * push wire — top-level `meta` on the batchWrite leg (afs-rpc `wireMeta` lifts
+   * it onto `payload.meta`), `metadata` on the upload-plane commit leg.
+   *
+   * OPTIONAL: providers that expose no application metadata omit it, and the
+   * engine emits no metadata — preserving the pre-G3 wire contract byte-for-byte.
+   * Mirrors Swift's `readApplicationMetadata` + Kotlin's equivalent (P1 lockstep).
+   */
+  readApplicationMetadata?(path: string, bytes: Uint8Array): Promise<Record<string, unknown>>;
+}
+/** Outcome of a {@link SyncEngine.sync} call. */
+interface SyncResult {
+  /** Whether the sync completed all three legs (push, pull, gc) normally. */
+  ok: boolean;
+  /** Whether abortSignal fired before the engine reached its happy path. */
+  aborted: boolean;
+  /** Number of rows successfully pushed in the push leg. */
+  pushed: number;
+  /** Number of rows successfully applied in the pull leg. */
+  pulled: number;
+  /** Number of changelog rows GC'd at the end of the run. */
+  gcDeleted: number;
+  /** True when fullResync was taken (first-sync or 409 Compacted). */
+  fullResynced: boolean;
+  /** When the run ended, Date.now() in millis. */
+  endedAt: number;
+}
+/**
+ * Thrown by {@link SyncEngine.resolveConflict} when the server's 409
+ * conflict response is missing required fields (notably `currentMtime`).
+ * The LWW decision needs both timestamps, so a malformed response is
+ * treated as fatal to the in-flight push leg.
+ *
+ * Phase 5 Task 5.1 (G11): replaced the Task 3.6 `ConflictTODOError`
+ * stub with the real LWW resolver. The resolver handles every well-formed
+ * conflict shape inline; this error class only fires on protocol breakage.
+ */
+declare class ConflictResolutionError extends Error {
+  readonly change: ChangelogEntry;
+  readonly reason: string;
+  constructor(change: ChangelogEntry, reason: string);
+}
+/** Where a current-cid 404 surfaced. */
+type CurrentObjectSource = "manifest" | "latest-put" | "conflict";
+/**
+ * Thrown when an object read returns 404 for a cid that is the **current**
+ * state of a path — design §4.7.2, the GC-go-live safety contract. Enabling
+ * object GC makes a current-cid 404 possible (a GC bug or the residual
+ * re-reference race); it MUST be a loud, hard error — NEVER silently treated as
+ * convergence. The cursor must stay pinned (do not advance past the failing
+ * change) so the next sync revisits it once the object is restored/re-pushed.
+ *
+ * Distinct from a **superseded**-cid 404 (an old changelog row a later same-path
+ * row supersedes), which is benign — skip + advance (the Path-Y offline
+ * tradeoff, §0.2). Classification: see {@link classifyMissingObject}.
+ */
+declare class CurrentObjectMissingError extends Error {
+  readonly path: string;
+  readonly cid: string;
+  readonly source: CurrentObjectSource;
+  constructor(path: string, cid: string, source: CurrentObjectSource);
+}
+/**
+ * Classify an object-read 404 during incremental apply (design §4.7.2).
+ *
+ * `lastCidForPath` maps each path in the batch to the cid of its LAST row
+ * (max seq) — `null` if that last row is a delete. Fail-closed:
+ *   - cid === the path's last-row cid  ⇒ "current" (this cid is the path's
+ *     final state in the batch) ⇒ hard error.
+ *   - path absent from the map (unknown cid, not in this batch) ⇒ "current"
+ *     (fail closed — never benign-skip something we can't prove superseded).
+ *   - otherwise a later same-path row supersedes this cid ⇒ "superseded" ⇒ skip.
+ */
+declare function classifyMissingObject(path: string, cid: string, lastCidForPath: Map<string, string | null>): "current" | "superseded";
+/**
+ * Conflict response shape consumed by {@link SyncEngine.resolveConflict}.
+ * Mirrors the 409 body returned by Task 3.3's PUT/DELETE handlers.
+ *
+ * `currentCid === null` AND `currentMtime !== null` means "the cloud has
+ * deleted this path at currentMtime"; both null means the server returned
+ * a malformed response and the resolver throws ConflictResolutionError.
+ */
+interface ConflictResponse {
+  /** Server's current CID for the path (null if cloud has deleted it). */
+  currentCid: string | null;
+  /** Server's current mtime for the path (required for LWW comparison). */
+  currentMtime: number | null;
+  /** Origin device id for the cloud entry. Used for echo-loop Layer II. */
+  currentDeviceId: string | null;
+}
+interface SyncEngineOptions {
+  localChangelog: LocalChangelog;
+  syncStateStore: SyncStateStore;
+  cloudAfs: SyncCloudAFS;
+  provider: SyncEngineProviderHandle;
+  /** Self deviceId: written into changelog rows (options.meta.deviceId) and used
+  /// as the self filter. */
+  deviceId: string;
+  /**
+   * Override wall-clock budget in tests. Falls back to the module-level
+   * constant when not provided.
+   */
+  wallClockBudgetMs?: number;
+}
+/**
+ * Local push + pull + GC orchestrator. One instance per DIDSpaceProvider /
+ * per userDid. Instances are NOT thread-safe at the data level — the
+ * internal mutex only serialises `sync()` calls; callers that mutate
+ * local state while a sync is in flight are expected to do so via
+ * `provider.internalWrite/Delete` so the changelog row is visible to the
+ * next push batch.
+ */
+declare class SyncEngine {
+  private readonly localChangelog;
+  private readonly syncStateStore;
+  private readonly cloudAfs;
+  private readonly provider;
+  private readonly selfDeviceId;
+  private readonly wallClockBudgetMs;
+  private readonly mutex;
+  /**
+   * Per-INSTANCE capability-fallback memory (design §7.1): set the first
+   * time the server answers a batch envelope with the exact
+   * "Unsupported op 'batch…'" 400. Never set by any other 400 (e.g.
+   * BATCH_OVER_BUDGET halves and retries instead).
+   */
+  private batchFallback;
+  /**
+   * Per-INSTANCE upload-plane capability memory (design §7.1, mirrors
+   * batchFallback). null = not yet probed; set on the first `push()` that
+   * reaches the threshold. `false` (Node / old server / signer-less) keeps the
+   * engine on batchWrite forever for this instance.
+   */
+  private uploadPlaneCapable;
+  /** Set per-push() when this push routes large put-chunks through the upload plane. */
+  private uploadPlaneActive;
+  /**
+   * Per-INSTANCE download-plane capability memory (design §7.3, mirrors
+   * uploadPlaneCapable). null = not yet probed. `false` (Node / old server /
+   * signer-less) keeps the engine on batchRead forever for this instance — it is
+   * NOT reset per session (unlike {@link downloadFallback}): a server that never
+   * advertised the capability won't start mid-process, so re-probing every sync
+   * would just waste a `/.actions` list. A server UPGRADE needs a client restart.
+   */
+  private downloadPlaneCapable;
+  /**
+   * Runtime fallback-on-403 latch (design §7.3): set when a presigned GET is
+   * rejected 401/403 (token lacks GetObject / bad signature). Once set, the whole
+   * sync SESSION reverts to batchRead and never re-tries the plane — so a misconfig
+   * costs at most ONE 403 per object before the first hit flips it, then nothing.
+   * Reset at the start of each sync() so a fixed token recovers without restart.
+   */
+  private downloadFallback;
+  /** Resolved once per instance — the out-of-band GET fan-out (env-overridable). */
+  private readonly downloadGetConcurrency;
+  constructor(opts: SyncEngineOptions);
+  /**
+   * Run a single sync round — push → pull → gc. Concurrent sync() calls
+   * on the same instance are serialised by the internal mutex. Always
+   * returns a {@link SyncResult}; throws only on unhandled errors from
+   * the underlying store/network layers.
+   */
+  sync(opts?: {
+    signal?: AbortSignal;
+  }): Promise<SyncResult>;
+  /**
+   * Upload unpushed local changes to the cloud, advancing local_seq in
+   * SQLite every `PUSH_PROGRESS_FLUSH_INTERVAL` rows. On any error
+   * mid-batch, flush the already-advanced cursor before re-throwing so
+   * the next sync() resumes where this one left off.
+   *
+   * Per-row semantics:
+   *   - `put` row → `cloudAfs.write(path, content, {...})`
+   *   - `delete` row → `cloudAfs.delete(path, {...})`
+   *   - `put` row whose file has been deleted locally since the row was
+   *     written → skip (cursor advances; the following delete row will
+   *     tell the cloud what happened).
+   *   - 409 conflict → delegate to {@link SyncEngine.resolveConflict}
+   *     (LWW + tiebreak — see G11 in native-sync-design.md).
+   */
+  push(opts: {
+    signal?: AbortSignal;
+    deadline: number;
+  }): Promise<{
+    pushed: number;
+  }>;
+  /**
+   * Batch push leg (P4, design §7.2): split the changelog window into
+   * MAXIMAL same-op runs in seq order (op type never mixes inside a run —
+   * put(a)→delete(a) is two runs, so same-path cross-op order rides the
+   * sequential awaits); pack each run by maxEntries + Σ-decoded-bytes +
+   * UNIQUE-path-per-chunk (a duplicate path cuts the chunk so the server's
+   * one-shot preread stays serial-equivalent — and the SECOND chunk's
+   * ifMatch sees the first chunk's result); consume results strictly in
+   * order. Returns the advanced cursor; `stop` = abort/deadline/tail-skip.
+   */
+  private pushBatchLeg;
+  /**
+   * Send one packed chunk, halving on envelope over-budget (down to 1 entry
+   * = pushOne, the literal old behavior — bounded recursion by construction:
+   * each level halves a strictly smaller chunk).
+   */
+  private sendPushChunk;
+  /**
+   * Decide whether THIS push routes large put-chunks through the upload plane
+   * (design §6.1 / decision 4). True only when (a) the adapter has the
+   * prepare/commit/uploadObject surface, (b) the server advertises grant
+   * capability (memoized per instance — Node/old-server/signer-less → false →
+   * never), and (c) the put backlog meets the conservative threshold
+   * (≥ MIN_ENTRIES puts, or ≥ MIN_BYTES) via a cheap bounded peek.
+   */
+  private shouldUseUploadPlane;
+  /**
+   * Upload-plane transport for one put chunk (design §6.1 / §8). Mirrors a
+   * `batchWrite` call but moves content OUT of the worker:
+   *   1. prepare-upload (reuses each row's local `cid` — never re-hashed);
+   *   2. out-of-band PUT each grant (bounded concurrency);
+   *   3. commit-upload ONLY the entries whose PUT returned 200 (commit-after-
+   *      200, decision 2 — the sole dangling defense). PUT-failed entries get a
+   *      per-entry failure so the cursor pins there for retry next round.
+   * Returns the SAME `RpcBatchResult` shape `sendPushChunk` consumes. If a grant
+   * is unexpectedly absent (capability was advertised but a row got none), bail
+   * via `BatchUnsupportedError` → the engine reverts to the legacy path.
+   */
+  /**
+   * Application metadata for a push entry, derived from its own bytes via the
+   * optional provider hook (did-space-metadata G3). Returns undefined when the
+   * provider exposes none — so the engine emits no metadata and the wire stays
+   * pre-G3 byte-identical.
+   */
+  private readAppMeta;
+  private uploadPlaneWriteChunk;
+  /** Run `fn(0..n-1)` with at most `limit` in flight (push-side PUT fan-out). */
+  private boundedAll;
+  /**
+   * Upload a single change row. Split from push() so both the normal
+   * loop and future retry paths can call it.
+   *
+   * On 409 conflict, delegates to {@link resolveConflict}, which decides
+   * by LWW + tiebreak whether to force-overwrite the cloud or adopt the
+   * cloud's version locally. Either way, after resolveConflict returns,
+   * the row is considered "handled" and the push cursor advances past it.
+   */
+  private pushOne;
+  /**
+   * Resolve a push-side 409 conflict via Last-Write-Wins (LWW).
+   *
+   * Decision matrix (see `native-sync-design.md` G11 for the full 7-row
+   * matrix and rationale):
+   *
+   *   1. `localMtime > cloudMtime` → **local wins**: force-overwrite the
+   *      cloud (resend without `If-Match`). The server still validates
+   *      `X-Content-CID`, so a corrupted upload still fails.
+   *
+   *   2. `localMtime < cloudMtime` → **cloud wins**: adopt the cloud's
+   *      version locally via `provider.internalWrite/Delete` with the
+   *      ORIGIN deviceId from the conflict response. Echo-loop Layer II.
+   *
+   *   3. `localMtime === cloudMtime` → **tiebreak by CID lexicographic
+   *      order** (round 7 decision). The larger cid wins. delete ops
+   *      treat their cid as the empty string, so a `put` with non-empty
+   *      cid always beats a `delete` at the same mtime.
+   *
+   * Special cases handled here:
+   *   - delete vs delete (both null cid) → idempotent no-op (defensive;
+   *     in practice the server's delete handler turns DELETE 404 into
+   *     success and the conflict never reaches here).
+   *   - same mtime + same cid → idempotent natural convergence (the
+   *     local-wins path is taken but the resend produces the same cid
+   *     the cloud already has).
+   *
+   * mtime skew defense: G5.c (Task 3.3) rejects writes with
+   * `mtime > serverNow + 5min` at the header layer, so a single device
+   * with a wildly bad clock cannot poison the LWW decision globally.
+   */
+  resolveConflict(change: ChangelogEntry, resp: ConflictResponse): Promise<void>;
+  /**
+   * Fetch and apply incoming changes from the cloud. Loops until either
+   * the server reports `hasMore === false`, the deadline passes, or the
+   * abort signal fires. On 409 Compacted, delegates to fullResync().
+   *
+   * Apply order: sequential in seq order within a batch (SQLite
+   * integrity + single origin-deviceId per row). Content fetching is
+   * parallel up to `PULL_FETCH_CONCURRENCY`.
+   */
+  pull(opts: {
+    signal?: AbortSignal;
+    deadline: number;
+  }): Promise<{
+    pulled: number;
+    fullResynced: boolean;
+  }>;
+  /**
+   * Fetch content bytes for a batch of `put` rows in parallel, bounded
+   * by {@link PULL_FETCH_CONCURRENCY}. Results land in `cidMap`;
+   * individual fetch failures (404, cid mismatch) are logged and the
+   * offending cid is omitted so the caller's serial apply pass can
+   * detect the gap and skip.
+   */
+  /**
+   * Content fetch dispatcher (P4): chunked `batchRead(optional:true)` when
+   * the adapter has it (≤20 cids and ≤2MB ESTIMATED bytes per chunk — size
+   * from the changelog rows), single concurrent reads otherwise. Tail-
+   * skipped cids are simply re-queued for the next chunk (they were never
+   * read); `missing:true` cids stay out of the map so the apply loop's
+   * §4.7.2 current/superseded classification is untouched.
+   */
+  private fetchContent;
+  /** Single `.objects/{cid}` read with the same soft-failure semantics. */
+  private fetchOneObject;
+  private fetchContentConcurrent;
+  /**
+   * Whether the download plane can be used RIGHT NOW: the adapter speaks the
+   * methods, the server advertised the INDEPENDENT capability (memoized per
+   * instance, §7.3), and this session hasn't latched a 401/403 fallback.
+   */
+  private downloadPlaneAvailable;
+  /**
+   * Fetch LARGE objects (size ≥ {@link DOWNLOAD_PLANE_MIN_BYTES}) via the
+   * download plane — prepare-download → bounded-concurrency direct R2 GET →
+   * computeCID → `bytesMap`. Bytes leave R2 directly (never through the worker /
+   * base64). Returns the SET of cids it satisfied; the caller routes the rest
+   * (small objects, Node `grant:null`, forbidden, 404, post-fallback) through
+   * batchRead — so a true miss still raises the existing fail-closed path.
+   *
+   * fail-closed: a byte string whose `computeCID` ≠ the requested cid (R2 served
+   * tampered/other bytes) is DROPPED, never written (§8.1). A 401/403 latches
+   * `downloadFallback` for the whole session — at most one wall-bang (§7.3).
+   */
+  private fillBytesViaDownloadPlane;
+  /**
+   * First-sync / post-compaction recovery path. Fetches the full manifest
+   * and reconciles the local store against it, skipping paths the local
+   * changelog still has unpushed changes for (invariant I1).
+   *
+   * ORDERING IS CRITICAL — `pendingPaths` MUST be collected BEFORE the
+   * manifest fetch so a delete written between pendingPaths collection
+   * and apply does not get reverted by the manifest restoration.
+   */
+  fullResync(opts: {
+    signal?: AbortSignal;
+    deadline: number;
+  }): Promise<{
+    pulled: number;
+  }>;
+}
+//#endregion
+export { ConflictResolutionError, ConflictResponse, CurrentObjectMissingError, CurrentObjectSource, PULL_BATCH_LIMIT, PULL_FETCH_CONCURRENCY, PUSH_BATCH_LIMIT, PUSH_PROGRESS_FLUSH_INTERVAL, SYNC_WALL_CLOCK_BUDGET_MS, SyncCloudAFS, SyncEngine, SyncEngineOptions, SyncEngineProviderHandle, SyncResult, classifyMissingObject };
+//# sourceMappingURL=sync-engine.d.mts.map

package/dist/sync-engine.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-engine.d.mts","names":[],"sources":["../src/sync-engine.ts"],"mappings":"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"}