@tearleads/client-sdk 0.1.42 → 0.1.44

package/internal/validators/util/blobTransferSchemas.d.ts

@@ -0,0 +1,41 @@
+import { z } from "zod";
+export declare const signedBlobUrlSchema: z.ZodCustom<string, string>;
+export declare const signedBlobUrlExpirySchema: z.ZodCustom<string, string>;
+export declare const blobPartContentMd5Schema: z.ZodCustom<string, string>;
+/** S3/R2 multipart part numbers run from 1 through 10,000. */
+export declare const MAX_MULTIPART_BLOB_PART_NUMBER = 10000;
+/**
+ * One encrypted part as the client will send it: its number, exact length, and
+ * the transport Content-MD5 a signed upload URL binds.
+ */
+export declare const MultipartBlobPartDescriptorSchema: z.ZodObject<{
+    byteLength: z.ZodCustom<number, number>;
+    contentMd5: z.ZodCustom<string, string>;
+    partNumber: z.ZodCustom<number, number>;
+}, z.core.$strict>;
+export type MultipartBlobPartDescriptor = z.infer<typeof MultipartBlobPartDescriptorSchema>;
+/**
+ * Where a part's bytes go: the API byte route for stores that cannot sign, or
+ * a short-lived URL that signs exactly one part of one upload.
+ */
+export declare const MultipartBlobPartUploadSourceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"api">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"signed-url">;
+    url: z.ZodCustom<string, string>;
+    expiresAt: z.ZodCustom<string, string>;
+}, z.core.$strict>], "kind">;
+export type MultipartBlobPartUploadSource = z.infer<typeof MultipartBlobPartUploadSourceSchema>;
+export declare const MultipartBlobPartUploadSchema: z.ZodObject<{
+    byteLength: z.ZodCustom<number, number>;
+    contentMd5: z.ZodCustom<string, string>;
+    partNumber: z.ZodCustom<number, number>;
+    source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"api">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"signed-url">;
+        url: z.ZodCustom<string, string>;
+        expiresAt: z.ZodCustom<string, string>;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>;
+export type MultipartBlobPartUpload = z.infer<typeof MultipartBlobPartUploadSchema>;

package/internal/validators/util/blobTransferSchemas.js

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { registerJsonSchemaFragment } from "../jsonSchema.js";
+import { boundedPositiveIntegerSchema } from "../schema.js";
+import { MAX_MULTIPART_BLOB_PART_BYTES } from "./blob.js";
+function stringSchemaFragment(schema) {
+    const { $schema: _dialect, ...fragment } = z.toJSONSchema(schema);
+    return registerJsonSchemaFragment(z.custom((value) => schema.safeParse(value).success), fragment);
+}
+export const signedBlobUrlSchema = stringSchemaFragment(z.url().regex(/^https?:\/\//u));
+export const signedBlobUrlExpirySchema = stringSchemaFragment(z.iso.datetime());
+// R2 transport checksum; assembled SHA-256 remains the application authority.
+export const blobPartContentMd5Schema = stringSchemaFragment(z.string().regex(/^[A-Za-z0-9+/]{21}[AQgw]==$/u));
+/** S3/R2 multipart part numbers run from 1 through 10,000. */
+export const MAX_MULTIPART_BLOB_PART_NUMBER = 10_000;
+/**
+ * One encrypted part as the client will send it: its number, exact length, and
+ * the transport Content-MD5 a signed upload URL binds.
+ */
+export const MultipartBlobPartDescriptorSchema = z.strictObject({
+    byteLength: boundedPositiveIntegerSchema(MAX_MULTIPART_BLOB_PART_BYTES),
+    contentMd5: blobPartContentMd5Schema,
+    partNumber: boundedPositiveIntegerSchema(MAX_MULTIPART_BLOB_PART_NUMBER),
+});
+/**
+ * Where a part's bytes go: the API byte route for stores that cannot sign, or
+ * a short-lived URL that signs exactly one part of one upload.
+ */
+export const MultipartBlobPartUploadSourceSchema = z.discriminatedUnion("kind", [
+    z.strictObject({ kind: z.literal("api") }),
+    z.strictObject({
+        kind: z.literal("signed-url"),
+        url: signedBlobUrlSchema,
+        expiresAt: signedBlobUrlExpirySchema,
+    }),
+]);
+export const MultipartBlobPartUploadSchema = MultipartBlobPartDescriptorSchema.extend({
+    source: MultipartBlobPartUploadSourceSchema,
+});
+//# sourceMappingURL=blobTransferSchemas.js.map

package/internal/validators/util/blobTransferSchemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"blobTransferSchemas.js","sourceRoot":"","sources":["blobTransferSchemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,0BAA0B,EAAE,MAAM,eAAe,CAAC;AAC3D,OAAO,EAAE,4BAA4B,EAAE,MAAM,WAAW,CAAC;AACzD,OAAO,EAAE,6BAA6B,EAAE,MAAM,QAAQ,CAAC;AAEvD,SAAS,oBAAoB,CAAC,MAAyB;IACrD,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,GAAG,QAAQ,EAAE,GAAG,CAAC,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;IAClE,OAAO,0BAA0B,CAC/B,CAAC,CAAC,MAAM,CAAS,CAAC,KAAK,EAAE,EAAE,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,EAC5D,QAAQ,CACT,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,MAAM,mBAAmB,GAAG,oBAAoB,CACrD,CAAC,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,eAAe,CAAC,CAC/B,CAAC;AACF,MAAM,CAAC,MAAM,yBAAyB,GAAG,oBAAoB,CAAC,CAAC,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,CAAC;AAEhF,8EAA8E;AAC9E,MAAM,CAAC,MAAM,wBAAwB,GAAG,oBAAoB,CAC1D,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,8BAA8B,CAAC,CACjD,CAAC;AAEF,8DAA8D;AAC9D,MAAM,CAAC,MAAM,8BAA8B,GAAG,MAAM,CAAC;AAErD;;;GAGG;AACH,MAAM,CAAC,MAAM,iCAAiC,GAAG,CAAC,CAAC,YAAY,CAAC;IAC9D,UAAU,EAAE,4BAA4B,CAAC,6BAA6B,CAAC;IACvE,UAAU,EAAE,wBAAwB;IACpC,UAAU,EAAE,4BAA4B,CAAC,8BAA8B,CAAC;CACzE,CAAC,CAAC;AAMH;;;GAGG;AACH,MAAM,CAAC,MAAM,mCAAmC,GAAG,CAAC,CAAC,kBAAkB,CACrE,MAAM,EACN;IACE,CAAC,CAAC,YAAY,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;IAC1C,CAAC,CAAC,YAAY,CAAC;QACb,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,YAAY,CAAC;QAC7B,GAAG,EAAE,mBAAmB;QACxB,SAAS,EAAE,yBAAyB;KACrC,CAAC;CACH,CACF,CAAC;AAMF,MAAM,CAAC,MAAM,6BAA6B,GACxC,iCAAiC,CAAC,MAAM,CAAC;IACvC,MAAM,EAAE,mCAAmC;CAC5C,CAAC,CAAC","sourcesContent":["import { z } from \"zod\";\nimport { registerJsonSchemaFragment } from \"../jsonSchema\";\nimport { boundedPositiveIntegerSchema } from \"../schema\";\nimport { MAX_MULTIPART_BLOB_PART_BYTES } from \"./blob\";\n\nfunction stringSchemaFragment(schema: z.ZodType<string>) {\n  const { $schema: _dialect, ...fragment } = z.toJSONSchema(schema);\n  return registerJsonSchemaFragment(\n    z.custom<string>((value) => schema.safeParse(value).success),\n    fragment,\n  );\n}\n\nexport const signedBlobUrlSchema = stringSchemaFragment(\n  z.url().regex(/^https?:\\/\\//u),\n);\nexport const signedBlobUrlExpirySchema = stringSchemaFragment(z.iso.datetime());\n\n// R2 transport checksum; assembled SHA-256 remains the application authority.\nexport const blobPartContentMd5Schema = stringSchemaFragment(\n  z.string().regex(/^[A-Za-z0-9+/]{21}[AQgw]==$/u),\n);\n\n/** S3/R2 multipart part numbers run from 1 through 10,000. */\nexport const MAX_MULTIPART_BLOB_PART_NUMBER = 10_000;\n\n/**\n * One encrypted part as the client will send it: its number, exact length, and\n * the transport Content-MD5 a signed upload URL binds.\n */\nexport const MultipartBlobPartDescriptorSchema = z.strictObject({\n  byteLength: boundedPositiveIntegerSchema(MAX_MULTIPART_BLOB_PART_BYTES),\n  contentMd5: blobPartContentMd5Schema,\n  partNumber: boundedPositiveIntegerSchema(MAX_MULTIPART_BLOB_PART_NUMBER),\n});\n\nexport type MultipartBlobPartDescriptor = z.infer<\n  typeof MultipartBlobPartDescriptorSchema\n>;\n\n/**\n * Where a part's bytes go: the API byte route for stores that cannot sign, or\n * a short-lived URL that signs exactly one part of one upload.\n */\nexport const MultipartBlobPartUploadSourceSchema = z.discriminatedUnion(\n  \"kind\",\n  [\n    z.strictObject({ kind: z.literal(\"api\") }),\n    z.strictObject({\n      kind: z.literal(\"signed-url\"),\n      url: signedBlobUrlSchema,\n      expiresAt: signedBlobUrlExpirySchema,\n    }),\n  ],\n);\n\nexport type MultipartBlobPartUploadSource = z.infer<\n  typeof MultipartBlobPartUploadSourceSchema\n>;\n\nexport const MultipartBlobPartUploadSchema =\n  MultipartBlobPartDescriptorSchema.extend({\n    source: MultipartBlobPartUploadSourceSchema,\n  });\n\nexport type MultipartBlobPartUpload = z.infer<\n  typeof MultipartBlobPartUploadSchema\n>;\n"]}

package/internal/validators/util/containerLimits.d.ts

@@ -1,2 +1,9 @@
 /** Maximum number of containers in a root-to-leaf path, including both ends. */
 export declare const MAX_CONTAINER_PATH_LENGTH = 100;
+/**
+ * Maximum number of stored manifests one container mutation may cite as the
+ * mutated container's history. Inline bundles (8-14 KiB each) fit about this
+ * many under the 32 MiB request ceiling; a reference is ~150 bytes, so the
+ * bound keeps that capacity instead of letting a small body cite ~50x more.
+ */
+export declare const MAX_CONTAINER_MANIFEST_HISTORY_REFS = 4096;

package/internal/validators/util/containerLimits.js

@@ -1,3 +1,10 @@
 /** Maximum number of containers in a root-to-leaf path, including both ends. */
 export const MAX_CONTAINER_PATH_LENGTH = 100;
+/**
+ * Maximum number of stored manifests one container mutation may cite as the
+ * mutated container's history. Inline bundles (8-14 KiB each) fit about this
+ * many under the 32 MiB request ceiling; a reference is ~150 bytes, so the
+ * bound keeps that capacity instead of letting a small body cite ~50x more.
+ */
+export const MAX_CONTAINER_MANIFEST_HISTORY_REFS = 4096;
 //# sourceMappingURL=containerLimits.js.map

package/internal/validators/util/containerLimits.js.map

@@ -1 +1 @@
-{"version":3,"file":"containerLimits.js","sourceRoot":"","sources":["containerLimits.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,MAAM,CAAC,MAAM,yBAAyB,GAAG,GAAG,CAAC","sourcesContent":["/** Maximum number of containers in a root-to-leaf path, including both ends. */\nexport const MAX_CONTAINER_PATH_LENGTH = 100;\n"]}
+{"version":3,"file":"containerLimits.js","sourceRoot":"","sources":["containerLimits.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,MAAM,CAAC,MAAM,yBAAyB,GAAG,GAAG,CAAC;AAE7C;;;;;GAKG;AACH,MAAM,CAAC,MAAM,mCAAmC,GAAG,IAAI,CAAC","sourcesContent":["/** Maximum number of containers in a root-to-leaf path, including both ends. */\nexport const MAX_CONTAINER_PATH_LENGTH = 100;\n\n/**\n * Maximum number of stored manifests one container mutation may cite as the\n * mutated container's history. Inline bundles (8-14 KiB each) fit about this\n * many under the 32 MiB request ceiling; a reference is ~150 bytes, so the\n * bound keeps that capacity instead of letting a small body cite ~50x more.\n */\nexport const MAX_CONTAINER_MANIFEST_HISTORY_REFS = 4096;\n"]}

package/internal/validators/util/index.d.ts

@@ -1,5 +1,6 @@
 export { type AccessEventBundleWireResponse, AccessEventBundleWireResponseSchema, type AccessManifestBundleWire, type AccessManifestBundleWireResponse, AccessManifestBundleWireResponseSchema, AccessManifestBundleWireSchema, isAccessEventBundleWireResponse, isAccessManifestBundleWire, isAccessManifestBundleWireArray, isAccessManifestBundleWireResponse, isOptionalAccessManifestBundleWireArray, } from "./accessManifestBundle.js";
-export { MAX_MULTIPART_BLOB_PART_BYTES } from "./blob.js";
+export { MAX_INITIATE_PART_UPLOADS, MAX_MULTIPART_BLOB_PART_BYTES, } from "./blob.js";
+export { blobPartContentMd5Schema, MAX_MULTIPART_BLOB_PART_NUMBER, type MultipartBlobPartDescriptor, MultipartBlobPartDescriptorSchema, type MultipartBlobPartUpload, MultipartBlobPartUploadSchema, type MultipartBlobPartUploadSource, MultipartBlobPartUploadSourceSchema, signedBlobUrlExpirySchema, signedBlobUrlSchema, } from "./blobTransferSchemas.js";
 export { CONTAINER_KEK_LOG_PAGE_LIMIT, CONTAINER_KEK_LOG_PRINCIPAL_SCOPE_LIMIT, CONTAINER_KEK_WRAPS_PER_EPOCH_LIMIT, ContainerKekKeyringWireRecordSchema, isContainerKekKeyringWireRecord, MAX_CONTAINER_KEY_EPOCH, MAX_INLINE_CONTAINER_REKEYS, MAX_ROTATION_CONTAINER_REKEYS, MAX_SEALED_CONTAINER_KEK_KEYRING_BASE64_LENGTH, SEALED_CONTAINER_KEK_KEYRING_AEAD_OVERHEAD_BYTES, SEALED_CONTAINER_KEK_KEYRING_ENTRY_BYTES, SEALED_CONTAINER_KEK_KEYRING_HEADER_BYTES, sealedContainerKekKeyringBytes, } from "./containerKekKeyringWire.js";
 export { MAX_CONTAINER_PATH_LENGTH } from "./containerLimits.js";
 export { MAX_DOCUMENT_SYNC_AUTHORIZATION_PATH_REFS, MAX_DOCUMENT_SYNC_AUTHORIZATION_PATHS, MAX_DOCUMENT_SYNC_CONTENT_KEY_TARGETS, MAX_DOCUMENT_SYNC_OUTGOING_UPDATES, MAX_DOCUMENT_SYNC_PULL_CURSOR_LENGTH, MAX_DOCUMENT_SYNC_REQUEST_BYTES, MAX_DOCUMENT_SYNC_RESPONSE_ENVELOPE_BYTES, MAX_DOCUMENT_SYNC_RESPONSE_PAGE_BYTES, MAX_DOCUMENT_SYNC_RESPONSE_PAGE_UPDATES, MAX_DOCUMENT_SYNC_RESPONSE_UPDATE_PAGE_BYTES, } from "./documentSyncLimits.js";

package/internal/validators/util/index.js

@@ -1,5 +1,6 @@
 export { AccessEventBundleWireResponseSchema, AccessManifestBundleWireResponseSchema, AccessManifestBundleWireSchema, isAccessEventBundleWireResponse, isAccessManifestBundleWire, isAccessManifestBundleWireArray, isAccessManifestBundleWireResponse, isOptionalAccessManifestBundleWireArray, } from "./accessManifestBundle.js";
-export { MAX_MULTIPART_BLOB_PART_BYTES } from "./blob.js";
+export { MAX_INITIATE_PART_UPLOADS, MAX_MULTIPART_BLOB_PART_BYTES, } from "./blob.js";
+export { blobPartContentMd5Schema, MAX_MULTIPART_BLOB_PART_NUMBER, MultipartBlobPartDescriptorSchema, MultipartBlobPartUploadSchema, MultipartBlobPartUploadSourceSchema, signedBlobUrlExpirySchema, signedBlobUrlSchema, } from "./blobTransferSchemas.js";
 export { CONTAINER_KEK_LOG_PAGE_LIMIT, CONTAINER_KEK_LOG_PRINCIPAL_SCOPE_LIMIT, CONTAINER_KEK_WRAPS_PER_EPOCH_LIMIT, ContainerKekKeyringWireRecordSchema, isContainerKekKeyringWireRecord, MAX_CONTAINER_KEY_EPOCH, MAX_INLINE_CONTAINER_REKEYS, MAX_ROTATION_CONTAINER_REKEYS, MAX_SEALED_CONTAINER_KEK_KEYRING_BASE64_LENGTH, SEALED_CONTAINER_KEK_KEYRING_AEAD_OVERHEAD_BYTES, SEALED_CONTAINER_KEK_KEYRING_ENTRY_BYTES, SEALED_CONTAINER_KEK_KEYRING_HEADER_BYTES, sealedContainerKekKeyringBytes, } from "./containerKekKeyringWire.js";
 export { MAX_CONTAINER_PATH_LENGTH } from "./containerLimits.js";
 export { MAX_DOCUMENT_SYNC_AUTHORIZATION_PATH_REFS, MAX_DOCUMENT_SYNC_AUTHORIZATION_PATHS, MAX_DOCUMENT_SYNC_CONTENT_KEY_TARGETS, MAX_DOCUMENT_SYNC_OUTGOING_UPDATES, MAX_DOCUMENT_SYNC_PULL_CURSOR_LENGTH, MAX_DOCUMENT_SYNC_REQUEST_BYTES, MAX_DOCUMENT_SYNC_RESPONSE_ENVELOPE_BYTES, MAX_DOCUMENT_SYNC_RESPONSE_PAGE_BYTES, MAX_DOCUMENT_SYNC_RESPONSE_PAGE_UPDATES, MAX_DOCUMENT_SYNC_RESPONSE_UPDATE_PAGE_BYTES, } from "./documentSyncLimits.js";

package/internal/validators/util/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,mCAAmC,EAGnC,sCAAsC,EACtC,8BAA8B,EAC9B,+BAA+B,EAC/B,0BAA0B,EAC1B,+BAA+B,EAC/B,kCAAkC,EAClC,uCAAuC,GACxC,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,6BAA6B,EAAE,MAAM,QAAQ,CAAC;AACvD,OAAO,EACL,4BAA4B,EAC5B,uCAAuC,EACvC,mCAAmC,EACnC,mCAAmC,EACnC,+BAA+B,EAC/B,uBAAuB,EACvB,2BAA2B,EAC3B,6BAA6B,EAC7B,8CAA8C,EAC9C,gDAAgD,EAChD,wCAAwC,EACxC,yCAAyC,EACzC,8BAA8B,GAC/B,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,EACL,yCAAyC,EACzC,qCAAqC,EACrC,qCAAqC,EACrC,kCAAkC,EAClC,oCAAoC,EACpC,+BAA+B,EAC/B,yCAAyC,EACzC,qCAAqC,EACrC,uCAAuC,EACvC,4CAA4C,GAC7C,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,uBAAuB,EACvB,4BAA4B,GAE7B,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,yBAAyB,EACzB,2BAA2B,EAC3B,uBAAuB,GACxB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,sCAAsC,EAEtC,0CAA0C,GAC3C,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,mCAAmC,EACnC,kCAAkC,GACnC,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,gBAAgB,EAChB,kBAAkB,EAClB,yBAAyB,EACzB,yBAAyB,EACzB,yBAAyB,EACzB,iBAAiB,EACjB,iBAAiB,EACjB,yBAAyB,EACzB,0BAA0B,EAC1B,gBAAgB,EAChB,iBAAiB,EACjB,qBAAqB,EACrB,qBAAqB,EACrB,0BAA0B,EAC1B,aAAa,EACb,kBAAkB,EAClB,aAAa,GACd,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,yBAAyB,EACzB,wBAAwB,EACxB,WAAW,EACX,mBAAmB,EACnB,iBAAiB,EACjB,yBAAyB,EACzB,wBAAwB,EACxB,2BAA2B,EAC3B,iBAAiB,GAClB,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,2BAA2B,EAC3B,mBAAmB,EACnB,kBAAkB,EAClB,kBAAkB,EAClB,kBAAkB,GACnB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAC;AACxC,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC","sourcesContent":["export {\n  type AccessEventBundleWireResponse,\n  AccessEventBundleWireResponseSchema,\n  type AccessManifestBundleWire,\n  type AccessManifestBundleWireResponse,\n  AccessManifestBundleWireResponseSchema,\n  AccessManifestBundleWireSchema,\n  isAccessEventBundleWireResponse,\n  isAccessManifestBundleWire,\n  isAccessManifestBundleWireArray,\n  isAccessManifestBundleWireResponse,\n  isOptionalAccessManifestBundleWireArray,\n} from \"./accessManifestBundle\";\nexport { MAX_MULTIPART_BLOB_PART_BYTES } from \"./blob\";\nexport {\n  CONTAINER_KEK_LOG_PAGE_LIMIT,\n  CONTAINER_KEK_LOG_PRINCIPAL_SCOPE_LIMIT,\n  CONTAINER_KEK_WRAPS_PER_EPOCH_LIMIT,\n  ContainerKekKeyringWireRecordSchema,\n  isContainerKekKeyringWireRecord,\n  MAX_CONTAINER_KEY_EPOCH,\n  MAX_INLINE_CONTAINER_REKEYS,\n  MAX_ROTATION_CONTAINER_REKEYS,\n  MAX_SEALED_CONTAINER_KEK_KEYRING_BASE64_LENGTH,\n  SEALED_CONTAINER_KEK_KEYRING_AEAD_OVERHEAD_BYTES,\n  SEALED_CONTAINER_KEK_KEYRING_ENTRY_BYTES,\n  SEALED_CONTAINER_KEK_KEYRING_HEADER_BYTES,\n  sealedContainerKekKeyringBytes,\n} from \"./containerKekKeyringWire\";\nexport { MAX_CONTAINER_PATH_LENGTH } from \"./containerLimits\";\nexport {\n  MAX_DOCUMENT_SYNC_AUTHORIZATION_PATH_REFS,\n  MAX_DOCUMENT_SYNC_AUTHORIZATION_PATHS,\n  MAX_DOCUMENT_SYNC_CONTENT_KEY_TARGETS,\n  MAX_DOCUMENT_SYNC_OUTGOING_UPDATES,\n  MAX_DOCUMENT_SYNC_PULL_CURSOR_LENGTH,\n  MAX_DOCUMENT_SYNC_REQUEST_BYTES,\n  MAX_DOCUMENT_SYNC_RESPONSE_ENVELOPE_BYTES,\n  MAX_DOCUMENT_SYNC_RESPONSE_PAGE_BYTES,\n  MAX_DOCUMENT_SYNC_RESPONSE_PAGE_UPDATES,\n  MAX_DOCUMENT_SYNC_RESPONSE_UPDATE_PAGE_BYTES,\n} from \"./documentSyncLimits\";\nexport {\n  isSerializedKeyEnvelope,\n  isSerializedKeyEnvelopeArray,\n  type SerializedKeyEnvelope,\n} from \"./keyEnvelope\";\nexport {\n  KNOWN_MANIFEST_HINT_LIMIT,\n  KnownManifestsHeadersSchema,\n  parseKnownManifestHints,\n} from \"./knownManifestWire\";\nexport {\n  isOrganizationReplacementAuthorization,\n  type OrganizationReplacementAuthorization,\n  OrganizationReplacementAuthorizationSchema,\n} from \"./organizationReplacement\";\nexport {\n  PRINCIPAL_POLICY_HISTORY_PAGE_LIMIT,\n  PRINCIPAL_POLICY_REPAIR_HEAD_LIMIT,\n} from \"./principalHistoryWire\";\nexport {\n  hasArrayProperty,\n  hasBooleanProperty,\n  hasNonEmptyStringProperty,\n  hasNullableNumberProperty,\n  hasNullableStringProperty,\n  hasNumberProperty,\n  hasObjectProperty,\n  hasOptionalStringProperty,\n  hasPositiveIntegerProperty,\n  hasPropertyValue,\n  hasStringProperty,\n  isNonEmptyStringArray,\n  isOptionalRecordArray,\n  isOptionalRecordArrayArray,\n  isRecordArray,\n  isRecordArrayArray,\n  isStringArray,\n} from \"./properties\";\nexport {\n  AUTH_CHALLENGE_HEX_LENGTH,\n  isAuthChallengeHexString,\n  isByteArray,\n  isByteArrayOfLength,\n  isSha256HexString,\n  ML_DSA87_PUBLIC_KEY_BYTES,\n  ML_DSA87_SIGNATURE_BYTES,\n  ML_KEM1024_PUBLIC_KEY_BYTES,\n  SHA256_HEX_LENGTH,\n} from \"./protocol\";\nexport {\n  CANONICAL_SIGNED_AT_PATTERN,\n  isCanonicalSignedAt,\n  MAX_SIGNED_AT_YEAR,\n  MIN_SIGNED_AT_YEAR,\n  SIGNED_AT_CONTRACT,\n} from \"./signedAt\";\nexport { isUuidV4String } from \"./uuid\";\nexport { isWalLsnString, parseWalLsn } from \"./walLsn\";\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,mCAAmC,EAGnC,sCAAsC,EACtC,8BAA8B,EAC9B,+BAA+B,EAC/B,0BAA0B,EAC1B,+BAA+B,EAC/B,kCAAkC,EAClC,uCAAuC,GACxC,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,yBAAyB,EACzB,6BAA6B,GAC9B,MAAM,QAAQ,CAAC;AAChB,OAAO,EACL,wBAAwB,EACxB,8BAA8B,EAE9B,iCAAiC,EAEjC,6BAA6B,EAE7B,mCAAmC,EACnC,yBAAyB,EACzB,mBAAmB,GACpB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,4BAA4B,EAC5B,uCAAuC,EACvC,mCAAmC,EACnC,mCAAmC,EACnC,+BAA+B,EAC/B,uBAAuB,EACvB,2BAA2B,EAC3B,6BAA6B,EAC7B,8CAA8C,EAC9C,gDAAgD,EAChD,wCAAwC,EACxC,yCAAyC,EACzC,8BAA8B,GAC/B,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,EACL,yCAAyC,EACzC,qCAAqC,EACrC,qCAAqC,EACrC,kCAAkC,EAClC,oCAAoC,EACpC,+BAA+B,EAC/B,yCAAyC,EACzC,qCAAqC,EACrC,uCAAuC,EACvC,4CAA4C,GAC7C,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,uBAAuB,EACvB,4BAA4B,GAE7B,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,yBAAyB,EACzB,2BAA2B,EAC3B,uBAAuB,GACxB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,sCAAsC,EAEtC,0CAA0C,GAC3C,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,mCAAmC,EACnC,kCAAkC,GACnC,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,gBAAgB,EAChB,kBAAkB,EAClB,yBAAyB,EACzB,yBAAyB,EACzB,yBAAyB,EACzB,iBAAiB,EACjB,iBAAiB,EACjB,yBAAyB,EACzB,0BAA0B,EAC1B,gBAAgB,EAChB,iBAAiB,EACjB,qBAAqB,EACrB,qBAAqB,EACrB,0BAA0B,EAC1B,aAAa,EACb,kBAAkB,EAClB,aAAa,GACd,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,yBAAyB,EACzB,wBAAwB,EACxB,WAAW,EACX,mBAAmB,EACnB,iBAAiB,EACjB,yBAAyB,EACzB,wBAAwB,EACxB,2BAA2B,EAC3B,iBAAiB,GAClB,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,2BAA2B,EAC3B,mBAAmB,EACnB,kBAAkB,EAClB,kBAAkB,EAClB,kBAAkB,GACnB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAC;AACxC,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC","sourcesContent":["export {\n  type AccessEventBundleWireResponse,\n  AccessEventBundleWireResponseSchema,\n  type AccessManifestBundleWire,\n  type AccessManifestBundleWireResponse,\n  AccessManifestBundleWireResponseSchema,\n  AccessManifestBundleWireSchema,\n  isAccessEventBundleWireResponse,\n  isAccessManifestBundleWire,\n  isAccessManifestBundleWireArray,\n  isAccessManifestBundleWireResponse,\n  isOptionalAccessManifestBundleWireArray,\n} from \"./accessManifestBundle\";\nexport {\n  MAX_INITIATE_PART_UPLOADS,\n  MAX_MULTIPART_BLOB_PART_BYTES,\n} from \"./blob\";\nexport {\n  blobPartContentMd5Schema,\n  MAX_MULTIPART_BLOB_PART_NUMBER,\n  type MultipartBlobPartDescriptor,\n  MultipartBlobPartDescriptorSchema,\n  type MultipartBlobPartUpload,\n  MultipartBlobPartUploadSchema,\n  type MultipartBlobPartUploadSource,\n  MultipartBlobPartUploadSourceSchema,\n  signedBlobUrlExpirySchema,\n  signedBlobUrlSchema,\n} from \"./blobTransferSchemas\";\nexport {\n  CONTAINER_KEK_LOG_PAGE_LIMIT,\n  CONTAINER_KEK_LOG_PRINCIPAL_SCOPE_LIMIT,\n  CONTAINER_KEK_WRAPS_PER_EPOCH_LIMIT,\n  ContainerKekKeyringWireRecordSchema,\n  isContainerKekKeyringWireRecord,\n  MAX_CONTAINER_KEY_EPOCH,\n  MAX_INLINE_CONTAINER_REKEYS,\n  MAX_ROTATION_CONTAINER_REKEYS,\n  MAX_SEALED_CONTAINER_KEK_KEYRING_BASE64_LENGTH,\n  SEALED_CONTAINER_KEK_KEYRING_AEAD_OVERHEAD_BYTES,\n  SEALED_CONTAINER_KEK_KEYRING_ENTRY_BYTES,\n  SEALED_CONTAINER_KEK_KEYRING_HEADER_BYTES,\n  sealedContainerKekKeyringBytes,\n} from \"./containerKekKeyringWire\";\nexport { MAX_CONTAINER_PATH_LENGTH } from \"./containerLimits\";\nexport {\n  MAX_DOCUMENT_SYNC_AUTHORIZATION_PATH_REFS,\n  MAX_DOCUMENT_SYNC_AUTHORIZATION_PATHS,\n  MAX_DOCUMENT_SYNC_CONTENT_KEY_TARGETS,\n  MAX_DOCUMENT_SYNC_OUTGOING_UPDATES,\n  MAX_DOCUMENT_SYNC_PULL_CURSOR_LENGTH,\n  MAX_DOCUMENT_SYNC_REQUEST_BYTES,\n  MAX_DOCUMENT_SYNC_RESPONSE_ENVELOPE_BYTES,\n  MAX_DOCUMENT_SYNC_RESPONSE_PAGE_BYTES,\n  MAX_DOCUMENT_SYNC_RESPONSE_PAGE_UPDATES,\n  MAX_DOCUMENT_SYNC_RESPONSE_UPDATE_PAGE_BYTES,\n} from \"./documentSyncLimits\";\nexport {\n  isSerializedKeyEnvelope,\n  isSerializedKeyEnvelopeArray,\n  type SerializedKeyEnvelope,\n} from \"./keyEnvelope\";\nexport {\n  KNOWN_MANIFEST_HINT_LIMIT,\n  KnownManifestsHeadersSchema,\n  parseKnownManifestHints,\n} from \"./knownManifestWire\";\nexport {\n  isOrganizationReplacementAuthorization,\n  type OrganizationReplacementAuthorization,\n  OrganizationReplacementAuthorizationSchema,\n} from \"./organizationReplacement\";\nexport {\n  PRINCIPAL_POLICY_HISTORY_PAGE_LIMIT,\n  PRINCIPAL_POLICY_REPAIR_HEAD_LIMIT,\n} from \"./principalHistoryWire\";\nexport {\n  hasArrayProperty,\n  hasBooleanProperty,\n  hasNonEmptyStringProperty,\n  hasNullableNumberProperty,\n  hasNullableStringProperty,\n  hasNumberProperty,\n  hasObjectProperty,\n  hasOptionalStringProperty,\n  hasPositiveIntegerProperty,\n  hasPropertyValue,\n  hasStringProperty,\n  isNonEmptyStringArray,\n  isOptionalRecordArray,\n  isOptionalRecordArrayArray,\n  isRecordArray,\n  isRecordArrayArray,\n  isStringArray,\n} from \"./properties\";\nexport {\n  AUTH_CHALLENGE_HEX_LENGTH,\n  isAuthChallengeHexString,\n  isByteArray,\n  isByteArrayOfLength,\n  isSha256HexString,\n  ML_DSA87_PUBLIC_KEY_BYTES,\n  ML_DSA87_SIGNATURE_BYTES,\n  ML_KEM1024_PUBLIC_KEY_BYTES,\n  SHA256_HEX_LENGTH,\n} from \"./protocol\";\nexport {\n  CANONICAL_SIGNED_AT_PATTERN,\n  isCanonicalSignedAt,\n  MAX_SIGNED_AT_YEAR,\n  MIN_SIGNED_AT_YEAR,\n  SIGNED_AT_CONTRACT,\n} from \"./signedAt\";\nexport { isUuidV4String } from \"./uuid\";\nexport { isWalLsnString, parseWalLsn } from \"./walLsn\";\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tearleads/client-sdk",
-  "version": "0.1.42",
+  "version": "0.1.44",
   "description": "React-free Tearleads client runtime: local SQLite persistence, keys, sync, encrypted blobs, and domain workflows.",
   "license": "UNLICENSED",
   "repository": {

package/sync/reconciliation/knownContainerSweep.js

@@ -1,6 +1,7 @@
+import { MAX_CONTAINER_DOCUMENT_LANES } from "../../internal/validators/request/index.js";
 import { acknowledgeContainerForce, } from "./idleBackfill.js";
 import { rearmFailedSweepContainers, } from "./laneFailure.js";
-import { reconcileOneContainer } from "./reconcileContainer.js";
+import { reconcileContainers, } from "./reconcileContainer.js";
 const pendingRetries = new WeakMap();
 export function clearPendingDiscoveryRetries(state) {
     for (const { timer } of pendingRetries.get(state)?.values() ?? [])
@@ -33,51 +34,62 @@ export function isCurrentReconciliationLifecycle(state, generation) {
     return (state.lifecycleGeneration === generation &&
         (state.active || generation === 0));
 }
-// Reconcile a container whose discovered mark is already set, rolling the mark
-// back when the container is skipped or fails so a transient error (or a
+// Reconcile containers whose discovered marks are already set, rolling a mark
+// back when its container is skipped or fails so a transient error (or a
 // container that later becomes eligible) can be retried.
-export async function reconcileMarkedContainer(host, state, containerId, forceDocumentContentPull, fullRevalidation = false) {
-    try {
-        const reconciled = await reconcileOneContainer(host, containerId, {
-            forceDocumentContentPull,
-            documentIds: fullRevalidation
-                ? undefined
-                : state.forcedDocumentIds.get(containerId),
-            onFullListing: state.initialDocumentProbe.captureListing(containerId),
-            onPendingDiscovery: (delayMs) => schedulePendingDiscovery(state, containerId, delayMs),
-        });
-        if (!reconciled) {
-            state.discoveredContainerIds.delete(containerId);
+export async function reconcileMarkedContainers(host, state, containers, fullRevalidation = false) {
+    const results = await reconcileContainers(host, containers.map(({ containerId, forceDocumentContentPull }) => ({
+        containerId,
+        documentIds: fullRevalidation
+            ? undefined
+            : state.forcedDocumentIds.get(containerId),
+        forceDocumentContentPull,
+        onFullListing: state.initialDocumentProbe.captureListing(containerId),
+        onPendingDiscovery: (delayMs) => schedulePendingDiscovery(state, containerId, delayMs),
+    })));
+    for (const result of results) {
+        if (result.status !== "reconciled") {
+            state.discoveredContainerIds.delete(result.containerId);
         }
-        return reconciled;
-    }
-    catch (error) {
-        state.discoveredContainerIds.delete(containerId);
-        throw error;
     }
+    return results;
 }
-async function sweepContainer(input) {
-    const { containerId, host, lifecycleGeneration, state } = input;
-    if (!isCurrentReconciliationLifecycle(state, lifecycleGeneration)) {
-        return { status: "stale" };
+/**
+ * Reconciles one batch of a sweep. Force generations are read before the
+ * batched listing starts, so a hint arriving while the batch is in flight
+ * keeps its newer generation and runs again.
+ */
+async function sweepContainerBatch(input) {
+    const { containerIds, forceAllDocumentContentPulls, host, state } = input;
+    const forceGenerations = new Map(containerIds.map((containerId) => [
+        containerId,
+        state.forcedContainerGenerations.get(containerId),
+    ]));
+    const results = await reconcileMarkedContainers(host, state, containerIds.map((containerId) => ({
+        containerId,
+        forceDocumentContentPull: forceAllDocumentContentPulls ||
+            forceGenerations.get(containerId) !== undefined,
+    })), forceAllDocumentContentPulls);
+    if (!isCurrentReconciliationLifecycle(state, input.lifecycleGeneration)) {
+        return null;
     }
-    const forceGeneration = state.forcedContainerGenerations.get(containerId);
-    try {
-        const reconciled = await reconcileMarkedContainer(host, state, containerId, input.forceAllDocumentContentPulls || forceGeneration !== undefined, input.forceAllDocumentContentPulls);
-        if (!isCurrentReconciliationLifecycle(state, lifecycleGeneration)) {
-            return { status: "stale" };
-        }
-        if (reconciled) {
-            acknowledgeContainerForce(state, containerId, forceGeneration);
+    const failedForces = [];
+    let firstError;
+    for (const result of results) {
+        const forceGeneration = forceGenerations.get(result.containerId);
+        if (result.status === "reconciled") {
+            acknowledgeContainerForce(state, result.containerId, forceGeneration);
         }
-        return { status: "succeeded" };
-    }
-    catch (error) {
-        if (!isCurrentReconciliationLifecycle(state, lifecycleGeneration)) {
-            return { status: "stale" };
+        else if (result.status === "failed") {
+            if (forceGeneration !== undefined) {
+                failedForces.push({ containerId: result.containerId, forceGeneration });
+            }
+            if (!host.isIgnorableError(result.error) && firstError === undefined) {
+                firstError = result.error;
+            }
         }
-        return { error, forceGeneration, status: "failed" };
     }
+    return { failedForces, firstError };
 }
 export async function sweepKnownContainers(input) {
     const { forceAllDocumentContentPulls, host, knownIds, lifecycleGeneration, state, } = input;
@@ -98,28 +110,19 @@ export async function sweepKnownContainers(input) {
     // block refreshing the rest. Surface the first real error after the sweep.
     let firstError;
     const failedForces = [];
-    for (const containerId of containerIds) {
-        const result = await sweepContainer({
-            containerId,
+    for (let offset = 0; offset < containerIds.length; offset += MAX_CONTAINER_DOCUMENT_LANES) {
+        const batch = await sweepContainerBatch({
+            containerIds: containerIds.slice(offset, offset + MAX_CONTAINER_DOCUMENT_LANES),
             forceAllDocumentContentPulls,
             host,
             lifecycleGeneration,
             state,
         });
-        if (result.status === "stale") {
+        if (!batch)
             return;
-        }
-        if (result.status === "failed") {
-            if (result.forceGeneration !== undefined) {
-                failedForces.push({
-                    containerId,
-                    forceGeneration: result.forceGeneration,
-                });
-            }
-            if (!host.isIgnorableError(result.error) && firstError === undefined) {
-                firstError = result.error;
-            }
-        }
+        failedForces.push(...batch.failedForces);
+        if (firstError === undefined)
+            firstError = batch.firstError;
     }
     rearmFailedSweepContainers(state, failedForces, lifecycleGeneration);
     if (firstError !== undefined) {

package/sync/reconciliation/knownContainerSweep.js.map

@@ -1 +1 @@
-{"version":3,"file":"knownContainerSweep.js","sourceRoot":"","sources":["knownContainerSweep.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  acknowledgeContainerForce,\n  type IdleBackfillState,\n} from \"./idleBackfill\";\nimport {\n  type FailedForcedContainer,\n  rearmFailedSweepContainers,\n} from \"./laneFailure\";\nimport { reconcileOneContainer } from \"./reconcileContainer\";\nimport type { ReconciliationHost } from \"./serviceTypes\";\n\ninterface KnownContainerSweepState extends IdleBackfillState {\n  active: boolean;\n  lane: {\n    requestSync: () => void;\n    requestSyncAfter: (delayMs: number) => void;\n  } | null;\n  lifecycleGeneration: number;\n}\n\nconst pendingRetries = new WeakMap<\n  KnownContainerSweepState,\n  Map<string, { due: number; timer: ReturnType<typeof setTimeout> }>\n>();\n\nexport function clearPendingDiscoveryRetries(\n  state: KnownContainerSweepState,\n): void {\n  for (const { timer } of pendingRetries.get(state)?.values() ?? [])\n    clearTimeout(timer);\n  pendingRetries.delete(state);\n}\n\nfunction schedulePendingDiscovery(\n  state: KnownContainerSweepState,\n  containerId: string,\n  delayMs: number,\n): void {\n  if (!state.active) return;\n  const retries = pendingRetries.get(state) ?? new Map();\n  pendingRetries.set(state, retries);\n  const due = Date.now() + delayMs;\n  const existing = retries.get(containerId);\n  if (existing && existing.due <= due) return;\n  if (existing) clearTimeout(existing.timer);\n  const generation = state.lifecycleGeneration;\n  const timer = setTimeout(\n    () => {\n      retries.delete(containerId);\n      if (!state.active || state.lifecycleGeneration !== generation) return;\n      state.discoveredContainerIds.delete(containerId);\n      state.queue.enqueue(\n        containerId,\n        state.activeContainerId === containerId ? \"active\" : \"idle\",\n      );\n      state.lane?.requestSync();\n    },\n    Math.max(1, delayMs),\n  );\n  retries.set(containerId, { due, timer });\n}\n\nexport function isCurrentReconciliationLifecycle(\n  state: KnownContainerSweepState,\n  generation: number,\n): boolean {\n  return (\n    state.lifecycleGeneration === generation &&\n    (state.active || generation === 0)\n  );\n}\n\n// Reconcile a container whose discovered mark is already set, rolling the mark\n// back when the container is skipped or fails so a transient error (or a\n// container that later becomes eligible) can be retried.\nexport async function reconcileMarkedContainer(\n  host: ReconciliationHost,\n  state: KnownContainerSweepState,\n  containerId: string,\n  forceDocumentContentPull: boolean,\n  fullRevalidation = false,\n): Promise<boolean> {\n  try {\n    const reconciled = await reconcileOneContainer(host, containerId, {\n      forceDocumentContentPull,\n      documentIds: fullRevalidation\n        ? undefined\n        : state.forcedDocumentIds.get(containerId),\n      onFullListing: state.initialDocumentProbe.captureListing(containerId),\n      onPendingDiscovery: (delayMs) =>\n        schedulePendingDiscovery(state, containerId, delayMs),\n    });\n    if (!reconciled) {\n      state.discoveredContainerIds.delete(containerId);\n    }\n    return reconciled;\n  } catch (error) {\n    state.discoveredContainerIds.delete(containerId);\n    throw error;\n  }\n}\n\ntype SweepContainerResult =\n  | { status: \"failed\"; error: unknown; forceGeneration: number | undefined }\n  | { status: \"stale\" }\n  | { status: \"succeeded\" };\n\nasync function sweepContainer(input: {\n  containerId: string;\n  forceAllDocumentContentPulls: boolean;\n  host: ReconciliationHost;\n  lifecycleGeneration: number;\n  state: KnownContainerSweepState;\n}): Promise<SweepContainerResult> {\n  const { containerId, host, lifecycleGeneration, state } = input;\n  if (!isCurrentReconciliationLifecycle(state, lifecycleGeneration)) {\n    return { status: \"stale\" };\n  }\n  const forceGeneration = state.forcedContainerGenerations.get(containerId);\n  try {\n    const reconciled = await reconcileMarkedContainer(\n      host,\n      state,\n      containerId,\n      input.forceAllDocumentContentPulls || forceGeneration !== undefined,\n      input.forceAllDocumentContentPulls,\n    );\n    if (!isCurrentReconciliationLifecycle(state, lifecycleGeneration)) {\n      return { status: \"stale\" };\n    }\n    if (reconciled) {\n      acknowledgeContainerForce(state, containerId, forceGeneration);\n    }\n    return { status: \"succeeded\" };\n  } catch (error) {\n    if (!isCurrentReconciliationLifecycle(state, lifecycleGeneration)) {\n      return { status: \"stale\" };\n    }\n    return { error, forceGeneration, status: \"failed\" };\n  }\n}\n\nexport async function sweepKnownContainers(input: {\n  forceAllDocumentContentPulls: boolean;\n  host: ReconciliationHost;\n  knownIds: ReadonlyArray<string>;\n  lifecycleGeneration: number;\n  state: KnownContainerSweepState;\n}): Promise<void> {\n  const {\n    forceAllDocumentContentPulls,\n    host,\n    knownIds,\n    lifecycleGeneration,\n    state,\n  } = input;\n  if (!isCurrentReconciliationLifecycle(state, lifecycleGeneration)) {\n    return;\n  }\n  const containerIds = forceAllDocumentContentPulls\n    ? knownIds\n    : knownIds.filter(\n        (containerId) =>\n          state.forcedContainerGenerations.has(containerId) ||\n          !state.discoveredContainerIds.has(containerId),\n      );\n  // Mark only the containers this sweep will fetch. Automatic root hints are\n  // discovery signals, so already-reconciled containers stay settled unless a\n  // targeted event forced them; explicit full refreshes still fetch every id.\n  for (const containerId of containerIds) {\n    state.discoveredContainerIds.add(containerId);\n  }\n  // Reconcile every container independently: one failing container must not\n  // block refreshing the rest. Surface the first real error after the sweep.\n  let firstError: unknown;\n  const failedForces: FailedForcedContainer[] = [];\n  for (const containerId of containerIds) {\n    const result = await sweepContainer({\n      containerId,\n      forceAllDocumentContentPulls,\n      host,\n      lifecycleGeneration,\n      state,\n    });\n    if (result.status === \"stale\") {\n      return;\n    }\n    if (result.status === \"failed\") {\n      if (result.forceGeneration !== undefined) {\n        failedForces.push({\n          containerId,\n          forceGeneration: result.forceGeneration,\n        });\n      }\n      if (!host.isIgnorableError(result.error) && firstError === undefined) {\n        firstError = result.error;\n      }\n    }\n  }\n  rearmFailedSweepContainers(state, failedForces, lifecycleGeneration);\n  if (firstError !== undefined) {\n    throw firstError;\n  }\n}\n"]}
+{"version":3,"file":"knownContainerSweep.js","sourceRoot":"","sources":["knownContainerSweep.ts"],"names":[],"mappings":"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","sourcesContent":["import { MAX_CONTAINER_DOCUMENT_LANES } from \"@tearleads/validators/request\";\nimport {\n  acknowledgeContainerForce,\n  type IdleBackfillState,\n} from \"./idleBackfill\";\nimport {\n  type FailedForcedContainer,\n  rearmFailedSweepContainers,\n} from \"./laneFailure\";\nimport {\n  type ContainerReconcileResult,\n  reconcileContainers,\n} from \"./reconcileContainer\";\nimport type { ReconciliationHost } from \"./serviceTypes\";\n\ninterface KnownContainerSweepState extends IdleBackfillState {\n  active: boolean;\n  lane: {\n    requestSync: () => void;\n    requestSyncAfter: (delayMs: number) => void;\n  } | null;\n  lifecycleGeneration: number;\n}\n\nconst pendingRetries = new WeakMap<\n  KnownContainerSweepState,\n  Map<string, { due: number; timer: ReturnType<typeof setTimeout> }>\n>();\n\nexport function clearPendingDiscoveryRetries(\n  state: KnownContainerSweepState,\n): void {\n  for (const { timer } of pendingRetries.get(state)?.values() ?? [])\n    clearTimeout(timer);\n  pendingRetries.delete(state);\n}\n\nfunction schedulePendingDiscovery(\n  state: KnownContainerSweepState,\n  containerId: string,\n  delayMs: number,\n): void {\n  if (!state.active) return;\n  const retries = pendingRetries.get(state) ?? new Map();\n  pendingRetries.set(state, retries);\n  const due = Date.now() + delayMs;\n  const existing = retries.get(containerId);\n  if (existing && existing.due <= due) return;\n  if (existing) clearTimeout(existing.timer);\n  const generation = state.lifecycleGeneration;\n  const timer = setTimeout(\n    () => {\n      retries.delete(containerId);\n      if (!state.active || state.lifecycleGeneration !== generation) return;\n      state.discoveredContainerIds.delete(containerId);\n      state.queue.enqueue(\n        containerId,\n        state.activeContainerId === containerId ? \"active\" : \"idle\",\n      );\n      state.lane?.requestSync();\n    },\n    Math.max(1, delayMs),\n  );\n  retries.set(containerId, { due, timer });\n}\n\nexport function isCurrentReconciliationLifecycle(\n  state: KnownContainerSweepState,\n  generation: number,\n): boolean {\n  return (\n    state.lifecycleGeneration === generation &&\n    (state.active || generation === 0)\n  );\n}\n\n// Reconcile containers whose discovered marks are already set, rolling a mark\n// back when its container is skipped or fails so a transient error (or a\n// container that later becomes eligible) can be retried.\nexport async function reconcileMarkedContainers(\n  host: ReconciliationHost,\n  state: KnownContainerSweepState,\n  containers: ReadonlyArray<{\n    readonly containerId: string;\n    readonly forceDocumentContentPull: boolean;\n  }>,\n  fullRevalidation = false,\n): Promise<ReadonlyArray<ContainerReconcileResult>> {\n  const results = await reconcileContainers(\n    host,\n    containers.map(({ containerId, forceDocumentContentPull }) => ({\n      containerId,\n      documentIds: fullRevalidation\n        ? undefined\n        : state.forcedDocumentIds.get(containerId),\n      forceDocumentContentPull,\n      onFullListing: state.initialDocumentProbe.captureListing(containerId),\n      onPendingDiscovery: (delayMs: number) =>\n        schedulePendingDiscovery(state, containerId, delayMs),\n    })),\n  );\n  for (const result of results) {\n    if (result.status !== \"reconciled\") {\n      state.discoveredContainerIds.delete(result.containerId);\n    }\n  }\n  return results;\n}\n\n/**\n * Reconciles one batch of a sweep. Force generations are read before the\n * batched listing starts, so a hint arriving while the batch is in flight\n * keeps its newer generation and runs again.\n */\nasync function sweepContainerBatch(input: {\n  containerIds: ReadonlyArray<string>;\n  forceAllDocumentContentPulls: boolean;\n  host: ReconciliationHost;\n  lifecycleGeneration: number;\n  state: KnownContainerSweepState;\n}): Promise<{\n  readonly failedForces: ReadonlyArray<FailedForcedContainer>;\n  readonly firstError: unknown;\n} | null> {\n  const { containerIds, forceAllDocumentContentPulls, host, state } = input;\n  const forceGenerations = new Map(\n    containerIds.map((containerId) => [\n      containerId,\n      state.forcedContainerGenerations.get(containerId),\n    ]),\n  );\n  const results = await reconcileMarkedContainers(\n    host,\n    state,\n    containerIds.map((containerId) => ({\n      containerId,\n      forceDocumentContentPull:\n        forceAllDocumentContentPulls ||\n        forceGenerations.get(containerId) !== undefined,\n    })),\n    forceAllDocumentContentPulls,\n  );\n  if (!isCurrentReconciliationLifecycle(state, input.lifecycleGeneration)) {\n    return null;\n  }\n  const failedForces: FailedForcedContainer[] = [];\n  let firstError: unknown;\n  for (const result of results) {\n    const forceGeneration = forceGenerations.get(result.containerId);\n    if (result.status === \"reconciled\") {\n      acknowledgeContainerForce(state, result.containerId, forceGeneration);\n    } else if (result.status === \"failed\") {\n      if (forceGeneration !== undefined) {\n        failedForces.push({ containerId: result.containerId, forceGeneration });\n      }\n      if (!host.isIgnorableError(result.error) && firstError === undefined) {\n        firstError = result.error;\n      }\n    }\n  }\n  return { failedForces, firstError };\n}\n\nexport async function sweepKnownContainers(input: {\n  forceAllDocumentContentPulls: boolean;\n  host: ReconciliationHost;\n  knownIds: ReadonlyArray<string>;\n  lifecycleGeneration: number;\n  state: KnownContainerSweepState;\n}): Promise<void> {\n  const {\n    forceAllDocumentContentPulls,\n    host,\n    knownIds,\n    lifecycleGeneration,\n    state,\n  } = input;\n  if (!isCurrentReconciliationLifecycle(state, lifecycleGeneration)) {\n    return;\n  }\n  const containerIds = forceAllDocumentContentPulls\n    ? knownIds\n    : knownIds.filter(\n        (containerId) =>\n          state.forcedContainerGenerations.has(containerId) ||\n          !state.discoveredContainerIds.has(containerId),\n      );\n  // Mark only the containers this sweep will fetch. Automatic root hints are\n  // discovery signals, so already-reconciled containers stay settled unless a\n  // targeted event forced them; explicit full refreshes still fetch every id.\n  for (const containerId of containerIds) {\n    state.discoveredContainerIds.add(containerId);\n  }\n  // Reconcile every container independently: one failing container must not\n  // block refreshing the rest. Surface the first real error after the sweep.\n  let firstError: unknown;\n  const failedForces: FailedForcedContainer[] = [];\n  for (\n    let offset = 0;\n    offset < containerIds.length;\n    offset += MAX_CONTAINER_DOCUMENT_LANES\n  ) {\n    const batch = await sweepContainerBatch({\n      containerIds: containerIds.slice(\n        offset,\n        offset + MAX_CONTAINER_DOCUMENT_LANES,\n      ),\n      forceAllDocumentContentPulls,\n      host,\n      lifecycleGeneration,\n      state,\n    });\n    if (!batch) return;\n    failedForces.push(...batch.failedForces);\n    if (firstError === undefined) firstError = batch.firstError;\n  }\n  rearmFailedSweepContainers(state, failedForces, lifecycleGeneration);\n  if (firstError !== undefined) {\n    throw firstError;\n  }\n}\n"]}

package/sync/reconciliation/reconcileContainer.js

@@ -1,31 +1,63 @@
-export async function reconcileOneContainer(host, containerId, options = {}) {
-    // A queued local root/system id can become stale before the document phase.
-    if (!host.canDiscoverContainerDocuments(containerId)) {
-        return false;
-    }
+async function settleDiscoveredContainer(host, entry, outcome, pending) {
+    const { containerId } = entry;
     try {
-        let pending = false;
-        const discovered = await host.discoverContainerDocuments(containerId, options.onFullListing, (delayMs) => {
-            pending = true;
-            options.onPendingDiscovery?.(delayMs);
-        });
-        if (discovered === null && !pending) {
-            return false;
+        if (outcome.status === "rejected")
+            throw outcome.reason;
+        if (outcome.value === null && !pending) {
+            return { containerId, status: "skipped" };
         }
         const delta = await host.loadContainerDelta(containerId);
         host.applyReconciled(delta);
         // Hint forces target named documents. Full refreshes revalidate every
         // registered store; passive pulls only open system projections.
-        host.requestDocumentContentPull(containerId, delta.documentSummaries, options.forceDocumentContentPull ?? false, options.documentIds);
+        host.requestDocumentContentPull(containerId, delta.documentSummaries, entry.forceDocumentContentPull, entry.documentIds);
         // A durable, scheduled retry is settled for this sweep and force request.
         // Its own timer will reopen the lane when evidence is due.
-        return true;
+        return { containerId, status: "reconciled" };
     }
     catch (error) {
-        if (host.isIgnorableError(error)) {
-            return false;
+        return host.isIgnorableError(error)
+            ? { containerId, status: "skipped" }
+            : { containerId, error, status: "failed" };
+    }
+}
+/**
+ * Lists every entry's documents in one batched discovery, then reconciles each
+ * container as soon as its lane applies. Results follow entry order; one
+ * container's failure never hides another's result.
+ */
+export async function reconcileContainers(host, entries) {
+    // A queued local root/system id can become stale before the document phase.
+    const eligible = new Map(entries
+        .filter((entry) => host.canDiscoverContainerDocuments(entry.containerId))
+        .map((entry) => [entry.containerId, entry]));
+    const pending = new Set();
+    const results = new Map();
+    const settle = async (outcome) => {
+        const entry = eligible.get(outcome.containerId);
+        if (!entry || results.has(entry.containerId))
+            return;
+        results.set(entry.containerId, await settleDiscoveredContainer(host, entry, outcome, pending.has(entry.containerId)));
+    };
+    if (eligible.size > 0) {
+        try {
+            const outcomes = await host.discoverContainerDocuments([...eligible.values()].map((entry) => ({
+                containerId: entry.containerId,
+                onFullListing: entry.onFullListing,
+                onPendingDiscovery: (delayMs) => {
+                    pending.add(entry.containerId);
+                    entry.onPendingDiscovery?.(delayMs);
+                },
+            })), settle);
+            for (const outcome of outcomes)
+                await settle(outcome);
+        }
+        catch (reason) {
+            for (const containerId of eligible.keys()) {
+                await settle({ containerId, reason, status: "rejected" });
+            }
         }
-        throw error;
     }
+    return entries.map(({ containerId }) => results.get(containerId) ?? { containerId, status: "skipped" });
 }
 //# sourceMappingURL=reconcileContainer.js.map

package/sync/reconciliation/reconcileContainer.js.map

@@ -1 +1 @@
-{"version":3,"file":"reconcileContainer.js","sourceRoot":"","sources":["reconcileContainer.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,KAAK,UAAU,qBAAqB,CACzC,IAAwB,EACxB,WAAmB,EACnB,UAKI,EAAE;IAEN,4EAA4E;IAC5E,IAAI,CAAC,IAAI,CAAC,6BAA6B,CAAC,WAAW,CAAC,EAAE,CAAC;QACrD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,IAAI,CAAC;QACH,IAAI,OAAO,GAAG,KAAK,CAAC;QACpB,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,0BAA0B,CACtD,WAAW,EACX,OAAO,CAAC,aAAa,EACrB,CAAC,OAAO,EAAE,EAAE;YACV,OAAO,GAAG,IAAI,CAAC;YACf,OAAO,CAAC,kBAAkB,EAAE,CAAC,OAAO,CAAC,CAAC;QACxC,CAAC,CACF,CAAC;QACF,IAAI,UAAU,KAAK,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACpC,OAAO,KAAK,CAAC;QACf,CAAC;QACD,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,kBAAkB,CAAC,WAAW,CAAC,CAAC;QACzD,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC;QAC5B,sEAAsE;QACtE,gEAAgE;QAChE,IAAI,CAAC,0BAA0B,CAC7B,WAAW,EACX,KAAK,CAAC,iBAAiB,EACvB,OAAO,CAAC,wBAAwB,IAAI,KAAK,EACzC,OAAO,CAAC,WAAW,CACpB,CAAC;QACF,0EAA0E;QAC1E,2DAA2D;QAC3D,OAAO,IAAI,CAAC;IACd,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,EAAE,CAAC;YACjC,OAAO,KAAK,CAAC;QACf,CAAC;QACD,MAAM,KAAK,CAAC;IACd,CAAC;AACH,CAAC","sourcesContent":["import type { ReconciliationHost } from \"./serviceTypes\";\n\nexport async function reconcileOneContainer(\n  host: ReconciliationHost,\n  containerId: string,\n  options: {\n    forceDocumentContentPull?: boolean;\n    documentIds?: ReadonlySet<string> | undefined;\n    onFullListing?: ((documentIds: ReadonlyArray<string>) => void) | undefined;\n    onPendingDiscovery?: ((delayMs: number) => void) | undefined;\n  } = {},\n): Promise<boolean> {\n  // A queued local root/system id can become stale before the document phase.\n  if (!host.canDiscoverContainerDocuments(containerId)) {\n    return false;\n  }\n\n  try {\n    let pending = false;\n    const discovered = await host.discoverContainerDocuments(\n      containerId,\n      options.onFullListing,\n      (delayMs) => {\n        pending = true;\n        options.onPendingDiscovery?.(delayMs);\n      },\n    );\n    if (discovered === null && !pending) {\n      return false;\n    }\n    const delta = await host.loadContainerDelta(containerId);\n    host.applyReconciled(delta);\n    // Hint forces target named documents. Full refreshes revalidate every\n    // registered store; passive pulls only open system projections.\n    host.requestDocumentContentPull(\n      containerId,\n      delta.documentSummaries,\n      options.forceDocumentContentPull ?? false,\n      options.documentIds,\n    );\n    // A durable, scheduled retry is settled for this sweep and force request.\n    // Its own timer will reopen the lane when evidence is due.\n    return true;\n  } catch (error) {\n    if (host.isIgnorableError(error)) {\n      return false;\n    }\n    throw error;\n  }\n}\n"]}
+{"version":3,"file":"reconcileContainer.js","sourceRoot":"","sources":["reconcileContainer.ts"],"names":[],"mappings":"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","sourcesContent":["import type {\n  ContainerDiscoveryOutcome,\n  ReconciliationHost,\n} from \"./serviceTypes\";\n\nexport interface ContainerReconcileEntry {\n  readonly containerId: string;\n  readonly documentIds?: ReadonlySet<string> | undefined;\n  readonly forceDocumentContentPull: boolean;\n  readonly onFullListing?:\n    | ((documentIds: ReadonlyArray<string>) => void)\n    | undefined;\n  readonly onPendingDiscovery?: ((delayMs: number) => void) | undefined;\n}\n\nexport type ContainerReconcileResult =\n  | { readonly containerId: string; readonly status: \"reconciled\" | \"skipped\" }\n  | {\n      readonly containerId: string;\n      readonly error: unknown;\n      readonly status: \"failed\";\n    };\n\nasync function settleDiscoveredContainer(\n  host: ReconciliationHost,\n  entry: ContainerReconcileEntry,\n  outcome: ContainerDiscoveryOutcome,\n  pending: boolean,\n): Promise<ContainerReconcileResult> {\n  const { containerId } = entry;\n  try {\n    if (outcome.status === \"rejected\") throw outcome.reason;\n    if (outcome.value === null && !pending) {\n      return { containerId, status: \"skipped\" };\n    }\n    const delta = await host.loadContainerDelta(containerId);\n    host.applyReconciled(delta);\n    // Hint forces target named documents. Full refreshes revalidate every\n    // registered store; passive pulls only open system projections.\n    host.requestDocumentContentPull(\n      containerId,\n      delta.documentSummaries,\n      entry.forceDocumentContentPull,\n      entry.documentIds,\n    );\n    // A durable, scheduled retry is settled for this sweep and force request.\n    // Its own timer will reopen the lane when evidence is due.\n    return { containerId, status: \"reconciled\" };\n  } catch (error) {\n    return host.isIgnorableError(error)\n      ? { containerId, status: \"skipped\" }\n      : { containerId, error, status: \"failed\" };\n  }\n}\n\n/**\n * Lists every entry's documents in one batched discovery, then reconciles each\n * container as soon as its lane applies. Results follow entry order; one\n * container's failure never hides another's result.\n */\nexport async function reconcileContainers(\n  host: ReconciliationHost,\n  entries: ReadonlyArray<ContainerReconcileEntry>,\n): Promise<ReadonlyArray<ContainerReconcileResult>> {\n  // A queued local root/system id can become stale before the document phase.\n  const eligible = new Map(\n    entries\n      .filter((entry) => host.canDiscoverContainerDocuments(entry.containerId))\n      .map((entry) => [entry.containerId, entry]),\n  );\n  const pending = new Set<string>();\n  const results = new Map<string, ContainerReconcileResult>();\n  const settle = async (outcome: ContainerDiscoveryOutcome) => {\n    const entry = eligible.get(outcome.containerId);\n    if (!entry || results.has(entry.containerId)) return;\n    results.set(\n      entry.containerId,\n      await settleDiscoveredContainer(\n        host,\n        entry,\n        outcome,\n        pending.has(entry.containerId),\n      ),\n    );\n  };\n  if (eligible.size > 0) {\n    try {\n      const outcomes = await host.discoverContainerDocuments(\n        [...eligible.values()].map((entry) => ({\n          containerId: entry.containerId,\n          onFullListing: entry.onFullListing,\n          onPendingDiscovery: (delayMs: number) => {\n            pending.add(entry.containerId);\n            entry.onPendingDiscovery?.(delayMs);\n          },\n        })),\n        settle,\n      );\n      for (const outcome of outcomes) await settle(outcome);\n    } catch (reason) {\n      for (const containerId of eligible.keys()) {\n        await settle({ containerId, reason, status: \"rejected\" });\n      }\n    }\n  }\n  return entries.map(\n    ({ containerId }) =>\n      results.get(containerId) ?? { containerId, status: \"skipped\" },\n  );\n}\n"]}

package/sync/reconciliation/service.js

@@ -1,20 +1,36 @@
 import { getOrCreateDomainSyncCoordinator, } from "../../data/sync/syncCoordinator.js";
 import { acknowledgeContainerForce, activateContainer, enqueueKnownContainersForIdleBackfill, markContainerForced, } from "./idleBackfill.js";
 import { createInitialDocumentProbe } from "./initialDocumentProbe.js";
-import { clearPendingDiscoveryRetries, isCurrentReconciliationLifecycle, reconcileMarkedContainer, sweepKnownContainers, } from "./knownContainerSweep.js";
+import { clearPendingDiscoveryRetries, isCurrentReconciliationLifecycle, reconcileMarkedContainers, sweepKnownContainers, } from "./knownContainerSweep.js";
 import { rearmFailedContainer } from "./laneFailure.js";
 import { clearOriginatedDocuments } from "./originatedDocuments.js";
 import { createReconcileQueue } from "./queue.js";
 function canReconcile(status) {
     return status.dbStatus === "ready" && status.isAuthenticated && status.online;
 }
+/**
+ * Queued containers one lane run lists together. Each still verifies and
+ * applies on its own; the bound keeps one run's head verification well
+ * inside the lane watchdog.
+ */
+const RECONCILE_LANE_BATCH_SIZE = 4;
+function dequeueContainerBatch(state) {
+    const containerIds = [];
+    while (containerIds.length < RECONCILE_LANE_BATCH_SIZE) {
+        const containerId = state.queue.dequeue();
+        if (!containerId)
+            break;
+        containerIds.push(containerId);
+    }
+    return containerIds;
+}
 async function runReconcileLane(host, state) {
     if (!state.active || !canReconcile(host.getRuntimeStatus())) {
         return;
     }
     const lifecycleGeneration = state.lifecycleGeneration;
-    const containerId = state.queue.dequeue();
-    if (!containerId) {
+    const containerIds = dequeueContainerBatch(state);
+    if (containerIds.length === 0) {
         await state.initialDocumentProbe.run();
         scheduleProbeContinuation(host, state);
         return;
@@ -22,22 +38,34 @@ async function runReconcileLane(host, state) {
     // Double-check at run time: a container may have been discovered (by an
     // explicit refresh or an earlier lane pass) after it was queued. Mark it
     // discovered up front to collapse concurrent re-enqueues into one fetch, but
-    // roll the mark back on failure so a transient error can be retried later.
-    const forceGeneration = state.forcedContainerGenerations.get(containerId);
-    const shouldForce = forceGeneration !== undefined;
-    if (shouldForce || !state.discoveredContainerIds.has(containerId)) {
+    // roll the mark back on failure so a transient error can be retried. Force
+    // generations are read before the batched listing starts.
+    const batch = containerIds.flatMap((containerId) => {
+        const forceGeneration = state.forcedContainerGenerations.get(containerId);
+        if (forceGeneration === undefined &&
+            state.discoveredContainerIds.has(containerId)) {
+            return [];
+        }
         state.discoveredContainerIds.add(containerId);
-        try {
-            const reconciled = await reconcileMarkedContainer(host, state, containerId, shouldForce);
-            if (reconciled) {
-                acknowledgeContainerForce(state, containerId, forceGeneration);
-            }
+        return [{ containerId, forceGeneration }];
+    });
+    const results = await reconcileMarkedContainers(host, state, batch.map(({ containerId, forceGeneration }) => ({
+        containerId,
+        forceDocumentContentPull: forceGeneration !== undefined,
+    })));
+    let firstError;
+    results.forEach((result, index) => {
+        const forceGeneration = batch[index]?.forceGeneration;
+        if (result.status === "reconciled") {
+            acknowledgeContainerForce(state, result.containerId, forceGeneration);
         }
-        catch (error) {
-            rearmFailedContainer(state, containerId, forceGeneration, lifecycleGeneration);
-            throw error;
+        else if (result.status === "failed") {
+            rearmFailedContainer(state, result.containerId, forceGeneration, lifecycleGeneration);
+            firstError ??= result.error;
         }
-    }
+    });
+    if (firstError !== undefined)
+        throw firstError;
     // Keep draining: schedule another pass while the queue holds work.
     if (state.queue.size > 0) {
         state.lane?.requestSync();