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

package/dist/index.d.cts

@@ -0,0 +1,504 @@
+import { ObjectStore } from "./platform/r2/dist/types.cjs";
+import { GcQueue } from "./gc-queue.cjs";
+import { D1GCQueue } from "./d1-gc-queue.cjs";
+import { PRESIGN_MAX_EXPIRES_SEC, PresignGetInput, PresignPutInput, PresignSigner, PresignedGet, PresignedPut } from "./presign-signer.cjs";
+import { DIDSpaceResolver, DomainResolveEntry, ResolveEntry } from "./resolve.cjs";
+import { isShareDeclarationPath } from "./share-declaration.cjs";
+import { ShareEntry, ShareRow, ShareStore, rowToEntry } from "./share-store.cjs";
+import { DirtyPathFollowerSource, DirtyPathOp, DirtyPathQueue, DirtyPathRow, DirtyPathStoredRow, ListDirtyPathOptions, applyDirtyUpsert } from "./dirty-path-queue.cjs";
+import { ChangelogEntry, OrderedQueryParts, ParsedTreeCursor, PutOpts, TreeEntry, TreeIndex, TreeIndexListEntriesResult, TreeIndexListOptions, TreeIndexListResult, TreeKeysetCursor, buildKeysetCursor, buildOrderedQueryParts, compareTreeSortValues, keysetAfter, parseTreeCursor } from "./tree-index.cjs";
+import { ShareResolver } from "./share-resolve.cjs";
+import { normalizeId, validateId } from "./did-utils.cjs";
+import { DIDSpaceBlockletDataBackend, DIDSpaceBlockletDataBackendOptions } from "./data-backend.cjs";
+import { detectMimeType, isTextMime } from "./mime-utils.cjs";
+import { D1UploadSessionStore, NewUploadSession, SqliteUploadSessionStore, UPLOAD_SESSION_TTL_MS, UploadSession, UploadSessionEntry, UploadSessionEntryInput, UploadSessionEntryStatus, UploadSessionStatus, UploadSessionStore } from "./upload-session-store.cjs";
+import { AFSMetadataContext, attachMetadataContext, detachMetadataContext, getMetadataContext } from "./afs-metadata-context.cjs";
+import { BLOCKLET_PUBLISH_MARKER, BlockletPublishMarker } from "./blocklet-hook.cjs";
+import { CHANGELOG_DDL, CHANGELOG_INDEX_SQL, CHANGELOG_ROW_KIND, CHANGELOG_SCOPE_CID_MIGRATION_SQL, CHANGELOG_TABLE_SQL, CHANGELOG_WIRE_EXTRA_FIELDS, ChangelogRowInput, ChangelogWireExtra, DEVICE_SYNC_STATE_INDEX_SQL, DEVICE_SYNC_STATE_TABLE_SQL, MANIFEST_FILE_KIND, MANIFEST_WIRE_EXTRA_FIELDS, ManifestRowInput, ManifestWireMeta, PREFIX_WATERMARK_TABLE_SQL, SCOPE_META_FILE_COUNT_BACKFILL_SQL, SCOPE_META_FILE_COUNT_DELETE_ONE_SQL, SCOPE_META_FILE_COUNT_DELETE_RANGE_SQL, SCOPE_META_FILE_COUNT_TRIGGER_SQL, SCOPE_META_INDEX_SQL, SCOPE_META_TABLE_SQL, SCOPE_META_TOTAL_BYTES_BACKFILL_SQL, SCOPE_META_TOTAL_BYTES_COLUMN_SQL, SCOPE_META_TOTAL_BYTES_TRIGGER_SQL, SYNC_STATE_DDL, SYNC_STATE_INDEX_SQL, SYNC_STATE_TABLE_SQL, normalizeDdl, parseChangelogEntry, parseManifestEntry, serializeChangelogEntry, serializeManifestEntry } from "./changelog-schema.cjs";
+import { CHANGELOG_INSERT_SQL, MAX_DEVICE_ID_BYTES, buildChangelogBinds, validateDeviceId } from "./changelog-write.cjs";
+import { cidToChecksumSha256, computeCID } from "./cid.cjs";
+import { CachingObjectStore, CidByteCache, CidByteCacheOptions } from "./cid-byte-cache.cjs";
+import { HttpTransportConfig, StaticReadonlyTransportConfig, Transport, TransportConfig, TransportKind, Unsubscribe, WsTransportConfig } from "./transports/types.cjs";
+import { ConnectDIDSpaceOptions, DIDSpaceClient, DIDSpaceClientOptions, connectDIDSpace } from "./client.cjs";
+import { D1ResolveStore } from "./d1-resolve-store.cjs";
+import { D1_DID_SPACE_SCHEMA_SQL, ENTRIES_CONTENT_TYPE_COLUMN_SQL, ENTRIES_CONTENT_TYPE_INDEX_DROP_SQL, ENTRIES_CONTENT_TYPE_INDEX_SQL, ENTRIES_DEDUP_INDEX_SQL, ENTRIES_DEDUP_KEY_COLUMN_SQL, ENTRIES_DEDUP_SCOPE_COLUMN_SQL, ENTRIES_INDEX_SQL, ENTRIES_INLINE_CONTENT_COLUMN_SQL, ENTRIES_METADATA_COLUMN_SQL, ENTRIES_TABLE_SQL, GC_QUEUE_INDEX_SQL, GC_QUEUE_TABLE_SQL, RESOLVE_ENTRIES_INDEX_SQL, RESOLVE_ENTRIES_TABLE_SQL, SHARES_INDEX_SQL, SHARES_TABLE_SQL, UPLOAD_SESSIONS_INDEX_SQL, UPLOAD_SESSIONS_TABLE_SQL, UPLOAD_SESSION_ENTRIES_TABLE_SQL, VERSIONED_SCOPES_INDEX_SQL, VERSIONED_SCOPES_TABLE_SQL } from "./d1-schema.cjs";
+import { D1ShareReconciler, D1ShareStore, ReconcileReport } from "./d1-share-store.cjs";
+import { DEFAULT_INLINE_THRESHOLD, INGEST_DEVICE_ID, INLINE_CONTENT_HARD_CAP, InlineCacheMode, InlineContentOptions, assertInlineThreshold, decodeInlineText } from "./inline-content.cjs";
+import { prefixRange } from "./prefix-range.cjs";
+import { D1TreeIndex, MAX_ENTRIES_PER_SCOPE, ancestorDirs, nameOf, parentOf } from "./d1-tree-index.cjs";
+import { DIRTY_PATH_DDL, DIRTY_PATH_INDEX_SQL, DIRTY_PATH_TABLE_SQL, DIRTY_PATH_TRIGGER_SQL } from "./dirty-path-schema.cjs";
+import { LOCAL_CHANGELOG_DEFAULT_LIMIT, LOCAL_CHANGELOG_MAX_LIMIT, LocalChangelog, LocalChangelogOptions } from "./local-changelog.cjs";
+import { MemoryGcQueue } from "./memory-gc-queue.cjs";
+import { MemoryTreeIndex } from "./memory-tree-index.cjs";
+import { assertValidCid, objectKeyForCid } from "./object-key.cjs";
+import { PrefixedTreeIndex } from "./prefixed-tree-index.cjs";
+import { referencedAnywhereD1, referencedAnywhereLibsql } from "./reference-check.cjs";
+import { BatchOverBudgetError, BatchUnsupportedError, RpcBatchEntryResult, RpcBatchResult, RpcUserSpaceAFS, RpcUserSpaceAFSOptions } from "./remote-afs.cjs";
+import { BuildManifestOptions, FileFingerprint, SyncDiff, SyncDiffEntry, SyncManifest, SyncOptions, SyncProgress, SyncResult as SyncResult$1, buildManifest, computeDiff, fetchRemoteManifest, runWithConcurrency, syncDIDSpace } from "./rsync.cjs";
+import { DEFAULT_GC_GRACE_MS, GcStats, RunGcOptions, runGc } from "./run-gc.cjs";
+import { decodeScopeHmacSecret, deriveScope, isPlainDidScope } from "./scope-id.cjs";
+import { BuildD1MigrationSqlOptions, D1MigrationSql, ScopeMigrationOptions, ScopeMigrationReport, buildD1MigrationSql, classifyScopes, migrateD1Scopes } from "./scope-migration.cjs";
+import { BuildScopedAFS, ServeShareOptions, ShareLookup, serveShare } from "./share-serve.cjs";
+import { SqliteGcQueue } from "./sqlite-gc-queue.cjs";
+import { SqliteResolveStore } from "./sqlite-resolve-store.cjs";
+import { SqliteShareStore, openDaemonShareStore } from "./sqlite-share-store.cjs";
+import { AppState, DEVICE_ID_FORMAT_RE, SYNC_STATE_KEYS, SyncStateStore, SyncStateStoreOptions, SyncStatus, defaultAppState, generateDesktopDeviceId, isValidDeviceId, parseSyncStatus, serializeSyncStatus } from "./sync-state.cjs";
+import { 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 } from "./sync-engine.cjs";
+import { HttpTransport, HttpTransportOptions } from "./transports/http.cjs";
+import { StaticReadonlyTransport, StaticReadonlyTransportOptions } from "./transports/static.cjs";
+import { WsTransport, WsTransportOptions, createWsTransport } from "./transports/ws.cjs";
+import { AFS_IFMATCH_ABSENT } from "./upload-actions.cjs";
+import { normalizeItemUrl } from "./url-normalize.cjs";
+import { VersionedContentFile, VersionedContentIndex, VersionedContentIndexOptions } from "./versioned-content-index.cjs";
+import { EnsureScopeOptions, EnsureScopeResult, LoadedScopeContent, VersionedContentStore, VersionedContentStoreOptions, VersionedScopeBackend, VersionedScopeMeta } from "./versioned-content-store.cjs";
+import { D1VersionedScopeBackend, LibsqlVersionedScopeBackend, MemoryVersionedScopeBackend } from "./versioned-content-backends.cjs";
+import { VersionedPackageIdentity, resolveVersionToken, versionedScope, versionedScopeGroup } from "./versioned-scope.cjs";
+import { AFSAccessMode, AFSBatchDeleteEntry, AFSBatchDeleteResult, AFSBatchReadEntry, AFSBatchReadResult, AFSBatchWriteEntry, AFSBatchWriteResult, AFSCollectionQueryResult, AFSCollectionQuerySpec, AFSEntry, AFSExecResult, AFSExplainResult, AFSListOptions, AFSListResult, AFSOperationOptions, AFSQueryOptions, AFSSearchOptions, AFSStatResult, AFSWriteEntryPayload, AFSWriteOptions, AFSWriteResult, CapabilitiesManifest, OperationsDeclaration, ProviderManifest, ProviderTreeSchema } from "@aigne/afs";
+import { AFSBaseProvider, RouteContext } from "@aigne/afs/provider";
+
+//#region src/index.d.ts
+interface DIDSpaceProviderOptions {
+  did: string;
+  objectStore: ObjectStore;
+  treeIndex: TreeIndex;
+  name?: string;
+  description?: string;
+  accessMode?: AFSAccessMode;
+  /** Optional: gc queue for deferred R2 object cleanup (any `GcQueue` impl —
+   * `D1GCQueue` on CF, `SqliteGcQueue` on Node, `MemoryGcQueue` in tests). */
+  gcQueue?: GcQueue;
+  /**
+   * Task 2.4a: deviceId written into every `changelog` row for mutations
+   * routed through the generic AFS write/delete handler. Production Worker
+   * paths bypass this provider via `CloudflareDIDSpace.internalWrite` (Task
+   * 2.4b) with a per-request deviceId from the `X-Device-Id` header; this
+   * constructor default (`"server:default"`) is used only for tests,
+   * conformance fixtures, and CLI flows that mount DIDSpaceProvider directly.
+   */
+  deviceId?: string;
+  /** Optional: ShareResolver for .share reconcile hook (Phase 0.4) */
+  shareResolver?: ShareResolver;
+  /**
+   * Owner DID recorded by the .share reconcile hook. Defaults to `did`. An
+   * instance fragment provider (treeIndex prefixed to `blocklets/<i>/user/`)
+   * has `did = instanceId`, but a share's owner is the WHOLE-SPACE user — pass
+   * the user's DID here so reconcile keys `owner_did` to the space (matching
+   * the serving scope), not the blocklet instance.
+   */
+  shareOwnerDid?: string;
+  /**
+   * Tree prefix prepended to the hook's `treePath` so the reconciled
+   * `decl_path`/`source_path` are WHOLE-TREE paths (`blocklets/<i>/user/...`),
+   * matching `shareResolver`'s whole-tree index and the serving scope. Set ONLY
+   * on prefixed instance-fragment providers; whole-space providers leave it
+   * unset (treePath is already whole-tree). Its presence also marks a provider
+   * as an instance fragment, which suppresses the `.shares/` virtual read view.
+   */
+  shareTreePrefix?: string;
+  /**
+   * Optional: global resolve table for the blocklet publish/resolve hook
+   * (#674). Writing a `blocklet.yaml` registers `resolve/blocklet/<id>` →
+   * {owner, path} so the CF serve path can read the published files back.
+   * Backed by the SAME D1 (CF) / in-memory (Node) store as the share/domain
+   * resolve entries — see blocklet-hook.ts. Absent → blocklet registration off.
+   */
+  blockletResolver?: DIDSpaceResolver;
+  /**
+   * PLAINTEXT space-owner DID recorded by the blocklet hook as the resolve
+   * entry's `owner` (so the serve path can reconstruct the space via
+   * `getUserSpace(owner)`). Unlike `shareOwnerDid` (the de-id storage scope),
+   * this MUST be the plaintext DID — the serve path re-derives the scope from
+   * it. Defaults to `did`, which is correct for whole-space providers; instance
+   * fragments (`did = instanceId`) MUST pass the user's plaintext DID here.
+   */
+  blockletOwnerDid?: string;
+  /**
+   * Upload plane (design §7 / §15). Injected by the runtime on the user-facing
+   * space so the `prepare/commit/abort-upload` actions can mint grants + persist
+   * sessions. All optional: when `sessionStore` is absent the actions report
+   * unavailable; when `signer` is absent (Node, fallback-only) prepare returns
+   * `grant: null` and the client falls back to batchWrite.
+   */
+  signer?: PresignSigner;
+  uploadSessionStore?: UploadSessionStore;
+  /**
+   * The de-identified storage scope (= the owning DIDSpace's `this._scope`)
+   * written into `upload_sessions.scope` and re-checked on commit for session
+   * ownership isolation (§9 / §10). NEVER a plaintext user DID.
+   */
+  uploadScope?: string;
+}
+declare class DIDSpaceProvider extends AFSBaseProvider {
+  static manifest(): ProviderManifest;
+  static treeSchema(): ProviderTreeSchema;
+  readonly name: string;
+  readonly description?: string;
+  readonly accessMode: AFSAccessMode;
+  readonly did: string;
+  private objectStore;
+  private treeIndex;
+  readonly gcQueue?: GcQueue;
+  /** See `DIDSpaceProviderOptions.deviceId`. Read by writeHandler/deleteHandler. */
+  readonly deviceId: string;
+  /** Optional ShareResolver for .share reconcile hook (Phase 0.4) */
+  private readonly shareResolver?;
+  /** See `DIDSpaceProviderOptions.shareOwnerDid` / `shareTreePrefix`. */
+  private readonly shareOwnerDid?;
+  private readonly shareTreePrefix?;
+  /** See `DIDSpaceProviderOptions.blockletResolver` / `blockletOwnerDid` (#674). */
+  private readonly blockletResolver?;
+  private readonly blockletOwnerDid?;
+  /** Upload plane deps (design §7). See `DIDSpaceProviderOptions`. */
+  private readonly signer?;
+  private readonly uploadSessionStore?;
+  private readonly uploadScope?;
+  constructor(options: DIDSpaceProviderOptions);
+  /** Convert AFS path to tree-index path (strip leading /) */
+  private treePath;
+  /** Convert AFS path to tree-index prefix for directory listing */
+  private treeListPrefix;
+  /**
+   * Remap a write/delete into the arguments the .share reconcile hook expects.
+   * On a whole-space provider this is identity. On a prefixed instance-fragment
+   * provider (`shareTreePrefix` set) it restores the WHOLE-TREE decl path and
+   * keys the share to the space owner (`shareOwnerDid`), so reconcile stores the
+   * same `owner_did` + full `decl_path` the public serving path resolves by.
+   */
+  private shareHookArgs;
+  /**
+   * Remap a write/delete into the arguments the blocklet hook expects. Same
+   * whole-tree path restoration as {@link shareHookArgs}, but the recorded
+   * `ownerDid` is the PLAINTEXT space owner (`blockletOwnerDid`), not the de-id
+   * scope — the serve path re-derives the storage scope from the plaintext DID.
+   */
+  private blockletHookArgs;
+  private objectKey;
+  private isDirectory;
+  /** Collect all CIDs under a prefix for GC queuing before bulk delete. */
+  private collectCIDsByPrefix;
+  readMeta(ctx: RouteContext<{
+    path?: string;
+  }>): Promise<AFSEntry | undefined>;
+  /**
+   * Override to implement the `maxDepth: -1` snapshot contract.
+   *
+   * When called with `maxDepth: -1`, collects ALL file entries under `path`
+   * using cursor-based pagination through the treeIndex and returns them in
+   * a single `AFSListResult` with `meta.cursor = String(manifestSeq)` so
+   * `SyncEngine.fullResync()` can advance `cloudSeq` correctly.
+   *
+   * > 10_000 entries → sets `meta.truncated: true` (HTTP 200, SyncEngine
+   * throws `ManifestTooLargeError`).
+   *
+   * All other options fall through to `super.list()` → `listHandler`.
+   */
+  list(path: string, options?: AFSListOptions): Promise<AFSListResult>;
+  listHandler(ctx: RouteContext<{
+    path?: string;
+  }>): Promise<AFSListResult>;
+  /**
+   * True direct-children total for a shallow listing.
+   *
+   * AFSListResult contract (`packages/core/src/type.ts`): absent `total`
+   * means "data IS the complete result" — so a handler that truncates its
+   * collection MUST report `total`, or every consumer downstream (base.ts
+   * pagination, afs-list pager) mistakes the page for the whole set.
+   *
+   * Cost model (D1: per-query round-trips dominate): `listShallow` scans
+   * the index in LIST_MAX_LIMIT batches and keeps counting rows past the
+   * build cap, so when the cursor drained (directories ≤ LIST_MAX_LIMIT
+   * children — the common case) the scan itself yields the exact total:
+   * ZERO extra queries. Only a directory truncated mid-cursor (> 1000
+   * children) pays ONE COUNT round-trip (same `countChildren(prefix)`
+   * call and parent-key format `readMeta` already relies on).
+   */
+  private shallowTotal;
+  /**
+   * Attach the per-prefix watermark `version` as the result's top-level
+   * `liveSeq` (Live Update Resilience §4 / 0a'). Read ONE row via the
+   * TreeIndex — O(1), independent of changelog history/global write volume.
+   *
+   * - Skipped for `.changelog` listings (sync-internal, no live-update scope).
+   * - Skipped when the index has no `getPrefixWatermark` (rollout) or reports
+   *   no watermark key for the path (`null` — no collection root): the
+   *   consumer then falls back to full re-list on the next edge/poll, still
+   *   correct.
+   * - A valid-but-never-written collection root reports `"0"` so consumers
+   *   baseline at 0 instead of conservatively refetching every poll tick on a
+   *   read-only collection (the first write bumps to 1 > 0 and is detected).
+   * - The value is prefix-LOCAL (only this collection root's write count), so
+   *   it never leaks another blocklet's timing (invariant I3).
+   */
+  private withLiveSeq;
+  /**
+   * Shallow listing with a VALID orderBy (did-space-sorting Phase 3).
+   *
+   * - Single tuple → forwarded to the TreeIndex (`listChildren` orders
+   *   natively over the (scope,parent,col,name) indexes; keyset cursor
+   *   pages stay globally ordered, so collecting offset+limit entries is
+   *   the correct order-before-pagination slice).
+   * - 2-3 tuples → the index can order by one column only, so collect the
+   *   FULL child set and apply the canonical core sort before truncation
+   *   (order → offset → limit still holds).
+   */
+  private listShallowOrdered;
+  private listShallow;
+  /**
+   * Patch EXACT `meta.childrenCount` onto the directory entries of a
+   * collected shallow page — the opt-in half of the two-tier childrenCount
+   * contract (`AFSListOptions.includeChildrenCounts`; default tier is the
+   * `-1` sentinel stamped by listShallow). Page-bounded by construction:
+   * only the dirs actually collected are counted, ONE `countChildrenMany`
+   * round-trip (per-dir `countChildren` fallback for indexes without it),
+   * so the cost is Σ direct children of the page's dirs — never the
+   * whole-subtree scan the retired `countChildrenGrouped` performed.
+   */
+  private fillChildrenCounts;
+  private listDeep;
+  /**
+   * Task 1.9: list changelog rows starting after `cursor` (seq number).
+   * Returns rows as AFSEntry objects + meta.cursor pointing to the last row's seq.
+   */
+  private listChangelog;
+  /**
+   * Promote write + delete to the object form so callers can discover the
+   * `ifMatch` sub-capability (CLAUDE.md "Sub-capability schema"). The base impl
+   * (base.ts) returns plain booleans; without this override the if-match
+   * conformance suite's `getCapabilityFeature("write","ifMatch")` reads nothing
+   * and the suite skips. Mirrors AFSFS's override (fs/src/index.ts).
+   */
+  protected getOperationsDeclaration(): OperationsDeclaration;
+  readCapabilities(_ctx: RouteContext): Promise<AFSEntry | undefined>;
+  /**
+   * Typed collection query over a directory of records (design §3.5).
+   *
+   * - dir-per-record (`spec.doc`): direct child dirs joined with their
+   *   `<dir>/<doc>` document; file-per-record (no doc): direct child files'
+   *   inline content is the record.
+   * - where/orderBy/pagination/total/groupBy execute inside the TreeIndex
+   *   engine (SQL or in-memory — lockstep-tested). select + annotate.memberOf
+   *   are page-level post-processing here, identical across backends.
+   * - Strict contract: spec arrives core-validated; provider constraints
+   *   (single orderBy key, no text) throw AFSValidationError. An index
+   *   without the engine (e.g. not-yet-migrated backends) throws
+   *   AFSUnsupportedError — and is never declared in capabilities.
+   */
+  query(path: string, spec: AFSCollectionQuerySpec, _options?: AFSQueryOptions): Promise<AFSCollectionQueryResult>;
+  /** Map an engine row to an AFSEntry (mirrors the list handlers' shapes). */
+  private queryRowToEntry;
+  readHandler(ctx: RouteContext<{
+    path?: string;
+  }>): Promise<AFSEntry>;
+  /**
+   * presignRead — path-keyed read-grant capability (preview-r2-direct §3).
+   *
+   * Resolves `path` in THIS provider's (prefix-isolated) view exactly like
+   * `read`/`stat` (`treeIndex.get(treePath(path))`, incl. the same null-byte /
+   * `..`-segment guards). iff the resolved entry has a cid AND a signer with
+   * `presignGet` is present → mint a short-TTL presigned GET with the
+   * Content-Type baked in, and return `{ url, expiresAt }`.
+   *
+   * The path resolution IS the authorization: a caller can only presign what
+   * `read` would already return. Prefix isolation is inherited from the view's
+   * `PrefixedTreeIndex` — no separate object-level `isReferenced(cid)` is needed
+   * (that primitive is for the cid-keyed `.objects/{cid}` path, which has no
+   * tree path). NEVER throws to the caller: no signer (Node) / non-CAS / no cid /
+   * unresolved / any internal error → `null`, and the raw handler then falls back
+   * to the worker serve path. TTL = `DOWNLOAD_GRANT_TTL_SEC` (2h) — never the 7d
+   * signer cap (§8.3).
+   */
+  presignRead(path: string, opts?: {
+    responseContentType?: string;
+  }): Promise<{
+    url: string;
+    expiresAt: string;
+  } | null>;
+  /**
+   * Re-verify an entry's inline copy against its cid (§2.I list contract).
+   * Returns the content when verified, null otherwise (best-effort miss).
+   */
+  private verifiedInline;
+  /**
+   * Returns true if the given AFS path is a virtual D4-protected path
+   * (.objects/* or .changelog/*).
+   */
+  private isVirtualPath;
+  writeHandler(ctx: RouteContext<{
+    path?: string;
+  }>, payload: AFSWriteEntryPayload): Promise<{
+    data: AFSEntry;
+  }>;
+  deleteHandler(ctx: RouteContext<{
+    path?: string;
+  }>): Promise<{
+    path: string;
+    deleted: boolean;
+  }>;
+  /** Conflict failure shaped exactly like the single-op AFSConflictError surface. */
+  private batchConflictFailure;
+  /** ONE preflight read for a batch — getMany when the index has it, per-path get otherwise. */
+  private batchPreread;
+  /** Run `fn` over `items` with bounded concurrency (Workers cap: 6 sockets). */
+  private boundedAll;
+  /**
+   * Native batch read (issue #808 follow-up) — the render fast path. Resolves the
+   * whole path set with ONE `treeIndex.getMany` (chunked `IN(…)`, which carries
+   * inline content when the index has it), so small cid-verified inline files are
+   * served with ZERO R2 gets; only the (few, large) non-inline entries fall back
+   * to bounded-concurrent `objectStore.get`. Mirrors the single-read handler's
+   * inline-verify → objects cascade per entry. File-oriented: getMany matches
+   * `kind='file'`, so directory / absent paths come back AFS_NOT_FOUND (callers
+   * reading directories use `list`/`read`).
+   */
+  batchRead(entries: AFSBatchReadEntry[], _options?: AFSOperationOptions): Promise<AFSBatchReadResult>;
+  /**
+   * Native batch write — the CF-subrequest-budget merge (§4.3): eight-step
+   * order aligned point-for-point with the single write path (preread BEFORE
+   * share pre-io, so a stale ifMatch on a `.share` declaration yields 409,
+   * never a share error):
+   *   1 shape/decode/computeCID → 2 ONE preread (conflict/skip exit here —
+   *   no share hook, no R2 upload) → 3 share pre-io (survivors) → 4 in-batch
+   *   CID dedup → 5 unconditional R2 put (unique cids, bounded ≤6 —
+   *   P0-measured wall-time) → 6 treeIndex.batchPutEntries (single db.batch)
+   *   → 7 gcQueue removeMany/enqueue → 8 share post-io + per-entry results.
+   */
+  batchWrite(entries: AFSBatchWriteEntry[], _options?: AFSOperationOptions): Promise<AFSBatchWriteResult>;
+  /** Write-echo entry — field-for-field the single-op writeHandler result. */
+  private buildBatchWriteData;
+  /** Build a failed AFSExecResult (shared across the three action handlers). */
+  private uploadErr;
+  /**
+   * Session ownership isolation (§9 / §10): a session belongs to THIS view only
+   * when its scope equals this provider's storage scope. A different-scope (or
+   * unknown) session is treated as not-found — never confirm another user's
+   * session exists, and never let one view commit into another.
+   */
+  private ownsSession;
+  /**
+   * Validate an action-supplied `path`. Unlike `@Write` handlers, action args
+   * carry NO router-layer traversal protection — `args.entries[].path` is raw
+   * client input, so we MUST normalize + reject traversal / reserved virtual
+   * prefixes explicitly (design §10). Returns the tree path on success.
+   */
+  private validateActionPath;
+  /**
+   * Action catalogue — the upload-plane + download-plane actions, always listed
+   * (protocol parity, T2.5). Each plane advertises its OWN capability flag:
+   * `grantCapability` for prepare-upload, the INDEPENDENT `downloadGrantCapability`
+   * for prepare-download (design §7.3 / Finding 4 — never reuse the upload flag,
+   * so the two planes can be advertised separately).
+   */
+  listObjectPlaneActions(ctx: RouteContext): AFSListResult;
+  execPrepareUpload(_ctx: RouteContext, args: Record<string, unknown>): Promise<AFSExecResult>;
+  execPrepareDownload(_ctx: RouteContext, args: Record<string, unknown>): Promise<AFSExecResult>;
+  execCommitUpload(_ctx: RouteContext, args: Record<string, unknown>): Promise<AFSExecResult>;
+  execAbortUpload(_ctx: RouteContext, args: Record<string, unknown>): Promise<AFSExecResult>;
+  /**
+   * Resolve the immutable-merge-key set: `createdAt` is always preserved, plus
+   * any caller-supplied lifecycle fields (e.g. `status`).
+   */
+  private resolveImmutableMergeKeys;
+  /** Extract the JSON record object from a write payload's `content`. */
+  private parseRecordBody;
+  /**
+   * Stamp the dedup identity into a write's meta so the writeHandler can project
+   * it onto the entry's `dedup_scope` / `dedup_key` columns (#1159). `dedupKey`
+   * stays in the metadata blob (observability / collection-query); on a merge
+   * we drop `createdAt` so the index keeps the original file ctime (R1,
+   * feed-sort §5.1).
+   */
+  private stampDedupMeta;
+  /**
+   * Dedup-on-write core (#492 / #1159) — the `options.dedupBy` upsert behind the
+   * standard `write` / `batchWrite`. The record's `dedupBy` field (URL-valued)
+   * is normalized into a `dedupKey`; the record lands at a STABLE readable path
+   * (`{collection}/{uuid}.json`) and dedup resolves through the tree-index's
+   * `(scope, dedup_scope, dedup_key)` secondary UNIQUE index — NOT a
+   * cid-in-path filename (which silently orphaned records written under any
+   * other layout, #1159). On a hit the incoming record is MERGED
+   * (non-degrading) into the existing entry AT ITS REAL PATH. Concurrency-safe:
+   * a racing create collides on the UNIQUE index, and the loser re-queries the
+   * index and merges (bounded retry). Records missing the field are written
+   * normally under the collection (no dedup).
+   */
+  private upsertByDedupKey;
+  /**
+   * One-time reindex/backfill seam (#1159 — run from a deferred one-shot
+   * script, NOT on the write hot path). Populates the dedup columns for
+   * EXISTING records under `collection` so pre-feature entries (old
+   * `{slug}.json` / `{uuid}/item.json` / `{cid}.json` layouts) become
+   * dedup-able — fixing the "an already-saved URL's first re-save duplicates"
+   * bug. Reads each record, extracts + normalizes `record[dedupBy]`, and writes
+   * the dedup columns INDEX-ONLY (no changelog / no cid change) via
+   * `TreeIndex.setDedupKey`. Records missing the field, and genuine
+   * pre-existing duplicates (which would violate the UNIQUE index), are
+   * skipped. Idempotent.
+   */
+  reindexDedupKeys(collection: string, dedupBy: string): Promise<{
+    scanned: number;
+    indexed: number;
+    skipped: number;
+  }>;
+  /**
+   * Standard write, extended with the dedup-on-write upsert policy (#492 /
+   * #1159). When `options.dedupBy` (canonical) or the deprecated `dedupKey`
+   * alias is set the write becomes a secondary-index upsert (see
+   * {@link upsertByDedupKey}); otherwise it is the base provider's write.
+   */
+  write(path: string, content: AFSWriteEntryPayload, options?: AFSWriteOptions): Promise<AFSWriteResult>;
+  /**
+   * The commit write — mirrors `batchWrite` steps 2/6/7/8 WITHOUT the R2 byte
+   * leg (existence is trusted, §8): preread → ifMatch/skip → batchPutEntries →
+   * GC bookkeeping → share hooks → per-entry results. `cid`/`size`/`mimeType`
+   * come from the SESSION record (the prepared contract, re-validated against
+   * the client's entries); `deviceId`/`mtime` are client provenance threaded to
+   * the changelog (echo防回环, §6.1).
+   */
+  private commitSessionEntries;
+  /**
+   * Native batch delete — same merge without the R2 leg: ONE preread → GC
+   * enqueue (before delete, single-op ordering) → ONE atomic index batch →
+   * share delete hooks. FILE entries only (no directory fallback — sync
+   * never dir-deletes; a dir path fails per entry with 404).
+   */
+  batchDelete(entries: AFSBatchDeleteEntry[], _options?: AFSOperationOptions): Promise<AFSBatchDeleteResult>;
+  statHandler(ctx: RouteContext<{
+    path?: string;
+  }>): Promise<AFSStatResult>;
+  searchHandler(ctx: RouteContext<{
+    path?: string;
+  }>, query: string, options?: AFSSearchOptions): Promise<{
+    data: AFSEntry[];
+    total: number;
+  }>;
+  explainHandler(ctx: RouteContext<{
+    path?: string;
+  }>): Promise<AFSExplainResult>;
+  /**
+   * Write content to the provider, bypassing D4 virtual path protection.
+   * Stores content to objectStore and treeIndex with the given deviceId.
+   */
+  internalWrite(afsPath: string, opts: {
+    content: Uint8Array;
+    deviceId: string;
+    mtime?: number;
+    mimeType?: string;
+    metadata?: Record<string, unknown>;
+  }): Promise<{
+    cid: string;
+    oldCid?: string;
+  }>;
+  /**
+   * Delete a file from the provider, bypassing D4 virtual path protection.
+   */
+  internalDelete(afsPath: string, opts: {
+    deviceId: string;
+    mtime?: number;
+  }): Promise<{
+    deleted: boolean;
+  }>;
+  capabilities(): CapabilitiesManifest;
+}
+//#endregion
+export { type AFSMetadataContext, AFS_IFMATCH_ABSENT, type AppState, BLOCKLET_PUBLISH_MARKER, BatchOverBudgetError, BatchUnsupportedError, type BlockletPublishMarker, type BuildD1MigrationSqlOptions, type BuildManifestOptions, type BuildScopedAFS, CHANGELOG_DDL, CHANGELOG_INDEX_SQL, CHANGELOG_INSERT_SQL, CHANGELOG_ROW_KIND, CHANGELOG_SCOPE_CID_MIGRATION_SQL, CHANGELOG_TABLE_SQL, CHANGELOG_WIRE_EXTRA_FIELDS, CachingObjectStore, type ChangelogEntry, type ChangelogRowInput, type ChangelogWireExtra, CidByteCache, type CidByteCacheOptions, ConflictResolutionError, type ConflictResponse, type ConnectDIDSpaceOptions, CurrentObjectMissingError, type CurrentObjectSource, D1GCQueue, type D1MigrationSql, D1ResolveStore, D1ShareReconciler, D1ShareStore, D1TreeIndex, D1UploadSessionStore, D1VersionedScopeBackend, D1_DID_SPACE_SCHEMA_SQL, DEFAULT_GC_GRACE_MS, DEFAULT_INLINE_THRESHOLD, DEVICE_ID_FORMAT_RE, DEVICE_SYNC_STATE_INDEX_SQL, DEVICE_SYNC_STATE_TABLE_SQL, DIDSpaceBlockletDataBackend, type DIDSpaceBlockletDataBackendOptions, DIDSpaceClient, type DIDSpaceClientOptions, DIDSpaceProvider, DIDSpaceProviderOptions, DIDSpaceResolver, DIRTY_PATH_DDL, DIRTY_PATH_INDEX_SQL, DIRTY_PATH_TABLE_SQL, DIRTY_PATH_TRIGGER_SQL, type DirtyPathFollowerSource, type DirtyPathOp, type DirtyPathQueue, type DirtyPathRow, type DirtyPathStoredRow, type DomainResolveEntry, ENTRIES_CONTENT_TYPE_COLUMN_SQL, ENTRIES_CONTENT_TYPE_INDEX_DROP_SQL, ENTRIES_CONTENT_TYPE_INDEX_SQL, ENTRIES_DEDUP_INDEX_SQL, ENTRIES_DEDUP_KEY_COLUMN_SQL, ENTRIES_DEDUP_SCOPE_COLUMN_SQL, ENTRIES_INDEX_SQL, ENTRIES_INLINE_CONTENT_COLUMN_SQL, ENTRIES_METADATA_COLUMN_SQL, ENTRIES_TABLE_SQL, type EnsureScopeOptions, type EnsureScopeResult, type FileFingerprint, GC_QUEUE_INDEX_SQL, GC_QUEUE_TABLE_SQL, type GcQueue, type GcStats, HttpTransport, type HttpTransportConfig, type HttpTransportOptions, INGEST_DEVICE_ID, INLINE_CONTENT_HARD_CAP, type InlineCacheMode, type InlineContentOptions, LOCAL_CHANGELOG_DEFAULT_LIMIT, LOCAL_CHANGELOG_MAX_LIMIT, LibsqlVersionedScopeBackend, type ListDirtyPathOptions, type LoadedScopeContent, LocalChangelog, type LocalChangelogOptions, MANIFEST_FILE_KIND, MANIFEST_WIRE_EXTRA_FIELDS, MAX_DEVICE_ID_BYTES, MAX_ENTRIES_PER_SCOPE, type ManifestRowInput, type ManifestWireMeta, MemoryGcQueue, MemoryTreeIndex, MemoryVersionedScopeBackend, type NewUploadSession, type OrderedQueryParts, PREFIX_WATERMARK_TABLE_SQL, PRESIGN_MAX_EXPIRES_SEC, PULL_BATCH_LIMIT, PULL_FETCH_CONCURRENCY, PUSH_BATCH_LIMIT, PUSH_PROGRESS_FLUSH_INTERVAL, type ParsedTreeCursor, PrefixedTreeIndex, type PresignGetInput, type PresignPutInput, type PresignSigner, type PresignedGet, type PresignedPut, type PutOpts, RESOLVE_ENTRIES_INDEX_SQL, RESOLVE_ENTRIES_TABLE_SQL, type ReconcileReport, type ResolveEntry, type RpcBatchEntryResult, type RpcBatchResult, RpcUserSpaceAFS, type RpcUserSpaceAFSOptions, type RunGcOptions, SCOPE_META_FILE_COUNT_BACKFILL_SQL, SCOPE_META_FILE_COUNT_DELETE_ONE_SQL, SCOPE_META_FILE_COUNT_DELETE_RANGE_SQL, SCOPE_META_FILE_COUNT_TRIGGER_SQL, SCOPE_META_INDEX_SQL, SCOPE_META_TABLE_SQL, SCOPE_META_TOTAL_BYTES_BACKFILL_SQL, SCOPE_META_TOTAL_BYTES_COLUMN_SQL, SCOPE_META_TOTAL_BYTES_TRIGGER_SQL, SHARES_INDEX_SQL, SHARES_TABLE_SQL, SYNC_STATE_DDL, SYNC_STATE_INDEX_SQL, SYNC_STATE_KEYS, SYNC_STATE_TABLE_SQL, SYNC_WALL_CLOCK_BUDGET_MS, type ScopeMigrationOptions, type ScopeMigrationReport, type ServeShareOptions, type ShareEntry, type ShareLookup, ShareResolver, type ShareRow, type ShareStore, SqliteGcQueue, SqliteResolveStore, SqliteShareStore, SqliteUploadSessionStore, StaticReadonlyTransport, type StaticReadonlyTransportConfig, type StaticReadonlyTransportOptions, type SyncCloudAFS, type SyncDiff, type SyncDiffEntry, SyncEngine, type SyncEngineOptions, type SyncEngineProviderHandle, type SyncResult as SyncEngineResult, type SyncManifest, type SyncOptions, type SyncProgress, type SyncResult$1 as SyncResult, SyncStateStore, type SyncStateStoreOptions, type SyncStatus, type Transport, type TransportConfig, type TransportKind, type TreeEntry, type TreeIndex, type TreeIndexListEntriesResult, type TreeIndexListOptions, type TreeIndexListResult, type TreeKeysetCursor, UPLOAD_SESSIONS_INDEX_SQL, UPLOAD_SESSIONS_TABLE_SQL, UPLOAD_SESSION_ENTRIES_TABLE_SQL, UPLOAD_SESSION_TTL_MS, type Unsubscribe, type UploadSession, type UploadSessionEntry, type UploadSessionEntryInput, type UploadSessionEntryStatus, type UploadSessionStatus, type UploadSessionStore, VERSIONED_SCOPES_INDEX_SQL, VERSIONED_SCOPES_TABLE_SQL, type VersionedContentFile, VersionedContentIndex, type VersionedContentIndexOptions, VersionedContentStore, type VersionedContentStoreOptions, type VersionedPackageIdentity, type VersionedScopeBackend, type VersionedScopeMeta, WsTransport, type WsTransportConfig, type WsTransportOptions, ancestorDirs, applyDirtyUpsert, assertInlineThreshold, assertValidCid, attachMetadataContext, buildChangelogBinds, buildD1MigrationSql, buildKeysetCursor, buildManifest, buildOrderedQueryParts, cidToChecksumSha256, classifyMissingObject, classifyScopes, compareTreeSortValues, computeCID, computeDiff, connectDIDSpace, createWsTransport, decodeInlineText, decodeScopeHmacSecret, defaultAppState, deriveScope, detachMetadataContext, detectMimeType, fetchRemoteManifest, generateDesktopDeviceId, getMetadataContext, isPlainDidScope, isShareDeclarationPath, isTextMime, isValidDeviceId, keysetAfter, migrateD1Scopes, nameOf, normalizeDdl, normalizeId, normalizeItemUrl, objectKeyForCid, openDaemonShareStore, parentOf, parseChangelogEntry, parseManifestEntry, parseSyncStatus, parseTreeCursor, prefixRange, referencedAnywhereD1, referencedAnywhereLibsql, resolveVersionToken, rowToEntry, runGc, runWithConcurrency, serializeChangelogEntry, serializeManifestEntry, serializeSyncStatus, serveShare, syncDIDSpace, validateDeviceId, validateId, versionedScope, versionedScopeGroup };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

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