@tearleads/client-sdk 0.0.0-stage → 0.1.11

package/data/keyingProjectionVerification.js

@@ -0,0 +1,16 @@
+import { requireTrustedUserIdentityResolver } from "./trustedUserIdentity/requiredResolver.js";
+export { resolveEventContainerPaths } from "./keyingProjectionVerification/documentDependencyPaths.js";
+export { readAccessEvent, readRecordString, readRequiredRecordValue, } from "./keyingProjectionVerification/readers.js";
+export { isProjectionVerificationCancelledError, nullOnProjectionVerificationCancellation, } from "./keyingProjectionVerification/types.js";
+export function requireProjectionUserKeyResolver(resolveProjectionUserKey, label) {
+    if (!resolveProjectionUserKey) {
+        throw new Error(`${label} requires projection key verification`);
+    }
+    // A ProjectionUserKey is a TrustedUserIdentity, so the shared adapter
+    // provides the untrusted-shape and wrong-user guards (with identity caching).
+    return requireTrustedUserIdentityResolver(resolveProjectionUserKey);
+}
+export { collectContainerWriterProjectionPrincipalPolicies, verifyContainerWriterProjection, } from "./keyingProjectionVerification/containerProjectionVerification.js";
+export { verifyDocumentWriterProjection, verifyDocumentWriterProjectionAuthorization, } from "./keyingProjectionVerification/documentProjectionVerification.js";
+export { verifyDocumentPurgeProof, verifyDocumentPurgeProofBaseline, } from "./keyingProjectionVerification/documentPurgeProofVerification.js";
+//# sourceMappingURL=keyingProjectionVerification.js.map

package/data/keyingProjectionVerification.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyingProjectionVerification.js","sourceRoot":"","sources":["keyingProjectionVerification.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kCAAkC,EAAE,MAAM,wCAAwC,CAAC;AAE5F,OAAO,EAAE,0BAA0B,EAAE,MAAM,wDAAwD,CAAC;AACpG,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,uBAAuB,GACxB,MAAM,wCAAwC,CAAC;AAShD,OAAO,EACL,sCAAsC,EACtC,wCAAwC,GACzC,MAAM,sCAAsC,CAAC;AAE9C,MAAM,UAAU,gCAAgC,CAC9C,wBAAsE,EACtE,KAAa;IAEb,IAAI,CAAC,wBAAwB,EAAE,CAAC;QAC9B,MAAM,IAAI,KAAK,CAAC,GAAG,KAAK,uCAAuC,CAAC,CAAC;IACnE,CAAC;IAED,sEAAsE;IACtE,8EAA8E;IAC9E,OAAO,kCAAkC,CAAC,wBAAwB,CAAC,CAAC;AACtE,CAAC;AAED,OAAO,EACL,iDAAiD,EACjD,+BAA+B,GAChC,MAAM,gEAAgE,CAAC;AACxE,OAAO,EAEL,8BAA8B,EAC9B,2CAA2C,GAC5C,MAAM,+DAA+D,CAAC;AACvE,OAAO,EACL,wBAAwB,EACxB,gCAAgC,GACjC,MAAM,+DAA+D,CAAC","sourcesContent":["import type { ProjectionUserKeyResolver } from \"./keyingProjectionVerification/types\";\nimport { requireTrustedUserIdentityResolver } from \"./trustedUserIdentity/requiredResolver\";\n\nexport { resolveEventContainerPaths } from \"./keyingProjectionVerification/documentDependencyPaths\";\nexport {\n  readAccessEvent,\n  readRecordString,\n  readRequiredRecordValue,\n} from \"./keyingProjectionVerification/readers\";\n\nexport type {\n  PrincipalPolicyBundleCacheRequest,\n  PrincipalPolicyCache,\n  ProjectionUserKey,\n  ProjectionUserKeyResolver,\n  ReferencedPrincipalPolicyWarmer,\n} from \"./keyingProjectionVerification/types\";\nexport {\n  isProjectionVerificationCancelledError,\n  nullOnProjectionVerificationCancellation,\n} from \"./keyingProjectionVerification/types\";\n\nexport function requireProjectionUserKeyResolver(\n  resolveProjectionUserKey: ProjectionUserKeyResolver | null | undefined,\n  label: string,\n): ProjectionUserKeyResolver {\n  if (!resolveProjectionUserKey) {\n    throw new Error(`${label} requires projection key verification`);\n  }\n\n  // A ProjectionUserKey is a TrustedUserIdentity, so the shared adapter\n  // provides the untrusted-shape and wrong-user guards (with identity caching).\n  return requireTrustedUserIdentityResolver(resolveProjectionUserKey);\n}\n\nexport {\n  collectContainerWriterProjectionPrincipalPolicies,\n  verifyContainerWriterProjection,\n} from \"./keyingProjectionVerification/containerProjectionVerification\";\nexport {\n  type DocumentWriterProjectionAuthorization,\n  verifyDocumentWriterProjection,\n  verifyDocumentWriterProjectionAuthorization,\n} from \"./keyingProjectionVerification/documentProjectionVerification\";\nexport {\n  verifyDocumentPurgeProof,\n  verifyDocumentPurgeProofBaseline,\n} from \"./keyingProjectionVerification/documentPurgeProofVerification\";\n"]}

package/data/persistence/container-contents/containerContentsPersistence.d.ts

@@ -0,0 +1,4 @@
+export type { ContainerContentsPersistence, ContainerCreateIntentRecord, ContainerHydrationTombstone, ContainerMetadataRecord, ContainerMoveIntentRecord, LocalRootDescendantReparentInput, StoredContainerState, } from "./containerContentsPersistenceTypes.js";
+export { CONTAINER_METADATA_APP_KIND } from "./dormantContainerMetadata.js";
+import type { ContainerContentsPersistence } from "./containerContentsPersistenceTypes.js";
+export declare const sqlContainerContentsPersistence: ContainerContentsPersistence;

package/data/persistence/container-contents/containerContentsPersistence.js

@@ -0,0 +1,199 @@
+import { and, eq, inArray } from "drizzle-orm";
+import { enqueueDocumentPendingUpdate, ensureDocumentProjectionTables, ensureDocumentTables, } from "../../sqlite/documentPersistence.js";
+import { containerCreateIntentTables, containerHydrationTombstones, containerMoveIntentTables, containers, documentContainerProjectionTables, documentPendingUpdates, } from "../../sqlite/schema.js";
+import { getClientSQLitePersistenceRuntime, } from "../../sqlite/sqlitePersistenceRuntime.js";
+import { ensureSqlTables, runOncePerConnection, runSerializedSqlMutation, } from "../../sqlite/sqlSchema.js";
+import { ensureContainerTables, loadContainerById, loadContainers as loadContainerRecords, } from "../containers/containerPersistence.js";
+import { sqlContainerSyncWatermarkPersistence } from "../containers/containerSyncWatermarkPersistence.js";
+import { getLatestTimestamp } from "../latestTimestamp.js";
+import { CONTAINER_METADATA_APP_KIND } from "./dormantContainerMetadata.js";
+import { claimDormantMetadataSweepAttempt, completeDormantMetadataSweepRequest, listDormantMetadataSweepRequests, } from "./dormantMetadataSweep.js";
+export { CONTAINER_METADATA_APP_KIND } from "./dormantContainerMetadata.js";
+import { deleteStoredContainers } from "./containerDeletionPersistence.js";
+import { commitStoredHydratedContainer, loadStoredHeldContainerBinding, } from "./containerHydrationPersistence.js";
+import { containerIntentPersistence } from "./containerIntentPersistence.js";
+import { commitStoredMetadataMutation, settleStoredMetadataPendingUpdates, } from "./containerMetadataMutationPersistence.js";
+import { containerMetadataPullContinuationPersistence } from "./containerMetadataPullContinuationPersistence.js";
+import { getContainerMetadataScope, saveContainerContentsContainerRows, selectContainerMetadataRecord, } from "./containerMetadataRows.js";
+import { abandonStoredMoveIntentRevision } from "./containerMoveAbandonPersistence.js";
+import { containerPendingUpdatePersistence } from "./containerPendingUpdatePersistence.js";
+import { rebindStoredHeldContainer } from "./containerRebindPersistence.js";
+import { containerReconcilePersistence } from "./containerReconcilePersistence.js";
+import { isSupersededContainerBinding } from "./supersededContainerBindings.js";
+async function saveStoredContainer(execSql, container, record, options) {
+    return runSerializedSqlMutation(execSql, async (lockedExecSql) => {
+        const localUpdatedAt = options?.localUpdatedAt ?? options?.updatedAt ?? new Date().toISOString();
+        const runtime = getClientSQLitePersistenceRuntime(lockedExecSql);
+        const save = async (tx) => {
+            const saved = await saveContainerContentsContainerRows({
+                container,
+                createIntent: options?.createIntent,
+                moveIntent: options?.moveIntent,
+                record,
+                serverTimestamps: options?.serverTimestamps,
+                tx,
+                localUpdatedAt,
+            });
+            if (options && "pendingUpdate" in options) {
+                await enqueueDocumentPendingUpdate(lockedExecSql, getContainerMetadataScope(container.id), options.pendingUpdate);
+            }
+            return saved;
+        };
+        if (!options?.stillCurrent) {
+            return runtime.transaction(save);
+        }
+        const outcome = await runtime.guardedTransaction(save, options.stillCurrent, { behavior: "immediate" });
+        // Guarded callers recheck the same monotonic generation immediately after
+        // this await. Returning the untouched candidate keeps the long-standing
+        // non-null save contract while the transaction itself remains rolled back.
+        return outcome.result ?? container;
+    });
+}
+async function hasPendingContainerMetadataUpdates(input) {
+    const rows = await input.tx
+        .select({ id: documentPendingUpdates.id })
+        .from(documentPendingUpdates)
+        .where(and(eq(documentPendingUpdates.appKind, CONTAINER_METADATA_APP_KIND), eq(documentPendingUpdates.localId, input.containerId)))
+        .limit(1);
+    return rows.length > 0;
+}
+export const sqlContainerContentsPersistence = {
+    ...containerIntentPersistence,
+    ...containerMetadataPullContinuationPersistence,
+    commitHydratedContainer: commitStoredHydratedContainer,
+    commitMetadataMutation: commitStoredMetadataMutation,
+    settleAcceptedMetadataPendingUpdates: settleStoredMetadataPendingUpdates,
+    listDormantMetadataSweepRequests,
+    ...containerPendingUpdatePersistence,
+    ...containerReconcilePersistence,
+    claimDormantMetadataSweepAttempt,
+    completeDormantMetadataSweepRequest,
+    async containerExists(execSql, containerId) {
+        await sqlContainerContentsPersistence.ensureSchema(execSql);
+        const { db } = getClientSQLitePersistenceRuntime(execSql);
+        const rows = await db
+            .select({ id: containers.id })
+            .from(containers)
+            .where(eq(containers.id, containerId))
+            .limit(1);
+        return rows.length > 0;
+    },
+    async deleteContainer(execSql, containerId, options) {
+        await sqlContainerContentsPersistence.deleteContainers(execSql, [
+            {
+                containerId,
+                reason: options?.reason ?? "deleted",
+                updatedAt: options?.updatedAt ?? new Date().toISOString(),
+            },
+        ]);
+    },
+    async deleteContainers(execSql, removals, options) {
+        return deleteStoredContainers(execSql, removals, options);
+    },
+    async ensureSchema(execSql) {
+        // Once ensured on this connection, skip the outer mutation lock entirely:
+        // ensureSchema runs on every query path, and re-acquiring the lock just to
+        // no-op would queue reads behind unrelated writes.
+        await runOncePerConnection(execSql, "ensure:container-contents", () => runSerializedSqlMutation(execSql, async (lockedExecSql) => {
+            await ensureContainerTables(lockedExecSql);
+            await ensureDocumentTables(lockedExecSql);
+            await ensureSqlTables(lockedExecSql, containerCreateIntentTables);
+            await ensureSqlTables(lockedExecSql, containerMoveIntentTables);
+            await ensureSqlTables(lockedExecSql, documentContainerProjectionTables);
+            await ensureDocumentProjectionTables(lockedExecSql);
+            await sqlContainerSyncWatermarkPersistence.ensureSchema(lockedExecSql);
+        }));
+    },
+    async loadHeldContainerBinding(execSql, containerId) {
+        await sqlContainerContentsPersistence.ensureSchema(execSql);
+        return loadStoredHeldContainerBinding(execSql, containerId);
+    },
+    async isSupersededContainerBinding(execSql, input) {
+        await sqlContainerContentsPersistence.ensureSchema(execSql);
+        return isSupersededContainerBinding(execSql, input);
+    },
+    async abandonMoveIntentRevision(execSql, input) {
+        await sqlContainerContentsPersistence.ensureSchema(execSql);
+        return abandonStoredMoveIntentRevision(execSql, input);
+    },
+    async rebindHeldContainer(execSql, input) {
+        await sqlContainerContentsPersistence.ensureSchema(execSql);
+        return rebindStoredHeldContainer(execSql, input);
+    },
+    async loadContainerMetadataRecord(execSql, containerId) {
+        await sqlContainerContentsPersistence.ensureSchema(execSql);
+        return selectContainerMetadataRecord(execSql, containerId);
+    },
+    async loadContainerHydrationTombstones(execSql) {
+        await sqlContainerContentsPersistence.ensureSchema(execSql);
+        const { db } = getClientSQLitePersistenceRuntime(execSql);
+        const rows = await db
+            .select({
+            containerId: containerHydrationTombstones.containerId,
+            generation: containerHydrationTombstones.generation,
+            reason: containerHydrationTombstones.reason,
+            updatedAt: containerHydrationTombstones.updatedAt,
+        })
+            .from(containerHydrationTombstones)
+            .where(eq(containerHydrationTombstones.cleared, false));
+        return rows.flatMap((row) => row.reason === "access_revoked" || row.reason === "deleted"
+            ? [{ ...row, reason: row.reason }]
+            : []);
+    },
+    async loadContainers(execSql) {
+        const containers = await loadContainerRecords(execSql);
+        const storedContainers = await Promise.all(containers.map(async (container) => ({
+            container,
+            record: await selectContainerMetadataRecord(execSql, container.id),
+        })));
+        return storedContainers;
+    },
+    async loadContainerMetadataState(execSql, containerId) {
+        await sqlContainerContentsPersistence.ensureSchema(execSql);
+        const container = await loadContainerById(execSql, containerId);
+        if (!container) {
+            return null;
+        }
+        return {
+            container,
+            record: await selectContainerMetadataRecord(execSql, containerId),
+        };
+    },
+    async saveContainer(execSql, container, record, options) {
+        return saveStoredContainer(execSql, container, record, options);
+    },
+    async saveContainerWithPendingUpdate(execSql, container, record, options) {
+        return saveStoredContainer(execSql, container, record, options);
+    },
+    async saveContainerAndDeletePendingUpdates(execSql, container, record, pendingUpdateIds) {
+        const uniquePendingUpdateIds = [...new Set(pendingUpdateIds)];
+        return runSerializedSqlMutation(execSql, async (lockedExecSql) => {
+            const localUpdatedAt = new Date().toISOString();
+            return getClientSQLitePersistenceRuntime(lockedExecSql).transaction(async (tx) => {
+                if (uniquePendingUpdateIds.length > 0) {
+                    await tx
+                        .delete(documentPendingUpdates)
+                        .where(and(eq(documentPendingUpdates.appKind, CONTAINER_METADATA_APP_KIND), eq(documentPendingUpdates.localId, container.id), inArray(documentPendingUpdates.id, uniquePendingUpdateIds)))
+                        .run();
+                }
+                const hasRemainingPendingUpdates = await hasPendingContainerMetadataUpdates({
+                    containerId: container.id,
+                    tx,
+                });
+                const containerToSave = hasRemainingPendingUpdates
+                    ? container
+                    : {
+                        ...container,
+                        serverUpdatedAt: getLatestTimestamp(container.serverUpdatedAt, localUpdatedAt),
+                    };
+                return saveContainerContentsContainerRows({
+                    container: containerToSave,
+                    record,
+                    tx,
+                    localUpdatedAt,
+                });
+            });
+        });
+    },
+};
+//# sourceMappingURL=containerContentsPersistence.js.map

package/data/persistence/container-contents/containerContentsPersistence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"containerContentsPersistence.js","sourceRoot":"","sources":["containerContentsPersistence.ts"],"names":[],"mappings":"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","sourcesContent":["import { and, eq, inArray } from \"drizzle-orm\";\nimport {\n  enqueueDocumentPendingUpdate,\n  ensureDocumentProjectionTables,\n  ensureDocumentTables,\n} from \"../../sqlite/documentPersistence\";\nimport {\n  containerCreateIntentTables,\n  containerHydrationTombstones,\n  containerMoveIntentTables,\n  containers,\n  documentContainerProjectionTables,\n  documentPendingUpdates,\n} from \"../../sqlite/schema\";\nimport {\n  type ClientSQLiteTransactionScope,\n  getClientSQLitePersistenceRuntime,\n} from \"../../sqlite/sqlitePersistenceRuntime\";\nimport {\n  ensureSqlTables,\n  runOncePerConnection,\n  runSerializedSqlMutation,\n} from \"../../sqlite/sqlSchema\";\nimport {\n  ensureContainerTables,\n  loadContainerById,\n  loadContainers as loadContainerRecords,\n} from \"../containers/containerPersistence\";\nimport { sqlContainerSyncWatermarkPersistence } from \"../containers/containerSyncWatermarkPersistence\";\nimport { getLatestTimestamp } from \"../latestTimestamp\";\nimport { CONTAINER_METADATA_APP_KIND } from \"./dormantContainerMetadata\";\nimport {\n  claimDormantMetadataSweepAttempt,\n  completeDormantMetadataSweepRequest,\n  listDormantMetadataSweepRequests,\n} from \"./dormantMetadataSweep\";\n\nexport type {\n  ContainerContentsPersistence,\n  ContainerCreateIntentRecord,\n  ContainerHydrationTombstone,\n  ContainerMetadataRecord,\n  ContainerMoveIntentRecord,\n  LocalRootDescendantReparentInput,\n  StoredContainerState,\n} from \"./containerContentsPersistenceTypes\";\nexport { CONTAINER_METADATA_APP_KIND } from \"./dormantContainerMetadata\";\n\nimport type {\n  ContainerContentsPersistence,\n  ContainerMetadataRecord,\n  SaveContainerOptions,\n  SaveContainerWithPendingUpdateOptions,\n} from \"./containerContentsPersistenceTypes\";\nimport { deleteStoredContainers } from \"./containerDeletionPersistence\";\nimport {\n  commitStoredHydratedContainer,\n  loadStoredHeldContainerBinding,\n} from \"./containerHydrationPersistence\";\nimport { containerIntentPersistence } from \"./containerIntentPersistence\";\nimport {\n  commitStoredMetadataMutation,\n  settleStoredMetadataPendingUpdates,\n} from \"./containerMetadataMutationPersistence\";\nimport { containerMetadataPullContinuationPersistence } from \"./containerMetadataPullContinuationPersistence\";\nimport {\n  getContainerMetadataScope,\n  saveContainerContentsContainerRows,\n  selectContainerMetadataRecord,\n} from \"./containerMetadataRows\";\nimport { abandonStoredMoveIntentRevision } from \"./containerMoveAbandonPersistence\";\nimport { containerPendingUpdatePersistence } from \"./containerPendingUpdatePersistence\";\nimport { rebindStoredHeldContainer } from \"./containerRebindPersistence\";\nimport { containerReconcilePersistence } from \"./containerReconcilePersistence\";\nimport { isSupersededContainerBinding } from \"./supersededContainerBindings\";\n\nasync function saveStoredContainer(\n  execSql: Parameters<ContainerContentsPersistence[\"saveContainer\"]>[0],\n  container: Parameters<ContainerContentsPersistence[\"saveContainer\"]>[1],\n  record: ContainerMetadataRecord | null,\n  options?:\n    | SaveContainerOptions\n    | SaveContainerWithPendingUpdateOptions\n    | undefined,\n) {\n  return runSerializedSqlMutation(execSql, async (lockedExecSql) => {\n    const localUpdatedAt =\n      options?.localUpdatedAt ?? options?.updatedAt ?? new Date().toISOString();\n    const runtime = getClientSQLitePersistenceRuntime(lockedExecSql);\n    const save = async (tx: ClientSQLiteTransactionScope) => {\n      const saved = await saveContainerContentsContainerRows({\n        container,\n        createIntent: options?.createIntent,\n        moveIntent: options?.moveIntent,\n        record,\n        serverTimestamps: options?.serverTimestamps,\n        tx,\n        localUpdatedAt,\n      });\n      if (options && \"pendingUpdate\" in options) {\n        await enqueueDocumentPendingUpdate(\n          lockedExecSql,\n          getContainerMetadataScope(container.id),\n          options.pendingUpdate,\n        );\n      }\n      return saved;\n    };\n    if (!options?.stillCurrent) {\n      return runtime.transaction(save);\n    }\n    const outcome = await runtime.guardedTransaction(\n      save,\n      options.stillCurrent,\n      { behavior: \"immediate\" },\n    );\n    // Guarded callers recheck the same monotonic generation immediately after\n    // this await. Returning the untouched candidate keeps the long-standing\n    // non-null save contract while the transaction itself remains rolled back.\n    return outcome.result ?? container;\n  });\n}\n\nasync function hasPendingContainerMetadataUpdates(input: {\n  tx: ClientSQLiteTransactionScope;\n  containerId: string;\n}): Promise<boolean> {\n  const rows = await input.tx\n    .select({ id: documentPendingUpdates.id })\n    .from(documentPendingUpdates)\n    .where(\n      and(\n        eq(documentPendingUpdates.appKind, CONTAINER_METADATA_APP_KIND),\n        eq(documentPendingUpdates.localId, input.containerId),\n      ),\n    )\n    .limit(1);\n\n  return rows.length > 0;\n}\n\nexport const sqlContainerContentsPersistence: ContainerContentsPersistence = {\n  ...containerIntentPersistence,\n  ...containerMetadataPullContinuationPersistence,\n  commitHydratedContainer: commitStoredHydratedContainer,\n  commitMetadataMutation: commitStoredMetadataMutation,\n  settleAcceptedMetadataPendingUpdates: settleStoredMetadataPendingUpdates,\n  listDormantMetadataSweepRequests,\n  ...containerPendingUpdatePersistence,\n  ...containerReconcilePersistence,\n  claimDormantMetadataSweepAttempt,\n  completeDormantMetadataSweepRequest,\n  async containerExists(execSql, containerId) {\n    await sqlContainerContentsPersistence.ensureSchema(execSql);\n    const { db } = getClientSQLitePersistenceRuntime(execSql);\n    const rows = await db\n      .select({ id: containers.id })\n      .from(containers)\n      .where(eq(containers.id, containerId))\n      .limit(1);\n    return rows.length > 0;\n  },\n  async deleteContainer(execSql, containerId, options) {\n    await sqlContainerContentsPersistence.deleteContainers(execSql, [\n      {\n        containerId,\n        reason: options?.reason ?? \"deleted\",\n        updatedAt: options?.updatedAt ?? new Date().toISOString(),\n      },\n    ]);\n  },\n  async deleteContainers(execSql, removals, options) {\n    return deleteStoredContainers(execSql, removals, options);\n  },\n  async ensureSchema(execSql) {\n    // Once ensured on this connection, skip the outer mutation lock entirely:\n    // ensureSchema runs on every query path, and re-acquiring the lock just to\n    // no-op would queue reads behind unrelated writes.\n    await runOncePerConnection(execSql, \"ensure:container-contents\", () =>\n      runSerializedSqlMutation(execSql, async (lockedExecSql) => {\n        await ensureContainerTables(lockedExecSql);\n        await ensureDocumentTables(lockedExecSql);\n        await ensureSqlTables(lockedExecSql, containerCreateIntentTables);\n        await ensureSqlTables(lockedExecSql, containerMoveIntentTables);\n        await ensureSqlTables(lockedExecSql, documentContainerProjectionTables);\n        await ensureDocumentProjectionTables(lockedExecSql);\n        await sqlContainerSyncWatermarkPersistence.ensureSchema(lockedExecSql);\n      }),\n    );\n  },\n  async loadHeldContainerBinding(execSql, containerId) {\n    await sqlContainerContentsPersistence.ensureSchema(execSql);\n    return loadStoredHeldContainerBinding(execSql, containerId);\n  },\n  async isSupersededContainerBinding(execSql, input) {\n    await sqlContainerContentsPersistence.ensureSchema(execSql);\n    return isSupersededContainerBinding(execSql, input);\n  },\n  async abandonMoveIntentRevision(execSql, input) {\n    await sqlContainerContentsPersistence.ensureSchema(execSql);\n    return abandonStoredMoveIntentRevision(execSql, input);\n  },\n  async rebindHeldContainer(execSql, input) {\n    await sqlContainerContentsPersistence.ensureSchema(execSql);\n    return rebindStoredHeldContainer(execSql, input);\n  },\n  async loadContainerMetadataRecord(execSql, containerId) {\n    await sqlContainerContentsPersistence.ensureSchema(execSql);\n    return selectContainerMetadataRecord(execSql, containerId);\n  },\n  async loadContainerHydrationTombstones(execSql) {\n    await sqlContainerContentsPersistence.ensureSchema(execSql);\n    const { db } = getClientSQLitePersistenceRuntime(execSql);\n    const rows = await db\n      .select({\n        containerId: containerHydrationTombstones.containerId,\n        generation: containerHydrationTombstones.generation,\n        reason: containerHydrationTombstones.reason,\n        updatedAt: containerHydrationTombstones.updatedAt,\n      })\n      .from(containerHydrationTombstones)\n      .where(eq(containerHydrationTombstones.cleared, false));\n    return rows.flatMap((row) =>\n      row.reason === \"access_revoked\" || row.reason === \"deleted\"\n        ? [{ ...row, reason: row.reason }]\n        : [],\n    );\n  },\n  async loadContainers(execSql) {\n    const containers = await loadContainerRecords(execSql);\n    const storedContainers = await Promise.all(\n      containers.map(async (container) => ({\n        container,\n        record: await selectContainerMetadataRecord(execSql, container.id),\n      })),\n    );\n\n    return storedContainers;\n  },\n  async loadContainerMetadataState(execSql, containerId) {\n    await sqlContainerContentsPersistence.ensureSchema(execSql);\n    const container = await loadContainerById(execSql, containerId);\n    if (!container) {\n      return null;\n    }\n    return {\n      container,\n      record: await selectContainerMetadataRecord(execSql, containerId),\n    };\n  },\n  async saveContainer(execSql, container, record, options) {\n    return saveStoredContainer(execSql, container, record, options);\n  },\n  async saveContainerWithPendingUpdate(execSql, container, record, options) {\n    return saveStoredContainer(execSql, container, record, options);\n  },\n  async saveContainerAndDeletePendingUpdates(\n    execSql,\n    container,\n    record,\n    pendingUpdateIds,\n  ) {\n    const uniquePendingUpdateIds = [...new Set(pendingUpdateIds)];\n\n    return runSerializedSqlMutation(execSql, async (lockedExecSql) => {\n      const localUpdatedAt = new Date().toISOString();\n      return getClientSQLitePersistenceRuntime(lockedExecSql).transaction(\n        async (tx) => {\n          if (uniquePendingUpdateIds.length > 0) {\n            await tx\n              .delete(documentPendingUpdates)\n              .where(\n                and(\n                  eq(\n                    documentPendingUpdates.appKind,\n                    CONTAINER_METADATA_APP_KIND,\n                  ),\n                  eq(documentPendingUpdates.localId, container.id),\n                  inArray(documentPendingUpdates.id, uniquePendingUpdateIds),\n                ),\n              )\n              .run();\n          }\n\n          const hasRemainingPendingUpdates =\n            await hasPendingContainerMetadataUpdates({\n              containerId: container.id,\n              tx,\n            });\n          const containerToSave = hasRemainingPendingUpdates\n            ? container\n            : {\n                ...container,\n                serverUpdatedAt: getLatestTimestamp(\n                  container.serverUpdatedAt,\n                  localUpdatedAt,\n                ),\n              };\n\n          return saveContainerContentsContainerRows({\n            container: containerToSave,\n            record,\n            tx,\n            localUpdatedAt,\n          });\n        },\n      );\n    });\n  },\n};\n"]}

package/data/persistence/container-contents/containerContentsPersistenceTypes.d.ts

@@ -0,0 +1,340 @@
+import type { AccessManifestCheckpoint } from "../../../internal/crypto/index.js";
+import type { HeldContainerBinding } from "../../containers/containerBinding.js";
+import type { DocumentSyncPullContinuation } from "../../documents/shared/pullContinuation.js";
+import type { DocumentRecord, PendingUpdateFields, PendingUpdateRecord } from "../../sqlite/documentPersistence.js";
+import type { ExecSql } from "../../sqlite/sqlSchema.js";
+import type { ContainerRecord } from "../containers/containerPersistence.js";
+import type { DormantMetadataSweepPersistence } from "./dormantMetadataSweep.js";
+export declare const CONTAINER_CREATE_INTENT_TYPE = "container.create";
+export declare const CONTAINER_MOVE_INTENT_TYPE = "container.move";
+export type ContainerCreateIntentSyncStatus = "pending" | "synced";
+export type ContainerMoveIntentSyncStatus = "pending" | "blocked";
+export interface ContainerCreateIntentRecord {
+    id: string;
+    containerId: string;
+    parentContainerId: string;
+    intentType: typeof CONTAINER_CREATE_INTENT_TYPE;
+    syncStatus: ContainerCreateIntentSyncStatus;
+    remoteContainerId: string | null;
+    remoteMetadataDocumentId: string | null;
+    remoteMetadataAccessStateHash: string | null;
+    lastError: string | null;
+    lastAttemptedAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ContainerMoveIntentRecord {
+    id: string;
+    containerId: string;
+    parentContainerId: string;
+    previousParentContainerId: string | null;
+    intentType: typeof CONTAINER_MOVE_INTENT_TYPE;
+    syncStatus: ContainerMoveIntentSyncStatus;
+    lastError: string | null;
+    lastAttemptedAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ContainerCreateIntentInput {
+    id?: string;
+    parentContainerId: string;
+}
+export interface ContainerMoveIntentInput {
+    id?: string;
+    parentContainerId: string;
+    previousParentContainerId?: string | null | undefined;
+}
+export interface ContainerCreateIntentErrorInput {
+    containerId: string;
+    expectedIntentId: string;
+    expectedUpdatedAt: string;
+    message: string;
+    stillCurrent?: (() => boolean) | undefined;
+}
+export type ContainerCreateIntentErrorInputRecorder = (execSql: ExecSql, input: ContainerCreateIntentErrorInput) => Promise<void>;
+export interface ContainerMoveIntentRevisionInput {
+    containerId: string;
+    expectedIntentId: string;
+    expectedUpdatedAt: string;
+    stillCurrent: () => boolean;
+}
+export interface ContainerCreateIntentRevisionInput extends ContainerMoveIntentRevisionInput {
+    remoteContainerId: string;
+    remoteMetadataAccessStateHash: string;
+    remoteMetadataDocumentId: string;
+    /** The remote parent now; a move settlement queues cites it as previous. */
+    supersededMovePreviousParentId?: string | undefined;
+    /**
+     * The parent the create committed under. A desired parent equal to it, or
+     * to the current one, owes no move: the user never moved the folder away,
+     * and a later remote move by another writer stands.
+     */
+    createdParentContainerId?: string | undefined;
+    /** The parent the settled intent wants. */
+    desiredParentContainerId?: string | undefined;
+}
+export interface LocalRootDescendantReparentInput {
+    containerId: string;
+    parentContainerId: string | null;
+    updateCreateIntent?: boolean | undefined;
+}
+/**
+ * A container's metadata document record plus its durable content: the full
+ * Loro updates export of the metadata document, stored in the shared
+ * history-checkpoint table under the container-metadata app kind. Metadata
+ * documents are tiny registries, so the whole update log is the checkpoint.
+ */
+export interface ContainerMetadataRecord extends DocumentRecord {
+    metadataUpdates: string;
+}
+export interface StoredContainerState {
+    container: ContainerRecord;
+    record: ContainerMetadataRecord | null;
+}
+export interface ContainerRemoval {
+    containerId: string;
+    reason: "access_revoked" | "deleted";
+    updatedAt: string;
+}
+export interface ContainerHydrationTombstone extends ContainerRemoval {
+    generation: number;
+}
+export interface ContainerDeletionGuard {
+    containerId: string;
+    expectedContainer: ContainerRecord | null;
+}
+export interface SaveContainerOptions {
+    createIntent?: ContainerCreateIntentInput;
+    stillCurrent?: (() => boolean) | undefined;
+    localUpdatedAt?: string;
+    moveIntent?: ContainerMoveIntentInput | undefined;
+    serverTimestamps?: {
+        createdAt?: string | null;
+        updatedAt?: string | null;
+    } | undefined;
+    updatedAt?: string;
+}
+export interface SaveContainerWithPendingUpdateOptions extends SaveContainerOptions {
+    pendingUpdate: PendingUpdateFields;
+}
+export interface ContainerContentsPersistence extends DormantMetadataSweepPersistence {
+    containerExists: (execSql: ExecSql, containerId: string) => Promise<boolean>;
+    /**
+     * Create an absent remotely hydrated container only when no newer durable
+     * tombstone or concurrent container/dormant-metadata mutation won first.
+     */
+    commitHydratedContainer: (execSql: ExecSql, input: {
+        container: ContainerRecord;
+        expectedDormantRecord: ContainerMetadataRecord | null;
+        /** Tombstone observed before the remote request began, or null. */
+        expectedHydrationTombstone?: ContainerHydrationTombstone | null | undefined;
+        /** Current placement verified and pinned before recovery insertion. */
+        expectedPlacementCheckpoint?: AccessManifestCheckpoint | undefined;
+        record: ContainerMetadataRecord;
+        remoteUpdatedAt: string;
+        saveOptions: {
+            localUpdatedAt?: string;
+            serverTimestamps?: {
+                createdAt?: string | null;
+                updatedAt?: string | null;
+            } | undefined;
+        };
+        stillCurrent?: (() => boolean) | undefined;
+    }) => Promise<{
+        committed: true;
+        container: ContainerRecord;
+    } | {
+        committed: false;
+    }>;
+    /** Capture anti-resurrection fences immediately before a remote fetch. */
+    loadContainerHydrationTombstones: (execSql: ExecSql) => Promise<ReadonlyArray<ContainerHydrationTombstone>>;
+    deleteContainer: (execSql: ExecSql, containerId: string, options?: {
+        reason?: ContainerRemoval["reason"];
+        updatedAt?: string;
+    }) => Promise<void>;
+    deleteContainers: (execSql: ExecSql, removals: ReadonlyArray<ContainerRemoval>, options?: {
+        /** Unsigned discovery removes listings but preserves metadata and local intent. */
+        discoveryOnly?: boolean;
+        /**
+         * Request-time states rechecked inside the deletion transaction. An
+         * absent or changed row means another pane won and aborts the cascade.
+         */
+        expectedContainers?: ReadonlyArray<ContainerDeletionGuard>;
+        stillCurrent?: (() => boolean) | undefined;
+    }) => Promise<ReadonlyArray<string>>;
+    deletePendingUpdates: (execSql: ExecSql, containerId: string) => Promise<void>;
+    deletePendingUpdate: (execSql: ExecSql, id: string) => Promise<void>;
+    ensureSchema: (execSql: ExecSql) => Promise<void>;
+    enqueuePendingUpdate: (execSql: ExecSql, input: PendingUpdateFields & {
+        containerId: string;
+    }) => Promise<string>;
+    listPendingCreateIntents: (execSql: ExecSql) => Promise<ContainerCreateIntentRecord[]>;
+    listUnsyncedMoveIntents: (execSql: ExecSql) => Promise<ContainerMoveIntentRecord[]>;
+    listContainerIdsWithPendingUpdates: (execSql: ExecSql, containerIds: ReadonlyArray<string>) => Promise<string[]>;
+    listContainerIdsWithPullContinuations: (execSql: ExecSql, containerIds: ReadonlyArray<string>) => Promise<string[]>;
+    listPendingUpdates: (execSql: ExecSql, containerId: string) => Promise<PendingUpdateRecord[]>;
+    rekeyPendingUpdate: (execSql: ExecSql, id: string) => Promise<string | null>;
+    /** Revision-CAS error recorder used by asynchronous create replay. */
+    recordCreateIntentRevisionError: ContainerCreateIntentErrorInputRecorder;
+    recordMoveIntentError: (execSql: ExecSql, input: {
+        blocked?: boolean | undefined;
+        containerId: string;
+        expectedIntentId?: string | undefined;
+        expectedUpdatedAt?: string | undefined;
+        message: string;
+        stillCurrent?: (() => boolean) | undefined;
+    }) => Promise<void>;
+    reassignContainerDocuments: (execSql: ExecSql, input: {
+        fromContainerId: string;
+        stillCurrent?: (() => boolean) | undefined;
+        toContainerId: string;
+        updatedAt?: string | undefined;
+    }) => Promise<void>;
+    reconcileLocalRootContainer: (execSql: ExecSql, input: {
+        descendantReparents: ReadonlyArray<LocalRootDescendantReparentInput>;
+        localRootContainerId: string;
+        remoteOrganizationId: string;
+        remoteRootContainerId: string;
+        stillCurrent?: (() => boolean) | undefined;
+        updatedAt?: string | undefined;
+    }) => Promise<void>;
+    reconcileLocalSystemContainer: (execSql: ExecSql, input: {
+        localContainerId: string;
+        remoteContainerId: string;
+        remoteOrganizationId: string;
+        stillCurrent?: (() => boolean) | undefined;
+        updatedAt?: string | undefined;
+    }) => Promise<void>;
+    loadContainers: (execSql: ExecSql) => Promise<ReadonlyArray<StoredContainerState>>;
+    loadContainerMetadataState: (execSql: ExecSql, containerId: string) => Promise<StoredContainerState | null>;
+    /**
+     * The organization and metadata target this device holds for a container,
+     * from its live row or retained dormant metadata; null when never held.
+     */
+    loadHeldContainerBinding: (execSql: ExecSql, containerId: string) => Promise<HeldContainerBinding | null>;
+    /** Whether a held folder was re-homed away from this organization. */
+    isSupersededContainerBinding: (execSql: ExecSql, input: {
+        containerId: string;
+        organizationId: string;
+    }) => Promise<boolean>;
+    /**
+     * Move a held folder to the binding its own user re-created it under,
+     * resetting the metadata record's remote stream; false if the held binding
+     * changed since it was read.
+     */
+    rebindHeldContainer: (execSql: ExecSql, input: {
+        containerId: string;
+        expected: HeldContainerBinding;
+        next: {
+            metadataDocumentId: string;
+            organizationId: string;
+        };
+        stillCurrent?: (() => boolean) | undefined;
+    }) => Promise<boolean>;
+    /**
+     * Load a container-metadata record by container id alone, without
+     * requiring a containers row — the dormant shape row 4's access_revoked
+     * branch leaves behind, re-attached on rehydration.
+     */
+    loadContainerMetadataRecord: (execSql: ExecSql, containerId: string) => Promise<ContainerMetadataRecord | null>;
+    /**
+     * Atomically replace the exact rejected metadata pull continuation with its
+     * durable recovery marker and return the authoritative current record.
+     */
+    invalidateMetadataPullContinuation: (execSql: ExecSql, input: {
+        accessEpoch: number;
+        accessStateHash: string | null;
+        continuation: DocumentSyncPullContinuation;
+        containerId: string;
+        contentKeyBundle: string | null;
+        documentId: string;
+        documentKekTargets: string | null;
+        documentManifestBundle: string | null;
+        lastCommitLsn: string | null;
+        stillCurrent?: (() => boolean) | undefined;
+    }) => Promise<ContainerMetadataRecord | null>;
+    /**
+     * Conditionally commit metadata content, its outgoing row, accepted queue
+     * settlement, container fields, and the canonical record in one transaction.
+     */
+    commitMetadataMutation: (execSql: ExecSql, input: {
+        acceptedPendingUpdateIds: readonly string[];
+        clearSyncFailure?: boolean | undefined;
+        container: ContainerRecord;
+        expectedContainer: ContainerRecord;
+        expectedRecord: ContainerMetadataRecord;
+        createIntentSettlement?: {
+            containerId: string;
+            expectedIntentId: string;
+            expectedUpdatedAt: string;
+            remoteContainerId: string;
+            remoteMetadataAccessStateHash: string;
+            remoteMetadataDocumentId: string;
+            /**
+             * When present, an overtaking create revision is adopted as the
+             * desired local parent and converted to a move from this remotely
+             * committed parent instead of rejecting the remote identity.
+             */
+            supersededMovePreviousParentId?: string | undefined;
+        } | undefined;
+        moveIntentSettlement?: {
+            containerId: string;
+            expectedIntentId: string;
+            expectedUpdatedAt: string;
+        } | undefined;
+        pendingUpdate?: PendingUpdateFields | undefined;
+        preserveDurableStructureWhenPending?: boolean | undefined;
+        record: ContainerMetadataRecord;
+        saveOptions?: {
+            createIntent?: ContainerCreateIntentInput;
+            localUpdatedAt?: string;
+            moveIntent?: ContainerMoveIntentInput | undefined;
+            serverTimestamps?: {
+                createdAt?: string | null;
+                updatedAt?: string | null;
+            } | undefined;
+            updatedAt?: string;
+        } | undefined;
+        settleAcceptedPendingOnConflict: boolean;
+        stillCurrent?: (() => boolean) | undefined;
+    }) => Promise<{
+        committed: true;
+        container: ContainerRecord;
+        createIntentSettled?: true | undefined;
+        moveIntentSettled?: true | undefined;
+    } | {
+        committed: false;
+        currentState: StoredContainerState | null;
+        staleServerState?: true;
+    }>;
+    settleAcceptedMetadataPendingUpdates: (execSql: ExecSql, input: {
+        containerId: string;
+        expectedRecord: ContainerMetadataRecord;
+        pendingUpdateIds: readonly string[];
+        stillCurrent?: (() => boolean) | undefined;
+    }) => Promise<StoredContainerState | null>;
+    saveContainer: (execSql: ExecSql, container: ContainerRecord, record: ContainerMetadataRecord | null, options?: SaveContainerOptions) => Promise<ContainerRecord>;
+    /**
+     * Atomically saves a container and enqueues its first metadata update.
+     * Host adapters must implement the compound write in their own transaction.
+     */
+    saveContainerWithPendingUpdate: (execSql: ExecSql, container: ContainerRecord, record: ContainerMetadataRecord, options: SaveContainerWithPendingUpdateOptions) => Promise<ContainerRecord>;
+    saveContainerAndDeletePendingUpdates: (execSql: ExecSql, container: ContainerRecord, record: ContainerMetadataRecord, pendingUpdateIds: readonly string[]) => Promise<ContainerRecord>;
+    /**
+     * Revision-CAS settlement used by asynchronous create replay. Invalid
+     * adapters are rejected before the remote mutation begins.
+     */
+    markCreateIntentRevisionSynced: (execSql: ExecSql, input: ContainerCreateIntentRevisionInput) => Promise<boolean>;
+    /**
+     * Explicit revision-CAS settlement. Move replay instead settles inside
+     * commitMetadataMutation and requires its atomic acknowledgment.
+     */
+    markMoveIntentRevisionSynced: (execSql: ExecSql, input: ContainerMoveIntentRevisionInput) => Promise<boolean>;
+    /**
+     * Drop a move revision the server refuses for good and restore the
+     * folder's previous parent in the same transaction; false if superseded.
+     */
+    abandonMoveIntentRevision: (execSql: ExecSql, input: ContainerMoveIntentRevisionInput & {
+        previousParentContainerId: string;
+    }) => Promise<boolean>;
+}

package/data/persistence/container-contents/containerContentsPersistenceTypes.js

@@ -0,0 +1,3 @@
+export const CONTAINER_CREATE_INTENT_TYPE = "container.create";
+export const CONTAINER_MOVE_INTENT_TYPE = "container.move";
+//# sourceMappingURL=containerContentsPersistenceTypes.js.map