@routier/core 0.2.1 → 0.4.0

package/dist/utilities/index.js

@@ -1,27 +1,12 @@
 var __webpack_modules__ = ({
-"./src/assertions/index.ts"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-__webpack_require__.r(__webpack_exports__);
+126(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 __webpack_require__.d(__webpack_exports__, {
-  assertDate: () => (assertDate),
-  assertInstanceOf: () => (assertInstanceOf),
-  assertIsArray: () => (assertIsArray),
-  assertIsNotNull: () => (assertIsNotNull),
-  assertIsNumber: () => (assertIsNumber),
-  assertString: () => (assertString),
-  isComparatorExpression: () => (isComparatorExpression),
-  isEmptyExpression: () => (isEmptyExpression),
-  isExpression: () => (isExpression),
-  isNotParsableExpression: () => (isNotParsableExpression),
-  isOperatorExpression: () => (isOperatorExpression),
-  isPropertyExpression: () => (isPropertyExpression),
-  isValueExpression: () => (isValueExpression)
+  e3: () => (isPropertyExpression)
 });
-/* import */ var _expressions_constants__rspack_import_1 = __webpack_require__("./src/expressions/constants.ts");
-/* import */ var _utilities__rspack_import_0 = __webpack_require__("./src/utilities/dates.ts");
 
 
 function assertDate(data) {
-    if ((0,_utilities__rspack_import_0.isDate)(data) === false) {
+    if (isDate(data) === false) {
         throw new TypeError('Value is not a Date');
     }
 }
@@ -65,77 +50,51 @@ function isObjectWithType(value) {
 }
 /**
  * Type guard: narrows `value` to `Expression` when it is an object with a valid `type` property.
- */
-function isExpression(value) {
-    return isObjectWithType(value) && _expressions_constants__rspack_import_1.EXPRESSION_TYPES.includes(value.type);
+ */ function isExpression(value) {
+    return isObjectWithType(value) && EXPRESSION_TYPES.includes(value.type);
 }
 /**
  * Type guard: narrows `value` to `OperatorExpression` when it is an object with `type === "operator"`.
- */
-function isOperatorExpression(value) {
+ */ function isOperatorExpression(value) {
     return isObjectWithType(value) && value.type === "operator";
 }
 /**
  * Type guard: narrows `value` to `ComparatorExpression` when it is an object with `type === "comparator"`.
- */
-function isComparatorExpression(value) {
+ */ function isComparatorExpression(value) {
     return isObjectWithType(value) && value.type === "comparator";
 }
 /**
  * Type guard: narrows `value` to `PropertyExpression` when it is an object with `type === "property"`.
- */
-function isPropertyExpression(value) {
+ */ function isPropertyExpression(value) {
     return isObjectWithType(value) && value.type === "property";
 }
 /**
  * Type guard: narrows `value` to `ValueExpression` when it is an object with `type === "value"`.
- */
-function isValueExpression(value) {
+ */ function isValueExpression(value) {
     return isObjectWithType(value) && value.type === "value";
 }
 /**
  * Type guard: narrows `value` to `EmptyExpression` when it is an object with `type === "empty"`.
- */
-function isEmptyExpression(value) {
+ */ function isEmptyExpression(value) {
     return isObjectWithType(value) && value.type === "empty";
 }
 /**
  * Type guard: narrows `value` to `NotParsableExpression` when it is an object with `type === "not-parsable"`.
- */
-function isNotParsableExpression(value) {
+ */ function isNotParsableExpression(value) {
     return isObjectWithType(value) && value.type === "not-parsable";
 }
 
 
 },
-"./src/expressions/constants.ts"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-__webpack_require__.r(__webpack_exports__);
+63(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 __webpack_require__.d(__webpack_exports__, {
-  EXPRESSION_TYPES: () => (EXPRESSION_TYPES)
-});
-const EXPRESSION_TYPES = [
-    "operator",
-    "comparator",
-    "property",
-    "value",
-    "empty",
-    "not-parsable",
-];
-
-
-},
-"./src/expressions/utils.ts"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-  forEach: () => (forEach),
-  getProperties: () => (getProperties)
+  j: () => (forEach)
 });
 /**
  * Extracts all properties referenced in an expression
  * @param expression The expression to analyze
  * @returns Array of PropertyInfo objects referenced in the expression
- */
-function getProperties(expression) {
+ */ function getProperties(expression) {
     const properties = [];
     function traverse(expr) {
         // If this is a property expression, add it to our collection
@@ -178,20 +137,37 @@ function forEach(expression, callback) {
 
 
 },
-"./src/plugins/query/QueryOptionsCollection.ts"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-__webpack_require__.r(__webpack_exports__);
+198(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 __webpack_require__.d(__webpack_exports__, {
-  QueryOptionsCollection: () => (QueryOptionsCollection)
+  H: () => (QueryOptionsCollection)
 });
-/* import */ var _assertions__rspack_import_1 = __webpack_require__("./src/assertions/index.ts");
-/* import */ var _expressions_utils__rspack_import_0 = __webpack_require__("./src/expressions/utils.ts");
+/* import */ var _assertions__rspack_import_1 = __webpack_require__(126);
+/* import */ var _expressions_utils__rspack_import_0 = __webpack_require__(63);
 
 
 class QueryOptionsCollection {
     options = new Map();
     nextExecutionTarget = "database";
+    nextExecutionReason = null;
     nextIndex = 0;
     enumeratedItems = [];
+    /** Cuts over to memory execution, keeping the first cause. See `MemoryExecutionReason`. */ cutOverToMemory(reason) {
+        this.nextExecutionTarget = "memory";
+        if (this.nextExecutionReason == null) {
+            this.nextExecutionReason = reason;
+        }
+    }
+    /**
+     * True when `split()` or `splitAt()` produced this collection.
+     *
+     * Those rebuild each half by re-adding its options, which re-derives execution targets
+     * without the options that caused them — a post-join filter alone in the memory half
+     * derives back to `"database"`. Anything reading `target` as a report of where work runs
+     * has to reject a derived collection; see `explainQuery`.
+     */ derived = false;
+    get isDerived() {
+        return this.derived;
+    }
     get items() {
         return this.options;
     }
@@ -209,48 +185,187 @@ class QueryOptionsCollection {
             const mapValue = value;
             // Evaluate the map value to see if we are renaming properties, 
             // if we are we need to perform everything after in memory
-            if (mapValue.fields.some(x => x.isRename === true) || mapValue.fields.some(x => x.property?.isUnmapped === true)) {
+            if (mapValue.fields.some((x)=>x.isRename === true) || mapValue.fields.some((x)=>x.property?.isUnmapped === true)) {
                 // Cut over to memory execution since we are renaming a property with .map
                 // We do not want to figure out how the new name flows through the entire query
-                this.nextExecutionTarget = "memory";
+                this.cutOverToMemory("map-rename");
             }
         }
         if (name === "filter") {
-            // Need to check for unmapped properties
+            // Need to check for unmapped and renamed properties
             const filterValue = value;
-            if (filterValue.expression.type === "not-parsable") {
-                this.nextExecutionTarget = "memory";
+            // A tautology (`x => true`) filters nothing — skip it entirely so
+            // plugins never see it
+            if (filterValue.expression.type === "empty") {
+                return;
             }
-            else {
-                (0,_expressions_utils__rspack_import_0.forEach)(filterValue.expression, (expression) => {
-                    if ((0,_assertions__rspack_import_1.isPropertyExpression)(expression) && expression.property.isUnmapped) {
+            if (filterValue.expression.type === "not-parsable") {
+                this.cutOverToMemory("not-parsable");
+            } else {
+                (0,_expressions_utils__rspack_import_0/* .forEach */.j)(filterValue.expression, (expression)=>{
+                    if ((0,_assertions__rspack_import_1/* .isPropertyExpression */.e3)(expression) && expression.property.isUnmapped) {
                         // Cut over to memory execution, unmapped properties are not in the database and
                         // cannot be queried
-                        this.nextExecutionTarget = "memory";
+                        this.cutOverToMemory("unmapped-property");
+                        return false;
+                    }
+                    if ((0,_assertions__rspack_import_1/* .isPropertyExpression */.e3)(expression) && expression.property.hasRenamedSegments) {
+                        // Cut over to memory execution: the plugin stores data under the
+                        // `from` (storage) names, but filter selectors reference the
+                        // in-memory names.  Memory execution runs after deserialization,
+                        // where the in-memory names exist
+                        this.cutOverToMemory("renamed-property");
                         return false;
                     }
                     return true;
                 });
             }
         }
+        if (name === "sort") {
+            const sortValue = value;
+            // Same rule as filters: sort selectors reference in-memory names, which
+            // only exist after deserialization when the property is renamed or unmapped
+            if (sortValue.property != null && sortValue.property.isUnmapped) {
+                this.cutOverToMemory("unmapped-property");
+            } else if (sortValue.property != null && sortValue.property.hasRenamedSegments) {
+                this.cutOverToMemory("renamed-property");
+            }
+        }
+        if (name === "nearest") {
+            const nearestValue = value;
+            // Same rule as sort, and for the same reason: the plugin stores the vector under
+            // the `from` name, and an unmapped property is not stored at all. Both are only
+            // readable after deserialization, which is where memory execution runs.
+            //
+            // This is also what lets every translator's in-memory fallback read the column by
+            // its resolved name — anything whose storage name differs never reaches them.
+            if (nearestValue.property != null && nearestValue.property.isUnmapped) {
+                this.cutOverToMemory("unmapped-property");
+            } else if (nearestValue.property != null && nearestValue.property.hasRenamedSegments) {
+                this.cutOverToMemory("renamed-property");
+            }
+        }
+        if (name === "join") {
+            const joinValue = value;
+            // A join whose two sides live on different plugins cannot be sent to EITHER of
+            // them — neither can read the other's rows — so the option itself belongs to the
+            // memory half, where the datastore interprets it.
+            //
+            // Set BEFORE the item is created, unlike `nearest`'s ratchet below, because this
+            // moves the join option itself rather than everything after it.
+            if (joinValue.crossPlugin === true) {
+                this.cutOverToMemory("cross-plugin-join");
+            }
+        }
         const item = {
             index: this.nextIndex,
             option: {
                 name,
                 target: this.nextExecutionTarget,
-                value
+                value,
+                ...this.nextExecutionReason == null ? {} : {
+                    reason: this.nextExecutionReason
+                }
             }
         };
         this.nextIndex++;
         const found = this.options.get(name);
-        this.options.set(name, [...found ?? [], item]);
+        this.options.set(name, [
+            ...found ?? [],
+            item
+        ]);
+        if (name === "nearest") {
+            // Everything AFTER a similarity search runs in memory, whatever the backend.
+            //
+            // Whether the search was pushed down is a fact about the plugin, which this
+            // collection cannot see — so a later option is only safe if it runs after the
+            // scoring definitely happened, and in memory is the only place that is true of.
+            //
+            // The failure this prevents is silent. `.nearest(x => x.embedding, v, 10).take(3)`
+            // sends `LIMIT 3` to a backend that ignored the ordering, so three arbitrary rows
+            // come back and get scored — three real rows, in a plausible order, and not the
+            // three nearest. Nothing errors.
+            //
+            // A plugin that DID push the search down loses nothing but the chance to also
+            // push down what follows it, which is a limit over ten rows.
+            this.cutOverToMemory("after-nearest");
+        }
+        if (name === "join") {
+            // Everything AFTER a join runs in memory, for the same reason as `nearest`: this
+            // collection cannot see HOW the plugin executed the join, and the rows it produced
+            // are TUPLES rather than entities of the root schema.
+            //
+            // A `take` sent to a backend that hash-joined in its translator would limit the
+            // OUTER rows read, not the pairs produced — a plausible-looking result with the
+            // wrong number of rows in it. Conjuncts that can safely run earlier are split off
+            // by the query builder BEFORE dispatch, which is the only exception.
+            this.cutOverToMemory("after-join");
+        }
+    }
+    /**
+     * Splits the collection around the FIRST occurrence of `name`, preserving order.
+     *
+     * For a join: the options recorded before it operate on entity rows, the option itself
+     * produces tuples, and the ones after it operate on tuples. Three different shapes, so the
+     * caller has to run them in three steps rather than one pass.
+     */ splitAt(name) {
+        this.resolveEnumeration();
+        const sortedItems = this.enumeratedItems.toSorted((a, b)=>a.index - b.index);
+        const before = new QueryOptionsCollection();
+        const after = new QueryOptionsCollection();
+        before.derived = true;
+        after.derived = true;
+        let at = null;
+        for(let i = 0, length = sortedItems.length; i < length; i++){
+            const { option } = sortedItems[i];
+            if (at == null && option.name === name) {
+                at = option;
+                continue;
+            }
+            const destination = at == null ? before : after;
+            destination.add(option.name, option.value);
+        }
+        return {
+            before,
+            at,
+            after
+        };
+    }
+    /**
+     * Captures the collection's current state and returns a function that restores it.
+     *
+     * Terminal queryable operations (count, first, aggregates, …) record their option on
+     * the shared collection before executing. Without restoring, a re-executed terminal —
+     * the whole point of a subscribed queryable — stacks its option a second time and
+     * runs it over the first execution's scalar result.
+     */ snapshot() {
+        const options = new Map([
+            ...this.options.entries()
+        ].map(([key, items])=>[
+                key,
+                [
+                    ...items
+                ]
+            ]));
+        const nextExecutionTarget = this.nextExecutionTarget;
+        const nextExecutionReason = this.nextExecutionReason;
+        const nextIndex = this.nextIndex;
+        return ()=>{
+            this.options = new Map(options);
+            this.nextExecutionTarget = nextExecutionTarget;
+            this.nextExecutionReason = nextExecutionReason;
+            this.nextIndex = nextIndex;
+            this.enumeratedItems = [];
+        };
     }
     split() {
         this.resolveEnumeration();
-        const sortedItems = this.enumeratedItems.toSorted((a, b) => a.index - b.index);
+        const sortedItems = this.enumeratedItems.toSorted((a, b)=>a.index - b.index);
         const memoryQueryOptionsCollection = new QueryOptionsCollection();
         const databaseQueryOptionsCollection = new QueryOptionsCollection();
-        for (let i = 0, length = sortedItems.length; i < length; i++) {
+        memoryQueryOptionsCollection.derived = true;
+        databaseQueryOptionsCollection.derived = true;
+        for(let i = 0, length = sortedItems.length; i < length; i++){
             const sortedItem = sortedItems[i];
             if (sortedItem.option.target === "database") {
                 databaseQueryOptionsCollection.add(sortedItem.option.name, sortedItem.option.value);
@@ -264,8 +379,15 @@ class QueryOptionsCollection {
         };
     }
     hasTransformations() {
-        const transformationOptions = ["map", "group", "min", "max", "count", "sum"];
-        return transformationOptions.some((name) => this.options.has(name));
+        const transformationOptions = [
+            "map",
+            "group",
+            "min",
+            "max",
+            "count",
+            "sum"
+        ];
+        return transformationOptions.some((name)=>this.options.has(name));
     }
     has(name) {
         return this.options.has(name);
@@ -275,7 +397,7 @@ class QueryOptionsCollection {
     }
     getLast(name) {
         this.resolveEnumeration();
-        for (let i = this.enumeratedItems.length - 1; i >= 0; i--) {
+        for(let i = this.enumeratedItems.length - 1; i >= 0; i--){
             const item = this.enumeratedItems[i];
             if (item.option.name === name) {
                 return item.option;
@@ -288,10 +410,12 @@ class QueryOptionsCollection {
         if (found == null) {
             return [];
         }
-        return found.map(w => w.option.value);
+        return found.map((w)=>w.option.value);
     }
     getEnumeration() {
-        return [...this.options.values()].flat().toSorted((a, b) => a.index - b.index);
+        return [
+            ...this.options.values()
+        ].flat().toSorted((a, b)=>a.index - b.index);
     }
     resolveEnumeration() {
         if (this.enumeratedItems.length != this.nextIndex) {
@@ -300,7 +424,7 @@ class QueryOptionsCollection {
     }
     forEach(iterator) {
         this.resolveEnumeration();
-        for (let i = 0, length = this.enumeratedItems.length; i < length; i++) {
+        for(let i = 0, length = this.enumeratedItems.length; i < length; i++){
             iterator(this.enumeratedItems[i].option);
         }
     }
@@ -308,29 +432,11 @@ class QueryOptionsCollection {
 
 
 },
-"./src/utilities/arrays.ts"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-__webpack_require__.r(__webpack_exports__);
+76(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 __webpack_require__.d(__webpack_exports__, {
-  toMap: () => (toMap)
+  $: () => (isDate)
 });
-const toMap = (data, keySelector) => {
-    const result = new Map();
-    for (let i = 0; i < data.length; i++) {
-        const item = data[i];
-        const key = keySelector(item);
-        result.set(key, item);
-    }
-    return result;
-};
-
-
-},
-"./src/utilities/dates.ts"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-  isDate: () => (isDate)
-});
-const isDate = (data) => {
+const isDate = (data)=>{
     if (data == null) {
         return false;
     }
@@ -342,211 +448,178 @@ const isDate = (data) => {
 
 
 },
-"./src/utilities/dbPluginEventUtils.ts"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-__webpack_require__.r(__webpack_exports__);
+581(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 __webpack_require__.d(__webpack_exports__, {
-  toEventArray: () => (toEventArray)
+  Cg: () => (resetLogLevel),
+  He: () => (setLogLevel),
+  Mi: () => (isLogLevelEnabled),
+  XM: () => (getLogLevel),
+  p_: () => (LOG_LEVELS),
+  vF: () => (logger)
 });
-const toEventArray = (event) => {
-    const result = [];
-    for (const [schemaId, changes] of event.operation) {
-        if (changes.hasItems === false) {
-            continue;
-        }
-        if (changes.adds.length > 0) {
-            result.push(...changes.adds.map(add => {
-                return [schemaId, { data: { ...add }, type: "add" }];
-            }));
-        }
-        if (changes.updates.length > 0) {
-            result.push(...changes.updates.map(update => {
-                return [schemaId, { data: { ...update }, type: "update" }];
-            }));
-        }
-        if (changes.removes.length > 0) {
-            result.push(...changes.removes.map(remove => {
-                return [schemaId, { data: { ...remove }, type: "remove" }];
-            }));
-        }
-    }
-    return result;
+/**
+ * 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
 };
-
-
-},
-"./src/utilities/functions.ts"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-  noop: () => (noop)
-});
-const noop = (..._args) => { };
-
-
-},
-"./src/utilities/logger.ts"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-  logger: () => (logger)
-});
+const isLogLevel = (value)=>typeof value === 'string' && LOG_LEVELS.includes(value);
 /**
- * Enable logging by setting `globalThis.__ROUTIER_DEBUG__ = true` before any routier code runs.
- */
-const shouldLog = () => {
+ * 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 (g.__ROUTIER_DEBUG__ === true)
-            return true;
-    }
+        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 true;
-        const env = "development"?.toLowerCase();
-        if (env === 'dev' || env === 'development' || env === 'test')
-            return true;
-    }
-    return false;
-};
-const tryLog = (type, ...args) => {
-    if (shouldLog()) {
-        console[type](...args);
-    }
+        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';
 };
-const logger = {
-    log: (...args) => {
-        tryLog("log", ...args);
-    },
-    info: (...args) => {
-        tryLog("info", ...args);
-    },
-    warn: (...args) => {
-        tryLog("warn", ...args);
-    },
-    error: (...args) => {
-        tryLog("error", ...args);
-    },
-    debug: (...args) => {
-        tryLog("debug", ...args);
-    },
-    table: (...args) => {
-        tryLog("table", ...args);
-    },
+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];
 };
-
-
-},
-"./src/utilities/objects.ts"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-  cast: () => (cast),
-  clone: () => (clone)
-});
-const cast = (item) => {
-    return item;
+const getLogLevel = ()=>level;
+/** Re-reads the environment. For tests that change it after this module was imported. */ const resetLogLevel = ()=>{
+    level = resolveLevel();
+    rank = RANK[level];
 };
-function clone(data) {
-    return JSON.parse(JSON.stringify(data));
-}
-
-
-},
-"./src/utilities/queryOptionsCollection.ts"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-  combineQueryOptionsCollections: () => (combineQueryOptionsCollections)
-});
-/* import */ var _plugins_query__rspack_import_0 = __webpack_require__("./src/plugins/query/QueryOptionsCollection.ts");
-
-const combineQueryOptionsCollections = (...collections) => {
-    const result = new _plugins_query__rspack_import_0.QueryOptionsCollection();
-    for (let i = 0, length = collections.length; i < length; i++) {
-        const collection = collections[i];
-        // Add scoped items first
-        collection.forEach(item => {
-            result.add(item.name, item.value);
-        });
+/**
+ * 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;
     }
-    return result;
+    // 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);
 };
-
-
-},
-"./src/utilities/replication.ts"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-  resolveBulkPersistChanges: () => (resolveBulkPersistChanges)
-});
-const resolveBulkPersistChanges = (event, result, bulkPersistChanges) => {
-    // make sure we swap the adds here, that way we can make sure other persist events
-    // don't take their additions and try to change subsequent calls
-    for (const [schemaId, changes] of event.operation) {
-        const schemmaBulkPersistResult = result.get(schemaId);
-        const schemaBulkPersistChanges = bulkPersistChanges.resolve(schemaId);
-        // Set the original removes
-        schemaBulkPersistChanges.removes = changes.removes;
-        // Set the original updates
-        schemaBulkPersistChanges.updates = changes.updates;
-        // Take the adds from the result and set them to be persisted
-        // in the replicated plugins because the id's are set in the 
-        // memory data store
-        schemaBulkPersistChanges.adds = schemmaBulkPersistResult.adds;
-    }
+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)
 };
 
 
 },
-"./src/utilities/runtime.ts"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-__webpack_require__.r(__webpack_exports__);
+615(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 __webpack_require__.d(__webpack_exports__, {
-  isNodeRuntime: () => (isNodeRuntime)
+  Nr: () => (fastHash),
+  Zm: () => (stringifyObject),
+  tW: () => (hash)
 });
-const isNodeRuntime = () => typeof process !== 'undefined' &&
-    process.versions != null &&
-    process.versions.node != null;
-
-
-},
-"./src/utilities/strings.ts"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-  fastHash: () => (fastHash),
-  hash: () => (hash),
-  stringifyObject: () => (stringifyObject)
-});
-const hash = (value, seed = 0) => {
+const hash = (value, seed = 0)=>{
     // From Stack Overflow
     // https://stackoverflow.com/a/52171480/3329760
     let h1 = 0xdeadbeef ^ seed, h2 = 0x41c6ce57 ^ seed;
-    for (let i = 0, ch; i < value.length; i++) {
+    for(let i = 0, ch; i < value.length; i++){
         ch = value.charCodeAt(i);
         h1 = Math.imul(h1 ^ ch, 2654435761);
         h2 = Math.imul(h2 ^ ch, 1597334677);
     }
-    h1 = Math.imul(h1 ^ (h1 >>> 16), 2246822507);
-    h1 ^= Math.imul(h2 ^ (h2 >>> 13), 3266489909);
-    h2 = Math.imul(h2 ^ (h2 >>> 16), 2246822507);
-    h2 ^= Math.imul(h1 ^ (h1 >>> 13), 3266489909);
+    h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507);
+    h1 ^= Math.imul(h2 ^ h2 >>> 13, 3266489909);
+    h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507);
+    h2 ^= Math.imul(h1 ^ h1 >>> 13, 3266489909);
     return 4294967296 * (2097151 & h2) + (h1 >>> 0);
 };
 /**
  * Fast string hash optimized for comparisons.
  * Uses djb2 algorithm - very fast and good distribution for short to medium strings.
  * Same input always produces same output (deterministic).
- *
+ * 
  * @param value - The string to hash
  * @param seed - Optional seed value (default: 5381)
  * @returns A positive 32-bit integer hash value
- *
+ * 
  * @example
  * ```ts
  * fastHash("test") === fastHash("test") // true
  * fastHash("test") !== fastHash("test2") // true
  * ```
- */
-const fastHash = (value, seed = 5381) => {
+ */ const fastHash = (value, seed = 5381)=>{
     let hash = seed;
-    for (let i = 0; i < value.length; i++) {
-        hash = ((hash << 5) + hash) + value.charCodeAt(i);
+    for(let i = 0; i < value.length; i++){
+        hash = (hash << 5) + hash + value.charCodeAt(i);
     }
     return hash >>> 0; // Convert to unsigned 32-bit integer
 };
@@ -554,26 +627,23 @@ const fastHash = (value, seed = 5381) => {
  * Converts any value to a readable string representation.
  * Handles primitives, objects, arrays, classes, dates, errors, and functions.
  * Supports depth limiting to prevent infinite recursion on circular references.
- *
+ * 
  * @param obj - The value to stringify
  * @param maxDepth - Maximum depth for nested objects (default: 3)
  * @param currentDepth - Current recursion depth (default: 0)
  * @returns String representation of the value
- *
+ * 
  * @example
  * ```ts
  * stringifyObject({ name: "test", count: 5 }) // '{ name: "test", count: 5 }'
  * stringifyObject([1, 2, 3]) // '[1, 2, 3]'
  * stringifyObject(new Date()) // 'Date(2024-01-01T00:00:00.000Z)'
  * ```
- */
-function stringifyObject(obj, maxDepth = 3, currentDepth = 0) {
-    if (obj === null)
-        return 'null';
-    if (obj === undefined)
-        return 'undefined';
+ */ function stringifyObject(obj, maxDepth = 3, currentDepth = 0) {
+    if (obj === null) return 'null';
+    if (obj === undefined) return 'undefined';
     const type = typeof obj;
-    switch (type) {
+    switch(type){
         case 'string':
             return `"${obj}"`;
         case 'number':
@@ -596,7 +666,7 @@ function getFunctionName(fn) {
 }
 function getObjectProperties(obj) {
     const properties = {};
-    for (const key in obj) {
+    for(const key in obj){
         if (obj.hasOwnProperty(key)) {
             properties[key] = obj[key];
         }
@@ -604,8 +674,7 @@ function getObjectProperties(obj) {
     return properties;
 }
 function stringifyObjectValue(obj, maxDepth, currentDepth) {
-    if (obj === null)
-        return 'null';
+    if (obj === null) return 'null';
     if (obj instanceof Date) {
         return `Date(${obj.toISOString()})`;
     }
@@ -624,9 +693,8 @@ function stringifyObjectValue(obj, maxDepth, currentDepth) {
     return stringifyPlainObject(obj, maxDepth, currentDepth);
 }
 function stringifyArray(arr, maxDepth, currentDepth) {
-    if (arr.length === 0)
-        return '[]';
-    const items = arr.slice(0, 5).map(item => stringifyObject(item, maxDepth, currentDepth + 1));
+    if (arr.length === 0) return '[]';
+    const items = arr.slice(0, 5).map((item)=>stringifyObject(item, maxDepth, currentDepth + 1));
     const suffix = arr.length > 5 ? `... (+${arr.length - 5} more)` : '';
     return `[${items.join(', ')}${suffix}]`;
 }
@@ -636,16 +704,12 @@ function stringifyClassInstance(obj, maxDepth, currentDepth) {
     if (Object.keys(properties).length === 0) {
         return `${className} {}`;
     }
-    const props = Object.entries(properties)
-        .slice(0, 5)
-        .map(([key, value]) => {
-        const isPrimitive = value === null || value === undefined ||
-            (typeof value !== 'object' && typeof value !== 'function');
+    const props = Object.entries(properties).slice(0, 5).map(([key, value])=>{
+        const isPrimitive = value === null || value === undefined || typeof value !== 'object' && typeof value !== 'function';
         const depth = isPrimitive ? currentDepth : currentDepth + 1;
         return `${key}: ${stringifyObject(value, maxDepth, depth)}`;
     });
-    const suffix = Object.keys(properties).length > 5 ?
-        `... (+${Object.keys(properties).length - 5} more)` : '';
+    const suffix = Object.keys(properties).length > 5 ? `... (+${Object.keys(properties).length - 5} more)` : '';
     return `${className} { ${props.join(', ')}${suffix} }`;
 }
 function stringifyPlainObject(obj, maxDepth, currentDepth) {
@@ -653,43 +717,27 @@ function stringifyPlainObject(obj, maxDepth, currentDepth) {
     if (Object.keys(properties).length === 0) {
         return '{}';
     }
-    const props = Object.entries(properties)
-        .slice(0, 5)
-        .map(([key, value]) => {
-        const isPrimitive = value === null || value === undefined ||
-            (typeof value !== 'object' && typeof value !== 'function');
+    const props = Object.entries(properties).slice(0, 5).map(([key, value])=>{
+        const isPrimitive = value === null || value === undefined || typeof value !== 'object' && typeof value !== 'function';
         const depth = isPrimitive ? currentDepth : currentDepth + 1;
         return `${key}: ${stringifyObject(value, maxDepth, depth)}`;
     });
-    const suffix = Object.keys(properties).length > 5 ?
-        `... (+${Object.keys(properties).length - 5} more)` : '';
+    const suffix = Object.keys(properties).length > 5 ? `... (+${Object.keys(properties).length - 5} more)` : '';
     return `{ ${props.join(', ')}${suffix} }`;
 }
 
 
 },
-"./src/utilities/unsafeCast.ts"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-__webpack_require__.r(__webpack_exports__);
+618(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 __webpack_require__.d(__webpack_exports__, {
-  unsafeCast: () => (unsafeCast)
+  g: () => (uuidv4),
+  u: () => (uuid)
 });
-const unsafeCast = (value) => {
-    return value;
-};
-
-
-},
-"./src/utilities/uuid.ts"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-  uuid: () => (uuid),
-  uuidv4: () => (uuidv4)
-});
-const uuid = (length = 16) => {
+const uuid = (length = 16)=>{
     const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
     const charLength = chars.length;
     let result = '';
-    for (let i = 0; i < length; i++) {
+    for(let i = 0; i < length; i++){
         result += chars[Math.random() * charLength | 0];
     }
     return result;
@@ -697,14 +745,21 @@ const uuid = (length = 16) => {
 const HEX_CHARS = '0123456789abcdef';
 const UUID_TEMPLATE = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx';
 const hasCrypto = typeof crypto !== 'undefined' && typeof crypto.getRandomValues === 'function';
-const uuidv4 = () => {
+const hasRandomUUID = typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function';
+const uuidv4 = ()=>{
+    if (hasRandomUUID) {
+        return crypto.randomUUID();
+    }
+    return uuidv4Fallback();
+};
+const uuidv4Fallback = ()=>{
     let randomBytes = null;
     if (hasCrypto) {
         randomBytes = crypto.getRandomValues(new Uint8Array(16));
     }
     let byteIndex = 0;
     let uuid = '';
-    for (let i = 0; i < UUID_TEMPLATE.length; i++) {
+    for(let i = 0; i < UUID_TEMPLATE.length; i++){
         const c = UUID_TEMPLATE[i];
         if (c === '-') {
             uuid += '-';
@@ -713,22 +768,16 @@ const uuidv4 = () => {
         let r;
         if (hasCrypto && randomBytes) {
             // Each byte gives two hex digits (nibbles)
-            r =
-                (i % 2 === 0
-                    ? randomBytes[byteIndex] >> 4
-                    : randomBytes[byteIndex++] & 0x0f);
-        }
-        else {
+            r = i % 2 === 0 ? randomBytes[byteIndex] >> 4 : randomBytes[byteIndex++] & 0x0f;
+        } else {
             r = Math.floor(Math.random() * 16);
         }
         if (c === 'x') {
             uuid += HEX_CHARS[r];
-        }
-        else if (c === 'y') {
+        } else if (c === 'y') {
             // Variant bits: 8, 9, A, or B
-            uuid += HEX_CHARS[(r & 0x3) | 0x8];
-        }
-        else if (c === '4') {
+            uuid += HEX_CHARS[r & 0x3 | 0x8];
+        } else if (c === '4') {
             uuid += '4';
         }
     }
@@ -776,50 +825,158 @@ __webpack_require__.d = (exports, definition) => {
 (() => {
 __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.
 (() => {
-__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
 __webpack_require__.d(__webpack_exports__, {
-  cast: () => (/* reexport safe */ _objects__rspack_import_3.cast),
-  clone: () => (/* reexport safe */ _objects__rspack_import_3.clone),
-  combineQueryOptionsCollections: () => (/* reexport safe */ _queryOptionsCollection__rspack_import_7.combineQueryOptionsCollections),
-  fastHash: () => (/* reexport safe */ _strings__rspack_import_1.fastHash),
-  hash: () => (/* reexport safe */ _strings__rspack_import_1.hash),
-  isDate: () => (/* reexport safe */ _dates__rspack_import_2.isDate),
-  isNodeRuntime: () => (/* reexport safe */ _runtime__rspack_import_4.isNodeRuntime),
-  logger: () => (/* reexport safe */ _logger__rspack_import_11.logger),
-  noop: () => (/* reexport safe */ _functions__rspack_import_9.noop),
-  resolveBulkPersistChanges: () => (/* reexport safe */ _replication__rspack_import_6.resolveBulkPersistChanges),
-  stringifyObject: () => (/* reexport safe */ _strings__rspack_import_1.stringifyObject),
-  toEventArray: () => (/* reexport safe */ _dbPluginEventUtils__rspack_import_8.toEventArray),
-  toMap: () => (/* reexport safe */ _arrays__rspack_import_0.toMap),
-  unsafeCast: () => (/* reexport safe */ _unsafeCast__rspack_import_10.unsafeCast),
-  uuid: () => (/* reexport safe */ _uuid__rspack_import_5.uuid),
-  uuidv4: () => (/* reexport safe */ _uuid__rspack_import_5.uuidv4)
+  N8: () => (/* reexport */ combineQueryOptionsCollections),
+  tW: () => (/* reexport */ strings/* .hash */.tW),
+  vF: () => (/* reexport */ logger/* .logger */.vF),
+  lQ: () => (/* reexport */ noop),
+  He: () => (/* reexport */ logger/* .setLogLevel */.He),
+  Nr: () => (/* reexport */ strings/* .fastHash */.Nr),
+  uR: () => (/* reexport */ uuid/* .uuid */.u),
+  p_: () => (/* reexport */ logger/* .LOG_LEVELS */.p_),
+  XM: () => (/* reexport */ logger/* .getLogLevel */.XM),
+  Cg: () => (/* reexport */ logger/* .resetLogLevel */.Cg),
+  Zm: () => (/* reexport */ strings/* .stringifyObject */.Zm),
+  av: () => (/* reexport */ toMap),
+  wg: () => (/* reexport */ cast),
+  $P: () => (/* reexport */ dates/* .isDate */.$),
+  Vg: () => (/* reexport */ toEventArray),
+  sz: () => (/* reexport */ unsafeCast),
+  Mi: () => (/* reexport */ logger/* .isLogLevelEnabled */.Mi),
+  ap: () => (/* reexport */ resolveBulkPersistChanges),
+  tX: () => (/* reexport */ isNodeRuntime),
+  gZ: () => (/* reexport */ uuid/* .uuidv4 */.g),
+  o8: () => (/* reexport */ clone)
 });
-/* import */ var _arrays__rspack_import_0 = __webpack_require__("./src/utilities/arrays.ts");
-/* import */ var _strings__rspack_import_1 = __webpack_require__("./src/utilities/strings.ts");
-/* import */ var _dates__rspack_import_2 = __webpack_require__("./src/utilities/dates.ts");
-/* import */ var _objects__rspack_import_3 = __webpack_require__("./src/utilities/objects.ts");
-/* import */ var _runtime__rspack_import_4 = __webpack_require__("./src/utilities/runtime.ts");
-/* import */ var _uuid__rspack_import_5 = __webpack_require__("./src/utilities/uuid.ts");
-/* import */ var _replication__rspack_import_6 = __webpack_require__("./src/utilities/replication.ts");
-/* import */ var _queryOptionsCollection__rspack_import_7 = __webpack_require__("./src/utilities/queryOptionsCollection.ts");
-/* import */ var _dbPluginEventUtils__rspack_import_8 = __webpack_require__("./src/utilities/dbPluginEventUtils.ts");
-/* import */ var _functions__rspack_import_9 = __webpack_require__("./src/utilities/functions.ts");
-/* import */ var _unsafeCast__rspack_import_10 = __webpack_require__("./src/utilities/unsafeCast.ts");
-/* import */ var _logger__rspack_import_11 = __webpack_require__("./src/utilities/logger.ts");
+
+;// CONCATENATED MODULE: ./src/utilities/arrays.ts
+const toMap = (data, keySelector)=>{
+    const result = new Map();
+    for(let i = 0; i < data.length; i++){
+        const item = data[i];
+        const key = keySelector(item);
+        result.set(key, item);
+    }
+    return result;
+};
+
+// EXTERNAL MODULE: ./src/utilities/strings.ts
+var strings = __webpack_require__(615);
+// EXTERNAL MODULE: ./src/utilities/dates.ts
+var dates = __webpack_require__(76);
+;// CONCATENATED MODULE: ./src/utilities/objects.ts
+const cast = (item)=>{
+    return item;
+};
+function clone(data) {
+    return JSON.parse(JSON.stringify(data));
+}
+
+;// CONCATENATED MODULE: ./src/utilities/runtime.ts
+const isNodeRuntime = ()=>typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
+
+// EXTERNAL MODULE: ./src/utilities/uuid.ts
+var uuid = __webpack_require__(618);
+;// CONCATENATED MODULE: ./src/utilities/replication.ts
+const resolveBulkPersistChanges = (event, result, bulkPersistChanges)=>{
+    // make sure we swap the adds here, that way we can make sure other persist events
+    // don't take their additions and try to change subsequent calls
+    for (const [schemaId, changes] of event.operation){
+        const schemmaBulkPersistResult = result.get(schemaId);
+        const schemaBulkPersistChanges = bulkPersistChanges.resolve(schemaId);
+        // Set the original removes
+        schemaBulkPersistChanges.removes = changes.removes;
+        // Set the original updates
+        schemaBulkPersistChanges.updates = changes.updates;
+        // Take the adds from the result and set them to be persisted
+        // in the replicated plugins because the id's are set in the 
+        // memory data store
+        schemaBulkPersistChanges.adds = schemmaBulkPersistResult.adds;
+    }
+};
+
+// EXTERNAL MODULE: ./src/plugins/query/QueryOptionsCollection.ts
+var QueryOptionsCollection = __webpack_require__(198);
+;// CONCATENATED MODULE: ./src/utilities/queryOptionsCollection.ts
+
+const combineQueryOptionsCollections = (...collections)=>{
+    const result = new QueryOptionsCollection/* .QueryOptionsCollection */.H();
+    for(let i = 0, length = collections.length; i < length; i++){
+        const collection = collections[i];
+        // Add scoped items first
+        collection.forEach((item)=>{
+            result.add(item.name, item.value);
+        });
+    }
+    return result;
+};
+
+;// CONCATENATED MODULE: ./src/utilities/dbPluginEventUtils.ts
+const toEventArray = (event)=>{
+    const result = [];
+    for (const [schemaId, changes] of event.operation){
+        if (changes.hasItems === false) {
+            continue;
+        }
+        if (changes.adds.length > 0) {
+            result.push(...changes.adds.map((add)=>{
+                return [
+                    schemaId,
+                    {
+                        data: {
+                            ...add
+                        },
+                        type: "add"
+                    }
+                ];
+            }));
+        }
+        if (changes.updates.length > 0) {
+            result.push(...changes.updates.map((update)=>{
+                return [
+                    schemaId,
+                    {
+                        data: {
+                            ...update
+                        },
+                        type: "update"
+                    }
+                ];
+            }));
+        }
+        if (changes.removes.length > 0) {
+            result.push(...changes.removes.map((remove)=>{
+                return [
+                    schemaId,
+                    {
+                        data: {
+                            ...remove
+                        },
+                        type: "remove"
+                    }
+                ];
+            }));
+        }
+    }
+    return result;
+};
+
+;// CONCATENATED MODULE: ./src/utilities/functions.ts
+const noop = (..._args)=>{};
+
+;// CONCATENATED MODULE: ./src/utilities/unsafeCast.ts
+const unsafeCast = (value)=>{
+    return value;
+};
+
+// EXTERNAL MODULE: ./src/utilities/logger.ts
+var logger = __webpack_require__(581);
+;// CONCATENATED MODULE: ./src/utilities/index.ts
 
 
 
@@ -836,22 +993,27 @@ __webpack_require__.d(__webpack_exports__, {
 
 })();
 
-var __webpack_exports__cast = __webpack_exports__.cast;
-var __webpack_exports__clone = __webpack_exports__.clone;
-var __webpack_exports__combineQueryOptionsCollections = __webpack_exports__.combineQueryOptionsCollections;
-var __webpack_exports__fastHash = __webpack_exports__.fastHash;
-var __webpack_exports__hash = __webpack_exports__.hash;
-var __webpack_exports__isDate = __webpack_exports__.isDate;
-var __webpack_exports__isNodeRuntime = __webpack_exports__.isNodeRuntime;
-var __webpack_exports__logger = __webpack_exports__.logger;
-var __webpack_exports__noop = __webpack_exports__.noop;
-var __webpack_exports__resolveBulkPersistChanges = __webpack_exports__.resolveBulkPersistChanges;
-var __webpack_exports__stringifyObject = __webpack_exports__.stringifyObject;
-var __webpack_exports__toEventArray = __webpack_exports__.toEventArray;
-var __webpack_exports__toMap = __webpack_exports__.toMap;
-var __webpack_exports__unsafeCast = __webpack_exports__.unsafeCast;
-var __webpack_exports__uuid = __webpack_exports__.uuid;
-var __webpack_exports__uuidv4 = __webpack_exports__.uuidv4;
-export { __webpack_exports__cast as cast, __webpack_exports__clone as clone, __webpack_exports__combineQueryOptionsCollections as combineQueryOptionsCollections, __webpack_exports__fastHash as fastHash, __webpack_exports__hash as hash, __webpack_exports__isDate as isDate, __webpack_exports__isNodeRuntime as isNodeRuntime, __webpack_exports__logger as logger, __webpack_exports__noop as noop, __webpack_exports__resolveBulkPersistChanges as resolveBulkPersistChanges, __webpack_exports__stringifyObject as stringifyObject, __webpack_exports__toEventArray as toEventArray, __webpack_exports__toMap as toMap, __webpack_exports__unsafeCast as unsafeCast, __webpack_exports__uuid as uuid, __webpack_exports__uuidv4 as uuidv4 };
+var __webpack_exports__LOG_LEVELS = __webpack_exports__.p_;
+var __webpack_exports__cast = __webpack_exports__.wg;
+var __webpack_exports__clone = __webpack_exports__.o8;
+var __webpack_exports__combineQueryOptionsCollections = __webpack_exports__.N8;
+var __webpack_exports__fastHash = __webpack_exports__.Nr;
+var __webpack_exports__getLogLevel = __webpack_exports__.XM;
+var __webpack_exports__hash = __webpack_exports__.tW;
+var __webpack_exports__isDate = __webpack_exports__.$P;
+var __webpack_exports__isLogLevelEnabled = __webpack_exports__.Mi;
+var __webpack_exports__isNodeRuntime = __webpack_exports__.tX;
+var __webpack_exports__logger = __webpack_exports__.vF;
+var __webpack_exports__noop = __webpack_exports__.lQ;
+var __webpack_exports__resetLogLevel = __webpack_exports__.Cg;
+var __webpack_exports__resolveBulkPersistChanges = __webpack_exports__.ap;
+var __webpack_exports__setLogLevel = __webpack_exports__.He;
+var __webpack_exports__stringifyObject = __webpack_exports__.Zm;
+var __webpack_exports__toEventArray = __webpack_exports__.Vg;
+var __webpack_exports__toMap = __webpack_exports__.av;
+var __webpack_exports__unsafeCast = __webpack_exports__.sz;
+var __webpack_exports__uuid = __webpack_exports__.uR;
+var __webpack_exports__uuidv4 = __webpack_exports__.gZ;
+export { __webpack_exports__LOG_LEVELS as LOG_LEVELS, __webpack_exports__cast as cast, __webpack_exports__clone as clone, __webpack_exports__combineQueryOptionsCollections as combineQueryOptionsCollections, __webpack_exports__fastHash as fastHash, __webpack_exports__getLogLevel as getLogLevel, __webpack_exports__hash as hash, __webpack_exports__isDate as isDate, __webpack_exports__isLogLevelEnabled as isLogLevelEnabled, __webpack_exports__isNodeRuntime as isNodeRuntime, __webpack_exports__logger as logger, __webpack_exports__noop as noop, __webpack_exports__resetLogLevel as resetLogLevel, __webpack_exports__resolveBulkPersistChanges as resolveBulkPersistChanges, __webpack_exports__setLogLevel as setLogLevel, __webpack_exports__stringifyObject as stringifyObject, __webpack_exports__toEventArray as toEventArray, __webpack_exports__toMap as toMap, __webpack_exports__unsafeCast as unsafeCast, __webpack_exports__uuid as uuid, __webpack_exports__uuidv4 as uuidv4 };
 
 //# sourceMappingURL=index.js.map