@tearleads/client-sdk 0.1.62 → 0.1.64

package/stores/documents/documentStore.js

@@ -1,215 +0,0 @@
-import { DEFAULT_DOCUMENT_KIND } from "../../data/documents/documentConstants.js";
-import { createDocumentProjectionUserKeyResolver, defaultDocumentsPersistence, didDocumentProjectionKeyRuntimeChange, didRegainSyncPrerequisites, requestDocumentSyncLaneAndWait, } from "../../workflows/documents/index.js";
-import { removeAttachmentFromDocumentStore } from "./documentStore/attachmentRemoval.js";
-import { attachFilesToDocumentStore, replaceAttachmentInDocumentStore, } from "./documentStore/attachments.js";
-import { discardDocumentStoreLocalState } from "./documentStore/discard.js";
-import { ensureDocumentStoreInitialized, ensureDocumentStoreReady, relinkDocumentStore, } from "./documentStore/initialization.js";
-import { registerInternalDocumentRelink } from "./documentStore/internalRelink.js";
-import { setDocumentStructuredFields, setDocumentText, } from "./documentStore/mutations.js";
-import { logRevalidationScheduled } from "./documentStore/remoteRevalidationTelemetry.js";
-import { assertDocumentStoreCanRotateContentKey } from "./documentStore/rotation.js";
-import { addRowToDocumentStore, removeRowFromDocumentStore, updateRowInDocumentStore, } from "./documentStore/rows.js";
-import { createDocumentStoreState, refreshAttachabilitySnapshot, resetDocumentStore, subscribeToDocumentStore, } from "./documentStore/state.js";
-import { registerDocumentStoreSyncLane } from "./documentStore/sync.js";
-import { allowDocumentStoreRemoteSync, captureDocumentStoreRemoteSyncRequestGeneration, captureDocumentStoreSyncLaneGeneration, didDocumentStoreRemoteSyncRequestComplete, hasPendingIndependentDocumentStoreRemoteSync, invalidateDocumentStoreRemoteSync, invalidateDocumentStoreSyncLane, isDocumentStoreRemoteSyncBlocked, isDocumentStoreRemoteSyncRequestGenerationCurrent, markDocumentStoreRemoteSyncPending, registerDocumentStoreRemoteSyncWaiter, } from "./documentStore/syncGeneration.js";
-import { handleDocumentRemoteEvents } from "./documentStore/syncRemoteSignals.js";
-import { createDocumentStoreFacade, emitPersistedDocument, getOrCreateDocumentStoreRegistry, registerDocumentStore, registerDocumentStoreIdentity, requestDocumentStoreSync, resolveDocumentStoreKey, } from "./registry.js";
-export { discardRegisteredDocumentLocalState, requestDomainDocumentSync, subscribeToPersistedDocuments, } from "./registry.js";
-function refreshDocumentStoreSyncLane(state, force = false) {
-    if (!force && state.syncLane && !state.syncLane.isDisposed?.()) {
-        return;
-    }
-    if (state.syncLane) {
-        invalidateDocumentStoreSyncLane(state);
-    }
-    let syncLaneGeneration = null;
-    state.syncLane = registerDocumentStoreSyncLane(state, () => syncLaneGeneration);
-    syncLaneGeneration = captureDocumentStoreSyncLaneGeneration(state);
-}
-function updateDocumentStoreRuntime(state, nextRuntime, scheduleSync) {
-    const previousRuntime = state.runtime;
-    const serverEventsReconnected = (nextRuntime.state.serverEventsConnectionGeneration ?? 0) >
-        (previousRuntime.state.serverEventsConnectionGeneration ?? 0);
-    const domainScopeChanged = previousRuntime.state.domainScope !== nextRuntime.state.domainScope;
-    const projectionKeyRuntimeChanged = didDocumentProjectionKeyRuntimeChange(previousRuntime, nextRuntime);
-    if (projectionKeyRuntimeChanged) {
-        state.resolveProjectionUserKey =
-            createDocumentProjectionUserKeyResolver(nextRuntime);
-        state.writerProjection = null;
-    }
-    state.runtime = nextRuntime;
-    refreshDocumentStoreSyncLane(state, domainScopeChanged);
-    if (domainScopeChanged) {
-        state.locallyAcceptedUpdateIds = new Set();
-        state.remoteUpdatePending = false;
-        state.writerProjection = null;
-    }
-    if (nextRuntime.infra.dbStatus !== "ready") {
-        if (state.snapshot.ready || state.initialized || state.initializePromise) {
-            resetDocumentStore(state);
-        }
-        state.lastEventCount = nextRuntime.state.events.length;
-        return;
-    }
-    refreshAttachabilitySnapshot(state);
-    ensureDocumentStoreInitialized(state, scheduleSync);
-    handleDocumentRemoteEvents(state, scheduleSync);
-    if (state.snapshot.ready) {
-        if (serverEventsReconnected) {
-            // The invalidation stream is lossy while disconnected. Once the server
-            // has acknowledged this socket's authoritative interest declaration,
-            // every already-open remote document needs one HTTP probe to cover peer
-            // writes made during the gap. This also closes iOS background/resume reconnects where the
-            // native network source remained online throughout.
-            requestRemoteDocumentStoreSync(state, scheduleSync);
-            logRevalidationScheduled(state.runtime, "reconnect");
-        }
-        else if (didRegainSyncPrerequisites(previousRuntime, state.runtime)) {
-            scheduleSync();
-        }
-    }
-}
-function requestRemoteDocumentStoreSync(state, scheduleSync, owner = "independent") {
-    allowDocumentStoreRemoteSync(state);
-    const signalSequence = markDocumentStoreRemoteSyncPending(state, owner);
-    scheduleSync();
-    return signalSequence;
-}
-function requestOrdinaryDocumentStoreSync(state, scheduleSync) {
-    // A normal UI reopen is a fresh owner for remote-only work. It may recover
-    // a probe that an earlier, now-unmounted owner aborted.
-    if (isDocumentStoreRemoteSyncBlocked(state)) {
-        requestRemoteDocumentStoreSync(state, scheduleSync);
-        return;
-    }
-    scheduleSync();
-}
-function requestRemoteDocumentStoreSyncAndWait(state, scheduleSync, signal) {
-    let requestGeneration = null;
-    let requestedSignalSequence = 0;
-    let releaseWaiter = null;
-    const releaseRemoteSyncWaiter = (invalidate) => {
-        const releasedLastWaiter = releaseWaiter?.() ?? false;
-        if (invalidate &&
-            releasedLastWaiter &&
-            requestGeneration !== null &&
-            isDocumentStoreRemoteSyncRequestGenerationCurrent(state, requestGeneration) &&
-            !hasPendingIndependentDocumentStoreRemoteSync(state)) {
-            invalidateDocumentStoreRemoteSync(state);
-        }
-    };
-    // A coordinator can be disposed and recreated while this same-scope store
-    // remains registered. Refresh its handle before requesting work.
-    refreshDocumentStoreSyncLane(state);
-    return requestDocumentSyncLaneAndWait({
-        didCompleteRequest: () => requestGeneration !== null &&
-            didDocumentStoreRemoteSyncRequestComplete(state, requestGeneration, requestedSignalSequence),
-        domainScope: state.runtime.state.domainScope,
-        localId: state.localId,
-        request: () => {
-            requestGeneration =
-                captureDocumentStoreRemoteSyncRequestGeneration(state);
-            releaseWaiter = registerDocumentStoreRemoteSyncWaiter(state, requestGeneration);
-            requestedSignalSequence = requestRemoteDocumentStoreSync(state, scheduleSync, "waiter");
-        },
-        onInvalidated: () => releaseRemoteSyncWaiter(true),
-        signal,
-    }).then((completed) => {
-        releaseRemoteSyncWaiter(!completed);
-        return completed;
-    }, (error) => {
-        releaseRemoteSyncWaiter(true);
-        throw error;
-    });
-}
-async function assertBackingDocumentStoreCanRotate(state, scheduleSync) {
-    if (!(await ensureDocumentStoreReady(state, scheduleSync)) || !state.doc) {
-        throw new Error("Document must finish loading before its content key can rotate");
-    }
-    return assertDocumentStoreCanRotateContentKey(state);
-}
-async function discardBackingDocumentStoreLocalState(state, scheduleSync, expectedDocumentId) {
-    try {
-        return await discardDocumentStoreLocalState(state, expectedDocumentId);
-    }
-    finally {
-        // Restart hydration whenever the attempt reset the store. This runs outside
-        // its identity-chained task because initialization also chains writes.
-        ensureDocumentStoreInitialized(state, scheduleSync);
-        scheduleSync();
-    }
-}
-function createLiveSyncLaneRequest(state) {
-    return (request) => {
-        refreshDocumentStoreSyncLane(state);
-        return request();
-    };
-}
-function registerBackingStoreInternalRelink(input) {
-    registerInternalDocumentRelink(input.store, (relinkInput, commitSideEffect) => input.withLiveSyncLane(() => relinkDocumentStore(input.state, relinkInput, input.scheduleSync, commitSideEffect)));
-    return input.store;
-}
-function createBackingStoreContext(localId, runtime, persistence, documentId, text, documentKind, options) {
-    const state = createDocumentStoreState(localId, runtime, persistence, {
-        emitPersistedDocument,
-        registerDocumentIdentity: registerDocumentStoreIdentity,
-    }, documentId, text, documentKind, (options.remoteSyncMode ?? "startup") === "startup");
-    if (options.deferInitialUpdate)
-        state.deferInitialUpdate = true;
-    refreshDocumentStoreSyncLane(state);
-    const scheduleSync = () => requestDocumentStoreSync(state);
-    return {
-        scheduleSync,
-        state,
-        withLiveSyncLane: createLiveSyncLaneRequest(state),
-    };
-}
-function createBackingDocumentStore(localId, initialRuntime, persistence = defaultDocumentsPersistence, initialDocumentId = null, initialText = "", initialDocumentKind = DEFAULT_DOCUMENT_KIND, openOptions = {}) {
-    const { scheduleSync, state, withLiveSyncLane } = createBackingStoreContext(localId, initialRuntime, persistence, initialDocumentId, initialText, initialDocumentKind, openOptions);
-    const store = {
-        addRow: (fields) => withLiveSyncLane(() => addRowToDocumentStore(state, scheduleSync, fields)),
-        assertCanRotateContentKey: () => withLiveSyncLane(() => assertBackingDocumentStoreCanRotate(state, scheduleSync)),
-        attachFiles: (files) => withLiveSyncLane(() => attachFilesToDocumentStore(state, scheduleSync, files)),
-        discardLocalState: (expectedDocumentId) => withLiveSyncLane(() => discardBackingDocumentStoreLocalState(state, scheduleSync, expectedDocumentId)),
-        ensureInitialized: () => withLiveSyncLane(() => ensureDocumentStoreReady(state, scheduleSync)),
-        getSnapshot: () => state.snapshot,
-        removeAttachment: (slotId) => withLiveSyncLane(() => removeAttachmentFromDocumentStore(state, scheduleSync, slotId)),
-        removeRow: (id) => withLiveSyncLane(() => removeRowFromDocumentStore(state, scheduleSync, id)),
-        replaceAttachment: (slotId, file) => withLiveSyncLane(() => replaceAttachmentInDocumentStore(state, scheduleSync, slotId, file)),
-        requestRemoteSync: () => withLiveSyncLane(() => requestRemoteDocumentStoreSync(state, scheduleSync)),
-        requestRemoteSyncAndWait: (signal) => requestRemoteDocumentStoreSyncAndWait(state, scheduleSync, signal),
-        requestSync: () => withLiveSyncLane(() => requestOrdinaryDocumentStoreSync(state, scheduleSync)),
-        relink: (input) => withLiveSyncLane(() => relinkDocumentStore(state, input, scheduleSync)),
-        setStructuredFields: (kind, patch, options) => withLiveSyncLane(() => setDocumentStructuredFields(state, scheduleSync, kind, patch, options)),
-        setText: (value) => withLiveSyncLane(() => setDocumentText(state, scheduleSync, value)),
-        subscribe: (listener) => subscribeToDocumentStore(state, listener),
-        updateRowFields: (id, patch) => withLiveSyncLane(() => updateRowInDocumentStore(state, scheduleSync, id, patch)),
-        updateRuntime: (runtime) => updateDocumentStoreRuntime(state, runtime, scheduleSync),
-    };
-    return registerBackingStoreInternalRelink({
-        scheduleSync,
-        state,
-        store,
-        withLiveSyncLane,
-    });
-}
-export function createDocumentStore(localId, initialRuntime, persistence = defaultDocumentsPersistence, initialDocumentId = null, initialText = "", initialDocumentKind = DEFAULT_DOCUMENT_KIND, options = {}) {
-    return createDocumentStoreFacade(createBackingDocumentStore(localId, initialRuntime, persistence, initialDocumentId, initialText, initialDocumentKind, options));
-}
-export function getOrCreateDocumentStore(domainScope, localId, runtime, initialDocumentId = null, initialText = "", initialDocumentKind = DEFAULT_DOCUMENT_KIND, options = {}) {
-    const registry = getOrCreateDocumentStoreRegistry(domainScope);
-    const existingStore = registry.storesByKey.get(resolveDocumentStoreKey(registry, localId, initialDocumentId));
-    if (existingStore) {
-        registerDocumentStore(domainScope, localId, existingStore, initialDocumentId);
-        return existingStore;
-    }
-    const nextStore = createDocumentStore(localId, runtime, defaultDocumentsPersistence, initialDocumentId, initialText, initialDocumentKind, options);
-    registerDocumentStore(domainScope, localId, nextStore, initialDocumentId);
-    return nextStore;
-}
-export function openDocumentStore(domainScope, localId, runtime, initialDocumentId = null, initialText = "", initialDocumentKind = DEFAULT_DOCUMENT_KIND, options = {}) {
-    const store = getOrCreateDocumentStore(domainScope, localId, runtime, initialDocumentId, initialText, initialDocumentKind, options);
-    store.updateRuntime(runtime);
-    return store;
-}
-//# sourceMappingURL=documentStore.js.map

package/stores/documents/documentStore.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"documentStore.js","sourceRoot":"","sources":["documentStore.ts"],"names":[],"mappings":"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","sourcesContent":["import { DEFAULT_DOCUMENT_KIND } from \"../../data/documents/documentConstants\";\nimport type { StoredDocumentKind } from \"../../data/documents/documentKinds\";\nimport type { DomainScope } from \"../../data/shared/domainScope\";\nimport {\n  createDocumentProjectionUserKeyResolver,\n  type DocumentsPersistence,\n  defaultDocumentsPersistence,\n  didDocumentProjectionKeyRuntimeChange,\n  didRegainSyncPrerequisites,\n  requestDocumentSyncLaneAndWait,\n} from \"../../workflows/documents\";\nimport { removeAttachmentFromDocumentStore } from \"./documentStore/attachmentRemoval\";\nimport {\n  attachFilesToDocumentStore,\n  replaceAttachmentInDocumentStore,\n} from \"./documentStore/attachments\";\nimport { discardDocumentStoreLocalState } from \"./documentStore/discard\";\nimport {\n  ensureDocumentStoreInitialized,\n  ensureDocumentStoreReady,\n  relinkDocumentStore,\n} from \"./documentStore/initialization\";\nimport { registerInternalDocumentRelink } from \"./documentStore/internalRelink\";\nimport {\n  setDocumentStructuredFields,\n  setDocumentText,\n} from \"./documentStore/mutations\";\nimport { logRevalidationScheduled } from \"./documentStore/remoteRevalidationTelemetry\";\nimport { assertDocumentStoreCanRotateContentKey } from \"./documentStore/rotation\";\nimport {\n  addRowToDocumentStore,\n  removeRowFromDocumentStore,\n  updateRowInDocumentStore,\n} from \"./documentStore/rows\";\nimport {\n  createDocumentStoreState,\n  type DocumentStoreState,\n  refreshAttachabilitySnapshot,\n  resetDocumentStore,\n  subscribeToDocumentStore,\n} from \"./documentStore/state\";\nimport { registerDocumentStoreSyncLane } from \"./documentStore/sync\";\nimport {\n  allowDocumentStoreRemoteSync,\n  captureDocumentStoreRemoteSyncRequestGeneration,\n  captureDocumentStoreSyncLaneGeneration,\n  type DocumentStoreRemoteSyncRequestGeneration,\n  type DocumentStoreSyncLaneGeneration,\n  didDocumentStoreRemoteSyncRequestComplete,\n  hasPendingIndependentDocumentStoreRemoteSync,\n  invalidateDocumentStoreRemoteSync,\n  invalidateDocumentStoreSyncLane,\n  isDocumentStoreRemoteSyncBlocked,\n  isDocumentStoreRemoteSyncRequestGenerationCurrent,\n  markDocumentStoreRemoteSyncPending,\n  registerDocumentStoreRemoteSyncWaiter,\n} from \"./documentStore/syncGeneration\";\nimport { handleDocumentRemoteEvents } from \"./documentStore/syncRemoteSignals\";\nimport {\n  createDocumentStoreFacade,\n  emitPersistedDocument,\n  getOrCreateDocumentStoreRegistry,\n  registerDocumentStore,\n  registerDocumentStoreIdentity,\n  requestDocumentStoreSync,\n  resolveDocumentStoreKey,\n} from \"./registry\";\nimport type {\n  DocumentAttachmentUpload,\n  DocumentStore,\n  DocumentStoreFacade,\n  DocumentStoreOpenOptions,\n  DocumentsRuntime,\n} from \"./types\";\n\nexport {\n  discardRegisteredDocumentLocalState,\n  requestDomainDocumentSync,\n  subscribeToPersistedDocuments,\n} from \"./registry\";\n\nfunction refreshDocumentStoreSyncLane(\n  state: DocumentStoreState,\n  force = false,\n): void {\n  if (!force && state.syncLane && !state.syncLane.isDisposed?.()) {\n    return;\n  }\n  if (state.syncLane) {\n    invalidateDocumentStoreSyncLane(state);\n  }\n  let syncLaneGeneration: DocumentStoreSyncLaneGeneration | null = null;\n  state.syncLane = registerDocumentStoreSyncLane(\n    state,\n    () => syncLaneGeneration,\n  );\n  syncLaneGeneration = captureDocumentStoreSyncLaneGeneration(state);\n}\n\nfunction updateDocumentStoreRuntime(\n  state: DocumentStoreState,\n  nextRuntime: DocumentsRuntime,\n  scheduleSync: () => void,\n) {\n  const previousRuntime = state.runtime;\n  const serverEventsReconnected =\n    (nextRuntime.state.serverEventsConnectionGeneration ?? 0) >\n    (previousRuntime.state.serverEventsConnectionGeneration ?? 0);\n  const domainScopeChanged =\n    previousRuntime.state.domainScope !== nextRuntime.state.domainScope;\n  const projectionKeyRuntimeChanged = didDocumentProjectionKeyRuntimeChange(\n    previousRuntime,\n    nextRuntime,\n  );\n  if (projectionKeyRuntimeChanged) {\n    state.resolveProjectionUserKey =\n      createDocumentProjectionUserKeyResolver(nextRuntime);\n    state.writerProjection = null;\n  }\n  state.runtime = nextRuntime;\n  refreshDocumentStoreSyncLane(state, domainScopeChanged);\n  if (domainScopeChanged) {\n    state.locallyAcceptedUpdateIds = new Set();\n    state.remoteUpdatePending = false;\n    state.writerProjection = null;\n  }\n\n  if (nextRuntime.infra.dbStatus !== \"ready\") {\n    if (state.snapshot.ready || state.initialized || state.initializePromise) {\n      resetDocumentStore(state);\n    }\n    state.lastEventCount = nextRuntime.state.events.length;\n    return;\n  }\n\n  refreshAttachabilitySnapshot(state);\n  ensureDocumentStoreInitialized(state, scheduleSync);\n  handleDocumentRemoteEvents(state, scheduleSync);\n\n  if (state.snapshot.ready) {\n    if (serverEventsReconnected) {\n      // The invalidation stream is lossy while disconnected. Once the server\n      // has acknowledged this socket's authoritative interest declaration,\n      // every already-open remote document needs one HTTP probe to cover peer\n      // writes made during the gap. This also closes iOS background/resume reconnects where the\n      // native network source remained online throughout.\n      requestRemoteDocumentStoreSync(state, scheduleSync);\n      logRevalidationScheduled(state.runtime, \"reconnect\");\n    } else if (didRegainSyncPrerequisites(previousRuntime, state.runtime)) {\n      scheduleSync();\n    }\n  }\n}\n\nfunction requestRemoteDocumentStoreSync(\n  state: DocumentStoreState,\n  scheduleSync: () => void,\n  owner: \"independent\" | \"waiter\" = \"independent\",\n): number {\n  allowDocumentStoreRemoteSync(state);\n  const signalSequence = markDocumentStoreRemoteSyncPending(state, owner);\n  scheduleSync();\n  return signalSequence;\n}\n\nfunction requestOrdinaryDocumentStoreSync(\n  state: DocumentStoreState,\n  scheduleSync: () => void,\n): void {\n  // A normal UI reopen is a fresh owner for remote-only work. It may recover\n  // a probe that an earlier, now-unmounted owner aborted.\n  if (isDocumentStoreRemoteSyncBlocked(state)) {\n    requestRemoteDocumentStoreSync(state, scheduleSync);\n    return;\n  }\n  scheduleSync();\n}\n\nfunction requestRemoteDocumentStoreSyncAndWait(\n  state: DocumentStoreState,\n  scheduleSync: () => void,\n  signal?: AbortSignal,\n): Promise<boolean> {\n  let requestGeneration: DocumentStoreRemoteSyncRequestGeneration | null = null;\n  let requestedSignalSequence = 0;\n  let releaseWaiter: (() => boolean) | null = null;\n  const releaseRemoteSyncWaiter = (invalidate: boolean) => {\n    const releasedLastWaiter = releaseWaiter?.() ?? false;\n    if (\n      invalidate &&\n      releasedLastWaiter &&\n      requestGeneration !== null &&\n      isDocumentStoreRemoteSyncRequestGenerationCurrent(\n        state,\n        requestGeneration,\n      ) &&\n      !hasPendingIndependentDocumentStoreRemoteSync(state)\n    ) {\n      invalidateDocumentStoreRemoteSync(state);\n    }\n  };\n  // A coordinator can be disposed and recreated while this same-scope store\n  // remains registered. Refresh its handle before requesting work.\n  refreshDocumentStoreSyncLane(state);\n  return requestDocumentSyncLaneAndWait({\n    didCompleteRequest: () =>\n      requestGeneration !== null &&\n      didDocumentStoreRemoteSyncRequestComplete(\n        state,\n        requestGeneration,\n        requestedSignalSequence,\n      ),\n    domainScope: state.runtime.state.domainScope,\n    localId: state.localId,\n    request: () => {\n      requestGeneration =\n        captureDocumentStoreRemoteSyncRequestGeneration(state);\n      releaseWaiter = registerDocumentStoreRemoteSyncWaiter(\n        state,\n        requestGeneration,\n      );\n      requestedSignalSequence = requestRemoteDocumentStoreSync(\n        state,\n        scheduleSync,\n        \"waiter\",\n      );\n    },\n    onInvalidated: () => releaseRemoteSyncWaiter(true),\n    signal,\n  }).then(\n    (completed) => {\n      releaseRemoteSyncWaiter(!completed);\n      return completed;\n    },\n    (error: unknown) => {\n      releaseRemoteSyncWaiter(true);\n      throw error;\n    },\n  );\n}\n\nasync function assertBackingDocumentStoreCanRotate(\n  state: DocumentStoreState,\n  scheduleSync: () => void,\n) {\n  if (!(await ensureDocumentStoreReady(state, scheduleSync)) || !state.doc) {\n    throw new Error(\n      \"Document must finish loading before its content key can rotate\",\n    );\n  }\n  return assertDocumentStoreCanRotateContentKey(state);\n}\n\nasync function discardBackingDocumentStoreLocalState(\n  state: DocumentStoreState,\n  scheduleSync: () => void,\n  expectedDocumentId: string,\n) {\n  try {\n    return await discardDocumentStoreLocalState(state, expectedDocumentId);\n  } finally {\n    // Restart hydration whenever the attempt reset the store. This runs outside\n    // its identity-chained task because initialization also chains writes.\n    ensureDocumentStoreInitialized(state, scheduleSync);\n    scheduleSync();\n  }\n}\n\nfunction createLiveSyncLaneRequest(state: DocumentStoreState) {\n  return <Result>(request: () => Result): Result => {\n    refreshDocumentStoreSyncLane(state);\n    return request();\n  };\n}\n\nfunction registerBackingStoreInternalRelink(input: {\n  scheduleSync: () => void;\n  state: DocumentStoreState;\n  store: DocumentStore;\n  withLiveSyncLane: ReturnType<typeof createLiveSyncLaneRequest>;\n}): DocumentStore {\n  registerInternalDocumentRelink(input.store, (relinkInput, commitSideEffect) =>\n    input.withLiveSyncLane(() =>\n      relinkDocumentStore(\n        input.state,\n        relinkInput,\n        input.scheduleSync,\n        commitSideEffect,\n      ),\n    ),\n  );\n  return input.store;\n}\n\nfunction createBackingStoreContext(\n  localId: string,\n  runtime: DocumentsRuntime,\n  persistence: DocumentsPersistence,\n  documentId: string | null,\n  text: string,\n  documentKind: StoredDocumentKind,\n  options: DocumentStoreOpenOptions,\n) {\n  const state = createDocumentStoreState(\n    localId,\n    runtime,\n    persistence,\n    {\n      emitPersistedDocument,\n      registerDocumentIdentity: registerDocumentStoreIdentity,\n    },\n    documentId,\n    text,\n    documentKind,\n    (options.remoteSyncMode ?? \"startup\") === \"startup\",\n  );\n  if (options.deferInitialUpdate) state.deferInitialUpdate = true;\n  refreshDocumentStoreSyncLane(state);\n  const scheduleSync = () => requestDocumentStoreSync(state);\n  return {\n    scheduleSync,\n    state,\n    withLiveSyncLane: createLiveSyncLaneRequest(state),\n  };\n}\n\nfunction createBackingDocumentStore(\n  localId: string,\n  initialRuntime: DocumentsRuntime,\n  persistence: DocumentsPersistence = defaultDocumentsPersistence,\n  initialDocumentId: string | null = null,\n  initialText = \"\",\n  initialDocumentKind: StoredDocumentKind = DEFAULT_DOCUMENT_KIND,\n  openOptions: DocumentStoreOpenOptions = {},\n): DocumentStore {\n  const { scheduleSync, state, withLiveSyncLane } = createBackingStoreContext(\n    localId,\n    initialRuntime,\n    persistence,\n    initialDocumentId,\n    initialText,\n    initialDocumentKind,\n    openOptions,\n  );\n\n  const store: DocumentStore = {\n    addRow: (fields) =>\n      withLiveSyncLane(() =>\n        addRowToDocumentStore(state, scheduleSync, fields),\n      ),\n    assertCanRotateContentKey: () =>\n      withLiveSyncLane(() =>\n        assertBackingDocumentStoreCanRotate(state, scheduleSync),\n      ),\n    attachFiles: (files: ReadonlyArray<DocumentAttachmentUpload>) =>\n      withLiveSyncLane(() =>\n        attachFilesToDocumentStore(state, scheduleSync, files),\n      ),\n    discardLocalState: (expectedDocumentId: string) =>\n      withLiveSyncLane(() =>\n        discardBackingDocumentStoreLocalState(\n          state,\n          scheduleSync,\n          expectedDocumentId,\n        ),\n      ),\n    ensureInitialized: () =>\n      withLiveSyncLane(() => ensureDocumentStoreReady(state, scheduleSync)),\n    getSnapshot: () => state.snapshot,\n    removeAttachment: (slotId: string) =>\n      withLiveSyncLane(() =>\n        removeAttachmentFromDocumentStore(state, scheduleSync, slotId),\n      ),\n    removeRow: (id) =>\n      withLiveSyncLane(() =>\n        removeRowFromDocumentStore(state, scheduleSync, id),\n      ),\n    replaceAttachment: (slotId: string, file: DocumentAttachmentUpload) =>\n      withLiveSyncLane(() =>\n        replaceAttachmentInDocumentStore(state, scheduleSync, slotId, file),\n      ),\n    requestRemoteSync: () =>\n      withLiveSyncLane(() =>\n        requestRemoteDocumentStoreSync(state, scheduleSync),\n      ),\n    requestRemoteSyncAndWait: (signal) =>\n      requestRemoteDocumentStoreSyncAndWait(state, scheduleSync, signal),\n    requestSync: () =>\n      withLiveSyncLane(() =>\n        requestOrdinaryDocumentStoreSync(state, scheduleSync),\n      ),\n    relink: (input) =>\n      withLiveSyncLane(() => relinkDocumentStore(state, input, scheduleSync)),\n    setStructuredFields: (kind, patch, options) =>\n      withLiveSyncLane(() =>\n        setDocumentStructuredFields(state, scheduleSync, kind, patch, options),\n      ),\n    setText: (value: string) =>\n      withLiveSyncLane(() => setDocumentText(state, scheduleSync, value)),\n    subscribe: (listener) => subscribeToDocumentStore(state, listener),\n    updateRowFields: (id, patch) =>\n      withLiveSyncLane(() =>\n        updateRowInDocumentStore(state, scheduleSync, id, patch),\n      ),\n    updateRuntime: (runtime: DocumentsRuntime) =>\n      updateDocumentStoreRuntime(state, runtime, scheduleSync),\n  };\n  return registerBackingStoreInternalRelink({\n    scheduleSync,\n    state,\n    store,\n    withLiveSyncLane,\n  });\n}\n\nexport function createDocumentStore(\n  localId: string,\n  initialRuntime: DocumentsRuntime,\n  persistence: DocumentsPersistence = defaultDocumentsPersistence,\n  initialDocumentId: string | null = null,\n  initialText = \"\",\n  initialDocumentKind: StoredDocumentKind = DEFAULT_DOCUMENT_KIND,\n  options: DocumentStoreOpenOptions = {},\n): DocumentStoreFacade {\n  return createDocumentStoreFacade(\n    createBackingDocumentStore(\n      localId,\n      initialRuntime,\n      persistence,\n      initialDocumentId,\n      initialText,\n      initialDocumentKind,\n      options,\n    ),\n  );\n}\n\nexport function getOrCreateDocumentStore(\n  domainScope: DomainScope,\n  localId: string,\n  runtime: DocumentsRuntime,\n  initialDocumentId: string | null = null,\n  initialText = \"\",\n  initialDocumentKind: StoredDocumentKind = DEFAULT_DOCUMENT_KIND,\n  options: DocumentStoreOpenOptions = {},\n): DocumentStore {\n  const registry = getOrCreateDocumentStoreRegistry(domainScope);\n  const existingStore = registry.storesByKey.get(\n    resolveDocumentStoreKey(registry, localId, initialDocumentId),\n  );\n  if (existingStore) {\n    registerDocumentStore(\n      domainScope,\n      localId,\n      existingStore,\n      initialDocumentId,\n    );\n    return existingStore;\n  }\n\n  const nextStore = createDocumentStore(\n    localId,\n    runtime,\n    defaultDocumentsPersistence,\n    initialDocumentId,\n    initialText,\n    initialDocumentKind,\n    options,\n  );\n  registerDocumentStore(domainScope, localId, nextStore, initialDocumentId);\n  return nextStore;\n}\n\nexport function openDocumentStore(\n  domainScope: DomainScope,\n  localId: string,\n  runtime: DocumentsRuntime,\n  initialDocumentId: string | null = null,\n  initialText = \"\",\n  initialDocumentKind: StoredDocumentKind = DEFAULT_DOCUMENT_KIND,\n  options: DocumentStoreOpenOptions = {},\n): DocumentStore {\n  const store = getOrCreateDocumentStore(\n    domainScope,\n    localId,\n    runtime,\n    initialDocumentId,\n    initialText,\n    initialDocumentKind,\n    options,\n  );\n  store.updateRuntime(runtime);\n  return store;\n}\n"]}

package/workflows/blobs/attachmentBindingVerification.js

@@ -1,49 +0,0 @@
-import { KeyingVerificationError, verifyAttachmentBindingEvent, } from "../../internal/crypto/index.js";
-import { readCanonicalJson, readCanonicalRecord, } from "../../data/keying/canonicalJson.js";
-import { readAccessEvent, readRecordString, readRequiredRecordValue, resolveEventContainerPaths, } from "../../data/keyingProjectionVerification/index.js";
-export async function assertAttachmentBindingVerified(input) {
-    if (!input.authorization) {
-        throw new Error("Attachment binding lacks verified document authority");
-    }
-    if (!input.binding.bindingEvent ||
-        !input.binding.documentManifestHash ||
-        input.binding.previousBindingId === undefined) {
-        throw new Error("Attachment binding lacks signed verification material");
-    }
-    const eventBundle = readCanonicalRecord(input.binding.bindingEvent, "Attachment binding event bundle");
-    const event = readAccessEvent(readRequiredRecordValue(eventBundle, "event", "Attachment binding event bundle"), "Attachment binding event");
-    const signer = await input.resolveProjectionUserKey(event.signerUserId);
-    if (!signer) {
-        throw new Error("Attachment binding signer identity is unavailable");
-    }
-    const documentManifest = input.authorization.documentManifestByHash.get(input.binding.documentManifestHash);
-    if (!documentManifest) {
-        throw new Error("Attachment binding document manifest is unverified");
-    }
-    const { dependencyContainerPaths } = resolveEventContainerPaths({
-        containerPathByManifestHash: input.authorization.containerPathByManifestHash,
-        dependencyManifestHashes: event.dependencyManifestHashes.filter((hash) => hash !== input.binding.documentManifestHash),
-    });
-    const verified = await verifyAttachmentBindingEvent({
-        authorizationMembership: "referenced",
-        authorizingContainerPaths: dependencyContainerPaths,
-        body: readCanonicalJson(readRequiredRecordValue(eventBundle, "body", "Attachment binding event bundle"), "Attachment binding event body"),
-        documentManifest,
-        event,
-        expectedBindingId: input.binding.bindingId,
-        expectedBlobId: input.binding.blobId,
-        expectedDocumentId: input.expectedDocumentId,
-        expectedDocumentManifestHash: input.binding.documentManifestHash,
-        expectedPreviousBindingId: input.binding.previousBindingId,
-        principalPolicies: input.authorization.principalPolicies,
-        signerPublicKey: signer.signingPublicKey,
-    });
-    if (!verified.ok) {
-        throw verified.error;
-    }
-    if (verified.value.slotId !== input.expectedSlotId ||
-        readRecordString(eventBundle, "eventHash", "Attachment binding event bundle") !== verified.value.event.eventHash) {
-        throw new KeyingVerificationError("object_mismatch", "Attachment binding slot or event hash is inconsistent");
-    }
-}
-//# sourceMappingURL=attachmentBindingVerification.js.map

package/workflows/blobs/attachmentBindingVerification.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"attachmentBindingVerification.js","sourceRoot":"","sources":["attachmentBindingVerification.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,uBAAuB,EACvB,4BAA4B,GAC7B,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACL,iBAAiB,EACjB,mBAAmB,GACpB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAGL,eAAe,EACf,gBAAgB,EAChB,uBAAuB,EACvB,0BAA0B,GAC3B,MAAM,yCAAyC,CAAC;AAEjD,MAAM,CAAC,KAAK,UAAU,+BAA+B,CAAC,KAarD;IACC,IAAI,CAAC,KAAK,CAAC,aAAa,EAAE,CAAC;QACzB,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAC;IAC1E,CAAC;IACD,IACE,CAAC,KAAK,CAAC,OAAO,CAAC,YAAY;QAC3B,CAAC,KAAK,CAAC,OAAO,CAAC,oBAAoB;QACnC,KAAK,CAAC,OAAO,CAAC,iBAAiB,KAAK,SAAS,EAC7C,CAAC;QACD,MAAM,IAAI,KAAK,CAAC,uDAAuD,CAAC,CAAC;IAC3E,CAAC;IACD,MAAM,WAAW,GAAG,mBAAmB,CACrC,KAAK,CAAC,OAAO,CAAC,YAAY,EAC1B,iCAAiC,CAClC,CAAC;IACF,MAAM,KAAK,GAAG,eAAe,CAC3B,uBAAuB,CACrB,WAAW,EACX,OAAO,EACP,iCAAiC,CAClC,EACD,0BAA0B,CAC3B,CAAC;IACF,MAAM,MAAM,GAAG,MAAM,KAAK,CAAC,wBAAwB,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;IACxE,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,MAAM,IAAI,KAAK,CAAC,mDAAmD,CAAC,CAAC;IACvE,CAAC;IACD,MAAM,gBAAgB,GAAG,KAAK,CAAC,aAAa,CAAC,sBAAsB,CAAC,GAAG,CACrE,KAAK,CAAC,OAAO,CAAC,oBAAoB,CACnC,CAAC;IACF,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACtB,MAAM,IAAI,KAAK,CAAC,oDAAoD,CAAC,CAAC;IACxE,CAAC;IACD,MAAM,EAAE,wBAAwB,EAAE,GAAG,0BAA0B,CAAC;QAC9D,2BAA2B,EACzB,KAAK,CAAC,aAAa,CAAC,2BAA2B;QACjD,wBAAwB,EAAE,KAAK,CAAC,wBAAwB,CAAC,MAAM,CAC7D,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,KAAK,KAAK,CAAC,OAAO,CAAC,oBAAoB,CACtD;KACF,CAAC,CAAC;IACH,MAAM,QAAQ,GAAG,MAAM,4BAA4B,CAAC;QAClD,uBAAuB,EAAE,YAAY;QACrC,yBAAyB,EAAE,wBAAwB;QACnD,IAAI,EAAE,iBAAiB,CACrB,uBAAuB,CACrB,WAAW,EACX,MAAM,EACN,iCAAiC,CAClC,EACD,+BAA+B,CAChC;QACD,gBAAgB;QAChB,KAAK;QACL,iBAAiB,EAAE,KAAK,CAAC,OAAO,CAAC,SAAS;QAC1C,cAAc,EAAE,KAAK,CAAC,OAAO,CAAC,MAAM;QACpC,kBAAkB,EAAE,KAAK,CAAC,kBAAkB;QAC5C,4BAA4B,EAAE,KAAK,CAAC,OAAO,CAAC,oBAAoB;QAChE,yBAAyB,EAAE,KAAK,CAAC,OAAO,CAAC,iBAAiB;QAC1D,iBAAiB,EAAE,KAAK,CAAC,aAAa,CAAC,iBAAiB;QACxD,eAAe,EAAE,MAAM,CAAC,gBAAgB;KACzC,CAAC,CAAC;IACH,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC;QACjB,MAAM,QAAQ,CAAC,KAAK,CAAC;IACvB,CAAC;IACD,IACE,QAAQ,CAAC,KAAK,CAAC,MAAM,KAAK,KAAK,CAAC,cAAc;QAC9C,gBAAgB,CACd,WAAW,EACX,WAAW,EACX,iCAAiC,CAClC,KAAK,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,SAAS,EACpC,CAAC;QACD,MAAM,IAAI,uBAAuB,CAC/B,iBAAiB,EACjB,uDAAuD,CACxD,CAAC;IACJ,CAAC;AACH,CAAC","sourcesContent":["import {\n  KeyingVerificationError,\n  verifyAttachmentBindingEvent,\n} from \"@tearleads/crypto\";\nimport type { DecryptDocumentAttachmentBlobInput } from \"../../data/documents/blob/shared/types\";\nimport {\n  readCanonicalJson,\n  readCanonicalRecord,\n} from \"../../data/keying/canonicalJson\";\nimport {\n  type DocumentWriterProjectionAuthorization,\n  type ProjectionUserKeyResolver,\n  readAccessEvent,\n  readRecordString,\n  readRequiredRecordValue,\n  resolveEventContainerPaths,\n} from \"../../data/keyingProjectionVerification\";\n\nexport async function assertAttachmentBindingVerified(input: {\n  readonly authorization: DocumentWriterProjectionAuthorization | undefined;\n  readonly binding: Pick<\n    DecryptDocumentAttachmentBlobInput[\"binding\"],\n    | \"bindingEvent\"\n    | \"documentManifestHash\"\n    | \"previousBindingId\"\n    | \"bindingId\"\n    | \"blobId\"\n  >;\n  readonly expectedDocumentId: string;\n  readonly expectedSlotId: string;\n  readonly resolveProjectionUserKey: ProjectionUserKeyResolver;\n}): Promise<void> {\n  if (!input.authorization) {\n    throw new Error(\"Attachment binding lacks verified document authority\");\n  }\n  if (\n    !input.binding.bindingEvent ||\n    !input.binding.documentManifestHash ||\n    input.binding.previousBindingId === undefined\n  ) {\n    throw new Error(\"Attachment binding lacks signed verification material\");\n  }\n  const eventBundle = readCanonicalRecord(\n    input.binding.bindingEvent,\n    \"Attachment binding event bundle\",\n  );\n  const event = readAccessEvent(\n    readRequiredRecordValue(\n      eventBundle,\n      \"event\",\n      \"Attachment binding event bundle\",\n    ),\n    \"Attachment binding event\",\n  );\n  const signer = await input.resolveProjectionUserKey(event.signerUserId);\n  if (!signer) {\n    throw new Error(\"Attachment binding signer identity is unavailable\");\n  }\n  const documentManifest = input.authorization.documentManifestByHash.get(\n    input.binding.documentManifestHash,\n  );\n  if (!documentManifest) {\n    throw new Error(\"Attachment binding document manifest is unverified\");\n  }\n  const { dependencyContainerPaths } = resolveEventContainerPaths({\n    containerPathByManifestHash:\n      input.authorization.containerPathByManifestHash,\n    dependencyManifestHashes: event.dependencyManifestHashes.filter(\n      (hash) => hash !== input.binding.documentManifestHash,\n    ),\n  });\n  const verified = await verifyAttachmentBindingEvent({\n    authorizationMembership: \"referenced\",\n    authorizingContainerPaths: dependencyContainerPaths,\n    body: readCanonicalJson(\n      readRequiredRecordValue(\n        eventBundle,\n        \"body\",\n        \"Attachment binding event bundle\",\n      ),\n      \"Attachment binding event body\",\n    ),\n    documentManifest,\n    event,\n    expectedBindingId: input.binding.bindingId,\n    expectedBlobId: input.binding.blobId,\n    expectedDocumentId: input.expectedDocumentId,\n    expectedDocumentManifestHash: input.binding.documentManifestHash,\n    expectedPreviousBindingId: input.binding.previousBindingId,\n    principalPolicies: input.authorization.principalPolicies,\n    signerPublicKey: signer.signingPublicKey,\n  });\n  if (!verified.ok) {\n    throw verified.error;\n  }\n  if (\n    verified.value.slotId !== input.expectedSlotId ||\n    readRecordString(\n      eventBundle,\n      \"eventHash\",\n      \"Attachment binding event bundle\",\n    ) !== verified.value.event.eventHash\n  ) {\n    throw new KeyingVerificationError(\n      \"object_mismatch\",\n      \"Attachment binding slot or event hash is inconsistent\",\n    );\n  }\n}\n"]}

package/workflows/blobs/attachmentDecryptor.js

@@ -1,41 +0,0 @@
-import { ProjectionDependencyUnavailableError } from "../../data/keyingProjectionVerification/dependencyUnavailable.js";
-import { isKeyingVerificationError } from "../../data/keyingProjectionVerification/error.js";
-import { decryptDocumentAttachmentBlob } from "./decrypt.js";
-/**
- * Proof material the cached projection lacks, such as a wrap-cited container
- * manifest that a fresher projection serves. Not integrity evidence.
- */
-function isRefreshableProofDependency(error) {
-    return (error instanceof ProjectionDependencyUnavailableError ||
-        (isKeyingVerificationError(error) && error.code === "missing_dependency"));
-}
-/** One fresh proof fetch shared by a hydration or key-rewrap run. */
-export function createAttachmentProofReader(apiClient, documentId, read) {
-    let refreshed;
-    const refresh = () => {
-        refreshed ??= (async () => {
-            apiClient.evictDocumentWriterProjection?.(documentId);
-            return apiClient.getDocumentWriterProjection(documentId);
-        })();
-        return refreshed;
-    };
-    return async (input) => {
-        try {
-            return await read(input);
-        }
-        catch (error) {
-            if (!isRefreshableProofDependency(error))
-                throw error;
-            const writerProjection = await refresh();
-            if (!writerProjection)
-                throw error;
-            // Retry the same binding and ciphertext with fully verified fresh proof.
-            // A second missing dependency escapes; it cannot trigger another fetch.
-            return read({ ...input, writerProjection });
-        }
-    };
-}
-export function createAttachmentDecryptor(apiClient, documentId) {
-    return createAttachmentProofReader(apiClient, documentId, decryptDocumentAttachmentBlob);
-}
-//# sourceMappingURL=attachmentDecryptor.js.map

package/workflows/blobs/attachmentDecryptor.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"attachmentDecryptor.js","sourceRoot":"","sources":["attachmentDecryptor.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,oCAAoC,EAAE,MAAM,+DAA+D,CAAC;AACrH,OAAO,EAAE,yBAAyB,EAAE,MAAM,+CAA+C,CAAC;AAC1F,OAAO,EAAE,6BAA6B,EAAE,MAAM,WAAW,CAAC;AAS1D;;;GAGG;AACH,SAAS,4BAA4B,CAAC,KAAc;IAClD,OAAO,CACL,KAAK,YAAY,oCAAoC;QACrD,CAAC,yBAAyB,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,IAAI,KAAK,oBAAoB,CAAC,CAC1E,CAAC;AACJ,CAAC;AAED,qEAAqE;AACrE,MAAM,UAAU,2BAA2B,CAIzC,SAAkC,EAClC,UAAkB,EAClB,IAAuC;IAEvC,IAAI,SAAuE,CAAC;IAC5E,MAAM,OAAO,GAAG,GAAG,EAAE;QACnB,SAAS,KAAK,CAAC,KAAK,IAAI,EAAE;YACxB,SAAS,CAAC,6BAA6B,EAAE,CAAC,UAAU,CAAC,CAAC;YACtD,OAAO,SAAS,CAAC,2BAA2B,CAAC,UAAU,CAAC,CAAC;QAC3D,CAAC,CAAC,EAAE,CAAC;QACL,OAAO,SAAS,CAAC;IACnB,CAAC,CAAC;IACF,OAAO,KAAK,EAAE,KAAY,EAAE,EAAE;QAC5B,IAAI,CAAC;YACH,OAAO,MAAM,IAAI,CAAC,KAAK,CAAC,CAAC;QAC3B,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,4BAA4B,CAAC,KAAK,CAAC;gBAAE,MAAM,KAAK,CAAC;YACtD,MAAM,gBAAgB,GAAG,MAAM,OAAO,EAAE,CAAC;YACzC,IAAI,CAAC,gBAAgB;gBAAE,MAAM,KAAK,CAAC;YACnC,yEAAyE;YACzE,wEAAwE;YACxE,OAAO,IAAI,CAAC,EAAE,GAAG,KAAK,EAAE,gBAAgB,EAAE,CAAC,CAAC;QAC9C,CAAC;IACH,CAAC,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,yBAAyB,CACvC,SAAkC,EAClC,UAAkB;IAElB,OAAO,2BAA2B,CAChC,SAAS,EACT,UAAU,EACV,6BAA6B,CAC9B,CAAC;AACJ,CAAC","sourcesContent":["import type { DocumentWriterProjectionResponse } from \"@tearleads/validators/response\";\nimport { ProjectionDependencyUnavailableError } from \"../../data/keyingProjectionVerification/dependencyUnavailable\";\nimport { isKeyingVerificationError } from \"../../data/keyingProjectionVerification/error\";\nimport { decryptDocumentAttachmentBlob } from \"./decrypt\";\n\ninterface AttachmentProjectionApi {\n  evictDocumentWriterProjection?(documentId: string): void;\n  getDocumentWriterProjection(\n    documentId: string,\n  ): Promise<DocumentWriterProjectionResponse | null>;\n}\n\n/**\n * Proof material the cached projection lacks, such as a wrap-cited container\n * manifest that a fresher projection serves. Not integrity evidence.\n */\nfunction isRefreshableProofDependency(error: unknown): boolean {\n  return (\n    error instanceof ProjectionDependencyUnavailableError ||\n    (isKeyingVerificationError(error) && error.code === \"missing_dependency\")\n  );\n}\n\n/** One fresh proof fetch shared by a hydration or key-rewrap run. */\nexport function createAttachmentProofReader<\n  Input extends { writerProjection: DocumentWriterProjectionResponse },\n  Result,\n>(\n  apiClient: AttachmentProjectionApi,\n  documentId: string,\n  read: (input: Input) => Promise<Result>,\n) {\n  let refreshed: Promise<DocumentWriterProjectionResponse | null> | undefined;\n  const refresh = () => {\n    refreshed ??= (async () => {\n      apiClient.evictDocumentWriterProjection?.(documentId);\n      return apiClient.getDocumentWriterProjection(documentId);\n    })();\n    return refreshed;\n  };\n  return async (input: Input) => {\n    try {\n      return await read(input);\n    } catch (error) {\n      if (!isRefreshableProofDependency(error)) throw error;\n      const writerProjection = await refresh();\n      if (!writerProjection) throw error;\n      // Retry the same binding and ciphertext with fully verified fresh proof.\n      // A second missing dependency escapes; it cannot trigger another fetch.\n      return read({ ...input, writerProjection });\n    }\n  };\n}\n\nexport function createAttachmentDecryptor(\n  apiClient: AttachmentProjectionApi,\n  documentId: string,\n) {\n  return createAttachmentProofReader(\n    apiClient,\n    documentId,\n    decryptDocumentAttachmentBlob,\n  );\n}\n"]}

package/workflows/blobs/attachmentKeyAuthenticator.js

@@ -1,68 +0,0 @@
-import { AES_GCM_TAG_BYTES, blobChunkPlaintextByteLength, bytesToHex, } from "../../internal/crypto/index.js";
-import { createBlobEnvelopeStream } from "../../data/documents/blob/shared/blobEnvelopeStream.js";
-import { assertEqualBytes, readWriteHeader, } from "../../data/documents/shared/readers.js";
-import { createAttachmentProofReader } from "./attachmentDecryptor.js";
-import { decryptBlobChunk } from "./blobChunkDecryption.js";
-import { prepareDocumentAttachmentBlobDecryption } from "./decrypt.js";
-const createProofReader = (api, documentId) => createAttachmentProofReader(api, documentId, prepareDocumentAttachmentBlobDecryption);
-async function authenticateAttachmentKey(api, input, readProof) {
-    const blob = await api.getBlobBytes(input.binding.blobId);
-    if (!blob)
-        throw new Error("Attachment ciphertext is unavailable for relinking");
-    const body = new Response(blob.encryptedBytes).body;
-    if (!body)
-        throw new Error("Attachment ciphertext stream is unavailable");
-    const source = createBlobEnvelopeStream(body);
-    try {
-        const encrypted = await source.readHeader();
-        // A missing citation can refresh the proof before consuming ciphertext.
-        const context = await readProof({ ...input, encrypted });
-        for (let index = 0; index < encrypted.chunkCount; index++) {
-            const plaintextByteLength = blobChunkPlaintextByteLength({
-                chunkCount: encrypted.chunkCount,
-                chunkIndex: index,
-                chunkSize: encrypted.chunkSize,
-                plaintextByteLength: encrypted.byteLength,
-            });
-            const ciphertext = await source.read(plaintextByteLength + AES_GCM_TAG_BYTES);
-            await decryptBlobChunk({
-                ...context,
-                encrypted,
-                expectedBlobId: input.binding.blobId,
-                chunk: { ciphertext, index, plaintextByteLength },
-            });
-        }
-        const header = readWriteHeader(input.binding.writeHeader, "Attachment blob write header");
-        if (bytesToHex(await source.finish()) !== header.ciphertextHash)
-            throw new Error("Attachment blob write header does not match ciphertext");
-        return {
-            encrypted,
-            contentKey: context.contentKey,
-            ciphertextHash: header.ciphertextHash,
-        };
-    }
-    finally {
-        await source.close();
-    }
-}
-/** Shared blobs retain only authenticated keys and metadata, never their bytes. */
-export function createAttachmentKeyAuthenticator(api, documentId) {
-    const readProof = createProofReader(api, documentId);
-    const authenticated = new Map();
-    return async (input) => {
-        const existing = authenticated.get(input.binding.blobId);
-        if (!existing) {
-            const pending = authenticateAttachmentKey(api, input, readProof);
-            authenticated.set(input.binding.blobId, pending);
-            return (await pending).contentKey;
-        }
-        const cached = await existing;
-        const context = await readProof({ ...input, encrypted: cached.encrypted });
-        if (readWriteHeader(input.binding.writeHeader, "Attachment blob write header")
-            .ciphertextHash !== cached.ciphertextHash)
-            throw new Error("Attachment blob write header does not match ciphertext");
-        assertEqualBytes(context.contentKey, cached.contentKey, "Attachment bindings contain conflicting blob keys");
-        return cached.contentKey;
-    };
-}
-//# sourceMappingURL=attachmentKeyAuthenticator.js.map

package/workflows/blobs/attachmentKeyAuthenticator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"attachmentKeyAuthenticator.js","sourceRoot":"","sources":["attachmentKeyAuthenticator.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AES_GCM_TAG_BYTES,\n  blobChunkPlaintextByteLength,\n  bytesToHex,\n} from \"@tearleads/crypto\";\nimport { createBlobEnvelopeStream } from \"../../data/documents/blob/shared/blobEnvelopeStream\";\nimport type {\n  BlobEncryptedBytesHeader,\n  DecryptDocumentAttachmentBlobInput,\n} from \"../../data/documents/blob/shared/types\";\nimport {\n  assertEqualBytes,\n  readWriteHeader,\n} from \"../../data/documents/shared/readers\";\nimport type { DocumentLinkSetMutationApi } from \"../../data/documents/shared/types\";\nimport { createAttachmentProofReader } from \"./attachmentDecryptor\";\nimport { decryptBlobChunk } from \"./blobChunkDecryption\";\nimport { prepareDocumentAttachmentBlobDecryption } from \"./decrypt\";\n\ntype AttachmentKeyInput = Omit<\n  DecryptDocumentAttachmentBlobInput,\n  \"encryptedBytes\"\n>;\ntype VerifiedKey = {\n  ciphertextHash: string;\n  encrypted: BlobEncryptedBytesHeader;\n  contentKey: Uint8Array;\n};\ntype ProofReader = ReturnType<typeof createProofReader>;\n\nconst createProofReader = (\n  api: DocumentLinkSetMutationApi,\n  documentId: string,\n) =>\n  createAttachmentProofReader(\n    api,\n    documentId,\n    prepareDocumentAttachmentBlobDecryption,\n  );\n\nasync function authenticateAttachmentKey(\n  api: DocumentLinkSetMutationApi,\n  input: AttachmentKeyInput,\n  readProof: ProofReader,\n): Promise<VerifiedKey> {\n  const blob = await api.getBlobBytes(input.binding.blobId);\n  if (!blob)\n    throw new Error(\"Attachment ciphertext is unavailable for relinking\");\n  const body = new Response(blob.encryptedBytes).body;\n  if (!body) throw new Error(\"Attachment ciphertext stream is unavailable\");\n  const source = createBlobEnvelopeStream(body);\n  try {\n    const encrypted = await source.readHeader();\n    // A missing citation can refresh the proof before consuming ciphertext.\n    const context = await readProof({ ...input, encrypted });\n    for (let index = 0; index < encrypted.chunkCount; index++) {\n      const plaintextByteLength = blobChunkPlaintextByteLength({\n        chunkCount: encrypted.chunkCount,\n        chunkIndex: index,\n        chunkSize: encrypted.chunkSize,\n        plaintextByteLength: encrypted.byteLength,\n      });\n      const ciphertext = await source.read(\n        plaintextByteLength + AES_GCM_TAG_BYTES,\n      );\n      await decryptBlobChunk({\n        ...context,\n        encrypted,\n        expectedBlobId: input.binding.blobId,\n        chunk: { ciphertext, index, plaintextByteLength },\n      });\n    }\n    const header = readWriteHeader(\n      input.binding.writeHeader,\n      \"Attachment blob write header\",\n    );\n    if (bytesToHex(await source.finish()) !== header.ciphertextHash)\n      throw new Error(\"Attachment blob write header does not match ciphertext\");\n    return {\n      encrypted,\n      contentKey: context.contentKey,\n      ciphertextHash: header.ciphertextHash,\n    };\n  } finally {\n    await source.close();\n  }\n}\n\n/** Shared blobs retain only authenticated keys and metadata, never their bytes. */\nexport function createAttachmentKeyAuthenticator(\n  api: DocumentLinkSetMutationApi,\n  documentId: string,\n) {\n  const readProof = createProofReader(api, documentId);\n  const authenticated = new Map<string, Promise<VerifiedKey>>();\n  return async (input: AttachmentKeyInput): Promise<Uint8Array> => {\n    const existing = authenticated.get(input.binding.blobId);\n    if (!existing) {\n      const pending = authenticateAttachmentKey(api, input, readProof);\n      authenticated.set(input.binding.blobId, pending);\n      return (await pending).contentKey;\n    }\n    const cached = await existing;\n    const context = await readProof({ ...input, encrypted: cached.encrypted });\n    if (\n      readWriteHeader(input.binding.writeHeader, \"Attachment blob write header\")\n        .ciphertextHash !== cached.ciphertextHash\n    )\n      throw new Error(\"Attachment blob write header does not match ciphertext\");\n    assertEqualBytes(\n      context.contentKey,\n      cached.contentKey,\n      \"Attachment bindings contain conflicting blob keys\",\n    );\n    return cached.contentKey;\n  };\n}\n"]}

package/workflows/blobs/automaticMultipartUpload.js

@@ -1,9 +0,0 @@
-import { DEFAULT_BLOB_CHUNK_SIZE_BYTES } from "../../data/documents/blob/shared/crypto.js";
-export function resolveMultipartUploadOptions(multipart) {
-    const resolved = multipart ?? { partSize: DEFAULT_BLOB_CHUNK_SIZE_BYTES };
-    if (resolved.partSize !== DEFAULT_BLOB_CHUNK_SIZE_BYTES) {
-        throw new Error("Multipart blob chunk size must be exactly 5 MiB");
-    }
-    return resolved;
-}
-//# sourceMappingURL=automaticMultipartUpload.js.map

package/workflows/blobs/automaticMultipartUpload.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"automaticMultipartUpload.js","sourceRoot":"","sources":["automaticMultipartUpload.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,6BAA6B,EAAE,MAAM,yCAAyC,CAAC;AAGxF,MAAM,UAAU,6BAA6B,CAC3C,SAAqD;IAErD,MAAM,QAAQ,GAAG,SAAS,IAAI,EAAE,QAAQ,EAAE,6BAA6B,EAAE,CAAC;IAC1E,IAAI,QAAQ,CAAC,QAAQ,KAAK,6BAA6B,EAAE,CAAC;QACxD,MAAM,IAAI,KAAK,CAAC,iDAAiD,CAAC,CAAC;IACrE,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC","sourcesContent":["import { DEFAULT_BLOB_CHUNK_SIZE_BYTES } from \"../../data/documents/blob/shared/crypto\";\nimport type { UploadDocumentAttachmentInput } from \"../../data/documents/blob/shared/types\";\n\nexport function resolveMultipartUploadOptions(\n  multipart: UploadDocumentAttachmentInput[\"multipart\"],\n): NonNullable<UploadDocumentAttachmentInput[\"multipart\"]> {\n  const resolved = multipart ?? { partSize: DEFAULT_BLOB_CHUNK_SIZE_BYTES };\n  if (resolved.partSize !== DEFAULT_BLOB_CHUNK_SIZE_BYTES) {\n    throw new Error(\"Multipart blob chunk size must be exactly 5 MiB\");\n  }\n  return resolved;\n}\n"]}

package/workflows/blobs/blobChunkDecryption.js

@@ -1,34 +0,0 @@
-import { deriveBlobChunkIv } from "../../internal/crypto/index.js";
-import { contentRecordAdditionalDataBytes } from "../../data/documents/blob/shared/crypto.js";
-import { asWebCryptoBytes } from "../../data/documents/shared/readers.js";
-export async function decryptBlobChunk(input) {
-    const { encrypted, expectedBlobId, organizationId, recordKey, chunk } = input;
-    const plaintext = new Uint8Array(await crypto.subtle.decrypt({
-        name: "AES-GCM",
-        iv: deriveBlobChunkIv(encrypted.iv, chunk.index),
-        additionalData: contentRecordAdditionalDataBytes({
-            blobId: expectedBlobId,
-            chunkCount: encrypted.chunkCount,
-            chunkIndex: chunk.index,
-            chunkPlaintextByteLength: chunk.plaintextByteLength,
-            chunkSize: encrypted.chunkSize,
-            contentKeyEpoch: encrypted.contentKeyEpoch,
-            contentRecordId: encrypted.contentRecordId,
-            metadataHash: encrypted.metadataHash,
-            nonceDomainHash: encrypted.nonceDomainHash,
-            organizationId,
-            plaintextByteLength: encrypted.byteLength,
-        }),
-    }, recordKey, asWebCryptoBytes(chunk.ciphertext)));
-    if (plaintext.byteLength !== chunk.plaintextByteLength)
-        throw new Error("Blob decrypted chunk byte length mismatch");
-    return plaintext;
-}
-export async function decryptBlobChunks(input) {
-    const decrypted = new Uint8Array(input.encrypted.byteLength);
-    for (const chunk of input.encrypted.chunks) {
-        decrypted.set(await decryptBlobChunk({ ...input, chunk }), chunk.index * input.encrypted.chunkSize);
-    }
-    return decrypted;
-}
-//# sourceMappingURL=blobChunkDecryption.js.map

package/workflows/blobs/blobChunkDecryption.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"blobChunkDecryption.js","sourceRoot":"","sources":["blobChunkDecryption.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAEtD,OAAO,EAAE,gCAAgC,EAAE,MAAM,yCAAyC,CAAC;AAM3F,OAAO,EAAE,gBAAgB,EAAE,MAAM,qCAAqC,CAAC;AASvE,MAAM,CAAC,KAAK,UAAU,gBAAgB,CACpC,KAEC;IAED,MAAM,EAAE,SAAS,EAAE,cAAc,EAAE,cAAc,EAAE,SAAS,EAAE,KAAK,EAAE,GAAG,KAAK,CAAC;IAC9E,MAAM,SAAS,GAAG,IAAI,UAAU,CAC9B,MAAM,MAAM,CAAC,MAAM,CAAC,OAAO,CACzB;QACE,IAAI,EAAE,SAAS;QACf,EAAE,EAAE,iBAAiB,CAAC,SAAS,CAAC,EAAE,EAAE,KAAK,CAAC,KAAK,CAAC;QAChD,cAAc,EAAE,gCAAgC,CAAC;YAC/C,MAAM,EAAE,cAAc;YACtB,UAAU,EAAE,SAAS,CAAC,UAAU;YAChC,UAAU,EAAE,KAAK,CAAC,KAAK;YACvB,wBAAwB,EAAE,KAAK,CAAC,mBAAmB;YACnD,SAAS,EAAE,SAAS,CAAC,SAAS;YAC9B,eAAe,EAAE,SAAS,CAAC,eAAe;YAC1C,eAAe,EAAE,SAAS,CAAC,eAAe;YAC1C,YAAY,EAAE,SAAS,CAAC,YAAY;YACpC,eAAe,EAAE,SAAS,CAAC,eAAe;YAC1C,cAAc;YACd,mBAAmB,EAAE,SAAS,CAAC,UAAU;SAC1C,CAAC;KACH,EACD,SAAS,EACT,gBAAgB,CAAC,KAAK,CAAC,UAAU,CAAC,CACnC,CACF,CAAC;IACF,IAAI,SAAS,CAAC,UAAU,KAAK,KAAK,CAAC,mBAAmB;QACpD,MAAM,IAAI,KAAK,CAAC,2CAA2C,CAAC,CAAC;IAC/D,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,KAEC;IAED,MAAM,SAAS,GAAG,IAAI,UAAU,CAAC,KAAK,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;IAC7D,KAAK,MAAM,KAAK,IAAI,KAAK,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC;QAC3C,SAAS,CAAC,GAAG,CACX,MAAM,gBAAgB,CAAC,EAAE,GAAG,KAAK,EAAE,KAAK,EAAE,CAAC,EAC3C,KAAK,CAAC,KAAK,GAAG,KAAK,CAAC,SAAS,CAAC,SAAS,CACxC,CAAC;IACJ,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC","sourcesContent":["import { deriveBlobChunkIv } from \"@tearleads/crypto\";\nimport type { BlobBytes } from \"../../data/blobs/blobContracts\";\nimport { contentRecordAdditionalDataBytes } from \"../../data/documents/blob/shared/crypto\";\nimport type {\n  BlobEncryptedBytesHeader,\n  BlobEncryptedBytesRecord,\n  BlobEncryptedChunk,\n} from \"../../data/documents/blob/shared/types\";\nimport { asWebCryptoBytes } from \"../../data/documents/shared/readers\";\n\ninterface BlobChunkDecryption {\n  encrypted: BlobEncryptedBytesHeader;\n  expectedBlobId: string;\n  organizationId: string;\n  recordKey: CryptoKey;\n}\n\nexport async function decryptBlobChunk(\n  input: BlobChunkDecryption & {\n    chunk: BlobEncryptedChunk;\n  },\n): Promise<BlobBytes> {\n  const { encrypted, expectedBlobId, organizationId, recordKey, chunk } = input;\n  const plaintext = new Uint8Array(\n    await crypto.subtle.decrypt(\n      {\n        name: \"AES-GCM\",\n        iv: deriveBlobChunkIv(encrypted.iv, chunk.index),\n        additionalData: contentRecordAdditionalDataBytes({\n          blobId: expectedBlobId,\n          chunkCount: encrypted.chunkCount,\n          chunkIndex: chunk.index,\n          chunkPlaintextByteLength: chunk.plaintextByteLength,\n          chunkSize: encrypted.chunkSize,\n          contentKeyEpoch: encrypted.contentKeyEpoch,\n          contentRecordId: encrypted.contentRecordId,\n          metadataHash: encrypted.metadataHash,\n          nonceDomainHash: encrypted.nonceDomainHash,\n          organizationId,\n          plaintextByteLength: encrypted.byteLength,\n        }),\n      },\n      recordKey,\n      asWebCryptoBytes(chunk.ciphertext),\n    ),\n  );\n  if (plaintext.byteLength !== chunk.plaintextByteLength)\n    throw new Error(\"Blob decrypted chunk byte length mismatch\");\n  return plaintext;\n}\n\nexport async function decryptBlobChunks(\n  input: Omit<BlobChunkDecryption, \"encrypted\"> & {\n    encrypted: BlobEncryptedBytesRecord;\n  },\n): Promise<BlobBytes> {\n  const decrypted = new Uint8Array(input.encrypted.byteLength);\n  for (const chunk of input.encrypted.chunks) {\n    decrypted.set(\n      await decryptBlobChunk({ ...input, chunk }),\n      chunk.index * input.encrypted.chunkSize,\n    );\n  }\n  return decrypted;\n}\n"]}

package/workflows/blobs/decrypt.d.ts

@@ -1,12 +0,0 @@
-import type { BlobBytes } from "../../data/blobs/blobContracts.js";
-import type { BlobEncryptedBytesHeader, DecryptDocumentAttachmentBlobInput } from "../../data/documents/blob/shared/types.js";
-export type AttachmentBlobDecryptionInput = Omit<DecryptDocumentAttachmentBlobInput, "encryptedBytes"> & {
-    encrypted: BlobEncryptedBytesHeader;
-};
-/** Verifies metadata and authority; the caller must still authenticate ciphertext. */
-export declare function prepareDocumentAttachmentBlobDecryption({ binding, encrypted, expectedDocumentId, expectedSlotId, execSql, resolveProjectionUserKey, targetSecretKey, stillCurrent, warmReferencedPrincipalPolicies, writerProjection, }: AttachmentBlobDecryptionInput): Promise<{
-    contentKey: Uint8Array;
-    recordKey: CryptoKey;
-    organizationId: string;
-}>;
-export declare function decryptDocumentAttachmentBlob(input: DecryptDocumentAttachmentBlobInput): Promise<BlobBytes>;