@tearleads/client-sdk 0.1.63 → 0.1.65

package/workflows/container-contents/container-state/create/createChild.js

@@ -0,0 +1,217 @@
+import { bytesToBase64 } from "../../../../internal/encoding/index.js";
+import { createInitializedContainerMetadataDocument } from "../../../../data/containers/containerMetadataDocument.js";
+import { createPendingUpdateFields } from "../../../../data/documents/documentSync.js";
+import { deriveStableUuidV4Shaped } from "../../../../data/keying/stableUuid.js";
+import { defaultContainerContentsPersistence } from "../../containerPersistence.js";
+import { loadContainerWriterProjectionForState } from "../projectionCache.js";
+import { createRemoteContainer } from "../remote.js";
+import { CONTAINER_ALREADY_COMMITTED } from "./createWithMetadata.js";
+const SYSTEM_CONTAINER_ID_NAMESPACE_BYTES = new Uint8Array([
+    0xc5, 0x5e, 0x8f, 0x2e, 0x3d, 0x82, 0x4b, 0x4d, 0x8d, 0xbd, 0x0d, 0xd2, 0xd3,
+    0x60, 0xb3, 0x6d,
+]);
+/**
+ * Derives a stable, UUID-shaped container id for a built-in system slot.
+ *
+ * The namespace digest makes each slot idempotent across stale store snapshots.
+ * The UUID version and variant bits are normalized to a v4 shape because remote
+ * container APIs currently validate container ids with the same v4 UUID contract
+ * they use for random user-created containers.
+ */
+function deriveSystemContainerId(input) {
+    return deriveStableUuidV4Shaped(SYSTEM_CONTAINER_ID_NAMESPACE_BYTES, `${input.parentContainerId}\u0000${input.systemSlot}`);
+}
+async function createChildContainerId(parentContainerId, systemSlot) {
+    return systemSlot
+        ? deriveSystemContainerId({ parentContainerId, systemSlot })
+        : crypto.randomUUID();
+}
+async function buildRemoteContainerContentsChildContainerState(input) {
+    const { childId, icon, systemSlot, doc, initialRecord, parentState, resolveProjectionUserKey, runtime, stillCurrent, trimmedName, } = input;
+    const parentProjection = await loadContainerWriterProjectionForState({
+        containerState: parentState,
+        runtime,
+    });
+    if (!parentProjection) {
+        return null;
+    }
+    const created = await createRemoteContainer({
+        systemSlot,
+        containerId: childId,
+        parentContainerId: parentState.container.id,
+        parentProjection,
+        resolveProjectionUserKey,
+        runtime,
+        stillCurrent,
+    });
+    if (!created || created === CONTAINER_ALREADY_COMMITTED) {
+        // A benign manifest-exists conflict means the container is already committed
+        // remotely (a lost create response). This eager path cannot rebuild its
+        // committed metadata state, so leave the create intent to reconcile it via
+        // hydration rather than fabricating a local record from a missing response.
+        return null;
+    }
+    return {
+        container: {
+            id: created.containerId,
+            // The creator owns a newly-created container until the server reconciles.
+            effectiveAccessLevel: "admin",
+            organizationId: created.organizationId,
+            parentId: created.parentId,
+            metadataDocumentId: created.metadataDocumentId,
+            systemSlot: created.systemSlot,
+            name: trimmedName,
+            icon,
+            createdAt: created.createdAt,
+            serverCreatedAt: created.createdAt,
+            serverUpdatedAt: created.updatedAt,
+            updatedAt: created.updatedAt,
+        },
+        doc,
+        record: {
+            ...initialRecord,
+            accessEpoch: 1,
+            accessStateHash: created.accessManifestHash,
+            ...created.persistedMetadataState,
+        },
+    };
+}
+function buildLocalContainerContentsChildContainerState(input) {
+    const { systemSlot, childId, doc, icon, initialRecord, parentState, trimmedName, } = input;
+    return {
+        container: {
+            id: childId,
+            effectiveAccessLevel: "admin",
+            organizationId: parentState.container.organizationId,
+            parentId: parentState.container.id,
+            metadataDocumentId: null,
+            systemSlot: systemSlot ?? null,
+            name: trimmedName,
+            icon,
+        },
+        doc,
+        record: initialRecord,
+    };
+}
+function createInitialChildContainerDocumentRecord(input) {
+    return {
+        accessEpoch: 1,
+        accessStateHash: null,
+        contentKeyBundle: null,
+        documentId: null,
+        documentKekTargets: null,
+        documentManifestBundle: null,
+        id: input.childId,
+        lastCommitLsn: null,
+        metadataUpdates: bytesToBase64(input.initialUpdate),
+        snapshotEndVersion: "",
+    };
+}
+function resolveAtomicChildContainerSave(persistence) {
+    const saveContainerWithPendingUpdate = persistence.saveContainerWithPendingUpdate;
+    if (!saveContainerWithPendingUpdate)
+        return null;
+    const inheritedSqlAtomicSave = saveContainerWithPendingUpdate ===
+        defaultContainerContentsPersistence.saveContainerWithPendingUpdate &&
+        (persistence.saveContainer !==
+            defaultContainerContentsPersistence.saveContainer ||
+            persistence.enqueuePendingUpdate !==
+                defaultContainerContentsPersistence.enqueuePendingUpdate);
+    return inheritedSqlAtomicSave ? null : saveContainerWithPendingUpdate;
+}
+async function persistCreatedChildContainer(input) {
+    const { containerState, persistence, queueRemoteSync, runtime } = input;
+    const createIntent = queueRemoteSync &&
+        !containerState.record.documentId &&
+        containerState.container.parentId
+        ? { parentContainerId: containerState.container.parentId }
+        : undefined;
+    const shouldRequestSync = queueRemoteSync &&
+        (!containerState.record.documentId ||
+            Boolean(containerState.record.contentKeyBundle));
+    const saveOptions = createIntent || input.stillCurrent
+        ? {
+            ...(createIntent ? { createIntent } : {}),
+            stillCurrent: input.stillCurrent,
+        }
+        : undefined;
+    const pendingUpdate = shouldRequestSync
+        ? createPendingUpdateFields(input.initialUpdate)
+        : null;
+    if (pendingUpdate) {
+        const saveContainerWithPendingUpdate = resolveAtomicChildContainerSave(persistence);
+        if (!saveContainerWithPendingUpdate)
+            return null;
+        containerState.container = await saveContainerWithPendingUpdate(runtime.infra.execSql, containerState.container, containerState.record, { ...saveOptions, pendingUpdate });
+    }
+    else {
+        containerState.container = await persistence.saveContainer(runtime.infra.execSql, containerState.container, containerState.record, saveOptions);
+    }
+    return input.stillCurrent?.() === false ? null : shouldRequestSync;
+}
+export async function createChildContainerState(input) {
+    const { createRemote, systemSlot, name, parentState, persistence, queueRemoteSync = true, resolveProjectionUserKey, runtime, } = input;
+    const trimmedName = name.trim();
+    if (!trimmedName) {
+        return null;
+    }
+    const icon = input.icon?.trim() || null;
+    const childId = await createChildContainerId(parentState.container.id, systemSlot);
+    const { doc, initialUpdate } = await createInitializedContainerMetadataDocument(childId, {
+        icon,
+        name: trimmedName,
+    });
+    const initialRecord = createInitialChildContainerDocumentRecord({
+        childId,
+        initialUpdate,
+    });
+    if (input.stillCurrent?.() === false)
+        return null;
+    // An initial metadata update and its container identity are one durable unit.
+    // Refuse before any remote create when an adapter cannot provide
+    // that atomic operation; a SQLite transaction cannot roll back adapter-owned
+    // side effects.
+    if (queueRemoteSync && !resolveAtomicChildContainerSave(persistence)) {
+        return null;
+    }
+    const remoteChildState = createRemote
+        ? await buildRemoteContainerContentsChildContainerState({
+            childId,
+            icon,
+            systemSlot,
+            doc,
+            initialRecord,
+            parentState,
+            resolveProjectionUserKey,
+            runtime,
+            stillCurrent: input.stillCurrent,
+            trimmedName,
+        })
+        : null;
+    const containerState = remoteChildState ??
+        buildLocalContainerContentsChildContainerState({
+            childId,
+            icon,
+            systemSlot,
+            doc,
+            initialRecord,
+            parentState,
+            trimmedName,
+        });
+    const shouldRequestSync = await persistCreatedChildContainer({
+        containerState,
+        initialUpdate,
+        persistence,
+        queueRemoteSync,
+        runtime,
+        stillCurrent: input.stillCurrent,
+    });
+    if (shouldRequestSync === null)
+        return null;
+    return {
+        containerState,
+        initialUpdate,
+        shouldRequestSync,
+    };
+}
+//# sourceMappingURL=createChild.js.map

package/workflows/container-contents/container-state/create/createChild.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createChild.js","sourceRoot":"","sources":["createChild.ts"],"names":[],"mappings":"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","sourcesContent":["import { bytesToBase64 } from \"@tearleads/encoding\";\nimport type { ContainerSystemSlot } from \"@tearleads/validators/containerSystemSlot\";\nimport { createInitializedContainerMetadataDocument } from \"../../../../data/containers/containerMetadataDocument\";\nimport { createPendingUpdateFields } from \"../../../../data/documents/documentSync\";\nimport { deriveStableUuidV4Shaped } from \"../../../../data/keying/stableUuid\";\nimport type { ProjectionUserKeyResolver } from \"../../../../data/keyingProjectionVerification\";\nimport type {\n  ContainerContentsPersistence,\n  ContainerDocumentRecord as DocumentRecord,\n} from \"../../containerPersistence\";\nimport { defaultContainerContentsPersistence } from \"../../containerPersistence\";\nimport type { ContainerState } from \"../../remoteHydration\";\nimport { loadContainerWriterProjectionForState } from \"../projectionCache\";\nimport { createRemoteContainer } from \"../remote\";\nimport type {\n  ContainerMetadataDocumentState,\n  ContainerWorkflowRuntime,\n  CreatedChildContainerState,\n} from \"../types\";\nimport { CONTAINER_ALREADY_COMMITTED } from \"./createWithMetadata\";\n\nconst SYSTEM_CONTAINER_ID_NAMESPACE_BYTES = new Uint8Array([\n  0xc5, 0x5e, 0x8f, 0x2e, 0x3d, 0x82, 0x4b, 0x4d, 0x8d, 0xbd, 0x0d, 0xd2, 0xd3,\n  0x60, 0xb3, 0x6d,\n]);\n\n/**\n * Derives a stable, UUID-shaped container id for a built-in system slot.\n *\n * The namespace digest makes each slot idempotent across stale store snapshots.\n * The UUID version and variant bits are normalized to a v4 shape because remote\n * container APIs currently validate container ids with the same v4 UUID contract\n * they use for random user-created containers.\n */\nfunction deriveSystemContainerId(input: {\n  parentContainerId: string;\n  systemSlot: ContainerSystemSlot;\n}): Promise<string> {\n  return deriveStableUuidV4Shaped(\n    SYSTEM_CONTAINER_ID_NAMESPACE_BYTES,\n    `${input.parentContainerId}\\u0000${input.systemSlot}`,\n  );\n}\n\nasync function createChildContainerId(\n  parentContainerId: string,\n  systemSlot: ContainerSystemSlot | null | undefined,\n): Promise<string> {\n  return systemSlot\n    ? deriveSystemContainerId({ parentContainerId, systemSlot })\n    : crypto.randomUUID();\n}\n\nasync function buildRemoteContainerContentsChildContainerState(input: {\n  childId: string;\n  icon: string | null;\n  systemSlot?: ContainerSystemSlot | null | undefined;\n  doc: ContainerMetadataDocumentState;\n  initialRecord: DocumentRecord;\n  parentState: ContainerState;\n  resolveProjectionUserKey: ProjectionUserKeyResolver;\n  runtime: ContainerWorkflowRuntime;\n  stillCurrent?: (() => boolean) | undefined;\n  trimmedName: string;\n}): Promise<ContainerState | null> {\n  const {\n    childId,\n    icon,\n    systemSlot,\n    doc,\n    initialRecord,\n    parentState,\n    resolveProjectionUserKey,\n    runtime,\n    stillCurrent,\n    trimmedName,\n  } = input;\n  const parentProjection = await loadContainerWriterProjectionForState({\n    containerState: parentState,\n    runtime,\n  });\n  if (!parentProjection) {\n    return null;\n  }\n\n  const created = await createRemoteContainer({\n    systemSlot,\n    containerId: childId,\n    parentContainerId: parentState.container.id,\n    parentProjection,\n    resolveProjectionUserKey,\n    runtime,\n    stillCurrent,\n  });\n\n  if (!created || created === CONTAINER_ALREADY_COMMITTED) {\n    // A benign manifest-exists conflict means the container is already committed\n    // remotely (a lost create response). This eager path cannot rebuild its\n    // committed metadata state, so leave the create intent to reconcile it via\n    // hydration rather than fabricating a local record from a missing response.\n    return null;\n  }\n\n  return {\n    container: {\n      id: created.containerId,\n      // The creator owns a newly-created container until the server reconciles.\n      effectiveAccessLevel: \"admin\",\n      organizationId: created.organizationId,\n      parentId: created.parentId,\n      metadataDocumentId: created.metadataDocumentId,\n      systemSlot: created.systemSlot,\n      name: trimmedName,\n      icon,\n      createdAt: created.createdAt,\n      serverCreatedAt: created.createdAt,\n      serverUpdatedAt: created.updatedAt,\n      updatedAt: created.updatedAt,\n    },\n    doc,\n    record: {\n      ...initialRecord,\n      accessEpoch: 1,\n      accessStateHash: created.accessManifestHash,\n      ...created.persistedMetadataState,\n    },\n  };\n}\n\nfunction buildLocalContainerContentsChildContainerState(input: {\n  childId: string;\n  icon: string | null;\n  systemSlot?: ContainerSystemSlot | null | undefined;\n  doc: ContainerMetadataDocumentState;\n  initialRecord: DocumentRecord;\n  parentState: ContainerState;\n  trimmedName: string;\n}): ContainerState {\n  const {\n    systemSlot,\n    childId,\n    doc,\n    icon,\n    initialRecord,\n    parentState,\n    trimmedName,\n  } = input;\n\n  return {\n    container: {\n      id: childId,\n      effectiveAccessLevel: \"admin\",\n      organizationId: parentState.container.organizationId,\n      parentId: parentState.container.id,\n      metadataDocumentId: null,\n      systemSlot: systemSlot ?? null,\n      name: trimmedName,\n      icon,\n    },\n    doc,\n    record: initialRecord,\n  };\n}\n\nfunction createInitialChildContainerDocumentRecord(input: {\n  childId: string;\n  initialUpdate: Uint8Array;\n}): DocumentRecord {\n  return {\n    accessEpoch: 1,\n    accessStateHash: null,\n    contentKeyBundle: null,\n    documentId: null,\n    documentKekTargets: null,\n    documentManifestBundle: null,\n    id: input.childId,\n    lastCommitLsn: null,\n    metadataUpdates: bytesToBase64(input.initialUpdate),\n    snapshotEndVersion: \"\",\n  };\n}\n\nfunction resolveAtomicChildContainerSave(\n  persistence: ContainerContentsPersistence,\n): NonNullable<\n  ContainerContentsPersistence[\"saveContainerWithPendingUpdate\"]\n> | null {\n  const saveContainerWithPendingUpdate =\n    persistence.saveContainerWithPendingUpdate;\n  if (!saveContainerWithPendingUpdate) return null;\n  const inheritedSqlAtomicSave =\n    saveContainerWithPendingUpdate ===\n      defaultContainerContentsPersistence.saveContainerWithPendingUpdate &&\n    (persistence.saveContainer !==\n      defaultContainerContentsPersistence.saveContainer ||\n      persistence.enqueuePendingUpdate !==\n        defaultContainerContentsPersistence.enqueuePendingUpdate);\n  return inheritedSqlAtomicSave ? null : saveContainerWithPendingUpdate;\n}\n\nasync function persistCreatedChildContainer(input: {\n  containerState: ContainerState;\n  initialUpdate: Uint8Array;\n  persistence: ContainerContentsPersistence;\n  queueRemoteSync: boolean;\n  runtime: ContainerWorkflowRuntime;\n  stillCurrent?: (() => boolean) | undefined;\n}): Promise<boolean | null> {\n  const { containerState, persistence, queueRemoteSync, runtime } = input;\n  const createIntent =\n    queueRemoteSync &&\n    !containerState.record.documentId &&\n    containerState.container.parentId\n      ? { parentContainerId: containerState.container.parentId }\n      : undefined;\n  const shouldRequestSync =\n    queueRemoteSync &&\n    (!containerState.record.documentId ||\n      Boolean(containerState.record.contentKeyBundle));\n  const saveOptions =\n    createIntent || input.stillCurrent\n      ? {\n          ...(createIntent ? { createIntent } : {}),\n          stillCurrent: input.stillCurrent,\n        }\n      : undefined;\n  const pendingUpdate = shouldRequestSync\n    ? createPendingUpdateFields(input.initialUpdate)\n    : null;\n  if (pendingUpdate) {\n    const saveContainerWithPendingUpdate =\n      resolveAtomicChildContainerSave(persistence);\n    if (!saveContainerWithPendingUpdate) return null;\n    containerState.container = await saveContainerWithPendingUpdate(\n      runtime.infra.execSql,\n      containerState.container,\n      containerState.record,\n      { ...saveOptions, pendingUpdate },\n    );\n  } else {\n    containerState.container = await persistence.saveContainer(\n      runtime.infra.execSql,\n      containerState.container,\n      containerState.record,\n      saveOptions,\n    );\n  }\n  return input.stillCurrent?.() === false ? null : shouldRequestSync;\n}\n\nexport async function createChildContainerState(input: {\n  systemSlot?: ContainerSystemSlot | null | undefined;\n  createRemote: boolean;\n  icon?: string | null | undefined;\n  name: string;\n  parentState: ContainerState;\n  persistence: ContainerContentsPersistence;\n  queueRemoteSync?: boolean | undefined;\n  resolveProjectionUserKey: ProjectionUserKeyResolver;\n  runtime: ContainerWorkflowRuntime;\n  stillCurrent?: (() => boolean) | undefined;\n}): Promise<CreatedChildContainerState | null> {\n  const {\n    createRemote,\n    systemSlot,\n    name,\n    parentState,\n    persistence,\n    queueRemoteSync = true,\n    resolveProjectionUserKey,\n    runtime,\n  } = input;\n  const trimmedName = name.trim();\n  if (!trimmedName) {\n    return null;\n  }\n\n  const icon = input.icon?.trim() || null;\n  const childId = await createChildContainerId(\n    parentState.container.id,\n    systemSlot,\n  );\n  const { doc, initialUpdate } =\n    await createInitializedContainerMetadataDocument(childId, {\n      icon,\n      name: trimmedName,\n    });\n  const initialRecord = createInitialChildContainerDocumentRecord({\n    childId,\n    initialUpdate,\n  });\n  if (input.stillCurrent?.() === false) return null;\n  // An initial metadata update and its container identity are one durable unit.\n  // Refuse before any remote create when an adapter cannot provide\n  // that atomic operation; a SQLite transaction cannot roll back adapter-owned\n  // side effects.\n  if (queueRemoteSync && !resolveAtomicChildContainerSave(persistence)) {\n    return null;\n  }\n\n  const remoteChildState = createRemote\n    ? await buildRemoteContainerContentsChildContainerState({\n        childId,\n        icon,\n        systemSlot,\n        doc,\n        initialRecord,\n        parentState,\n        resolveProjectionUserKey,\n        runtime,\n        stillCurrent: input.stillCurrent,\n        trimmedName,\n      })\n    : null;\n  const containerState =\n    remoteChildState ??\n    buildLocalContainerContentsChildContainerState({\n      childId,\n      icon,\n      systemSlot,\n      doc,\n      initialRecord,\n      parentState,\n      trimmedName,\n    });\n  const shouldRequestSync = await persistCreatedChildContainer({\n    containerState,\n    initialUpdate,\n    persistence,\n    queueRemoteSync,\n    runtime,\n    stillCurrent: input.stillCurrent,\n  });\n  if (shouldRequestSync === null) return null;\n\n  return {\n    containerState,\n    initialUpdate,\n    shouldRequestSync,\n  };\n}\n"]}

package/workflows/container-contents/container-state/create/createIntentDepth.js

@@ -0,0 +1,36 @@
+import { CONTAINER_PATH_TOO_DEEP_MESSAGE } from "../../../../data/containers/shared/containerPathLimits.js";
+import { localChildPathFits } from "../localPathDepth.js";
+/** Record the depth refusal once; the intent then waits for a local move. */
+async function recordTooDeepCreate(input) {
+    const { intent, state } = input;
+    if (intent.lastError === CONTAINER_PATH_TOO_DEEP_MESSAGE)
+        return;
+    await state.persistence.recordCreateIntentRevisionError(state.runtime.infra.execSql, {
+        containerId: intent.containerId,
+        expectedIntentId: intent.id,
+        expectedUpdatedAt: intent.updatedAt,
+        message: CONTAINER_PATH_TOO_DEEP_MESSAGE,
+        stillCurrent: input.isCurrent,
+    });
+}
+/**
+ * A create already refused for path length, or whose path is too deep here,
+ * can never succeed, so waiting costs no request. Re-queuing the folder under
+ * another parent (a local move) clears the recorded refusal and re-arms it.
+ * Returns whether the create was deferred.
+ */
+export async function deferTooDeepCreate(input) {
+    const { intent, state } = input;
+    if (intent.lastError !== CONTAINER_PATH_TOO_DEEP_MESSAGE &&
+        localChildPathFits(state.containersById, intent.parentContainerId)) {
+        return false;
+    }
+    await recordTooDeepCreate(input);
+    return true;
+}
+/** Record a refusal from the verified plan or the API; it is final too. */
+export async function recordRefusedTooDeepCreate(input) {
+    await recordTooDeepCreate(input);
+    return "blocked";
+}
+//# sourceMappingURL=createIntentDepth.js.map

package/workflows/container-contents/container-state/create/createIntentDepth.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createIntentDepth.js","sourceRoot":"","sources":["createIntentDepth.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,+BAA+B,EAAE,MAAM,wDAAwD,CAAC;AACzG,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAGvD,6EAA6E;AAC7E,KAAK,UAAU,mBAAmB,CAChC,KAAqC;IAErC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,CAAC;IAChC,IAAI,MAAM,CAAC,SAAS,KAAK,+BAA+B;QAAE,OAAO;IACjE,MAAM,KAAK,CAAC,WAAW,CAAC,+BAA+B,CACrD,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,EAC3B;QACE,WAAW,EAAE,MAAM,CAAC,WAAW;QAC/B,gBAAgB,EAAE,MAAM,CAAC,EAAE;QAC3B,iBAAiB,EAAE,MAAM,CAAC,SAAS;QACnC,OAAO,EAAE,+BAA+B;QACxC,YAAY,EAAE,KAAK,CAAC,SAAS;KAC9B,CACF,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,kBAAkB,CACtC,KAAqC;IAErC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,CAAC;IAChC,IACE,MAAM,CAAC,SAAS,KAAK,+BAA+B;QACpD,kBAAkB,CAAC,KAAK,CAAC,cAAc,EAAE,MAAM,CAAC,iBAAiB,CAAC,EAClE,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IACD,MAAM,mBAAmB,CAAC,KAAK,CAAC,CAAC;IACjC,OAAO,IAAI,CAAC;AACd,CAAC;AAED,2EAA2E;AAC3E,MAAM,CAAC,KAAK,UAAU,0BAA0B,CAC9C,KAAqC;IAErC,MAAM,mBAAmB,CAAC,KAAK,CAAC,CAAC;IACjC,OAAO,SAAS,CAAC;AACnB,CAAC","sourcesContent":["import { CONTAINER_PATH_TOO_DEEP_MESSAGE } from \"../../../../data/containers/shared/containerPathLimits\";\nimport { localChildPathFits } from \"../localPathDepth\";\nimport type { ContainerCreateIntentSyncInput } from \"../types\";\n\n/** Record the depth refusal once; the intent then waits for a local move. */\nasync function recordTooDeepCreate(\n  input: ContainerCreateIntentSyncInput,\n): Promise<void> {\n  const { intent, state } = input;\n  if (intent.lastError === CONTAINER_PATH_TOO_DEEP_MESSAGE) return;\n  await state.persistence.recordCreateIntentRevisionError(\n    state.runtime.infra.execSql,\n    {\n      containerId: intent.containerId,\n      expectedIntentId: intent.id,\n      expectedUpdatedAt: intent.updatedAt,\n      message: CONTAINER_PATH_TOO_DEEP_MESSAGE,\n      stillCurrent: input.isCurrent,\n    },\n  );\n}\n\n/**\n * A create already refused for path length, or whose path is too deep here,\n * can never succeed, so waiting costs no request. Re-queuing the folder under\n * another parent (a local move) clears the recorded refusal and re-arms it.\n * Returns whether the create was deferred.\n */\nexport async function deferTooDeepCreate(\n  input: ContainerCreateIntentSyncInput,\n): Promise<boolean> {\n  const { intent, state } = input;\n  if (\n    intent.lastError !== CONTAINER_PATH_TOO_DEEP_MESSAGE &&\n    localChildPathFits(state.containersById, intent.parentContainerId)\n  ) {\n    return false;\n  }\n  await recordTooDeepCreate(input);\n  return true;\n}\n\n/** Record a refusal from the verified plan or the API; it is final too. */\nexport async function recordRefusedTooDeepCreate(\n  input: ContainerCreateIntentSyncInput,\n): Promise<\"blocked\"> {\n  await recordTooDeepCreate(input);\n  return \"blocked\";\n}\n"]}

package/workflows/container-contents/container-state/create/createIntentSettlement.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createIntentSettlement.js","sourceRoot":"","sources":["createIntentSettlement.ts"],"names":[],"mappings":"AAKA,MAAM,CAAC,KAAK,UAAU,2BAA2B,CAAC,KAUjD;IACC,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE;QAAE,OAAO,KAAK,CAAC;IACrC,MAAM,cAAc,GAAG,KAAK,CAAC,KAAK,CAAC,WAAW,CAAC,8BAA8B,CAAC;IAC9E,IAAI,CAAC,cAAc;QAAE,OAAO,KAAK,CAAC;IAClC,MAAM,OAAO,GAAG,MAAM,cAAc,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,EAAE;QACtE,WAAW,EAAE,KAAK,CAAC,MAAM,CAAC,WAAW;QACrC,gBAAgB,EAAE,KAAK,CAAC,MAAM,CAAC,EAAE;QACjC,iBAAiB,EAAE,KAAK,CAAC,MAAM,CAAC,SAAS;QACzC,iBAAiB,EAAE,KAAK,CAAC,iBAAiB;QAC1C,6BAA6B,EAAE,KAAK,CAAC,6BAA6B;QAClE,wBAAwB,EAAE,KAAK,CAAC,wBAAwB;QACxD,YAAY,EAAE,KAAK,CAAC,SAAS;QAC7B,8BAA8B,EAAE,KAAK,CAAC,8BAA8B;QACpE,wBAAwB,EAAE,KAAK,CAAC,wBAAwB;QACxD,wBAAwB,EAAE,KAAK,CAAC,wBAAwB;KACzD,CAAC,CAAC;IACH,OAAO,OAAO,IAAI,KAAK,CAAC,SAAS,EAAE,CAAC;AACtC,CAAC","sourcesContent":["import type {\n  ContainerCreateIntentSyncInput,\n  ContainerCreateIntentSyncState,\n} from \"../types\";\n\nexport async function settleContainerCreateIntent(input: {\n  intent: ContainerCreateIntentSyncInput[\"intent\"];\n  isCurrent: () => boolean;\n  remoteContainerId: string;\n  remoteMetadataAccessStateHash: string;\n  remoteMetadataDocumentId: string;\n  state: ContainerCreateIntentSyncState;\n  supersededMovePreviousParentId: string;\n  createdParentContainerId: string;\n  desiredParentContainerId: string;\n}): Promise<boolean> {\n  if (!input.isCurrent()) return false;\n  const settleRevision = input.state.persistence.markCreateIntentRevisionSynced;\n  if (!settleRevision) return false;\n  const settled = await settleRevision(input.state.runtime.infra.execSql, {\n    containerId: input.intent.containerId,\n    expectedIntentId: input.intent.id,\n    expectedUpdatedAt: input.intent.updatedAt,\n    remoteContainerId: input.remoteContainerId,\n    remoteMetadataAccessStateHash: input.remoteMetadataAccessStateHash,\n    remoteMetadataDocumentId: input.remoteMetadataDocumentId,\n    stillCurrent: input.isCurrent,\n    supersededMovePreviousParentId: input.supersededMovePreviousParentId,\n    createdParentContainerId: input.createdParentContainerId,\n    desiredParentContainerId: input.desiredParentContainerId,\n  });\n  return settled && input.isCurrent();\n}\n"]}

package/workflows/container-contents/container-state/create/createIntentSync.js

@@ -0,0 +1,354 @@
+import { ContainerPathTooDeepError } from "../../../../data/containers/shared/containerPathLimits.js";
+import { reportAndRethrowKeyingVerificationError } from "../../../../data/keyingProjectionVerification/error.js";
+import { ContainerCreateIntentSupersededError } from "../../../../data/persistence/container-contents/containerIntentPersistence.js";
+import { errorMessage } from "../../../../data/shared/errorMessage.js";
+import { createDetachedContainerMetadataState, installDetachedContainerMetadataState, } from "../../metadata/metadataStateIsolation.js";
+import { hasRemoteContainerMetadataState } from "../../remoteHydration/reconciliation.js";
+import { createRemoteContainer, deleteRemoteContainer } from "../remote.js";
+import { syncListedContainerCreate } from "./createAdoption.js";
+import { deferTooDeepCreate, recordRefusedTooDeepCreate, } from "./createIntentDepth.js";
+import { CONTAINER_ALREADY_COMMITTED } from "./createWithMetadata.js";
+class IncompleteContainerCreateSettlementError extends Error {
+}
+function currentCreateResult(isCurrent, result) {
+    return isCurrent() ? result : "abandoned";
+}
+async function reportContainerCreateIntegrityFailure(input) {
+    await reportAndRethrowKeyingVerificationError(input.error, input.state.runtime.util.reportSecurityIncident, {
+        objectId: input.containerId,
+        objectKind: "container",
+        operation: "container.create.replay",
+        organizationId: input.organizationId,
+    });
+}
+async function recordContainerCreateFailure(input) {
+    if (!input.isCurrent()) {
+        return "abandoned";
+    }
+    await reportContainerCreateIntegrityFailure({
+        containerId: input.intent.containerId,
+        error: input.error,
+        organizationId: input.organizationId,
+        state: input.state,
+    });
+    if (!input.isCurrent()) {
+        return "abandoned";
+    }
+    await input.state.persistence.recordCreateIntentRevisionError(input.state.runtime.infra.execSql, {
+        containerId: input.intent.containerId,
+        expectedIntentId: input.intent.id,
+        expectedUpdatedAt: input.intent.updatedAt,
+        message: `${input.error instanceof IncompleteContainerCreateSettlementError ? "Container create persistence failed" : "Remote container create failed"}: ${errorMessage(input.error)}`,
+        stillCurrent: input.isCurrent,
+    });
+    return currentCreateResult(input.isCurrent, "failed");
+}
+async function persistCreatedRemoteContainerStateFromIntent(input) {
+    const { containerState, created, host, intent, state } = input;
+    if (!input.isCurrent())
+        return "abandoned";
+    const persistenceCandidate = await createDetachedContainerMetadataState(containerState);
+    if (!input.isCurrent())
+        return "abandoned";
+    persistenceCandidate.container = {
+        ...persistenceCandidate.container,
+        createdAt: created.createdAt,
+        serverCreatedAt: created.createdAt,
+        serverUpdatedAt: created.updatedAt,
+        updatedAt: created.updatedAt,
+    };
+    let persistenceResult;
+    try {
+        persistenceResult = await host.persistContainerState(persistenceCandidate, {
+            accessEpoch: 1,
+            accessStateHash: created.accessManifestHash,
+            lastCommitLsn: null,
+            metadataDocumentId: created.metadataDocumentId,
+            systemSlot: created.systemSlot,
+            organizationId: created.organizationId,
+            parentId: created.parentId,
+            ...created.persistedMetadataState,
+        }, false, {
+            serverTimestamps: {
+                createdAt: created.createdAt,
+                updatedAt: created.updatedAt,
+            },
+        }, {
+            createIntentSettlement: {
+                containerId: intent.containerId,
+                expectedIntentId: intent.id,
+                expectedUpdatedAt: intent.updatedAt,
+                remoteContainerId: created.containerId,
+                remoteMetadataAccessStateHash: created.accessManifestHash,
+                remoteMetadataDocumentId: created.metadataDocumentId,
+                supersededMovePreviousParentId: created.parentId,
+            },
+            expectedStateWhenMissing: containerState,
+            isCurrent: input.isCurrent,
+            preserveDurableStructureWhenPending: true,
+        });
+    }
+    catch (error) {
+        if (error instanceof ContainerCreateIntentSupersededError) {
+            return "intent-superseded";
+        }
+        throw error;
+    }
+    if (!input.isCurrent() || persistenceResult.status === "stale-generation") {
+        return "abandoned";
+    }
+    if (persistenceResult.status !== "persisted")
+        return persistenceResult.status;
+    if (persistenceResult.createIntentSettled !== true) {
+        throw new IncompleteContainerCreateSettlementError("Container create persistence must settle the intent atomically");
+    }
+    const { record: nextRecord } = persistenceResult;
+    if (!input.isCurrent())
+        return "abandoned";
+    const currentContainerState = state.containersById.get(intent.containerId);
+    if (!currentContainerState)
+        return "missing";
+    if (currentContainerState !== containerState)
+        return "identity-superseded";
+    installDetachedContainerMetadataState(containerState, persistenceCandidate, {
+        candidateRecord: nextRecord,
+        preserveConcurrentMetadataEdit: true,
+    });
+    containerState.container = {
+        ...containerState.container,
+        metadataDocumentId: created.metadataDocumentId,
+        systemSlot: created.systemSlot,
+        organizationId: created.organizationId,
+        parentId: persistenceCandidate.container.parentId,
+        serverCreatedAt: created.createdAt,
+        serverUpdatedAt: created.updatedAt,
+        createdAt: created.createdAt,
+        updatedAt: created.updatedAt,
+    };
+    return "persisted";
+}
+async function discardOrphanedRemoteContainer(input) {
+    if (!input.isCurrent()) {
+        return;
+    }
+    const discardFailure = await deleteRemoteContainer({
+        containerId: input.created.containerId,
+        organizationId: input.created.organizationId,
+        runtime: input.state.runtime,
+    }).then((deleted) => (deleted ? null : "the server rejected the delete"), (error) => errorMessage(error));
+    if (input.isCurrent() && discardFailure !== null) {
+        input.state.runtime.util.log(`Container contents: failed to discard orphaned remote container ${input.created.containerId} after local delete: ${discardFailure}`);
+    }
+}
+async function settleRemoteContainerCreate(input) {
+    const { containerState, created, syncInput } = input;
+    const { host, intent, state } = syncInput;
+    if (created === CONTAINER_ALREADY_COMMITTED) {
+        // A lost create response leaves the intent pending until hydration installs
+        // the committed remote metadata state.
+        state.runtime.util.log(`Container contents: deferred create intent for ${intent.containerId}; container already committed remotely, awaiting hydration.`);
+        syncInput.requestRemoteReconciliation(intent.parentContainerId);
+        return "blocked";
+    }
+    if (!created) {
+        await state.persistence.recordCreateIntentRevisionError(state.runtime.infra.execSql, {
+            containerId: intent.containerId,
+            expectedIntentId: intent.id,
+            expectedUpdatedAt: intent.updatedAt,
+            message: "Remote container create was rejected or unavailable",
+            stillCurrent: syncInput.isCurrent,
+        });
+        return currentCreateResult(syncInput.isCurrent, "failed");
+    }
+    if (!state.containersById.has(intent.containerId)) {
+        // A same-generation local delete wins; discard the remote orphan instead
+        // of resurrecting the deleted local container.
+        await discardOrphanedRemoteContainer({
+            created,
+            isCurrent: syncInput.isCurrent,
+            state,
+        });
+        return currentCreateResult(syncInput.isCurrent, "failed");
+    }
+    const persistenceStatus = await persistCreatedRemoteContainerStateFromIntent({
+        containerState,
+        created,
+        host,
+        isCurrent: syncInput.isCurrent,
+        intent,
+        state,
+    });
+    if (persistenceStatus === "abandoned") {
+        syncInput.requestRemoteReconciliation(intent.parentContainerId);
+        return "abandoned";
+    }
+    if (persistenceStatus === "missing") {
+        await discardOrphanedRemoteContainer({
+            created,
+            isCurrent: syncInput.isCurrent,
+            state,
+        });
+        return currentCreateResult(syncInput.isCurrent, "failed");
+    }
+    if (persistenceStatus === "identity-superseded") {
+        state.runtime.util.log(`Container contents: deferred create intent for ${intent.containerId}; another writer persisted its remote identity.`);
+        syncInput.requestRemoteReconciliation(intent.parentContainerId);
+        return "blocked";
+    }
+    if (persistenceStatus === "intent-superseded") {
+        state.runtime.util.log(`Container contents: deferred create intent for ${intent.containerId}; a newer local intent superseded this pass.`);
+        return "blocked";
+    }
+    state.runtime.util.log(`Container contents: synced local container create ${containerState.container.id}`);
+    return "created";
+}
+async function createPendingRemoteContainer(input) {
+    const { containerState, parentState, syncInput } = input;
+    const { intent, state } = syncInput;
+    let created;
+    try {
+        created = await createRemoteContainer({
+            systemSlot: containerState.container.systemSlot,
+            containerId: containerState.container.id,
+            parentContainerId: parentState.container.id,
+            resolveProjectionUserKey: state.resolveProjectionUserKey,
+            runtime: state.runtime,
+            stillCurrent: syncInput.isCurrent,
+        });
+    }
+    catch (error) {
+        if (error instanceof ContainerPathTooDeepError)
+            return recordRefusedTooDeepCreate(syncInput);
+        return recordContainerCreateFailure({
+            error,
+            isCurrent: syncInput.isCurrent,
+            intent,
+            organizationId: parentState.container.organizationId,
+            state,
+        });
+    }
+    if (!syncInput.isCurrent()) {
+        syncInput.requestRemoteReconciliation(intent.parentContainerId);
+        return "abandoned";
+    }
+    try {
+        return await settleRemoteContainerCreate({
+            containerState,
+            created,
+            syncInput,
+        });
+    }
+    catch (error) {
+        if (!(error instanceof IncompleteContainerCreateSettlementError))
+            throw error;
+        return recordContainerCreateFailure({
+            error,
+            isCurrent: syncInput.isCurrent,
+            intent,
+            organizationId: parentState.container.organizationId,
+            state,
+        });
+    }
+}
+async function trySyncPendingContainerContentsContainerCreateIntent(input) {
+    const { intent, state } = input;
+    if (!input.isCurrent()) {
+        return "abandoned";
+    }
+    const containerState = state.containersById.get(intent.containerId);
+    const parentState = state.containersById.get(intent.parentContainerId);
+    if (!containerState || !parentState) {
+        const execSql = state.runtime.infra.execSql;
+        await state.persistence.recordCreateIntentRevisionError(execSql, {
+            containerId: intent.containerId,
+            expectedIntentId: intent.id,
+            expectedUpdatedAt: intent.updatedAt,
+            message: "Container create intent references a missing local container",
+            stillCurrent: input.isCurrent,
+        });
+        return currentCreateResult(input.isCurrent, "failed");
+    }
+    if (typeof state.persistence.markCreateIntentRevisionSynced !== "function") {
+        await state.persistence.recordCreateIntentRevisionError(state.runtime.infra.execSql, {
+            containerId: intent.containerId,
+            expectedIntentId: intent.id,
+            expectedUpdatedAt: intent.updatedAt,
+            message: "Container create replay requires revision-CAS persistence",
+            stillCurrent: input.isCurrent,
+        });
+        return currentCreateResult(input.isCurrent, "failed");
+    }
+    if (input.isRemoteSyncBlocked(parentState.container.organizationId)) {
+        return "blocked";
+    }
+    if (hasRemoteContainerMetadataState(containerState)) {
+        return syncListedContainerCreate({
+            containerState,
+            parentState,
+            syncInput: input,
+        });
+    }
+    // A parent whose own create has not settled may carry a listed identity
+    // adoption has not verified, or has refused; nothing is created under it.
+    if (!hasRemoteContainerMetadataState(parentState) ||
+        input.isCreatePending(parentState.container.id)) {
+        return "blocked";
+    }
+    if (await deferTooDeepCreate(input)) {
+        return currentCreateResult(input.isCurrent, "blocked");
+    }
+    return createPendingRemoteContainer({
+        containerState,
+        parentState,
+        syncInput: input,
+    });
+}
+export async function syncPendingContainerCreateIntents(input) {
+    if (!input.isCurrent()) {
+        return 0;
+    }
+    const { host } = input;
+    const state = { ...input.state };
+    const execSql = state.runtime.infra.execSql;
+    const pendingIntents = await state.persistence.listPendingCreateIntents(execSql);
+    if (!input.isCurrent()) {
+        return 0;
+    }
+    const remainingContainerIds = new Set(pendingIntents.map((intent) => intent.containerId));
+    // Only a create that settles in this pass leaves the pending set; a failed
+    // or parked one stays pending even though this pass stops retrying it.
+    const unsettledContainerIds = new Set(remainingContainerIds);
+    let createdCount = 0;
+    let progressed = true;
+    while (progressed && input.isCurrent()) {
+        progressed = false;
+        for (const intent of pendingIntents) {
+            if (!remainingContainerIds.has(intent.containerId)) {
+                continue;
+            }
+            const result = await trySyncPendingContainerContentsContainerCreateIntent({
+                host,
+                isCreatePending: (containerId) => unsettledContainerIds.has(containerId),
+                isCurrent: input.isCurrent,
+                isRemoteSyncBlocked: input.isRemoteSyncBlocked,
+                intent,
+                requestRemoteReconciliation: input.requestRemoteReconciliation,
+                state,
+            });
+            if (result === "abandoned") {
+                return createdCount;
+            }
+            if (result === "blocked") {
+                continue;
+            }
+            remainingContainerIds.delete(intent.containerId);
+            progressed = result === "created" || progressed;
+            if (result === "created") {
+                createdCount += 1;
+                unsettledContainerIds.delete(intent.containerId);
+            }
+        }
+    }
+    return createdCount;
+}
+//# sourceMappingURL=createIntentSync.js.map