@powerhousedao/reactor 6.2.2-dev.61 → 6.2.2-dev.62

package/dist/{build-worker-executor-DBHkoWBR.js → build-worker-executor-DymEQNP9.js}

@@ -1,4 +1,4 @@
-import { _ as DocumentMetaCache, c as KyselyKeyframeStore, f as KyselyExecutionScope, g as KyselyOperationIndex, h as KyselyWriteCache, l as DocumentModelRegistry, m as EventBus, n as REACTOR_SCHEMA, s as KyselyOperationStore, t as DEFAULT_DRIVE_CONTAINER_TYPES, u as SimpleJobExecutor, v as CollectionMembershipCache } from "./drive-container-types-bVQ_8YwX.js";
+import { _ as DocumentMetaCache, c as KyselyKeyframeStore, f as KyselyExecutionScope, g as KyselyOperationIndex, h as KyselyWriteCache, l as DocumentModelRegistry, m as EventBus, n as REACTOR_SCHEMA, s as KyselyOperationStore, t as DEFAULT_DRIVE_CONTAINER_TYPES, u as SimpleJobExecutor, v as CollectionMembershipCache } from "./drive-container-types-CruMdXue.js";
 import { n as ReactorEventTypes } from "./types-DMKLa0Ok.js";
 //#region src/executor/worker/build-worker-executor.ts
 async function defaultLoadFactory(spec) {
@@ -80,4 +80,4 @@ async function buildWorkerExecutor(options) {
 //#endregion
 export { defaultLoadFactory as n, buildWorkerExecutor as t };
 
-//# sourceMappingURL=build-worker-executor-DBHkoWBR.js.map
+//# sourceMappingURL=build-worker-executor-DymEQNP9.js.map

package/dist/{build-worker-executor-DBHkoWBR.js.map → build-worker-executor-DymEQNP9.js.map}

@@ -1 +1 @@
-{"version":3,"file":"build-worker-executor-DBHkoWBR.js","names":[],"sources":["../src/executor/worker/build-worker-executor.ts"],"sourcesContent":["import type {\n  DocumentModelModule,\n  OperationWithContext,\n} from \"@powerhousedao/shared/document-model\";\nimport type { ILogger } from \"document-model\";\nimport type { Kysely } from \"kysely\";\nimport { CollectionMembershipCache } from \"../../cache/collection-membership-cache.js\";\nimport { DocumentMetaCache } from \"../../cache/document-meta-cache.js\";\nimport { KyselyOperationIndex } from \"../../cache/kysely-operation-index.js\";\nimport { KyselyWriteCache } from \"../../cache/kysely-write-cache.js\";\nimport type { WriteCacheConfig } from \"../../cache/write-cache-types.js\";\nimport { DEFAULT_DRIVE_CONTAINER_TYPES } from \"../../core/drive-container-types.js\";\nimport type { Database } from \"../../core/types.js\";\nimport { EventBus } from \"../../events/event-bus.js\";\nimport {\n  ReactorEventTypes,\n  type JobWriteReadyEvent,\n} from \"../../events/types.js\";\nimport { DocumentModelRegistry } from \"../../registry/implementation.js\";\nimport type { JobMeta } from \"../../shared/types.js\";\nimport type { SignatureVerificationHandler } from \"../../signer/types.js\";\nimport { KyselyKeyframeStore } from \"../../storage/kysely/keyframe-store.js\";\nimport { KyselyOperationStore } from \"../../storage/kysely/store.js\";\nimport type { Database as StorageDatabase } from \"../../storage/kysely/types.js\";\nimport { REACTOR_SCHEMA } from \"../../storage/migrations/migrator.js\";\nimport { KyselyExecutionScope } from \"../execution-scope.js\";\nimport { SimpleJobExecutor } from \"../simple-job-executor.js\";\nimport type { JobExecutorConfig } from \"../types.js\";\nimport type {\n  FactorySpec,\n  InitMessage,\n  ModelManifestEntry,\n} from \"./protocol.js\";\n\n/**\n * In-worker capture of the JOB_WRITE_READY event emitted by the executor.\n * The worker forwards `operations` and `jobMeta` back to the parent; the\n * parent re-enriches `collectionMemberships` at emit time.\n */\nexport type WorkerWriteReadyCapture = {\n  operations: OperationWithContext[];\n  jobMeta: JobMeta;\n};\n\nexport type WorkerExecutorStack = {\n  executor: SimpleJobExecutor;\n  registry: DocumentModelRegistry;\n  /**\n   * Synchronously pops the most-recent JOB_WRITE_READY captured on this\n   * worker's local event bus and clears it. Returns null if the executor\n   * did not produce one for this job.\n   */\n  takeLastWriteReady(): WorkerWriteReadyCapture | null;\n};\n\nexport type BuildWorkerExecutorOptions = {\n  init: InitMessage;\n  database: Kysely<Database>;\n  logger: ILogger;\n  executorConfig?: JobExecutorConfig;\n  driveContainerTypes?: ReadonlySet<string>;\n  /**\n   * Override the module loader used to materialize factory specs. Tests\n   * can inject a deterministic resolver instead of touching the real\n   * Node module loader.\n   */\n  loadFactory?: (spec: FactorySpec) => Promise<unknown>;\n};\n\nexport async function defaultLoadFactory(spec: FactorySpec): Promise<unknown> {\n  const ref = spec.module;\n  const specifier =\n    \"filePath\" in ref\n      ? new URL(`file://${ref.filePath}`).href\n      : ref.packageName;\n  const mod = (await import(specifier)) as Record<string, unknown>;\n  const exported = mod[ref.exportName];\n  if (typeof exported === \"function\") {\n    return (exported as (args: unknown) => unknown)(spec.initArgs);\n  }\n  return exported;\n}\n\nasync function loadModelManifest(\n  entries: ModelManifestEntry[],\n  loadFactory: (spec: FactorySpec) => Promise<unknown>,\n  registry: DocumentModelRegistry,\n  logger: ILogger,\n): Promise<void> {\n  for (const entry of entries) {\n    let module: DocumentModelModule;\n    try {\n      module = (await loadFactory(entry.spec)) as DocumentModelModule;\n    } catch (error) {\n      logger.error(\n        \"worker failed to load document model: @entry @error\",\n        entry,\n        error,\n      );\n      throw error;\n    }\n    const [result] = registry.registerModules(module);\n    if (result.status === \"error\") {\n      logger.error(\n        \"worker failed to register document model: @entry @error\",\n        entry,\n        result.error,\n      );\n      throw result.error;\n    }\n  }\n}\n\n/**\n * Assembles the in-worker storage stack plus a {@link SimpleJobExecutor}\n * bound to a pre-built Kysely instance. The parent owns the wire protocol\n * and routing; the worker owns everything below `SimpleJobExecutor`.\n *\n * The local event bus exists only to satisfy the executor's contract: its\n * JOB_WRITE_READY emissions are captured here and shipped to the parent\n * via {@link WorkerExecutorStack.takeLastWriteReady}.\n */\nexport async function buildWorkerExecutor(\n  options: BuildWorkerExecutorOptions,\n): Promise<WorkerExecutorStack> {\n  const { init, database: baseDatabase, logger } = options;\n  const driveContainerTypes =\n    options.driveContainerTypes ?? DEFAULT_DRIVE_CONTAINER_TYPES;\n  const loadFactory = options.loadFactory ?? defaultLoadFactory;\n\n  const registry = new DocumentModelRegistry();\n  await loadModelManifest(init.models, loadFactory, registry, logger);\n\n  let signatureVerifier: SignatureVerificationHandler | undefined;\n  if (init.signatureVerifier) {\n    try {\n      signatureVerifier = (await loadFactory(\n        init.signatureVerifier,\n      )) as SignatureVerificationHandler;\n    } catch (error) {\n      logger.error(\n        \"worker failed to load signature verifier: @spec @error\",\n        init.signatureVerifier,\n        error,\n      );\n      throw error;\n    }\n  }\n\n  const database = baseDatabase.withSchema(REACTOR_SCHEMA);\n  const operationStore = new KyselyOperationStore(\n    database as unknown as Kysely<StorageDatabase>,\n  );\n  const keyframeStore = new KyselyKeyframeStore(\n    database as unknown as Kysely<StorageDatabase>,\n  );\n\n  const cacheConfig: WriteCacheConfig = {\n    maxDocuments: 100,\n    ringBufferSize: 10,\n    keyframeInterval: 10,\n  };\n  const writeCache = new KyselyWriteCache(\n    keyframeStore,\n    operationStore,\n    registry,\n    cacheConfig,\n  );\n  await writeCache.startup();\n\n  const operationIndex = new KyselyOperationIndex(\n    database as unknown as Kysely<StorageDatabase>,\n  );\n\n  const documentMetaCache = new DocumentMetaCache(operationStore, {\n    maxDocuments: 1000,\n  });\n  await documentMetaCache.startup();\n\n  const collectionMembershipCache = new CollectionMembershipCache(\n    operationIndex,\n  );\n\n  const executionScope = new KyselyExecutionScope(\n    database as unknown as Kysely<StorageDatabase>,\n    operationStore,\n    operationIndex,\n    keyframeStore,\n    writeCache,\n    documentMetaCache,\n    collectionMembershipCache,\n  );\n\n  const eventBus = new EventBus();\n  let lastWriteReady: WorkerWriteReadyCapture | null = null;\n  eventBus.subscribe(\n    ReactorEventTypes.JOB_WRITE_READY,\n    (_t: number, event: JobWriteReadyEvent) => {\n      lastWriteReady = {\n        operations: event.operations,\n        jobMeta: event.jobMeta,\n      };\n    },\n  );\n\n  const executorConfig = options.executorConfig ?? {};\n  const executor = new SimpleJobExecutor(\n    logger,\n    registry,\n    operationStore,\n    eventBus,\n    writeCache,\n    operationIndex,\n    documentMetaCache,\n    collectionMembershipCache,\n    driveContainerTypes,\n    executorConfig,\n    signatureVerifier,\n    executionScope,\n  );\n\n  return {\n    executor,\n    registry,\n    takeLastWriteReady(): WorkerWriteReadyCapture | null {\n      const captured = lastWriteReady;\n      lastWriteReady = null;\n      return captured;\n    },\n  };\n}\n"],"mappings":";;;AAqEA,eAAsB,mBAAmB,MAAqC;CAC5E,MAAM,MAAM,KAAK;CAMjB,MAAM,YADO,OAHX,cAAc,MAAA,OACV,IAAI,IAAI,UAAU,IAAI,WAAW,CAAC,QAAA,OAClC,IAAI,eAEW,IAAI;AACzB,KAAI,OAAO,aAAa,WACtB,QAAQ,SAAwC,KAAK,SAAS;AAEhE,QAAO;;AAGT,eAAe,kBACb,SACA,aACA,UACA,QACe;AACf,MAAK,MAAM,SAAS,SAAS;EAC3B,IAAI;AACJ,MAAI;AACF,YAAU,MAAM,YAAY,MAAM,KAAK;WAChC,OAAO;AACd,UAAO,MACL,uDACA,OACA,MACD;AACD,SAAM;;EAER,MAAM,CAAC,UAAU,SAAS,gBAAgB,OAAO;AACjD,MAAI,OAAO,WAAW,SAAS;AAC7B,UAAO,MACL,2DACA,OACA,OAAO,MACR;AACD,SAAM,OAAO;;;;;;;;;;;;;AAcnB,eAAsB,oBACpB,SAC8B;CAC9B,MAAM,EAAE,MAAM,UAAU,cAAc,WAAW;CACjD,MAAM,sBACJ,QAAQ,uBAAuB;CACjC,MAAM,cAAc,QAAQ,eAAe;CAE3C,MAAM,WAAW,IAAI,uBAAuB;AAC5C,OAAM,kBAAkB,KAAK,QAAQ,aAAa,UAAU,OAAO;CAEnE,IAAI;AACJ,KAAI,KAAK,kBACP,KAAI;AACF,sBAAqB,MAAM,YACzB,KAAK,kBACN;UACM,OAAO;AACd,SAAO,MACL,0DACA,KAAK,mBACL,MACD;AACD,QAAM;;CAIV,MAAM,WAAW,aAAa,WAAW,eAAe;CACxD,MAAM,iBAAiB,IAAI,qBACzB,SACD;CACD,MAAM,gBAAgB,IAAI,oBACxB,SACD;CAOD,MAAM,aAAa,IAAI,iBACrB,eACA,gBACA,UARoC;EACpC,cAAc;EACd,gBAAgB;EAChB,kBAAkB;EACnB,CAMA;AACD,OAAM,WAAW,SAAS;CAE1B,MAAM,iBAAiB,IAAI,qBACzB,SACD;CAED,MAAM,oBAAoB,IAAI,kBAAkB,gBAAgB,EAC9D,cAAc,KACf,CAAC;AACF,OAAM,kBAAkB,SAAS;CAEjC,MAAM,4BAA4B,IAAI,0BACpC,eACD;CAED,MAAM,iBAAiB,IAAI,qBACzB,UACA,gBACA,gBACA,eACA,YACA,mBACA,0BACD;CAED,MAAM,WAAW,IAAI,UAAU;CAC/B,IAAI,iBAAiD;AACrD,UAAS,UACP,kBAAkB,kBACjB,IAAY,UAA8B;AACzC,mBAAiB;GACf,YAAY,MAAM;GAClB,SAAS,MAAM;GAChB;GAEJ;AAkBD,QAAO;EACL,UAhBe,IAAI,kBACnB,QACA,UACA,gBACA,UACA,YACA,gBACA,mBACA,2BACA,qBAVqB,QAAQ,kBAAkB,EAAE,EAYjD,mBACA,eACD;EAIC;EACA,qBAAqD;GACnD,MAAM,WAAW;AACjB,oBAAiB;AACjB,UAAO;;EAEV"}
+{"version":3,"file":"build-worker-executor-DymEQNP9.js","names":[],"sources":["../src/executor/worker/build-worker-executor.ts"],"sourcesContent":["import type {\n  DocumentModelModule,\n  OperationWithContext,\n} from \"@powerhousedao/shared/document-model\";\nimport type { ILogger } from \"document-model\";\nimport type { Kysely } from \"kysely\";\nimport { CollectionMembershipCache } from \"../../cache/collection-membership-cache.js\";\nimport { DocumentMetaCache } from \"../../cache/document-meta-cache.js\";\nimport { KyselyOperationIndex } from \"../../cache/kysely-operation-index.js\";\nimport { KyselyWriteCache } from \"../../cache/kysely-write-cache.js\";\nimport type { WriteCacheConfig } from \"../../cache/write-cache-types.js\";\nimport { DEFAULT_DRIVE_CONTAINER_TYPES } from \"../../core/drive-container-types.js\";\nimport type { Database } from \"../../core/types.js\";\nimport { EventBus } from \"../../events/event-bus.js\";\nimport {\n  ReactorEventTypes,\n  type JobWriteReadyEvent,\n} from \"../../events/types.js\";\nimport { DocumentModelRegistry } from \"../../registry/implementation.js\";\nimport type { JobMeta } from \"../../shared/types.js\";\nimport type { SignatureVerificationHandler } from \"../../signer/types.js\";\nimport { KyselyKeyframeStore } from \"../../storage/kysely/keyframe-store.js\";\nimport { KyselyOperationStore } from \"../../storage/kysely/store.js\";\nimport type { Database as StorageDatabase } from \"../../storage/kysely/types.js\";\nimport { REACTOR_SCHEMA } from \"../../storage/migrations/migrator.js\";\nimport { KyselyExecutionScope } from \"../execution-scope.js\";\nimport { SimpleJobExecutor } from \"../simple-job-executor.js\";\nimport type { JobExecutorConfig } from \"../types.js\";\nimport type {\n  FactorySpec,\n  InitMessage,\n  ModelManifestEntry,\n} from \"./protocol.js\";\n\n/**\n * In-worker capture of the JOB_WRITE_READY event emitted by the executor.\n * The worker forwards `operations` and `jobMeta` back to the parent; the\n * parent re-enriches `collectionMemberships` at emit time.\n */\nexport type WorkerWriteReadyCapture = {\n  operations: OperationWithContext[];\n  jobMeta: JobMeta;\n};\n\nexport type WorkerExecutorStack = {\n  executor: SimpleJobExecutor;\n  registry: DocumentModelRegistry;\n  /**\n   * Synchronously pops the most-recent JOB_WRITE_READY captured on this\n   * worker's local event bus and clears it. Returns null if the executor\n   * did not produce one for this job.\n   */\n  takeLastWriteReady(): WorkerWriteReadyCapture | null;\n};\n\nexport type BuildWorkerExecutorOptions = {\n  init: InitMessage;\n  database: Kysely<Database>;\n  logger: ILogger;\n  executorConfig?: JobExecutorConfig;\n  driveContainerTypes?: ReadonlySet<string>;\n  /**\n   * Override the module loader used to materialize factory specs. Tests\n   * can inject a deterministic resolver instead of touching the real\n   * Node module loader.\n   */\n  loadFactory?: (spec: FactorySpec) => Promise<unknown>;\n};\n\nexport async function defaultLoadFactory(spec: FactorySpec): Promise<unknown> {\n  const ref = spec.module;\n  const specifier =\n    \"filePath\" in ref\n      ? new URL(`file://${ref.filePath}`).href\n      : ref.packageName;\n  const mod = (await import(specifier)) as Record<string, unknown>;\n  const exported = mod[ref.exportName];\n  if (typeof exported === \"function\") {\n    return (exported as (args: unknown) => unknown)(spec.initArgs);\n  }\n  return exported;\n}\n\nasync function loadModelManifest(\n  entries: ModelManifestEntry[],\n  loadFactory: (spec: FactorySpec) => Promise<unknown>,\n  registry: DocumentModelRegistry,\n  logger: ILogger,\n): Promise<void> {\n  for (const entry of entries) {\n    let module: DocumentModelModule;\n    try {\n      module = (await loadFactory(entry.spec)) as DocumentModelModule;\n    } catch (error) {\n      logger.error(\n        \"worker failed to load document model: @entry @error\",\n        entry,\n        error,\n      );\n      throw error;\n    }\n    const [result] = registry.registerModules(module);\n    if (result.status === \"error\") {\n      logger.error(\n        \"worker failed to register document model: @entry @error\",\n        entry,\n        result.error,\n      );\n      throw result.error;\n    }\n  }\n}\n\n/**\n * Assembles the in-worker storage stack plus a {@link SimpleJobExecutor}\n * bound to a pre-built Kysely instance. The parent owns the wire protocol\n * and routing; the worker owns everything below `SimpleJobExecutor`.\n *\n * The local event bus exists only to satisfy the executor's contract: its\n * JOB_WRITE_READY emissions are captured here and shipped to the parent\n * via {@link WorkerExecutorStack.takeLastWriteReady}.\n */\nexport async function buildWorkerExecutor(\n  options: BuildWorkerExecutorOptions,\n): Promise<WorkerExecutorStack> {\n  const { init, database: baseDatabase, logger } = options;\n  const driveContainerTypes =\n    options.driveContainerTypes ?? DEFAULT_DRIVE_CONTAINER_TYPES;\n  const loadFactory = options.loadFactory ?? defaultLoadFactory;\n\n  const registry = new DocumentModelRegistry();\n  await loadModelManifest(init.models, loadFactory, registry, logger);\n\n  let signatureVerifier: SignatureVerificationHandler | undefined;\n  if (init.signatureVerifier) {\n    try {\n      signatureVerifier = (await loadFactory(\n        init.signatureVerifier,\n      )) as SignatureVerificationHandler;\n    } catch (error) {\n      logger.error(\n        \"worker failed to load signature verifier: @spec @error\",\n        init.signatureVerifier,\n        error,\n      );\n      throw error;\n    }\n  }\n\n  const database = baseDatabase.withSchema(REACTOR_SCHEMA);\n  const operationStore = new KyselyOperationStore(\n    database as unknown as Kysely<StorageDatabase>,\n  );\n  const keyframeStore = new KyselyKeyframeStore(\n    database as unknown as Kysely<StorageDatabase>,\n  );\n\n  const cacheConfig: WriteCacheConfig = {\n    maxDocuments: 100,\n    ringBufferSize: 10,\n    keyframeInterval: 10,\n  };\n  const writeCache = new KyselyWriteCache(\n    keyframeStore,\n    operationStore,\n    registry,\n    cacheConfig,\n  );\n  await writeCache.startup();\n\n  const operationIndex = new KyselyOperationIndex(\n    database as unknown as Kysely<StorageDatabase>,\n  );\n\n  const documentMetaCache = new DocumentMetaCache(operationStore, {\n    maxDocuments: 1000,\n  });\n  await documentMetaCache.startup();\n\n  const collectionMembershipCache = new CollectionMembershipCache(\n    operationIndex,\n  );\n\n  const executionScope = new KyselyExecutionScope(\n    database as unknown as Kysely<StorageDatabase>,\n    operationStore,\n    operationIndex,\n    keyframeStore,\n    writeCache,\n    documentMetaCache,\n    collectionMembershipCache,\n  );\n\n  const eventBus = new EventBus();\n  let lastWriteReady: WorkerWriteReadyCapture | null = null;\n  eventBus.subscribe(\n    ReactorEventTypes.JOB_WRITE_READY,\n    (_t: number, event: JobWriteReadyEvent) => {\n      lastWriteReady = {\n        operations: event.operations,\n        jobMeta: event.jobMeta,\n      };\n    },\n  );\n\n  const executorConfig = options.executorConfig ?? {};\n  const executor = new SimpleJobExecutor(\n    logger,\n    registry,\n    operationStore,\n    eventBus,\n    writeCache,\n    operationIndex,\n    documentMetaCache,\n    collectionMembershipCache,\n    driveContainerTypes,\n    executorConfig,\n    signatureVerifier,\n    executionScope,\n  );\n\n  return {\n    executor,\n    registry,\n    takeLastWriteReady(): WorkerWriteReadyCapture | null {\n      const captured = lastWriteReady;\n      lastWriteReady = null;\n      return captured;\n    },\n  };\n}\n"],"mappings":";;;AAqEA,eAAsB,mBAAmB,MAAqC;CAC5E,MAAM,MAAM,KAAK;CAMjB,MAAM,YADO,OAHX,cAAc,MAAA,OACV,IAAI,IAAI,UAAU,IAAI,WAAW,CAAC,QAAA,OAClC,IAAI,eAEW,IAAI;AACzB,KAAI,OAAO,aAAa,WACtB,QAAQ,SAAwC,KAAK,SAAS;AAEhE,QAAO;;AAGT,eAAe,kBACb,SACA,aACA,UACA,QACe;AACf,MAAK,MAAM,SAAS,SAAS;EAC3B,IAAI;AACJ,MAAI;AACF,YAAU,MAAM,YAAY,MAAM,KAAK;WAChC,OAAO;AACd,UAAO,MACL,uDACA,OACA,MACD;AACD,SAAM;;EAER,MAAM,CAAC,UAAU,SAAS,gBAAgB,OAAO;AACjD,MAAI,OAAO,WAAW,SAAS;AAC7B,UAAO,MACL,2DACA,OACA,OAAO,MACR;AACD,SAAM,OAAO;;;;;;;;;;;;;AAcnB,eAAsB,oBACpB,SAC8B;CAC9B,MAAM,EAAE,MAAM,UAAU,cAAc,WAAW;CACjD,MAAM,sBACJ,QAAQ,uBAAuB;CACjC,MAAM,cAAc,QAAQ,eAAe;CAE3C,MAAM,WAAW,IAAI,uBAAuB;AAC5C,OAAM,kBAAkB,KAAK,QAAQ,aAAa,UAAU,OAAO;CAEnE,IAAI;AACJ,KAAI,KAAK,kBACP,KAAI;AACF,sBAAqB,MAAM,YACzB,KAAK,kBACN;UACM,OAAO;AACd,SAAO,MACL,0DACA,KAAK,mBACL,MACD;AACD,QAAM;;CAIV,MAAM,WAAW,aAAa,WAAW,eAAe;CACxD,MAAM,iBAAiB,IAAI,qBACzB,SACD;CACD,MAAM,gBAAgB,IAAI,oBACxB,SACD;CAOD,MAAM,aAAa,IAAI,iBACrB,eACA,gBACA,UARoC;EACpC,cAAc;EACd,gBAAgB;EAChB,kBAAkB;EACnB,CAMA;AACD,OAAM,WAAW,SAAS;CAE1B,MAAM,iBAAiB,IAAI,qBACzB,SACD;CAED,MAAM,oBAAoB,IAAI,kBAAkB,gBAAgB,EAC9D,cAAc,KACf,CAAC;AACF,OAAM,kBAAkB,SAAS;CAEjC,MAAM,4BAA4B,IAAI,0BACpC,eACD;CAED,MAAM,iBAAiB,IAAI,qBACzB,UACA,gBACA,gBACA,eACA,YACA,mBACA,0BACD;CAED,MAAM,WAAW,IAAI,UAAU;CAC/B,IAAI,iBAAiD;AACrD,UAAS,UACP,kBAAkB,kBACjB,IAAY,UAA8B;AACzC,mBAAiB;GACf,YAAY,MAAM;GAClB,SAAS,MAAM;GAChB;GAEJ;AAkBD,QAAO;EACL,UAhBe,IAAI,kBACnB,QACA,UACA,gBACA,UACA,YACA,gBACA,mBACA,2BACA,qBAVqB,QAAQ,kBAAkB,EAAE,EAYjD,mBACA,eACD;EAIC;EACA,qBAAqD;GACnD,MAAM,WAAW;AACjB,oBAAiB;AACjB,UAAO;;EAEV"}

package/dist/{drive-container-types-bVQ_8YwX.js → drive-container-types-CruMdXue.js}

@@ -572,14 +572,16 @@ function documentDecisionModel(target) {
 * append condition it returns is the read-set the store enforces at write time.
 *
 * With `conditions` supplied, the executing scope's state is read at the head
-* for `doc.<scope>.*` paths. That read carries no append-condition entry of
-* its own: the written stream's expected-revision check already refuses a
-* write whose scope grew between the read and the append.
+* for `doc.<scope>.*` paths, or taken from the run's carried document when the
+* caller has already reduced earlier writes into it. That read carries no
+* append-condition entry of its own: the written stream's expected-revision
+* check already refuses a write whose scope grew between the read and the
+* append.
 */
 async function decideAtHead(model, cache, target, subject, request, signal, conditions) {
 	const built = await buildDecisionModel(cache, model, target, signal);
 	let scopeState;
-	if (conditions !== void 0) scopeState = (await cache.getState(target.documentId, request.scope, target.branch, void 0, signal)).state[request.scope];
+	if (conditions !== void 0) scopeState = (conditions.carriedDocument ?? await cache.getState(target.documentId, request.scope, target.branch, void 0, signal)).state[request.scope];
 	return {
 		evaluation: model(target).decide(built.model, subject, request, {
 			scopeState,
@@ -1740,6 +1742,17 @@ var KyselyWriteCache = class KyselyWriteCache {
 	putState(documentId, scope, branch, revision, document, position) {
 		this.store(documentId, scope, branch, revision, document, position);
 	}
+	/**
+	* Stores the run's head and mints a keyframe for every interval the run
+	* crossed on its way there. Only the head enters the ring buffer; the
+	* earlier revisions are keyframe candidates and nothing more.
+	*/
+	putRun(documentId, scope, branch, run) {
+		if (run.length === 0) return;
+		for (const entry of run.slice(0, -1)) this.persistKeyframe(documentId, scope, branch, entry.revision, entry.document);
+		const head = run[run.length - 1];
+		this.store(documentId, scope, branch, head.revision, head.document, SnapshotPosition.Head);
+	}
 	store(documentId, scope, branch, revision, document, position) {
 		const streamKey = this.makeStreamKey(documentId, scope, branch);
 		const stream = this.getOrCreateStream(streamKey);
@@ -1753,7 +1766,12 @@ var KyselyWriteCache = class KyselyWriteCache {
 			position
 		};
 		stream.ringBuffer.push(snapshot);
-		if (this.isKeyframeRevision(revision)) this.keyframeStore.putKeyframe(documentId, scope, branch, revision, {
+		this.persistKeyframe(documentId, scope, branch, revision, document);
+	}
+	/** Persists the snapshot if this revision is one the interval falls on. */
+	persistKeyframe(documentId, scope, branch, revision, document) {
+		if (!this.isKeyframeRevision(revision)) return;
+		this.keyframeStore.putKeyframe(documentId, scope, branch, revision, {
 			...document,
 			operations: {},
 			clipboard: []
@@ -2327,14 +2345,15 @@ function reshuffleByTimestamp(startIndex, opsA, opsB) {
 	return [...opsA, ...opsB].sort((a, b) => {
 		const timestampDiff = new Date(a.timestampUtcMs).getTime() - new Date(b.timestampUtcMs).getTime();
 		if (timestampDiff !== 0) return timestampDiff;
-		const shouldPrioritizeLogicalIndex = STRICT_ORDER_ACTION_TYPES.has(a.action?.type ?? "") || STRICT_ORDER_ACTION_TYPES.has(b.action?.type ?? "");
-		const logicalIndexDiff = a.index - a.skip - (b.index - b.skip);
-		if (shouldPrioritizeLogicalIndex) {
+		const rank = (op) => STRICT_ORDER_ACTION_TYPES.has(op.action?.type ?? "") ? 0 : 1;
+		const rankDiff = rank(a) - rank(b);
+		if (rankDiff !== 0) return rankDiff;
+		if (rank(a) === 0) {
+			const logicalIndexDiff = a.index - a.skip - (b.index - b.skip);
 			if (logicalIndexDiff !== 0) return logicalIndexDiff;
 		}
 		const actionIdDiff = (a.action?.id ?? "").localeCompare(b.action?.id ?? "");
 		if (actionIdDiff !== 0) return actionIdDiff;
-		if (!shouldPrioritizeLogicalIndex && logicalIndexDiff !== 0) return logicalIndexDiff;
 		return a.id.localeCompare(b.id);
 	}).map((op, i) => ({
 		...op,
@@ -3155,9 +3174,6 @@ function isValidISOTimestamp(value) {
 	if (!ISO_TIMESTAMP_REGEX.test(value)) return false;
 	return !isNaN(new Date(value).getTime());
 }
-/**
-* Simple job executor that processes a job by applying actions through document model reducers.
-*/
 var SimpleJobExecutor = class {
 	config;
 	featureFlags;
@@ -3183,7 +3199,8 @@ var SimpleJobExecutor = class {
 			deferredJobTtlMs: config.deferredJobTtlMs ?? 3e4,
 			retryBaseDelayMs: config.retryBaseDelayMs ?? 100,
 			retryMaxDelayMs: config.retryMaxDelayMs ?? 5e3,
-			yieldDeadlineMs: config.yieldDeadlineMs ?? 50
+			yieldDeadlineMs: config.yieldDeadlineMs ?? 50,
+			batchApplies: config.batchApplies ?? true
 		};
 		this.featureFlags = resolveFeatureFlags(config.featureFlags);
 		this.decisionModel = selectDecisionModel(this.featureFlags, registry);
@@ -3356,6 +3373,21 @@ var SimpleJobExecutor = class {
 			error: new InvalidOperationTimestampError(job.documentId, action.scope, action.timestampUtcMs, `action ${action.type} (id: ${action.id})`)
 		};
 		let lastYield = performance.now();
+		if (this.config.batchApplies && this.canBatch(writes, executing)) {
+			const batched = await this.executeRegularActionsBatched(writes, executing);
+			const error = this.accumulateResultOrReturnError(batched, generatedOperations, operationsWithContext);
+			if (error !== null) return {
+				success: false,
+				generatedOperations,
+				operationsWithContext,
+				error: error.error
+			};
+			return {
+				success: true,
+				generatedOperations,
+				operationsWithContext
+			};
+		}
 		for (const write of writes) {
 			const result = DOCUMENT_SCOPE_ACTIONS.has(write.action.type) ? await this.documentActionHandler.execute(write, executing) : await this.executeRegularAction(write, executing);
 			const error = this.accumulateResultOrReturnError(result, generatedOperations, operationsWithContext);
@@ -3382,7 +3414,15 @@ var SimpleJobExecutor = class {
 			operationsWithContext
 		};
 	}
-	async executeRegularAction(write, executing) {
+	/**
+	* Decides a write and reduces it, without persisting anything.
+	*
+	* Split from the commit so one write and a batch of them share this logic
+	* rather than keeping two copies of it. `baseDocument` lets a batch thread
+	* the previous action's result forward instead of reading its own write back
+	* out of the cache, which is the only reason the reduce has to be sequential.
+	*/
+	async prepareRegularWrite(write, executing, baseDocument) {
 		const { action, skip, sourceOperation, sourceRemote, deniedReason } = write;
 		const { job, startTime, indexTxn, stores, signal } = executing;
 		let appendCondition;
@@ -3402,7 +3442,10 @@ var SimpleJobExecutor = class {
 					verb: "execute",
 					scope: action.scope,
 					operation: action.type
-				}, signal, this.featureFlags.authConditions ? { actionInput: action.input } : void 0);
+				}, signal, this.featureFlags.authConditions ? {
+					actionInput: action.input,
+					carriedDocument: baseDocument
+				} : void 0);
 			} catch (error) {
 				return buildErrorResult(job, error instanceof Error ? error : new Error(String(error)), startTime);
 			}
@@ -3420,9 +3463,10 @@ var SimpleJobExecutor = class {
 			if (docMeta.state.isDeleted) return buildErrorResult(job, new DocumentDeletedError(job.documentId, docMeta.state.deletedAtUtcIso), startTime);
 			documentVersion = docMeta.state.version;
 		}
-		if (isUndoRedo(action) || action.type === "PRUNE" || action.type === "NOOP" && skip > 0) stores.writeCache.invalidate(job.documentId, job.scope, job.branch);
+		if (isUndoRedo(action) || action.type === "PRUNE" || skip > 0) stores.writeCache.invalidate(job.documentId, job.scope, job.branch);
 		let document;
-		try {
+		if (baseDocument !== void 0) document = baseDocument;
+		else try {
 			document = await stores.writeCache.getState(job.documentId, job.scope, job.branch, void 0, signal);
 		} catch (error) {
 			return buildErrorResult(job, error instanceof Error ? error : new Error(String(error)), startTime);
@@ -3495,13 +3539,45 @@ var SimpleJobExecutor = class {
 			...updatedDocument.state,
 			header: updatedDocument.header
 		});
+		return {
+			action,
+			sourceRemote,
+			scope,
+			document,
+			updatedDocument,
+			operation: newOperation,
+			resultingState,
+			appendCondition,
+			denied: deniedReason !== void 0
+		};
+	}
+	/**
+	* Persists a run of prepared writes in one store transaction.
+	*
+	* The store has always accepted many operations per apply; the executor only
+	* ever handed it one. Passing the whole run means one advisory lock over the
+	* read set and one guarded insert for the batch, instead of one of each per
+	* operation.
+	*
+	* The append condition is taken from the first write. Every write in a run
+	* reads the same streams at the same revisions, because nothing outside the
+	* run can change them mid-batch, and the caller has already refused to batch
+	* the scopes where that does not hold.
+	*/
+	async commitPreparedWrites(prepared, executing) {
+		const { job, startTime, indexTxn, stores, signal } = executing;
+		const first = prepared[0];
+		const last = prepared[prepared.length - 1];
+		const scope = first.scope;
+		const documentType = first.document.header.documentType;
+		const operations = prepared.map((write) => write.operation);
 		let storedOperations;
 		try {
-			storedOperations = await stores.operationStore.apply(job.documentId, document.header.documentType, scope, job.branch, newOperation.index, (txn) => {
-				txn.addOperations(newOperation);
-			}, signal, appendCondition);
+			storedOperations = await stores.operationStore.apply(job.documentId, documentType, scope, job.branch, first.operation.index, (txn) => {
+				txn.addOperations(...operations);
+			}, signal, first.appendCondition);
 		} catch (error) {
-			this.logger.error("Error writing @Operation to IOperationStore: @Error", newOperation, error);
+			this.logger.error("Error writing @Operation to IOperationStore: @Error", operations, error);
 			stores.writeCache.invalidate(job.documentId, scope, job.branch);
 			if (AppendConditionFailedError.isError(error)) for (const stream of error.condition.streams) stores.writeCache.invalidate(stream.documentId, stream.scope, stream.branch);
 			return {
@@ -3511,40 +3587,151 @@ var SimpleJobExecutor = class {
 				duration: Date.now() - startTime
 			};
 		}
-		const storedOperation = storedOperations[0];
-		updatedDocument.header.revision = {
-			...updatedDocument.header.revision,
-			[scope]: storedOperation.index + 1
+		const head = storedOperations[storedOperations.length - 1];
+		last.updatedDocument.header.revision = {
+			...last.updatedDocument.header.revision,
+			[scope]: head.index + 1
 		};
-		stores.writeCache.putState(job.documentId, scope, job.branch, storedOperation.index, updatedDocument, SnapshotPosition.Head);
-		indexTxn.write([{
-			...storedOperation,
+		stores.writeCache.putRun(job.documentId, scope, job.branch, storedOperations.map((operation, position) => ({
+			revision: operation.index,
+			document: prepared[position].updatedDocument
+		})));
+		indexTxn.write(storedOperations.map((operation, position) => ({
+			...operation,
 			documentId: job.documentId,
-			documentType: document.header.documentType,
+			documentType,
 			branch: job.branch,
 			scope,
-			sourceRemote
-		}]);
-		if (scope === "auth") indexTxn.recordGroupReferences(job.documentId, mentionedGroupIds(action));
+			sourceRemote: prepared[position].sourceRemote
+		})));
+		if (scope === "auth") for (const write of prepared) indexTxn.recordGroupReferences(job.documentId, mentionedGroupIds(write.action));
 		return {
 			job,
 			success: true,
-			operations: [storedOperation],
-			operationsWithContext: [{
-				operation: storedOperation,
+			operations: storedOperations,
+			operationsWithContext: storedOperations.map((operation, position) => ({
+				operation,
 				context: {
 					documentId: job.documentId,
 					scope,
 					branch: job.branch,
-					documentType: document.header.documentType,
-					resultingState,
+					documentType,
+					resultingState: prepared[position].resultingState,
 					ordinal: 0
 				}
-			}],
+			})),
 			duration: Date.now() - startTime
 		};
 	}
 	/**
+	* Whether a job's writes may share one store transaction.
+	*
+	* Deliberately narrow. Batching changes only how many transactions the
+	* operations arrive in, and every condition below is a case where that would
+	* change something else as well:
+	*
+	* - A document-scope action goes through its own handler, which has its own
+	*   apply and its own reasons for it.
+	* - A positional or replayed run carries skips and re-appended operations,
+	*   whose indices are not a simple ascending run from the head.
+	* - UNDO, REDO, PRUNE and NOOP-with-skip each invalidate the write cache to
+	*   force a full-history rebuild, so they cannot be reduced against state
+	*   threaded from the write before them.
+	* - The auth scope decides later writes against the policy earlier ones
+	*   install, so a batch would decide them all against the policy as it stood
+	*   before the batch.
+	* - The document scope is read by every decision model, so writing it is
+	*   writing part of the read set; the per-write conditions would not agree.
+	*
+	* A run that fails any of these is executed one write at a time, unchanged.
+	*/
+	canBatch(writes, executing) {
+		if (writes.length < 2) return false;
+		if (executing.evaluatedByPosition || executing.replayingAcceptedHistory) return false;
+		const scope = executing.job.scope;
+		if (scope === "auth" || scope === "document") return false;
+		return writes.every((write) => {
+			const type = write.action.type;
+			return write.skip === 0 && write.deniedReason === void 0 && write.sourceOperation === void 0 && !DOCUMENT_SCOPE_ACTIONS.has(type) && !isUndoRedo(write.action) && type !== "PRUNE" && type !== "NOOP";
+		});
+	}
+	/**
+	* Decides and reduces a run of writes, then persists them together.
+	*
+	* The reduce stays sequential - each action needs the state the one before it
+	* produced - but the result is threaded in memory rather than read back from
+	* the cache, and the whole run reaches the store in a single apply.
+	*
+	* A write that cannot be prepared, or that turns out to be denied, abandons
+	* the batch and the caller replays the whole job one write at a time. That is
+	* simpler than committing a partial run, and these are the paths where the
+	* per-write behaviour is load-bearing.
+	*/
+	async executeRegularActionsBatched(writes, executing) {
+		const prepared = [];
+		let carried;
+		let lastYield = performance.now();
+		for (const write of writes) {
+			const outcome = await this.prepareRegularWrite(write, executing, carried);
+			if ("success" in outcome) return prepared.length === 0 ? outcome : this.executeRegularActionsSequentially(writes, executing);
+			if (outcome.denied) return this.executeRegularActionsSequentially(writes, executing);
+			prepared.push(outcome);
+			carried = outcome.updatedDocument;
+			if (performance.now() - lastYield > this.config.yieldDeadlineMs) {
+				await yieldToMain();
+				lastYield = performance.now();
+				if (executing.signal?.aborted) return buildErrorResult(executing.job, /* @__PURE__ */ new Error("Aborted"), executing.startTime);
+			}
+		}
+		if (!this.conditionsAgree(prepared)) return this.executeRegularActionsSequentially(writes, executing);
+		return this.commitPreparedWrites(prepared, executing);
+	}
+	/** Whether every prepared write carries the same read-set condition. */
+	conditionsAgree(prepared) {
+		const shape = (write) => write.appendCondition === void 0 ? "none" : JSON.stringify([...write.appendCondition.streams].map((stream) => [
+			stream.documentId,
+			stream.scope,
+			stream.branch,
+			stream.revision
+		]).sort());
+		const first = shape(prepared[0]);
+		return prepared.every((write) => shape(write) === first);
+	}
+	/**
+	* The unbatched path, for a run that turned out not to qualify after its
+	* writes were prepared. Nothing has been persisted at that point, so
+	* replaying the whole run per write is safe.
+	*/
+	async executeRegularActionsSequentially(writes, executing) {
+		const operations = [];
+		const contexts = [];
+		let lastYield = performance.now();
+		for (const write of writes) {
+			const result = await this.executeRegularAction(write, executing);
+			if (!result.success) return result;
+			operations.push(...result.operations ?? []);
+			contexts.push(...result.operationsWithContext ?? []);
+			if (performance.now() - lastYield > this.config.yieldDeadlineMs) {
+				await yieldToMain();
+				lastYield = performance.now();
+				if (executing.signal?.aborted) return buildErrorResult(executing.job, /* @__PURE__ */ new Error("Aborted"), executing.startTime);
+			}
+		}
+		return {
+			job: executing.job,
+			success: true,
+			operations,
+			operationsWithContext: contexts,
+			duration: Date.now() - executing.startTime
+		};
+	}
+	/** Decides, reduces and persists one write. */
+	async executeRegularAction(write, executing) {
+		const prepared = await this.prepareRegularWrite(write, executing);
+		if ("success" in prepared) return prepared;
+		return this.commitPreparedWrites([prepared], executing);
+	}
+	/**
 	* Orders a write by timestamp and decides it where it lands. The caller
 	* supplies the timestamp, so a write can belong before operations already
 	* stored; those are re-appended alongside it, the way a load reshuffles.
@@ -3926,7 +4113,7 @@ var SimpleJobExecutor = class {
 			...operation,
 			id: operation.id
 		})));
-		for (const operation of reshuffledOperations) if (operation.action.type === "NOOP") operation.skip = 1;
+		for (const operation of reshuffledOperations) if (operation.action.type === "NOOP" && operation.skip === 0) operation.skip = 1;
 		let deniedReasons;
 		if (this.featureFlags.documentDecisions) try {
 			deniedReasons = await evaluateByPosition(this.decisionModel, {
@@ -4947,4 +5134,4 @@ const DEFAULT_DRIVE_CONTAINER_TYPES = new Set(["powerhouse/document-drive", "pow
 //#endregion
 export { GATED_DOCUMENT_ACTIONS as A, AuthTimestampNotMonotonicError as B, DuplicateOperationError as C, DuplicateModuleError as D, DuplicateManifestError as E, selectDecisionModel as F, InvalidOperationTimestampError as G, DocumentDeletedError as H, documentDecisionModel as I, parsePagingOptions as J, UpgradePreconditionFailedError as K, authDecisionModel as L, createEmptyConsistencyToken as M, targetDocumentId as N, InvalidModuleError as O, decideAtHead as P, buildDecisionModel as R, AppendConditionFailedError as S, RevisionMismatchError as T, DocumentNotFoundError as U, AuthorizationDeniedError as V, ExcessiveReshuffleError as W, __exportAll as X, throwIfAborted as Y, DocumentMetaCache as _, createForwardingPoolInstrumentation as a, JobExecutorEventTypes as b, KyselyKeyframeStore as c, DriveCollectionId as d, KyselyExecutionScope as f, KyselyOperationIndex as g, KyselyWriteCache as h, runMigrations as i, createConsistencyToken as j, ModuleNotFoundError as k, DocumentModelRegistry as l, EventBus as m, REACTOR_SCHEMA as n, instrumentPgPool as o, resolveFeatureFlags as p, matchesScope as q, getMigrationStatus as r, KyselyOperationStore as s, DEFAULT_DRIVE_CONTAINER_TYPES as t, SimpleJobExecutor as u, CollectionMembershipCache as v, OptimisticLockError as w, APPEND_CONDITION_FAILED_PREFIX as x, DEFAULT_DEFERRED_JOB_TTL_MS as y, AuthEnforcementDisabledError as z };
 
-//# sourceMappingURL=drive-container-types-bVQ_8YwX.js.map
+//# sourceMappingURL=drive-container-types-CruMdXue.js.map