@konneal/engine 0.2.1 → 0.2.3

package/workers/worker_public/src/index.ts

@@ -14,6 +14,7 @@ import { scoreFaithfulness } from "./faithfulness";
 import { checkQuoteAnchors } from "./anchors";
 import { namedDocumentIn } from "./context";
 import { standardForDocNumber } from "./modelplane";
+import { entitlementScope, standardKeysFrom } from "./requestScope";
 import type { Env } from "./env";
 export type { Env };
 import { json, err, corsHeaders, withCors, readJson, authenticate, type ApiKey } from "./lib/http";
@@ -227,7 +228,7 @@ async function verifyRoute(c: RouteContext): Promise<Response> {
   if (!answer || !query) return err(400, "invalid_input", "answer and query are required");
   try {
     const u = await understandQuery(env.AI, roleModel(env, "understand"), query, [], []);
-    const retrieved = await retrieve(env, query, { understanding: u });
+    const retrieved = await retrieve(env, query, { understanding: u, standardKeys: entitlementScope(standardKeysFrom(body)) });
     const passages = retrieved.hits.map((h: Hit) => h.text);
     const anchors = checkQuoteAnchors(answer, passages);
     const refs = [...answer.matchAll(/\[\[u:([^\]]+)\]\]/g)].map((m) => m[1]);

package/workers/worker_public/src/modelplane.ts

@@ -52,6 +52,82 @@ export function standardForDocNumber(docNumber: string | undefined): string | nu
   return (models.standards as string[]).includes(docNumber) ? `${models.standard_prefix}${docNumber}` : null;
 }
 
+// ── the license tier (TODO.external-refs/08) ─────────────────────────────
+// The profile's `sources.licensed` rows ({key, package, doc_number,
+// title, edition}) are the deployment's declared licensed standards —
+// the same keys the chunk metadata carries (`standard_key`) and the
+// entitlement set arrives with (requestScope.standardKeysFrom validates
+// against exactly this list).
+
+/** The license entry for a package id (the model-plane standard id, e.g.
+ *  `iec-60068-2-30`), or null when the package is public content. */
+export function licensedEntryForPackage(packageId: string | undefined | null):
+  | { key: string; package: string; doc_number?: string; title?: string; edition?: string }
+  | null {
+  if (!packageId) return null;
+  return (P().sources?.licensed ?? []).find((l: any) => l.package === packageId) ?? null;
+}
+
+/** The license entry for a doc number (the question's named publication,
+ *  e.g. "60068-2-30"), or null when unnamed/public. */
+export function licensedEntryForDocNumber(docNumber: string | undefined | null):
+  | { key: string; package: string; doc_number?: string; title?: string; edition?: string }
+  | null {
+  if (!docNumber) return null;
+  return (P().sources?.licensed ?? []).find((l: any) => String(l.doc_number ?? "") === docNumber) ?? null;
+}
+
+/** The per-question license boundary note: composed ONLY when the
+ *  question's named/understood publication is licensed AND the caller's
+ *  entitlement set does not carry its key. The honesty posture, made
+ *  structural: name the standard, say the organization's license does
+ *  not cover its text, keep every procedural claim out, point at the
+ *  declare flow. Citation-level metadata (title, edition, the invoking
+ *  clause the RECs publicly name) stays answerable from the public
+ *  passages already in context — the note instructs exactly that. */
+export function licenseBoundaryNote(
+  docNumber: string | undefined | null,
+  standardKeys: ReadonlySet<string> | null | undefined,
+): string | undefined {
+  const entry = licensedEntryForDocNumber(docNumber);
+  if (!entry || (standardKeys && standardKeys.has(entry.key))) return undefined;
+  const pointer = P().prompts?.vars?.license_declare_pointer;
+  return (
+    `License boundary — the question is about ${licenseBoundaryName(entry)}, a licensed publication` +
+    ` (entitlement key ${entry.key}). The caller's organization license does not cover its text, so no passage of it was retrieved` +
+    ` and NONE of its procedural content (steps, parameters, severities, limits) may be stated, paraphrased or recalled from memory.` +
+    ` You MAY answer at the citation level: name the standard and edition, and cite the invoking clause from the PUBLIC passages in context` +
+    ` (the Recommendation's own applicability and normative references are public and stay answerable).` +
+    ` Then say the organization's license does not cover the standard's text` +
+    (pointer ? ` and point to the declare flow: ${pointer}.` : ".")
+  );
+}
+
+function licenseBoundaryName(entry: { title?: string; edition?: string; package: string; doc_number?: string }): string {
+  const id = entry.doc_number ? ` ${entry.doc_number}` : ` ${entry.package}`;
+  return `${entry.title ?? "standard"}${entry.edition ? ` (${entry.edition})` : ""} —${id}`;
+}
+
+/** The deterministic boundary answer for the zero-passage case: the
+ *  question's licensed publication has nothing to show an unentitled
+ *  caller — name the standard, state the boundary, point at the declare
+ *  flow. Undefined when the question is not the licensed case (the plain
+ *  refusal applies). */
+export function licenseBoundaryRefusal(
+  docNumber: string | undefined | null,
+  standardKeys: ReadonlySet<string> | null | undefined,
+): string | undefined {
+  const entry = licensedEntryForDocNumber(docNumber);
+  if (!entry || (standardKeys && standardKeys.has(entry.key))) return undefined;
+  const pointer = P().prompts?.vars?.license_declare_pointer;
+  return (
+    `${licenseBoundaryName(entry)} is a licensed publication and your organization's license does not cover its text, ` +
+    `so I can't quote or summarize its procedure. I can answer at the citation level — the standard's title and edition, ` +
+    `and the clause your Recommendation invokes — and the public ${P().publisher.name} content in full.` +
+    (pointer ? ` To unlock the full text, an org admin can declare the license under ${pointer}.` : "")
+  );
+}
+
 export interface BoundModelNode {
   standard: string;
   node_id: string;
@@ -60,6 +136,12 @@ export interface BoundModelNode {
   clause: { doc: string; ref: string; urn: string } | null;
   /** The node's bundle projection (verbatim JSON). */
   content: any;
+  /** True when the node's package is licensed and the caller's
+   *  entitlement set lacks the key (TODO.external-refs/08): the citation
+   *  and the echo stay (metadata), but the grounding block and the
+   *  verdict engine are withheld — no licensed machine content enters
+   *  the prompt. */
+  gated?: boolean;
 }
 
 async function fetchNode(env: any, standard: string, nodeId: string): Promise<BoundModelNode | null> {
@@ -97,18 +179,26 @@ async function fetchNode(env: any, standard: string, nodeId: string): Promise<Bo
  *  model-aware chip), then a node id the question names. The standard
  *  comes from the declared doc scope when it carries one; without a scope
  *  the node binds only when it exists in EXACTLY ONE indexed standard —
- *  ambiguity is refused honestly (retrieval still surfaces the chunks). */
+ *  ambiguity is refused honestly (retrieval still surfaces the chunks).
+ *  A licensed package binds GATED for an unentitled caller (metadata
+ *  only — the grounding block and the verdict engine are the ask path's
+ *  to withhold). */
 export async function bindModelNode(
   env: any,
-  opts: { label?: string; query: string; standard?: string | null },
+  opts: { label?: string; query: string; standard?: string | null; standardKeys?: ReadonlySet<string> | null },
 ): Promise<BoundModelNode | null> {
   const nodeId = modelNodeRefIn(opts.label) ?? modelNodeRefIn(opts.query);
   if (!nodeId) return null;
-  if (opts.standard) return fetchNode(env, opts.standard, nodeId);
+  const gate = (node: BoundModelNode | null): BoundModelNode | null => {
+    if (!node) return null;
+    const entry = licensedEntryForPackage(node.standard);
+    return entry && !(opts.standardKeys?.has(entry.key) ?? false) ? { ...node, gated: true, content: {} } : node;
+  };
+  if (opts.standard) return gate(await fetchNode(env, opts.standard, nodeId));
   try {
     const rows = await env.DB.prepare("SELECT standard FROM model_nodes WHERE node_id = ?1 LIMIT 2").bind(nodeId).all();
     const standards = (rows?.results ?? []).map((r: any) => String(r.standard));
-    if (standards.length === 1) return fetchNode(env, standards[0]!, nodeId);
+    if (standards.length === 1) return gate(await fetchNode(env, standards[0]!, nodeId));
     return null; // zero (not indexed) or ambiguous (several standards) — no silent pick
   } catch {
     return null;

package/workers/worker_public/src/pipeline.ts

@@ -32,7 +32,7 @@ export function promptVars(extra: Record<string, string> = {}): Record<string, s
 export function fill(template: string, vars: Record<string, string>): string {
   return template.replace(/\{\{(\w+)\}\}/g, (_m, k: string) => (k in vars ? vars[k] : ""));
 }
-import { QueryFilters, toVectorizeFilter } from "./selfquery";
+import { QueryFilters, toVectorizeFilter, standardKeyAllowed } from "./selfquery";
 import { lexicalPrefilter } from "./lexical";
 import { positionOrder } from "./structural";
 import { STAGES, runStages } from "./stages";
@@ -125,10 +125,18 @@ export async function retrieve(
   // The declared context's seal binds the lexical lane at the SOURCE: the
   // RRF fusion mixes the full-corpus lexical ranking straight into the
   // final hits — past the pool-level seal — so under a seal the lexical
-  // lane is the FAMILY's lexical hits only.
-  const lexicalHits = opts.sealScope
-    ? lexicalHits0.filter((h) => h.metadata.doc_number === opts.sealScope!.doc_number && (!opts.sealScope!.edition || h.metadata.edition === opts.sealScope!.edition))
-    : lexicalHits0;
+  // lane is the FAMILY's lexical hits only. The license entitlement scope
+  // binds the same lane the same way (it re-enters twice: lexical-union
+  // pre-rerank and lexical-rrf post-rerank — both consume this list).
+  const lexicalHits = (opts.sealScope || opts.standardKeys
+    ? lexicalHits0.filter(
+        (h) =>
+          (!opts.sealScope ||
+            (h.metadata.doc_number === opts.sealScope!.doc_number &&
+              (!opts.sealScope!.edition || h.metadata.edition === opts.sealScope!.edition))) &&
+          standardKeyAllowed(h.metadata, opts.standardKeys),
+      )
+    : lexicalHits0);
   if (lexicalHits.length) console.log("lexical prefilter:", lexicalHits.length, "hits");
 
   const ctx: PipelineContext = {

package/workers/worker_public/src/profile.gen.ts

@@ -77,7 +77,16 @@ export const PROFILE = {
     },
     "bibliography": {},
     "terminology": {},
-    "models": {}
+    "models": {},
+    "licensed": [
+      {
+        "key": "std:fixture-60068-2-30",
+        "package": "fixture-60068-2-30",
+        "doc_number": "60068-2-30",
+        "title": "FIXTURE environmental testing — damp heat, cyclic",
+        "edition": "2005"
+      }
+    ]
   },
   "ui": {
     "suggestions": [
@@ -115,7 +124,9 @@ export const PROFILE = {
       "parts_example": "FIXTURE 1-1, FIXTURE 1-A",
       "docid_example": "FIXTURE 1-2",
       "spelling_examples": "\"f1\", \"FIXTURE 1\"",
-      "process_vocab": "the fixture certification system framework"
+      "process_vocab": "the fixture certification system framework",
+      "license_declare_pointer": "org admin → Settings → Standards licenses",
+      "license_posture": "Some indexed publications are LICENSED. When a license boundary note names the question's publication, obey it: answer at the citation level only — the standard's title and edition, and the invoking clause the public passages carry — never state, paraphrase or \"summarize from memory\" any procedure of the licensed text, and point at the declare flow the note names. Public content (the Recommendations' own models, applicability and references) stays fully answerable."
     }
   }
 } as const;

package/workers/worker_public/src/requestScope.ts

@@ -1,10 +1,12 @@
 // The per-request scope model (MECE: ask.ts orchestrates, this module
 // owns the derivation): which DATASETS the request searches (the sidebar
-// toggles, server-intersected with session permissions) and which
-// memory files ride it — plus the answer-cache SALT both selections
+// toggles, server-intersected with session permissions), which memory
+// files ride it, and which LICENSED standards the caller's organization
+// is entitled to — plus the answer-cache SALT all three selections
 // produce. Pure: D1 access stays with the caller (memoryNote); this
 // module only derives.
 import { DATASETS, datasetAllowed } from "./config.ts";
+import { P } from "./profile.ts";
 
 export interface RequestScope {
   /** dataset ids the request may search */
@@ -18,6 +20,37 @@ export interface RequestScope {
   isoOn: boolean;
   /** raw (validated) memory ids from the body — empty for anon */
   memoryIds: string[];
+  /** raw (validated) license entitlement keys from the body — empty for
+   *  anon and for requests that carry none (TODO.external-refs/08) */
+  standardKeys: Set<string>;
+}
+
+/** The deployment's declared licensed standards (profile sources.yaml
+ *  `licensed:` — key/package/doc_number rows). Empty = the deployment
+ *  serves public content only and the entitlement scope is inert. */
+export function licenseDeclared(): boolean {
+  return (P().sources?.licensed?.length ?? 0) > 0;
+}
+
+/** The request's entitlement set, VALIDATED against the declared
+ *  whitelist: unknown keys drop (a forged key can never widen scope past
+ *  the standards the deployment actually keys). Absent field = empty set
+ *  — the fail-closed default for a deployment that declares licensed
+ *  content. */
+export function standardKeysFrom(body: any): Set<string> {
+  const declared = new Set<string>((P().sources?.licensed ?? []).map((l: any) => String(l.key)));
+  const raw = Array.isArray(body?.licensed_standards) ? body.licensed_standards : [];
+  return new Set(
+    raw.filter((x: unknown): x is string => typeof x === "string" && declared.has(x)),
+  );
+}
+
+/** The RetrieveOptions value for the hard scope: null when the
+ *  deployment declares no licensed content (inert — zero behavior
+ *  change); otherwise the caller's validated set, EMPTY INCLUDED (the
+ *  unentitled caller: licensed chunks hidden, citation metadata stays). */
+export function entitlementScope(keys: Set<string>): Set<string> | null {
+  return licenseDeclared() ? keys : null;
 }
 
 /** Validate + intersect. Returns { error } when the request explicitly
@@ -54,18 +87,27 @@ export function resolveRequestScope(body: any, member: unknown): RequestScope |
     // federation flag: any session-gated (federated) dataset in scope
     isoOn: scopeIds.some((id) => DATASETS().find((x) => x.id === id)?.session === true),
     memoryIds,
+    standardKeys: standardKeysFrom(body),
   };
 }
 
 /** The answer-cache salt: request-scoped context that materially changes
- *  the answer (dataset scope, memory selection). Requests differing only
- *  in salt share query text — an unsalted key would serve a scoped (or
- *  memory-flavored) answer to a plain ask. Null = default scope, no
- *  memory: keys stay byte-identical to the pre-salt era. */
+ *  the answer (dataset scope, memory selection, license entitlements —
+ *  the licensed tier changes the grounding, so two callers asking the
+ *  same question must never share an entry). Requests differing only in
+ *  salt share query text — an unsalted key would serve a scoped (or
+ *  memory-flavored, or licensed-tier) answer to a plain ask. Null =
+ *  default scope, no memory, no entitlement effect: keys stay
+ *  byte-identical to the pre-salt era. */
 export function requestSalt(scope: RequestScope, memoryUsed: string[]): string | null {
-  if (!scope.narrowed && !memoryUsed.length) return null;
+  const licensed = licenseDeclared();
+  if (!scope.narrowed && !memoryUsed.length && !licensed) return null;
   return JSON.stringify({
     ...(scope.narrowed ? { d: [...scope.corpora].sort() } : {}),
     ...(memoryUsed.length ? { m: [...memoryUsed].sort() } : {}),
+    // the entitlement set rides whenever the deployment keys content at
+    // all — an unentitled ask and an entitled ask of the same text are
+    // different answers even when the set is empty
+    ...(licensed ? { s: [...scope.standardKeys].sort() } : {}),
   });
 }

package/workers/worker_public/src/search.ts

@@ -4,6 +4,7 @@ import { portModelRunner } from "./env.ts";
 import type { Background } from "./ports/runtime.ts";
 import { retrieve } from "./pipeline";
 import { understandQuery } from "./understand";
+import { entitlementScope, standardKeysFrom } from "./requestScope";
 import { sessionFrom } from "./auth";
 import { err, json, corsHeaders, readJson, validateQuery, type ApiKey } from "./lib/http";
 import { checkQuota, clientIp, telemetry } from "./quota";
@@ -32,9 +33,14 @@ export async function handleSearch(
 
   const understanding = await understandQuery(portModelRunner(env), MODELS.understand, q.query, []);
   const graphDocNumbers = await graphExpand(env, understanding);
+  // the license entitlement set rides the body exactly as it does on the
+  // ask path (TODO.external-refs/08): request-scoped, whitelist-validated,
+  // fail-closed — a retrieval with an empty set returns zero licensed
+  // chunks at the transport level
+  const standardKeys = entitlementScope(standardKeysFrom(body));
   let retrieved;
   try {
-    retrieved = await retrieve(env, q.query, { understanding, graphDocNumbers });
+    retrieved = await retrieve(env, q.query, { understanding, graphDocNumbers, standardKeys });
   } catch {
     return err(503, "retrieval_unavailable", "Search is briefly busy — please retry in a moment.");
   }

package/workers/worker_public/src/selfquery.ts

@@ -23,3 +23,29 @@ export function toVectorizeFilter(f: QueryFilters): Record<string, string> | und
   }
   return undefined;
 }
+
+// ── the license entitlement scope (TODO.external-refs/08) ────────────────
+// A chunk's `standard_key` metadata carries the licensed package's
+// entitlement key; public content carries none. The scope is a HARD
+// FILTER (a hit never reaches ranking when its key is outside the
+// caller's set) — but it deliberately does NOT translate into a
+// Vectorize metadata predicate: the wire has no "field missing OR in-set"
+// operator, so a `standard_key $in […]` push-down would exclude every
+// public chunk (they predate the field). The scope binds pool-level
+// (stages/licenseScope.ts, before rerank) and at the lexical lane's
+// source (pipeline.ts, the sealScope posture) instead; the single-doc
+// post-seal fetches (section-descent, typed-pin parent, edition-cover)
+// are doc-scoped and a document's key is a per-document constant, so
+// they cannot re-admit a dropped key.
+
+/** The one entitlement predicate: no key = public = always allowed; a key
+ *  outside the caller's set = never allowed. `null`/undefined keys (the
+ *  deployment declares no licensed content) disable the scope entirely. */
+export function standardKeyAllowed(
+  meta: { standard_key?: string },
+  keys: ReadonlySet<string> | null | undefined,
+): boolean {
+  if (!keys) return true;
+  const k = meta.standard_key;
+  return !k || keys.has(k);
+}

package/workers/worker_public/src/share.ts

@@ -26,11 +26,33 @@ export async function handleShareConversation(
   await env.CACHE.put(`sh:${day}:${ownerSub.slice(0, 20)}`, String(count + 1), { expirationTtl: 90000 });
 
   const slug = makeSlug();
-  const cleanMessages = messages.slice(0, 50).map((m: any) => ({
-    role: m.role === "user" ? "user" : "assistant",
-    content: (m.content ?? "").slice(0, LIMITS.maxOutputTokens * 2),
-    citations: m.citations ? JSON.parse(m.citations) : null,
-  }));
+  const cleanMessages = messages.slice(0, 50).map((m: any) => {
+    const citations = Array.isArray(m.citations)
+      ? m.citations
+      : typeof m.citations === "string"
+        ? (() => { try { return JSON.parse(m.citations); } catch { return null; } })()
+        : null;
+    const read = m.read && typeof m.read === "object"
+      ? {
+          intent: String(m.read.intent ?? ""),
+          doc: m.read.doc ?? null,
+          edition: m.read.edition ?? null,
+          term: m.read.term ?? null,
+          terms: Array.isArray(m.read.terms) ? m.read.terms.slice(0, 4).map(String) : [],
+          lang: m.read.lang ?? null,
+        }
+      : undefined;
+    // passages stay off the shared wire: the recipient verifies against the
+    // live corpus, never against a grounding they cannot re-derive
+    return {
+      role: m.role === "user" ? "user" : "assistant",
+      content: (m.content ?? "").slice(0, LIMITS.maxOutputTokens * 2),
+      citations,
+      ...(m.model ? { model: String(m.model).slice(0, 80) } : {}),
+      ...(Array.isArray(m.blocks) ? { blocks: m.blocks.slice(0, 12) } : {}),
+      ...(read ? { read } : {}),
+    };
+  });
   await env.DB.prepare(
     "INSERT INTO shared_conversations (slug, owner_sub, title, messages, created_at) VALUES (?1,?2,?3,?4,?5)",
   )

package/workers/worker_public/src/stages/citationProbe.ts

@@ -14,6 +14,7 @@
 import type { Stage } from "./types.ts";
 import { namedDocumentIn } from "../context.ts";
 import { refCodec } from "../codecs.ts";
+import { standardKeyAllowed } from "../selfquery.ts";
 import type { Hit } from "../../../shared/chunk.ts";
 
 const CITE_PATTERN = /\b(?:cite[sd]?|citing|referenc(?:e|es|ed|ing)|list[s]?|quote[sd]?)\b/i;
@@ -123,9 +124,13 @@ export const citationProbe: Stage = {
     const [probes, citeRows] = (await c.lane["citation-probe"]) as [Hit[], CiteRow[]];
     const seen = new Set(c.hits.map((m: any) => m.id));
     let added = 0;
-    // only bibliography-shaped chunks (clause title or text mentions it)
+    // only bibliography-shaped chunks (clause title or text mentions it);
+    // the push rides the entitlement predicate — the probe runs past the
+    // pool-level license scope, and a licensed family's bibliography
+    // passages must obey the same hard scope as everything else
     for (const h of probes) {
       if (seen.has(h.id as any)) continue;
+      if (!standardKeyAllowed(h.metadata as any, c.opts.standardKeys)) continue;
       const title = String((h.metadata as any)?.clause_title ?? "");
       const text = String(h.text ?? "");
       if (/bibliograph|normative reference/i.test(title + " " + text.slice(0, 300))) {

package/workers/worker_public/src/stages/index.ts

@@ -23,6 +23,7 @@ import { poolOpen } from "./poolOpen.ts";
 import { lexicalUnion } from "./lexicalUnion.ts";
 import { federate } from "./federate.ts";
 import { seal } from "./seal.ts";
+import { licenseScope } from "./licenseScope.ts";
 import { corpusScope } from "./corpusScope.ts";
 import { editionCover } from "./editionCover.ts";
 import { stdRefNudge } from "./stdRefNudge.ts";
@@ -51,6 +52,7 @@ export const STAGES: Stage[] = [
   lexicalUnion,
   federate,
   seal,
+  licenseScope,
   overviewDemote,
   familyBoost,
   rerankStage,

package/workers/worker_public/src/stages/licenseScope.ts

@@ -0,0 +1,23 @@
+// The license entitlement hard scope (TODO.external-refs/08) — pool-level,
+// after every candidate lane has merged, BEFORE rerank + the top-N cut
+// (the `seal` posture, never the post-rerank corpus-scope drop). A chunk
+// whose `standard_key` lies outside the caller's entitlement set never
+// competes for the window: the model never sees licensed text the caller
+// cannot be shown, so no prompt-level leakage either. The predicate is
+// selfquery.standardKeyAllowed; the lane audit that binds every query
+// shape lives in its doc comment.
+import { standardKeyAllowed } from "../selfquery.ts";
+import type { Stage } from "./types.ts";
+
+export const licenseScope: Stage = {
+  name: "license-scope",
+  when: (c) => !!c.opts.standardKeys,
+  run: (c) => {
+    const keys = c.opts.standardKeys!;
+    const before = c.hits.length;
+    c.hits = c.hits.filter((h) => standardKeyAllowed(h.metadata, keys));
+    if (c.hits.length !== before) {
+      console.log("license scope:", before, "→", c.hits.length, "candidates within the caller's entitlement set");
+    }
+  },
+};

package/workers/worker_public/src/stages/types.ts

@@ -36,6 +36,17 @@ export interface RetrieveOptions {
    *  intersects the requested ids with session permissions before
    *  building this set. */
   datasetScope?: Set<string> | null;
+  /** The license entitlement set (TODO.external-refs/08): the standard
+   *  keys the caller's organization is entitled to, resolved
+   *  request-scoped by the deployment (never a client-tunable filter —
+   *  it arrives through the same trusted request context as the session,
+   *  and the profile's declared licensed list is the validation
+   *  whitelist). NON-NULL activates the hard scope: chunks carrying a
+   *  `standard_key` outside the set never reach ranking (an EMPTY set is
+   *  the unentitled caller — licensed content hidden, citation-level
+   *  metadata stays). Null = the deployment declares no licensed
+   *  content, the scope is inert. */
+  standardKeys?: Set<string> | null;
 }
 
 export interface GlossaryEntry {

package/dist/ask-47RNGK2R.js

@@ -1,12 +0,0 @@
-import {
-  handleAsk
-} from "./chunk-3OXSQH7Y.js";
-import "./chunk-LNSDBEKS.js";
-import "./chunk-6GOSMLRH.js";
-import "./chunk-SN3ANQ3Y.js";
-import "./chunk-WGXATDXY.js";
-import "./chunk-Q6LI4T7M.js";
-import "./chunk-Q327B27J.js";
-export {
-  handleAsk
-};

package/dist/search-OMPBMZT4.js

@@ -1,11 +0,0 @@
-import {
-  handleSearch
-} from "./chunk-VJZLVU3S.js";
-import "./chunk-6GOSMLRH.js";
-import "./chunk-SN3ANQ3Y.js";
-import "./chunk-WGXATDXY.js";
-import "./chunk-Q6LI4T7M.js";
-import "./chunk-Q327B27J.js";
-export {
-  handleSearch
-};