@konneal/engine 0.1.0

package/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, Konneal
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,13 @@
+# Konneal Engine
+
+The publisher-agnostic serving layer for standards intelligence: hybrid
+retrieval over clause-structured corpora, citation-grounded answers,
+typed tables/formulas/figures, conformance checking by execution, and
+the measurement gates that keep it honest. Konneal builds the databases
+and serves the API; publishers own their content, profile and frontend.
+
+Architecture and plan: docs/konneal-extraction-plan.md (and
+docs/multi-sdo-architecture.md). The reference deployment is OIML SMART
+AI (oimlsmart/ai — the reference profile). This repository was born
+from it with history preserved (git filter-repo over the engine
+subtrees); the README seed commit was replaced by the extraction.

package/dist/admin.d.ts

@@ -0,0 +1,26 @@
+import type { Env } from "./env";
+/** Contextual enrichment (quality-first lane): for each chunk, write a
+ *  situating context (KV-cached per chunk id), embed context+text, and
+ *  upsert in place — the enrichment persists into every future retrieval
+ *  of that chunk. Driven by ingest/enrich.py in resumable batches. */
+export declare function handleEnrich(env: Env, ctx: ExecutionContext, req: Request): Promise<Response>;
+/** Section-summary units (FABLE/BEAR multi-granularity, arXiv:2601.18116):
+ *  the corpus's clause chunks start at depth 2 ("3.1"), so the tree has no
+ *  depth-1 nodes. This endpoint writes them: a summary of each top-level
+ *  clause generated from its child chunks' excerpts (quality-first lane,
+ *  KV-cached per unit id), embedded as toc-path ⊕ summary à la FABLE's
+ *  internal-node indexing, and upserted as a navigation node — serving
+ *  descends from it to quotable leaf clauses (pipeline.ts section
+ *  descent). Credential, batching and ledger mirror /admin/enrich. */
+export declare function handleSectionUnit(env: Env, ctx: ExecutionContext, req: Request): Promise<Response>;
+/** Ops access to the Vectorize binding (get/upsert by id) for offline
+ *  passes like embedding smoothing (G-ETSI-4) — the binding is the
+ *  credential, admin-token gated exactly like /admin/enrich. */
+/** One-time figure captioning (TODO.remaining/03): fetch the unit's asset
+ *  from R2, describe it with the vision-capable answer model, store the
+ *  description into unit_payloads. Admin-gated; idempotent. */
+export declare function handleCaption(env: Env, req: Request): Promise<Response>;
+export declare function handleVectors(env: Env, req: Request): Promise<Response>;
+export declare function handleJudge(env: Env, req: Request): Promise<Response>;
+export declare function handleCreateKey(env: Env, req: Request): Promise<Response>;
+export declare function handleListKeys(env: Env, req: Request): Promise<Response>;

package/dist/ai.d.ts

@@ -0,0 +1,6 @@
+import type { ModelRunner } from "./ports/model.ts";
+type AnyAi = ModelRunner;
+export declare function embed(ai: ModelRunner, _model: string, text: string): Promise<number[]>;
+export declare function rerank(ai: AnyAi, model: string, query: string, texts: string[]): Promise<number[] | null>;
+export declare function generateOnce(env: any, model: string, messages: any[], effort?: string): Promise<string | null>;
+export {};

package/dist/anchors.d.ts

@@ -0,0 +1,6 @@
+export interface AnchorCheck {
+    total: number;
+    violations: string[];
+}
+export declare function checkQuoteAnchors(answer: string, passages: string[]): AnchorCheck;
+export declare const ANCHOR_CORRECTION_NOTE: string;

package/dist/answercache.d.ts

@@ -0,0 +1,22 @@
+import type { Kv } from "./ports/kv.ts";
+/** KV key carrying the corpus-generation stamp (the house sys:
+ *  convention, cf. sys:generation). Absent = "0". */
+export declare const CORPUS_GEN_KEY = "sys:corpus_gen";
+/** Read the corpus-generation stamp; a KV failure fails open to "0"
+ *  (the cache keeps working, generation pinning degrades to deploy-only). */
+export declare function corpusGen(cache: Pick<Kv, "get">): Promise<string>;
+/** The fresh (regenerate) flag: the JSON boolean, plus the string/1
+ *  forms a caller may serialize. Anything else is not a bypass request. */
+export declare function freshRequested(body: any): boolean;
+/** The exact cache's hash input: the query lowercased and whitespace-
+ *  folded, plus the output-language pin (a pinned language gets its own
+ *  entry). Hashed with sha256Hex (./config) at the call site. */
+/** `salt`: per-request context that materially changes the answer — the
+ *  dataset scope selection and the memory-file selection. Requests that
+ *  differ ONLY in salt share the query text, so an unsalted key would
+ *  serve a scoped (or memory-flavored) answer to a plain ask. Null/empty
+ *  = the default scope (no salt segment — keys stay byte-identical to
+ *  the pre-salt era). */
+export declare function cacheKeyMaterial(query: string, lang?: string, salt?: string | null): string;
+export declare function exactCacheKey(indexVersion: string, gen: string, ns: string, queryHash: string): string;
+export declare function semanticCacheKey(indexVersion: string, gen: string, signature: string): string;

package/dist/ask.d.ts

@@ -0,0 +1,5 @@
+import type { Env } from "./env";
+export type { Env };
+import { type ApiKey } from "./lib/http";
+declare function handleAsk(env: Env, ctx: ExecutionContext, req: Request, tier: "anon" | "key" | "member", key: ApiKey | null): Promise<Response>;
+export { handleAsk };

package/dist/auth.d.ts

@@ -0,0 +1,12 @@
+import { SessionClaims } from "./session";
+export interface AuthConfig {
+    issuer: string;
+    clientId: string;
+    redirectUri: string;
+    sessionSecret: string;
+}
+export declare function handleLogin(env: any, req: Request): Promise<Response>;
+export declare function handleCallback(env: any, req: Request): Promise<Response>;
+export declare function sessionFrom(req: Request, env: any): Promise<SessionClaims | null>;
+export declare function handleMe(env: any, req: Request): Promise<Response>;
+export declare function handleLogout(env: any, req: Request): Promise<Response>;

package/dist/bubble.d.ts

@@ -0,0 +1,14 @@
+/** The origins a bubble may ride from: the estate pattern (the same rule
+ *  corsHeaders applies) plus localhost for the local dev posture. */
+export declare function isAllowedBubbleOrigin(origin: string): boolean;
+/** The confirm page the callback renders in bubble mode. Static inline
+ *  HTML+JS, everything escaped, targetOrigin = the validated origin
+ *  (never "*"). The token leaves ONLY on the user's explicit Continue —
+ *  a popup the user never asked for (a page opening it under the OP's
+ *  SSO session) shows the request and stops here. */
+export declare function bubbleConfirmPage(opts: {
+    name: string;
+    origin: string;
+    token: string;
+    expiresAt: number;
+}): string;

package/dist/chunk-LLWPT2XV.js

@@ -0,0 +1,49 @@
+import {
+  P
+} from "./chunk-MB74PTRM.js";
+
+// workers/worker_public/src/refusal.ts
+function refusalAnswer() {
+  return P().prompts.vars.refusal_sentence;
+}
+var REFUSAL_VARIANT = /^\s*I don[’']?t have information on .{1,120}? in the indexed OIML(?: \w+){0,2} (?:publications|passages|documents|corpus)\.?/i;
+var REFUSAL_DRIFT = [
+  /\b(can'?t|cannot|couldn'?t|unable)\b[^.]{0,120}?\b(indexed )?OIML(?: \w+){0,2} publications\b/i,
+  /\bno real answer to give\b[^.]{0,120}?\bOIML\b/i,
+  /\b(?:falls|well) outside\b[^.]{0,120}?\b(?:what I can answer|my scope|the scope of)\b/i,
+  /\boutside (?:of )?what (?:I|this service) can answer\b/i,
+  // "I can't answer that — weather forecasting is outside my scope":
+  // requires the refusal verb, so a scope DISCUSSION inside a real answer
+  // ("this exemption is outside the scope of R 60") never matches
+  /\bI can[’']?t answer\b[^.]{0,100}?\bscope\b/i,
+  /^\s*I don[’']?t have any indexed OIML \w+(?:s)? (?:covering|about|on)\b/im
+];
+function sentenceStart(answer, i) {
+  let s = 0;
+  for (const sep of [". ", "! ", "? ", "\n"]) {
+    const j = answer.lastIndexOf(sep, i);
+    if (j >= 0) s = Math.max(s, j + sep.length);
+  }
+  return s;
+}
+function sentenceEnd(answer, i) {
+  const m = /[.!?\n]/.exec(answer.slice(i));
+  return m ? i + m.index + 1 : answer.length;
+}
+function canonicalRefusal(answer) {
+  const CANON = refusalAnswer();
+  if (answer.includes(CANON)) return answer;
+  const variant = answer.match(REFUSAL_VARIANT);
+  if (variant) return answer.replace(variant[0], CANON);
+  for (const drift of REFUSAL_DRIFT) {
+    const m = drift.exec(answer);
+    if (!m) continue;
+    return answer.slice(0, sentenceStart(answer, m.index)) + CANON + answer.slice(sentenceEnd(answer, m.index));
+  }
+  return answer;
+}
+
+export {
+  refusalAnswer,
+  canonicalRefusal
+};

package/dist/chunk-MB74PTRM.js

@@ -0,0 +1,114 @@
+// workers/worker_public/src/profile.gen.ts
+var PROFILE = {
+  "publisher": {
+    "id": "fixture",
+    "name": "Fixture",
+    "full_name": "The Fixture Publisher",
+    "product_name": "Fixture Answers",
+    "description": "A minimal publisher profile exercising every declared surface: an open dataset, a permission-gated dataset, production and lane corpora, prompt vars and retrieval vocabulary.",
+    "domains": {
+      "public": "fixture.example.org"
+    },
+    "identity": {
+      "issuer": "https://id.fixture.example.org"
+    },
+    "codec": "plain-slug"
+  },
+  "datasets": [
+    {
+      "id": "pub",
+      "label": "Fixture Publications",
+      "description": "The fixture publisher's corpus",
+      "corpora": [
+        "pub",
+        "dirty",
+        "clean",
+        "synthetic"
+      ],
+      "note": "Some passages come from the fixture corpus \u2014 cite them the same way as every other passage."
+    },
+    {
+      "id": "internal",
+      "label": "Internal corpus",
+      "description": "An access-restricted corpus proving the permission gate",
+      "session": true,
+      "permission": "preview",
+      "corpora": [
+        "internal"
+      ]
+    }
+  ],
+  "corpora": {
+    "production": [
+      "pub",
+      "dirty",
+      "clean",
+      "synthetic",
+      "model"
+    ],
+    "lanes": {
+      "exp_a": [
+        "exp_a"
+      ],
+      "exp_b": [
+        "exp_b"
+      ],
+      "glossary": [
+        "glossary"
+      ]
+    }
+  },
+  "sources": {
+    "corpora": {
+      "clean": {
+        "repo": "fixtures/corpus",
+        "note": "the engine's fixture corpus"
+      }
+    },
+    "bibliography": {},
+    "terminology": {},
+    "models": {}
+  },
+  "ui": {
+    "suggestions": [
+      "What is in the fixture corpus?",
+      "Which documents does the fixture publisher issue?"
+    ],
+    "models_disclosure": [
+      {
+        "role": "Answers",
+        "model": "fixture-answer-model"
+      }
+    ],
+    "smoke": [
+      {
+        "label": "sanity",
+        "query": "What is in the fixture corpus?",
+        "expect": "fixture"
+      }
+    ]
+  },
+  "retrieval": {
+    "process_expansion": " fixture certification system framework application evaluation"
+  },
+  "prompts": {
+    "vars": {
+      "assistant_identity": "the fixture assistant \u2014 a public service answering questions about the fixture publisher's documents",
+      "refusal_sentence": "I don't have information on this in the indexed fixture documents."
+    }
+  }
+};
+
+// workers/worker_public/src/profile.ts
+var current = PROFILE;
+function setProfile(profile) {
+  current = profile;
+}
+function P() {
+  return current;
+}
+
+export {
+  setProfile,
+  P
+};

package/dist/chunk-WOGQM7DJ.js

@@ -0,0 +1,197 @@
+import {
+  P
+} from "./chunk-MB74PTRM.js";
+
+// workers/worker_public/src/config.ts
+var MODELS = {
+  embed: "@cf/qwen/qwen3-embedding-0.6b",
+  rerank: "@cf/baai/bge-reranker-base",
+  // ANSWER MODEL (all tiers, user decision 2026-08-29): glm-5.3-flash —
+  // natively multimodal (vision-unified contract), GLM family, flash tier.
+  // Vision image-parts land with answer contract v2; text answers work now.
+  anon: "@cf/zai-org/glm-5.3-flash",
+  member: "@cf/zai-org/glm-5.3-flash",
+  // hot-path understanding/summarize stays on the cheap Qwen (cost-first lane)
+  understand: "@cf/qwen/qwen3-30b-a3b-fp8",
+  // generation fallback when the answer model is unavailable
+  fallback: "@cf/qwen/qwen3-30b-a3b-fp8",
+  grader: "@cf/deepseek-ai/deepseek-v4-flash-0731",
+  // CRAG grader + judges (unsuffixed slug was retired → silent 5018s)
+  // contextual enrichment is the QUALITY-FIRST lane (one-time spend over
+  // the corpus, its quality persists into every future retrieval)
+  enrich: "@cf/deepseek-ai/deepseek-v4-pro-0813",
+  // final-tier listwise reranker for hard/member queries (cascade:
+  // cross-encoder prunes, listwise orders jointly)
+  listwise: "@cf/zai-org/glm-4.7-flash",
+  // deep-research loop (G10): bounded agentic iterations, members-only
+  research: "@cf/zai-org/glm-5.3-flash"
+};
+var LIMITS = {
+  // input sizes: generous — real questions can be long (pasted scenarios,
+  // multi-part asks). The context BUDGET is the real governor of what the
+  // model sees; these caps only bound abuse.
+  maxInputChars: 8e3,
+  maxOutputTokens: 3072,
+  // qwen3-30b-a3b always reasons; 768 starved the answer entirely
+  retrieveK: 50,
+  // Vectorize caps topK at 50 when returnMetadata=all
+  rerankKeep: 10,
+  // 8 crowded out dirty-lane goldens once 3k enriched MKO clean chunks entered the pool
+  cacheTtlSec: 6 * 3600,
+  // context-window budget (estimated tokens) for the assembled prompt —
+  // system + summary + history slice + passages must fit or the model
+  // request fails. 16k is conservative for the qwen3 tier (pre-budget
+  // traffic at ~12k+ never hit a length error); raise via INPUT_TOKEN_BUDGET
+  // after watching logs for length rejections
+  inputTokenBudget: 16e3,
+  maxPassageTokens: 900
+  // per-passage cap (clause chunks with tables can be huge)
+};
+var THRESHOLDS = {
+  /** HyDE candidate score discount — hypothetical-answer vectors match
+   *  differently than question vectors; 0.7 keeps them competitive
+   *  without letting a bad hypothetical outrank the real query. */
+  hydeDiscount: 0.7,
+  /** Graph-lane candidate discount — graph-filtered chunks enter the
+   *  pool below the primary dense lane; they must earn their window
+   *  slot under the cross-encoder, not by graph membership alone. */
+  graphLaneDiscount: 0.75,
+  /** Concept-graph candidate discount — same rationale as the graph
+   *  lane: definitional content enters discounted. */
+  conceptGraphDiscount: 0.75,
+  /** Multi-hop sub-query discount — sub-question hits are unioned, not
+   *  RRF-fused; the discount keeps them from dominating the primary
+   *  ranking on their first appearance. */
+  subQueryDiscount: 0.8,
+  /** Federated-ISO discount — the public corpus answers by default;
+   *  internal ISO passages compete but don't preempt. */
+  federateDiscount: 0.95,
+  /** Standard-reference nudge (L5): when the question asks about an
+   *  invoked ISO/IEC standard, chunks that CARRY such a citation (their
+   *  text contains an ISO/IEC identifier) get a spread-scaled boost —
+   *  the citing clause is the answer, and generic family prose otherwise
+   *  fills the window (measured: l5a-iso-humidity flips ~1/6 runs). */
+  stdRefNudgeSpread: 0.35,
+  /** Edition cover — the score multiplier for current-edition chunks the
+   *  cover stage fetches when a pool holds ONLY stale editions of a
+   *  document. Just under the top: the point is REPRESENTATION (so
+   *  edition steering can demote the stale siblings and diversity keeps
+   *  the current overview), not free ranking. */
+  editionCoverDiscount: 0.9,
+  /** Overview-chunk demotion — overview chunks repeat title/doctype
+   *  boilerplate and embed strongly for name-like queries, crowding
+   *  clause chunks out of the rerank window. */
+  overviewDemotion: 0.85,
+  /** Glossary-link cosine floor — below this the dense match to a
+   *  defined term is noise, not a candidate. Calibrated on the
+   *  drifting→durability probe (durability-def 0.542, noise ~0.3). */
+  glossaryCosineFloor: 0.5,
+  /** Exact-term nudge (spread multiplier) — clause chunks whose head IS
+   *  the asked-for term get a decisive nudge because publication headers
+   *  contain the title words and the reranker alone is unreliable there;
+   *  >1 so it dominates the spread, unlike the additive steering boosts. */
+  termNudgeSpread: 1.5,
+  /** Concept-steering rerank boost (spread fraction) — the vocabulary
+   *  link's defining families get the edition-steering boost idiom.
+   *  0.15 is enough to lift in-family content past the cross-encoder's
+   *  vocabulary bias without overriding genuine relevance. */
+  conceptSteerSpread: 0.15,
+  /** Cross-publication recency boost (spread fraction) — a
+   *  current-edition publication ranks over stale ones; composed with
+   *  the family-relative demotion below. */
+  crossPubRecencySpread: 0.1,
+  /** Family-relative edition demotion (spread fraction) — superseded
+   *  editions are demoted when a newer edition of the same publication
+   *  is in the pool; a sibling one revision back still competes. */
+  familyDemoteSpread: 0.4,
+  /** Relevance-floored window — passages below this fraction of the
+   *  top rerank score leave the window (the evidence-budget principle;
+   *  structural units are exempt). */
+  windowFloorFraction: 0.25,
+  /** Small-to-big parent fetch discount — the parent clause enters at
+   *  a discount because it's supplementary grounding, not the answer. */
+  smallToBigDiscount: 0.7,
+  /** Section-descent child discount — children fetched from a ranked
+   *  depth-1 summary enter discounted. */
+  sectionDescentDiscount: 0.8,
+  /** History budget share — the fraction of the context budget the
+   *  conversation slice may consume; older turns overflow into the
+   *  compacted summary instead of starving the passages. */
+  historyBudgetShare: 0.3
+};
+function processExpansion() {
+  return P().retrieval.process_expansion;
+}
+function roleModel(env, role) {
+  const ov = env[`${role.toUpperCase()}_MODEL`];
+  return typeof ov === "string" && ov.startsWith("@cf/") ? ov : MODELS[role];
+}
+var EFFORTS = /* @__PURE__ */ new Set(["low", "medium", "high", "max"]);
+function answerEffort(env) {
+  const v = env?.ANSWER_EFFORT;
+  return typeof v === "string" && EFFORTS.has(v) ? v : "low";
+}
+function effortBudget(effort) {
+  if (effort === "medium") return LIMITS.maxOutputTokens * 2;
+  if (effort === "high" || effort === "max") return LIMITS.maxOutputTokens * 4;
+  return LIMITS.maxOutputTokens;
+}
+function requestEffort(env, session, requested) {
+  if (typeof requested !== "string" || !EFFORTS.has(requested)) return answerEffort(env);
+  if (requested === "low") return requested;
+  return session ? requested : answerEffort(env);
+}
+function DATASETS() {
+  return P().datasets;
+}
+function hasPermission(session, code) {
+  const roles = session?.roles;
+  return Array.isArray(roles) && roles.map(String).includes(code);
+}
+function datasetAllowed(d, session) {
+  if (!d.session) return true;
+  if (!session) return false;
+  return hasPermission(session, d.permission ?? "ai-preview");
+}
+function datasetsFor(session) {
+  return DATASETS().map((d) => ({
+    id: d.id,
+    label: d.label,
+    description: d.description,
+    enabled: datasetAllowed(d, session),
+    ...d.session ? { requires: `the ${d.permission ?? "ai-preview"} permission (id.oimlsmart.org)`, authenticated: !!session } : {}
+  }));
+}
+function SUGGESTIONS() {
+  return [...P().ui.suggestions];
+}
+function num(env, key, fallback) {
+  const v = Number(env[key]);
+  return Number.isFinite(v) && v > 0 ? v : fallback;
+}
+function today() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+async function sha256Hex(s) {
+  const d = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(s));
+  return [...new Uint8Array(d)].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+export {
+  MODELS,
+  LIMITS,
+  THRESHOLDS,
+  processExpansion,
+  roleModel,
+  answerEffort,
+  effortBudget,
+  requestEffort,
+  DATASETS,
+  hasPermission,
+  datasetAllowed,
+  datasetsFor,
+  SUGGESTIONS,
+  num,
+  today,
+  sha256Hex
+};

package/dist/chunk-WWNCWKKC.js

@@ -0,0 +1,42 @@
+import {
+  DATASETS,
+  datasetAllowed
+} from "./chunk-WOGQM7DJ.js";
+
+// workers/worker_public/src/requestScope.ts
+function resolveRequestScope(body, member) {
+  const allIds = DATASETS().map((d) => d.id);
+  const requested = Array.isArray(body?.datasets) ? body.datasets.filter((x) => typeof x === "string" && allIds.includes(x)) : null;
+  if (requested !== null && requested.length === 0) return { error: "empty-datasets" };
+  const permittedIds = allIds.filter((id) => {
+    const d = DATASETS().find((x) => x.id === id);
+    return d.session ? datasetAllowed(d, member) : true;
+  });
+  const scopeIds = (requested ?? permittedIds).filter((id) => permittedIds.includes(id));
+  const corpora = /* @__PURE__ */ new Set();
+  for (const id of scopeIds) {
+    const d = DATASETS().find((x) => x.id === id);
+    for (const v of d?.corpora ?? [id]) corpora.add(v);
+  }
+  const memoryIds = member && Array.isArray(body?.memories) ? body.memories.filter((x) => typeof x === "string").slice(0, 4) : [];
+  return {
+    scopeIds,
+    corpora,
+    narrowed: scopeIds.length < permittedIds.length,
+    // federation flag: any session-gated (federated) dataset in scope
+    isoOn: scopeIds.some((id) => DATASETS().find((x) => x.id === id)?.session === true),
+    memoryIds
+  };
+}
+function requestSalt(scope, memoryUsed) {
+  if (!scope.narrowed && !memoryUsed.length) return null;
+  return JSON.stringify({
+    ...scope.narrowed ? { d: [...scope.corpora].sort() } : {},
+    ...memoryUsed.length ? { m: [...memoryUsed].sort() } : {}
+  });
+}
+
+export {
+  resolveRequestScope,
+  requestSalt
+};

package/dist/completion.d.ts

@@ -0,0 +1,5 @@
+import type { StoreQuery } from "./ports/store.ts";
+import { type ResolvedBlock } from "./refs.ts";
+import type { Hit } from "./pipeline.ts";
+export declare function completeTables(db: StoreQuery, answer: string, used: Hit[]): Promise<ResolvedBlock[]>;
+export declare function completeFigures(db: StoreQuery, answer: string, alreadyAttached: ResolvedBlock[]): Promise<ResolvedBlock[]>;