@open-mercato/shared 0.9.1-develop.7574.1.837288eec1 → 0.10.1-develop.7576.1.21d5b50435

package/dist/lib/bootstrap/next-subpath-resolve-hook.js

@@ -1,62 +0,0 @@
-import * as nodeModule from "node:module";
-const NEXT_BARE_SUBPATH = /^next\/[A-Za-z0-9_-]+$/;
-let installed = false;
-function isModuleNotFound(error) {
-  return Boolean(error) && typeof error === "object" && error.code === "ERR_MODULE_NOT_FOUND";
-}
-function resolveNextSubpath(specifier, context, nextResolve) {
-  if (!NEXT_BARE_SUBPATH.test(specifier)) return nextResolve(specifier, context);
-  try {
-    return nextResolve(specifier, context);
-  } catch (error) {
-    if (!isModuleNotFound(error)) throw error;
-    try {
-      return nextResolve(`${specifier}.js`, context);
-    } catch {
-      throw error;
-    }
-  }
-}
-async function resolveNextSubpathAsync(specifier, context, nextResolve) {
-  if (!NEXT_BARE_SUBPATH.test(specifier)) return nextResolve(specifier, context);
-  try {
-    return await nextResolve(specifier, context);
-  } catch (error) {
-    if (!isModuleNotFound(error)) throw error;
-    try {
-      return await nextResolve(`${specifier}.js`, context);
-    } catch {
-      throw error;
-    }
-  }
-}
-function runtimeRegisterHooks() {
-  const candidate = nodeModule.registerHooks;
-  return typeof candidate === "function" ? candidate : void 0;
-}
-function runtimeRegisterHookModule() {
-  const candidate = nodeModule.register;
-  return typeof candidate === "function" ? candidate : void 0;
-}
-function installNextSubpathResolveHook(registerHooks = runtimeRegisterHooks(), registerHookModule = runtimeRegisterHookModule()) {
-  if (installed) return false;
-  if (typeof registerHooks === "function") {
-    registerHooks({ resolve: resolveNextSubpath });
-  } else if (typeof registerHookModule === "function") {
-    registerHookModule(new URL("./next-subpath-resolve-hook-worker.js", import.meta.url), import.meta.url);
-  } else {
-    return false;
-  }
-  installed = true;
-  return true;
-}
-function resetNextSubpathResolveHookForTests() {
-  installed = false;
-}
-export {
-  installNextSubpathResolveHook,
-  resetNextSubpathResolveHookForTests,
-  resolveNextSubpath,
-  resolveNextSubpathAsync
-};
-//# sourceMappingURL=next-subpath-resolve-hook.js.map

package/dist/lib/bootstrap/next-subpath-resolve-hook.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/lib/bootstrap/next-subpath-resolve-hook.ts"],
-  "sourcesContent": ["/**\n * Node ESM resolution for `next/<subpath>` outside the Next bundler (#6118, #7102).\n *\n * Installed by the `mercato` CLI entry, so every CLI command and worker it\n * runs can load package dists that import `next/dynamic`, `next/link`,\n * `next/server` \u2026 The `next/dynamic` imports in particular MUST keep the bare\n * specifier: Next's `next_dynamic` compiler transform only matches it exactly.\n *\n * `mercato ai_assistant mcp:serve-http` (and `mcp:serve`, `mcp:dev`,\n * `mcp:list-tools`) run in plain Node, and the AI API operation runner loads\n * API route modules with a runtime `import()`. Those modules import\n * `NextResponse` from `'next/server'`: a bare package subpath that only a\n * bundler resolves, because `next` ships no `exports` map and Node's ESM\n * resolver does no extension guessing. Every route with that import (287 of\n * them on the 0.7.0 packages) therefore fails to load with\n * `ERR_MODULE_NOT_FOUND \u2026 node_modules/next/server`, and every tool backed by\n * such a route returns \"Failed to load route module\".\n *\n * `next/server.js`, `next/headers.js`, `next/navigation.js` \u2026 do exist as files,\n * which is why `@open-mercato/shared` imports `'next/headers.js'`. Rather than\n * rewriting several hundred imports across every package (and every\n * third-party module), this hook retries a failed bare `next/<subpath>` with\n * the `.js` suffix. It only runs in the processes that install it, only for\n * `next/*` specifiers, and only after the normal resolution failed, so it\n * becomes a no-op the day `next` publishes an `exports` map.\n */\nimport * as nodeModule from 'node:module'\n\ntype ResolveContext = Record<string, unknown>\ntype ResolveResult = { url: string; format?: string | null | undefined; shortCircuit?: boolean }\ntype NextResolve = (specifier: string, context?: ResolveContext) => ResolveResult\ntype AsyncNextResolve = (specifier: string, context?: ResolveContext) => ResolveResult | Promise<ResolveResult>\n\n/** Bare `next/<one segment>` specifiers, e.g. `next/server`, `next/headers`. */\nconst NEXT_BARE_SUBPATH = /^next\\/[A-Za-z0-9_-]+$/\n\nlet installed = false\n\nfunction isModuleNotFound(error: unknown): boolean {\n  return Boolean(error) && typeof error === 'object' && (error as { code?: unknown }).code === 'ERR_MODULE_NOT_FOUND'\n}\n\n/**\n * The resolve hook itself. Exported so it can be tested without touching the\n * process-global hook chain.\n */\nexport function resolveNextSubpath(\n  specifier: string,\n  context: ResolveContext,\n  nextResolve: NextResolve,\n): ResolveResult {\n  if (!NEXT_BARE_SUBPATH.test(specifier)) return nextResolve(specifier, context)\n  try {\n    return nextResolve(specifier, context)\n  } catch (error) {\n    if (!isModuleNotFound(error)) throw error\n    try {\n      return nextResolve(`${specifier}.js`, context)\n    } catch {\n      // Neither form resolves (Next is not installed at all): surface the\n      // original error, which names the specifier the caller wrote.\n      throw error\n    }\n  }\n}\n\nexport async function resolveNextSubpathAsync(\n  specifier: string,\n  context: ResolveContext,\n  nextResolve: AsyncNextResolve,\n): Promise<ResolveResult> {\n  if (!NEXT_BARE_SUBPATH.test(specifier)) return nextResolve(specifier, context)\n  try {\n    return await nextResolve(specifier, context)\n  } catch (error) {\n    if (!isModuleNotFound(error)) throw error\n    try {\n      return await nextResolve(`${specifier}.js`, context)\n    } catch {\n      throw error\n    }\n  }\n}\n\ntype RegisterHooks = (hooks: { resolve: typeof resolveNextSubpath }) => unknown\ntype RegisterHookModule = (specifier: string | URL, parentURL?: string | URL) => unknown\n\n/**\n * `module.registerHooks` exists from Node 22.15. It is read off the namespace\n * rather than imported by name: in the published ESM build a named import of an\n * export the running Node lacks fails while the module links, before the check\n * in `installNextSubpathResolveHook` can run, and the package still declares\n * `node >= 22.0.0`.\n */\nfunction runtimeRegisterHooks(): RegisterHooks | undefined {\n  const candidate = (nodeModule as unknown as { registerHooks?: unknown }).registerHooks\n  return typeof candidate === 'function' ? (candidate as RegisterHooks) : undefined\n}\n\nfunction runtimeRegisterHookModule(): RegisterHookModule | undefined {\n  const candidate = (nodeModule as unknown as { register?: unknown }).register\n  return typeof candidate === 'function' ? (candidate as RegisterHookModule) : undefined\n}\n\n/**\n * Install the hook once per process. Returns `true` when it was installed by\n * this call, `false` when it already was or when the runtime has neither\n * registration API. Node 22.15+ uses the synchronous hook API; earlier\n * supported Node 22 releases use the asynchronous hook API.\n */\nexport function installNextSubpathResolveHook(\n  registerHooks: RegisterHooks | null | undefined = runtimeRegisterHooks(),\n  registerHookModule: RegisterHookModule | null | undefined = runtimeRegisterHookModule(),\n): boolean {\n  if (installed) return false\n  if (typeof registerHooks === 'function') {\n    registerHooks({ resolve: resolveNextSubpath })\n  } else if (typeof registerHookModule === 'function') {\n    registerHookModule(new URL('./next-subpath-resolve-hook-worker.js', import.meta.url), import.meta.url)\n  } else {\n    return false\n  }\n  installed = true\n  return true\n}\n\n/** Test seam: forget that the hook was installed. */\nexport function resetNextSubpathResolveHookForTests(): void {\n  installed = false\n}\n"],
-  "mappings": "AA0BA,YAAY,gBAAgB;AAQ5B,MAAM,oBAAoB;AAE1B,IAAI,YAAY;AAEhB,SAAS,iBAAiB,OAAyB;AACjD,SAAO,QAAQ,KAAK,KAAK,OAAO,UAAU,YAAa,MAA6B,SAAS;AAC/F;AAMO,SAAS,mBACd,WACA,SACA,aACe;AACf,MAAI,CAAC,kBAAkB,KAAK,SAAS,EAAG,QAAO,YAAY,WAAW,OAAO;AAC7E,MAAI;AACF,WAAO,YAAY,WAAW,OAAO;AAAA,EACvC,SAAS,OAAO;AACd,QAAI,CAAC,iBAAiB,KAAK,EAAG,OAAM;AACpC,QAAI;AACF,aAAO,YAAY,GAAG,SAAS,OAAO,OAAO;AAAA,IAC/C,QAAQ;AAGN,YAAM;AAAA,IACR;AAAA,EACF;AACF;AAEA,eAAsB,wBACpB,WACA,SACA,aACwB;AACxB,MAAI,CAAC,kBAAkB,KAAK,SAAS,EAAG,QAAO,YAAY,WAAW,OAAO;AAC7E,MAAI;AACF,WAAO,MAAM,YAAY,WAAW,OAAO;AAAA,EAC7C,SAAS,OAAO;AACd,QAAI,CAAC,iBAAiB,KAAK,EAAG,OAAM;AACpC,QAAI;AACF,aAAO,MAAM,YAAY,GAAG,SAAS,OAAO,OAAO;AAAA,IACrD,QAAQ;AACN,YAAM;AAAA,IACR;AAAA,EACF;AACF;AAYA,SAAS,uBAAkD;AACzD,QAAM,YAAa,WAAsD;AACzE,SAAO,OAAO,cAAc,aAAc,YAA8B;AAC1E;AAEA,SAAS,4BAA4D;AACnE,QAAM,YAAa,WAAiD;AACpE,SAAO,OAAO,cAAc,aAAc,YAAmC;AAC/E;AAQO,SAAS,8BACd,gBAAkD,qBAAqB,GACvE,qBAA4D,0BAA0B,GAC7E;AACT,MAAI,UAAW,QAAO;AACtB,MAAI,OAAO,kBAAkB,YAAY;AACvC,kBAAc,EAAE,SAAS,mBAAmB,CAAC;AAAA,EAC/C,WAAW,OAAO,uBAAuB,YAAY;AACnD,uBAAmB,IAAI,IAAI,yCAAyC,YAAY,GAAG,GAAG,YAAY,GAAG;AAAA,EACvG,OAAO;AACL,WAAO;AAAA,EACT;AACA,cAAY;AACZ,SAAO;AACT;AAGO,SAAS,sCAA4C;AAC1D,cAAY;AACd;",
-  "names": []
-}

package/dist/lib/catalog-visibility/canonicalizeEffectiveScope.js

@@ -1,33 +0,0 @@
-const ID_LIST_KEYS = [
-  "categoryIds",
-  "excludeCategoryIds",
-  "excludeProductIds",
-  "excludeTagIds",
-  "tagIds"
-];
-function compareStrings(left, right) {
-  if (left < right) return -1;
-  if (left > right) return 1;
-  return 0;
-}
-function sortedUnique(values) {
-  return Array.from(new Set(values)).sort(compareStrings);
-}
-function canonicalizeBranch(scope) {
-  const members = [];
-  const nested = (scope.allOf ?? []).map(canonicalizeBranch);
-  if (nested.length > 0) members.push(`"allOf":[${sortedUnique(nested).join(",")}]`);
-  for (const key of ID_LIST_KEYS) {
-    const ids = scope[key] ?? [];
-    if (ids.length > 0) members.push(`${JSON.stringify(key)}:${JSON.stringify(sortedUnique(ids))}`);
-  }
-  return `{${members.join(",")}}`;
-}
-function canonicalizeEffectiveScope(scope) {
-  if (scope === null) return "null";
-  return `[${sortedUnique(scope.map(canonicalizeBranch)).join(",")}]`;
-}
-export {
-  canonicalizeEffectiveScope
-};
-//# sourceMappingURL=canonicalizeEffectiveScope.js.map

package/dist/lib/catalog-visibility/canonicalizeEffectiveScope.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/lib/catalog-visibility/canonicalizeEffectiveScope.ts"],
-  "sourcesContent": ["import type { AssortmentScope, EffectiveAssortmentScope } from './types'\n\nconst ID_LIST_KEYS = [\n  'categoryIds',\n  'excludeCategoryIds',\n  'excludeProductIds',\n  'excludeTagIds',\n  'tagIds',\n] as const\n\nfunction compareStrings(left: string, right: string): number {\n  if (left < right) return -1\n  if (left > right) return 1\n  return 0\n}\n\nfunction sortedUnique(values: string[]): string[] {\n  return Array.from(new Set(values)).sort(compareStrings)\n}\n\nfunction canonicalizeBranch(scope: AssortmentScope): string {\n  const members: string[] = []\n  const nested = (scope.allOf ?? []).map(canonicalizeBranch)\n  if (nested.length > 0) members.push(`\"allOf\":[${sortedUnique(nested).join(',')}]`)\n  for (const key of ID_LIST_KEYS) {\n    const ids = scope[key] ?? []\n    if (ids.length > 0) members.push(`${JSON.stringify(key)}:${JSON.stringify(sortedUnique(ids))}`)\n  }\n  return `{${members.join(',')}}`\n}\n\n/**\n * Deterministic serialization of a resolved scope. `null` (unrestricted) serializes as `null`\n * and `[]` (deny-all) as `[]`, so the two never collide. Empty and absent arrays are\n * equivalent, id lists are sorted and deduplicated, and OR-branches and `allOf` entries are\n * ordered by their own canonical form with identical ones collapsed.\n */\nexport function canonicalizeEffectiveScope(scope: EffectiveAssortmentScope): string {\n  if (scope === null) return 'null'\n  return `[${sortedUnique(scope.map(canonicalizeBranch)).join(',')}]`\n}\n"],
-  "mappings": "AAEA,MAAM,eAAe;AAAA,EACnB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAEA,SAAS,eAAe,MAAc,OAAuB;AAC3D,MAAI,OAAO,MAAO,QAAO;AACzB,MAAI,OAAO,MAAO,QAAO;AACzB,SAAO;AACT;AAEA,SAAS,aAAa,QAA4B;AAChD,SAAO,MAAM,KAAK,IAAI,IAAI,MAAM,CAAC,EAAE,KAAK,cAAc;AACxD;AAEA,SAAS,mBAAmB,OAAgC;AAC1D,QAAM,UAAoB,CAAC;AAC3B,QAAM,UAAU,MAAM,SAAS,CAAC,GAAG,IAAI,kBAAkB;AACzD,MAAI,OAAO,SAAS,EAAG,SAAQ,KAAK,YAAY,aAAa,MAAM,EAAE,KAAK,GAAG,CAAC,GAAG;AACjF,aAAW,OAAO,cAAc;AAC9B,UAAM,MAAM,MAAM,GAAG,KAAK,CAAC;AAC3B,QAAI,IAAI,SAAS,EAAG,SAAQ,KAAK,GAAG,KAAK,UAAU,GAAG,CAAC,IAAI,KAAK,UAAU,aAAa,GAAG,CAAC,CAAC,EAAE;AAAA,EAChG;AACA,SAAO,IAAI,QAAQ,KAAK,GAAG,CAAC;AAC9B;AAQO,SAAS,2BAA2B,OAAyC;AAClF,MAAI,UAAU,KAAM,QAAO;AAC3B,SAAO,IAAI,aAAa,MAAM,IAAI,kBAAkB,CAAC,EAAE,KAAK,GAAG,CAAC;AAClE;",
-  "names": []
-}

package/dist/lib/catalog-visibility/hashEffectiveScope.js

@@ -1,9 +0,0 @@
-import { createHash } from "node:crypto";
-import { canonicalizeEffectiveScope } from "./canonicalizeEffectiveScope.js";
-function hashEffectiveScope(scope) {
-  return createHash("sha256").update(canonicalizeEffectiveScope(scope)).digest("hex").slice(0, 16);
-}
-export {
-  hashEffectiveScope
-};
-//# sourceMappingURL=hashEffectiveScope.js.map

package/dist/lib/catalog-visibility/hashEffectiveScope.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/lib/catalog-visibility/hashEffectiveScope.ts"],
-  "sourcesContent": ["import { createHash } from 'node:crypto'\nimport { canonicalizeEffectiveScope } from './canonicalizeEffectiveScope'\nimport type { EffectiveAssortmentScope } from './types'\n\n/** 16-hex-character sha256 digest of the canonical scope (SPEC-029 \u00A76.1 truncation). Server-only: uses node:crypto. */\nexport function hashEffectiveScope(scope: EffectiveAssortmentScope): string {\n  return createHash('sha256').update(canonicalizeEffectiveScope(scope)).digest('hex').slice(0, 16)\n}\n"],
-  "mappings": "AAAA,SAAS,kBAAkB;AAC3B,SAAS,kCAAkC;AAIpC,SAAS,mBAAmB,OAAyC;AAC1E,SAAO,WAAW,QAAQ,EAAE,OAAO,2BAA2B,KAAK,CAAC,EAAE,OAAO,KAAK,EAAE,MAAM,GAAG,EAAE;AACjG;",
-  "names": []
-}

package/dist/lib/db/advisoryLock.js

@@ -1,172 +0,0 @@
-import { calculateBackoffDelayMs } from "../delivery/retry.js";
-import { isTransientLockDbError } from "./pg-errors.js";
-const ADVISORY_LOCK_UNAVAILABLE_BRAND = /* @__PURE__ */ Symbol.for("@open-mercato/shared:AdvisoryLockUnavailableError");
-const ADVISORY_LOCK_UNAVAILABLE_MESSAGES = {
-  deadline: "[internal] Advisory lock not acquired before the wait deadline",
-  transient_db: "[internal] Advisory lock transaction failed with a transient database error",
-  commit_unknown: "[internal] Advisory lock transaction failed after its callback returned; the commit outcome is unknown"
-};
-class AdvisoryLockUnavailableError extends Error {
-  static [Symbol.hasInstance](value) {
-    return typeof value === "object" && value !== null && Reflect.get(value, ADVISORY_LOCK_UNAVAILABLE_BRAND) === true;
-  }
-  constructor(reason, key, cause) {
-    super(ADVISORY_LOCK_UNAVAILABLE_MESSAGES[reason], cause === void 0 ? void 0 : { cause });
-    Object.defineProperty(this, ADVISORY_LOCK_UNAVAILABLE_BRAND, { value: true, enumerable: false });
-    this.name = "AdvisoryLockUnavailableError";
-    this.reason = reason;
-    this.key = key;
-  }
-}
-const DEFAULT_WAIT_DEADLINE_MS = 15e3;
-const BACKOFF_ATTEMPT_CAP = 5;
-const BACKOFF_OPTIONS = { baseDelayMs: 50, maxJitterMs: 25 };
-const KEY_NAMESPACE_PATTERN = /^[a-z][a-z0-9_]*$/;
-const ADVISORY_LOCK_SQL = "select pg_try_advisory_xact_lock(hashtextextended(?, 0)) as locked";
-const LOCK_FORK_OPTIONS = {
-  disableContextResolution: true,
-  clear: true,
-  useContext: false,
-  disableTransactions: false,
-  cloneEventManager: true
-};
-const GLOBAL_SLOTS_KEY = "__openMercatoAdvisoryLockSlots__";
-const NOT_ACQUIRED = { acquired: false };
-const releaseNothing = () => void 0;
-function getSlotRegistry() {
-  const globals = globalThis;
-  const existing = globals[GLOBAL_SLOTS_KEY];
-  if (existing instanceof Map) return existing;
-  const created = /* @__PURE__ */ new Map();
-  globals[GLOBAL_SLOTS_KEY] = created;
-  return created;
-}
-function getNamespaceSlots(namespace) {
-  const registry = getSlotRegistry();
-  const existing = registry.get(namespace);
-  if (existing) return existing;
-  const created = { held: 0, waiters: [] };
-  registry.set(namespace, created);
-  return created;
-}
-function handOffSlots(slots) {
-  let index = 0;
-  while (index < slots.waiters.length) {
-    const waiter = slots.waiters[index];
-    if (slots.held >= waiter.limit) {
-      index += 1;
-      continue;
-    }
-    slots.waiters.splice(index, 1);
-    slots.held += 1;
-    waiter.grant();
-  }
-}
-function createSlotRelease(slots) {
-  let released = false;
-  return () => {
-    if (released) return;
-    released = true;
-    slots.held -= 1;
-    handOffSlots(slots);
-  };
-}
-function acquireSlot(namespace, limit, key, deadlineAt) {
-  const slots = getNamespaceSlots(namespace);
-  if (slots.held < limit) {
-    slots.held += 1;
-    return Promise.resolve(createSlotRelease(slots));
-  }
-  const remainingMs = deadlineAt - Date.now();
-  if (remainingMs <= 0) return Promise.reject(new AdvisoryLockUnavailableError("deadline", key));
-  return new Promise((resolve, reject) => {
-    const waiter = {
-      limit,
-      grant: () => {
-        clearTimeout(deadlineTimer);
-        resolve(createSlotRelease(slots));
-      }
-    };
-    const deadlineTimer = setTimeout(() => {
-      const position = slots.waiters.indexOf(waiter);
-      if (position >= 0) slots.waiters.splice(position, 1);
-      reject(new AdvisoryLockUnavailableError("deadline", key));
-    }, remainingMs);
-    slots.waiters.push(waiter);
-  });
-}
-function parseKeyNamespace(key) {
-  const separator = typeof key === "string" ? key.indexOf(":") : -1;
-  if (typeof key === "string" && separator > 0 && separator < key.length - 1) {
-    const namespace = key.slice(0, separator);
-    if (KEY_NAMESPACE_PATTERN.test(namespace)) return namespace;
-  }
-  throw new TypeError('[internal] Advisory lock key must be "<namespace>:<parts>" with a namespace matching ^[a-z][a-z0-9_]*$');
-}
-function resolveWaitDeadlineMs(value) {
-  if (value === void 0) return DEFAULT_WAIT_DEADLINE_MS;
-  if (Number.isFinite(value) && value >= 0) return value;
-  throw new TypeError("[internal] Advisory lock waitDeadlineMs must be a finite number of at least 0");
-}
-function resolveMaxConcurrentHolders(value) {
-  if (value === void 0) return null;
-  if (Number.isInteger(value) && value > 0) return value;
-  throw new TypeError("[internal] Advisory lock maxConcurrentHolders must be a positive integer");
-}
-function sleep(delayMs) {
-  return new Promise((resolve) => setTimeout(resolve, delayMs));
-}
-async function attemptLock(lockEm, key, fn) {
-  const callback = { thrown: false, returned: false, error: void 0 };
-  try {
-    return await lockEm.transactional(async (txEm) => {
-      const rows = await txEm.execute(ADVISORY_LOCK_SQL, [key]);
-      if (rows[0]?.locked !== true) return NOT_ACQUIRED;
-      try {
-        const value = await fn(txEm);
-        callback.returned = true;
-        return { acquired: true, value };
-      } catch (error) {
-        callback.thrown = true;
-        callback.error = error;
-        throw error;
-      }
-    });
-  } catch (error) {
-    if (callback.thrown) throw callback.error;
-    if (isTransientLockDbError(error)) {
-      throw new AdvisoryLockUnavailableError(callback.returned ? "commit_unknown" : "transient_db", key, error);
-    }
-    throw error;
-  }
-}
-async function withAdvisoryXactLock(em, key, fn, options = {}) {
-  const namespace = parseKeyNamespace(key);
-  const waitDeadlineMs = resolveWaitDeadlineMs(options.waitDeadlineMs);
-  const maxConcurrentHolders = resolveMaxConcurrentHolders(options.maxConcurrentHolders);
-  const deadlineAt = Date.now() + waitDeadlineMs;
-  const lockEm = em.fork(LOCK_FORK_OPTIONS);
-  for (let attempt = 1; ; attempt += 1) {
-    const releaseSlot = maxConcurrentHolders === null ? releaseNothing : await acquireSlot(namespace, maxConcurrentHolders, key, deadlineAt);
-    let outcome;
-    try {
-      outcome = await attemptLock(lockEm, key, fn);
-    } finally {
-      releaseSlot();
-    }
-    if (outcome.acquired) return outcome.value;
-    const remainingMs = deadlineAt - Date.now();
-    if (remainingMs <= 0) throw new AdvisoryLockUnavailableError("deadline", key);
-    await sleep(Math.min(calculateBackoffDelayMs(Math.min(attempt, BACKOFF_ATTEMPT_CAP), BACKOFF_OPTIONS), remainingMs));
-    if (options.onWait) {
-      const waitResult = await options.onWait();
-      if (waitResult.done) return waitResult.value;
-    }
-    if (Date.now() >= deadlineAt) throw new AdvisoryLockUnavailableError("deadline", key);
-  }
-}
-export {
-  AdvisoryLockUnavailableError,
-  withAdvisoryXactLock
-};
-//# sourceMappingURL=advisoryLock.js.map

package/dist/lib/db/advisoryLock.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/lib/db/advisoryLock.ts"],
-  "sourcesContent": ["import type { EntityManager } from '@mikro-orm/postgresql'\nimport { calculateBackoffDelayMs } from '../delivery/retry'\nimport { isTransientLockDbError } from './pg-errors'\n\n/** @internal */\nexport type AdvisoryLockWaitResult<T> = { done: true; value: T } | { done: false }\n\nexport type AdvisoryLockOptions<T> = {\n  /** Total waiting budget from the call start. Default 15_000. */\n  waitDeadlineMs?: number\n  /** @internal Called after each failed attempt, with no connection held; `done: true` short-circuits. */\n  onWait?: () => Promise<AdvisoryLockWaitResult<T>>\n  /** Per process and key namespace: at most this many lock transactions at once (attempts included).\n   *  Waiting for a slot holds no connection and counts against `waitDeadlineMs`. Default: unlimited. */\n  maxConcurrentHolders?: number\n}\n\nconst ADVISORY_LOCK_UNAVAILABLE_BRAND = Symbol.for('@open-mercato/shared:AdvisoryLockUnavailableError')\n\n/**\n * The helper's own work failed with an error `isTransientLockDbError` accepts (kept as `cause`), or\n * the wait ran out. `deadline`: the wait budget ran out (contention or no free holder slot), so `fn`\n * never ran. `transient_db`: the begin or the lock query failed, so `fn` never ran. `commit_unknown`:\n * `fn` returned and the flush or commit after it failed, so its writes may or may not be committed.\n * `reason` is additive-only; branch on it, never on the message.\n */\nexport type AdvisoryLockUnavailableReason = 'deadline' | 'transient_db' | 'commit_unknown'\n\nconst ADVISORY_LOCK_UNAVAILABLE_MESSAGES: Record<AdvisoryLockUnavailableReason, string> = {\n  deadline: '[internal] Advisory lock not acquired before the wait deadline',\n  transient_db: '[internal] Advisory lock transaction failed with a transient database error',\n  commit_unknown: '[internal] Advisory lock transaction failed after its callback returned; the commit outcome is unknown',\n}\n\nexport class AdvisoryLockUnavailableError extends Error {\n  static [Symbol.hasInstance](value: unknown): boolean {\n    return typeof value === 'object' && value !== null && Reflect.get(value, ADVISORY_LOCK_UNAVAILABLE_BRAND) === true\n  }\n\n  readonly reason: AdvisoryLockUnavailableReason\n  readonly key: string\n  constructor(reason: AdvisoryLockUnavailableReason, key: string, cause?: unknown) {\n    super(ADVISORY_LOCK_UNAVAILABLE_MESSAGES[reason], cause === undefined ? undefined : { cause })\n    Object.defineProperty(this, ADVISORY_LOCK_UNAVAILABLE_BRAND, { value: true, enumerable: false })\n    this.name = 'AdvisoryLockUnavailableError'\n    this.reason = reason\n    this.key = key\n  }\n}\n\nconst DEFAULT_WAIT_DEADLINE_MS = 15_000\nconst BACKOFF_ATTEMPT_CAP = 5\nconst BACKOFF_OPTIONS = { baseDelayMs: 50, maxJitterMs: 25 }\nconst KEY_NAMESPACE_PATTERN = /^[a-z][a-z0-9_]*$/\nconst ADVISORY_LOCK_SQL = 'select pg_try_advisory_xact_lock(hashtextextended(?, 0)) as locked'\n\n/**\n * `disableContextResolution` keeps the fork off an outer transaction resolved from the\n * async context, `useContext: false` keeps the fork's own transaction from joining one\n * later, `disableTransactions: false` keeps a source EntityManager with transactions disabled\n * from turning the lock into a statement-scoped no-op, and the cloned event manager carries\n * the request's subscribers (tenant field encryption among them) into the lock transaction.\n */\nconst LOCK_FORK_OPTIONS = {\n  disableContextResolution: true,\n  clear: true,\n  useContext: false,\n  disableTransactions: false,\n  cloneEventManager: true,\n}\n\n/**\n * Holder slots live on `globalThis` so duplicated module instances in one process (dev\n * HMR, standalone server chunks) count against one limit. The map is created once and\n * never replaced; each namespace entry is created on first use and kept.\n */\nconst GLOBAL_SLOTS_KEY = '__openMercatoAdvisoryLockSlots__'\n\ntype SlotWaiter = {\n  limit: number\n  grant: () => void\n}\n\ntype NamespaceSlots = {\n  held: number\n  waiters: SlotWaiter[]\n}\n\ntype SlotRelease = () => void\n\ntype AttemptOutcome<T> = { acquired: true; value: T } | { acquired: false }\n\nconst NOT_ACQUIRED: AttemptOutcome<never> = { acquired: false }\n\nconst releaseNothing: SlotRelease = () => undefined\n\nfunction getSlotRegistry(): Map<string, NamespaceSlots> {\n  const globals = globalThis as Record<string, unknown>\n  const existing = globals[GLOBAL_SLOTS_KEY]\n  if (existing instanceof Map) return existing as Map<string, NamespaceSlots>\n  const created = new Map<string, NamespaceSlots>()\n  globals[GLOBAL_SLOTS_KEY] = created\n  return created\n}\n\nfunction getNamespaceSlots(namespace: string): NamespaceSlots {\n  const registry = getSlotRegistry()\n  const existing = registry.get(namespace)\n  if (existing) return existing\n  const created: NamespaceSlots = { held: 0, waiters: [] }\n  registry.set(namespace, created)\n  return created\n}\n\nfunction handOffSlots(slots: NamespaceSlots): void {\n  let index = 0\n  while (index < slots.waiters.length) {\n    const waiter = slots.waiters[index]\n    if (slots.held >= waiter.limit) {\n      index += 1\n      continue\n    }\n    slots.waiters.splice(index, 1)\n    slots.held += 1\n    waiter.grant()\n  }\n}\n\nfunction createSlotRelease(slots: NamespaceSlots): SlotRelease {\n  let released = false\n  return () => {\n    if (released) return\n    released = true\n    slots.held -= 1\n    handOffSlots(slots)\n  }\n}\n\nfunction acquireSlot(namespace: string, limit: number, key: string, deadlineAt: number): Promise<SlotRelease> {\n  const slots = getNamespaceSlots(namespace)\n  if (slots.held < limit) {\n    slots.held += 1\n    return Promise.resolve(createSlotRelease(slots))\n  }\n  const remainingMs = deadlineAt - Date.now()\n  if (remainingMs <= 0) return Promise.reject(new AdvisoryLockUnavailableError('deadline', key))\n  return new Promise<SlotRelease>((resolve, reject) => {\n    const waiter: SlotWaiter = {\n      limit,\n      grant: () => {\n        clearTimeout(deadlineTimer)\n        resolve(createSlotRelease(slots))\n      },\n    }\n    const deadlineTimer = setTimeout(() => {\n      const position = slots.waiters.indexOf(waiter)\n      if (position >= 0) slots.waiters.splice(position, 1)\n      reject(new AdvisoryLockUnavailableError('deadline', key))\n    }, remainingMs)\n    slots.waiters.push(waiter)\n  })\n}\n\nfunction parseKeyNamespace(key: unknown): string {\n  const separator = typeof key === 'string' ? key.indexOf(':') : -1\n  if (typeof key === 'string' && separator > 0 && separator < key.length - 1) {\n    const namespace = key.slice(0, separator)\n    if (KEY_NAMESPACE_PATTERN.test(namespace)) return namespace\n  }\n  throw new TypeError('[internal] Advisory lock key must be \"<namespace>:<parts>\" with a namespace matching ^[a-z][a-z0-9_]*$')\n}\n\nfunction resolveWaitDeadlineMs(value: number | undefined): number {\n  if (value === undefined) return DEFAULT_WAIT_DEADLINE_MS\n  if (Number.isFinite(value) && value >= 0) return value\n  throw new TypeError('[internal] Advisory lock waitDeadlineMs must be a finite number of at least 0')\n}\n\nfunction resolveMaxConcurrentHolders(value: number | undefined): number | null {\n  if (value === undefined) return null\n  if (Number.isInteger(value) && value > 0) return value\n  throw new TypeError('[internal] Advisory lock maxConcurrentHolders must be a positive integer')\n}\n\nfunction sleep(delayMs: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, delayMs))\n}\n\nasync function attemptLock<T>(\n  lockEm: EntityManager,\n  key: string,\n  fn: (txEm: EntityManager) => Promise<T>,\n): Promise<AttemptOutcome<T>> {\n  const callback: { thrown: boolean; returned: boolean; error: unknown } = { thrown: false, returned: false, error: undefined }\n  try {\n    return await lockEm.transactional(async (txEm): Promise<AttemptOutcome<T>> => {\n      const rows = await txEm.execute<Array<{ locked: boolean }>>(ADVISORY_LOCK_SQL, [key])\n      if (rows[0]?.locked !== true) return NOT_ACQUIRED\n      try {\n        const value = await fn(txEm)\n        callback.returned = true\n        return { acquired: true, value }\n      } catch (error) {\n        callback.thrown = true\n        callback.error = error\n        throw error\n      }\n    })\n  } catch (error) {\n    if (callback.thrown) throw callback.error\n    if (isTransientLockDbError(error)) {\n      throw new AdvisoryLockUnavailableError(callback.returned ? 'commit_unknown' : 'transient_db', key, error)\n    }\n    throw error\n  }\n}\n\n/**\n * Runs `fn` in one transaction that holds `pg_try_advisory_xact_lock(hashtextextended(key, 0))`.\n * - `key` is `<namespace>:<parts>` with namespace `^[a-z][a-z0-9_]*$`; anything else throws `TypeError`.\n * - `waitDeadlineMs` must be a finite number \u2265 0 and `maxConcurrentHolders` a positive integer;\n *   anything else throws `TypeError` before any connection is taken.\n * - Pass the request (container) EntityManager. The helper forks it with\n *   `{ disableContextResolution: true, clear: true, useContext: false, disableTransactions: false, cloneEventManager: true }`,\n *   so the lock transaction never nests in a caller's transaction and commits on its own.\n * - `fn` MUST do all DB I/O on `txEm`, MUST flush its own writes, MUST be bounded (\u2264 one external\n *   call), MUST NOT call `transactional` again (it only opens a savepoint in the lock transaction) and\n *   MUST NOT fork or use `getConnection().execute` (another pooled connection, outside the lock).\n * - `txEm` carries the request EntityManager's subscribers (cloned event manager).\n * - A failed attempt ends its empty transaction, so waiters hold no connection between attempts.\n *   They back off 50 ms doubling up to 800 ms (plus up to 24 ms jitter), never past\n *   `waitDeadlineMs` measured from the call start, then retry.\n * - With `maxConcurrentHolders`, each attempt first takes a per-process slot for the key\n *   namespace and gives it back when the attempt fails or the lock transaction settles.\n * - Errors from the helper's own begin, lock query and commit that `isTransientLockDbError` accepts,\n *   and the deadline, throw `AdvisoryLockUnavailableError` (its `reason` says whether `fn` ran); any\n *   other error from them, and every error thrown by `fn`, propagates unchanged (a throw from `fn`\n *   rolls back).\n */\nexport async function withAdvisoryXactLock<T>(\n  em: EntityManager,\n  key: string,\n  fn: (txEm: EntityManager) => Promise<T>,\n  options: AdvisoryLockOptions<T> = {},\n): Promise<T> {\n  const namespace = parseKeyNamespace(key)\n  const waitDeadlineMs = resolveWaitDeadlineMs(options.waitDeadlineMs)\n  const maxConcurrentHolders = resolveMaxConcurrentHolders(options.maxConcurrentHolders)\n  const deadlineAt = Date.now() + waitDeadlineMs\n  const lockEm = em.fork(LOCK_FORK_OPTIONS)\n  for (let attempt = 1; ; attempt += 1) {\n    const releaseSlot = maxConcurrentHolders === null\n      ? releaseNothing\n      : await acquireSlot(namespace, maxConcurrentHolders, key, deadlineAt)\n    let outcome: AttemptOutcome<T>\n    try {\n      outcome = await attemptLock(lockEm, key, fn)\n    } finally {\n      releaseSlot()\n    }\n    if (outcome.acquired) return outcome.value\n    const remainingMs = deadlineAt - Date.now()\n    if (remainingMs <= 0) throw new AdvisoryLockUnavailableError('deadline', key)\n    await sleep(Math.min(calculateBackoffDelayMs(Math.min(attempt, BACKOFF_ATTEMPT_CAP), BACKOFF_OPTIONS), remainingMs))\n    if (options.onWait) {\n      const waitResult = await options.onWait()\n      if (waitResult.done) return waitResult.value\n    }\n    if (Date.now() >= deadlineAt) throw new AdvisoryLockUnavailableError('deadline', key)\n  }\n}\n"],
-  "mappings": "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",
-  "names": []
-}

package/dist/lib/query/overlap.js

@@ -1,58 +0,0 @@
-import { sql } from "kysely";
-const LITERAL_SAFE_DOC_KEY = /^[A-Za-z0-9_:.-]{1,128}$/;
-function normalizeOverlapValues(value) {
-  const list = Array.isArray(value) ? value : value === void 0 || value === null ? [] : [value];
-  const out = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const entry of list) {
-    if (entry === void 0 || entry === null) continue;
-    const normalized = String(entry);
-    if (seen.has(normalized)) continue;
-    seen.add(normalized);
-    out.push(normalized);
-  }
-  return out;
-}
-function jsonbDocKeyExpression(docColumnRef, key) {
-  const keyExpr = LITERAL_SAFE_DOC_KEY.test(key) ? sql.lit(key) : sql`${key}`;
-  return sql`(${sql.ref(docColumnRef)} -> ${keyExpr})`;
-}
-function buildJsonbOverlapPredicate(docColumnRef, key, value) {
-  const values = normalizeOverlapValues(value);
-  if (!values.length) return sql`false`;
-  return sql`${jsonbDocKeyExpression(docColumnRef, key)} ?| ${values}::text[]`;
-}
-function buildJsonbNoOverlapPredicate(docColumnRef, key, value) {
-  const values = normalizeOverlapValues(value);
-  const keyExpr = jsonbDocKeyExpression(docColumnRef, key);
-  const isArray = sql`jsonb_typeof(${keyExpr}) = 'array'`;
-  if (!values.length) return isArray;
-  return sql`(${isArray} and not (${keyExpr} ?| ${values}::text[]))`;
-}
-function buildArrayColumnOverlapPredicate(column, value) {
-  const values = normalizeOverlapValues(value);
-  if (!values.length) return sql`false`;
-  const columnExpr = typeof column === "string" ? sql.ref(column) : column;
-  return sql`${columnExpr} && ${values}`;
-}
-function buildArrayColumnNoOverlapPredicate(column, value) {
-  const values = normalizeOverlapValues(value);
-  const columnExpr = typeof column === "string" ? sql.ref(column) : column;
-  if (!values.length) return sql`${columnExpr} is not null`;
-  return sql`not (${columnExpr} && ${values})`;
-}
-function buildScalarOverlapPredicate(expression, value) {
-  const values = normalizeOverlapValues(value);
-  if (!values.length) return sql`false`;
-  return sql`${expression} in (${sql.join(values.map((entry) => sql`${entry}`), sql`, `)})`;
-}
-export {
-  buildArrayColumnNoOverlapPredicate,
-  buildArrayColumnOverlapPredicate,
-  buildJsonbNoOverlapPredicate,
-  buildJsonbOverlapPredicate,
-  buildScalarOverlapPredicate,
-  jsonbDocKeyExpression,
-  normalizeOverlapValues
-};
-//# sourceMappingURL=overlap.js.map

package/dist/lib/query/overlap.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/lib/query/overlap.ts"],
-  "sourcesContent": ["import { sql, type RawBuilder } from 'kysely'\n\nconst LITERAL_SAFE_DOC_KEY = /^[A-Za-z0-9_:.-]{1,128}$/\n\n/**\n * Normalizes the right-hand side of an `overlap` filter into a de-duplicated list of strings.\n *\n * `null`/`undefined` entries are dropped; a scalar is treated as a one-element list. An empty\n * result means the filter matches nothing \u2014 every `overlap` builder compiles it to `false`\n * rather than dropping the predicate, so a caller that computes an empty inclusion set can\n * never widen a query by accident.\n */\nexport function normalizeOverlapValues(value: unknown): string[] {\n  const list: readonly unknown[] = Array.isArray(value)\n    ? value\n    : value === undefined || value === null\n      ? []\n      : [value]\n  const out: string[] = []\n  const seen = new Set<string>()\n  for (const entry of list) {\n    if (entry === undefined || entry === null) continue\n    const normalized = String(entry)\n    if (seen.has(normalized)) continue\n    seen.add(normalized)\n    out.push(normalized)\n  }\n  return out\n}\n\n/**\n * `(<docColumn> -> '<key>')` \u2014 the jsonb sub-document of an index document.\n *\n * The key is emitted as an escaped SQL literal when it is a plain identifier so the expression is\n * textually identical to a GIN expression index such as `((doc -> 'scope_keys'))` and the planner\n * can match it. Any other key falls back to a bound parameter (still correct, just not indexable).\n */\nexport function jsonbDocKeyExpression(docColumnRef: string, key: string): RawBuilder<unknown> {\n  const keyExpr = LITERAL_SAFE_DOC_KEY.test(key) ? sql.lit(key) : sql`${key}`\n  return sql`(${sql.ref(docColumnRef)} -> ${keyExpr})`\n}\n\n/**\n * jsonb \"has any of\" over a string-array key of an index document:\n * `(<docColumn> -> '<key>') ?| $n::text[]`. The values are bound as one array parameter.\n * A missing key or a JSON `null` evaluates to SQL NULL, i.e. the row does not match.\n */\nexport function buildJsonbOverlapPredicate(docColumnRef: string, key: string, value: unknown): RawBuilder<boolean> {\n  const values = normalizeOverlapValues(value)\n  if (!values.length) return sql<boolean>`false`\n  return sql<boolean>`${jsonbDocKeyExpression(docColumnRef, key)} ?| ${values}::text[]`\n}\n\n/**\n * jsonb \"has none of\" over a string-array key of an index document (`noverlap`):\n * `(jsonb_typeof(<expr>) = 'array' and not (<expr> ?| $n::text[]))`.\n *\n * Only a document whose key holds a JSON array can match: a missing key, a JSON `null` or a\n * scalar never satisfies it, so an unindexed document can never slip through an exclusion.\n * An empty value list excludes nothing (only the array check remains).\n */\nexport function buildJsonbNoOverlapPredicate(docColumnRef: string, key: string, value: unknown): RawBuilder<boolean> {\n  const values = normalizeOverlapValues(value)\n  const keyExpr = jsonbDocKeyExpression(docColumnRef, key)\n  const isArray = sql<boolean>`jsonb_typeof(${keyExpr}) = 'array'`\n  if (!values.length) return isArray\n  return sql<boolean>`(${isArray} and not (${keyExpr} ?| ${values}::text[]))`\n}\n\n/**\n * Postgres array overlap for array-typed columns: `<column> && $n`. The bound array takes its\n * element type from the column, so `text[]`, `varchar[]` and `uuid[]` columns all work.\n */\nexport function buildArrayColumnOverlapPredicate(\n  column: string | RawBuilder<unknown>,\n  value: unknown,\n): RawBuilder<boolean> {\n  const values = normalizeOverlapValues(value)\n  if (!values.length) return sql<boolean>`false`\n  const columnExpr = typeof column === 'string' ? sql.ref(column) : column\n  return sql<boolean>`${columnExpr} && ${values}`\n}\n\n/**\n * Postgres array \"has none of\" for array-typed columns (`noverlap`): `not (<column> && $n)`.\n * A NULL column never matches; an empty value list excludes nothing (`<column> is not null`).\n */\nexport function buildArrayColumnNoOverlapPredicate(\n  column: string | RawBuilder<unknown>,\n  value: unknown,\n): RawBuilder<boolean> {\n  const values = normalizeOverlapValues(value)\n  const columnExpr = typeof column === 'string' ? sql.ref(column) : column\n  if (!values.length) return sql<boolean>`${columnExpr} is not null`\n  return sql<boolean>`not (${columnExpr} && ${values})`\n}\n\n/**\n * `overlap` over a scalar expression evaluated once per stored value (custom-field value rows):\n * the record matches when any of its values is one of the requested ones \u2014 `<expr> in (...)`.\n */\nexport function buildScalarOverlapPredicate(expression: RawBuilder<unknown>, value: unknown): RawBuilder<boolean> {\n  const values = normalizeOverlapValues(value)\n  if (!values.length) return sql<boolean>`false`\n  return sql<boolean>`${expression} in (${sql.join(values.map((entry) => sql`${entry}`), sql`, `)})`\n}\n"],
-  "mappings": "AAAA,SAAS,WAA4B;AAErC,MAAM,uBAAuB;AAUtB,SAAS,uBAAuB,OAA0B;AAC/D,QAAM,OAA2B,MAAM,QAAQ,KAAK,IAChD,QACA,UAAU,UAAa,UAAU,OAC/B,CAAC,IACD,CAAC,KAAK;AACZ,QAAM,MAAgB,CAAC;AACvB,QAAM,OAAO,oBAAI,IAAY;AAC7B,aAAW,SAAS,MAAM;AACxB,QAAI,UAAU,UAAa,UAAU,KAAM;AAC3C,UAAM,aAAa,OAAO,KAAK;AAC/B,QAAI,KAAK,IAAI,UAAU,EAAG;AAC1B,SAAK,IAAI,UAAU;AACnB,QAAI,KAAK,UAAU;AAAA,EACrB;AACA,SAAO;AACT;AASO,SAAS,sBAAsB,cAAsB,KAAkC;AAC5F,QAAM,UAAU,qBAAqB,KAAK,GAAG,IAAI,IAAI,IAAI,GAAG,IAAI,MAAM,GAAG;AACzE,SAAO,OAAO,IAAI,IAAI,YAAY,CAAC,OAAO,OAAO;AACnD;AAOO,SAAS,2BAA2B,cAAsB,KAAa,OAAqC;AACjH,QAAM,SAAS,uBAAuB,KAAK;AAC3C,MAAI,CAAC,OAAO,OAAQ,QAAO;AAC3B,SAAO,MAAe,sBAAsB,cAAc,GAAG,CAAC,OAAO,MAAM;AAC7E;AAUO,SAAS,6BAA6B,cAAsB,KAAa,OAAqC;AACnH,QAAM,SAAS,uBAAuB,KAAK;AAC3C,QAAM,UAAU,sBAAsB,cAAc,GAAG;AACvD,QAAM,UAAU,mBAA4B,OAAO;AACnD,MAAI,CAAC,OAAO,OAAQ,QAAO;AAC3B,SAAO,OAAgB,OAAO,aAAa,OAAO,OAAO,MAAM;AACjE;AAMO,SAAS,iCACd,QACA,OACqB;AACrB,QAAM,SAAS,uBAAuB,KAAK;AAC3C,MAAI,CAAC,OAAO,OAAQ,QAAO;AAC3B,QAAM,aAAa,OAAO,WAAW,WAAW,IAAI,IAAI,MAAM,IAAI;AAClE,SAAO,MAAe,UAAU,OAAO,MAAM;AAC/C;AAMO,SAAS,mCACd,QACA,OACqB;AACrB,QAAM,SAAS,uBAAuB,KAAK;AAC3C,QAAM,aAAa,OAAO,WAAW,WAAW,IAAI,IAAI,MAAM,IAAI;AAClE,MAAI,CAAC,OAAO,OAAQ,QAAO,MAAe,UAAU;AACpD,SAAO,WAAoB,UAAU,OAAO,MAAM;AACpD;AAMO,SAAS,4BAA4B,YAAiC,OAAqC;AAChH,QAAM,SAAS,uBAAuB,KAAK;AAC3C,MAAI,CAAC,OAAO,OAAQ,QAAO;AAC3B,SAAO,MAAe,UAAU,QAAQ,IAAI,KAAK,OAAO,IAAI,CAAC,UAAU,MAAM,KAAK,EAAE,GAAG,OAAO,CAAC;AACjG;",
-  "names": []
-}

package/dist/modules/notifications/safeHref.js

@@ -1,20 +0,0 @@
-const SENTINEL_ORIGIN = "https://notifications.open-mercato.local";
-const CONTROL_OR_BACKSLASH = /[\u0000-\u001F\u007F\\]/;
-function isSafeNotificationHref(href) {
-  if (!href.startsWith("/") || href.startsWith("//")) {
-    return false;
-  }
-  if (CONTROL_OR_BACKSLASH.test(href)) {
-    return false;
-  }
-  try {
-    const parsed = new URL(href, SENTINEL_ORIGIN);
-    return parsed.origin === SENTINEL_ORIGIN && !parsed.pathname.startsWith("//");
-  } catch {
-    return false;
-  }
-}
-export {
-  isSafeNotificationHref
-};
-//# sourceMappingURL=safeHref.js.map

package/dist/modules/notifications/safeHref.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/modules/notifications/safeHref.ts"],
-  "sourcesContent": ["const SENTINEL_ORIGIN = 'https://notifications.open-mercato.local'\nconst CONTROL_OR_BACKSLASH = /[\\u0000-\\u001F\\u007F\\\\]/\n\nexport function isSafeNotificationHref(href: string): boolean {\n  if (!href.startsWith('/') || href.startsWith('//')) {\n    return false\n  }\n\n  if (CONTROL_OR_BACKSLASH.test(href)) {\n    return false\n  }\n\n  try {\n    const parsed = new URL(href, SENTINEL_ORIGIN)\n    return parsed.origin === SENTINEL_ORIGIN && !parsed.pathname.startsWith('//')\n  } catch {\n    return false\n  }\n}\n"],
-  "mappings": "AAAA,MAAM,kBAAkB;AACxB,MAAM,uBAAuB;AAEtB,SAAS,uBAAuB,MAAuB;AAC5D,MAAI,CAAC,KAAK,WAAW,GAAG,KAAK,KAAK,WAAW,IAAI,GAAG;AAClD,WAAO;AAAA,EACT;AAEA,MAAI,qBAAqB,KAAK,IAAI,GAAG;AACnC,WAAO;AAAA,EACT;AAEA,MAAI;AACF,UAAM,SAAS,IAAI,IAAI,MAAM,eAAe;AAC5C,WAAO,OAAO,WAAW,mBAAmB,CAAC,OAAO,SAAS,WAAW,IAAI;AAAA,EAC9E,QAAQ;AACN,WAAO;AAAA,EACT;AACF;",
-  "names": []
-}

package/src/lib/__tests__/url.cross-site.test.ts

@@ -1,140 +0,0 @@
-import { isCrossSiteBrowserRequest } from '../url'
-
-function req(headers: Record<string, string>, url = 'https://app.example.com/api/auth/login') {
-  return new Request(url, { method: 'POST', headers })
-}
-
-const configured = { APP_URL: 'https://app.example.com', NODE_ENV: 'production' }
-const unconfiguredDev = { NODE_ENV: 'development' }
-
-describe('isCrossSiteBrowserRequest', () => {
-  describe('non-browser callers (no Origin, no Sec-Fetch-Site) are never cross-site', () => {
-    test.each([
-      ['configured', configured],
-      ['unconfigured dev', unconfiguredDev],
-    ])('%s', (_label, env) => {
-      expect(isCrossSiteBrowserRequest(req({ host: 'app.example.com' }), env)).toBe(false)
-    })
-  })
-
-  describe('Fetch Metadata is authoritative when present', () => {
-    test('cross-site is rejected regardless of Origin', () => {
-      expect(isCrossSiteBrowserRequest(req({ host: 'app.example.com', 'sec-fetch-site': 'cross-site' }), configured)).toBe(true)
-      expect(isCrossSiteBrowserRequest(req({ host: 'app.example.com', 'sec-fetch-site': 'cross-site', origin: 'https://app.example.com' }), configured)).toBe(true)
-    })
-
-    test('same-origin and none are accepted even when the proxy hides the public host', () => {
-      const internal = 'http://app-internal:3000/api/auth/login'
-      expect(isCrossSiteBrowserRequest(req({ host: 'app-internal:3000', origin: 'https://public.example.net', 'sec-fetch-site': 'same-origin' }, internal), {})).toBe(false)
-      expect(isCrossSiteBrowserRequest(req({ host: 'app-internal:3000', 'sec-fetch-site': 'none' }, internal), {})).toBe(false)
-    })
-
-    test('same-site falls back to the Origin allowlist', () => {
-      expect(isCrossSiteBrowserRequest(req({ host: 'app.example.com', origin: 'https://blog.example.com', 'sec-fetch-site': 'same-site' }), configured)).toBe(true)
-      expect(isCrossSiteBrowserRequest(req({ host: 'app.example.com', origin: 'https://ops.example.com', 'sec-fetch-site': 'same-site' }), {
-        ...configured,
-        APP_ALLOWED_ORIGINS: 'https://ops.example.com',
-      })).toBe(false)
-    })
-
-    test('an unknown Sec-Fetch-Site token falls back to the Origin check', () => {
-      expect(isCrossSiteBrowserRequest(req({ host: 'app.example.com', origin: 'https://evil.example', 'sec-fetch-site': 'bogus' }), configured)).toBe(true)
-      expect(isCrossSiteBrowserRequest(req({ host: 'app.example.com', origin: 'https://app.example.com', 'sec-fetch-site': 'bogus' }), configured)).toBe(false)
-    })
-  })
-
-  describe('Origin check (browsers without Fetch Metadata)', () => {
-    test('Origin: null is cross-site', () => {
-      expect(isCrossSiteBrowserRequest(req({ host: 'app.example.com', origin: 'null' }), configured)).toBe(true)
-    })
-
-    test('a malformed Origin is cross-site', () => {
-      expect(isCrossSiteBrowserRequest(req({ host: 'app.example.com', origin: 'not a url' }), configured)).toBe(true)
-    })
-
-    test('a foreign Origin is cross-site', () => {
-      expect(isCrossSiteBrowserRequest(req({ host: 'app.example.com', origin: 'https://evil.example' }), configured)).toBe(true)
-    })
-
-    test('Origin matching a configured origin (APP_URL / NEXT_PUBLIC_APP_URL / APP_ALLOWED_ORIGINS) is accepted', () => {
-      const internal = 'http://app-internal:3000/api/auth/login'
-      expect(isCrossSiteBrowserRequest(req({ host: 'app-internal:3000', origin: 'https://app.example.com' }, internal), configured)).toBe(false)
-      expect(isCrossSiteBrowserRequest(req({ host: 'app-internal:3000', origin: 'https://admin.example.com' }, internal), {
-        NEXT_PUBLIC_APP_URL: 'https://admin.example.com',
-      })).toBe(false)
-    })
-
-    test('Origin matching the request Host authority is accepted (portal custom domains, unconfigured dev)', () => {
-      expect(isCrossSiteBrowserRequest(req({ host: 'shop.acme.test', origin: 'https://shop.acme.test' }, 'https://shop.acme.test/api/customer_accounts/login'), configured)).toBe(false)
-      expect(isCrossSiteBrowserRequest(req({ host: 'localhost:3000', origin: 'http://localhost:3000' }, 'http://localhost:3000/api/auth/login'), unconfiguredDev)).toBe(false)
-    })
-
-    test('Origin matching X-Forwarded-Host is accepted even when the proxy did not forward the scheme', () => {
-      expect(isCrossSiteBrowserRequest(req({
-        host: 'app-internal:3000',
-        'x-forwarded-host': 'admin.example.com',
-        origin: 'https://admin.example.com',
-      }, 'http://app-internal:3000/api/auth/login'), {})).toBe(false)
-    })
-
-    test('a different port on the same host is cross-origin', () => {
-      expect(isCrossSiteBrowserRequest(req({ host: 'app.example.com', origin: 'https://app.example.com:8443' }), configured)).toBe(true)
-    })
-
-    test('a Host carrying the default port matches the Origin', () => {
-      expect(isCrossSiteBrowserRequest(req({
-        host: 'app.example.com:443',
-        'x-forwarded-proto': 'https',
-        origin: 'https://app.example.com',
-      }, 'http://app.example.com:443/api/auth/login'), {})).toBe(false)
-      expect(isCrossSiteBrowserRequest(req({
-        host: 'app.example.com:443',
-        origin: 'https://app.example.com',
-      }, 'http://app.example.com:443/api/auth/login'), {})).toBe(false)
-    })
-
-    test('an uppercase Host matches the Origin', () => {
-      expect(isCrossSiteBrowserRequest(req({ host: 'APP.Example.COM', origin: 'https://app.example.com' }), {})).toBe(false)
-    })
-
-    test('an IPv6 loopback Host matches the Origin in dev', () => {
-      expect(isCrossSiteBrowserRequest(req({ host: '[::1]:3000', origin: 'http://[::1]:3000' }, 'http://[::1]:3000/api/auth/login'), unconfiguredDev)).toBe(false)
-    })
-
-    test('only the first X-Forwarded-Host value is used', () => {
-      const internal = 'http://app-internal:3000/api/auth/login'
-      expect(isCrossSiteBrowserRequest(req({
-        host: 'app-internal:3000',
-        'x-forwarded-host': 'admin.example.com, evil.example',
-        origin: 'https://admin.example.com',
-      }, internal), {})).toBe(false)
-      expect(isCrossSiteBrowserRequest(req({
-        host: 'app-internal:3000',
-        'x-forwarded-host': 'admin.example.com, evil.example',
-        origin: 'https://evil.example',
-      }, internal), {})).toBe(true)
-    })
-
-    test('a forwarded scheme that differs from the Origin scheme is cross-origin', () => {
-      expect(isCrossSiteBrowserRequest(req({
-        host: 'app.example.com',
-        'x-forwarded-proto': 'https',
-        origin: 'http://app.example.com',
-      }), {})).toBe(true)
-    })
-  })
-
-  describe('Fetch Metadata without Origin', () => {
-    test('same-site without Origin is cross-site', () => {
-      expect(isCrossSiteBrowserRequest(req({ host: 'app.example.com', 'sec-fetch-site': 'same-site' }), configured)).toBe(true)
-    })
-
-    test('an unknown token without Origin is cross-site', () => {
-      expect(isCrossSiteBrowserRequest(req({ host: 'app.example.com', 'sec-fetch-site': 'bogus' }), configured)).toBe(true)
-    })
-
-    test('the Sec-Fetch-Site value is compared case- and whitespace-insensitively', () => {
-      expect(isCrossSiteBrowserRequest(req({ host: 'app.example.com', origin: 'https://app.example.com', 'sec-fetch-site': ' Cross-Site ' }), configured)).toBe(true)
-    })
-  })
-})