@tearleads/client-sdk 0.0.0-stage → 0.1.13

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

@@ -0,0 +1,154 @@
+import type { ListContainerParentLanesRequest } from "../../internal/validators/request/index.js";
+import type { EffectiveAccessLevel, ReferencedPrincipalStateResponse, SyncWatermark } from "../../internal/validators/response/index.js";
+import type { DiscoveredDocumentInput, DocumentSummary } from "../../data/documents/documentSummary.js";
+import type { DiscoveredDocumentCandidate } from "../../data/persistence/documents/documentDiscoveryEvidencePersistence.js";
+export interface ListedContainerDocument {
+    createdAt: string;
+    currentAccessEpoch: number;
+    currentAccessStateHash: string;
+    effectiveAccessLevel?: EffectiveAccessLevel | undefined;
+    id: string;
+    linkedContainerIds: string[];
+    referencedPrincipals: ReferencedPrincipalStateResponse[];
+    updatedAt: string;
+}
+export interface ListContainerDocumentsResponse {
+    hasMore: boolean;
+    items: ListedContainerDocument[];
+    nextWatermark: SyncWatermark | null;
+    tombstones: ReadonlyArray<{
+        containerId: string;
+        documentId: string;
+        updatedAt: string;
+    }>;
+}
+export interface ListedContainer {
+    id: string;
+}
+export interface ListContainersResponse {
+    hasMore: boolean;
+    items: ListedContainer[];
+    nextWatermark: SyncWatermark | null;
+}
+export interface ListContainerParentLanesResponse {
+    results: ReadonlyArray<{
+        laneId: string;
+        page: ListContainersResponse;
+    }>;
+}
+export interface ContainerDocumentDiscoveryApi {
+    readonly listContainerDocuments: (containerId: string, options?: {
+        watermark?: SyncWatermark | null;
+    }) => Promise<ListContainerDocumentsResponse | null>;
+    readonly listContainerDocumentsResult?: (containerId: string, options?: {
+        watermark?: SyncWatermark | null;
+    }, requestOptions?: {
+        reportErrors?: boolean | undefined;
+    }) => Promise<{
+        readonly data: ListContainerDocumentsResponse;
+        readonly ok: true;
+    } | {
+        readonly message: string;
+        readonly ok: false;
+        readonly report: () => void;
+        readonly status: number | null;
+    }>;
+    readonly listContainerParentLanes: (input: ListContainerParentLanesRequest) => Promise<ListContainerParentLanesResponse | null>;
+}
+export interface DocumentLinkInput {
+    accessEpoch?: number | undefined;
+    containerIds: ReadonlyArray<string>;
+    documentId: string;
+}
+export type ContainerDocumentTombstone = ListContainerDocumentsResponse["tombstones"][number];
+export interface VerifiedContainerDocumentTombstone extends ContainerDocumentTombstone {
+    /** The verified head's link-set epoch, not below the local document epoch. */
+    readonly accessEpoch: number;
+    /** The verified head link set; it omits `containerId`. */
+    readonly linkedContainerIds: ReadonlyArray<string>;
+}
+/**
+ * What the document's signed head says about a listing tombstone.
+ * - `verified`: the verified head link set omits the container; apply.
+ * - `refuted`: the verified head still links the container; keep visible and retry.
+ * - `unverified`: no verified head is available; hold, hide, retry later.
+ * - `deferred`: not attempted this run (the per-run head-load cap); hold
+ *   without counting an attempt, so the retry backoff does not grow.
+ */
+export type ContainerDocumentTombstoneVerdict = {
+    readonly kind: "verified";
+    readonly tombstone: VerifiedContainerDocumentTombstone;
+} | {
+    readonly kind: "refuted";
+    /** The verified head link set, which contains the container. */
+    readonly linkedContainerIds: ReadonlyArray<string>;
+    readonly tombstone: ContainerDocumentTombstone;
+} | {
+    readonly kind: "unverified";
+    readonly tombstone: ContainerDocumentTombstone;
+} | {
+    readonly kind: "deferred";
+    readonly tombstone: ContainerDocumentTombstone;
+};
+export interface HeldContainerDocumentTombstoneInput extends ContainerDocumentTombstone {
+    /** Held without a verification attempt; the backoff does not advance. */
+    readonly deferred?: boolean | undefined;
+    /** A verified head still links it; retry the tombstone while keeping it visible. */
+    readonly refuted?: boolean | undefined;
+}
+export type ContainerDocumentTombstoneVerifier = (tombstones: ReadonlyArray<ContainerDocumentTombstone>) => Promise<ReadonlyArray<ContainerDocumentTombstoneVerdict>>;
+export type ContainerDocumentPlacement = Pick<ContainerDocumentTombstone, "containerId" | "documentId">;
+export interface ContainerDocumentTombstoneHoldStore {
+    holdContainerDocumentTombstones: (tombstones: ReadonlyArray<HeldContainerDocumentTombstoneInput>) => Promise<void>;
+    /** Held tombstones on these containers that are due for another attempt. */
+    listHeldContainerDocumentTombstones: (containerIds: ReadonlyArray<string>) => Promise<ReadonlyArray<ContainerDocumentTombstone>>;
+    /** The subset of placements that exist locally (link row or primary). */
+    listKnownContainerDocumentPlacements: (placements: ReadonlyArray<ContainerDocumentPlacement>) => Promise<ReadonlyArray<ContainerDocumentPlacement>>;
+    refuteContainerDocumentTombstoneHolds: (placements: ReadonlyArray<ContainerDocumentPlacement>) => Promise<void>;
+}
+export interface DiscoverContainerDocumentsOptions extends ContainerDocumentTombstoneHoldStore {
+    applyContainerDocumentTombstones: (tombstones: ReadonlyArray<VerifiedContainerDocumentTombstone>) => Promise<ReadonlyArray<DocumentSummary>>;
+    verifyContainerDocumentTombstones: ContainerDocumentTombstoneVerifier;
+    /** Allocate durable local order before fetching a listing. */
+    beginDocumentDiscovery: () => Promise<number>;
+    /** Persist pending candidates and return only signed placements. */
+    verifyDiscoveredDocuments: (inputs: ReadonlyArray<DiscoveredDocumentCandidate>, containerIds: ReadonlyArray<string>, generation: number, tombstones?: ReadonlyArray<ContainerDocumentTombstone>) => Promise<{
+        inputs: ReadonlyArray<DiscoveredDocumentInput>;
+        /** False once a remote trust reset cancels this listing pass. */
+        isCurrent: () => Promise<boolean>;
+        /** Acknowledge only after local apply; true means no pending candidates remain. */
+        commit: () => Promise<boolean>;
+    }>;
+    cacheReferencedPrincipalPolicies?: (references: ReadonlyArray<ReferencedPrincipalStateResponse>) => Promise<void>;
+    containerId: string;
+    /** Completed unwatermarked listing, published only after local apply succeeds. */
+    onFullListing?: ((documentIds: ReadonlyArray<string>) => void) | undefined;
+    loadContainerDocumentWatermark: (containerId: string) => Promise<SyncWatermark | null>;
+    listContainerDocuments: ContainerDocumentDiscoveryApi["listContainerDocuments"];
+    replaceDocumentLinksBatch: (inputs: ReadonlyArray<DocumentLinkInput>) => Promise<void>;
+    saveContainerDocumentWatermark: (containerId: string, watermark: SyncWatermark) => Promise<void>;
+    upsertDiscoveredDocuments: (inputs: ReadonlyArray<DiscoveredDocumentInput>) => Promise<ReadonlyArray<DocumentSummary>>;
+}
+export interface ListedContainerDocuments {
+    isFullListing: boolean;
+    items: ListedContainerDocument[];
+    nextWatermark: SyncWatermark | null;
+    tombstones: ContainerDocumentTombstone[];
+}
+export interface ContainerParentDiscoveryLane {
+    parentId: string | null;
+    watermark: SyncWatermark | null;
+}
+export interface ListedContainerDocumentsLane {
+    containerId: string;
+    listedDocuments: ListedContainerDocuments | null;
+}
+export interface DiscoverAllContainerDocumentsOptions extends Omit<DiscoverContainerDocumentsOptions, "containerId"> {
+    containerIds: ReadonlyArray<string>;
+}
+export interface RefreshAllContainerDocumentsOptions extends Omit<DiscoverAllContainerDocumentsOptions, "containerIds"> {
+    listContainerParentLanes: ContainerDocumentDiscoveryApi["listContainerParentLanes"];
+}
+export interface RefreshAllContainerDocumentsFromApiOptions extends Omit<RefreshAllContainerDocumentsOptions, "listContainerDocuments" | "listContainerParentLanes"> {
+    readonly apiClient: Pick<ContainerDocumentDiscoveryApi, "listContainerDocuments" | "listContainerDocumentsResult" | "listContainerParentLanes">;
+}

package/workflows/container-contents/documentDiscoveryTypes.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"documentDiscoveryTypes.js","sourceRoot":"","sources":["documentDiscoveryTypes.ts"],"names":[],"mappings":"","sourcesContent":["import type { ListContainerParentLanesRequest } from \"@tearleads/validators/request\";\nimport type {\n  EffectiveAccessLevel,\n  ReferencedPrincipalStateResponse,\n  SyncWatermark,\n} from \"@tearleads/validators/response\";\nimport type {\n  DiscoveredDocumentInput,\n  DocumentSummary,\n} from \"../../data/documents/documentSummary\";\nimport type { DiscoveredDocumentCandidate } from \"../../data/persistence/documents/documentDiscoveryEvidencePersistence\";\n\nexport interface ListedContainerDocument {\n  createdAt: string;\n  currentAccessEpoch: number;\n  currentAccessStateHash: string;\n  effectiveAccessLevel?: EffectiveAccessLevel | undefined;\n  id: string;\n  linkedContainerIds: string[];\n  referencedPrincipals: ReferencedPrincipalStateResponse[];\n  updatedAt: string;\n}\n\nexport interface ListContainerDocumentsResponse {\n  hasMore: boolean;\n  items: ListedContainerDocument[];\n  nextWatermark: SyncWatermark | null;\n  tombstones: ReadonlyArray<{\n    containerId: string;\n    documentId: string;\n    updatedAt: string;\n  }>;\n}\n\nexport interface ListedContainer {\n  id: string;\n}\n\nexport interface ListContainersResponse {\n  hasMore: boolean;\n  items: ListedContainer[];\n  nextWatermark: SyncWatermark | null;\n}\n\nexport interface ListContainerParentLanesResponse {\n  results: ReadonlyArray<{\n    laneId: string;\n    page: ListContainersResponse;\n  }>;\n}\n\nexport interface ContainerDocumentDiscoveryApi {\n  readonly listContainerDocuments: (\n    containerId: string,\n    options?: { watermark?: SyncWatermark | null },\n  ) => Promise<ListContainerDocumentsResponse | null>;\n  readonly listContainerDocumentsResult?: (\n    containerId: string,\n    options?: { watermark?: SyncWatermark | null },\n    requestOptions?: { reportErrors?: boolean | undefined },\n  ) => Promise<\n    | {\n        readonly data: ListContainerDocumentsResponse;\n        readonly ok: true;\n      }\n    | {\n        readonly message: string;\n        readonly ok: false;\n        readonly report: () => void;\n        readonly status: number | null;\n      }\n  >;\n  readonly listContainerParentLanes: (\n    input: ListContainerParentLanesRequest,\n  ) => Promise<ListContainerParentLanesResponse | null>;\n}\n\nexport interface DocumentLinkInput {\n  accessEpoch?: number | undefined;\n  containerIds: ReadonlyArray<string>;\n  documentId: string;\n}\n\nexport type ContainerDocumentTombstone =\n  ListContainerDocumentsResponse[\"tombstones\"][number];\n\nexport interface VerifiedContainerDocumentTombstone\n  extends ContainerDocumentTombstone {\n  /** The verified head's link-set epoch, not below the local document epoch. */\n  readonly accessEpoch: number;\n  /** The verified head link set; it omits `containerId`. */\n  readonly linkedContainerIds: ReadonlyArray<string>;\n}\n\n/**\n * What the document's signed head says about a listing tombstone.\n * - `verified`: the verified head link set omits the container; apply.\n * - `refuted`: the verified head still links the container; keep visible and retry.\n * - `unverified`: no verified head is available; hold, hide, retry later.\n * - `deferred`: not attempted this run (the per-run head-load cap); hold\n *   without counting an attempt, so the retry backoff does not grow.\n */\nexport type ContainerDocumentTombstoneVerdict =\n  | {\n      readonly kind: \"verified\";\n      readonly tombstone: VerifiedContainerDocumentTombstone;\n    }\n  | {\n      readonly kind: \"refuted\";\n      /** The verified head link set, which contains the container. */\n      readonly linkedContainerIds: ReadonlyArray<string>;\n      readonly tombstone: ContainerDocumentTombstone;\n    }\n  | {\n      readonly kind: \"unverified\";\n      readonly tombstone: ContainerDocumentTombstone;\n    }\n  | {\n      readonly kind: \"deferred\";\n      readonly tombstone: ContainerDocumentTombstone;\n    };\n\nexport interface HeldContainerDocumentTombstoneInput\n  extends ContainerDocumentTombstone {\n  /** Held without a verification attempt; the backoff does not advance. */\n  readonly deferred?: boolean | undefined;\n  /** A verified head still links it; retry the tombstone while keeping it visible. */\n  readonly refuted?: boolean | undefined;\n}\n\nexport type ContainerDocumentTombstoneVerifier = (\n  tombstones: ReadonlyArray<ContainerDocumentTombstone>,\n) => Promise<ReadonlyArray<ContainerDocumentTombstoneVerdict>>;\n\nexport type ContainerDocumentPlacement = Pick<\n  ContainerDocumentTombstone,\n  \"containerId\" | \"documentId\"\n>;\n\nexport interface ContainerDocumentTombstoneHoldStore {\n  holdContainerDocumentTombstones: (\n    tombstones: ReadonlyArray<HeldContainerDocumentTombstoneInput>,\n  ) => Promise<void>;\n  /** Held tombstones on these containers that are due for another attempt. */\n  listHeldContainerDocumentTombstones: (\n    containerIds: ReadonlyArray<string>,\n  ) => Promise<ReadonlyArray<ContainerDocumentTombstone>>;\n  /** The subset of placements that exist locally (link row or primary). */\n  listKnownContainerDocumentPlacements: (\n    placements: ReadonlyArray<ContainerDocumentPlacement>,\n  ) => Promise<ReadonlyArray<ContainerDocumentPlacement>>;\n  refuteContainerDocumentTombstoneHolds: (\n    placements: ReadonlyArray<ContainerDocumentPlacement>,\n  ) => Promise<void>;\n}\n\nexport interface DiscoverContainerDocumentsOptions\n  extends ContainerDocumentTombstoneHoldStore {\n  applyContainerDocumentTombstones: (\n    tombstones: ReadonlyArray<VerifiedContainerDocumentTombstone>,\n  ) => Promise<ReadonlyArray<DocumentSummary>>;\n  verifyContainerDocumentTombstones: ContainerDocumentTombstoneVerifier;\n  /** Allocate durable local order before fetching a listing. */\n  beginDocumentDiscovery: () => Promise<number>;\n  /** Persist pending candidates and return only signed placements. */\n  verifyDiscoveredDocuments: (\n    inputs: ReadonlyArray<DiscoveredDocumentCandidate>,\n    containerIds: ReadonlyArray<string>,\n    generation: number,\n    tombstones?: ReadonlyArray<ContainerDocumentTombstone>,\n  ) => Promise<{\n    inputs: ReadonlyArray<DiscoveredDocumentInput>;\n    /** False once a remote trust reset cancels this listing pass. */\n    isCurrent: () => Promise<boolean>;\n    /** Acknowledge only after local apply; true means no pending candidates remain. */\n    commit: () => Promise<boolean>;\n  }>;\n  cacheReferencedPrincipalPolicies?: (\n    references: ReadonlyArray<ReferencedPrincipalStateResponse>,\n  ) => Promise<void>;\n  containerId: string;\n  /** Completed unwatermarked listing, published only after local apply succeeds. */\n  onFullListing?: ((documentIds: ReadonlyArray<string>) => void) | undefined;\n  loadContainerDocumentWatermark: (\n    containerId: string,\n  ) => Promise<SyncWatermark | null>;\n  listContainerDocuments: ContainerDocumentDiscoveryApi[\"listContainerDocuments\"];\n  replaceDocumentLinksBatch: (\n    inputs: ReadonlyArray<DocumentLinkInput>,\n  ) => Promise<void>;\n  saveContainerDocumentWatermark: (\n    containerId: string,\n    watermark: SyncWatermark,\n  ) => Promise<void>;\n  upsertDiscoveredDocuments: (\n    inputs: ReadonlyArray<DiscoveredDocumentInput>,\n  ) => Promise<ReadonlyArray<DocumentSummary>>;\n}\n\nexport interface ListedContainerDocuments {\n  isFullListing: boolean;\n  items: ListedContainerDocument[];\n  nextWatermark: SyncWatermark | null;\n  tombstones: ContainerDocumentTombstone[];\n}\n\nexport interface ContainerParentDiscoveryLane {\n  parentId: string | null;\n  watermark: SyncWatermark | null;\n}\n\nexport interface ListedContainerDocumentsLane {\n  containerId: string;\n  listedDocuments: ListedContainerDocuments | null;\n}\n\nexport interface DiscoverAllContainerDocumentsOptions\n  extends Omit<DiscoverContainerDocumentsOptions, \"containerId\"> {\n  containerIds: ReadonlyArray<string>;\n}\n\nexport interface RefreshAllContainerDocumentsOptions\n  extends Omit<DiscoverAllContainerDocumentsOptions, \"containerIds\"> {\n  listContainerParentLanes: ContainerDocumentDiscoveryApi[\"listContainerParentLanes\"];\n}\n\nexport interface RefreshAllContainerDocumentsFromApiOptions\n  extends Omit<\n    RefreshAllContainerDocumentsOptions,\n    \"listContainerDocuments\" | \"listContainerParentLanes\"\n  > {\n  readonly apiClient: Pick<\n    ContainerDocumentDiscoveryApi,\n    | \"listContainerDocuments\"\n    | \"listContainerDocumentsResult\"\n    | \"listContainerParentLanes\"\n  >;\n}\n"]}

package/workflows/container-contents/documentFieldBlame.js

@@ -0,0 +1,26 @@
+import { base64ToBytes } from "../../internal/encoding/index.js";
+import { listSnapshotFieldEditors } from "../../internal/loro/index.js";
+import { DOCUMENT_FIELDS_MAP_KEY } from "../../data/documents/documentKinds.js";
+import { summarizeFieldBlame, } from "../../data/documents/editAttribution.js";
+/**
+ * Per-field "blame" for a structured document: read the peer that last set each
+ * field from the locally persisted snapshot and resolve it against the
+ * attribution segments. Reconstructing the small `fields` map is cheap (no
+ * per-character sweep), so this runs its own reconstruction independent of the
+ * character-blame path. Returns null when it can't be produced — no local
+ * snapshot or an unreadable one — mirroring the character-blame degrade-to-null;
+ * a note (or any document without fields) yields an empty array, not null.
+ */
+export function computeFieldBlame(contentSnapshot, segments) {
+    if (!contentSnapshot || contentSnapshot.length === 0) {
+        return null;
+    }
+    try {
+        const fieldEditors = listSnapshotFieldEditors(base64ToBytes(contentSnapshot), DOCUMENT_FIELDS_MAP_KEY);
+        return summarizeFieldBlame(fieldEditors, segments);
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=documentFieldBlame.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"documentFieldBlame.js","sourceRoot":"","sources":["documentFieldBlame.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,wBAAwB,EAAE,MAAM,iBAAiB,CAAC;AAE3D,OAAO,EAAE,uBAAuB,EAAE,MAAM,oCAAoC,CAAC;AAC7E,OAAO,EAEL,mBAAmB,GACpB,MAAM,sCAAsC,CAAC;AAE9C;;;;;;;;GAQG;AACH,MAAM,UAAU,iBAAiB,CAC/B,eAA8B,EAC9B,QAAqD;IAErD,IAAI,CAAC,eAAe,IAAI,eAAe,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACrD,OAAO,IAAI,CAAC;IACd,CAAC;IACD,IAAI,CAAC;QACH,MAAM,YAAY,GAAG,wBAAwB,CAC3C,aAAa,CAAC,eAAe,CAAC,EAC9B,uBAAuB,CACxB,CAAC;QACF,OAAO,mBAAmB,CAAC,YAAY,EAAE,QAAQ,CAAC,CAAC;IACrD,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC","sourcesContent":["import { base64ToBytes } from \"@tearleads/encoding\";\nimport { listSnapshotFieldEditors } from \"@tearleads/loro\";\nimport type { DocumentEditAttributionResponse } from \"@tearleads/validators/response\";\nimport { DOCUMENT_FIELDS_MAP_KEY } from \"../../data/documents/documentKinds\";\nimport {\n  type DocumentFieldBlame,\n  summarizeFieldBlame,\n} from \"../../data/documents/editAttribution\";\n\n/**\n * Per-field \"blame\" for a structured document: read the peer that last set each\n * field from the locally persisted snapshot and resolve it against the\n * attribution segments. Reconstructing the small `fields` map is cheap (no\n * per-character sweep), so this runs its own reconstruction independent of the\n * character-blame path. Returns null when it can't be produced — no local\n * snapshot or an unreadable one — mirroring the character-blame degrade-to-null;\n * a note (or any document without fields) yields an empty array, not null.\n */\nexport function computeFieldBlame(\n  contentSnapshot: string | null,\n  segments: DocumentEditAttributionResponse[\"segments\"],\n): DocumentFieldBlame[] | null {\n  if (!contentSnapshot || contentSnapshot.length === 0) {\n    return null;\n  }\n  try {\n    const fieldEditors = listSnapshotFieldEditors(\n      base64ToBytes(contentSnapshot),\n      DOCUMENT_FIELDS_MAP_KEY,\n    );\n    return summarizeFieldBlame(fieldEditors, segments);\n  } catch {\n    return null;\n  }\n}\n"]}

package/workflows/container-contents/documentHeadScope.js

@@ -0,0 +1,9 @@
+/** Live placement evidence belongs to one organization; purge pins are terminal. */
+export function documentHeadMatchesOrganization(head, organizationId) {
+    const terminalPurge = head.organizationId === null &&
+        !head.accessStateHash &&
+        head.accessEpoch === Number.MAX_SAFE_INTEGER;
+    return (terminalPurge ||
+        Boolean(organizationId && head.organizationId === organizationId));
+}
+//# sourceMappingURL=documentHeadScope.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"documentHeadScope.js","sourceRoot":"","sources":["documentHeadScope.ts"],"names":[],"mappings":"AAAA,oFAAoF;AACpF,MAAM,UAAU,+BAA+B,CAC7C,IAIC,EACD,cAAkC;IAElC,MAAM,aAAa,GACjB,IAAI,CAAC,cAAc,KAAK,IAAI;QAC5B,CAAC,IAAI,CAAC,eAAe;QACrB,IAAI,CAAC,WAAW,KAAK,MAAM,CAAC,gBAAgB,CAAC;IAC/C,OAAO,CACL,aAAa;QACb,OAAO,CAAC,cAAc,IAAI,IAAI,CAAC,cAAc,KAAK,cAAc,CAAC,CAClE,CAAC;AACJ,CAAC","sourcesContent":["/** Live placement evidence belongs to one organization; purge pins are terminal. */\nexport function documentHeadMatchesOrganization(\n  head: {\n    readonly organizationId: string | null;\n    readonly accessEpoch: number;\n    readonly accessStateHash?: string | undefined;\n  },\n  organizationId: string | undefined,\n): boolean {\n  const terminalPurge =\n    head.organizationId === null &&\n    !head.accessStateHash &&\n    head.accessEpoch === Number.MAX_SAFE_INTEGER;\n  return (\n    terminalPurge ||\n    Boolean(organizationId && head.organizationId === organizationId)\n  );\n}\n"]}

package/workflows/container-contents/documentHydrationProbe.js

@@ -0,0 +1,146 @@
+import { HIDDEN_DOCUMENT_SUMMARY_KINDS } from "../../data/documents/documentSummary.js";
+import { documentContainerProjectionTables, documentProjectionTables, documentTables, } from "../../data/sqlite/schema.js";
+import { ensureSqlTables } from "../../data/sqlite/sqlSchema.js";
+import { listContainerContentsSqlIdBatches } from "./documentQueries/sql.js";
+import { requestRemoteDocumentRuntimeTargetSync } from "./documentRuntimeTargetSync.js";
+const DOCUMENT_HYDRATION_PROBE_REQUEST_BATCH_SIZE = 8;
+const DOCUMENT_HYDRATION_PROBE_SCAN_BATCH_SIZE = 64;
+function valuePlaceholders(values) {
+    return values.map(() => "?").join(", ");
+}
+function valueRows(values) {
+    return values.map(() => "(?)").join(", ");
+}
+function readProbeTarget(row) {
+    // These aliases are wholly internal SQL contracts; fail loudly if a query
+    // edit violates them instead of silently skipping a persisted document.
+    if (row === null || (typeof row !== "object" && typeof row !== "function")) {
+        throw new Error("Document hydration probe returned an invalid target");
+    }
+    const documentId = Reflect.get(row, "document_id");
+    const localId = Reflect.get(row, "local_id");
+    const projectedContainerId = Reflect.get(row, "projected_container_id");
+    const runtimeContainerId = Reflect.get(row, "container_id");
+    if (typeof documentId !== "string" ||
+        typeof localId !== "string" ||
+        typeof runtimeContainerId !== "string") {
+        throw new Error("Document hydration probe returned an invalid target");
+    }
+    return {
+        documentId,
+        localId,
+        preferredRuntimeContainer: projectedContainerId === runtimeContainerId,
+        runtimeContainerId,
+    };
+}
+async function listRemoteDocumentProbeBatchForContainerIds(input) {
+    const rows = await input.runtime.infra.execSql(`
+      WITH eligible_container_ids(container_id) AS (
+        VALUES ${valueRows(input.containerIds)}
+      )
+      SELECT
+        stored.local_id AS local_id,
+        stored.document_id AS document_id,
+        projection.container_id AS projected_container_id,
+        COALESCE(
+          projected_container.container_id,
+          MIN(linked_container.container_id)
+        ) AS container_id
+      FROM documents stored
+      INNER JOIN document_projection projection
+        ON projection.local_id = stored.local_id
+      LEFT JOIN eligible_container_ids projected_container
+        ON projected_container.container_id = projection.container_id
+      LEFT JOIN document_container_projection link
+        ON link.document_id = stored.document_id
+      LEFT JOIN eligible_container_ids linked_container
+        ON linked_container.container_id = link.container_id
+      WHERE stored.app_kind = 'documents'
+        AND stored.document_id IS NOT NULL
+        AND (? IS NULL OR stored.local_id > ?)
+        AND (
+          projected_container.container_id IS NOT NULL
+          OR linked_container.container_id IS NOT NULL
+        )
+        AND projection.document_kind NOT IN (${valuePlaceholders(HIDDEN_DOCUMENT_SUMMARY_KINDS)})
+      GROUP BY
+        stored.local_id,
+        stored.document_id,
+        projection.container_id,
+        projected_container.container_id
+      ORDER BY stored.local_id ASC
+      LIMIT ?
+    `, [
+        ...input.containerIds,
+        input.afterLocalId,
+        input.afterLocalId,
+        ...HIDDEN_DOCUMENT_SUMMARY_KINDS,
+        DOCUMENT_HYDRATION_PROBE_SCAN_BATCH_SIZE,
+    ]);
+    return rows.map(readProbeTarget);
+}
+function mergeRemoteDocumentProbeTargets(batches) {
+    const targetsByLocalId = new Map();
+    for (const batch of batches) {
+        for (const target of batch) {
+            const existing = targetsByLocalId.get(target.localId);
+            if (existing === undefined ||
+                (target.preferredRuntimeContainer &&
+                    !existing.preferredRuntimeContainer) ||
+                (target.preferredRuntimeContainer ===
+                    existing.preferredRuntimeContainer &&
+                    target.runtimeContainerId < existing.runtimeContainerId)) {
+                targetsByLocalId.set(target.localId, target);
+            }
+        }
+    }
+    return [...targetsByLocalId.values()]
+        .sort((left, right) => left.localId < right.localId ? -1 : Number(left.localId > right.localId))
+        .slice(0, DOCUMENT_HYDRATION_PROBE_SCAN_BATCH_SIZE);
+}
+async function listRemoteDocumentProbeBatch(input) {
+    const containerIds = [...input.listedContainerIds];
+    if (containerIds.length === 0) {
+        return [];
+    }
+    await ensureSqlTables(input.runtime.infra.execSql, [
+        ...documentTables,
+        ...documentProjectionTables,
+        ...documentContainerProjectionTables,
+    ]);
+    const batches = [];
+    for (const containerIdBatch of listContainerContentsSqlIdBatches(containerIds)) {
+        batches.push(await listRemoteDocumentProbeBatchForContainerIds({
+            afterLocalId: input.afterLocalId,
+            containerIds: containerIdBatch,
+            runtime: input.runtime,
+        }));
+    }
+    return mergeRemoteDocumentProbeTargets(batches);
+}
+/**
+ * Opens at most one bounded batch of visible, remote-backed local documents
+ * linked to an authoritatively listed container but absent from every full
+ * listing. Each store's ordinary sync pass owns its coded-404/403 verdict.
+ */
+export async function probeUndiscoveredRemoteDocumentBatch(input) {
+    const scanned = await listRemoteDocumentProbeBatch(input);
+    const candidates = scanned.filter((target) => !input.listedDocumentIds.has(target.documentId));
+    const targets = candidates.slice(0, DOCUMENT_HYDRATION_PROBE_REQUEST_BATCH_SIZE);
+    const requested = await requestRemoteDocumentRuntimeTargetSync({
+        host: input.host,
+        targets,
+    });
+    const hasUnrequestedCandidate = candidates.length > targets.length;
+    const scanPageMayContinue = scanned.length === DOCUMENT_HYDRATION_PROBE_SCAN_BATCH_SIZE;
+    const done = !hasUnrequestedCandidate && !scanPageMayContinue;
+    const nextCursorTarget = hasUnrequestedCandidate
+        ? targets.at(-1)
+        : scanned.at(-1);
+    return {
+        done,
+        nextCursor: done ? null : (nextCursorTarget?.localId ?? null),
+        requestedCount: requested.size,
+    };
+}
+//# sourceMappingURL=documentHydrationProbe.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"documentHydrationProbe.js","sourceRoot":"","sources":["documentHydrationProbe.ts"],"names":[],"mappings":"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","sourcesContent":["import { HIDDEN_DOCUMENT_SUMMARY_KINDS } from \"../../data/documents/documentSummary\";\nimport {\n  documentContainerProjectionTables,\n  documentProjectionTables,\n  documentTables,\n} from \"../../data/sqlite/schema\";\nimport { ensureSqlTables } from \"../../data/sqlite/sqlSchema\";\nimport { listContainerContentsSqlIdBatches } from \"./documentQueries/sql\";\nimport type {\n  ContainerContentsDocumentRuntimeTarget,\n  ContainerDocumentProbeHost,\n  ContainerDocumentQueriesRuntime,\n} from \"./documentQueries/types\";\nimport { requestRemoteDocumentRuntimeTargetSync } from \"./documentRuntimeTargetSync\";\n\nconst DOCUMENT_HYDRATION_PROBE_REQUEST_BATCH_SIZE = 8;\nconst DOCUMENT_HYDRATION_PROBE_SCAN_BATCH_SIZE = 64;\n\ninterface DocumentHydrationProbeBatchResult {\n  readonly done: boolean;\n  readonly nextCursor: string | null;\n  readonly requestedCount: number;\n}\n\ntype RemoteDocumentProbeTarget = Omit<\n  ContainerContentsDocumentRuntimeTarget,\n  \"documentId\" | \"runtimeContainerId\"\n> & {\n  readonly documentId: string;\n  readonly preferredRuntimeContainer: boolean;\n  readonly runtimeContainerId: string;\n};\n\nfunction valuePlaceholders(values: ReadonlyArray<unknown>): string {\n  return values.map(() => \"?\").join(\", \");\n}\n\nfunction valueRows(values: ReadonlyArray<unknown>): string {\n  return values.map(() => \"(?)\").join(\", \");\n}\n\nfunction readProbeTarget(row: unknown): RemoteDocumentProbeTarget {\n  // These aliases are wholly internal SQL contracts; fail loudly if a query\n  // edit violates them instead of silently skipping a persisted document.\n  if (row === null || (typeof row !== \"object\" && typeof row !== \"function\")) {\n    throw new Error(\"Document hydration probe returned an invalid target\");\n  }\n  const documentId = Reflect.get(row, \"document_id\");\n  const localId = Reflect.get(row, \"local_id\");\n  const projectedContainerId = Reflect.get(row, \"projected_container_id\");\n  const runtimeContainerId = Reflect.get(row, \"container_id\");\n  if (\n    typeof documentId !== \"string\" ||\n    typeof localId !== \"string\" ||\n    typeof runtimeContainerId !== \"string\"\n  ) {\n    throw new Error(\"Document hydration probe returned an invalid target\");\n  }\n  return {\n    documentId,\n    localId,\n    preferredRuntimeContainer: projectedContainerId === runtimeContainerId,\n    runtimeContainerId,\n  };\n}\n\nasync function listRemoteDocumentProbeBatchForContainerIds(input: {\n  readonly afterLocalId: string | null;\n  readonly containerIds: ReadonlyArray<string>;\n  readonly runtime: ContainerDocumentQueriesRuntime;\n}): Promise<RemoteDocumentProbeTarget[]> {\n  const rows = await input.runtime.infra.execSql(\n    `\n      WITH eligible_container_ids(container_id) AS (\n        VALUES ${valueRows(input.containerIds)}\n      )\n      SELECT\n        stored.local_id AS local_id,\n        stored.document_id AS document_id,\n        projection.container_id AS projected_container_id,\n        COALESCE(\n          projected_container.container_id,\n          MIN(linked_container.container_id)\n        ) AS container_id\n      FROM documents stored\n      INNER JOIN document_projection projection\n        ON projection.local_id = stored.local_id\n      LEFT JOIN eligible_container_ids projected_container\n        ON projected_container.container_id = projection.container_id\n      LEFT JOIN document_container_projection link\n        ON link.document_id = stored.document_id\n      LEFT JOIN eligible_container_ids linked_container\n        ON linked_container.container_id = link.container_id\n      WHERE stored.app_kind = 'documents'\n        AND stored.document_id IS NOT NULL\n        AND (? IS NULL OR stored.local_id > ?)\n        AND (\n          projected_container.container_id IS NOT NULL\n          OR linked_container.container_id IS NOT NULL\n        )\n        AND projection.document_kind NOT IN (${valuePlaceholders(\n          HIDDEN_DOCUMENT_SUMMARY_KINDS,\n        )})\n      GROUP BY\n        stored.local_id,\n        stored.document_id,\n        projection.container_id,\n        projected_container.container_id\n      ORDER BY stored.local_id ASC\n      LIMIT ?\n    `,\n    [\n      ...input.containerIds,\n      input.afterLocalId,\n      input.afterLocalId,\n      ...HIDDEN_DOCUMENT_SUMMARY_KINDS,\n      DOCUMENT_HYDRATION_PROBE_SCAN_BATCH_SIZE,\n    ],\n  );\n  return rows.map(readProbeTarget);\n}\n\nfunction mergeRemoteDocumentProbeTargets(\n  batches: ReadonlyArray<ReadonlyArray<RemoteDocumentProbeTarget>>,\n): RemoteDocumentProbeTarget[] {\n  const targetsByLocalId = new Map<string, RemoteDocumentProbeTarget>();\n  for (const batch of batches) {\n    for (const target of batch) {\n      const existing = targetsByLocalId.get(target.localId);\n      if (\n        existing === undefined ||\n        (target.preferredRuntimeContainer &&\n          !existing.preferredRuntimeContainer) ||\n        (target.preferredRuntimeContainer ===\n          existing.preferredRuntimeContainer &&\n          target.runtimeContainerId < existing.runtimeContainerId)\n      ) {\n        targetsByLocalId.set(target.localId, target);\n      }\n    }\n  }\n  return [...targetsByLocalId.values()]\n    .sort((left, right) =>\n      left.localId < right.localId ? -1 : Number(left.localId > right.localId),\n    )\n    .slice(0, DOCUMENT_HYDRATION_PROBE_SCAN_BATCH_SIZE);\n}\n\nasync function listRemoteDocumentProbeBatch(input: {\n  readonly afterLocalId: string | null;\n  readonly listedContainerIds: ReadonlySet<string>;\n  readonly runtime: ContainerDocumentQueriesRuntime;\n}): Promise<RemoteDocumentProbeTarget[]> {\n  const containerIds = [...input.listedContainerIds];\n  if (containerIds.length === 0) {\n    return [];\n  }\n\n  await ensureSqlTables(input.runtime.infra.execSql, [\n    ...documentTables,\n    ...documentProjectionTables,\n    ...documentContainerProjectionTables,\n  ]);\n  const batches: RemoteDocumentProbeTarget[][] = [];\n  for (const containerIdBatch of listContainerContentsSqlIdBatches(\n    containerIds,\n  )) {\n    batches.push(\n      await listRemoteDocumentProbeBatchForContainerIds({\n        afterLocalId: input.afterLocalId,\n        containerIds: containerIdBatch,\n        runtime: input.runtime,\n      }),\n    );\n  }\n  return mergeRemoteDocumentProbeTargets(batches);\n}\n\n/**\n * Opens at most one bounded batch of visible, remote-backed local documents\n * linked to an authoritatively listed container but absent from every full\n * listing. Each store's ordinary sync pass owns its coded-404/403 verdict.\n */\nexport async function probeUndiscoveredRemoteDocumentBatch<TRuntime>(input: {\n  readonly afterLocalId: string | null;\n  readonly host: ContainerDocumentProbeHost<TRuntime>;\n  readonly listedContainerIds: ReadonlySet<string>;\n  readonly listedDocumentIds: ReadonlySet<string>;\n  readonly runtime: ContainerDocumentQueriesRuntime;\n}): Promise<DocumentHydrationProbeBatchResult> {\n  const scanned = await listRemoteDocumentProbeBatch(input);\n  const candidates = scanned.filter(\n    (target) => !input.listedDocumentIds.has(target.documentId),\n  );\n  const targets = candidates.slice(\n    0,\n    DOCUMENT_HYDRATION_PROBE_REQUEST_BATCH_SIZE,\n  );\n  const requested = await requestRemoteDocumentRuntimeTargetSync({\n    host: input.host,\n    targets,\n  });\n  const hasUnrequestedCandidate = candidates.length > targets.length;\n  const scanPageMayContinue =\n    scanned.length === DOCUMENT_HYDRATION_PROBE_SCAN_BATCH_SIZE;\n  const done = !hasUnrequestedCandidate && !scanPageMayContinue;\n  const nextCursorTarget = hasUnrequestedCandidate\n    ? targets.at(-1)\n    : scanned.at(-1);\n  return {\n    done,\n    nextCursor: done ? null : (nextCursorTarget?.localId ?? null),\n    requestedCount: requested.size,\n  };\n}\n"]}

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

@@ -0,0 +1,18 @@
+import type { DocumentEditAttributionResponse, DocumentWriterProjectionResponse, ListDocumentAttachmentsResponse } from "../../internal/validators/response/index.js";
+import type { SecurityIncidentReporter } from "../../data/securityIncidents.js";
+import type { ExecSql } from "../../data/sqlite/sqlSchema.js";
+import type { DocumentInfo, DocumentInfoRemoteMode } from "./documentInfoTypes.js";
+export type { DocumentInfo, DocumentInfoAttachment, DocumentInfoAuthorizingContainerPath, DocumentInfoLocalDetails, DocumentInfoRemoteAttachmentBinding, DocumentInfoRemoteDetails, DocumentInfoRemoteMode, } from "./documentInfoTypes.js";
+interface DocumentInfoApi {
+    getDocumentEditAttribution: (documentId: string, requestKey?: string) => Promise<DocumentEditAttributionResponse | null>;
+    getDocumentWriterProjection: (documentId: string) => Promise<DocumentWriterProjectionResponse | null>;
+    listDocumentAttachments: (documentId: string) => Promise<ListDocumentAttachmentsResponse | null>;
+}
+export declare function loadDocumentInfo(input: {
+    apiClient: DocumentInfoApi;
+    attributionRequestKey?: string | undefined;
+    execSql?: ExecSql | null;
+    localId: string;
+    reportSecurityIncident: SecurityIncidentReporter;
+    remoteInfoMode?: DocumentInfoRemoteMode | undefined;
+}): Promise<DocumentInfo>;