@routier/core 0.2.1 → 0.4.0

package/dist/pipeline/index.cjs

@@ -0,0 +1,576 @@
+(() => {
+"use strict";
+var __webpack_modules__ = ({
+416(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  U: () => (WorkPipeline),
+  k: () => (TrampolinePipeline)
+});
+/* import */ var _utilities__rspack_import_0 = __webpack_require__(581);
+/* import */ var _results__rspack_import_1 = __webpack_require__(718);
+
+
+class TrampolinePipeline {
+    _list = [];
+    _hasErrored = false;
+    filter(initialData, done) {
+        this._hasErrored = false; // Reset error flag on new execution
+        if (this._list.length === 0) {
+            done(initialData);
+            return;
+        }
+        let index = 0;
+        let currentData = initialData;
+        let isRunning = false; // Guard against overlapping trampoline calls
+        try {
+            // --- Revised Completion Logic --- (Moved up for clarity)
+            const finalStepSentinel = ()=>{
+                // Only call done if no error has occurred
+                if (!this._hasErrored) {
+                    done(currentData);
+                }
+                return null; // Stop the trampoline
+            };
+            const createStepRevised = (idx)=>{
+                return ()=>{
+                    if (this._hasErrored) return null; // Stop if an error occurred elsewhere
+                    if (idx >= this._list.length) {
+                        return finalStepSentinel(); // Execute the dedicated final step
+                    }
+                    const processor = this._list[idx];
+                    // Initialize syncCallbackResult to null to satisfy StepResult type
+                    let syncCallbackResult = null;
+                    let calledSync = false;
+                    try {
+                        processor(currentData, (result, error)=>{
+                            // --- Error Handling ---
+                            if (error) {
+                                _utilities__rspack_import_0/* .logger.error */.vF.error(`Error reported by processor at index ${idx}:`, error);
+                                this._hasErrored = true; // Set flag
+                                // Throw the error to be caught by outer try...catch blocks
+                                throw error;
+                            }
+                            // --- /Error Handling ---
+                            // If no error, proceed as before
+                            currentData = result;
+                            index = idx + 1; // Update index for the next step
+                            const nextStep = createStepRevised(index); // Use updated index
+                            if (isRunning) {
+                                // Callback was synchronous
+                                syncCallbackResult = nextStep; // Store next step function
+                                calledSync = true;
+                            } else {
+                                // Callback was asynchronous, restart trampoline
+                                trampoline(nextStep);
+                            }
+                        });
+                    } catch (error) {
+                        if (!this._hasErrored) {
+                            _utilities__rspack_import_0/* .logger.error */.vF.error(`Error thrown by processor at index ${idx} or its callback:`, error);
+                            this._hasErrored = true;
+                        }
+                        // Rethrow to be caught by the trampoline's catch block
+                        throw error;
+                    }
+                    if (calledSync) {
+                        // Return the next step function for the sync loop
+                        return syncCallbackResult;
+                    } else {
+                        // Pause trampoline for async, loop will stop as step returns null
+                        return null;
+                    }
+                };
+            };
+            // The trampoline loop
+            const trampoline = (step)=>{
+                if (isRunning) {
+                    return;
+                }
+                isRunning = true;
+                let currentStep = step;
+                while(currentStep !== null){
+                    try {
+                        // Stop immediately if an error was flagged elsewhere
+                        if (this._hasErrored) {
+                            currentStep = null;
+                            break;
+                        }
+                        currentStep = currentStep(); // Execute step, get next step or null
+                    } catch (trampolineError) {
+                        // Catch errors propagated from step execution (processor or callback errors)
+                        if (!this._hasErrored) {
+                            _utilities__rspack_import_0/* .logger.error */.vF.error("Error during trampoline step execution:", trampolineError);
+                            this._hasErrored = true;
+                        }
+                        currentStep = null; // Stop the loop
+                        // Report the failure to the caller.
+                        //
+                        // This used to break without calling `done`, on the reasoning that
+                        // the application should handle the uncaught exception. It cannot:
+                        // the error is caught right here, so nothing escapes to be handled,
+                        // and every caller awaiting the callback waits forever. A hang is
+                        // strictly worse than an error — it gives the caller nothing to act
+                        // on and no way to time out.
+                        //
+                        // `done` runs exactly once per execution: this path returns
+                        // immediately, and finalStepSentinel checks `_hasErrored` before
+                        // reporting success, so the two are mutually exclusive.
+                        isRunning = false;
+                        done(currentData, trampolineError);
+                        return;
+                    }
+                }
+                // Loop ends when currentStep is null or loop is broken by error
+                isRunning = false;
+            // Completion check is now handled by finalStepSentinel ensuring `done` isn't called on error.
+            };
+            // --- Start the process ---
+            index = 0; // Reset index
+            currentData = initialData; // Reset data
+            trampoline(createStepRevised(0)); // Start with the revised step creator
+        } catch (error) {
+            done(currentData, error);
+        }
+    }
+    pipe(processor) {
+        this._list.push(processor);
+        return this;
+    }
+    pipeEach(items, fn, map) {
+        for(let i = 0, length = items.length; i < length; i++){
+            this.pipe((previous, done)=>{
+                fn(map(previous, _results__rspack_import_1/* .Result.success */.Q.success(items[i])), done);
+            });
+        }
+    }
+}
+/**
+ * Processes functions with callbacks asynchronously.
+ * 
+ * This pipeline handles work items that contain callback functions,
+ * executing them in an asynchronous manner while maintaining proper
+ * flow control and error handling.
+ */ class WorkPipeline {
+    unitsOfWork = [];
+    _hasErrored = false;
+    filter(done) {
+        this._hasErrored = false; // Reset error flag on new execution
+        if (this.unitsOfWork.length === 0) {
+            done(_results__rspack_import_1/* .Result.success */.Q.success());
+            return;
+        }
+        let index = 0;
+        let isRunning = false; // Guard against overlapping trampoline calls
+        try {
+            // --- Revised Completion Logic --- (Moved up for clarity)
+            const finalStepSentinel = ()=>{
+                // Only call done if no error has occurred
+                if (!this._hasErrored) {
+                    done(_results__rspack_import_1/* .Result.success */.Q.success());
+                }
+                return null; // Stop the trampoline
+            };
+            const createStepRevised = (idx)=>{
+                return ()=>{
+                    if (this._hasErrored) return null; // Stop if an error occurred elsewhere
+                    if (idx >= this.unitsOfWork.length) {
+                        return finalStepSentinel(); // Execute the dedicated final step
+                    }
+                    const processor = this.unitsOfWork[idx];
+                    // Initialize syncCallbackResult to null to satisfy StepResult type
+                    let syncCallbackResult = null;
+                    let calledSync = false;
+                    try {
+                        processor((result)=>{
+                            // --- Error Handling ---
+                            if (result.ok === _results__rspack_import_1/* .Result.ERROR */.Q.ERROR) {
+                                _utilities__rspack_import_0/* .logger.error */.vF.error(`Error reported by AsyncPipeline at index ${idx}:`, result.error);
+                                this._hasErrored = true; // Set flag
+                                // Throw the error to be caught by outer try...catch blocks
+                                throw result.error;
+                            }
+                            // --- /Error Handling ---
+                            // If no error, proceed as before
+                            index = idx + 1; // Update index for the next step
+                            const nextStep = createStepRevised(index); // Use updated index
+                            if (isRunning) {
+                                // Callback was synchronous
+                                syncCallbackResult = nextStep; // Store next step function
+                                calledSync = true;
+                            } else {
+                                // Callback was asynchronous, restart trampoline
+                                trampoline(nextStep);
+                            }
+                        });
+                    } catch (error) {
+                        if (!this._hasErrored) {
+                            _utilities__rspack_import_0/* .logger.error */.vF.error(`Error thrown by processor at index ${idx} or its callback:`, error);
+                            this._hasErrored = true;
+                        }
+                        // Rethrow to be caught by the trampoline's catch block
+                        throw error;
+                    }
+                    if (calledSync) {
+                        // Return the next step function for the sync loop
+                        return syncCallbackResult;
+                    } else {
+                        // Pause trampoline for async, loop will stop as step returns null
+                        return null;
+                    }
+                };
+            };
+            // The trampoline loop
+            const trampoline = (step)=>{
+                if (isRunning) {
+                    return;
+                }
+                isRunning = true;
+                let currentStep = step;
+                while(currentStep !== null){
+                    try {
+                        // Stop immediately if an error was flagged elsewhere
+                        if (this._hasErrored) {
+                            currentStep = null;
+                            break;
+                        }
+                        currentStep = currentStep(); // Execute step, get next step or null
+                    } catch (trampolineError) {
+                        // Catch errors propagated from step execution (processor or callback errors)
+                        if (!this._hasErrored) {
+                            _utilities__rspack_import_0/* .logger.error */.vF.error("Error during trampoline step execution:", trampolineError);
+                            this._hasErrored = true;
+                        }
+                        currentStep = null; // Stop the loop
+                        // Report the failure to the caller. See the note on the same path in
+                        // TrampolinePipeline: swallowing the error here left every caller
+                        // awaiting `done` hanging instead of receiving a failure.
+                        isRunning = false;
+                        done(_results__rspack_import_1/* .Result.error */.Q.error(trampolineError));
+                        return;
+                    }
+                }
+                // Loop ends when currentStep is null or loop is broken by error
+                isRunning = false;
+            // Completion check is now handled by finalStepSentinel ensuring `done` isn't called on error.
+            };
+            // --- Start the process ---
+            index = 0; // Reset index
+            trampoline(createStepRevised(0)); // Start with the revised step creator
+        } catch (error) {
+            done(_results__rspack_import_1/* .Result.error */.Q.error(error));
+        }
+    }
+    pipe(work) {
+        this.unitsOfWork.push(work);
+    }
+}
+
+
+},
+718(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  Q: () => (Result)
+});
+class BaseResult {
+    static ERROR = "error";
+    static SUCCESS = "success";
+    static PARTIAL = "partial";
+    static resolve(result, resolve, reject) {
+        if (result.ok === BaseResult.SUCCESS) {
+            resolve(result.data);
+            return;
+        }
+        if (result.ok === BaseResult.PARTIAL) {
+            reject({
+                partial: result.data,
+                error: result.error
+            });
+            return;
+        }
+        reject(result.error);
+    }
+    static assertSuccess(result) {
+        if (result.ok !== BaseResult.SUCCESS) {
+            throw new Error(`Expected success result, but got ${result.ok}: ${result.error}`);
+        }
+    }
+}
+class Result extends BaseResult {
+    static success(data) {
+        return {
+            ok: Result.SUCCESS,
+            data
+        };
+    }
+    static error(error) {
+        return {
+            ok: Result.ERROR,
+            error
+        };
+    }
+    static partial(data, error) {
+        return {
+            ok: Result.PARTIAL,
+            data,
+            error
+        };
+    }
+}
+class PluginEventResult extends (/* unused pure expression or super */ null && (BaseResult)) {
+    static success(id, data) {
+        return {
+            id,
+            ok: Result.SUCCESS,
+            data
+        };
+    }
+    static error(id, error) {
+        return {
+            id,
+            ok: Result.ERROR,
+            error
+        };
+    }
+    static partial(id, data, error) {
+        return {
+            id,
+            ok: Result.PARTIAL,
+            data,
+            error
+        };
+    }
+    static assertSuccess(result) {
+        if (result.ok !== Result.SUCCESS) {
+            throw new Error(`Expected success result, but got ${result.ok}: ${result.error}`);
+        }
+    }
+}
+
+
+},
+581(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  vF: () => (logger)
+});
+/**
+ * Levelled logging, resolved once.
+ *
+ * Three things about the previous implementation drove this shape:
+ *
+ *  - **There was no way to turn logging off.** `globalThis.__ROUTIER_DEBUG__` was only ever
+ *    compared against `true`, so setting it to `false` did nothing — while
+ *    `docs/how-to/debug-logging.md` documented exactly that as the way to force logging off.
+ *    A documented switch that silently does nothing is worse than no switch.
+ *  - **`NODE_ENV === 'test'` enabled it.** Every Jest run therefore logged, because Jest always
+ *    sets `NODE_ENV=test`. Measured on the S7 stress scenario, which drives ~2,000 saves through
+ *    a plugin that logs three lines per query: 12.4s with logging, ~6s without. Test runners also
+ *    capture console output by snapshotting a stack trace per call, so the cost is far above what
+ *    writing to a terminal would suggest — and the output buries whatever the failure was.
+ *  - **It was all-or-nothing, and re-resolved per call.** An error could not be kept while debug
+ *    was dropped, and every one of the ~97 call sites re-read `globalThis` and `process.env`.
+ *
+ * Levels are compared numerically against a value cached at module load. Measured against a
+ * no-op console at 200k calls: an enabled call costs ~70ns, a call rejected by the gate ~3ns.
+ * Building the arguments the call site passes in accounts for ~0.2ns of that 3ns, which is why
+ * this keeps the ordinary `logger.debug(msg, payload)` signature instead of taking a thunk —
+ * a lazy API would recover 0.3% of an enabled call's cost and would have to change every call
+ * site to do it.
+ */ /** Ordered from most severe to most verbose. `silent` discards everything. */ const LOG_LEVELS = [
+    'silent',
+    'error',
+    'warn',
+    'info',
+    'debug'
+];
+/** Numeric rank, so a gate is one integer comparison. */ const RANK = {
+    silent: 0,
+    error: 1,
+    warn: 2,
+    info: 3,
+    debug: 4
+};
+const isLogLevel = (value)=>typeof value === 'string' && LOG_LEVELS.includes(value);
+/**
+ * Resolves the configured level, in precedence order.
+ *
+ * Ordered most specific first: an explicit level beats a boolean flag, a boolean flag beats an
+ * environment variable, and an environment variable beats an inference from `NODE_ENV`. Anything
+ * unrecognised is ignored rather than treated as an error — a typo'd level should not take down
+ * an application, and `silent` is the safe direction to fall back to.
+ */ const resolveLevel = ()=>{
+    if (typeof globalThis !== 'undefined') {
+        const g = globalThis;
+        if (isLogLevel(g.__ROUTIER_LOG_LEVEL__)) {
+            return g.__ROUTIER_LOG_LEVEL__;
+        }
+        // Both directions honoured. `=== false` used to fall through to the NODE_ENV checks
+        // below and re-enable the logging it was asked to suppress.
+        if (g.__ROUTIER_DEBUG__ === true) return 'debug';
+        if (g.__ROUTIER_DEBUG__ === false) return 'silent';
+    }
+    // There is deliberately no `import.meta.env` branch, although the documentation used to
+    // promise one. It could never work: this package is bundled with rspack, which replaces
+    // `import.meta` with `undefined`, so the check would read the *library's* build-time
+    // environment rather than the application's — and referencing `import.meta` at all is a parse
+    // error under a CommonJS build target, which is how the test suite loads this file. Vite and
+    // similar apps set `__ROUTIER_LOG_LEVEL__` or `__ROUTIER_DEBUG__` from their own
+    // `import.meta.env`, which is what the docs now describe.
+    if (typeof process !== 'undefined' && process.env != null) {
+        if (isLogLevel(process.env.ROUTIER_LOG_LEVEL)) {
+            return process.env.ROUTIER_LOG_LEVEL;
+        }
+        const debug = process.env.DEBUG;
+        if (debug === 'routier' || debug === '*') return 'debug';
+        const env = "production"?.toLowerCase();
+        // `test` is deliberately absent. It used to be here, which meant no test suite anywhere
+        // could run Routier quietly. Opt in with DEBUG=routier or ROUTIER_LOG_LEVEL when a test
+        // needs the output.
+        if (env === 'dev' || env === 'development') return 'debug';
+    }
+    return 'silent';
+};
+let level = resolveLevel();
+let rank = RANK[level];
+/**
+ * Overrides the level for the rest of the process.
+ *
+ * The configuration above is read once, at import, which is what makes the gate cheap — but it
+ * also means an application that decides its verbosity after startup, or a test that wants to
+ * assert on output, has no way in. This is that way in.
+ */ const setLogLevel = (next)=>{
+    if (isLogLevel(next) === false) {
+        throw new Error(`Unknown log level "${next}". Expected one of: ${LOG_LEVELS.join(', ')}`);
+    }
+    level = next;
+    rank = RANK[next];
+};
+const getLogLevel = ()=>level;
+/** Re-reads the environment. For tests that change it after this module was imported. */ const resetLogLevel = ()=>{
+    level = resolveLevel();
+    rank = RANK[level];
+};
+/**
+ * Whether a message at this level would be emitted.
+ *
+ * For the rare call site whose *arguments* are expensive to build — a serialization, a deep
+ * clone, a join over a large collection. An ordinary payload object is not worth guarding; see
+ * the measurement in the header.
+ */ const isLogLevelEnabled = (at)=>rank >= RANK[at];
+const emit = (at, method, args)=>{
+    if (rank < RANK[at]) {
+        return;
+    }
+    // Resolved at call time rather than captured once: test harnesses and browser devtools both
+    // replace console methods after modules have loaded, and a captured reference would keep
+    // writing past the replacement.
+    console[method](...args);
+};
+const logger = {
+    /** General-purpose output. Carried at `info`, since `log` names a console method, not a level. */ log: (...args)=>emit('info', 'log', args),
+    info: (...args)=>emit('info', 'info', args),
+    warn: (...args)=>emit('warn', 'warn', args),
+    error: (...args)=>emit('error', 'error', args),
+    debug: (...args)=>emit('debug', 'debug', args),
+    /** Diagnostic tabular output; verbose by nature, so it sits at `debug`. */ table: (...args)=>emit('debug', 'table', args)
+};
+
+
+},
+
+});
+// The module cache
+var __webpack_module_cache__ = {};
+
+// The require function
+function __webpack_require__(moduleId) {
+
+// Check if module is in cache
+var cachedModule = __webpack_module_cache__[moduleId];
+if (cachedModule !== undefined) {
+return cachedModule.exports;
+}
+// Create a new module (and put it into the cache)
+var module = (__webpack_module_cache__[moduleId] = {
+exports: {}
+});
+// Execute the module function
+__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+
+// Return the exports of the module
+return module.exports;
+
+}
+
+// webpack/runtime/define_property_getters
+(() => {
+__webpack_require__.d = (exports, definition) => {
+	for(var key in definition) {
+        if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+            Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+        }
+    }
+};
+})();
+// webpack/runtime/has_own_property
+(() => {
+__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+})();
+// webpack/runtime/make_namespace_object
+(() => {
+// define __esModule on exports
+__webpack_require__.r = (exports) => {
+	if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+		Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+	}
+	Object.defineProperty(exports, '__esModule', { value: true });
+};
+})();
+var __webpack_exports__ = {};
+// This entry needs to be wrapped in an IIFE because it needs to be isolated against other modules in the chunk.
+(() => {
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  TrampolinePipeline: () => (/* reexport */ TrampolinePipeline/* .TrampolinePipeline */.k),
+  WorkPipeline: () => (/* reexport */ TrampolinePipeline/* .WorkPipeline */.U),
+  SyncronousQueue: () => (/* reexport */ SyncronousQueue)
+});
+
+;// CONCATENATED MODULE: ./src/pipeline/SyncronousQueue.ts
+class SyncronousQueue {
+    _queue = [];
+    _current = null;
+    enqueue(unitOfWork) {
+        this._queue.push(unitOfWork);
+        this._next();
+    }
+    _next() {
+        if (this._current != null || this._queue.length === 0) {
+            return;
+        }
+        // Take first item
+        this._current = this._queue.shift() ?? null;
+        if (this._current == null) {
+            return;
+        }
+        this._current(()=>{
+            this._current = null;
+            this._next();
+        });
+    }
+}
+
+// EXTERNAL MODULE: ./src/pipeline/TrampolinePipeline.ts
+var TrampolinePipeline = __webpack_require__(416);
+;// CONCATENATED MODULE: ./src/pipeline/index.ts
+
+
+
+})();
+
+module.exports = __webpack_exports__;
+})()
+;
+//# sourceMappingURL=index.cjs.map

package/dist/pipeline/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline/index.cjs","sources":["webpack://@routier/core/./src/pipeline/TrampolinePipeline.ts","webpack://@routier/core/./src/results/Result.ts","webpack://@routier/core/./src/utilities/logger.ts","webpack://@routier/core/webpack/runtime/define_property_getters","webpack://@routier/core/webpack/runtime/has_own_property","webpack://@routier/core/webpack/runtime/make_namespace_object","webpack://@routier/core/./src/pipeline/SyncronousQueue.ts","webpack://@routier/core/./src/pipeline/index.ts"],"sourcesContent":["import { logger } from \"../utilities\";\nimport { CallbackResult, Result, ResultType } from \"../results\";\n\n/**\n * Type definition for an asynchronous function that takes data and a callback.\n * TIn: The input data type.\n * TOut: The output data type (passed to the callback).\n */\nexport type Processor<TIn, TOut> = (data: TIn, callback: (result: TOut, error?: any) => void) => void;\n\n// Return type for a step execution: Either the next step function or null if waiting/done.\ntype StepResult<TData> = TrampolineStep<TData> | null;\ntype TrampolineStep<TData> = () => StepResult<TData>;\n\nexport class TrampolinePipeline<TInitial, TCurrent = TInitial> {\n    private _list: Processor<any, any>[] = [];\n    private _hasErrored: boolean = false; // Flag to prevent calling done on error\n\n    filter<TFinal>(initialData: TInitial, done: (data: TFinal, error?: any) => void) {\n\n        this._hasErrored = false; // Reset error flag on new execution\n\n        if (this._list.length === 0) {\n            done(initialData as unknown as TFinal);\n            return;\n        }\n\n        let index = 0;\n        let currentData: any = initialData;\n        let isRunning = false; // Guard against overlapping trampoline calls\n\n        try {\n            // --- Revised Completion Logic --- (Moved up for clarity)\n            const finalStepSentinel = (): StepResult<any> => { // A special step function for the very end\n                // Only call done if no error has occurred\n                if (!this._hasErrored) {\n                    done(currentData as TFinal);\n                }\n                return null; // Stop the trampoline\n            };\n\n            const createStepRevised = (idx: number): TrampolineStep<any> => {\n                return () => {\n                    if (this._hasErrored) return null; // Stop if an error occurred elsewhere\n\n                    if (idx >= this._list.length) {\n                        return finalStepSentinel(); // Execute the dedicated final step\n                    }\n\n                    const processor = this._list[idx];\n                    // Initialize syncCallbackResult to null to satisfy StepResult type\n                    let syncCallbackResult: StepResult<any> = null;\n                    let calledSync = false;\n\n                    try {\n                        processor(currentData, (result, error) => {\n                            // --- Error Handling ---\n                            if (error) {\n                                logger.error(`Error reported by processor at index ${idx}:`, error);\n                                this._hasErrored = true; // Set flag\n                                // Throw the error to be caught by outer try...catch blocks\n                                throw error;\n                            }\n                            // --- /Error Handling ---\n\n                            // If no error, proceed as before\n                            currentData = result;\n                            index = idx + 1; // Update index for the next step\n                            const nextStep = createStepRevised(index); // Use updated index\n\n                            if (isRunning) {\n                                // Callback was synchronous\n                                syncCallbackResult = nextStep; // Store next step function\n                                calledSync = true;\n                            } else {\n                                // Callback was asynchronous, restart trampoline\n                                trampoline(nextStep);\n                            }\n                        });\n                    } catch (error) {\n                        if (!this._hasErrored) { // Check flag to avoid double logging if error was from callback\n                            logger.error(`Error thrown by processor at index ${idx} or its callback:`, error);\n                            this._hasErrored = true;\n                        }\n                        // Rethrow to be caught by the trampoline's catch block\n                        throw error;\n                    }\n\n                    if (calledSync) {\n                        // Return the next step function for the sync loop\n                        return syncCallbackResult;\n                    } else {\n                        // Pause trampoline for async, loop will stop as step returns null\n                        return null;\n                    }\n                };\n            };\n\n            // The trampoline loop\n            const trampoline = (step: TrampolineStep<any> | null) => {\n\n                if (isRunning) {\n                    return;\n                }\n\n                isRunning = true;\n                let currentStep = step;\n\n                while (currentStep !== null) {\n                    try {\n                        // Stop immediately if an error was flagged elsewhere\n                        if (this._hasErrored) {\n                            currentStep = null;\n                            break;\n                        }\n                        currentStep = currentStep(); // Execute step, get next step or null\n                    } catch (trampolineError) {\n                        // Catch errors propagated from step execution (processor or callback errors)\n                        if (!this._hasErrored) { // Avoid double logging\n                            logger.error(\"Error during trampoline step execution:\", trampolineError);\n                            this._hasErrored = true;\n                        }\n                        currentStep = null; // Stop the loop\n\n                        // Report the failure to the caller.\n                        //\n                        // This used to break without calling `done`, on the reasoning that\n                        // the application should handle the uncaught exception. It cannot:\n                        // the error is caught right here, so nothing escapes to be handled,\n                        // and every caller awaiting the callback waits forever. A hang is\n                        // strictly worse than an error — it gives the caller nothing to act\n                        // on and no way to time out.\n                        //\n                        // `done` runs exactly once per execution: this path returns\n                        // immediately, and finalStepSentinel checks `_hasErrored` before\n                        // reporting success, so the two are mutually exclusive.\n                        isRunning = false;\n                        done(currentData as TFinal, trampolineError);\n                        return;\n                    }\n                }\n                // Loop ends when currentStep is null or loop is broken by error\n                isRunning = false;\n\n                // Completion check is now handled by finalStepSentinel ensuring `done` isn't called on error.\n            };\n\n            // --- Start the process ---\n            index = 0; // Reset index\n            currentData = initialData; // Reset data\n            trampoline(createStepRevised(0)); // Start with the revised step creator\n        } catch (error: any) {\n            done(currentData, error);\n        }\n    }\n\n    pipe<TNext>(processor: Processor<TCurrent, TNext>) {\n        this._list.push(processor);\n        return this as unknown as TrampolinePipeline<TInitial, TNext>;\n    }\n\n    pipeEach(items: TCurrent[], fn: (payload: ResultType<TCurrent>, done: CallbackResult<TCurrent>) => void, map: (previous: ResultType<TCurrent>, current: ResultType<TCurrent>) => ResultType<TCurrent>) {\n        for (let i = 0, length = items.length; i < length; i++) {\n\n            this.pipe<ResultType<TCurrent>>((previous, done) => {\n\n                fn(map(previous as ResultType<TCurrent>, Result.success(items[i])), done);\n            });\n        }\n    }\n}\n\nexport type UnitOfWork = (done: CallbackResult<never>) => void;\n\n/**\n * Processes functions with callbacks asynchronously.\n * \n * This pipeline handles work items that contain callback functions,\n * executing them in an asynchronous manner while maintaining proper\n * flow control and error handling.\n */\nexport class WorkPipeline {\n    private unitsOfWork: UnitOfWork[] = [];\n    private _hasErrored: boolean = false; // Flag to prevent calling done on error\n\n    filter(done: CallbackResult<never>) {\n\n        this._hasErrored = false; // Reset error flag on new execution\n\n        if (this.unitsOfWork.length === 0) {\n            done(Result.success());\n            return;\n        }\n\n        let index = 0;\n        let isRunning = false; // Guard against overlapping trampoline calls\n\n        try {\n            // --- Revised Completion Logic --- (Moved up for clarity)\n            const finalStepSentinel = (): StepResult<never> => { // A special step function for the very end\n                // Only call done if no error has occurred\n                if (!this._hasErrored) {\n                    done(Result.success());\n                }\n                return null; // Stop the trampoline\n            };\n\n            const createStepRevised = (idx: number): TrampolineStep<any> => {\n                return () => {\n                    if (this._hasErrored) return null; // Stop if an error occurred elsewhere\n\n                    if (idx >= this.unitsOfWork.length) {\n                        return finalStepSentinel(); // Execute the dedicated final step\n                    }\n\n                    const processor = this.unitsOfWork[idx];\n                    // Initialize syncCallbackResult to null to satisfy StepResult type\n                    let syncCallbackResult: StepResult<any> = null;\n                    let calledSync = false;\n\n                    try {\n                        processor((result) => {\n                            // --- Error Handling ---\n                            if (result.ok === Result.ERROR) {\n                                logger.error(`Error reported by AsyncPipeline at index ${idx}:`, result.error);\n                                this._hasErrored = true; // Set flag\n                                // Throw the error to be caught by outer try...catch blocks\n                                throw result.error;\n                            }\n                            // --- /Error Handling ---\n\n                            // If no error, proceed as before\n                            index = idx + 1; // Update index for the next step\n                            const nextStep = createStepRevised(index); // Use updated index\n\n                            if (isRunning) {\n                                // Callback was synchronous\n                                syncCallbackResult = nextStep; // Store next step function\n                                calledSync = true;\n                            } else {\n                                // Callback was asynchronous, restart trampoline\n                                trampoline(nextStep);\n                            }\n                        });\n                    } catch (error) {\n                        if (!this._hasErrored) { // Check flag to avoid double logging if error was from callback\n                            logger.error(`Error thrown by processor at index ${idx} or its callback:`, error);\n                            this._hasErrored = true;\n                        }\n                        // Rethrow to be caught by the trampoline's catch block\n                        throw error;\n                    }\n\n                    if (calledSync) {\n                        // Return the next step function for the sync loop\n                        return syncCallbackResult;\n                    } else {\n                        // Pause trampoline for async, loop will stop as step returns null\n                        return null;\n                    }\n                };\n            };\n\n            // The trampoline loop\n            const trampoline = (step: TrampolineStep<any> | null) => {\n\n                if (isRunning) {\n                    return;\n                }\n\n                isRunning = true;\n                let currentStep = step;\n\n                while (currentStep !== null) {\n                    try {\n                        // Stop immediately if an error was flagged elsewhere\n                        if (this._hasErrored) {\n                            currentStep = null;\n                            break;\n                        }\n                        currentStep = currentStep(); // Execute step, get next step or null\n                    } catch (trampolineError) {\n                        // Catch errors propagated from step execution (processor or callback errors)\n                        if (!this._hasErrored) { // Avoid double logging\n                            logger.error(\"Error during trampoline step execution:\", trampolineError);\n                            this._hasErrored = true;\n                        }\n                        currentStep = null; // Stop the loop\n\n                        // Report the failure to the caller. See the note on the same path in\n                        // TrampolinePipeline: swallowing the error here left every caller\n                        // awaiting `done` hanging instead of receiving a failure.\n                        isRunning = false;\n                        done(Result.error(trampolineError));\n                        return;\n                    }\n                }\n                // Loop ends when currentStep is null or loop is broken by error\n                isRunning = false;\n\n                // Completion check is now handled by finalStepSentinel ensuring `done` isn't called on error.\n            };\n\n            // --- Start the process ---\n            index = 0; // Reset index\n            trampoline(createStepRevised(0)); // Start with the revised step creator\n        } catch (error: any) {\n            done(Result.error(error));\n        }\n    }\n\n    pipe(work: UnitOfWork) {\n        this.unitsOfWork.push(work);\n    }\n}","import { PartialResultType, PluginEventPartialResultType, PluginEventResultType, ResultType } from \"./types\";\n\nabstract class BaseResult {\n    static ERROR = \"error\" as const;\n    static SUCCESS = \"success\" as const;\n    static PARTIAL = \"partial\" as const;\n\n    static resolve<T>(result: ResultType<T> | PartialResultType<T>, resolve: (data: T) => void, reject: (error?: any) => void) {\n        if (result.ok === BaseResult.SUCCESS) {\n            resolve(result.data);\n            return;\n        }\n\n        if (result.ok === BaseResult.PARTIAL) {\n            reject({\n                partial: result.data,\n                error: result.error\n            });\n            return;\n        }\n\n        reject(result.error);\n    }\n\n    static assertSuccess<T>(result: any): asserts result is { ok: \"success\"; data: T } {\n        if (result.ok !== BaseResult.SUCCESS) {\n            throw new Error(`Expected success result, but got ${result.ok}: ${result.error}`);\n        }\n    }\n}\n\nexport class Result extends BaseResult {\n    static success<T>(data: T): ResultType<T>;\n    static success(): ResultType<never>;\n    static success<T>(data?: T): ResultType<T> {\n        return {\n            ok: Result.SUCCESS,\n            data\n        }\n    }\n\n    static error<T>(error: any): ResultType<T> {\n        return {\n            ok: Result.ERROR,\n            error\n        }\n    }\n\n    static partial<T>(data: T, error: any): PartialResultType<T> {\n        return {\n            ok: Result.PARTIAL,\n            data,\n            error\n        }\n    }\n}\n\nexport class PluginEventResult extends BaseResult {\n    static success<T>(id: string, data: T): PluginEventResultType<T>;\n    static success(id: string): PluginEventResultType<never>;\n    static success<T>(id: string, data?: T): PluginEventResultType<T> {\n        return {\n            id,\n            ok: Result.SUCCESS,\n            data\n        }\n    }\n\n    static error<T>(id: string, error: any): PluginEventResultType<T> {\n        return {\n            id,\n            ok: Result.ERROR,\n            error\n        }\n    }\n\n    static partial<T>(id: string, data: T, error: any): PluginEventPartialResultType<T> {\n        return {\n            id,\n            ok: Result.PARTIAL,\n            data,\n            error\n        }\n    }\n\n    static assertSuccess<T>(result: PluginEventResultType<T>): asserts result is { ok: \"success\"; data: T; id: string } {\n        if (result.ok !== Result.SUCCESS) {\n            throw new Error(`Expected success result, but got ${result.ok}: ${result.error}`);\n        }\n    }\n}\n","/**\n * Levelled logging, resolved once.\n *\n * Three things about the previous implementation drove this shape:\n *\n *  - **There was no way to turn logging off.** `globalThis.__ROUTIER_DEBUG__` was only ever\n *    compared against `true`, so setting it to `false` did nothing — while\n *    `docs/how-to/debug-logging.md` documented exactly that as the way to force logging off.\n *    A documented switch that silently does nothing is worse than no switch.\n *  - **`NODE_ENV === 'test'` enabled it.** Every Jest run therefore logged, because Jest always\n *    sets `NODE_ENV=test`. Measured on the S7 stress scenario, which drives ~2,000 saves through\n *    a plugin that logs three lines per query: 12.4s with logging, ~6s without. Test runners also\n *    capture console output by snapshotting a stack trace per call, so the cost is far above what\n *    writing to a terminal would suggest — and the output buries whatever the failure was.\n *  - **It was all-or-nothing, and re-resolved per call.** An error could not be kept while debug\n *    was dropped, and every one of the ~97 call sites re-read `globalThis` and `process.env`.\n *\n * Levels are compared numerically against a value cached at module load. Measured against a\n * no-op console at 200k calls: an enabled call costs ~70ns, a call rejected by the gate ~3ns.\n * Building the arguments the call site passes in accounts for ~0.2ns of that 3ns, which is why\n * this keeps the ordinary `logger.debug(msg, payload)` signature instead of taking a thunk —\n * a lazy API would recover 0.3% of an enabled call's cost and would have to change every call\n * site to do it.\n */\n\n/** Ordered from most severe to most verbose. `silent` discards everything. */\nexport const LOG_LEVELS = ['silent', 'error', 'warn', 'info', 'debug'] as const;\n\nexport type LogLevel = (typeof LOG_LEVELS)[number];\n\n/** Numeric rank, so a gate is one integer comparison. */\nconst RANK: Record<LogLevel, number> = {\n    silent: 0,\n    error: 1,\n    warn: 2,\n    info: 3,\n    debug: 4,\n};\n\nconst isLogLevel = (value: unknown): value is LogLevel =>\n    typeof value === 'string' && (LOG_LEVELS as readonly string[]).includes(value);\n\n/**\n * Resolves the configured level, in precedence order.\n *\n * Ordered most specific first: an explicit level beats a boolean flag, a boolean flag beats an\n * environment variable, and an environment variable beats an inference from `NODE_ENV`. Anything\n * unrecognised is ignored rather than treated as an error — a typo'd level should not take down\n * an application, and `silent` is the safe direction to fall back to.\n */\nconst resolveLevel = (): LogLevel => {\n    if (typeof globalThis !== 'undefined') {\n        const g = globalThis as { __ROUTIER_LOG_LEVEL__?: unknown; __ROUTIER_DEBUG__?: unknown };\n\n        if (isLogLevel(g.__ROUTIER_LOG_LEVEL__)) {\n            return g.__ROUTIER_LOG_LEVEL__;\n        }\n\n        // Both directions honoured. `=== false` used to fall through to the NODE_ENV checks\n        // below and re-enable the logging it was asked to suppress.\n        if (g.__ROUTIER_DEBUG__ === true) return 'debug';\n        if (g.__ROUTIER_DEBUG__ === false) return 'silent';\n    }\n\n    // There is deliberately no `import.meta.env` branch, although the documentation used to\n    // promise one. It could never work: this package is bundled with rspack, which replaces\n    // `import.meta` with `undefined`, so the check would read the *library's* build-time\n    // environment rather than the application's — and referencing `import.meta` at all is a parse\n    // error under a CommonJS build target, which is how the test suite loads this file. Vite and\n    // similar apps set `__ROUTIER_LOG_LEVEL__` or `__ROUTIER_DEBUG__` from their own\n    // `import.meta.env`, which is what the docs now describe.\n    if (typeof process !== 'undefined' && process.env != null) {\n        if (isLogLevel(process.env.ROUTIER_LOG_LEVEL)) {\n            return process.env.ROUTIER_LOG_LEVEL as LogLevel;\n        }\n\n        const debug = process.env.DEBUG;\n        if (debug === 'routier' || debug === '*') return 'debug';\n\n        const env = process.env.NODE_ENV?.toLowerCase();\n\n        // `test` is deliberately absent. It used to be here, which meant no test suite anywhere\n        // could run Routier quietly. Opt in with DEBUG=routier or ROUTIER_LOG_LEVEL when a test\n        // needs the output.\n        if (env === 'dev' || env === 'development') return 'debug';\n    }\n\n    return 'silent';\n};\n\nlet level: LogLevel = resolveLevel();\nlet rank = RANK[level];\n\n/**\n * Overrides the level for the rest of the process.\n *\n * The configuration above is read once, at import, which is what makes the gate cheap — but it\n * also means an application that decides its verbosity after startup, or a test that wants to\n * assert on output, has no way in. This is that way in.\n */\nexport const setLogLevel = (next: LogLevel): void => {\n    if (isLogLevel(next) === false) {\n        throw new Error(`Unknown log level \"${next}\". Expected one of: ${LOG_LEVELS.join(', ')}`);\n    }\n\n    level = next;\n    rank = RANK[next];\n};\n\nexport const getLogLevel = (): LogLevel => level;\n\n/** Re-reads the environment. For tests that change it after this module was imported. */\nexport const resetLogLevel = (): void => {\n    level = resolveLevel();\n    rank = RANK[level];\n};\n\n/**\n * Whether a message at this level would be emitted.\n *\n * For the rare call site whose *arguments* are expensive to build — a serialization, a deep\n * clone, a join over a large collection. An ordinary payload object is not worth guarding; see\n * the measurement in the header.\n */\nexport const isLogLevelEnabled = (at: LogLevel): boolean => rank >= RANK[at];\n\ntype ConsoleMethod = 'log' | 'info' | 'warn' | 'error' | 'debug' | 'table';\n\nconst emit = (at: LogLevel, method: ConsoleMethod, args: unknown[]) => {\n    if (rank < RANK[at]) {\n        return;\n    }\n\n    // Resolved at call time rather than captured once: test harnesses and browser devtools both\n    // replace console methods after modules have loaded, and a captured reference would keep\n    // writing past the replacement.\n    (console[method] as (...a: unknown[]) => void)(...args);\n};\n\nexport const logger = {\n    /** General-purpose output. Carried at `info`, since `log` names a console method, not a level. */\n    log: (...args: unknown[]): void => emit('info', 'log', args),\n    info: (...args: unknown[]): void => emit('info', 'info', args),\n    warn: (...args: unknown[]): void => emit('warn', 'warn', args),\n    error: (...args: unknown[]): void => emit('error', 'error', args),\n    debug: (...args: unknown[]): void => emit('debug', 'debug', args),\n    /** Diagnostic tabular output; verbose by nature, so it sits at `debug`. */\n    table: (...args: unknown[]): void => emit('debug', 'table', args),\n};\n","__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n        if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n            Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n        }\n    }\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","export type SyncronousUnitOfWork = (done: () => void) => void\n\nexport class SyncronousQueue {\n\n    private readonly _queue: SyncronousUnitOfWork[] = [];\n    private _current: SyncronousUnitOfWork | null = null;\n\n    enqueue(unitOfWork: SyncronousUnitOfWork) {\n        this._queue.push(unitOfWork);\n        this._next();\n    }\n\n    private _next() {\n        if (this._current != null || this._queue.length === 0) {\n            return;\n        }\n\n        // Take first item\n        this._current = this._queue.shift() ?? null;\n\n        if (this._current == null) {\n            return;\n        }\n\n        this._current(() => {\n            this._current = null;\n            this._next();\n        })\n    }\n}","export * from './SyncronousQueue';\nexport * from './TrampolinePipeline';"],"names":["logger","Result","TrampolinePipeline","initialData","done","index","currentData","isRunning","finalStepSentinel","createStepRevised","idx","processor","syncCallbackResult","calledSync","result","error","nextStep","trampoline","step","currentStep","trampolineError","items","fn","map","i","length","previous","WorkPipeline","work","BaseResult","resolve","reject","Error","data","PluginEventResult","id","LOG_LEVELS","RANK","isLogLevel","value","resolveLevel","globalThis","g","process","debug","env","level","rank","setLogLevel","next","getLogLevel","resetLogLevel","isLogLevelEnabled","at","emit","method","args","console","SyncronousQueue","unitOfWork"],"mappings":"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"}