@omnicross/core 0.1.10 → 0.2.1

package/dist/chunk-7RJI3NDI.cjs

@@ -0,0 +1,236 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/search/egress.ts
+var _dns = require('dns');
+var _net = require('net');
+
+
+
+var _searchtypes = require('@omnicross/contracts/search-types');
+var _undici = require('undici');
+var DEFAULT_SEARCH_EGRESS_POLICY = Object.freeze({});
+var ALLOWED_SCHEMES = /* @__PURE__ */ new Set(["http:", "https:"]);
+var METADATA_HOSTNAMES = /* @__PURE__ */ new Set(["metadata.google.internal"]);
+var DENIAL_TEXT = Object.freeze({
+  scheme: "only http and https are permitted",
+  malformed: "the request target is not a valid absolute URL",
+  loopback: "loopback addresses are not permitted",
+  unspecified: "unspecified addresses are not permitted",
+  "link-local": "link-local addresses are not permitted",
+  private: "private addresses are not permitted",
+  "unique-local": "unique-local addresses are not permitted",
+  metadata: "cloud metadata endpoints are not permitted"
+});
+function validateEgressUrl(url, policy = DEFAULT_SEARCH_EGRESS_POLICY, providerId) {
+  let parsed;
+  try {
+    parsed = url instanceof URL ? url : new URL(url);
+  } catch (e) {
+    throw egressDenied("unknown-host", "malformed", providerId);
+  }
+  if (!ALLOWED_SCHEMES.has(parsed.protocol)) {
+    throw egressDenied(parsed.hostname || "unknown-host", "scheme", providerId, parsed.protocol);
+  }
+  const hostname = parsed.hostname;
+  if (isAllowlisted(hostname, policy)) return parsed;
+  const denial = classifyHostname(hostname);
+  if (denial) throw egressDenied(hostname, denial, providerId);
+  return parsed;
+}
+function assertEgressAddressAllowed(address, hostname, policy = DEFAULT_SEARCH_EGRESS_POLICY, providerId) {
+  if (isAllowlisted(hostname, policy)) return;
+  const denial = classifyAddress(address);
+  if (denial) throw egressDenied(hostname, denial, providerId, void 0, address);
+}
+function isAllowlisted(hostname, policy) {
+  const allowed = policy.allowedPrivateHosts;
+  if (!allowed || allowed.length === 0) return false;
+  const normalized = normalizeHostname(hostname);
+  return allowed.some((entry) => normalizeHostname(entry) === normalized);
+}
+function normalizeHostname(hostname) {
+  const trimmed = hostname.trim().toLowerCase().replace(/\.+$/, "");
+  return trimmed.startsWith("[") && trimmed.endsWith("]") ? trimmed.slice(1, -1) : trimmed;
+}
+function classifyHostname(hostname) {
+  const candidate = normalizeHostname(hostname);
+  if (candidate === "") return "malformed";
+  const version = _net.isIP.call(void 0, candidate);
+  if (version !== 0) return classifyAddress(candidate);
+  if (candidate === "localhost" || candidate.endsWith(".localhost")) return "loopback";
+  if (METADATA_HOSTNAMES.has(candidate)) return "metadata";
+  return void 0;
+}
+function classifyAddress(address) {
+  const candidate = normalizeHostname(address);
+  const version = _net.isIP.call(void 0, candidate);
+  if (version === 4) return classifyIPv4(candidate);
+  if (version === 6) return classifyIPv6(candidate);
+  return "malformed";
+}
+function classifyIPv4(address) {
+  const octets = address.split(".").map((part) => Number.parseInt(part, 10));
+  if (octets.length !== 4 || octets.some((octet) => !Number.isInteger(octet))) return "malformed";
+  const [a, b, c, d] = octets;
+  if (a === 127) return "loopback";
+  if (a === 0) return "unspecified";
+  if (a === 10) return "private";
+  if (a === 172 && b >= 16 && b <= 31) return "private";
+  if (a === 192 && b === 168) return "private";
+  if (a === 169 && b === 254 && c === 169 && d === 254) return "metadata";
+  if (a === 169 && b === 254) return "link-local";
+  return void 0;
+}
+function classifyIPv6(address) {
+  const pieces = parseIPv6Pieces(address);
+  if (!pieces) return "malformed";
+  const topIsZero = pieces.slice(0, 5).every((piece) => piece === 0);
+  if (topIsZero && (pieces[5] === 65535 || pieces[5] === 0)) {
+    const embedded = [pieces[6] >> 8, pieces[6] & 255, pieces[7] >> 8, pieces[7] & 255];
+    const isLoopbackOrUnspecified = pieces[5] === 0 && pieces[6] === 0 && pieces[7] <= 1;
+    if (isLoopbackOrUnspecified) return pieces[7] === 1 ? "loopback" : "unspecified";
+    return classifyIPv4(embedded.join("."));
+  }
+  if ((pieces[0] & 65472) === 65152) return "link-local";
+  if ((pieces[0] & 65024) === 64512) return "unique-local";
+  return void 0;
+}
+function parseIPv6Pieces(address) {
+  let text = address.split("%")[0];
+  const lastColon = text.lastIndexOf(":");
+  const tail = text.slice(lastColon + 1);
+  if (tail.includes(".")) {
+    if (_net.isIP.call(void 0, tail) !== 4) return void 0;
+    const octets = tail.split(".").map((part) => Number.parseInt(part, 10));
+    const high = (octets[0] << 8 | octets[1]).toString(16);
+    const low = (octets[2] << 8 | octets[3]).toString(16);
+    text = `${text.slice(0, lastColon + 1)}${high}:${low}`;
+  }
+  const halves = text.split("::");
+  if (halves.length > 2) return void 0;
+  const head = halves[0] === "" ? [] : halves[0].split(":");
+  const rest = halves.length === 2 ? halves[1] === "" ? [] : halves[1].split(":") : [];
+  let groups;
+  if (halves.length === 1) {
+    if (head.length !== 8) return void 0;
+    groups = head;
+  } else {
+    const zeros = 8 - head.length - rest.length;
+    if (zeros < 1) return void 0;
+    groups = [...head, ...Array.from({ length: zeros }, () => "0"), ...rest];
+  }
+  const pieces = [];
+  for (const group of groups) {
+    if (!/^[0-9a-f]{1,4}$/i.test(group)) return void 0;
+    pieces.push(Number.parseInt(group, 16));
+  }
+  return pieces;
+}
+function egressDenied(hostname, reason, providerId, scheme, resolvedAddress) {
+  const subject = scheme ? `scheme "${scheme}"` : `host "${hostname}"`;
+  const via = resolvedAddress ? ` (resolved to a ${reason} address)` : "";
+  const details = { host: hostname, egressClass: reason };
+  if (resolvedAddress) details.egressStage = "dns";
+  return new (0, _searchtypes.SearchProviderError)(
+    "policy_denied",
+    `egress policy denied ${subject}${via}: ${DENIAL_TEXT[reason]}`,
+    {
+      providerId,
+      retryable: false,
+      details
+    }
+  );
+}
+function findEgressDenial(error) {
+  let current = error;
+  for (let depth = 0; depth < 6 && current !== void 0 && current !== null; depth += 1) {
+    if (_searchtypes.isSearchProviderError.call(void 0, current) && current.code === "policy_denied") {
+      return current;
+    }
+    current = current instanceof Error ? current.cause : void 0;
+  }
+  return void 0;
+}
+function createEgressGuardedLookup(policy = DEFAULT_SEARCH_EGRESS_POLICY, lookupImpl = _dns.lookup) {
+  const guarded = (hostname, options, callback) => {
+    const requestedAll = Boolean(_optionalChain([options, 'optionalAccess', _ => _.all]));
+    const lookupOptions = { ...options, all: true };
+    lookupImpl(hostname, lookupOptions, (error, addresses) => {
+      if (error) {
+        callback(error);
+        return;
+      }
+      const entries = Array.isArray(addresses) ? addresses : [];
+      if (entries.length === 0) {
+        callback(new Error(`no addresses resolved for ${hostname}`));
+        return;
+      }
+      try {
+        for (const entry of entries) assertEgressAddressAllowed(entry.address, hostname, policy);
+      } catch (denial) {
+        callback(denial);
+        return;
+      }
+      if (requestedAll) callback(null, entries);
+      else callback(null, entries[0].address, entries[0].family);
+    });
+  };
+  return guarded;
+}
+var guardedDispatchers = /* @__PURE__ */ new Map();
+function createEgressGuardedDispatcher(policy = DEFAULT_SEARCH_EGRESS_POLICY, lookupImpl) {
+  if (lookupImpl) {
+    return new (0, _undici.Agent)({ connect: { lookup: createEgressGuardedLookup(policy, lookupImpl) } });
+  }
+  const signature = JSON.stringify(normalizePolicy(policy));
+  const cached = guardedDispatchers.get(signature);
+  if (cached) return cached;
+  const dispatcher = new (0, _undici.Agent)({ connect: { lookup: createEgressGuardedLookup(policy) } });
+  guardedDispatchers.set(signature, dispatcher);
+  return dispatcher;
+}
+function normalizePolicy(policy) {
+  return {
+    allowedPrivateHosts: [..._nullishCoalesce(policy.allowedPrivateHosts, () => ( []))].map(normalizeHostname).sort((left, right) => left < right ? -1 : left > right ? 1 : 0)
+  };
+}
+
+// src/search/http/proxy.ts
+
+var cachedProxySignature = "";
+var cachedProxyDispatcher;
+function resolveSearchProxySettings(env = process.env) {
+  const allProxy = firstNonEmpty(env.all_proxy, env.ALL_PROXY);
+  const httpProxy = firstNonEmpty(env.http_proxy, env.HTTP_PROXY, allProxy);
+  const httpsProxy = firstNonEmpty(env.https_proxy, env.HTTPS_PROXY, allProxy);
+  if (!httpProxy && !httpsProxy) return void 0;
+  const noProxy = firstNonEmpty(env.no_proxy, env.NO_PROXY);
+  return {
+    ...httpProxy ? { httpProxy } : {},
+    ...httpsProxy ? { httpsProxy } : {},
+    ...noProxy ? { noProxy } : {}
+  };
+}
+function getSearchProxyDispatcher(proxy) {
+  const signature = JSON.stringify(proxy);
+  if (cachedProxyDispatcher && cachedProxySignature === signature) return cachedProxyDispatcher;
+  cachedProxySignature = signature;
+  cachedProxyDispatcher = new (0, _undici.EnvHttpProxyAgent)(proxy);
+  return cachedProxyDispatcher;
+}
+function firstNonEmpty(...values) {
+  for (const value of values) {
+    const trimmed = _optionalChain([value, 'optionalAccess', _2 => _2.trim, 'call', _3 => _3()]);
+    if (trimmed) return trimmed;
+  }
+  return void 0;
+}
+
+
+
+
+
+
+
+
+
+
+exports.DEFAULT_SEARCH_EGRESS_POLICY = DEFAULT_SEARCH_EGRESS_POLICY; exports.validateEgressUrl = validateEgressUrl; exports.assertEgressAddressAllowed = assertEgressAddressAllowed; exports.findEgressDenial = findEgressDenial; exports.createEgressGuardedLookup = createEgressGuardedLookup; exports.createEgressGuardedDispatcher = createEgressGuardedDispatcher; exports.resolveSearchProxySettings = resolveSearchProxySettings; exports.getSearchProxyDispatcher = getSearchProxyDispatcher;

package/dist/{chunk-IIRPUVPH.cjs → chunk-7ZHBN75N.cjs}

@@ -30,6 +30,7 @@ var TransformerChainExecutor = class {
       providerName: provider.name
     };
     let requestBody = request;
+    let endpointRequest;
     let config = {};
     let bypass = false;
     bypass = this.shouldBypassTransformers(
@@ -60,6 +61,7 @@ var TransformerChainExecutor = class {
         this.logger.error(`transformRequestOut error: ${this.getErrorMessage(error)}`);
         throw error;
       }
+      endpointRequest = requestBody;
     }
     if (!bypass && chain.providerTransformers.length > 0) {
       this.logger.debug(`Executing ${chain.providerTransformers.length} provider transformers`);
@@ -118,7 +120,7 @@ var TransformerChainExecutor = class {
         true
       );
     }
-    return { requestBody, config, bypass };
+    return { requestBody, endpointRequest, config, bypass };
   }
   /**
    * Execute the response transformation chain

package/dist/chunk-D4WNI6BR.cjs

@@ -0,0 +1,386 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;
+
+var _chunkHL2YSPL7cjs = require('./chunk-HL2YSPL7.cjs');
+
+// src/search/orchestrator.ts
+var _searchtypes = require('@omnicross/contracts/search-types');
+var _crypto = require('crypto');
+
+// src/search/normalize.ts
+var DEFAULT_NORMALIZED_MAX_RESULTS = 5;
+var SERP_REDIRECT_RULES = [
+  { domain: "google.com", paths: ["/search", "/goto"] },
+  { domain: "bing.com", paths: ["/search"] },
+  { domain: "duckduckgo.com", paths: ["/html/", "/l/"] },
+  { domain: "baidu.com", paths: ["/s"] }
+];
+function isDirectResultUrl(rawUrl) {
+  let url;
+  try {
+    url = new URL(rawUrl);
+  } catch (e) {
+    return false;
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") return false;
+  const host = url.hostname.toLowerCase();
+  for (const rule of SERP_REDIRECT_RULES) {
+    if (host !== rule.domain && !host.endsWith(`.${rule.domain}`)) continue;
+    if (rule.paths.includes(url.pathname)) return false;
+  }
+  return true;
+}
+function normalizedResultLimit(maxResults) {
+  const requested = maxResults === void 0 || !Number.isFinite(maxResults) ? DEFAULT_NORMALIZED_MAX_RESULTS : Math.floor(maxResults);
+  return Math.max(1, requested);
+}
+function normalizeSearchResults(results, maxResults) {
+  const limit = normalizedResultLimit(maxResults);
+  const seenUrls = /* @__PURE__ */ new Set();
+  const normalized = [];
+  for (const result of results) {
+    if (result === null || typeof result !== "object") continue;
+    const title = typeof result.title === "string" ? result.title.trim() : "";
+    const url = typeof result.url === "string" ? result.url.trim() : "";
+    if (title.length === 0 || !isDirectResultUrl(url)) continue;
+    if (seenUrls.has(url)) continue;
+    seenUrls.add(url);
+    normalized.push({
+      title,
+      url,
+      content: typeof result.content === "string" ? result.content.trim() : ""
+    });
+    if (normalized.length >= limit) break;
+  }
+  return normalized;
+}
+
+// src/search/orchestrator.ts
+var QUERY_HASH_LENGTH = 12;
+function hashSearchQuery(query) {
+  return _crypto.createHash.call(void 0, "sha256").update(query).digest("hex").slice(0, QUERY_HASH_LENGTH);
+}
+var SearchOrchestrator = class {
+  
+  
+  
+  constructor(registry, options = {}) {
+    this.registry = registry;
+    this.defaultPolicy = _nullishCoalesce(options.policy, () => ( {}));
+    this.onEvent = options.onEvent;
+  }
+  /**
+   * Run one search.
+   *
+   * @param request - the query, an optional pinned provider, and per-request
+   *   options. `options` is passed to the provider untouched: providers own
+   *   their own timeouts and the orchestrator adds no second timeout layer.
+   * @param policyOverride - per-request policy, merged field-by-field over the
+   *   orchestrator's default.
+   * @throws {SearchProviderError} when no provider produced a response.
+   */
+  async search(request, policyOverride) {
+    const policy = { ...this.defaultPolicy, ...policyOverride };
+    const requestId = _crypto.randomUUID.call(void 0, );
+    const queryHash = hashSearchQuery(request.query);
+    const startedAt = Date.now();
+    const attempts = [];
+    const emitComplete = (providerId, resultCount) => {
+      this.emit({
+        type: "search_complete",
+        requestId,
+        queryHash,
+        ...providerId === void 0 ? {} : { providerId },
+        resultCount,
+        fallbackCount: fallbackCountOf(attempts),
+        durationMs: Date.now() - startedAt
+      });
+    };
+    let plan;
+    try {
+      plan = this.planCandidates(request, policy);
+    } catch (error) {
+      emitComplete(void 0, 0);
+      throw error;
+    }
+    if (plan.skippedPreferred !== void 0) {
+      this.emit({
+        type: "search_attempt",
+        requestId,
+        queryHash,
+        providerId: plan.skippedPreferred.providerId,
+        outcome: "failed",
+        errorCode: plan.skippedPreferred.errorCode,
+        durationMs: 0
+      });
+    }
+    let lastError;
+    for (const candidate of plan.candidates) {
+      const attemptStartedAt = Date.now();
+      try {
+        const produced = await candidate.provider.search(request.query, request.options);
+        const durationMs = Date.now() - attemptStartedAt;
+        const results = normalizeSearchResults(produced, _optionalChain([request, 'access', _ => _.options, 'optionalAccess', _2 => _2.maxResults]));
+        attempts.push({
+          providerId: candidate.id,
+          outcome: "success",
+          resultCount: results.length,
+          durationMs
+        });
+        this.emit({
+          type: "search_attempt",
+          requestId,
+          queryHash,
+          providerId: candidate.id,
+          outcome: "success",
+          resultCount: results.length,
+          durationMs
+        });
+        emitComplete(candidate.id, results.length);
+        return {
+          query: request.query,
+          providerId: candidate.id,
+          results,
+          attempts,
+          fallbackCount: fallbackCountOf(attempts)
+        };
+      } catch (error) {
+        const durationMs = Date.now() - attemptStartedAt;
+        const shape = _searchtypes.toSearchErrorShape.call(void 0, error);
+        const isCancelled = shape.code === "cancelled" || _optionalChain([request, 'access', _3 => _3.options, 'optionalAccess', _4 => _4.signal, 'optionalAccess', _5 => _5.aborted]) === true;
+        const errorCode = isCancelled ? "cancelled" : shape.code;
+        attempts.push({
+          providerId: candidate.id,
+          outcome: "failed",
+          errorCode,
+          durationMs
+        });
+        this.emit({
+          type: "search_attempt",
+          requestId,
+          queryHash,
+          providerId: candidate.id,
+          outcome: "failed",
+          errorCode,
+          durationMs
+        });
+        if (isCancelled) {
+          emitComplete(void 0, 0);
+          throw shape.code === "cancelled" ? error : new (0, _searchtypes.SearchProviderError)("cancelled", "search was cancelled by the caller", {
+            providerId: candidate.id,
+            retryable: false,
+            cause: error
+          });
+        }
+        lastError = asSearchProviderError(error, shape.code, shape.message, candidate.id);
+      }
+    }
+    emitComplete(void 0, 0);
+    throw exhaustionError(attempts, lastError);
+  }
+  /** Resolve the candidate list for one request. */
+  planCandidates(request, policy) {
+    if (request.provider !== void 0) {
+      const pinned = this.registry.get(request.provider);
+      if (pinned === void 0) {
+        throw new (0, _searchtypes.SearchProviderError)(
+          "upstream_unavailable",
+          `search provider '${request.provider}' is not registered in this runtime`,
+          { providerId: request.provider, retryable: false }
+        );
+      }
+      if (!isAllowed(pinned.id, policy)) {
+        throw new (0, _searchtypes.SearchProviderError)(
+          "policy_denied",
+          `search provider '${request.provider}' is not allowed by the active search policy`,
+          { providerId: request.provider, retryable: false }
+        );
+      }
+      return { candidates: [pinned] };
+    }
+    const allowed = this.registry.list().filter((entry) => isAllowed(entry.id, policy));
+    let ordered = allowed;
+    let skippedPreferred;
+    if (policy.preferred !== void 0) {
+      const preferred = allowed.find((entry) => entry.id === policy.preferred);
+      if (preferred === void 0) {
+        skippedPreferred = {
+          providerId: policy.preferred,
+          errorCode: this.registry.has(policy.preferred) ? "policy_denied" : "upstream_unavailable"
+        };
+      } else {
+        ordered = [preferred, ...allowed.filter((entry) => entry.id !== preferred.id)];
+      }
+    }
+    if (policy.fallbackEnabled === false) ordered = ordered.slice(0, 1);
+    if (policy.maxAttempts !== void 0) {
+      ordered = ordered.slice(0, Math.max(0, Math.floor(policy.maxAttempts)));
+    }
+    return { candidates: ordered, ...skippedPreferred === void 0 ? {} : { skippedPreferred } };
+  }
+  /** Deliver one event. A listener that throws must never fail a search. */
+  emit(event) {
+    if (this.onEvent === void 0) return;
+    try {
+      this.onEvent(event);
+    } catch (e2) {
+    }
+  }
+};
+function fallbackCountOf(attempts) {
+  return Math.max(0, attempts.length - 1);
+}
+function isAllowed(id, policy) {
+  return policy.allowed === void 0 || policy.allowed.includes(id);
+}
+function asSearchProviderError(error, code, message, providerId) {
+  if (error instanceof _searchtypes.SearchProviderError) return error;
+  return new (0, _searchtypes.SearchProviderError)(code, message, { providerId, cause: error });
+}
+function exhaustionError(attempts, lastError) {
+  if (attempts.length === 1 && lastError !== void 0) return lastError;
+  if (attempts.length === 0) {
+    return new (0, _searchtypes.SearchProviderError)(
+      "upstream_unavailable",
+      "no eligible search provider was available (0 attempts)",
+      { retryable: false }
+    );
+  }
+  const trail = attempts.map((attempt) => `${attempt.providerId}:${_nullishCoalesce(attempt.errorCode, () => ( "unknown"))}`).join(",");
+  return new (0, _searchtypes.SearchProviderError)(
+    _nullishCoalesce(_optionalChain([lastError, 'optionalAccess', _6 => _6.code]), () => ( "upstream_unavailable")),
+    `search failed after ${attempts.length} attempt(s)`,
+    { retryable: _optionalChain([lastError, 'optionalAccess', _7 => _7.retryable]), details: { attempts: trail }, cause: lastError }
+  );
+}
+
+// src/search/registry.ts
+var SearchRegistryError = class _SearchRegistryError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SearchRegistryError";
+    Object.setPrototypeOf(this, _SearchRegistryError.prototype);
+  }
+};
+var SearchProviderRegistry = (_class = class {
+  __init() {this.entries = /* @__PURE__ */ new Map()}
+  
+  __init2() {this.nextSequence = 0}
+  constructor(options = {}) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);
+    this.allowBuiltinOverride = options.allowBuiltinOverride === true;
+  }
+  /**
+   * Register one provider.
+   *
+   * @param contribution - the provider with its origin, transport, and
+   *   capabilities declared.
+   * @param context - who is registering, for a Phase-2 host. Retained as-is;
+   *   no rule reads it today, and the parameter exists so adding one later is
+   *   not a signature change for every caller.
+   * @throws {SearchRegistryError} on a blank id, a duplicate id, or a host
+   *   contribution colliding with a builtin without `allowBuiltinOverride`.
+   */
+  register(contribution, context) {
+    const id = contribution.id;
+    if (typeof id !== "string" || id.trim().length === 0) {
+      throw new SearchRegistryError("a search provider contribution needs a non-blank id");
+    }
+    const existing = this.entries.get(id);
+    let sequence = this.nextSequence;
+    if (existing !== void 0) {
+      const isPermittedOverride = this.allowBuiltinOverride && contribution.source === "host" && existing.contribution.source === "builtin";
+      if (!isPermittedOverride) {
+        throw new SearchRegistryError(
+          existing.contribution.source === "builtin" && contribution.source === "host" ? `search provider '${id}' is a builtin; overriding it requires allowBuiltinOverride` : `search provider '${id}' is already registered`
+        );
+      }
+      sequence = existing.sequence;
+    } else {
+      this.nextSequence += 1;
+    }
+    this.entries.set(id, { contribution, context, sequence });
+  }
+  /** Whether an id is currently registered. */
+  has(id) {
+    return this.entries.has(id);
+  }
+  /** The contribution registered under `id`, if any. */
+  get(id) {
+    return _optionalChain([this, 'access', _8 => _8.entries, 'access', _9 => _9.get, 'call', _10 => _10(id), 'optionalAccess', _11 => _11.contribution]);
+  }
+  /**
+   * Remove a provider.
+   *
+   * The Phase-2 host-disconnect hook: when a host goes away its contributions
+   * go with it, and the id becomes free to register again.
+   *
+   * @returns whether something was removed.
+   */
+  unregister(id) {
+    return this.entries.delete(id);
+  }
+  /**
+   * Every registered contribution, in candidate order.
+   *
+   * `priorityHint` ascending; contributions without a hint come AFTER every
+   * hinted one (an absent hint is "no opinion", not "highest priority"); ties
+   * keep registration order. The builtin HTTP contributions carry no hints, so
+   * today this is exactly registration order.
+   */
+  list() {
+    return [...this.entries.values()].sort((a, b) => {
+      const aHint = a.contribution.priorityHint;
+      const bHint = b.contribution.priorityHint;
+      if (aHint !== bHint) {
+        if (aHint === void 0) return 1;
+        if (bHint === void 0) return -1;
+        return aHint - bHint;
+      }
+      return a.sequence - b.sequence;
+    }).map((entry) => entry.contribution);
+  }
+}, _class);
+
+// src/search/runtime.ts
+function createSearchRuntime(options = {}) {
+  const registry = new SearchProviderRegistry({
+    allowBuiltinOverride: options.allowBuiltinOverride === true
+  });
+  for (const contribution of _nullishCoalesce(options.contributions, () => ( _chunkHL2YSPL7cjs.builtinHttpSearchContributions.call(void 0, )))) {
+    registry.register(contribution);
+  }
+  const orchestrator = new SearchOrchestrator(registry, {
+    ...options.policy === void 0 ? {} : { policy: options.policy },
+    ...options.onEvent === void 0 ? {} : { onEvent: options.onEvent }
+  });
+  return {
+    search(request) {
+      return orchestrator.search(request);
+    },
+    registerContribution(contribution, context) {
+      registry.register(contribution, context);
+    },
+    unregisterContribution(id) {
+      return registry.unregister(id);
+    },
+    listProviders() {
+      return registry.list().map((contribution) => ({
+        id: contribution.id,
+        source: contribution.source,
+        kind: contribution.kind,
+        capabilities: { ...contribution.capabilities }
+      }));
+    }
+  };
+}
+
+
+
+
+
+
+
+
+
+
+
+exports.DEFAULT_NORMALIZED_MAX_RESULTS = DEFAULT_NORMALIZED_MAX_RESULTS; exports.isDirectResultUrl = isDirectResultUrl; exports.normalizedResultLimit = normalizedResultLimit; exports.normalizeSearchResults = normalizeSearchResults; exports.hashSearchQuery = hashSearchQuery; exports.SearchOrchestrator = SearchOrchestrator; exports.SearchRegistryError = SearchRegistryError; exports.SearchProviderRegistry = SearchProviderRegistry; exports.createSearchRuntime = createSearchRuntime;