@tearleads/client-sdk 0.0.0-stage → 0.1.11

package/workflows/container-contents/metadataReadState.js

@@ -0,0 +1,11 @@
+export function hasCurrentContainerMetadataReadState(record) {
+    return (typeof record.lastCommitLsn === "string" &&
+        record.lastCommitLsn.length > 0 &&
+        typeof record.contentKeyBundle === "string" &&
+        record.contentKeyBundle.length > 0 &&
+        typeof record.documentKekTargets === "string" &&
+        record.documentKekTargets.length > 0 &&
+        typeof record.documentManifestBundle === "string" &&
+        record.documentManifestBundle.length > 0);
+}
+//# sourceMappingURL=metadataReadState.js.map

package/workflows/container-contents/metadataReadState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadataReadState.js","sourceRoot":"","sources":["metadataReadState.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,oCAAoC,CAClD,MAMC;IAED,OAAO,CACL,OAAO,MAAM,CAAC,aAAa,KAAK,QAAQ;QACxC,MAAM,CAAC,aAAa,CAAC,MAAM,GAAG,CAAC;QAC/B,OAAO,MAAM,CAAC,gBAAgB,KAAK,QAAQ;QAC3C,MAAM,CAAC,gBAAgB,CAAC,MAAM,GAAG,CAAC;QAClC,OAAO,MAAM,CAAC,kBAAkB,KAAK,QAAQ;QAC7C,MAAM,CAAC,kBAAkB,CAAC,MAAM,GAAG,CAAC;QACpC,OAAO,MAAM,CAAC,sBAAsB,KAAK,QAAQ;QACjD,MAAM,CAAC,sBAAsB,CAAC,MAAM,GAAG,CAAC,CACzC,CAAC;AACJ,CAAC","sourcesContent":["import type { ContainerDocumentRecord as DocumentRecord } from \"./containerPersistence\";\n\nexport function hasCurrentContainerMetadataReadState(\n  record: Pick<\n    DocumentRecord,\n    | \"contentKeyBundle\"\n    | \"documentKekTargets\"\n    | \"documentManifestBundle\"\n    | \"lastCommitLsn\"\n  >,\n): boolean {\n  return (\n    typeof record.lastCommitLsn === \"string\" &&\n    record.lastCommitLsn.length > 0 &&\n    typeof record.contentKeyBundle === \"string\" &&\n    record.contentKeyBundle.length > 0 &&\n    typeof record.documentKekTargets === \"string\" &&\n    record.documentKekTargets.length > 0 &&\n    typeof record.documentManifestBundle === \"string\" &&\n    record.documentManifestBundle.length > 0\n  );\n}\n"]}

package/workflows/container-contents/metadataRecord.js

@@ -0,0 +1,43 @@
+import { bytesToBase64 } from "../../internal/encoding/index.js";
+import { exportAllUpdates } from "../../internal/loro/index.js";
+import { currentMetadataPullContinuation, } from "./metadataMutationPreparation.js";
+export function resolveContainerSystemSlot(patch, container) {
+    return patch.systemSlot ?? container.systemSlot ?? null;
+}
+export function resolveMetadataDocumentId(patch, container) {
+    return (patch.metadataDocumentId ?? patch.documentId ?? container.metadataDocumentId);
+}
+function resolveNullableContainerMetadataDocumentField(patch, key, currentValue, resetWhenUnpatched = false) {
+    if (Object.hasOwn(patch, key))
+        return patch[key] ?? null;
+    return resetWhenUnpatched ? null : (currentValue ?? null);
+}
+function resolveMetadataPullState(metadataState, patch, securityContextChanged) {
+    if (Object.hasOwn(patch, "pullContinuation")) {
+        return { pullContinuation: patch.pullContinuation ?? null };
+    }
+    if (securityContextChanged)
+        return { pullContinuation: null };
+    if (metadataState.record.pullContinuationRecoveryRequired) {
+        return { pullContinuationRecoveryRequired: true };
+    }
+    return { pullContinuation: currentMetadataPullContinuation(metadataState) };
+}
+export function buildContainerMetadataRecord(input) {
+    const { metadataState, patch, securityContext } = input;
+    return {
+        id: metadataState.container.id,
+        documentId: securityContext.documentId,
+        metadataUpdates: patch.metadataUpdates ??
+            bytesToBase64(exportAllUpdates(metadataState.doc)),
+        snapshotEndVersion: "",
+        accessEpoch: securityContext.accessEpoch,
+        accessStateHash: resolveNullableContainerMetadataDocumentField(patch, "accessStateHash", metadataState.record.accessStateHash, securityContext.changed),
+        lastCommitLsn: resolveNullableContainerMetadataDocumentField(patch, "lastCommitLsn", metadataState.record.lastCommitLsn, securityContext.documentIdChanged),
+        contentKeyBundle: resolveNullableContainerMetadataDocumentField(patch, "contentKeyBundle", metadataState.record.contentKeyBundle, securityContext.changed),
+        documentKekTargets: resolveNullableContainerMetadataDocumentField(patch, "documentKekTargets", metadataState.record.documentKekTargets, securityContext.changed),
+        documentManifestBundle: resolveNullableContainerMetadataDocumentField(patch, "documentManifestBundle", metadataState.record.documentManifestBundle, securityContext.changed),
+        ...resolveMetadataPullState(metadataState, patch, securityContext.changed),
+    };
+}
+//# sourceMappingURL=metadataRecord.js.map

package/workflows/container-contents/metadataRecord.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadataRecord.js","sourceRoot":"","sources":["metadataRecord.ts"],"names":[],"mappings":"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","sourcesContent":["import { bytesToBase64 } from \"@tearleads/encoding\";\nimport { exportAllUpdates } from \"@tearleads/loro\";\nimport type { ContainerRecord } from \"../../data/persistence/containers/containerPersistence\";\nimport type { ContainerDocumentRecord as DocumentRecord } from \"./containerPersistence\";\nimport {\n  currentMetadataPullContinuation,\n  type resolveMetadataSecurityContext,\n} from \"./metadataMutationPreparation\";\nimport type {\n  ContainerMetadataPatch,\n  ContainerMetadataState,\n} from \"./metadataTypes\";\n\ntype NullableContainerMetadataDocumentField =\n  | \"accessStateHash\"\n  | \"lastCommitLsn\"\n  | \"contentKeyBundle\"\n  | \"documentKekTargets\"\n  | \"documentManifestBundle\";\n\nexport function resolveContainerSystemSlot(\n  patch: Partial<ContainerMetadataPatch>,\n  container: ContainerRecord,\n): NonNullable<ContainerRecord[\"systemSlot\"]> | null {\n  return patch.systemSlot ?? container.systemSlot ?? null;\n}\n\nexport function resolveMetadataDocumentId(\n  patch: Partial<ContainerMetadataPatch>,\n  container: ContainerRecord,\n): ContainerRecord[\"metadataDocumentId\"] {\n  return (\n    patch.metadataDocumentId ?? patch.documentId ?? container.metadataDocumentId\n  );\n}\n\nfunction resolveNullableContainerMetadataDocumentField(\n  patch: Partial<ContainerMetadataPatch>,\n  key: NullableContainerMetadataDocumentField,\n  currentValue: string | null | undefined,\n  resetWhenUnpatched = false,\n): string | null {\n  if (Object.hasOwn(patch, key)) return patch[key] ?? null;\n  return resetWhenUnpatched ? null : (currentValue ?? null);\n}\n\nfunction resolveMetadataPullState(\n  metadataState: ContainerMetadataState,\n  patch: Partial<ContainerMetadataPatch>,\n  securityContextChanged: boolean,\n): Pick<\n  DocumentRecord,\n  \"pullContinuation\" | \"pullContinuationRecoveryRequired\"\n> {\n  if (Object.hasOwn(patch, \"pullContinuation\")) {\n    return { pullContinuation: patch.pullContinuation ?? null };\n  }\n  if (securityContextChanged) return { pullContinuation: null };\n  if (metadataState.record.pullContinuationRecoveryRequired) {\n    return { pullContinuationRecoveryRequired: true };\n  }\n  return { pullContinuation: currentMetadataPullContinuation(metadataState) };\n}\n\nexport function buildContainerMetadataRecord(input: {\n  metadataState: ContainerMetadataState;\n  patch: Partial<ContainerMetadataPatch>;\n  securityContext: ReturnType<typeof resolveMetadataSecurityContext>;\n}): DocumentRecord {\n  const { metadataState, patch, securityContext } = input;\n  return {\n    id: metadataState.container.id,\n    documentId: securityContext.documentId,\n    metadataUpdates:\n      patch.metadataUpdates ??\n      bytesToBase64(exportAllUpdates(metadataState.doc)),\n    snapshotEndVersion: \"\",\n    accessEpoch: securityContext.accessEpoch,\n    accessStateHash: resolveNullableContainerMetadataDocumentField(\n      patch,\n      \"accessStateHash\",\n      metadataState.record.accessStateHash,\n      securityContext.changed,\n    ),\n    lastCommitLsn: resolveNullableContainerMetadataDocumentField(\n      patch,\n      \"lastCommitLsn\",\n      metadataState.record.lastCommitLsn,\n      securityContext.documentIdChanged,\n    ),\n    contentKeyBundle: resolveNullableContainerMetadataDocumentField(\n      patch,\n      \"contentKeyBundle\",\n      metadataState.record.contentKeyBundle,\n      securityContext.changed,\n    ),\n    documentKekTargets: resolveNullableContainerMetadataDocumentField(\n      patch,\n      \"documentKekTargets\",\n      metadataState.record.documentKekTargets,\n      securityContext.changed,\n    ),\n    documentManifestBundle: resolveNullableContainerMetadataDocumentField(\n      patch,\n      \"documentManifestBundle\",\n      metadataState.record.documentManifestBundle,\n      securityContext.changed,\n    ),\n    ...resolveMetadataPullState(metadataState, patch, securityContext.changed),\n  };\n}\n"]}

package/workflows/container-contents/metadataRemoteSync.d.ts

@@ -0,0 +1,38 @@
+import type { DocumentWriterProjectionResponse } from "../../internal/validators/response/index.js";
+import type { ProjectionUserKeyResolver } from "../../data/keyingProjectionVerification.js";
+import type { PendingUpdateRecord } from "../../data/sqlite/documentPersistence.js";
+import { type RekeyPendingUpdate, syncRemoteDocument } from "../documents/index.js";
+import type { ContainerMetadataState } from "./metadataTypes.js";
+import type { ContainerContentsWorkflowRuntime } from "./runtime.js";
+type ContainerMetadataSyncApi = Parameters<typeof syncRemoteDocument>[0]["apiClient"] & Pick<ContainerContentsWorkflowRuntime["apiClient"], "getCurrentPrincipalPolicy">;
+export interface ContainerMetadataSyncRuntime extends Pick<ContainerContentsWorkflowRuntime, "auth" | "crypto" | "infra" | "resolveTrustedUserIdentity" | "state" | "util"> {
+    apiClient: ContainerMetadataSyncApi;
+}
+type ContainerMetadataSyncResult = NonNullable<Awaited<ReturnType<typeof syncRemoteDocument>>>;
+export interface ContainerMetadataSyncAttempt {
+    consumedPullContinuation: ContainerMetadataState["pullContinuation"];
+    outgoingUpdateCount: number;
+    requestRecord: ContainerMetadataState["record"];
+    synced: ContainerMetadataSyncResult;
+}
+interface SyncRemoteContainerMetadataInput {
+    buildRotationSnapshot?: (() => Promise<Uint8Array | null>) | undefined;
+    containerId: string;
+    currentDocument: ContainerMetadataState["doc"];
+    documentId: string | null;
+    isCurrent: () => boolean;
+    lastCommitLsn?: string | null | undefined;
+    localVersionVector: string | null;
+    onOutgoingUpdatesMaterialized?: ((updateIds: readonly string[]) => void) | undefined;
+    onPullContinuationInvalidated?: Parameters<typeof syncRemoteDocument>[0]["onPullContinuationInvalidated"];
+    pendingUpdates: readonly PendingUpdateRecord[];
+    persistedState: ContainerMetadataState["record"];
+    pullContinuation?: ContainerMetadataState["pullContinuation"];
+    rekeyPendingUpdate: RekeyPendingUpdate;
+    resolveProjectionUserKey: ProjectionUserKeyResolver;
+    runtime: ContainerMetadataSyncRuntime;
+    targetSecretKey: Uint8Array;
+    writerProjection?: DocumentWriterProjectionResponse | undefined;
+}
+export declare function syncRemoteContainerMetadata(input: SyncRemoteContainerMetadataInput): Promise<ContainerMetadataSyncAttempt | null>;
+export {};

package/workflows/container-contents/metadataRemoteSync.js

@@ -0,0 +1,91 @@
+import { CONTAINER_METADATA_APP_KIND } from "../../data/persistence/container-contents/containerContentsPersistence.js";
+import { createDocumentWriterPublicKeyResolver, describeDocumentSyncSubmitFailure, resolveDocumentCreateAuthor, syncRemoteDocument, } from "../documents/index.js";
+import { createRuntimePrincipalPolicyWarmer } from "../principals/runtimePolicyWarmer.js";
+import { metadataIncomingUpdateIsolation, recordCurrentMetadataSyncFailure, } from "./metadataIncomingUpdateIsolation.js";
+import { deferRecoverableMetadataSyncError } from "./metadataSyncErrors.js";
+function createContainerMetadataSyncAttempt(input) {
+    return {
+        consumedPullContinuation: input.synced.plan.request.pullCursor === undefined
+            ? null
+            : (input.requestedPullContinuation ?? null),
+        outgoingUpdateCount: input.outgoingUpdateCount,
+        requestRecord: input.requestRecord,
+        synced: input.synced,
+    };
+}
+export async function syncRemoteContainerMetadata(input) {
+    const { documentId, isCurrent, runtime } = input;
+    if (!documentId)
+        return null;
+    const author = resolveDocumentCreateAuthor(runtime);
+    if (!author) {
+        runtime.util.log("Container contents: skipped metadata sync because the writer context is unavailable.");
+        return null;
+    }
+    const execSql = runtime.infra.execSql;
+    const metadataScope = {
+        appKind: CONTAINER_METADATA_APP_KIND,
+        localId: input.containerId,
+    };
+    const synced = await syncRemoteDocument({
+        apiClient: runtime.apiClient,
+        author,
+        buildRotationSnapshot: input.buildRotationSnapshot,
+        documentId,
+        execSql,
+        isRemoteSyncBlocked: runtime.util.isRemoteSyncBlocked,
+        localVersionVector: input.localVersionVector,
+        minLsn: input.lastCommitLsn ?? undefined,
+        ...metadataIncomingUpdateIsolation({
+            currentDocument: input.currentDocument,
+            execSql,
+            isCurrent,
+            logError: runtime.util.logError,
+            metadataScope,
+        }),
+        onOutgoingUpdatesMaterialized: input.onOutgoingUpdatesMaterialized,
+        onPullContinuationInvalidated: input.onPullContinuationInvalidated,
+        onSyncTrace: (line) => runtime.util.log(`Container contents: ${line}`),
+        onTerminalSubmitFailure: async (failure) => {
+            await recordCurrentMetadataSyncFailure({
+                execSql,
+                failure: {
+                    attemptedAt: new Date().toISOString(),
+                    message: describeDocumentSyncSubmitFailure(failure),
+                    status: failure.status,
+                },
+                isCurrent,
+                metadataScope,
+            });
+        },
+        pendingUpdates: input.pendingUpdates,
+        persistedState: input.persistedState,
+        pullContinuation: input.pullContinuation ?? undefined,
+        rekeyPendingUpdate: (rekeyExecSql, updateId) => isCurrent()
+            ? input.rekeyPendingUpdate(rekeyExecSql, updateId)
+            : Promise.resolve(null),
+        resolveProjectionUserKey: input.resolveProjectionUserKey,
+        resolveWriterPublicKey: createDocumentWriterPublicKeyResolver({
+            logPrefix: "Container contents",
+            runtime,
+            writerKeyLabel: "metadata writer key",
+        }),
+        stillCurrent: isCurrent,
+        targetSecretKey: input.targetSecretKey,
+        warmReferencedPrincipalPolicies: createRuntimePrincipalPolicyWarmer(runtime),
+        writerProjection: input.writerProjection,
+    }).catch((error) => deferRecoverableMetadataSyncError({
+        containerId: input.containerId,
+        error,
+        runtime,
+    }));
+    if (!synced)
+        return null;
+    return createContainerMetadataSyncAttempt({
+        outgoingUpdateCount: input.pendingUpdates.length,
+        requestedPullContinuation: input.pullContinuation,
+        requestRecord: input.persistedState,
+        synced,
+    });
+}
+//# sourceMappingURL=metadataRemoteSync.js.map

package/workflows/container-contents/metadataRemoteSync.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadataRemoteSync.js","sourceRoot":"","sources":["metadataRemoteSync.ts"],"names":[],"mappings":"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","sourcesContent":["import type { DocumentWriterProjectionResponse } from \"@tearleads/validators/response\";\nimport type { ProjectionUserKeyResolver } from \"../../data/keyingProjectionVerification\";\nimport { CONTAINER_METADATA_APP_KIND } from \"../../data/persistence/container-contents/containerContentsPersistence\";\nimport type { PendingUpdateRecord } from \"../../data/sqlite/documentPersistence\";\nimport {\n  createDocumentWriterPublicKeyResolver,\n  describeDocumentSyncSubmitFailure,\n  type RekeyPendingUpdate,\n  resolveDocumentCreateAuthor,\n  syncRemoteDocument,\n} from \"../documents\";\nimport { createRuntimePrincipalPolicyWarmer } from \"../principals/runtimePolicyWarmer\";\nimport {\n  metadataIncomingUpdateIsolation,\n  recordCurrentMetadataSyncFailure,\n} from \"./metadataIncomingUpdateIsolation\";\nimport { deferRecoverableMetadataSyncError } from \"./metadataSyncErrors\";\nimport type { ContainerMetadataState } from \"./metadataTypes\";\nimport type { ContainerContentsWorkflowRuntime } from \"./runtime\";\n\ntype ContainerMetadataSyncApi = Parameters<\n  typeof syncRemoteDocument\n>[0][\"apiClient\"] &\n  Pick<\n    ContainerContentsWorkflowRuntime[\"apiClient\"],\n    \"getCurrentPrincipalPolicy\"\n  >;\n\nexport interface ContainerMetadataSyncRuntime\n  extends Pick<\n    ContainerContentsWorkflowRuntime,\n    | \"auth\"\n    | \"crypto\"\n    | \"infra\"\n    | \"resolveTrustedUserIdentity\"\n    | \"state\"\n    | \"util\"\n  > {\n  apiClient: ContainerMetadataSyncApi;\n}\n\ntype ContainerMetadataSyncResult = NonNullable<\n  Awaited<ReturnType<typeof syncRemoteDocument>>\n>;\n\nexport interface ContainerMetadataSyncAttempt {\n  consumedPullContinuation: ContainerMetadataState[\"pullContinuation\"];\n  outgoingUpdateCount: number;\n  requestRecord: ContainerMetadataState[\"record\"];\n  synced: ContainerMetadataSyncResult;\n}\n\ninterface SyncRemoteContainerMetadataInput {\n  buildRotationSnapshot?: (() => Promise<Uint8Array | null>) | undefined;\n  containerId: string;\n  currentDocument: ContainerMetadataState[\"doc\"];\n  documentId: string | null;\n  isCurrent: () => boolean;\n  lastCommitLsn?: string | null | undefined;\n  localVersionVector: string | null;\n  onOutgoingUpdatesMaterialized?:\n    | ((updateIds: readonly string[]) => void)\n    | undefined;\n  onPullContinuationInvalidated?: Parameters<\n    typeof syncRemoteDocument\n  >[0][\"onPullContinuationInvalidated\"];\n  pendingUpdates: readonly PendingUpdateRecord[];\n  persistedState: ContainerMetadataState[\"record\"];\n  pullContinuation?: ContainerMetadataState[\"pullContinuation\"];\n  rekeyPendingUpdate: RekeyPendingUpdate;\n  resolveProjectionUserKey: ProjectionUserKeyResolver;\n  runtime: ContainerMetadataSyncRuntime;\n  targetSecretKey: Uint8Array;\n  writerProjection?: DocumentWriterProjectionResponse | undefined;\n}\n\nfunction createContainerMetadataSyncAttempt(input: {\n  outgoingUpdateCount: number;\n  requestedPullContinuation: ContainerMetadataState[\"pullContinuation\"];\n  requestRecord: ContainerMetadataState[\"record\"];\n  synced: ContainerMetadataSyncResult;\n}): ContainerMetadataSyncAttempt {\n  return {\n    consumedPullContinuation:\n      input.synced.plan.request.pullCursor === undefined\n        ? null\n        : (input.requestedPullContinuation ?? null),\n    outgoingUpdateCount: input.outgoingUpdateCount,\n    requestRecord: input.requestRecord,\n    synced: input.synced,\n  };\n}\n\nexport async function syncRemoteContainerMetadata(\n  input: SyncRemoteContainerMetadataInput,\n): Promise<ContainerMetadataSyncAttempt | null> {\n  const { documentId, isCurrent, runtime } = input;\n  if (!documentId) return null;\n  const author = resolveDocumentCreateAuthor(runtime);\n  if (!author) {\n    runtime.util.log(\n      \"Container contents: skipped metadata sync because the writer context is unavailable.\",\n    );\n    return null;\n  }\n  const execSql = runtime.infra.execSql;\n  const metadataScope = {\n    appKind: CONTAINER_METADATA_APP_KIND,\n    localId: input.containerId,\n  };\n  const synced = await syncRemoteDocument({\n    apiClient: runtime.apiClient,\n    author,\n    buildRotationSnapshot: input.buildRotationSnapshot,\n    documentId,\n    execSql,\n    isRemoteSyncBlocked: runtime.util.isRemoteSyncBlocked,\n    localVersionVector: input.localVersionVector,\n    minLsn: input.lastCommitLsn ?? undefined,\n    ...metadataIncomingUpdateIsolation({\n      currentDocument: input.currentDocument,\n      execSql,\n      isCurrent,\n      logError: runtime.util.logError,\n      metadataScope,\n    }),\n    onOutgoingUpdatesMaterialized: input.onOutgoingUpdatesMaterialized,\n    onPullContinuationInvalidated: input.onPullContinuationInvalidated,\n    onSyncTrace: (line) => runtime.util.log(`Container contents: ${line}`),\n    onTerminalSubmitFailure: async (failure) => {\n      await recordCurrentMetadataSyncFailure({\n        execSql,\n        failure: {\n          attemptedAt: new Date().toISOString(),\n          message: describeDocumentSyncSubmitFailure(failure),\n          status: failure.status,\n        },\n        isCurrent,\n        metadataScope,\n      });\n    },\n    pendingUpdates: input.pendingUpdates,\n    persistedState: input.persistedState,\n    pullContinuation: input.pullContinuation ?? undefined,\n    rekeyPendingUpdate: (rekeyExecSql, updateId) =>\n      isCurrent()\n        ? input.rekeyPendingUpdate(rekeyExecSql, updateId)\n        : Promise.resolve(null),\n    resolveProjectionUserKey: input.resolveProjectionUserKey,\n    resolveWriterPublicKey: createDocumentWriterPublicKeyResolver({\n      logPrefix: \"Container contents\",\n      runtime,\n      writerKeyLabel: \"metadata writer key\",\n    }),\n    stillCurrent: isCurrent,\n    targetSecretKey: input.targetSecretKey,\n    warmReferencedPrincipalPolicies:\n      createRuntimePrincipalPolicyWarmer(runtime),\n    writerProjection: input.writerProjection,\n  }).catch((error: unknown) =>\n    deferRecoverableMetadataSyncError({\n      containerId: input.containerId,\n      error,\n      runtime,\n    }),\n  );\n  if (!synced) return null;\n  return createContainerMetadataSyncAttempt({\n    outgoingUpdateCount: input.pendingUpdates.length,\n    requestedPullContinuation: input.pullContinuation,\n    requestRecord: input.persistedState,\n    synced,\n  });\n}\n"]}

package/workflows/container-contents/metadataStateInstallation.d.ts

@@ -0,0 +1,3 @@
+import type { ContainerDocumentRecord } from "./containerPersistence.js";
+import type { ContainerMetadataState } from "./metadataTypes.js";
+export declare function installContainerMetadataRecord(metadataState: ContainerMetadataState, record: ContainerDocumentRecord): void;

package/workflows/container-contents/metadataStateInstallation.js

@@ -0,0 +1,5 @@
+export function installContainerMetadataRecord(metadataState, record) {
+    metadataState.record = record;
+    metadataState.pullContinuation = record.pullContinuation ?? null;
+}
+//# sourceMappingURL=metadataStateInstallation.js.map

package/workflows/container-contents/metadataStateInstallation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadataStateInstallation.js","sourceRoot":"","sources":["metadataStateInstallation.ts"],"names":[],"mappings":"AAGA,MAAM,UAAU,8BAA8B,CAC5C,aAAqC,EACrC,MAA+B;IAE/B,aAAa,CAAC,MAAM,GAAG,MAAM,CAAC;IAC9B,aAAa,CAAC,gBAAgB,GAAG,MAAM,CAAC,gBAAgB,IAAI,IAAI,CAAC;AACnE,CAAC","sourcesContent":["import type { ContainerDocumentRecord } from \"./containerPersistence\";\nimport type { ContainerMetadataState } from \"./metadataTypes\";\n\nexport function installContainerMetadataRecord(\n  metadataState: ContainerMetadataState,\n  record: ContainerDocumentRecord,\n): void {\n  metadataState.record = record;\n  metadataState.pullContinuation = record.pullContinuation ?? null;\n}\n"]}

package/workflows/container-contents/metadataStateIsolation.js

@@ -0,0 +1,80 @@
+import { encodeVersionVector, exportAllUpdates, exportFullHistorySnapshot, importSnapshot, importUpdates, satisfiesVersionVector, } from "../../internal/loro/index.js";
+import { createContainerMetadataDocument, getDefaultContainerName, readContainerMetadataValue, } from "../../data/containers/containerMetadataDocument.js";
+import { metadataSyncSecurityContextMatches } from "./metadataSyncSettlement.js";
+import { projectionGeneration } from "./projectionGeneration.js";
+function mergeConcurrentMetadataRecord(liveRecord, candidateRecord) {
+    if (metadataSyncSecurityContextMatches(liveRecord, candidateRecord)) {
+        return liveRecord;
+    }
+    // The live document owns the concurrent CRDT frontier, but the candidate
+    // owns the newly committed remote identity. Carry only the fields that
+    // describe the live CRDT history across that identity boundary.
+    return {
+        ...candidateRecord,
+        metadataUpdates: liveRecord.metadataUpdates,
+        snapshotEndVersion: liveRecord.snapshotEndVersion,
+        ...(liveRecord.pendingBaseVersion === undefined
+            ? {}
+            : { pendingBaseVersion: liveRecord.pendingBaseVersion }),
+    };
+}
+/**
+ * Gives an asynchronous sync pass its own mutable metadata projection. Durable
+ * settlement can then repair or replace the candidate without changing the
+ * live store until the caller has rechecked its lifecycle generation.
+ */
+export async function createDetachedContainerMetadataState(metadataState, options = {}) {
+    const doc = await createContainerMetadataDocument(metadataState.container.id);
+    importSnapshot(doc, exportFullHistorySnapshot(metadataState.doc));
+    return {
+        ...metadataState,
+        container: { ...metadataState.container },
+        detachedSource: {
+            metadataVersion: encodeVersionVector(metadataState.doc),
+            writerProjectionGeneration: options.writerProjectionGeneration ??
+                projectionGeneration(metadataState),
+        },
+        doc,
+        record: { ...metadataState.record },
+    };
+}
+export function installDetachedContainerMetadataState(target, candidate, options = {}) {
+    const candidateRecord = options.candidateRecord ?? candidate.record;
+    const liveMetadataVersion = encodeVersionVector(target.doc);
+    const candidateMetadataVersion = encodeVersionVector(candidate.doc);
+    const liveRecord = target.record;
+    const livePullContinuation = target.pullContinuation;
+    const preserveConcurrentLiveMetadata = options.preserveConcurrentMetadataEdit === true &&
+        liveMetadataVersion !== candidate.detachedSource.metadataVersion &&
+        !satisfiesVersionVector(candidateMetadataVersion, liveMetadataVersion);
+    const installedRecord = preserveConcurrentLiveMetadata
+        ? mergeConcurrentMetadataRecord(liveRecord, candidateRecord)
+        : candidateRecord;
+    if (preserveConcurrentLiveMetadata) {
+        importUpdates(target.doc, [exportAllUpdates(candidate.doc)]);
+        const metadata = readContainerMetadataValue(target.doc, getDefaultContainerName(candidate.container.parentId));
+        target.container = {
+            ...candidate.container,
+            icon: metadata.icon,
+            name: metadata.name,
+        };
+    }
+    else {
+        target.container = candidate.container;
+        target.doc = candidate.doc;
+    }
+    // A hint invalidated the live projections while this candidate was out;
+    // its copy may cite a pre-hint manifest, so the live slot stays as the hint
+    // left it and the next metadata write fetches a fresh projection.
+    if (projectionGeneration(target) ===
+        candidate.detachedSource.writerProjectionGeneration)
+        target.metadataWriterProjection = candidate.metadataWriterProjection;
+    target.pullContinuation = preserveConcurrentLiveMetadata
+        ? metadataSyncSecurityContextMatches(liveRecord, candidateRecord)
+            ? livePullContinuation
+            : (candidateRecord.pullContinuation ?? null)
+        : (candidateRecord.pullContinuation ?? null);
+    target.record = installedRecord;
+    target.rekeyOnlyPassCount = candidate.rekeyOnlyPassCount;
+}
+//# sourceMappingURL=metadataStateIsolation.js.map

package/workflows/container-contents/metadataStateIsolation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadataStateIsolation.js","sourceRoot":"","sources":["metadataStateIsolation.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  encodeVersionVector,\n  exportAllUpdates,\n  exportFullHistorySnapshot,\n  importSnapshot,\n  importUpdates,\n  satisfiesVersionVector,\n} from \"@tearleads/loro\";\nimport {\n  createContainerMetadataDocument,\n  getDefaultContainerName,\n  readContainerMetadataValue,\n} from \"../../data/containers/containerMetadataDocument\";\nimport { metadataSyncSecurityContextMatches } from \"./metadataSyncSettlement\";\nimport type { ContainerMetadataState } from \"./metadataTypes\";\nimport { projectionGeneration } from \"./projectionGeneration\";\n\nexport interface DetachedContainerMetadataState extends ContainerMetadataState {\n  readonly detachedSource: {\n    readonly metadataVersion: string;\n    /** The live state's `writerProjectionGeneration` when it was detached. */\n    readonly writerProjectionGeneration: number;\n  };\n}\n\ninterface DetachedContainerMetadataInstallOptions {\n  readonly candidateRecord?: ContainerMetadataState[\"record\"];\n  readonly preserveConcurrentMetadataEdit?: boolean;\n}\n\nfunction mergeConcurrentMetadataRecord(\n  liveRecord: ContainerMetadataState[\"record\"],\n  candidateRecord: ContainerMetadataState[\"record\"],\n): ContainerMetadataState[\"record\"] {\n  if (metadataSyncSecurityContextMatches(liveRecord, candidateRecord)) {\n    return liveRecord;\n  }\n\n  // The live document owns the concurrent CRDT frontier, but the candidate\n  // owns the newly committed remote identity. Carry only the fields that\n  // describe the live CRDT history across that identity boundary.\n  return {\n    ...candidateRecord,\n    metadataUpdates: liveRecord.metadataUpdates,\n    snapshotEndVersion: liveRecord.snapshotEndVersion,\n    ...(liveRecord.pendingBaseVersion === undefined\n      ? {}\n      : { pendingBaseVersion: liveRecord.pendingBaseVersion }),\n  };\n}\n\n/**\n * Gives an asynchronous sync pass its own mutable metadata projection. Durable\n * settlement can then repair or replace the candidate without changing the\n * live store until the caller has rechecked its lifecycle generation.\n */\nexport async function createDetachedContainerMetadataState(\n  metadataState: ContainerMetadataState,\n  options: {\n    /**\n     * The live generation captured when the surrounding operation began, for\n     * callers that awaited (a request, a policy warm-up) before detaching.\n     */\n    readonly writerProjectionGeneration?: number | undefined;\n  } = {},\n): Promise<DetachedContainerMetadataState> {\n  const doc = await createContainerMetadataDocument(metadataState.container.id);\n  importSnapshot(doc, exportFullHistorySnapshot(metadataState.doc));\n  return {\n    ...metadataState,\n    container: { ...metadataState.container },\n    detachedSource: {\n      metadataVersion: encodeVersionVector(metadataState.doc),\n      writerProjectionGeneration:\n        options.writerProjectionGeneration ??\n        projectionGeneration(metadataState),\n    },\n    doc,\n    record: { ...metadataState.record },\n  };\n}\n\nexport function installDetachedContainerMetadataState(\n  target: ContainerMetadataState,\n  candidate: DetachedContainerMetadataState,\n  options: DetachedContainerMetadataInstallOptions = {},\n): void {\n  const candidateRecord = options.candidateRecord ?? candidate.record;\n  const liveMetadataVersion = encodeVersionVector(target.doc);\n  const candidateMetadataVersion = encodeVersionVector(candidate.doc);\n  const liveRecord = target.record;\n  const livePullContinuation = target.pullContinuation;\n  const preserveConcurrentLiveMetadata =\n    options.preserveConcurrentMetadataEdit === true &&\n    liveMetadataVersion !== candidate.detachedSource.metadataVersion &&\n    !satisfiesVersionVector(candidateMetadataVersion, liveMetadataVersion);\n  const installedRecord = preserveConcurrentLiveMetadata\n    ? mergeConcurrentMetadataRecord(liveRecord, candidateRecord)\n    : candidateRecord;\n\n  if (preserveConcurrentLiveMetadata) {\n    importUpdates(target.doc, [exportAllUpdates(candidate.doc)]);\n    const metadata = readContainerMetadataValue(\n      target.doc,\n      getDefaultContainerName(candidate.container.parentId),\n    );\n    target.container = {\n      ...candidate.container,\n      icon: metadata.icon,\n      name: metadata.name,\n    };\n  } else {\n    target.container = candidate.container;\n    target.doc = candidate.doc;\n  }\n  // A hint invalidated the live projections while this candidate was out;\n  // its copy may cite a pre-hint manifest, so the live slot stays as the hint\n  // left it and the next metadata write fetches a fresh projection.\n  if (\n    projectionGeneration(target) ===\n    candidate.detachedSource.writerProjectionGeneration\n  )\n    target.metadataWriterProjection = candidate.metadataWriterProjection;\n  target.pullContinuation = preserveConcurrentLiveMetadata\n    ? metadataSyncSecurityContextMatches(liveRecord, candidateRecord)\n      ? livePullContinuation\n      : (candidateRecord.pullContinuation ?? null)\n    : (candidateRecord.pullContinuation ?? null);\n  target.record = installedRecord;\n  target.rekeyOnlyPassCount = candidate.rekeyOnlyPassCount;\n}\n"]}

package/workflows/container-contents/metadataSyncErrors.js

@@ -0,0 +1,41 @@
+import { isDocumentSyncUpdateIsolationError } from "../../data/documents/shared/documentSyncUpdateIsolation.js";
+import { isKeyingVerificationError, reportKeyingVerificationErrorInCauseChain, } from "../../data/keyingProjectionVerification/error.js";
+import { isPrincipalPolicyNotCachedError } from "../../data/keyingProjectionVerification/principalPolicyVerification.js";
+function isStaleContainerMetadataSecurityStateError(error) {
+    // Signed-state verification failures are terminal integrity incidents, even
+    // when their diagnostic message resembles an ordinary stale-key condition.
+    if (isKeyingVerificationError(error))
+        return false;
+    const message = error instanceof Error ? error.message : "";
+    return (message.startsWith("Document authorizing container KEK path could not be unwrapped") ||
+        message.startsWith("Document content key could not be unwrapped") ||
+        message.startsWith("Document content-key bundle is stale") ||
+        message.startsWith("Document content-key re-wrap KEK is unavailable") ||
+        message.startsWith("Document stale-bundle recovery") ||
+        message === "Document sync target hash mismatch" ||
+        message === "Document sync content-key targets mismatch");
+}
+export async function deferRecoverableMetadataSyncError(input) {
+    if (isDocumentSyncUpdateIsolationError(input.error)) {
+        await reportKeyingVerificationErrorInCauseChain(input.error, input.runtime.util.reportSecurityIncident, {
+            objectId: input.containerId,
+            objectKind: "container",
+            operation: "container.metadata.sync",
+            organizationId: input.runtime.auth.organizationId,
+        });
+        input.runtime.util.log(`Container contents: quarantined incoming metadata updates for ${input.containerId}; deferred this container without blocking later metadata syncs.`);
+        return null;
+    }
+    if (isStaleContainerMetadataSecurityStateError(input.error)) {
+        input.runtime.util.log(`Container contents: deferred metadata sync for ${input.containerId} because its content-key targets are stale.`);
+        return null;
+    }
+    // A cold principal-policy cache is transient: warming already ran and failed
+    // within this attempt. Keep the needing-sync state set for the next trigger.
+    if (isPrincipalPolicyNotCachedError(input.error)) {
+        input.runtime.util.log(`Container contents: deferred metadata sync for ${input.containerId} because a referenced principal policy is not cached yet.`);
+        return null;
+    }
+    throw input.error;
+}
+//# sourceMappingURL=metadataSyncErrors.js.map

package/workflows/container-contents/metadataSyncErrors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadataSyncErrors.js","sourceRoot":"","sources":["metadataSyncErrors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kCAAkC,EAAE,MAAM,yDAAyD,CAAC;AAC7G,OAAO,EACL,yBAAyB,EACzB,yCAAyC,GAC1C,MAAM,+CAA+C,CAAC;AACvD,OAAO,EAAE,+BAA+B,EAAE,MAAM,qEAAqE,CAAC;AAGtH,SAAS,0CAA0C,CAAC,KAAc;IAChE,4EAA4E;IAC5E,2EAA2E;IAC3E,IAAI,yBAAyB,CAAC,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IACnD,MAAM,OAAO,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC;IAE5D,OAAO,CACL,OAAO,CAAC,UAAU,CAChB,gEAAgE,CACjE;QACD,OAAO,CAAC,UAAU,CAAC,6CAA6C,CAAC;QACjE,OAAO,CAAC,UAAU,CAAC,sCAAsC,CAAC;QAC1D,OAAO,CAAC,UAAU,CAAC,iDAAiD,CAAC;QACrE,OAAO,CAAC,UAAU,CAAC,gCAAgC,CAAC;QACpD,OAAO,KAAK,oCAAoC;QAChD,OAAO,KAAK,4CAA4C,CACzD,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,iCAAiC,CAAC,KAUvD;IACC,IAAI,kCAAkC,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;QACpD,MAAM,yCAAyC,CAC7C,KAAK,CAAC,KAAK,EACX,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,sBAAsB,EACzC;YACE,QAAQ,EAAE,KAAK,CAAC,WAAW;YAC3B,UAAU,EAAE,WAAW;YACvB,SAAS,EAAE,yBAAyB;YACpC,cAAc,EAAE,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,cAAc;SAClD,CACF,CAAC;QACF,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,CACpB,iEAAiE,KAAK,CAAC,WAAW,kEAAkE,CACrJ,CAAC;QACF,OAAO,IAAI,CAAC;IACd,CAAC;IAED,IAAI,0CAA0C,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;QAC5D,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,CACpB,kDAAkD,KAAK,CAAC,WAAW,6CAA6C,CACjH,CAAC;QACF,OAAO,IAAI,CAAC;IACd,CAAC;IAED,6EAA6E;IAC7E,6EAA6E;IAC7E,IAAI,+BAA+B,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;QACjD,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,CACpB,kDAAkD,KAAK,CAAC,WAAW,2DAA2D,CAC/H,CAAC;QACF,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,KAAK,CAAC,KAAK,CAAC;AACpB,CAAC","sourcesContent":["import { isDocumentSyncUpdateIsolationError } from \"../../data/documents/shared/documentSyncUpdateIsolation\";\nimport {\n  isKeyingVerificationError,\n  reportKeyingVerificationErrorInCauseChain,\n} from \"../../data/keyingProjectionVerification/error\";\nimport { isPrincipalPolicyNotCachedError } from \"../../data/keyingProjectionVerification/principalPolicyVerification\";\nimport type { SecurityIncidentReporter } from \"../../data/securityIncidents\";\n\nfunction isStaleContainerMetadataSecurityStateError(error: unknown): boolean {\n  // Signed-state verification failures are terminal integrity incidents, even\n  // when their diagnostic message resembles an ordinary stale-key condition.\n  if (isKeyingVerificationError(error)) return false;\n  const message = error instanceof Error ? error.message : \"\";\n\n  return (\n    message.startsWith(\n      \"Document authorizing container KEK path could not be unwrapped\",\n    ) ||\n    message.startsWith(\"Document content key could not be unwrapped\") ||\n    message.startsWith(\"Document content-key bundle is stale\") ||\n    message.startsWith(\"Document content-key re-wrap KEK is unavailable\") ||\n    message.startsWith(\"Document stale-bundle recovery\") ||\n    message === \"Document sync target hash mismatch\" ||\n    message === \"Document sync content-key targets mismatch\"\n  );\n}\n\nexport async function deferRecoverableMetadataSyncError(input: {\n  containerId: string;\n  error: unknown;\n  runtime: {\n    auth: { organizationId: string | null };\n    util: {\n      log: (message: string) => void;\n      reportSecurityIncident: SecurityIncidentReporter;\n    };\n  };\n}): Promise<null> {\n  if (isDocumentSyncUpdateIsolationError(input.error)) {\n    await reportKeyingVerificationErrorInCauseChain(\n      input.error,\n      input.runtime.util.reportSecurityIncident,\n      {\n        objectId: input.containerId,\n        objectKind: \"container\",\n        operation: \"container.metadata.sync\",\n        organizationId: input.runtime.auth.organizationId,\n      },\n    );\n    input.runtime.util.log(\n      `Container contents: quarantined incoming metadata updates for ${input.containerId}; deferred this container without blocking later metadata syncs.`,\n    );\n    return null;\n  }\n\n  if (isStaleContainerMetadataSecurityStateError(input.error)) {\n    input.runtime.util.log(\n      `Container contents: deferred metadata sync for ${input.containerId} because its content-key targets are stale.`,\n    );\n    return null;\n  }\n\n  // A cold principal-policy cache is transient: warming already ran and failed\n  // within this attempt. Keep the needing-sync state set for the next trigger.\n  if (isPrincipalPolicyNotCachedError(input.error)) {\n    input.runtime.util.log(\n      `Container contents: deferred metadata sync for ${input.containerId} because a referenced principal policy is not cached yet.`,\n    );\n    return null;\n  }\n\n  throw input.error;\n}\n"]}

package/workflows/container-contents/metadataSyncFollowup.js

@@ -0,0 +1,11 @@
+export function shouldRequestContainerMetadataFollowup(input) {
+    const { persisted } = input;
+    if (persisted.syncIdentitySuperseded === true ||
+        persisted.pullContinuationSuperseded === true ||
+        persisted.record.pullContinuation != null ||
+        persisted.record.pullContinuationRecoveryRequired === true) {
+        return true;
+    }
+    return input.settleOutgoingPass();
+}
+//# sourceMappingURL=metadataSyncFollowup.js.map

package/workflows/container-contents/metadataSyncFollowup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadataSyncFollowup.js","sourceRoot":"","sources":["metadataSyncFollowup.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,sCAAsC,CAAC,KAMtD;IACC,MAAM,EAAE,SAAS,EAAE,GAAG,KAAK,CAAC;IAC5B,IACE,SAAS,CAAC,sBAAsB,KAAK,IAAI;QACzC,SAAS,CAAC,0BAA0B,KAAK,IAAI;QAC7C,SAAS,CAAC,MAAM,CAAC,gBAAgB,IAAI,IAAI;QACzC,SAAS,CAAC,MAAM,CAAC,gCAAgC,KAAK,IAAI,EAC1D,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IACD,OAAO,KAAK,CAAC,kBAAkB,EAAE,CAAC;AACpC,CAAC","sourcesContent":["import type { SyncedContainerMetadataState } from \"./metadataTypes\";\n\nexport function shouldRequestContainerMetadataFollowup(input: {\n  persisted: Pick<\n    SyncedContainerMetadataState,\n    \"pullContinuationSuperseded\" | \"record\" | \"syncIdentitySuperseded\"\n  >;\n  settleOutgoingPass: () => boolean;\n}): boolean {\n  const { persisted } = input;\n  if (\n    persisted.syncIdentitySuperseded === true ||\n    persisted.pullContinuationSuperseded === true ||\n    persisted.record.pullContinuation != null ||\n    persisted.record.pullContinuationRecoveryRequired === true\n  ) {\n    return true;\n  }\n  return input.settleOutgoingPass();\n}\n"]}

package/workflows/container-contents/metadataSyncRegistrations.d.ts

@@ -0,0 +1,4 @@
+export declare function preRegisterMaterializedContainerMetadataUpdateIds(locallyAcceptedUpdateIds: Set<string> | undefined, registeredUpdateIds: string[], materializedUpdateIds: readonly string[]): void;
+declare function discardUnacceptedContainerMetadataUpdateIds(locallyAcceptedUpdateIds: Set<string> | undefined, sentUpdateIds: readonly string[], acceptedUpdateIds: readonly string[]): void;
+export declare function cleanupContainerMetadataRegistrationsOnFailure<T>(locallyAcceptedUpdateIds: Set<string> | undefined, sentUpdateIds: readonly string[], task: () => Promise<T | null>): Promise<T | null>;
+export { discardUnacceptedContainerMetadataUpdateIds };

package/workflows/container-contents/metadataSyncRegistrations.js

@@ -0,0 +1,35 @@
+export function preRegisterMaterializedContainerMetadataUpdateIds(locallyAcceptedUpdateIds, registeredUpdateIds, materializedUpdateIds) {
+    const alreadyRegistered = new Set(registeredUpdateIds);
+    for (const updateId of materializedUpdateIds) {
+        if (alreadyRegistered.has(updateId))
+            continue;
+        alreadyRegistered.add(updateId);
+        registeredUpdateIds.push(updateId);
+        locallyAcceptedUpdateIds?.add(updateId);
+    }
+}
+function discardUnacceptedContainerMetadataUpdateIds(locallyAcceptedUpdateIds, sentUpdateIds, acceptedUpdateIds) {
+    if (!locallyAcceptedUpdateIds)
+        return;
+    const acceptedOutgoing = new Set(acceptedUpdateIds);
+    for (const sentUpdateId of sentUpdateIds) {
+        if (!acceptedOutgoing.has(sentUpdateId)) {
+            locallyAcceptedUpdateIds.delete(sentUpdateId);
+        }
+    }
+}
+export async function cleanupContainerMetadataRegistrationsOnFailure(locallyAcceptedUpdateIds, sentUpdateIds, task) {
+    try {
+        const result = await task();
+        if (result === null) {
+            discardUnacceptedContainerMetadataUpdateIds(locallyAcceptedUpdateIds, sentUpdateIds, []);
+        }
+        return result;
+    }
+    catch (error) {
+        discardUnacceptedContainerMetadataUpdateIds(locallyAcceptedUpdateIds, sentUpdateIds, []);
+        throw error;
+    }
+}
+export { discardUnacceptedContainerMetadataUpdateIds };
+//# sourceMappingURL=metadataSyncRegistrations.js.map

package/workflows/container-contents/metadataSyncRegistrations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadataSyncRegistrations.js","sourceRoot":"","sources":["metadataSyncRegistrations.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,iDAAiD,CAC/D,wBAAiD,EACjD,mBAA6B,EAC7B,qBAAwC;IAExC,MAAM,iBAAiB,GAAG,IAAI,GAAG,CAAC,mBAAmB,CAAC,CAAC;IACvD,KAAK,MAAM,QAAQ,IAAI,qBAAqB,EAAE,CAAC;QAC7C,IAAI,iBAAiB,CAAC,GAAG,CAAC,QAAQ,CAAC;YAAE,SAAS;QAC9C,iBAAiB,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QAChC,mBAAmB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACnC,wBAAwB,EAAE,GAAG,CAAC,QAAQ,CAAC,CAAC;IAC1C,CAAC;AACH,CAAC;AAED,SAAS,2CAA2C,CAClD,wBAAiD,EACjD,aAAgC,EAChC,iBAAoC;IAEpC,IAAI,CAAC,wBAAwB;QAAE,OAAO;IACtC,MAAM,gBAAgB,GAAG,IAAI,GAAG,CAAC,iBAAiB,CAAC,CAAC;IACpD,KAAK,MAAM,YAAY,IAAI,aAAa,EAAE,CAAC;QACzC,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,YAAY,CAAC,EAAE,CAAC;YACxC,wBAAwB,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;QAChD,CAAC;IACH,CAAC;AACH,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,8CAA8C,CAClE,wBAAiD,EACjD,aAAgC,EAChC,IAA6B;IAE7B,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;QAC5B,IAAI,MAAM,KAAK,IAAI,EAAE,CAAC;YACpB,2CAA2C,CACzC,wBAAwB,EACxB,aAAa,EACb,EAAE,CACH,CAAC;QACJ,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,2CAA2C,CACzC,wBAAwB,EACxB,aAAa,EACb,EAAE,CACH,CAAC;QACF,MAAM,KAAK,CAAC;IACd,CAAC;AACH,CAAC;AAED,OAAO,EAAE,2CAA2C,EAAE,CAAC","sourcesContent":["export function preRegisterMaterializedContainerMetadataUpdateIds(\n  locallyAcceptedUpdateIds: Set<string> | undefined,\n  registeredUpdateIds: string[],\n  materializedUpdateIds: readonly string[],\n): void {\n  const alreadyRegistered = new Set(registeredUpdateIds);\n  for (const updateId of materializedUpdateIds) {\n    if (alreadyRegistered.has(updateId)) continue;\n    alreadyRegistered.add(updateId);\n    registeredUpdateIds.push(updateId);\n    locallyAcceptedUpdateIds?.add(updateId);\n  }\n}\n\nfunction discardUnacceptedContainerMetadataUpdateIds(\n  locallyAcceptedUpdateIds: Set<string> | undefined,\n  sentUpdateIds: readonly string[],\n  acceptedUpdateIds: readonly string[],\n): void {\n  if (!locallyAcceptedUpdateIds) return;\n  const acceptedOutgoing = new Set(acceptedUpdateIds);\n  for (const sentUpdateId of sentUpdateIds) {\n    if (!acceptedOutgoing.has(sentUpdateId)) {\n      locallyAcceptedUpdateIds.delete(sentUpdateId);\n    }\n  }\n}\n\nexport async function cleanupContainerMetadataRegistrationsOnFailure<T>(\n  locallyAcceptedUpdateIds: Set<string> | undefined,\n  sentUpdateIds: readonly string[],\n  task: () => Promise<T | null>,\n): Promise<T | null> {\n  try {\n    const result = await task();\n    if (result === null) {\n      discardUnacceptedContainerMetadataUpdateIds(\n        locallyAcceptedUpdateIds,\n        sentUpdateIds,\n        [],\n      );\n    }\n    return result;\n  } catch (error) {\n    discardUnacceptedContainerMetadataUpdateIds(\n      locallyAcceptedUpdateIds,\n      sentUpdateIds,\n      [],\n    );\n    throw error;\n  }\n}\n\nexport { discardUnacceptedContainerMetadataUpdateIds };\n"]}

package/workflows/container-contents/metadataSyncSettlement.d.ts

@@ -0,0 +1,13 @@
+import type { DocumentSyncPullContinuation } from "../../data/documents/shared/syncPagination.js";
+import type { ContainerDocumentRecord as DocumentRecord } from "./containerPersistence.js";
+import type { ContainerMetadataState } from "./metadataTypes.js";
+export interface ExpectedContainerMetadataSyncState {
+    pullContinuation: DocumentSyncPullContinuation | null;
+    record: DocumentRecord;
+}
+export declare function sameNullableMetadataValue(left: string | null | undefined, right: string | null | undefined): boolean;
+export declare function metadataSyncSecurityContextMatches(current: DocumentRecord | null, expected: DocumentRecord): boolean;
+export declare function replaceSupersededMetadataIdentity(input: {
+    durableRecord: DocumentRecord | null;
+    metadataState: ContainerMetadataState;
+}): Promise<void>;

package/workflows/container-contents/metadataSyncSettlement.js

@@ -0,0 +1,27 @@
+import { base64ToBytes } from "../../internal/encoding/index.js";
+import { importUpdates } from "../../internal/loro/index.js";
+import { createContainerMetadataDocument } from "../../data/containers/containerMetadataDocument.js";
+export function sameNullableMetadataValue(left, right) {
+    return (left ?? null) === (right ?? null);
+}
+export function metadataSyncSecurityContextMatches(current, expected) {
+    return (current !== null &&
+        current.id === expected.id &&
+        current.documentId === expected.documentId &&
+        current.accessEpoch === expected.accessEpoch &&
+        sameNullableMetadataValue(current.accessStateHash, expected.accessStateHash) &&
+        sameNullableMetadataValue(current.contentKeyBundle, expected.contentKeyBundle) &&
+        sameNullableMetadataValue(current.documentKekTargets, expected.documentKekTargets) &&
+        sameNullableMetadataValue(current.documentManifestBundle, expected.documentManifestBundle));
+}
+export async function replaceSupersededMetadataIdentity(input) {
+    const replacementDoc = await createContainerMetadataDocument(input.metadataState.container.id);
+    if (input.durableRecord?.metadataUpdates) {
+        importUpdates(replacementDoc, [
+            base64ToBytes(input.durableRecord.metadataUpdates),
+        ]);
+    }
+    input.metadataState.doc = replacementDoc;
+    input.metadataState.metadataWriterProjection = null;
+}
+//# sourceMappingURL=metadataSyncSettlement.js.map

package/workflows/container-contents/metadataSyncSettlement.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadataSyncSettlement.js","sourceRoot":"","sources":["metadataSyncSettlement.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,+BAA+B,EAAE,MAAM,iDAAiD,CAAC;AAUlG,MAAM,UAAU,yBAAyB,CACvC,IAA+B,EAC/B,KAAgC;IAEhC,OAAO,CAAC,IAAI,IAAI,IAAI,CAAC,KAAK,CAAC,KAAK,IAAI,IAAI,CAAC,CAAC;AAC5C,CAAC;AAED,MAAM,UAAU,kCAAkC,CAChD,OAA8B,EAC9B,QAAwB;IAExB,OAAO,CACL,OAAO,KAAK,IAAI;QAChB,OAAO,CAAC,EAAE,KAAK,QAAQ,CAAC,EAAE;QAC1B,OAAO,CAAC,UAAU,KAAK,QAAQ,CAAC,UAAU;QAC1C,OAAO,CAAC,WAAW,KAAK,QAAQ,CAAC,WAAW;QAC5C,yBAAyB,CACvB,OAAO,CAAC,eAAe,EACvB,QAAQ,CAAC,eAAe,CACzB;QACD,yBAAyB,CACvB,OAAO,CAAC,gBAAgB,EACxB,QAAQ,CAAC,gBAAgB,CAC1B;QACD,yBAAyB,CACvB,OAAO,CAAC,kBAAkB,EAC1B,QAAQ,CAAC,kBAAkB,CAC5B;QACD,yBAAyB,CACvB,OAAO,CAAC,sBAAsB,EAC9B,QAAQ,CAAC,sBAAsB,CAChC,CACF,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,iCAAiC,CAAC,KAGvD;IACC,MAAM,cAAc,GAAG,MAAM,+BAA+B,CAC1D,KAAK,CAAC,aAAa,CAAC,SAAS,CAAC,EAAE,CACjC,CAAC;IACF,IAAI,KAAK,CAAC,aAAa,EAAE,eAAe,EAAE,CAAC;QACzC,aAAa,CAAC,cAAc,EAAE;YAC5B,aAAa,CAAC,KAAK,CAAC,aAAa,CAAC,eAAe,CAAC;SACnD,CAAC,CAAC;IACL,CAAC;IACD,KAAK,CAAC,aAAa,CAAC,GAAG,GAAG,cAAc,CAAC;IACzC,KAAK,CAAC,aAAa,CAAC,wBAAwB,GAAG,IAAI,CAAC;AACtD,CAAC","sourcesContent":["import { base64ToBytes } from \"@tearleads/encoding\";\nimport { importUpdates } from \"@tearleads/loro\";\nimport { createContainerMetadataDocument } from \"../../data/containers/containerMetadataDocument\";\nimport type { DocumentSyncPullContinuation } from \"../../data/documents/shared/syncPagination\";\nimport type { ContainerDocumentRecord as DocumentRecord } from \"./containerPersistence\";\nimport type { ContainerMetadataState } from \"./metadataTypes\";\n\nexport interface ExpectedContainerMetadataSyncState {\n  pullContinuation: DocumentSyncPullContinuation | null;\n  record: DocumentRecord;\n}\n\nexport function sameNullableMetadataValue(\n  left: string | null | undefined,\n  right: string | null | undefined,\n): boolean {\n  return (left ?? null) === (right ?? null);\n}\n\nexport function metadataSyncSecurityContextMatches(\n  current: DocumentRecord | null,\n  expected: DocumentRecord,\n): boolean {\n  return (\n    current !== null &&\n    current.id === expected.id &&\n    current.documentId === expected.documentId &&\n    current.accessEpoch === expected.accessEpoch &&\n    sameNullableMetadataValue(\n      current.accessStateHash,\n      expected.accessStateHash,\n    ) &&\n    sameNullableMetadataValue(\n      current.contentKeyBundle,\n      expected.contentKeyBundle,\n    ) &&\n    sameNullableMetadataValue(\n      current.documentKekTargets,\n      expected.documentKekTargets,\n    ) &&\n    sameNullableMetadataValue(\n      current.documentManifestBundle,\n      expected.documentManifestBundle,\n    )\n  );\n}\n\nexport async function replaceSupersededMetadataIdentity(input: {\n  durableRecord: DocumentRecord | null;\n  metadataState: ContainerMetadataState;\n}): Promise<void> {\n  const replacementDoc = await createContainerMetadataDocument(\n    input.metadataState.container.id,\n  );\n  if (input.durableRecord?.metadataUpdates) {\n    importUpdates(replacementDoc, [\n      base64ToBytes(input.durableRecord.metadataUpdates),\n    ]);\n  }\n  input.metadataState.doc = replacementDoc;\n  input.metadataState.metadataWriterProjection = null;\n}\n"]}

package/workflows/container-contents/metadataTypes.d.ts

@@ -0,0 +1,54 @@
+import type { DocumentWriterProjectionResponse } from "../../internal/validators/response/index.js";
+import type { ContainerMetadataDocument } from "../../data/containers/containerMetadataDocument.js";
+import type { DocumentSyncPullContinuation } from "../../data/documents/shared/syncPagination.js";
+import type { ContainerMetadataRecord } from "../../data/persistence/container-contents/containerContentsPersistence.js";
+import type { ContainerRecord } from "../../data/persistence/containers/containerPersistence.js";
+export interface ContainerMetadataState {
+    container: ContainerRecord;
+    doc: ContainerMetadataDocument;
+    metadataWriterProjection?: DocumentWriterProjectionResponse | null | undefined;
+    /** See `ContainerState.writerProjectionGeneration`; shared by both caches. */
+    writerProjectionGeneration?: number | undefined;
+    /** Durable continuation mirrored from the metadata document record. */
+    pullContinuation?: DocumentSyncPullContinuation | null | undefined;
+    record: ContainerMetadataRecord;
+    /**
+     * Consecutive completed sync passes that re-keyed conflicted pending updates
+     * without settling anything; bounds the rekey-driven follow-up sync. See
+     * shouldReArmAfterOutgoingSettlement.
+     */
+    rekeyOnlyPassCount?: number | undefined;
+}
+export interface ContainerMetadataPatch {
+    accessEpoch: number;
+    accessStateHash: string | null;
+    effectiveAccessLevel: ContainerRecord["effectiveAccessLevel"];
+    documentId: string | null;
+    icon: string | null;
+    lastCommitLsn: string | null;
+    metadataDocumentId: string | null;
+    systemSlot: ContainerRecord["systemSlot"];
+    metadataUpdates: string;
+    name: string;
+    organizationId: string;
+    parentId: string | null;
+    pullContinuation: DocumentSyncPullContinuation | null;
+    contentKeyBundle: string | null;
+    documentKekTargets: string | null;
+    documentManifestBundle: string | null;
+}
+export interface PersistedContainerMetadataState {
+    container: ContainerRecord;
+    createIntentSettled?: true;
+    moveIntentSettled?: true;
+    mutationSuperseded?: true;
+    pullContinuationSuperseded?: true;
+    record: ContainerMetadataRecord;
+    syncIdentitySuperseded?: true;
+}
+export interface SyncedContainerMetadataState extends PersistedContainerMetadataState {
+    shouldRequestFollowupSync: boolean;
+}
+export interface MissingContainerMetadataState {
+    missing: true;
+}

package/workflows/container-contents/metadataTypes.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=metadataTypes.js.map

package/workflows/container-contents/metadataTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadataTypes.js","sourceRoot":"","sources":["metadataTypes.ts"],"names":[],"mappings":"","sourcesContent":["import type { DocumentWriterProjectionResponse } from \"@tearleads/validators/response\";\nimport type { ContainerMetadataDocument } from \"../../data/containers/containerMetadataDocument\";\nimport type { DocumentSyncPullContinuation } from \"../../data/documents/shared/syncPagination\";\nimport type { ContainerMetadataRecord } from \"../../data/persistence/container-contents/containerContentsPersistence\";\nimport type { ContainerRecord } from \"../../data/persistence/containers/containerPersistence\";\n\nexport interface ContainerMetadataState {\n  container: ContainerRecord;\n  doc: ContainerMetadataDocument;\n  metadataWriterProjection?:\n    | DocumentWriterProjectionResponse\n    | null\n    | undefined;\n  /** See `ContainerState.writerProjectionGeneration`; shared by both caches. */\n  writerProjectionGeneration?: number | undefined;\n  /** Durable continuation mirrored from the metadata document record. */\n  pullContinuation?: DocumentSyncPullContinuation | null | undefined;\n  record: ContainerMetadataRecord;\n  /**\n   * Consecutive completed sync passes that re-keyed conflicted pending updates\n   * without settling anything; bounds the rekey-driven follow-up sync. See\n   * shouldReArmAfterOutgoingSettlement.\n   */\n  rekeyOnlyPassCount?: number | undefined;\n}\n\nexport interface ContainerMetadataPatch {\n  accessEpoch: number;\n  accessStateHash: string | null;\n  effectiveAccessLevel: ContainerRecord[\"effectiveAccessLevel\"];\n  documentId: string | null;\n  icon: string | null;\n  lastCommitLsn: string | null;\n  metadataDocumentId: string | null;\n  systemSlot: ContainerRecord[\"systemSlot\"];\n  metadataUpdates: string;\n  name: string;\n  organizationId: string;\n  parentId: string | null;\n  pullContinuation: DocumentSyncPullContinuation | null;\n  contentKeyBundle: string | null;\n  documentKekTargets: string | null;\n  documentManifestBundle: string | null;\n}\n\nexport interface PersistedContainerMetadataState {\n  container: ContainerRecord;\n  createIntentSettled?: true;\n  moveIntentSettled?: true;\n  mutationSuperseded?: true;\n  pullContinuationSuperseded?: true;\n  record: ContainerMetadataRecord;\n  syncIdentitySuperseded?: true;\n}\n\nexport interface SyncedContainerMetadataState\n  extends PersistedContainerMetadataState {\n  shouldRequestFollowupSync: boolean;\n}\n\nexport interface MissingContainerMetadataState {\n  missing: true;\n}\n"]}