@powerhousedao/reactor-hypercore 6.2.3-dev.5 → 6.2.3-dev.51

package/dist/index.d.ts

@@ -1,6 +1,10 @@
 import { Operation, OperationWithContext } from "@powerhousedao/shared/document-model";
+import "@powerhousedao/shared/document-model/errors";
+import "document-model";
+import "@powerhousedao/shared/document-drive";
+import "@powerhousedao/shared/processors";
 import Hyperbee from "hyperbee";
-
+import "node:worker_threads";
 //#region ../../node_modules/.pnpm/kysely@0.28.16/node_modules/kysely/dist/esm/kysely.d.ts
 declare global {
   interface AsyncDisposable {}
@@ -8,41 +12,8 @@ declare global {
     readonly asyncDispose: unique symbol;
   }
 }
-/**
- * The main Kysely class.
- *
- * You should create one instance of `Kysely` per database using the {@link Kysely}
- * constructor. Each `Kysely` instance maintains its own connection pool.
- *
- * ### Examples
- *
- * This example assumes your database has a "person" table:
- *
- * ```ts
- * import * as Sqlite from 'better-sqlite3'
- * import { type Generated, Kysely, SqliteDialect } from 'kysely'
- *
- * interface Database {
- *   person: {
- *     id: Generated<number>
- *     first_name: string
- *     last_name: string | null
- *   }
- * }
- *
- * const db = new Kysely<Database>({
- *   dialect: new SqliteDialect({
- *     database: new Sqlite(':memory:'),
- *   })
- * })
- * ```
- *
- * @typeParam DB - The database interface type. Keys of this type must be table names
- *    in the database and values must be interfaces that describe the rows in those
- *    tables. See the examples above.
- */
 //#endregion
-//#region ../reactor/dist/index.d.ts
+//#region ../reactor/dist/index-dDm0fUBT.d.ts
 /**
  * Describes the options for paging.
  */
@@ -58,11 +29,7 @@ type PagedResults<T> = {
   options: PagingOptions;
   next?: () => Promise<PagedResults<T>>;
   nextCursor?: string;
-  totalCount?: number;
 };
-/**
- * A string key in the format `documentId:scope:branch` used to identify a consistency checkpoint.
- */
 /**
  * One read-set stream and the highest operation index observed on it, or -1
  * if it was observed empty.
@@ -80,7 +47,6 @@ type AppendConditionStream = {
 type AppendCondition = {
   streams: AppendConditionStream[];
 };
-/** Error history keeps messages, not classes, so failures match by prefix. */
 /**
  * A write transaction passed to {@link IOperationStore.apply}. Accumulates
  * operations that are committed atomically when the callback returns.
@@ -94,7 +60,9 @@ interface AtomicTxn {
  * revision field and lastModified timestamp.
  */
 type DocumentRevisions = {
-  /** Map of scope to operation index for that scope */revision: Record<string, number>; /** The largest operation timestamp in the document, across every scope. */
+  /** Map of scope to operation index for that scope */
+  revision: Record<string, number>;
+  /** The largest operation timestamp in the document, across every scope. */
   latestTimestamp: string;
 };
 /**
@@ -136,6 +104,16 @@ interface IOperationStore {
    * Returns operations for a document/scope/branch whose index is greater
    * than the given revision.
    *
+   * `paging.cursor` is opaque to callers: treat it only as the value
+   * returned in `nextCursor` from a previous page, never construct or
+   * interpret it directly. An implementation must never emit a `nextCursor`
+   * equal to the start-of-stream sentinel ("0"), since a caller that walks
+   * `nextCursor` to exhaustion would read that as "start over" and loop
+   * forever. The reference encoding (used by the Kysely and Hypercore
+   * stores) is the index to resume from, i.e. the last returned row's index
+   * plus one, so a page that happens to end at index 0 still produces a
+   * cursor distinguishable from the start sentinel.
+   *
    * @param documentId - The document id
    * @param scope - The operation scope
    * @param branch - The branch name
@@ -158,6 +136,16 @@ interface IOperationStore {
   /**
    * Gets operations that may conflict with incoming operations during a load.
    *
+   * `paging.cursor` is opaque to callers: treat it only as the value
+   * returned in `nextCursor` from a previous page, never construct or
+   * interpret it directly. An implementation must never emit a `nextCursor`
+   * equal to the start-of-stream sentinel ("0"), since a caller that walks
+   * `nextCursor` to exhaustion would read that as "start over" and loop
+   * forever. The reference encoding (used by the Kysely and Hypercore
+   * stores) is the index to resume from, i.e. the last returned row's index
+   * plus one, so a page that happens to end at index 0 still produces a
+   * cursor distinguishable from the start sentinel.
+   *
    * @param documentId - The document id
    * @param scope - The scope to query
    * @param branch - The branch name
@@ -188,11 +176,14 @@ interface IOperationStore {
    * timestamp, so a later timestamp can sit behind the last row.
    */
   getStreamLatestTimestamp(documentId: string, scope: string, branch: string, signal?: AbortSignal): Promise<string | undefined>;
+  /**
+   * The subset of `opIds` stored anywhere in one stream, retracted rows
+   * included.
+   */
+  findOperationIds(documentId: string, scope: string, branch: string, opIds: string[], signal?: AbortSignal): Promise<Set<string>>;
+  /** The latest row of each of `opIds` stored in one stream. */
+  getOperationsByIds(documentId: string, scope: string, branch: string, opIds: string[], signal?: AbortSignal): Promise<Operation[]>;
 }
-/**
- * Stores periodic document snapshots (keyframes) so that document state
- * can be reconstructed without replaying the full operation history.
- */
 /**
  * Filter options for querying operations. When multiple filters are provided,
  * they are combined with AND logic.
@@ -207,12 +198,9 @@ interface OperationFilter {
   /** Filter operations with index >= this value */
   sinceRevision?: number;
 }
-/**
- * Which sense of "exists" a caller of {@link IDocumentView.exists} means.
- */
 //#endregion
 //#region src/hypercore-operation-store.d.ts
-declare class HypercoreOperationStore implements IOperationStore {
+export declare class HypercoreOperationStore implements IOperationStore {
   private bee;
   private applyLock;
   constructor(bee: Hyperbee);
@@ -220,9 +208,33 @@ declare class HypercoreOperationStore implements IOperationStore {
   /** Throws if any read-set stream has grown past its recorded revision. */
   private assertConditionHolds;
   private executeApply;
+  /** A purge marker is written to document/main whichever branch it erases. */
+  private purgeMarkerAtHead;
   private isCreate;
+  /**
+   * The paging cursor encodes the index to resume from (one past the last
+   * row returned), not the last row's own index; "" or "0" (or anything
+   * unparsable) means the start of the stream. This keeps "0" an unambiguous
+   * start-of-stream sentinel even when a page ends at index 0, which would
+   * otherwise make `nextCursor` equal the start cursor and loop a caller that
+   * walks pages forever. Mirrors the encoding in the Kysely store.
+   */
   getSince(documentId: string, scope: string, branch: string, revision: number, filter?: OperationFilter, paging?: PagingOptions, signal?: AbortSignal): Promise<PagedResults<Operation>>;
+  /**
+   * The paging cursor encodes the ordinal to resume from (one past the last
+   * ordinal returned), not the last ordinal itself; "" or "0" (or anything
+   * unparsable) means the start of the stream. Unlike the Kysely store's
+   * `getSinceId` (whose auto-increment id starts at 1), this store's ordinal
+   * counter starts at 0, so 0 is a real, valid ordinal and the same
+   * ambiguous-cursor hazard as `getSince`/`getConflicting` applies here too.
+   */
   getSinceId(id: number, paging?: PagingOptions, signal?: AbortSignal): Promise<PagedResults<OperationWithContext>>;
+  /**
+   * The paging cursor here encodes the index to resume from (one past the
+   * last row returned), not the last row's own index, for the same reason as
+   * `getSince`: a page ending at index 0 must not produce a cursor that is
+   * indistinguishable from the start-of-stream sentinel.
+   */
   getConflicting(documentId: string, scope: string, branch: string, minTimestamp: string, paging?: PagingOptions, signal?: AbortSignal): Promise<PagedResults<Operation>>;
   getRevisions(documentId: string, branch: string, signal?: AbortSignal): Promise<DocumentRevisions>;
   /**
@@ -231,6 +243,8 @@ declare class HypercoreOperationStore implements IOperationStore {
    * later one, so it would under-report and admit a backdated auth write.
    */
   getStreamLatestTimestamp(documentId: string, scope: string, branch: string, signal?: AbortSignal): Promise<string | undefined>;
+  findOperationIds(documentId: string, scope: string, branch: string, opIds: string[], signal?: AbortSignal): Promise<Set<string>>;
+  getOperationsByIds(documentId: string, scope: string, branch: string, opIds: string[], signal?: AbortSignal): Promise<Operation[]>;
   private serializeOperation;
   private toOperation;
 }
@@ -247,7 +261,7 @@ type HypercoreStoreOptions = {
 };
 //#endregion
 //#region src/hypercore-atomic-transaction.d.ts
-declare class HypercoreAtomicTransaction implements AtomicTxn {
+export declare class HypercoreAtomicTransaction implements AtomicTxn {
   private documentId;
   private documentType;
   private scope;
@@ -259,7 +273,7 @@ declare class HypercoreAtomicTransaction implements AtomicTxn {
 }
 //#endregion
 //#region src/storage-manager.d.ts
-declare class StorageManager {
+export declare class StorageManager {
   private store;
   private bee;
   constructor(storagePath: string);
@@ -269,23 +283,23 @@ declare class StorageManager {
 }
 //#endregion
 //#region src/key-encoding.d.ts
-declare const RANGE_UPPER_BOUND: string;
-declare function pad(n: number): string;
-declare function operationKey(documentId: string, scope: string, branch: string, index: number): string;
-declare function operationPrefix(documentId: string, scope: string, branch: string): string;
-declare function ordinalKey(ordinal: number): string;
-declare function ordinalPrefix(): string;
-declare function duplicateKey(opId: string, index: number, skip: number): string;
-declare function headKey(documentId: string, scope: string, branch: string): string;
-declare function headPrefix(documentId: string): string;
-declare const ORDINAL_COUNTER_KEY = "_meta/ordinal";
+export declare const RANGE_UPPER_BOUND: string;
+export declare function pad(n: number): string;
+export declare function operationKey(documentId: string, scope: string, branch: string, index: number): string;
+export declare function operationPrefix(documentId: string, scope: string, branch: string): string;
+export declare function ordinalKey(ordinal: number): string;
+export declare function ordinalPrefix(): string;
+export declare function duplicateKey(opId: string, index: number, skip: number): string;
+export declare function headKey(documentId: string, scope: string, branch: string): string;
+export declare function headPrefix(documentId: string): string;
+export declare const ORDINAL_COUNTER_KEY = "_meta/ordinal";
 type ParsedOperationKey = {
   documentId: string;
   scope: string;
   branch: string;
   index: number;
 };
-declare function parseOperationKey(key: string): ParsedOperationKey;
+export declare function parseOperationKey(key: string): ParsedOperationKey;
 type OrdinalEntry = {
   documentId: string;
   documentType: string;
@@ -299,5 +313,6 @@ type HeadEntryValue = {
   latestTimestampUtcMs: string;
 };
 //#endregion
-export { type HeadEntryValue, HypercoreAtomicTransaction, HypercoreOperationStore, type HypercoreStoreOptions, ORDINAL_COUNTER_KEY, type OrdinalEntry, type ParsedOperationKey, RANGE_UPPER_BOUND, StorageManager, type StoredOperation, duplicateKey, headKey, headPrefix, operationKey, operationPrefix, ordinalKey, ordinalPrefix, pad, parseOperationKey };
+export type { HeadEntryValue, HypercoreStoreOptions, OrdinalEntry, ParsedOperationKey, StoredOperation };
+export {};
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":["Dialect","SchemaModule","DynamicModule","QueryExecutor","QueryCreator","KyselyPlugin","DatabaseIntrospector","Driver","IsolationLevel","AccessMode","FunctionModule","LogConfig","QueryExecutorProvider","QueryResult","CompiledQuery","QueryId","Compilable","CaseBuilder","Expression","DrainOuterGeneric","ReleaseSavepoint","RollbackToSavepoint","ControlledConnection","_0","global","AsyncDisposable","SymbolConstructor","asyncDispose","sideEffect","Kysely","V","T","R","DB","KyselyConfig","KyselyProps","TransactionBuilder","ControlledTransactionBuilder","ConnectionBuilder","Record","Promise","Symbol","private","constructor","args","schema","dynamic","introspection","case","value","fn","transaction","startTransaction","connection","withPlugin","plugin","withoutPlugins","withSchema","withTables","destroy","isTransaction","getExecutor","executeQuery","query","queryId","Transaction","props","config","driver","executor","dialect","isKyselyProps","obj","plugins","log","ConnectionBuilderProps","execute","db","callback","TransactionBuilderProps","setAccessMode","accessMode","setIsolationLevel","isolationLevel","trx","ControlledTransaction","SN","S","ControlledTransactionProps","Command","isCommitted","isRolledBack","commit","rollback","savepoint","savepointName","rollbackToSavepoint","releaseSavepoint","cb","Action","AuthRequest","AuthSubject","CreateDocumentActionInput","DocumentModelModule","ISigner","Operation","OperationContext","OperationWithContext","OperationWithContext$1","PHAuthState","PHDocument","PHDocumentState","SignatureVerificationHandler","UpgradeDocumentActionInput","UpgradeManifest","UpgradeReducer","UpgradeTransition","actions","documentActions","DocumentDriveDocument","DriveInput","FolderNode","Node","ILogger","kysely","Generated","Insertable","Kysely","Transaction","IProcessor","IProcessorHostModuleBase","IProcessorHostModuleBase$1","IProcessorManager","IProcessorManager$1","IRelationalDb","ProcessorApp","ProcessorFactory","ProcessorFactory$1","ProcessorFactoryBuilder","ProcessorFilter","ProcessorRecord","ProcessorStatus","RelationalDbProcessor","TrackedProcessor","TrackedProcessor$1","createRelationalDb","Pool","AttachmentHash","AttachmentRef","createDocumentAction","input","upgradeDocumentAction","deleteDocumentAction","documentId","addRelationshipAction","Record","sourceId","targetId","relationshipType","metadata","updateRelationshipAction","removeRelationshipAction","JobKind","JobQueueState","UNKNOWN","PREPROCESSING","PENDING","READY","RUNNING","RESOLVED","RetryAccounting","CountAgainstLimit","ExemptFromLimit","IJobExecutionHandle","Job","ErrorInfo$1","job","state","start","complete","fail","error","defer","JobMeta","id","kind","scope","branch","operations","createdAt","queueHint","retryCount","maxRetries","lastError","errorHistory","meta","QueueEventTypes","JOB_AVAILABLE","JobRoutingMeta","JobAvailableEvent","jobId","name","message","stack","ShutdownStatus","Promise","isShutdown","completed","PropagationMode","None","Cascade","RelationshipChangeType","Added","Removed","BatchMeta","batchId","batchJobIds","JobInfo","JobStatus","ConsistencyToken","status","createdAtUtcIso","completedAtUtcIso","result","consistencyToken","WRITE_READY","READ_READY","FAILED","ViewFilter","scopes","revision","subject","SearchFilter","type","parentId","ids","slugs","PagingOptions","cursor","limit","PagedResults","T","results","options","next","nextCursor","totalCount","ConsistencyKey","ConsistencyCoordinate","operationIndex","version","coordinates","IReadModel","indexOperations","IReadModelCoordinator","readModels","stop","drain","getChainDepth","ReadModelRegistrationStage","ILiveReadModelCoordinator","addReadModel","readModel","stage","supportsLiveReadModelRegistration","coordinator","ChannelScheme","CONNECT","SWITCHBOARD","JwtHandler","url","PollBehavior","Auto","Manual","RemoteOptions","sinceTimestampUtcMs","pollBehavior","boundAddress","RemoteFilter","RemoteCursor","remoteName","cursorType","cursorOrdinal","lastSyncedAtUtcMs","ChannelMeta","SyncEnvelopeType","SyncEnvelope","channelMeta","key","dependsOn","SyncOperationStatus","Unknown","TransportPending","ExecutionPending","Applied","Error","ChannelErrorSource","Channel","Inbox","Outbox","SyncOperationErrorType","ChannelHealth","lastSuccessUtcMs","lastFailureUtcMs","failureCount","ConnectionState","ConnectionStateSnapshot","pushBlocked","pushFailureCount","receivingPages","requiresAuth","ConnectionStateChangedEvent","remoteId","previous","current","snapshot","RemoteStatus","push","pull","ChannelConfig","parameters","RemoteRecord","DriveCollectionId","collectionId","channelConfig","filter","SyncEventTypes","SYNC_PENDING","SYNC_SUCCEEDED","SYNC_FAILED","DEAD_LETTER_ADDED","CONNECTION_STATE_CHANGED","SyncPendingEvent","syncOperationCount","remoteNames","SyncSucceededEvent","SyncFailedEvent","Array","successCount","errors","DeadLetterAddedEvent","errorSource","errorType","SyncResultStatus","SyncResultError","SyncResult","DuplicateOperationError","constructor","description","OptimisticLockError","RevisionMismatchError","expected","actual","DocumentAlreadyExistsError","headRevision","isError","AppendConditionStream","AppendCondition","streams","APPEND_CONDITION_FAILED_PREFIX","AppendConditionFailedError","condition","isFailureMessage","AtomicTxn","addOperations","DocumentRevisions","latestTimestamp","IOperationStore","AbortSignal","OperationFilter","apply","documentType","txn","fn","signal","getSince","paging","getSinceId","getConflicting","minTimestamp","getRevisions","getStreamLatestTimestamp","IKeyframeStore","putKeyframe","document","findNearestKeyframe","targetRevision","listKeyframes","deleteKeyframes","ViewFilter$1","excludeSourceRemote","actionTypes","timestampFrom","timestampTo","sinceRevision","DocumentExistence","LiveOnly","IncludingDeleted","IDocumentView","TDocument","init","items","waitForConsistency","token","timeoutMs","exists","documentIds","existence","get","view","getMany","getByIdOrSlug","identifier","findByType","resolveSlug","slug","resolveSlugs","resolveIdOrSlug","DocumentRelationship","Date","updatedAt","DocumentGraphEdge","from","to","IDocumentGraph","nodes","edges","IDocumentIndexer","getOutgoing","types","getIncoming","hasRelationship","getUndirectedRelationships","a","b","getDirectedRelationships","findPath","findAncestors","getOrphanedChildren","parentIds","getRelationshipTypes","ISyncRemoteStorage","list","upsert","remote","remove","ISyncCursorStorage","DeadLetterRecord","jobDependencies","errorMessage","ISyncDeadLetterStorage","add","deadLetter","removeByRemote","listQuarantinedDocumentIds","OperationIndexEntry","ordinal","sourceRemote","IOperationIndexTxn","createCollection","addToCollection","removeFromCollection","recordGroupReferences","groupIds","write","getMembershipInvalidations","IOperationIndex","commit","find","getSinceOrdinal","getLatestTimestampForCollection","getCollectionsForDocuments","getGroupReferencers","groupId","driveId","forDrive","fromKey","toString","equals","other","WriteCacheConfig","maxDocuments","ringBufferSize","keyframeInterval","DocumentStreamKey","SnapshotPosition","Head","Historical","CachedSnapshot","position","KeyframeSnapshot","IWriteCache","getState","putState","putRun","run","invalidate","clear","startup","shutdown","Unsubscribe","Subscriber","data","EventBusAggregateError","ReactorEventTypes","JOB_PENDING","JOB_RUNNING","JOB_WRITE_READY","JOB_READ_READY","JOB_FAILED","READMODEL_BATCH_COMPLETED","READMODEL_INDEXED","MODEL_LOADED","ReadModelStage","ReadModelIndexingStage","ModelLoadedEvent","JobPendingEvent","jobMeta","JobRunningEvent","JobWriteReadyEvent","collectionMemberships","JobReadReadyEvent","JobFailedEvent$1","ReadModelBatchCompletedEvent","batchSize","chainWaitDurationMs","preReadyDurationMs","emitDurationMs","postReadyDurationMs","ReadModelIndexedEvent","readModelName","durationMs","operationCount","success","IEventBus","K","subscribe","event","subscriber","emit","IJobAwaiter","waitForJob","JobAwaiter","eventBus","getJobStatus","pendingJobs","unsubscribers","subscribeToEvents","handleWriteReady","handleReadReady","handleJobFailed","checkAndResolveWaiters","ISubscriptionErrorHandler","SubscriptionErrorContext","handleError","context","eventType","subscriptionId","eventData","IReactorSubscriptionManager","onDocumentCreated","callback","search","onDocumentDeleted","onDocumentStateUpdated","onRelationshipChanged","childId","changeType","StreamQuery","IStreamStateReader","DecisionTarget","DecisionContext","scopeState","actionInput","StreamHistory","Projection","M","Partial","query","model","queryOverHistory","reads","decidingActions","operation","Evaluation","decision","reason","DecisionModel","projections","foldEvaluatedScope","evaluatesScope","decide","request","ctx","BuiltDecisionModel","appendCondition","DocumentChangeType","Created","Deleted","Updated","ParentAdded","ParentRemoved","ChildAdded","ChildRemoved","DocumentChangeEvent","documents","CreateDocumentOptions","parentIdentifier","documentModelVersion","UpgradeDocumentOptions","maxConflictRetries","IDriveClient","create","addFile","driveIdentifier","parentFolder","addFolder","removeNode","nodeId","renameNode","setPreferredEditorOnNode","preferredEditor","moveNode","srcNodeId","targetParentFolderId","copyNode","getNode","listNodes","ActionCandidate","ActionEvaluations","evaluations","allAllowed","anyAllowed","allDenied","anyDenied","IReactorClient","BatchExecutionRequest","BatchExecutionResult","BatchLoadRequest","BatchLoadResult","drives","getDocumentModelModules","namespace","getDocumentModelModule","isDocumentIdTaken","getOperations","documentIdentifier","getOutgoingRelationships","sourceIdentifier","getIncomingRelationships","targetIdentifier","evaluateActions","candidates","createEmpty","documentModelType","getDocumentModelModuleForDocument","upgradeDocument","toVersion","createDocumentInDrive","execute","executeAsync","executeBatch","rename","setPreferredEditor","addRelationship","removeRelationship","moveRelationship","sourceParentIdentifier","targetParentIdentifier","source","target","deleteDocument","propagate","deleteDocuments","identifiers","loadBatch","ICollectionMembershipCache","CachedDocumentMeta","documentScopeRevision","IDocumentMetaCache","getDocumentMeta","rebuildAtRevision","putDocumentMeta","OperationTable","opId","prevOpId","writeTimestampUtcMs","timestampUtcMs","index","action","skip","deniedReason","hash","KeyframeTable","DocumentCollectionTable","joinedOrdinal","leftOrdinal","OperationIndexOperationTable","SyncRemoteTable","collection_id","channel_type","channel_id","remote_name","channel_parameters","filter_document_ids","filter_scopes","filter_branch","push_state","push_last_success_utc_ms","push_last_failure_utc_ms","push_failure_count","pull_state","pull_last_success_utc_ms","pull_last_failure_utc_ms","pull_failure_count","bound_address","created_at","updated_at","SyncCursorTable","cursor_type","cursor_ordinal","last_synced_at_utc_ms","SyncDeadLetterTable","job_id","job_dependencies","document_id","error_source","error_message","error_type","GroupReferenceTable","Database$1","Keyframe","document_collections","operation_index_operations","group_references","sync_remotes","sync_cursors","sync_dead_letters","DocumentTable","DocumentRelationshipTable","IndexerStateTable","lastOperationId","lastOperationTimestamp","DocumentIndexerDatabase","Document","IndexerState","SanitizedArg","ErrorInfo","cause","ModuleRef","packageName","exportName","filePath","FactorySpec","module","initArgs","SignatureVerifierSpec","DocumentModelSpec","ModelManifestEntry","spec","DbConfig","host","port","database","user","password","ssl","applicationName","poolSize","connectionTimeoutMillis","idleTimeoutMillis","WorkerPoolConfig","enabled","numWorkers","workerType","heartbeatMs","workerPgPoolSize","JobWriteReadyPayload","InitMessage","JobExecutorConfig","correlationId","workerId","poolConfig","db","signatureVerifier","models","executorConfig","ExecuteMessage","AbortMessage","targetCorrelationId","ShutdownMessage","graceMs","LoadModelMessage","ParentMessage","ReadyMessage","ResultMessage","JobResult","writeReady","ModelLoadedMessage","ModelLoadFailedMessage","LogMessage","level","args","timestamp","HeartbeatMessage","inFlightCorrelationIds","MetricsMessage","counters","gauges","PoolAcquireSamplesMessage","poolName","durations","size","idle","waiting","WorkerMessage","FileModelSource","PackageModelSource","subpath","DocumentModelSource","RegistrationResult","item","IDocumentModelLoader","load","IDocumentModelRegistry","registerModules","modules","unregisterModules","documentTypes","getModule","getAllModules","getSupportedVersions","getLatestVersion","registerUpgradeManifests","manifests","unregisterUpgradeManifests","getUpgradeManifest","computeUpgradePath","fromVersion","getUpgradeReducer","RingBuffer","buffer","head","capacity","getAll","length","DocumentStream","ringBuffer","KyselyWriteCache","lruTracker","keyframeStore","operationStore","registry","config","withScopedStores","store","persistKeyframe","getStream","coldMissRebuild","applyPendingUpgrades","applyTailPendingUpgrades","applyPendingUpgrade","stampRevisions","operationAt","resolveModuleVersionForOp","warmMissRebuild","findNearestOlderSnapshot","makeStreamKey","getOrCreateStream","isKeyframeRevision","KyselyOperationStore","trx","queryExecutor","withTransaction","resolveUniqueConstraint","executeApply","acquireStreamLocks","insertGuarded","findIdempotentReplay","isCreate","rowToOperation","rowToOperationWithContext","KyselyKeyframeStore","ExecutionStores","writeCache","documentMetaCache","collectionMembershipCache","IExecutionScope","stores","operationsWithContext","completedAt","duration","ReactorFeatureFlags","documentDecisions","authEnforcement","authGroups","authConditions","featureFlags","maxSkipThreshold","maxConcurrency","jobTimeoutMs","deferredJobTtlMs","retryBaseDelayMs","retryMaxDelayMs","yieldDeadlineMs","batchApplies","JobExecutorEventTypes","JOB_STARTED","JOB_COMPLETED","EXECUTOR_STARTED","EXECUTOR_STOPPED","JobStartedEvent","startedAt","JobCompletedEvent","JobFailedEvent","willRetry","ExecutorStartedEvent","ExecutorStoppedEvent","stoppedAt","graceful","ExecutorManagerStatus","isRunning","numExecutors","activeJobs","totalJobsProcessed","DocumentDecisionModel","documentDecisionModel","RegisteredDecisionModel","AdmissionDecision","evaluation","documentVersion","deletedAtUtcIso","AdmissionConditions","carriedDocument","decideAtHead","cache","conditions","selectDecisionModel","flags","ALWAYS_READABLE_SCOPES","ReadonlySet","ReadGateOptions","withholdUninitialized","IReadGate","scopePredicate","readDecisionModel","BareReadGate","SeededStateReader","documentView","seed","assertAbsent","ModelReadGate","servesGroups","logger","servesGroupTo","servesThrough","servesGroup","ownPolicyPredicate","ActionEvaluationConfig","ReactorClient","IReactor","reactor","signer","subscriptionManager","jobAwaiter","documentIndexer","readGate","actionEvaluation","readSubject","readableScopes","gateDocument","getOperationsWithCompositeCursor","buildEvaluationTarget","removeAllIncomingRelationships","WorkerInFlightSnapshot","WorkerExecutionOutcome","IExecutorWorker","abort","loadModel","entry","isIdle","getInFlight","IJobExecutor","executeJob","IJobExecutorManager","getExecutors","getStatus","IJobTracker","registerJob","jobInfo","markRunning","markFailed","IQueue","enqueue","dequeue","dequeueNext","dequeueNextMatching","predicate","totalSize","clearAll","hasJobs","completeJob","failJob","retryJob","accounting","isDrained","block","onDrained","unblock","GroupReevaluationTrigger","queue","unsubscribe","onWriteReady","ViewStateTable","readModelId","lastOrdinal","DocumentSnapshotTable","content","lastOperationIndex","lastOperationHash","lastUpdatedAt","snapshotVersion","isDeleted","deletedAt","SlugMappingTable","ProcessorCursorTable","processorId","factoryId","processorIndex","lastErrorTimestamp","DocumentViewDatabase","ViewState","DocumentSnapshot","SlugMapping","ProcessorCursor","InsertableDocumentSnapshot","IConsistencyTracker","update","getLatest","waitFor","serialize","hydrate","entries","makeConsistencyKey","ConsistencyTracker","waiters","deduplicateCoordinates","areCoordinatesSatisfied","checkWaiters","removeWaiter","PoolStats","PoolInstrumentation","getStats","onAcquire","listener","instrumentPgPool","pool","ForwardingPoolInstrumentation","pushSamples","updateStats","stats","GraphQLRequestErrorCategory","GraphQLRequestError","statusCode","category","codes","RECOVERABLE_GRAPHQL_ERROR_CODES","malformedStoredOperation","isRecoverableGraphQLError","DRIVE_AUTH_ERROR_MESSAGES","forbidden","authenticationRequired","DriveRequestError","isDriveAuthError","PollingChannelError","ChannelError","SyncOperationStatusCallback","SyncOperation","syncOp","prev","SyncOperationAggregateError","deliveredCount","emittedCount","callbacks","on","started","transported","executed","failed","transition","MailboxCallback","IMailbox","ReadonlyArray","ackOrdinal","latestOrdinal","advanceOrdinal","onAdded","onRemoved","pause","resume","flush","isPaused","Mailbox","itemsMap","addedCallbacks","removedCallbacks","paused","addedBuffer","removedBuffer","_ack","_latestOrdinal","SyncStatus","Synced","Outgoing","Incoming","OutgoingAndIncoming","SyncStatusChangeCallback","ISyncStatusTracker","IChannel","onChange","trackRemote","channel","untrackRemote","SyncStatusTracker","remotes","seen","handleAdded","handleRemoved","getOrCreateCounts","notifyChange","ConnectionStateChangeCallback","inbox","outbox","getConnectionState","onConnectionStateChange","triggerPull","notePoll","lastHolderPollUtcMs","IChannelFactory","instance","cursorStorage","RemoteMeta","Remote","ISyncManager","getByName","getById","bindRemote","waitForSync","getSyncStatus","onSyncStatusChange","ExecutionJobPlan","jobs","LoadJobPlan","externalDeps","kill","getDocumentModels","getBySlug","docId","ReactorFeatures","Database","SyncModule","syncManager","InProcessSyncModule","remoteStorage","deadLetterStorage","channelFactory","ReactorModule","documentModelRegistry","syncModule","DegradedComponent","component","InProcessReactorModule","jobTracker","executorManager","documentViewConsistencyTracker","documentIndexerConsistencyTracker","readModelCoordinator","processorManager","processorManagerConsistencyTracker","groupReevaluationTrigger","pools","degradedComponents","ReactorClientModule","client","reactorModule","InProcessReactorClientModule","DriveClient","runJobs","toError","documentExists","removeFileNode","IDocumentModelResolver","ensureModelLoaded","ModelLoadedBroadcastHook","DocumentModelResolver","loader","loadingModels","failedModelTypes","broadcastHook","modelLoadedHook","setBroadcastHook","hook","setModelLoadedHook","loadRegisterAndBroadcast","notifyPeersModelLoaded","NullDocumentModelResolver","WorkerFactory","BuiltInReadModelKind","ChainDepthReport","shardId","depth","ProjectionInitMessage","shardIndex","shardCount","preReadyKinds","postReadyKinds","chainDepthReportIntervalMs","ProjectionWriteReadyMessage","ProjectionDrainMessage","ProjectionShutdownMessage","ProjectionParentMessage","ProjectionReadyMessage","ProjectionInitFailedMessage","ProjectionReadReadyMessage","ProjectionReadModelIndexedMessage","ProjectionBatchCompletedMessage","ProjectionChainDepthMessage","ProjectionPoolAcquireSamplesMessage","ProjectionDrainedMessage","ProjectionLogMessage","ProjectionWorkerMessage","HybridProjectionOptions","onFatal","initTimeoutMs","shutdownGraceMs","drainTimeoutMs","createHybridProjectionCoordinatorFactory","ReadModelCoordinatorFactory","ProjectionTransportEventMap","exit","ProjectionTransportEvent","ProjectionTransportListener","E","payload","IProjectionTransport","postMessage","off","terminate","ProjectionWorkerFactory","ProjectionShardHooks","onReadReady","onShardFatal","ProjectionShardManagerConfig","factory","hostBus","poolInstrumentations","consistencyTrackers","ProjectionShardManager","shards","initPromises","pendingDrains","trackersByReadModelName","hostSubscription","isShuttingDown","emitReadReady","getShardDepths","routeWriteReady","dropWriteReady","handleWorkerMessage","advanceConsistencyTrackers","handlePoolAcquireSamples","failPendingInit","handleReady","handleDrained","releaseDrain","handleLog","handleTransportError","handleTransportExit","relayReadReady","relayReadModelIndexed","relayBatchCompleted","HybridProjectionCoordinatorOptions","manager","preReady","postReady","lookupOnly","HybridProjectionCoordinator","chains","acceptReadReady","runHostChain","indexWithTiming","emitBatchCompleted","emitReadModelIndexed","queueKeyFor","SignerConfig","verifier","MigrationStrategy","MigrationResult","migrationsExecuted","SyncBuilder","withChannelFactory","withRemoteStorage","storage","withCursorStorage","withDeadLetterStorage","withMaxDeadLettersPerRemote","withMaxInboxBatchSize","withMaxHeldOperationsPerRemote","withStaleRemotePollWindowMs","windowMs","build","driveContainerTypes","buildModule","ReadModelFactoryDeps","ReadModelFactory","deps","ReadModelCoordinatorFactoryDeps","ProjectionShardBuilderConfig","subscriptionNotificationReadModel","createProjectionShardManager","registerShutdownHook","WorkerPoolBase","WorkerPoolOptions","ReactorBuilder","documentModelSources","upgradeManifests","features","readModelFactories","writeCacheConfig","migrationStrategy","syncBuilder","readModelCoordinatorFactory","kyselyInstance","signalHandlersEnabled","queueInstance","channelScheme","jwtHandler","documentModelLoader","shutdownHooks","workerPool","resolvedModelManifest","moduleOnlyModelKeys","projectionShardConfig","projectionWorkerFactory","instrumentedPools","withLogger","withDocumentModelSources","sources","withUpgradeManifests","withFeatures","withReadModel","withReadModelFactory","withReadModelCoordinator","withReadModelCoordinatorFactory","withExecutor","executor","withExecutorConfig","withWriteCacheConfig","withDriveContainerTypes","withMigrationStrategy","strategy","withSync","withEventBus","withSignatureVerifier","withKysely","withInstrumentedPool","instrumentation","withQueue","withChannelScheme","scheme","withJwtHandler","handler","withDocumentModelLoader","withSignalHandlers","withShutdownHook","withWorkerPool","withProjectionShards","withProjectionWorkerFactory","getResolvedModelManifest","resolveReactorDbConfig","createDefaultProjectionWorkerFactory","createDefaultWorkerFactory","createPostgresDatabase","attachSignalHandlers","ReactorClientBuilder","reactorBuilder","withReactorBuilder","withReactor","withSigner","withSubscriptionManager","withJobAwaiter","withReadGate","resolveReadGate","resolveActionEvaluation","DEFAULT_DRIVE_CONTAINER_TYPES","Reactor","shutdownStatus","setShutdown","setCompleted","findByIds","findBySlugs","findByParentId","emitJobPending","ParsedDriveUrl","graphqlEndpoint","parseDriveUrl","driveIdFromUrl","AuthEnforcementDisabledError","createMutableShutdownStatus","initialState","value","ParsedPaging","offset","parsePagingOptions","defaultLimit","DefaultSubscriptionErrorHandler","DocumentCreatedCallback","DocumentDeletedCallback","DocumentStateUpdatedCallback","RelationshipChangedCallback","ReactorSubscriptionManager","Map","createdSubscriptions","deletedSubscriptions","updatedSubscriptions","relationshipSubscriptions","subscriptionCounter","errorHandler","notifyDocumentsCreated","notifyDocumentsDeleted","notifyDocumentsUpdated","notifyRelationshipChanged","childType","filterDocumentIds","filterDocuments","matchesRelationshipFilter","EventBus","eventTypeToSubscribers","InMemoryQueue","Set","resolver","queues","jobIdToQueueKey","docIdToJobId","jobIdToDocId","completedJobs","jobIndex","isBlocked","onDrainedCallback","isPausedFlag","toErrorInfo","createQueueKey","getQueue","isDocumentExecuting","markJobExecuting","markJobComplete","areDependenciesMet","getNextJobWithMetDependencies","getCreateDocumentType","deferJob","checkDrained","getPendingJobs","getExecutingJobIds","getJob","InMemoryJobTracker","JobExecutorFactory","SimpleJobExecutorManager","executorFactory","executors","deferredJobs","resultHandler","processNextJob","checkForMoreJobs","processExistingJobs","SimpleJobExecutor","decisionModel","signatureVerifierModule","documentActionHandler","executionScope","executeInScope","evictTouchedStreams","getCollectionMembershipsForOperations","processActions","prepareRegularWrite","commitPreparedWrites","canBatch","executeRegularActionsBatched","conditionsAgree","executeRegularActionsSequentially","executeRegularAction","positionByTimestamp","evaluatePositioned","evaluationOrder","firstNonMonotonicTimestamp","appendedOperations","reevaluateIfCriteriaMet","reevaluateDocument","executeReevaluationJob","executeLoadJob","accumulateResultOrReturnError","createForwardingLogger","msg","post","tags","errorToInfo","err","sanitizeArg","WeakSet","workerEntryPath","ModuleNotFoundError","requestedVersion","DuplicateModuleError","InvalidModuleError","DuplicateManifestError","DocumentModelRegistry","manifestsToRegister","buildDecisionModel","reader","definition","AuthDecisionModel","auth","authDecisionModel","SyncScopeGate","gate","scopePredicateById","OutOfOrderPair","firstOutOfOrderPair","requireStrict","BaseReadModelConfig","rebuildStateOnInit","BaseReadModel","consistencyTracker","commitOperations","rebuildStateForOperations","loadState","initializeState","saveState","updateConsistencyTracker","IndexerDatabase","KyselyDocumentIndexer","_db","handleAddRelationship","handleRemoveRelationship","handleUpdateRelationship","ReadModelCoordinator","emitEmptyReadReady","runChain","Database$2","KyselyDocumentView","servesDeletionBoundary","idsWithStreams","liveIds","DOCUMENT_VIEW_READ_MODEL","DOCUMENT_INDEXER_READ_MODEL","ReactorReadModels","REACTOR_SCHEMA","runMigrations","schema","upTo","getMigrationStatus","MigrationInfo","KyselySyncCursorStorage","KyselySyncRemoteStorage","GqlRequestChannelFactory","GqlResponseChannelFactory","IPollTimer","setDelegate","delegate","triggerNow","GqlChannelConfig","fetch","fetchFn","GqlRequestChannel","bufferedOutbox","channelId","pollTimer","abortController","lastPersistedInboxOrdinal","lastPersistedOutboxOrdinal","pushRetryTimer","isPushing","pendingDrain","peerServesDecisionFields","isRecovering","connectionState","connectionStateCallbacks","transitionConnectionState","poll","handleRemoteDeadLetters","handlePollError","recoverFromChannelNotFound","resumePushAfterRecovery","pollSyncEnvelopes","rejectsDecisionFields","pollQuery","touchRemoteChannel","attemptPush","schedulePushRetry","drainOutbox","classifyError","pushSyncOperations","getAuthorizationHeader","executeGraphQL","poller","GqlResponseChannel","evictedOutboxFloor","appliedOutboxOrdinal","lastPollUtcMs","rememberUnserved","persistOutboxCursor","forgetEvictedBelow","unservedFloor","PollTimerConfig","intervalMs","maxQueueDepth","backpressureCheckIntervalMs","startPaused","IntervalPollTimer","timer","running","consecutiveFailures","tick","scheduleNext","scheduleRetry","scheduleBackpressureRecheck","getIntervalMs","setIntervalMs","ms","envelopesToSyncOperations","envelope","OperationBatch","trimMailboxFromAckOrdinal","mailbox","batchOperationsByDocument","consolidateSyncOperations","syncOps","classifyJobFailure","errorName","syncOperationErrorType","quarantinesDocument","IReactorProcessorHostModuleBase","getReadModel","ReactorHostModuleBaseOptions","Pick","createReactorHostModuleBase","KeyframeValidationIssue","keyframeHash","replayedHash","SnapshotValidationIssue","snapshotHash","StreamOrderIssue","ValidationResult","isConsistent","keyframeIssues","snapshotIssues","streamOrderIssues","RebuildResult","keyframesDeleted","scopesInvalidated","IDocumentIntegrityService","validateDocument","rebuildKeyframes","rebuildSnapshots","DocumentIntegrityService","findStreamOrderIssues","discoverScopes","ProcessorManagerOptions","legacyProcessorIds","ProcessorManager","factoryRegistry","processorsByDrive","factoryToProcessors","knownDrives","cursorCache","registerFactory","unregisterFactory","allTrackedProcessors","detectAndRegisterNewDrives","isDriveCreation","detectAndCleanupDeletedDrives","discoverExistingDrives","isDeletedDocumentADrive","createProcessorsForDrive","backfillProcessor","retryProcessor","cleanupDriveProcessors","safeDisconnect","routeOperationsToProcessors","loadAllCursors","safeSaveProcessorCursor","saveProcessorCursor","deleteProcessorCursors","InMemoryJobExecutor","ReactorJobFailedEvent","StorageDatabase","WorkerErrorInfo"],"sources":["../../../node_modules/.pnpm/kysely@0.28.16/node_modules/kysely/dist/esm/kysely.d.ts","../../reactor/dist/index.d.ts","../src/hypercore-operation-store.ts","../src/types.ts","../src/hypercore-atomic-transaction.ts","../src/storage-manager.ts","../src/key-encoding.ts"],"x_google_ignoreList":[0],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../node_modules/.pnpm/kysely@0.28.16/node_modules/kysely/dist/esm/kysely.d.ts","../../reactor/dist/index-dDm0fUBT.d.ts","../src/hypercore-operation-store.ts","../src/types.ts","../src/hypercore-atomic-transaction.ts","../src/storage-manager.ts","../src/key-encoding.ts"],"x_google_ignoreList":[0],"mappings":";;;;;;;;QAoBQ;YACM;YAEA;aACG;;;;;;;;KC0NZ;EACH;EACA;;;;;KAKG,aAAa;EAChB,SAAS;EACT,SAAS;EACT,aAAa,QAAQ,aAAa;EAClC;;;;;;KAkhBG;EACH;EACA;EACA;EACA;;;;;;KAMG;EACH,SAAS;;;;;;UAmBD;;EAER,iBAAiB,YAAY;;;;;;KAM1B;;EAEH,UAAU;;EAEV;;;;;;UAMQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8BR,MAAM,oBAAoB,sBAAsB,eAAe,gBAAgB,kBAAkB,KAAK,KAAK,qBAAqB,eAAe,SAAS,aAAa,YAAY,kBAAkB,QAAQ;;;;;;;;;;;;;;;;;;;;;;;EAuB3M,SAAS,oBAAoB,eAAe,gBAAgB,kBAAkB,SAAS,iBAAiB,SAAS,eAAe,SAAS,cAAc,QAAQ,aAAa;;;;;;;;;;EAU5K,WAAW,YAAY,SAAS,eAAe,SAAS,cAAc,QAAQ,aAAa;;;;;;;;;;;;;;;;;;;;;;EAsB3F,eAAe,oBAAoB,eAAe,gBAAgB,sBAAsB,SAAS,eAAe,SAAS,cAAc,QAAQ,aAAa;;;;;;;;;;;EAW5J,aAAa,oBAAoB,gBAAgB,SAAS,cAAc,QAAQ;;;;;;;;;;EAUhF,yBAAyB,oBAAoB,eAAe,gBAAgB,SAAS,cAAc;;;;;EAKnG,iBAAiB,oBAAoB,eAAe,gBAAgB,iBAAiB,SAAS,cAAc,QAAQ;;EAEpH,mBAAmB,oBAAoB,eAAe,gBAAgB,iBAAiB,SAAS,cAAc,QAAQ;;;;;;UA2E9G;;EAER;;EAEA;;EAEA;;EAEA;;;;qBC79BW,mCAAmC;UAG1B;UAFZ;EAER,YAAoB,KAAK;EAEnB,MACJ,oBACA,sBACA,eACA,gBACA,kBACA,KAAK,KAAK,qBAAqB,eAC/B,SAAS,aACT,YAAY,kBACX,QAAQ;;UA8BG;UAoBA;;UAuGA;UAkBN;;;;;;;;;EAYF,SACJ,oBACA,eACA,gBACA,kBACA,SAAS,iBACT,SAAS,eACT,SAAS,cACR,QAAQ,aAAa;;;;;;;;;EAiGlB,WACJ,YACA,SAAS,eACT,SAAS,cACR,QAAQ,aAAa;;;;;;;EA2ElB,eACJ,oBACA,eACA,gBACA,sBACA,SAAS,eACT,SAAS,cACR,QAAQ,aAAa;EAwElB,aACJ,oBACA,gBACA,SAAS,cACR,QAAQ;;;;;;EAuCL,yBACJ,oBACA,eACA,gBACA,SAAS,cACR;EAyBG,iBACJ,oBACA,eACA,gBACA,iBACA,SAAS,cACR,QAAQ;EA6BL,mBACJ,oBACA,eACA,gBACA,iBACA,SAAS,cACR,QAAQ;UA2BH;UAiBA;;;;KC9oBE,kBAAkB;EAC5B;EACA;EACA;EACA;;KAGU;EACV;;;;qBCNW,sCAAsC;UAIvC;UACA;UACA;UACA;UANF;EAER,YACU,oBACA,sBACA,eACA;EAGV,iBAAiB,YAAY;EAY7B,iBAAiB;;;;qBCvBN;UACH;UACA;EAER,YAAY;EAIN,QAAQ;EAUR,SAAS;EAOf,UAAU;;;;qBCxBC;wBAEG,IAAI;wBAIJ,aACd,oBACA,eACA,gBACA;wBAKc,gBACd,oBACA,eACA;wBAKc,WAAW;wBAIX;wBAIA,aACd,cACA,eACA;wBAKc,QACd,oBACA,eACA;wBAKc,WAAW;qBAId;KAED;EACV;EACA;EACA;EACA;;wBAGc,kBAAkB,cAAc;KAUpC;EACV;EACA;EACA;EACA;EACA;EACA,WAAW;;KAGD;EACV;EACA"}

package/dist/index.js

@@ -1,7 +1,41 @@
-import "@powerhousedao/shared/document-model";
+import { DOCUMENT_SCOPE_ACTION_TYPES, isPurgeMarker } from "@powerhousedao/shared/document-model";
 import Corestore from "corestore";
 import Hyperbee from "hyperbee";
-//#region ../reactor/dist/drive-container-types-yZrksiJR.js
+//#region ../reactor/dist/forwarding-logger-B9LLXItm.js
+/**
+* Error thrown when a document is not found (no operations exist for the document ID).
+*/
+var DocumentNotFoundError = class DocumentNotFoundError extends Error {
+	documentId;
+	/**
+	* @param message Overrides the default text. A handler that knows which of
+	* several documents an action reads - a relationship's source, say - says so
+	* here rather than rewrapping in a bare Error, which would strip the name the
+	* executor classifies by.
+	*/
+	constructor(documentId, message) {
+		super(message ?? `Document ${documentId} not found`);
+		this.name = "DocumentNotFoundError";
+		this.documentId = documentId;
+		Error.captureStackTrace(this, DocumentNotFoundError);
+	}
+	/** Also true for DocumentPurgedError: only the name crosses the queue. */
+	static isError(error) {
+		return Error.isError(error) && (error.name === "DocumentNotFoundError" || error.name === "DocumentPurgedError");
+	}
+};
+/** The document was purged; readers treat it as absent. Terminal. */
+var DocumentPurgedError = class DocumentPurgedError extends DocumentNotFoundError {
+	purged = true;
+	constructor(documentId, message) {
+		super(documentId, message ?? `Document ${documentId} was purged`);
+		this.name = "DocumentPurgedError";
+		Error.captureStackTrace(this, DocumentPurgedError);
+	}
+	static isError(error) {
+		return Error.isError(error) && error.name === "DocumentPurgedError";
+	}
+};
 /**
 * Thrown when an operation with the same identity already exists in the store.
 */
@@ -43,6 +77,7 @@ const APPEND_CONDITION_FAILED_PREFIX = "Append condition failed: ";
 * conflict, not a fault: the caller retries against the new stream heads.
 */
 var AppendConditionFailedError = class extends Error {
+	condition;
 	constructor(condition) {
 		const streams = condition.streams.map((s) => `${s.documentId}:${s.scope}:${s.branch}@${s.revision}`).join(", ");
 		super(`${APPEND_CONDITION_FAILED_PREFIX}a read-set stream advanced [${streams}]`);
@@ -57,19 +92,14 @@ var AppendConditionFailedError = class extends Error {
 		return message.startsWith(APPEND_CONDITION_FAILED_PREFIX);
 	}
 };
-/** Actions the reactor reduces itself, onto the document scope. */
-const DOCUMENT_SCOPE_ACTIONS = new Set([
-	"CREATE_DOCUMENT",
-	"DELETE_DOCUMENT",
-	"UPGRADE_DOCUMENT",
-	"ADD_RELATIONSHIP",
-	"REMOVE_RELATIONSHIP",
-	"UPDATE_RELATIONSHIP"
-]);
-new Set([...DOCUMENT_SCOPE_ACTIONS].filter((type) => type !== "CREATE_DOCUMENT"));
+new Set([...DOCUMENT_SCOPE_ACTION_TYPES].filter((type) => type !== "CREATE_DOCUMENT"));
 //#endregion
 //#region src/hypercore-atomic-transaction.ts
 var HypercoreAtomicTransaction = class {
+	documentId;
+	documentType;
+	scope;
+	branch;
 	operations = [];
 	constructor(documentId, documentType, scope, branch) {
 		this.documentId = documentId;
@@ -131,6 +161,7 @@ function parseOperationKey(key) {
 //#endregion
 //#region src/hypercore-operation-store.ts
 var HypercoreOperationStore = class {
+	bee;
 	applyLock = Promise.resolve();
 	constructor(bee) {
 		this.bee = bee;
@@ -165,6 +196,11 @@ var HypercoreOperationStore = class {
 		const atomicTxn = new HypercoreAtomicTransaction(documentId, documentType, scope, branch);
 		await fn(atomicTxn);
 		const operations = atomicTxn.getOperations();
+		const marker = await this.purgeMarkerAtHead(documentId);
+		if (marker !== void 0 && operations.length > 0) {
+			if (!operations.every((op) => isPurgeMarker(op))) throw new DocumentPurgedError(documentId);
+			return [marker];
+		}
 		if (currentRevision !== revision - 1) {
 			if (revision === 0 && this.isCreate(operations)) throw new DocumentAlreadyExistsError(documentId, scope, currentRevision);
 			throw new RevisionMismatchError(currentRevision + 1, revision);
@@ -203,15 +239,32 @@ var HypercoreOperationStore = class {
 		await batch.flush();
 		return operations.map((op) => this.toOperation(op));
 	}
+	/** A purge marker is written to document/main whichever branch it erases. */
+	async purgeMarkerAtHead(documentId) {
+		const branch = "main";
+		const head = await this.bee.get(headKey(documentId, "document", branch));
+		if (!head) return;
+		const index = head.value.index;
+		const stored = (await this.bee.get(operationKey(documentId, "document", branch, index)))?.value;
+		return stored && isPurgeMarker(stored) ? this.toOperation(stored) : void 0;
+	}
 	isCreate(operations) {
 		return operations.some((op) => op.action.type === "CREATE_DOCUMENT");
 	}
+	/**
+	* The paging cursor encodes the index to resume from (one past the last
+	* row returned), not the last row's own index; "" or "0" (or anything
+	* unparsable) means the start of the stream. This keeps "0" an unambiguous
+	* start-of-stream sentinel even when a page ends at index 0, which would
+	* otherwise make `nextCursor` equal the start cursor and loop a caller that
+	* walks pages forever. Mirrors the encoding in the Kysely store.
+	*/
 	async getSince(documentId, scope, branch, revision, filter, paging, signal) {
 		if (signal?.aborted) throw new Error("Operation aborted");
 		const prefix = operationPrefix(documentId, scope, branch);
 		const startIndex = revision + 1;
-		const cursorIndex = paging?.cursor && parseInt(paging.cursor, 10) > 0 ? parseInt(paging.cursor, 10) + 1 : startIndex;
-		const gt = prefix + pad(Math.max(startIndex, cursorIndex) - 1);
+		const parsedCursor = paging?.cursor ? Number.parseInt(paging.cursor, 10) : NaN;
+		const gt = prefix + pad(Math.max(startIndex, Number.isFinite(parsedCursor) && parsedCursor > 0 ? parsedCursor : startIndex) - 1);
 		const lt = prefix + RANGE_UPPER_BOUND;
 		const limit = paging?.limit ? paging.limit + 1 : void 0;
 		const items = [];
@@ -236,7 +289,7 @@ var HypercoreOperationStore = class {
 			hasMore = true;
 			resultItems = items.slice(0, paging.limit);
 		}
-		const nextCursor = hasMore && resultItems.length > 0 ? resultItems[resultItems.length - 1].index.toString() : void 0;
+		const nextCursor = hasMore && resultItems.length > 0 ? (resultItems[resultItems.length - 1].index + 1).toString() : void 0;
 		const cursor = paging?.cursor || "0";
 		const resultLimit = paging?.limit || 100;
 		return {
@@ -252,11 +305,20 @@ var HypercoreOperationStore = class {
 			}, signal) : void 0
 		};
 	}
+	/**
+	* The paging cursor encodes the ordinal to resume from (one past the last
+	* ordinal returned), not the last ordinal itself; "" or "0" (or anything
+	* unparsable) means the start of the stream. Unlike the Kysely store's
+	* `getSinceId` (whose auto-increment id starts at 1), this store's ordinal
+	* counter starts at 0, so 0 is a real, valid ordinal and the same
+	* ambiguous-cursor hazard as `getSince`/`getConflicting` applies here too.
+	*/
 	async getSinceId(id, paging, signal) {
 		if (signal?.aborted) throw new Error("Operation aborted");
-		const cursorValue = paging?.cursor && parseInt(paging.cursor, 10) > 0 ? parseInt(paging.cursor, 10) : id;
-		const effectiveId = Math.max(id, cursorValue);
-		const gt = ordinalPrefix() + pad(effectiveId);
+		const startId = id + 1;
+		const parsedCursor = paging?.cursor ? Number.parseInt(paging.cursor, 10) : NaN;
+		const effectiveStart = Math.max(startId, Number.isFinite(parsedCursor) && parsedCursor > 0 ? parsedCursor : startId);
+		const gt = ordinalPrefix() + pad(effectiveStart - 1);
 		const lt = ordinalPrefix() + RANGE_UPPER_BOUND;
 		const limit = paging?.limit ? paging.limit + 1 : void 0;
 		const items = [];
@@ -285,7 +347,7 @@ var HypercoreOperationStore = class {
 			hasMore = true;
 			resultItems = items.slice(0, paging.limit);
 		}
-		const nextCursor = hasMore && resultItems.length > 0 ? resultItems[resultItems.length - 1].context.ordinal.toString() : void 0;
+		const nextCursor = hasMore && resultItems.length > 0 ? (resultItems[resultItems.length - 1].context.ordinal + 1).toString() : void 0;
 		const cursor = paging?.cursor || "0";
 		const resultLimit = paging?.limit || 100;
 		return {
@@ -301,21 +363,31 @@ var HypercoreOperationStore = class {
 			}, signal) : void 0
 		};
 	}
+	/**
+	* The paging cursor here encodes the index to resume from (one past the
+	* last row returned), not the last row's own index, for the same reason as
+	* `getSince`: a page ending at index 0 must not produce a cursor that is
+	* indistinguishable from the start-of-stream sentinel.
+	*/
 	async getConflicting(documentId, scope, branch, minTimestamp, paging, signal) {
 		if (signal?.aborted) throw new Error("Operation aborted");
 		const prefix = operationPrefix(documentId, scope, branch);
-		const cursorIndex = paging?.cursor && parseInt(paging.cursor, 10) > 0 ? parseInt(paging.cursor, 10) : -1;
-		const gt = cursorIndex >= 0 ? prefix + pad(cursorIndex) : prefix;
+		const parsedCursor = paging?.cursor ? Number.parseInt(paging.cursor, 10) : NaN;
+		const cursorIndex = Number.isFinite(parsedCursor) && parsedCursor > 0 ? parsedCursor : -1;
+		const gte = cursorIndex >= 0 ? prefix + pad(cursorIndex) : prefix;
 		const lt = prefix + RANGE_UPPER_BOUND;
 		const stream = this.bee.createReadStream({
-			gt: cursorIndex >= 0 ? gt : void 0,
-			gte: cursorIndex >= 0 ? void 0 : gt,
+			gte,
 			lt
 		});
+		const readLimit = paging?.limit ? paging.limit + 1 : void 0;
 		const items = [];
 		for await (const entry of stream) {
 			const stored = entry.value;
-			if (stored.timestampUtcMs >= minTimestamp) items.push(this.toOperation(stored));
+			if (stored.timestampUtcMs >= minTimestamp) {
+				items.push(this.toOperation(stored));
+				if (readLimit !== void 0 && items.length >= readLimit) break;
+			}
 		}
 		let hasMore = false;
 		let resultItems = items;
@@ -323,7 +395,7 @@ var HypercoreOperationStore = class {
 			hasMore = true;
 			resultItems = items.slice(0, paging.limit);
 		}
-		const nextCursor = hasMore && resultItems.length > 0 ? resultItems[resultItems.length - 1].index.toString() : void 0;
+		const nextCursor = hasMore && resultItems.length > 0 ? (resultItems[resultItems.length - 1].index + 1).toString() : void 0;
 		const cursor = paging?.cursor || "0";
 		const resultLimit = paging?.limit || 100;
 		return {
@@ -373,6 +445,24 @@ var HypercoreOperationStore = class {
 		for (const operation of stored.results) if (latest === void 0 || operation.timestampUtcMs > latest) latest = operation.timestampUtcMs;
 		return latest;
 	}
+	async findOperationIds(documentId, scope, branch, opIds, signal) {
+		if (signal?.aborted) throw new Error("Operation aborted");
+		const found = /* @__PURE__ */ new Set();
+		if (opIds.length === 0) return found;
+		const wanted = new Set(opIds);
+		const stored = await this.getSince(documentId, scope, branch, -1, void 0, void 0, signal);
+		for (const operation of stored.results) if (wanted.has(operation.id)) found.add(operation.id);
+		return found;
+	}
+	async getOperationsByIds(documentId, scope, branch, opIds, signal) {
+		if (signal?.aborted) throw new Error("Operation aborted");
+		if (opIds.length === 0) return [];
+		const wanted = new Set(opIds);
+		const stored = await this.getSince(documentId, scope, branch, -1, void 0, void 0, signal);
+		const latest = /* @__PURE__ */ new Map();
+		for (const operation of stored.results) if (wanted.has(operation.id)) latest.set(operation.id, operation);
+		return [...latest.values()];
+	}
 	serializeOperation(op) {
 		return {
 			id: op.id,
@@ -412,7 +502,8 @@ var StorageManager = class {
 	}
 	async open() {
 		await this.store.ready();
-		this.bee = new Hyperbee(this.store.get({ name: "operations" }), {
+		const core = this.store.get({ name: "operations" });
+		this.bee = new Hyperbee(core, {
 			keyEncoding: "utf-8",
 			valueEncoding: "json"
 		});