@harperfast/harper 5.3.2 → 5.3.3

package/dist/config/parseConfigFile.js

@@ -1,19 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConfigParseError = void 0;
+exports.formatConfigParseErrorDetails = formatConfigParseErrorDetails;
 exports.parseConfigFile = parseConfigFile;
 const yaml_1 = require("yaml");
 // yaml's prettyErrors frames the offending source lines into `message`, and a config file holds
 // credentials. Neither the cause nor the original stack is carried for the same reason.
 class ConfigParseError extends Error {
     constructor(filePath, error) {
-        const { name, code, linePos } = (error ?? {});
-        const at = linePos?.[0] ? ` at line ${linePos[0].line}, column ${linePos[0].col}` : '';
-        super(`Unable to parse the Harper configuration file at ${filePath}: ${code ?? name ?? 'parse failure'}${at}`);
+        super(`Unable to parse the Harper configuration file at ${filePath}: ${formatConfigParseErrorDetails(error)}`);
         this.name = 'ConfigParseError';
     }
 }
 exports.ConfigParseError = ConfigParseError;
+function formatConfigParseErrorDetails(error) {
+    const { name, code, linePos } = (error ?? {});
+    const at = linePos?.[0] ? ` at line ${linePos[0].line}, column ${linePos[0].col}` : '';
+    return `${code ?? name ?? 'parse failure'}${at}`;
+}
 function parseConfigFile(contents, filePath) {
     try {
         // yaml routes warnings through `process.emitWarning` rather than a throw, so a framed

package/dist/config/parseConfigFile.js.map

@@ -1 +1 @@
-{"version":3,"file":"parseConfigFile.js","sourceRoot":"","sources":["../../config/parseConfigFile.ts"],"names":[],"mappings":";;;AAiBA,0CAWC;AA5BD,+BAA6B;AAE7B,gGAAgG;AAChG,wFAAwF;AACxF,MAAa,gBAAiB,SAAQ,KAAK;IAC1C,YAAY,QAAgB,EAAE,KAAc;QAC3C,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,CAAC,KAAK,IAAI,EAAE,CAI3C,CAAC;QACF,MAAM,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,YAAY,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,YAAY,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QACvF,KAAK,CAAC,oDAAoD,QAAQ,KAAK,IAAI,IAAI,IAAI,IAAI,eAAe,GAAG,EAAE,EAAE,CAAC,CAAC;QAC/G,IAAI,CAAC,IAAI,GAAG,kBAAkB,CAAC;IAChC,CAAC;CACD;AAXD,4CAWC;AAED,SAAgB,eAAe,CAAC,QAAgB,EAAE,QAAgB;IACjE,IAAI,CAAC;QACJ,sFAAsF;QACtF,0FAA0F;QAC1F,OAAO,IAAA,YAAK,EAAC,QAAQ,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,CAAC;IAC/C,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QAChB,4FAA4F;QAC5F,uEAAuE;QACvE,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC;YAAE,MAAM,KAAK,CAAC;QAC1C,MAAM,IAAI,gBAAgB,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;IAC7C,CAAC;AACF,CAAC;AAED,SAAS,gBAAgB,CAAC,KAAc;IACvC,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,CAAC,KAAK,IAAI,EAAE,CAAyC,CAAC;IAChF,OAAO,OAAO,KAAK,SAAS,IAAI,IAAI,KAAK,gBAAgB,CAAC;AAC3D,CAAC"}
+{"version":3,"file":"parseConfigFile.js","sourceRoot":"","sources":["../../config/parseConfigFile.ts"],"names":[],"mappings":";;;AAWA,sEAQC;AAED,0CAWC;AAhCD,+BAA6B;AAE7B,gGAAgG;AAChG,wFAAwF;AACxF,MAAa,gBAAiB,SAAQ,KAAK;IAC1C,YAAY,QAAgB,EAAE,KAAc;QAC3C,KAAK,CAAC,oDAAoD,QAAQ,KAAK,6BAA6B,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;QAC/G,IAAI,CAAC,IAAI,GAAG,kBAAkB,CAAC;IAChC,CAAC;CACD;AALD,4CAKC;AAED,SAAgB,6BAA6B,CAAC,KAAc;IAC3D,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,CAAC,KAAK,IAAI,EAAE,CAI3C,CAAC;IACF,MAAM,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,YAAY,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,YAAY,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;IACvF,OAAO,GAAG,IAAI,IAAI,IAAI,IAAI,eAAe,GAAG,EAAE,EAAE,CAAC;AAClD,CAAC;AAED,SAAgB,eAAe,CAAC,QAAgB,EAAE,QAAgB;IACjE,IAAI,CAAC;QACJ,sFAAsF;QACtF,0FAA0F;QAC1F,OAAO,IAAA,YAAK,EAAC,QAAQ,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,CAAC;IAC/C,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QAChB,4FAA4F;QAC5F,uEAAuE;QACvE,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC;YAAE,MAAM,KAAK,CAAC;QAC1C,MAAM,IAAI,gBAAgB,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;IAC7C,CAAC;AACF,CAAC;AAED,SAAS,gBAAgB,CAAC,KAAc;IACvC,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,CAAC,KAAK,IAAI,EAAE,CAAyC,CAAC;IAChF,OAAO,OAAO,KAAK,SAAS,IAAI,IAAI,KAAK,gBAAgB,CAAC;AAC3D,CAAC"}

package/dist/resources/DatabaseTransaction.d.ts

@@ -11,6 +11,8 @@ export declare const TRANSACTION_STATE: {
     LINGERING: number;
 };
 export declare const COMMIT_PHASE_GRACE = 10;
+/** Test seam: clears the stuck- and stalled-commit log cooldowns so consecutive tests can assert on log emission without sleeping. */
+export declare function resetStuckCommitLogCooldownForTests(): void;
 export declare function trackOutstandingCommit(commitResolution: Promise<number | void>, store?: any, startedFrom?: {
     resourceName: string;
     method: string;
@@ -109,7 +111,7 @@ export type TransactionWrite = {
     entry?: Partial<Entry>;
     before?: () => void | Promise<void>;
     beforeIntermediate?: () => void | Promise<void>;
-    commit?: (txnTime: number, existingEntry: Partial<Entry>, retry: boolean, transaction: any) => MaybePromise<void>;
+    commit?: (txnTime: number, existingEntry: Partial<Entry>, retry: boolean, transaction: any, committedBy?: DatabaseTransaction) => MaybePromise<void>;
     validate?: (txnTime: number, committedBy: DatabaseTransaction) => void;
     fullUpdate?: boolean;
     recordVersion?: number;
@@ -123,6 +125,7 @@ export type TransactionWrite = {
     savedBlobs?: Blob[];
     skipped?: boolean;
     appendedAuditEntry?: boolean;
+    appendedTo?: RocksTransaction;
     stagedIn?: DatabaseTransaction;
     priorWrite?: TransactionWrite;
     chainsStagedState?: boolean;
@@ -137,6 +140,7 @@ export type TransactionWrite = {
     recordVersionApplied?: boolean;
     innerCommit?: MaybePromise<CommitResolution>;
     reloadCommitBase?: boolean;
+    stagedOn?: RocksTransaction;
     baseReadTxn?: any;
     writeGeneration?: WriteGeneration;
     instanceClosed?: boolean;
@@ -167,6 +171,17 @@ export declare function priorStagedWrite(operation: TransactionWrite): Transacti
 export declare function writeKeyId(key: Id): unknown;
 type RocksTransactionWithRetry = RocksTransaction & {
     isRetry?: boolean;
+    retries?: number;
+    hasStagedLog?: boolean;
+    stagedTxnTime?: number;
+    commitStartedAt?: number;
+    commitOverdueLogged?: boolean;
+    lockHolds?: Set<RecordLockHandle>;
+    holdBudgetSpent?: boolean;
+    abortedByWrapper?: boolean;
+    commitInFlight?: boolean;
+    committed?: boolean;
+    immediateCommit?: boolean;
 };
 export declare class DatabaseTransaction implements Transaction {
     #private;
@@ -177,6 +192,7 @@ export declare class DatabaseTransaction implements Transaction {
     ownedWrites?: WeakSet<TransactionWrite>;
     writesByKey?: Map<any, Map<unknown, TransactionWrite>>;
     completions: Promise<void>[];
+    private completionHandles?;
     db: RootDatabaseKind;
     transaction: RocksTransactionWithRetry;
     readTxn: ReadTransaction;
@@ -195,6 +211,7 @@ export declare class DatabaseTransaction implements Transaction {
     next: DatabaseTransaction;
     root?: DatabaseTransaction;
     commitStartedAt?: number;
+    commitOverdueLogged?: boolean;
     writeSupervised?: boolean;
     stale: boolean;
     baseReadRefConsumed?: boolean;
@@ -233,9 +250,18 @@ export declare class DatabaseTransaction implements Transaction {
     requestAbortListener?: () => void;
     ownedReadIterators?: Set<OwnedReadIterator>;
     commitsInFlight: number;
+    private activeCommitHandle?;
+    private activeCommitHandles?;
+    private activeHandleStagedTxnTime?;
+    private activeHandleInFlight?;
+    private activeHandleCommitted?;
     poisonedMidCommit?: boolean;
     deferredPoisonDeadline?: number;
     unsubmittedCommitDeadline?: number;
+    loggedRetriesSeen?: number;
+    loggedRetriesChangedAt?: number;
+    loggedRetriesTick?: number;
+    loggedRetryAdvancing?: boolean;
     nativeCommitSubmitted: boolean;
     commitSubmitted: boolean;
     submittedLink?: DatabaseTransaction;
@@ -316,12 +342,40 @@ export declare class DatabaseTransaction implements Transaction {
     unregisterPendingLock(store: any, keyId: unknown): void;
     /** Release every transaction-scoped lock() handle this link owns. */
     releaseRecordLocks(): void;
+    private budgetCarrier;
+    private backfillActiveHandleWrites;
+    private isSingleHandleTarget;
+    private getHandleStagedTxnTime;
+    private setHandleStagedTxnTime;
+    private isHandleCommitInFlight;
+    private setHandleCommitInFlight;
+    private isHandleCommitted;
+    private setHandleCommitted;
+    private trackActiveCommitHandle;
+    private releaseActiveCommitHandle;
+    private clearActiveCommitHandles;
+    private hasActiveCommitHandle;
+    /**
+     * Retries so far of the handles with a durable transaction-log entry still retrying their commit on
+     * this link, summed over overlapping commits so the total moves whenever any of them does, or -1
+     * when there is none.
+     */
+    activeDurableLogRetries(): number;
+    private isActiveCommitHandle;
+    private hasSiblingCommitInFlight;
+    private isWriteOwnedByActiveCommit;
+    private hasWriteOwnedByActiveCommit;
+    private hasSavedWrite;
+    private hasSavedWriteForHandle;
+    private retainTransactionLockHolds;
     private noteCommittedLockVersions;
     /**
      * Discard the staged write set (committed or aborted); the per-key chain must go with it so a
-     * reused transaction never bases a write on a previous batch's staged state.
+     * reused transaction never bases a write on a previous batch's staged state. When concurrent
+     * commits share one DatabaseTransaction, only the writes staged on `committedTransaction` are
+     * removed while another native commit is still in flight.
      */
-    clearWrites(): void;
+    clearWrites(committedTransaction?: RocksTransaction, fromAbort?: boolean): void;
     /**
      * Drop this transaction's back-reference from its context once completed (commit or abort),
      * so a long-lived context (e.g. an MQTT subscription context held open for the life of a
@@ -353,23 +407,25 @@ export declare class DatabaseTransaction implements Transaction {
      * no record), and writes with no stored entry at all — a delete leaves a readable tombstone on any
      * audited or delete-tracking table, so only a delete on a table with neither is entry-less. Such a
      * `put(A); delete(B)` confirms on A's entry, whose version is this transaction's (every write in a
-     * transaction is stamped with one version).
+     * transaction is stamped with one version). `savedOnly` also skips a deferred write not yet saved,
+     * which a commit leaves in place for a later one.
      */
-    lastConfirmableEntry(): Partial<Entry> | undefined;
+    lastConfirmableEntry(savedOnly?: boolean): Partial<Entry> | undefined;
     /**
      * Stage an async operation that commit() must wait for. Staging can happen a turn or more before
      * commit() attaches its Promise.all, so the no-op rejection handler is attached here: without it a
      * rejection in that window is an unhandled rejection (fatal under --unhandled-rejections=strict).
      * The rejection still surfaces through commit()'s Promise.all.
      */
-    stageCompletion(completion: Promise<void>): void;
+    stageCompletion(completion: Promise<void>, transaction?: RocksTransaction): void;
+    private takeCompletions;
     /**
      * Discard staged completions that no commit() will ever aggregate (abort path). Their rejections
      * are already no-op-handled by stageCompletion(), so without this they fail silently; log instead.
      * Clearing them also keeps a reused transaction's next commit() from rejecting with the previous
      * batch's error.
      */
-    drainCompletions(): void;
+    drainCompletions(targetTransaction?: RocksTransaction, preserveActiveWrites?: boolean): void;
     addWrite(operation: TransactionWrite): any;
     save(operation: TransactionWrite, transaction?: RocksTransaction, reloadEntry?: boolean, options?: CommitOptions): MaybePromise<CommitResolution>;
     /**
@@ -458,8 +514,8 @@ export declare class DatabaseTransaction implements Transaction {
     /** See completeMidScopeCommit, which is the only caller and carries the reasoning. */
     private rotateAfterMidScopeCommit;
     private assertDatabaseCommitAllowed;
-    protected abortAfterCommitError(error: any): never;
-    abort(retainReadTransaction?: boolean, cascade?: boolean): void;
+    protected abortAfterCommitError(error: any, targetTransaction?: RocksTransaction): never;
+    abort(retainReadTransaction?: boolean, cascade?: boolean, targetTransaction?: RocksTransaction): void;
     /** How long this logical commit may keep retrying: the thread-wide queue limit, or its own larger explicit budget. */
     private commitConflictBudget;
     /**
@@ -484,6 +540,11 @@ export declare class DatabaseTransaction implements Transaction {
      * through a mid-scope commit is in the same position.
      */
     private abandonCommitAfterDeadline;
+    /**
+     * A durably logged commit past its conflict budget cannot be aborted; release its deferred
+     * record-lock holds (`holdBudgetSpent` prevents re-retaining them) and log once per chain/cooldown.
+     */
+    private noteOverdueLoggedCommit;
     /**
      * Give up on a chain of linked transactions after exhausting conflict retries: poison every link
      * first, then abort each link's native transaction and release its DatabaseTransaction-level
@@ -577,7 +638,7 @@ export declare function isJoinableScope(transaction: DatabaseTransaction | null
  * outcome is not known yet. Merely entering commit() is not enough: a wholly pre-submit transaction
  * remains subject to shouldSpareCommitPhase() and its ordinary bounded grace.
  */
-export declare function deferForCommitInFlight(txn: DatabaseTransaction, url: string | undefined, expiration?: any): boolean;
+export declare function deferForCommitInFlight(txn: DatabaseTransaction, url: string | undefined, expiration?: any, tick?: number): boolean;
 /**
  * Test seam: re-arms the once-per-process replay warning. The whole unit suite shares one process,
  * so whichever test first drives a commit under open iterators consumes the warning for every test
@@ -585,7 +646,11 @@ export declare function deferForCommitInFlight(txn: DatabaseTransaction, url: st
  */
 export declare function resetReplayedWritesWarning(): void;
 export declare function setMaxOutstandingTxnDuration(ms: number): number;
+/** Test seam: overrides the per-retry backoff cap and returns the previous value. */
+export declare function setMaxRetryDelayMs(ms: number): number;
 /** Test seam: whether the monitor supervises this logical transaction for its writes. */
 export declare function isWriteSupervised(txn: DatabaseTransaction): boolean;
+/** Test seam: returns the current open-transaction monitor interval. */
+export declare function getTxnExpiration(): number;
 export declare function setTxnExpiration(ms: any): Set<DatabaseTransaction>;
 export {};