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

package/src/lib/query/engine.ts

@@ -38,13 +38,6 @@ import { resolveListCountCap } from './count-cap'
 import { mapWithConcurrency } from './bounded-decrypt'
 import { parseNumberWithDefault } from '../number'
 import { createLogger } from '../logger'
-import {
-  buildArrayColumnNoOverlapPredicate,
-  buildArrayColumnOverlapPredicate,
-  buildJsonbNoOverlapPredicate,
-  buildJsonbOverlapPredicate,
-  buildScalarOverlapPredicate,
-} from './overlap'
 
 const logger = createLogger('shared').child({ component: 'query' })
 
@@ -1223,11 +1216,7 @@ export class BasicQueryEngine implements QueryEngine {
           })
           continue
         }
-        q = f.op === 'overlap'
-          ? q.where(buildScalarOverlapPredicate(expr, f.value))
-          : f.op === 'noverlap'
-            ? q.where(sql<boolean>`false`)
-            : this.applyColumnOp(q, expr, f.op, f.value)
+        q = this.applyColumnOp(q, expr, f.op, f.value)
       }
 
       // OR groups are applied here, after the cf:* value expressions exist, so a
@@ -1274,10 +1263,7 @@ export class BasicQueryEngine implements QueryEngine {
                     value: rf.value,
                   })
                 }
-                if (rf.op === 'noverlap') return sql<boolean>`false`
-                return rf.op === 'overlap'
-                  ? buildScalarOverlapPredicate(cfValueExprByKey[rf.key], rf.value)
-                  : this.buildColumnOpExpression(eb, cfValueExprByKey[rf.key], rf.op, rf.value)
+                return this.buildColumnOpExpression(eb, cfValueExprByKey[rf.key], rf.op, rf.value)
               }
               return this.buildIndexDocOpExpression(eb, {
                 entity: String(entity),
@@ -1603,22 +1589,10 @@ export class BasicQueryEngine implements QueryEngine {
         return builder.where(column as any, '<', value as any)
       case 'lte':
         return builder.where(column as any, '<=', value as any)
-      case 'in': {
-        // An empty list ("no id survived validation", #7502) compiles to invalid
-        // SQL (`in ()`) under Kysely/Postgres — short-circuit to a predicate that
-        // never matches instead of letting the driver reject the query.
-        const inValues = Array.isArray(value) ? value : [value]
-        return inValues.length === 0
-          ? builder.where(sql<boolean>`false`)
-          : builder.where(column as any, 'in', inValues)
-      }
-      case 'nin': {
-        // Mirrors 'in' above: empty means "exclude nothing".
-        const ninValues = Array.isArray(value) ? value : [value]
-        return ninValues.length === 0
-          ? builder.where(sql<boolean>`true`)
-          : builder.where(column as any, 'not in', ninValues)
-      }
+      case 'in':
+        return builder.where(column as any, 'in', Array.isArray(value) ? value : [value])
+      case 'nin':
+        return builder.where(column as any, 'not in', Array.isArray(value) ? value : [value])
       case 'like':
         return builder.where(column as any, 'like', value as any)
       case 'ilike':
@@ -1627,10 +1601,6 @@ export class BasicQueryEngine implements QueryEngine {
         return value
           ? builder.where(column as any, 'is not', null)
           : builder.where(column as any, 'is', null)
-      case 'overlap':
-        return builder.where(buildArrayColumnOverlapPredicate(column, value))
-      case 'noverlap':
-        return builder.where(buildArrayColumnNoOverlapPredicate(column, value))
       default:
         return builder
     }
@@ -1764,11 +1734,6 @@ export class BasicQueryEngine implements QueryEngine {
       case 'exists':
         predicate = sql<boolean>`${caseExpr} is not null`
         break
-      case 'overlap':
-        predicate = buildScalarOverlapPredicate(caseExpr, value)
-        break
-      case 'noverlap':
-        return sql<boolean>`false`
       default:
         // Mirrors buildColumnOpExpression's unknown-op fallback: a neutral
         // predicate, so full and count shapes drop the same leaves.
@@ -1786,20 +1751,11 @@ export class BasicQueryEngine implements QueryEngine {
       case 'gte': return eb(column, '>=', value)
       case 'lt': return eb(column, '<', value)
       case 'lte': return eb(column, '<=', value)
-      case 'in': {
-        // Mirrors the guard in applyColumnOp above (#7502).
-        const inValues = Array.isArray(value) ? value : [value]
-        return inValues.length === 0 ? eb.val(false) : eb(column, 'in', inValues)
-      }
-      case 'nin': {
-        const ninValues = Array.isArray(value) ? value : [value]
-        return ninValues.length === 0 ? eb.val(true) : eb(column, 'not in', ninValues)
-      }
+      case 'in': return eb(column, 'in', Array.isArray(value) ? value : [value])
+      case 'nin': return eb(column, 'not in', Array.isArray(value) ? value : [value])
       case 'like': return eb(column, 'like', value)
       case 'ilike': return eb(column, 'ilike', value)
       case 'exists': return value ? eb(column, 'is not', null) : eb(column, 'is', null)
-      case 'overlap': return buildArrayColumnOverlapPredicate(column, value)
-      case 'noverlap': return buildArrayColumnNoOverlapPredicate(column, value)
       default: return eb.val(true)
     }
   }
@@ -2017,12 +1973,6 @@ export class BasicQueryEngine implements QueryEngine {
             ? sub.where(sql<boolean>`${textExpr} is not null`)
             : sub.where(sql<boolean>`${textExpr} is null`)
           break
-        case 'overlap':
-          sub = sub.where(buildJsonbOverlapPredicate(`${alias}.doc`, opts.field, opts.value))
-          break
-        case 'noverlap':
-          sub = sub.where(buildJsonbNoOverlapPredicate(`${alias}.doc`, opts.field, opts.value))
-          break
         default:
           break
       }

package/src/lib/query/join-utils.ts

@@ -7,7 +7,7 @@ type AnyBuilder = any
 
 export type NormalizedFilter = { field: string; op: FilterOp; value?: unknown; orGroup?: string; qualified?: string | null }
 
-const VALID_OPS = ['eq', 'ne', 'gt', 'gte', 'lt', 'lte', 'in', 'nin', 'like', 'ilike', 'exists', 'overlap', 'noverlap'] as const
+const VALID_OPS = ['eq', 'ne', 'gt', 'gte', 'lt', 'lte', 'in', 'nin', 'like', 'ilike', 'exists'] as const
 
 const normalizeField = (key: string) => (key.startsWith('cf_') ? `cf:${key.slice(3)}` : key)
 

package/src/lib/query/types.ts

@@ -2,17 +2,7 @@ import type { EntityId } from '@open-mercato/shared/modules/entities'
 import type { Profiler } from '../profiler'
 import type { ResolvedCustomFieldDefinitions } from '../crud/custom-field-definition-index'
 
-/**
- * `overlap` (additive, 2026-10-05): "has any of" over a multi-valued field. An index-document
- * string array compiles to jsonb `?|`, a `cf:*` key to any-value-in-set, and an array-typed base
- * column to `&&`. An empty value list matches nothing.
- *
- * `noverlap` (additive, 2026-10-05): "has none of" — the negation of `overlap` on an index-document
- * string array or an array-typed base column. Only a present array can match (a missing/null key or
- * NULL column never does); an empty value list excludes nothing. Unsupported on `cf:*` keys, where
- * it compiles to `false`.
- */
-export type FilterOp = 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte' | 'in' | 'nin' | 'like' | 'ilike' | 'exists' | 'overlap' | 'noverlap'
+export type FilterOp = 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte' | 'in' | 'nin' | 'like' | 'ilike' | 'exists'
 
 export enum SortDir {
   Asc = 'asc',
@@ -44,8 +34,6 @@ export type WhereOps<T> = {
   $like?: T extends string ? string : never
   $ilike?: T extends string ? string : never
   $exists?: boolean
-  $overlap?: T extends readonly (infer Element)[] ? Element[] : T[]
-  $noverlap?: T extends readonly (infer Element)[] ? Element[] : T[]
 }
 
 // A field filter can be a direct value (equals) or ops object

package/src/lib/url.ts

@@ -267,36 +267,6 @@ export function toSecurityEmailUrl(input: RequestInput, path: string, env: EnvLi
   return `${base}/${path.replace(/^\/+/, '')}`
 }
 
-export function isCrossSiteBrowserRequest(req: Request, env: EnvLike = process.env): boolean {
-  const rawFetchSite = req.headers.get('sec-fetch-site')
-  const fetchSite = rawFetchSite?.trim().toLowerCase() ?? null
-  if (fetchSite === 'cross-site') return true
-  if (fetchSite === 'same-origin' || fetchSite === 'none') return false
-
-  const rawOrigin = req.headers.get('origin')
-  if (rawOrigin === null) return rawFetchSite !== null
-  const origin = normalizeOrigin(rawOrigin)
-  if (!origin) return true
-
-  const allowedOrigins = readAllowedOrigins(env)
-  if (allowedOrigins.has(origin)) return false
-  if (shouldAllowLoopbackOrigin(origin, allowedOrigins, env)) return false
-
-  const forwardedProto = readFirstHeaderValue(req.headers.get('x-forwarded-proto'))
-  const protocol = forwardedProto
-    ? (forwardedProto.endsWith(':') ? forwardedProto : `${forwardedProto}:`)
-    : new URL(origin).protocol
-  const host = req.headers.get('host')
-  const forwardedHost = req.headers.get('x-forwarded-host')
-  if (originFromHost(protocol, forwardedHost) === origin) return false
-  if (originFromHost(protocol, host) === origin) return false
-
-  if (env.NODE_ENV !== 'test') {
-    logger.warn('Cross-site request rejected', { origin, host, forwardedHost })
-  }
-  return true
-}
-
 export function mapSecurityEmailUrlError(
   error: unknown,
   mapping: SecurityEmailUrlErrorMapping,

package/src/lib/webhooks/__tests__/body.test.ts

@@ -2,7 +2,6 @@
 import {
   DEFAULT_WEBHOOK_BODY_LIMIT_BYTES,
   readBoundedRequestBody,
-  readBoundedRequestBytes,
   resolveWebhookBodyLimitBytes,
   WebhookBodyTooLargeError,
 } from '../body'
@@ -78,53 +77,6 @@ describe('readBoundedRequestBody', () => {
   })
 })
 
-describe('readBoundedRequestBytes', () => {
-  it('preserves exact bytes including invalid UTF-8', async () => {
-    const bytes = new Uint8Array([0xff, 0xfe, 0x41, 0xc3, 0x28])
-    const { request } = makeStreamingRequest([bytes.slice(0, 2), bytes.slice(2)])
-
-    const result = await readBoundedRequestBytes(request, { maxBytes: bytes.byteLength })
-
-    expect(Array.from(result)).toEqual(Array.from(bytes))
-    expect(new TextDecoder().decode(result)).toContain('\uFFFD')
-  })
-
-  it('returns an empty array for a missing body', async () => {
-    const request = new Request('http://localhost/webhook', { method: 'POST' })
-
-    expect((await readBoundedRequestBytes(request)).byteLength).toBe(0)
-    await expect(readBoundedRequestBody(request)).resolves.toBe('')
-  })
-
-  it('enforces the declared and streamed limits and cancels the stream', async () => {
-    const declared = new Request('http://localhost/webhook', {
-      method: 'POST',
-      headers: { 'content-length': '6' },
-      body: 'ok',
-    })
-    await expect(readBoundedRequestBytes(declared, { maxBytes: 5 })).rejects.toBeInstanceOf(
-      WebhookBodyTooLargeError,
-    )
-
-    const { request, cancel } = makeStreamingRequest([
-      new Uint8Array([1, 2, 3]),
-      new Uint8Array([4, 5, 6]),
-      new Uint8Array([7, 8, 9]),
-    ])
-    await expect(readBoundedRequestBytes(request, { maxBytes: 5 })).rejects.toBeInstanceOf(
-      WebhookBodyTooLargeError,
-    )
-    expect(cancel).toHaveBeenCalled()
-  })
-
-  it('keeps the string reader decoding the same bytes', async () => {
-    const bytes = new TextEncoder().encode('zażółć')
-    const { request } = makeStreamingRequest([bytes])
-
-    await expect(readBoundedRequestBody(request)).resolves.toBe('zażółć')
-  })
-})
-
 describe('resolveWebhookBodyLimitBytes', () => {
   it('uses the documented default for missing or invalid configuration', () => {
     expect(resolveWebhookBodyLimitBytes(undefined)).toBe(DEFAULT_WEBHOOK_BODY_LIMIT_BYTES)

package/src/lib/webhooks/body.ts

@@ -23,10 +23,10 @@ export function resolveWebhookBodyLimitBytes(
   return Number.isSafeInteger(parsed) ? parsed : fallback
 }
 
-export async function readBoundedRequestBytes(
+export async function readBoundedRequestBody(
   request: Request,
   options?: { maxBytes?: number },
-): Promise<Uint8Array> {
+): Promise<string> {
   const configuredLimit = options?.maxBytes ?? resolveWebhookBodyLimitBytes()
   const maxBytes = Number.isSafeInteger(configuredLimit) && configuredLimit > 0
     ? configuredLimit
@@ -39,7 +39,7 @@ export async function readBoundedRequestBytes(
     }
   }
 
-  if (!request.body) return new Uint8Array(0)
+  if (!request.body) return ''
 
   const reader = request.body.getReader()
   const chunks: Uint8Array[] = []
@@ -66,12 +66,5 @@ export async function readBoundedRequestBytes(
     body.set(chunk, offset)
     offset += chunk.byteLength
   }
-  return body
-}
-
-export async function readBoundedRequestBody(
-  request: Request,
-  options?: { maxBytes?: number },
-): Promise<string> {
-  return new TextDecoder().decode(await readBoundedRequestBytes(request, options))
+  return new TextDecoder().decode(body)
 }

package/src/lib/webhooks/index.ts

@@ -4,7 +4,6 @@ export { generateWebhookSecret, parseWebhookSecret, isValidWebhookSecret } from
 export {
   DEFAULT_WEBHOOK_BODY_LIMIT_BYTES,
   readBoundedRequestBody,
-  readBoundedRequestBytes,
   resolveWebhookBodyLimitBytes,
   WebhookBodyTooLargeError,
 } from './body'

package/src/modules/integrations/types.ts

@@ -157,12 +157,6 @@ export interface IntegrationDetailPageConfig {
    * Provider modules can replace these with injected tabs using the same spot.
    */
   hiddenTabs?: IntegrationDetailBuiltInTab[]
-  /**
-   * Detail-page tab that holds the provider's Connect / Reconnect controls (a built-in tab id or
-   * an injected tab id). The OAuth reauth banner links to `?tab=<connectTabId>` while that tab is
-   * visible and the viewer holds `integrations.credentials.manage`.
-   */
-  connectTabId?: string
 }
 
 export type IntegrationDetailBuiltInTab =

package/src/modules/notifications/types.ts

@@ -3,13 +3,6 @@ import type { ComponentType } from 'react'
 export type NotificationStatus = 'unread' | 'read' | 'actioned' | 'dismissed'
 export type NotificationSeverity = 'info' | 'warning' | 'success' | 'error'
 
-/**
- * `code` of the 409 body `POST /api/notifications/:id/action` answers with when the notification's
- * action has already been executed. Lets a client tell that refusal apart from a 409 raised by
- * the action's own command.
- */
-export const NOTIFICATION_ACTION_ALREADY_EXECUTED_ERROR_CODE = 'notification_action_already_executed'
-
 export type NotificationAction = {
   id: string
   label: string

package/src/modules/payment_gateways/__tests__/types.test.ts

@@ -3,9 +3,6 @@ import {
   getWebhookHandler,
   registerWebhookHandler,
   type VerifyWebhookInput,
-  type WebhookLocatorContext,
-  type WebhookResponseOutcome,
-  WebhookVerificationUnavailableError,
   type WebhookEvent,
 } from '../types'
 
@@ -37,45 +34,4 @@ describe('payment gateway webhook registration', () => {
       expect(getWebhookHandler('invalid')).toBeUndefined()
     },
   )
-
-  it('stays compatible with one-argument locator hints', () => {
-    const readSessionIdHint = (payload: Record<string, unknown> | null) => (payload ? 'sess' : null)
-    registerWebhookHandler('legacy', handler, { readSessionIdHint })
-
-    expect(getWebhookHandler('legacy')?.readSessionIdHint?.({})).toBe('sess')
-    expect(getWebhookHandler('legacy')?.rawBody).toBeUndefined()
-    expect(getWebhookHandler('legacy')?.formatResponse).toBeUndefined()
-  })
-
-  it('passes through the optional extension hooks', () => {
-    const readSessionIdHint = (_payload: Record<string, unknown> | null, context?: WebhookLocatorContext) =>
-      context ? String(context.headers['x-id']) : null
-    const readPaymentIdHint = () => 'pay'
-    const formatResponse = (outcome: WebhookResponseOutcome) => ({ status: 200, body: outcome })
-    registerWebhookHandler('extended', handler, {
-      readSessionIdHint,
-      readPaymentIdHint,
-      rawBody: 'bytes',
-      formatResponse,
-    })
-
-    const registration = getWebhookHandler('extended')
-    expect(registration?.rawBody).toBe('bytes')
-    expect(registration?.readPaymentIdHint).toBe(readPaymentIdHint)
-    expect(registration?.formatResponse).toBe(formatResponse)
-    expect(registration?.readSessionIdHint?.(null, { rawBody: '', headers: { 'x-id': 'abc' } })).toBe('abc')
-  })
-
-  it('rejects an unknown rawBody mode', () => {
-    expect(() =>
-      registerWebhookHandler('bad', handler, { rawBody: 'stream' as unknown as 'text' }),
-    ).toThrow('[internal] Payment gateway webhook rawBody must be')
-    expect(getWebhookHandler('bad')).toBeUndefined()
-  })
-
-  it('exposes a typed verification-unavailable error', () => {
-    const error = new WebhookVerificationUnavailableError()
-    expect(error).toBeInstanceOf(Error)
-    expect(error.name).toBe('WebhookVerificationUnavailableError')
-  })
 })

package/src/modules/payment_gateways/types.ts

@@ -237,45 +237,6 @@ export interface VerifyWebhookInput {
   rawBody: string | Buffer
   headers: Record<string, string | string[] | undefined>
   credentials: Record<string, unknown>
-  /** Platform-resolved payment the webhook is expected to concern, when a locator found one. */
-  candidate?: WebhookCandidateSnapshot
-}
-
-/** Raw request material handed to webhook locator hints. */
-export interface WebhookLocatorContext {
-  rawBody: string | Buffer
-  headers: Record<string, string | string[] | undefined>
-}
-
-export interface WebhookCandidateSnapshot {
-  transactionId: string
-  paymentId: string
-  providerSessionId: string | null
-  amount: string
-  currencyCode: string
-}
-
-export type WebhookResponseOutcome =
-  | 'accepted'
-  | 'no_candidate'
-  | 'verification_failed'
-  | 'verification_unavailable'
-  | 'processing_failed'
-  | 'payload_too_large'
-  | 'rate_limited'
-
-export interface WebhookHttpResponse {
-  status: number
-  body: string | Record<string, unknown>
-  contentType?: string
-}
-
-/** Thrown by a webhook handler when verification cannot be performed (for example a provider outage). */
-export class WebhookVerificationUnavailableError extends Error {
-  constructor(message = 'Webhook verification is unavailable') {
-    super(message)
-    this.name = 'WebhookVerificationUnavailableError'
-  }
 }
 
 export interface WebhookEvent {
@@ -291,15 +252,10 @@ export interface WebhookEvent {
 export interface WebhookHandlerRegistration {
   handler: (input: VerifyWebhookInput) => Promise<WebhookEvent>
   queue?: string
-  readSessionIdHint?: (payload: Record<string, unknown> | null, context?: WebhookLocatorContext) => string | null
-  readPaymentIdHint?: (payload: Record<string, unknown> | null, context?: WebhookLocatorContext) => string | null
+  readSessionIdHint?: (payload: Record<string, unknown> | null) => string | null
   maxBodyBytes?: number
-  rawBody?: WebhookRawBodyMode
-  formatResponse?: (outcome: WebhookResponseOutcome) => WebhookHttpResponse
 }
 
-export type WebhookRawBodyMode = 'text' | 'bytes'
-
 // ── Adapter Registry Options ────────────────────────────────────────────────
 
 export interface RegisterAdapterOptions {
@@ -389,11 +345,12 @@ export function clearGatewayAdapters(): void {
 export function registerWebhookHandler(
   providerKey: string,
   handler: (input: VerifyWebhookInput) => Promise<WebhookEvent>,
-  options?: Omit<WebhookHandlerRegistration, 'handler'>,
+  options?: {
+    queue?: string
+    readSessionIdHint?: (payload: Record<string, unknown> | null) => string | null
+    maxBodyBytes?: number
+  },
 ): () => void {
-  if (options?.rawBody !== undefined && options.rawBody !== 'text' && options.rawBody !== 'bytes') {
-    throw new Error("[internal] Payment gateway webhook rawBody must be 'text' or 'bytes'")
-  }
   if (
     options?.maxBodyBytes !== undefined
     && (!Number.isSafeInteger(options.maxBodyBytes)
@@ -409,10 +366,7 @@ export function registerWebhookHandler(
     handler,
     queue: options?.queue,
     readSessionIdHint: options?.readSessionIdHint,
-    readPaymentIdHint: options?.readPaymentIdHint,
     maxBodyBytes: options?.maxBodyBytes,
-    rawBody: options?.rawBody,
-    formatResponse: options?.formatResponse,
   })
   return () => {
     webhookHandlerRegistry.delete(providerKey)

package/src/modules/registry.ts

@@ -178,11 +178,6 @@ export type ApiRouteManifestEntry = {
 export type ModuleCli = {
   command: string
   run: (argv: string[]) => Promise<void> | void
-  // Usage text printed by the `mercato` dispatcher when the command is invoked with --help/-h.
-  help?: string
-  // Set when the command parses --help/-h itself; the dispatcher then forwards the flag
-  // instead of intercepting it, so the command can print its own richer usage text.
-  handlesHelp?: boolean
 }
 
 export type ModuleSubscriber = {

package/src/modules/search.ts

@@ -94,39 +94,6 @@ export type SearchOptions = {
   offset?: number
   /** How to combine results: 'or' merges all, 'and' requires match in all strategies */
   combineMode?: 'or' | 'and'
-  /**
-   * Restricts results to records whose query-index row (`entity_indexes`) matches this predicate,
-   * evaluated inside the strategy's ranking query so a restrictive filter never starves the result
-   * set (additive, 2026-10-06). Only strategies with `supportsIndexDocFilter: true` receive a
-   * filtered search; any other strategy returns no results for it rather than unfiltered ones.
-   */
-  indexDocFilter?: SearchIndexDocFilter
-}
-
-/**
- * One condition over a record's query-index document (`entity_indexes.doc`), with the query
- * engine's index-document semantics:
- * - `exists`: the key is present and not JSON `null`;
- * - `eq`: the key's text value equals `value` (booleans and numbers compare by their JSON text);
- * - `overlap`: the key holds an array sharing at least one entry with `values`; empty `values`
- *   matches nothing;
- * - `noverlap`: the key holds an array sharing no entry with `values`; a missing key never matches;
- * - `recordIdNotIn`: the record id is none of `values`.
- */
-export type SearchIndexDocCondition =
-  | { op: 'exists'; key: string }
-  | { op: 'eq'; key: string; value: string | number | boolean }
-  | { op: 'overlap'; key: string; values: string[] }
-  | { op: 'noverlap'; key: string; values: string[] }
-  | { op: 'recordIdNotIn'; values: string[] }
-
-/**
- * A predicate over a record's `entity_indexes` row in disjunctive normal form: the record matches
- * when its index row is not deleted and every condition of at least one `anyOf` branch holds.
- * An empty `anyOf` matches nothing; an empty branch matches every indexed record.
- */
-export type SearchIndexDocFilter = {
-  anyOf: SearchIndexDocCondition[][]
 }
 
 // =============================================================================
@@ -177,12 +144,6 @@ export interface SearchStrategy {
   /** Priority for result merging (higher = more prominent in results) */
   readonly priority: number
 
-  /**
-   * Whether `search()` applies `SearchOptions.indexDocFilter` inside its ranking query. Absent or
-   * `false` means the strategy is skipped for filtered searches (fail closed).
-   */
-  readonly supportsIndexDocFilter?: boolean
-
   /** Check if strategy is available and configured */
   isAvailable(): Promise<boolean>
 

package/src/modules/widgets/injection-loader.ts

@@ -141,41 +141,11 @@ function notifyInjectionRegistryChanged() {
   }))
 }
 
-export type RegisterCoreInjectionWidgetsOptions = {
-  /**
-   * `replace` (default) publishes `entries` as the whole registry.
-   *
-   * `merge` adds only the entries the registry does not already carry, keeping whatever a
-   * previous bootstrap published. A process may run more than one bootstrap partition (the
-   * API-only one and the full page one share a Node process in a mixed web host), and the
-   * partition that registers second must not shrink the registry the first one populated.
-   */
-  mode?: 'replace' | 'merge'
-}
-
-export function registerCoreInjectionWidgets(
-  entries: ModuleInjectionWidgetEntry[],
-  options: RegisterCoreInjectionWidgetsOptions = {},
-) {
-  if (_coreInjectionWidgetEntries !== null && process.env.NODE_ENV === 'development' && options.mode !== 'merge') {
+export function registerCoreInjectionWidgets(entries: ModuleInjectionWidgetEntry[]) {
+  if (_coreInjectionWidgetEntries !== null && process.env.NODE_ENV === 'development') {
     logger.debug('Core injection widgets re-registered (this may occur during HMR)')
   }
-  const incoming = applyInjectionWidgetOverridesToEntries(entries)
-  if (options.mode !== 'merge') {
-    _coreInjectionWidgetEntries = incoming
-    writeGlobalInjectionWidgets(incoming)
-    notifyInjectionRegistryChanged()
-    return
-  }
-
-  const existing = readGlobalInjectionWidgets() ?? _coreInjectionWidgetEntries ?? []
-  const known = new Set(existing.map((entry) => entry.key))
-  const added = incoming.filter((entry) => !known.has(entry.key))
-  // Nothing to contribute: leave the registry exactly as it was. Publishing an empty array here
-  // would turn "never registered" into "registered with no widgets", which downgrades the loud
-  // bootstrap error into silently missing contributions.
-  if (!added.length) return
-  const finalEntries = [...existing, ...added]
+  const finalEntries = applyInjectionWidgetOverridesToEntries(entries)
   _coreInjectionWidgetEntries = finalEntries
   writeGlobalInjectionWidgets(finalEntries)
   notifyInjectionRegistryChanged()

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

@@ -1,6 +0,0 @@
-import { resolveNextSubpathAsync } from "./next-subpath-resolve-hook.js";
-const resolve = resolveNextSubpathAsync;
-export {
-  resolve
-};
-//# sourceMappingURL=next-subpath-resolve-hook-worker.js.map

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

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/lib/bootstrap/next-subpath-resolve-hook-worker.ts"],
-  "sourcesContent": ["import { resolveNextSubpathAsync } from './next-subpath-resolve-hook'\n\nexport const resolve = resolveNextSubpathAsync\n"],
-  "mappings": "AAAA,SAAS,+BAA+B;AAEjC,MAAM,UAAU;",
-  "names": []
-}