run-dmcp 0.9.0 → 0.10.0

package/dist/bin/run-dmcp.js

@@ -10,6 +10,7 @@
 // The web UI runs by default, as it always has. DMCP_NO_HTTP turns it off, for
 // a host that spawns this as an MCP subprocess and has no use for an admin
 // page it cannot close.
+import { readFileSync } from "node:fs";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { closeDatabase } from "../db/connection.js";
 import { initializeSchema } from "../db/schema.js";
@@ -26,7 +27,21 @@ async function main() {
     // An application owns its database, so this is where the schema is brought
     // up -- not at import time, and not in any module a consumer might load.
     initializeSchema();
-    const server = createMcpServer();
+    // A game's rules as declared data (issue #41): a stock server loads its
+    // mechanics, gates and conditions from a JSON file. Unreadable or invalid
+    // rules stop startup here, loudly -- a server that came up without the
+    // rules it was pointed at would answer every resolve with unknown-mechanic.
+    const rulesPath = process.env.DMCP_RULES_FILE;
+    let rules;
+    if (rulesPath) {
+        try {
+            rules = JSON.parse(readFileSync(rulesPath, "utf8"));
+        }
+        catch (error) {
+            throw new Error(`DMCP_RULES_FILE '${rulesPath}' could not be read as JSON: ${error.message}`);
+        }
+    }
+    const server = createMcpServer(rules ? { rules } : undefined);
     if (webUiEnabled(process.env)) {
         const actualPort = await startHttpServer(httpPortFromEnv(process.env));
         setHttpPort(actualPort);

package/dist/db/schema.js

@@ -1281,9 +1281,10 @@ export function initializeSchema(options) {
     //     need for this -- it enforces whatever `bounds` a caller passes at
     //     write time against an EXISTING resource's own min_value/max_value
     //     columns -- but a constraint declared in the same breath as the
-    //     entity it governs is recorded here instead, opaquely: the engine
-    //     stores these bounds and does not interpret them (issue #42's own
-    //     scope note), the same "one column, several kinds, mostly null"
+    //     entity it governs is recorded here instead, and enforced at the
+    //     choke point against every later write (assertConstraintsAllow,
+    //     src/timeline/constrained.ts) -- compared as numbers, never given a
+    //     meaning -- in the same "one column, several kinds, mostly null"
     //     shape `direction` (monotonic) and `total` (conserved) already use.
     //   - caused_by_event_id: which `resolution.recorded` event's resolve()
     //     call declared this constraint -- design §5.2c's one hop of

package/dist/index.d.ts

@@ -26,8 +26,12 @@ export { createResolver, ResolveProtocolError } from "./timeline/resolve.js";
 export type { Mechanic, Resolver, Proposal, Expectation, AdjudicationInput, Adjudication, IntendedChange, IntendedWrite, IntendedTransfer, IntendedSet, IntendedCreate, CreateConstraint, IntendedDestroy, EntityRef, Outcome, ResolveRefusalReason, } from "./timeline/resolve.js";
 export { createStateRenderer } from "./timeline/render.js";
 export type { RenderVocabulary, VocabularyEntry, StateRenderer, RenderedState, RenderedNoun, UnnamedFact, } from "./timeline/render.js";
-export { createTurnReader } from "./reader/turnReader.js";
-export type { TurnReader, ReaderQuestion, ReaderSource, ReaderTransport, ReadRequest, TransportAnswer, ReaderResult, AnsweredQuestion, RejectedOffer, RejectionReason, } from "./reader/turnReader.js";
+export { createTurnReader, sourceWords, verifyAnswers } from "./reader/turnReader.js";
+export type { TurnReader, ReaderQuestion, ReaderSource, ReaderTransport, ReadRequest, TransportAnswer, ReaderResult, AnsweredQuestion, RejectedOffer, RejectionReason, QuotedCitation, RangedCitation, AcceptedCitation, SourceWord, RungAttempt, RungReport, } from "./reader/turnReader.js";
+export { checkGroundings } from "./reader/preflight.js";
+export type { DeclaredGrounding, GroundingRow, TargetRow, GroundingReport } from "./reader/preflight.js";
+export { declaredMechanics, evaluateConditions, validateDeclaredRules } from "./timeline/declared.js";
+export type { DeclaredRules, DeclaredCondition, DeclaredMechanic, DeclaredLeg, ConditionClause, FactClause, ComparisonOp, EntityOperand, NumberOperand, ParamRef, ConditionRow, ClauseRow, } from "./timeline/declared.js";
 export { exportTimeline, importTimeline, exportTimelineToFile, importTimelineFromFile, TIMELINE_FORMAT_VERSION, } from "./timeline/export.js";
 export type { TimelineExport, TimelineExportEntity, TimelineExportFact, TimelineExportEvent, TimelineExportClock, TimelineImportResult, } from "./timeline/export.js";
 export { ENTITY_KINDS } from "./timeline/kinds.js";

package/dist/index.js

@@ -174,7 +174,18 @@ export { createStateRenderer } from "./timeline/render.js";
 // scans for a consumer's language. The engine is provably ignorant of what is
 // on the other end of a rung, which is also why the ladder's ORDER is the
 // caller's: it never learns which rung is local and which is hosted.
-export { createTurnReader } from "./reader/turnReader.js";
+export { createTurnReader, sourceWords, verifyAnswers } from "./reader/turnReader.js";
+// A preflight over a declared world (GitHub issue #37): caller-declared
+// spans checked by the turn reader's own citation rule before play -- which
+// reachable targets nothing can cite, which spans are not unique, which
+// spans name a target nothing can reach. Rows, never a verdict.
+export { checkGroundings } from "./reader/preflight.js";
+// Mechanics, gates and end conditions as declared data (GitHub issue #41): a
+// small JSON declaration -- conditions over facts, and mechanics that adjust or
+// set facts when their gate conditions hold -- turned into ordinary Mechanics
+// for createResolver, and evaluated at any t for a principal's condition list.
+// Anything the declaration cannot say stays a hand-written Mechanic.
+export { declaredMechanics, evaluateConditions, validateDeclaredRules } from "./timeline/declared.js";
 // Timeline export (design §6) -- the boundary that keeps both halves honest:
 // conversational authoring upstream of a frozen artifact, deterministic
 // consumers downstream of it. These are exported as library functions first

package/dist/mcp-server.d.ts

@@ -1,4 +1,5 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { type DeclaredRules } from "./timeline/declared.js";
 import { type Mechanic } from "./timeline/resolve.js";
 import { type RenderVocabulary } from "./timeline/render.js";
 export declare const SERVER_NAME = "dmcp";
@@ -6,7 +7,7 @@ export declare const SERVER_NAME = "dmcp";
  *  the published package version by src/__tests__/serverVersion.test.ts --
  *  this said "0.3.0" for the whole of 0.4.0, because a release bumps
  *  package.json and nothing was watching this. */
-export declare const SERVER_VERSION = "0.9.0";
+export declare const SERVER_VERSION = "0.10.0";
 /**
  * Build an MCP server with every CORE tool, resource and prompt this engine
  * serves -- entities, facts, events, the timeline, and the entity/property
@@ -50,4 +51,8 @@ export declare const SERVER_VERSION = "0.9.0";
 export declare function createCoreMcpServer(options?: {
     mechanics?: readonly Mechanic[];
     vocabulary?: RenderVocabulary;
+    /** A game's mechanics, gates and conditions as declared data (issue #41):
+     *  its mechanics register beside `mechanics`, and `conditions_at` is
+     *  served. Validated here, so a server with broken rules never comes up. */
+    rules?: DeclaredRules;
 }): McpServer;

package/dist/mcp-server.js

@@ -38,6 +38,9 @@ import { registerMcpResources } from "./register/mcp-resources.js";
 import { registerTimelineTools } from "./register/timeline.js";
 import { registerResolveTools } from "./register/resolve.js";
 import { registerRenderTools } from "./register/render.js";
+import { registerReaderTools } from "./register/reader.js";
+import { registerConditionTools } from "./register/conditions.js";
+import { declaredMechanics, validateDeclaredRules } from "./timeline/declared.js";
 import { createResolver } from "./timeline/resolve.js";
 import { createStateRenderer } from "./timeline/render.js";
 export const SERVER_NAME = "dmcp";
@@ -45,7 +48,7 @@ export const SERVER_NAME = "dmcp";
  *  the published package version by src/__tests__/serverVersion.test.ts --
  *  this said "0.3.0" for the whole of 0.4.0, because a release bumps
  *  package.json and nothing was watching this. */
-export const SERVER_VERSION = "0.9.0";
+export const SERVER_VERSION = "0.10.0";
 /**
  * Build an MCP server with every CORE tool, resource and prompt this engine
  * serves -- entities, facts, events, the timeline, and the entity/property
@@ -87,6 +90,8 @@ export const SERVER_VERSION = "0.9.0";
  * shape (and the identical silence) as `mechanics` above.
  */
 export function createCoreMcpServer(options) {
+    if (options?.rules)
+        validateDeclaredRules(options.rules);
     const server = new McpServer({
         name: SERVER_NAME,
         version: SERVER_VERSION,
@@ -110,11 +115,14 @@ export function createCoreMcpServer(options) {
     registerDisplayTools(server); // Display/Theme Configuration
     registerBatchTools(server); // Batch Operations (multi-entity, workflows -- entity/property only)
     registerTimelineTools(server); // replay(t), story-time axis declaration
-    const mechanics = options?.mechanics;
-    if (mechanics && mechanics.length > 0) {
+    registerReaderTools(server); // prepare_reading, verify_reading -- the turn reader with the model on the caller's side
+    const mechanics = [...(options?.mechanics ?? []), ...(options?.rules ? declaredMechanics(options.rules) : [])];
+    if (mechanics.length > 0) {
         const resolver = createResolver({ mechanics });
         registerResolveTools(server, resolver); // resolve(), list_mechanics -- only when mechanics are registered
     }
+    if (options?.rules)
+        registerConditionTools(server, options.rules); // conditions_at -- only when rules are declared
     const vocabulary = options?.vocabulary;
     if (vocabulary) {
         // Built here rather than accepted pre-built so the vocabulary is

package/dist/reader/preflight.d.ts

@@ -0,0 +1,62 @@
+import { type AcceptedCitation, type ReaderSource, type RejectionReason } from "./turnReader.js";
+/**
+ * A preflight over a declared world (GitHub issue #37), run before play.
+ *
+ * Two failures that are otherwise silent until a transcript is read: a
+ * reachable property whose object's text holds nothing a citation could
+ * quote for it (every attempt on it is refused, forever), and prose that an
+ * author meant to matter with nothing modelled behind it (an actor plans
+ * around it and gets nowhere). The engine cannot find either by reading a
+ * description -- "does this text ground `integrity`" is a judgement about
+ * meaning (hard rule 4). So the CALLER declares, as data it already owns,
+ * which span of which source grounds which target, and this checks those
+ * declarations with the turn reader's own citation rule (`resolveCitation`),
+ * so a span that passes here is exactly a span that would pass live.
+ *
+ * `target` is opaque: the engine never parses it, compares it only for
+ * equality, and has no idea it is usually "<object>.<property>".
+ *
+ * Rows, never a verdict (hard rule 2). The counts are the report: a target
+ * with `grounded: 0` can never be cited, a span with `occurrences` above 1
+ * does not pick out one place, a span with `reachable: false` names a target
+ * nothing can act on. What any of that means for a given world is the
+ * caller's to decide. Quantity claims ("one of five") are not checked here:
+ * only the caller knows what it modelled, and once it has declared the span,
+ * comparing two of its own numbers needs no engine.
+ */
+export interface DeclaredGrounding {
+    target: string;
+    sourceId: string;
+    quote?: string;
+    from?: number;
+    to?: number;
+}
+export interface GroundingRow {
+    target: string;
+    sourceId: string;
+    /** The span as it would be cited: the quote given, or a range rebuilt. Absent when it does not cite. */
+    quote?: string;
+    range?: AcceptedCitation["range"];
+    /** The citation rule's own reason, when the span does not cite. */
+    reason?: RejectionReason;
+    /** Byte-exact positions the span starts at in its source, overlapping included; 0 when it does not cite. */
+    occurrences: number;
+    /** Whether `target` is among the targets the caller listed as reachable. */
+    reachable: boolean;
+}
+export interface TargetRow {
+    target: string;
+    /** Declared spans for this target that cite. */
+    grounded: number;
+    /** Of those, the ones that occur exactly once in their source. */
+    uniquelyGrounded: number;
+}
+export interface GroundingReport {
+    groundings: GroundingRow[];
+    targets: TargetRow[];
+}
+export declare function checkGroundings(params: {
+    sources: readonly ReaderSource[];
+    targets: readonly string[];
+    groundings: readonly DeclaredGrounding[];
+}): GroundingReport;

package/dist/reader/preflight.js

@@ -0,0 +1,40 @@
+import { resolveCitation, validateSourceIds } from "./turnReader.js";
+/** Every position the span starts at, overlapping included: "ab ab" starts
+ *  twice in "ab ab ab", and a live quote of it would pick out neither. */
+function occurrencesOf(text, span) {
+    let count = 0;
+    for (let at = text.indexOf(span); at !== -1; at = text.indexOf(span, at + 1))
+        count++;
+    return count;
+}
+export function checkGroundings(params) {
+    validateSourceIds(params.sources);
+    const reachable = new Set();
+    for (const target of params.targets) {
+        if (reachable.has(target))
+            throw new Error(`duplicate target '${target}'`);
+        reachable.add(target);
+    }
+    const sourcesById = new Map(params.sources.map((s) => [s.id, s]));
+    const groundings = params.groundings.map((g) => {
+        const { target, sourceId, quote, from, to } = g;
+        const cited = resolveCitation({ sourceId, quote, from, to }, sourcesById);
+        const base = { target, sourceId, reachable: reachable.has(target) };
+        if ("reason" in cited)
+            return { ...base, reason: cited.reason, occurrences: 0 };
+        const text = sourcesById.get(sourceId)?.text ?? "";
+        return {
+            target,
+            sourceId,
+            quote: cited.citation.quote,
+            ...(cited.citation.range ? { range: cited.citation.range } : {}),
+            occurrences: occurrencesOf(text, cited.citation.quote),
+            reachable: base.reachable,
+        };
+    });
+    const targets = params.targets.map((target) => {
+        const citing = groundings.filter((g) => g.target === target && g.reason === undefined);
+        return { target, grounded: citing.length, uniquelyGrounded: citing.filter((g) => g.occurrences === 1).length };
+    });
+    return { groundings, targets };
+}

package/dist/reader/turnReader.d.ts

@@ -96,14 +96,30 @@ export interface ReadRequest {
     questions: readonly ReaderQuestion[];
     sources: readonly ReaderSource[];
 }
-/** What a transport returns: KEYS and citations, never prose. */
+/** A citation by quote: `quote` must occur byte-exact in the source named. */
+export interface QuotedCitation {
+    sourceId: string;
+    quote: string;
+}
+/** A citation by word range (GitHub issue #35): words `from` through `to` of
+ *  the source named, numbered from 1 exactly as `sourceWords()` numbers them.
+ *  The engine rebuilds it into a quote -- the source sliced from the first
+ *  character of word `from` to the last of word `to` -- and holds that quote
+ *  to the same rule as a typed one. A range can only name a substring of its
+ *  source, so it makes misquoting unconstructable rather than instructing
+ *  against it. */
+export interface RangedCitation {
+    sourceId: string;
+    from: number;
+    to: number;
+}
+/** What a transport returns: KEYS and citations, never prose. A citation
+ *  that carries `from` or `to` is read as a range and any `quote` beside it
+ *  is not read; otherwise it is read as a quote. */
 export interface TransportAnswer {
     questionId: string;
     answerKey: string;
-    citation: {
-        sourceId: string;
-        quote: string;
-    };
+    citation: QuotedCitation | RangedCitation;
 }
 /** An injected capability, not a call this module makes itself -- see the
  *  module doc comment's "hard constraint" section. A transport may throw,
@@ -114,18 +130,32 @@ export type ReaderTransport = (request: ReadRequest) => Promise<readonly Transpo
 /** The literal, engine-defined reasons an offered answer is discarded.
  *  Never a severity, never a score -- a row names exactly which mechanical
  *  check failed (hard rule 2). */
-export type RejectionReason = "unknown-question" | "unknown-answer-key" | "unknown-source-id" | "quote-not-in-source" | "empty-quote" | "duplicate-answer";
+export type RejectionReason = "malformed-offer" | "missing-citation" | "unknown-question" | "unknown-answer-key" | "unknown-source-id" | "quote-not-in-source" | "empty-quote" | "invalid-range" | "range-start-past-end" | "duplicate-answer";
 /** One discarded offer, carried verbatim so a reviewer can see exactly what
  *  was offered and why it did not count -- never summarised, never
  *  scored. `rung` is the index into the caller's own `transports` array
  *  that produced this offer; the engine reports the position, it does not
- *  interpret what that position means. */
+ *  interpret what that position means. `offer` is typed `unknown` in
+ *  spirit: for `malformed-offer` it is whatever the transport put in its
+ *  list, which may not be an object at all. */
 export interface RejectedOffer {
     reason: RejectionReason;
     rung: number;
     /** The offer exactly as the transport returned it. */
     offer: TransportAnswer;
 }
+/** An accepted citation, always as a quote. `range` is present when the
+ *  offer cited by range: the span actually quoted, with `to` clamped to the
+ *  source's last word (issue #35's overshoot). The offer as given is in
+ *  `AnsweredQuestion.acceptedOffer`, so a clamp is visible, never silent. */
+export interface AcceptedCitation {
+    sourceId: string;
+    quote: string;
+    range?: {
+        from: number;
+        to: number;
+    };
+}
 /** One row of the result: a question's final answer, whether it came from
  *  a transport or from the caller's own safe default, and every offer for
  *  that question this read discarded along the way. */
@@ -140,21 +170,49 @@ export interface AnsweredQuestion {
     answeredByRung: number | null;
     /** `null` when `fromSafeDefault` is true -- a default was never cited
      *  against anything, because nothing was accepted for it to cite. */
-    citation: {
-        sourceId: string;
-        quote: string;
-    } | null;
+    citation: AcceptedCitation | null;
+    /** The accepted offer exactly as the transport gave it (issue #36);
+     *  `null` when nothing was accepted. */
+    acceptedOffer: TransportAnswer | null;
+    /** Every rung this question was put to, in order (issue #36). Empty means
+     *  it was never asked; non-empty with no `rejected` rows and no
+     *  acceptance means the rungs asked offered nothing for it -- and
+     *  `ReaderResult.rungs` says whether each of those rungs answered at all. */
+    askedOfRungs: readonly number[];
     rejected: readonly RejectedOffer[];
 }
+/** What one call to one rung came back as (issue #36). A record of what
+ *  happened, never a judgement of the transport: `threw` carries the thrown
+ *  value as a string, exactly as the transport raised it. */
+export type RungAttempt = {
+    outcome: "answered";
+    offers: number;
+} | {
+    outcome: "threw";
+    error: string;
+} | {
+    outcome: "not-a-list";
+};
+/** Every rung that was called, in order, with the questions it was asked and
+ *  each attempt within its `attemptsPerTransport` budget. A rung never
+ *  called -- because every question was already answered -- is not listed. */
+export interface RungReport {
+    rung: number;
+    asked: readonly string[];
+    attempts: readonly RungAttempt[];
+}
 export interface ReaderResult {
     /** One row per question this read declared, in the caller's own declared
      *  order -- deterministic regardless of which rung answered what or in
      *  what order a transport's own response array happened to list them. */
     answers: readonly AnsweredQuestion[];
     /** Offers naming a `questionId` that is not any question this read
-     *  declared -- cannot be attached to a row in `answers` because there is
-     *  no question for it to belong to. Always `reason: "unknown-question"`. */
+     *  declared, or that are not offers at all (`malformed-offer`) -- cannot
+     *  be attached to a row in `answers` because there is no question for
+     *  them to belong to. */
     unmatched: readonly RejectedOffer[];
+    /** What each rung that was called came back as (issue #36). */
+    rungs: readonly RungReport[];
 }
 export interface TurnReader {
     /** Runs the ladder for this reader's declared questions against `sources`
@@ -165,6 +223,40 @@ export interface TurnReader {
      *  changes turn to turn. */
     read(sources: readonly ReaderSource[]): Promise<ReaderResult>;
 }
+/** One word of a source, as a range citation numbers it (issue #35). */
+export interface SourceWord {
+    /** 1-based, the number a range names. */
+    index: number;
+    word: string;
+    /** Offsets into the source text: `text.slice(start, end) === word`. */
+    start: number;
+    end: number;
+}
+/**
+ * The words of a source as a range citation numbers them: each maximal run
+ * of non-whitespace, numbered from 1. Exported so a caller that shows its
+ * model numbered words builds that numbering from the same function the
+ * rebuild uses -- two numberings that disagree by one word would cite the
+ * wrong span without any error. Lexical only: punctuation stays on its word
+ * and nothing is split by what it means (hard rule 4).
+ */
+export declare function sourceWords(text: string): SourceWord[];
+/**
+ * Construction-time validation, in the same voice as `validateMechanics`
+ * (resolve.ts) and `validateMigrations` (src/db/schema.ts): every check
+ * that could make an invalid reader constructable runs ONCE, here, so a bad
+ * declaration fails loudly before a single `read()` call rather than
+ * surfacing as an answer silently outside the declared set three calls
+ * later. In particular: a reader that could ever return a key outside its
+ * own declared `answerKeys` must be unconstructable, which is why
+ * `safeDefault` membership is checked here rather than trusted.
+ */
+export declare function validateQuestions(questions: readonly ReaderQuestion[]): void;
+/** A citation names its source by id, so two sources sharing one make a
+ *  citation ambiguous. Checked everywhere sources are handed over: `read()`
+ *  (which rejects), `verifyAnswers`, and the MCP verbs over it. Until
+ *  2026-09-27 `read()` let the last duplicate win silently. */
+export declare function validateSourceIds(sources: readonly ReaderSource[]): void;
 /**
  * Builds the reader a caller uses for the lifetime of a session -- the
  * `createResolver({ mechanics })` idiom (resolve.ts) copied directly:
@@ -183,3 +275,67 @@ export declare function createTurnReader(params: {
     transports: readonly ReaderTransport[];
     attemptsPerTransport?: number;
 }): TurnReader;
+/**
+ * Whether `citation` cites a real source, non-empty, verbatim -- the
+ * citation rule's three conjuncts. All three must hold; the order below is
+ * only the order a REASON is reported in when more than one fails, and it
+ * runs cheapest-first: the quote must be a non-empty string, the source must
+ * be one that is actually in the request, and the quote must occur EXACTLY
+ * (`String.prototype.includes`, no case folding, no trimming, no fuzzy
+ * matching) inside that source's text. An offer that fails two conjuncts is
+ * rejected either way -- which reason it carries is a reporting detail, not
+ * a difference in whether it counts. Returns the accepted citation, or the
+ * first failing reason -- see the module doc comment's rule-4 discussion for
+ * why this literal presence test does not become the pattern-matching-meaning
+ * it is built beside.
+ *
+ * A RANGE (issue #35) is rebuilt into a quote first, then held to the same
+ * rule -- which a rebuilt quote always passes, being a slice of the source.
+ * Its own conjuncts: both ends integers with 1 <= from <= to
+ * (`invalid-range`), and `from` naming a real word (`range-start-past-end`).
+ * A `to` past the last word is CLAMPED to it, not rejected: the span cites
+ * what is there plus nothing. Dropping those instead was the recorded
+ * failure -- short sources overshoot most, and in the consumer that hit it
+ * a whole class of four-word intents was never once ruled.
+ *
+ * A citation that names no span at all -- absent, `{}`, or a source alone
+ * -- is `missing-citation`, reported before any of the above. A null field
+ * counts as absent throughout.
+ *
+ * Defensive against a citation that is missing entirely or missing a field
+ * -- a transport is caller-supplied code this module does not control at
+ * runtime, and a malformed citation must still be rejected mechanically
+ * rather than throwing out of this function and aborting the whole read.
+ */
+export declare function resolveCitation(citation: unknown, sourcesById: ReadonlyMap<string, ReaderSource>): {
+    citation: AcceptedCitation;
+} | {
+    reason: "missing-citation" | "unknown-source-id" | "empty-quote" | "quote-not-in-source" | "invalid-range" | "range-start-past-end";
+};
+/**
+ * Verifies one list of answers a caller's own model produced, by the same
+ * rule a `read()` applies to a rung's offers (GitHub issue #39: intent in,
+ * ruling out, with the ruling model outside the engine). For a caller that
+ * cannot hand the engine a transport -- a client reaching it over MCP, whose
+ * model runs on its own side -- this is the second of the verb's two steps:
+ * the caller builds the request and gets it answered; the engine verifies the
+ * answers and returns the ruling. It never infers anything itself.
+ *
+ * The result is exactly what `createTurnReader({ questions, transports: [t]
+ * }).read(sources)` returns when `t` resolves to `offers`, and both refuse
+ * duplicate source ids: the offers are rung
+ * 0, asked every question, and go through the one tally every rung's offers
+ * go through, so the verb and the library cannot disagree about what counts.
+ * Synchronous, because there is nothing to wait for.
+ *
+ * The question set is validated as `createTurnReader` validates it. A
+ * non-list `offers` throws rather than reading as "no offers": at this
+ * boundary the CALLER parsed its model's reply, so a non-list is the caller's
+ * bug, not a rung failure to record. Individual malformed entries inside the
+ * list are still rows (`malformed-offer`), as on the ladder.
+ */
+export declare function verifyAnswers(params: {
+    questions: readonly ReaderQuestion[];
+    sources: readonly ReaderSource[];
+    offers: readonly TransportAnswer[];
+}): ReaderResult;