@sharpee/chord 3.1.0 → 3.5.0

package/analyzer.js

@@ -1,10 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeTopic = normalizeTopic;
 exports.analyze = analyze;
-const catalog_1 = require("./catalog");
-const ir_1 = require("./ir");
+const catalog_js_1 = require("./catalog.js");
+const index_js_1 = require("./manifests/index.js");
+const phrasebooks_js_1 = require("./phrasebooks.js");
+const version_js_1 = require("./version.js");
+const ir_js_1 = require("./ir.js");
 /** Phase A stories register text in this locale (design.md §2.6). */
 const DEFAULT_LOCALE = 'en-US';
+/**
+ * Kebab-case a quoted author string into a story key (ADR-254).
+ *
+ * Used to derive a rank's id from its name, so a rank is addressable in
+ * diagnostics and in `if.event.band_crossed` without the author declaring one.
+ */
+function kebabId(name) {
+    return name
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+/**
+ * Exit-direction opposites (parser DIRECTIONS vocabulary) — the same
+ * inference every plain exit line performs platform-side; here it backs
+ * the door mirror-line check (ADR-234 D2/D3, `checkDoors`).
+ */
+const OPPOSITE_DIRECTION = {
+    north: 'south', south: 'north', east: 'west', west: 'east',
+    northeast: 'southwest', southwest: 'northeast',
+    northwest: 'southeast', southeast: 'northwest',
+    up: 'down', down: 'up',
+};
 const PLAYER_WORDS = new Set(['player', 'you', 'yourself']);
 /** Reserved-name gate text (David, 2026-07-12 — each package P3). */
 const RESERVED_MATCH_MESSAGE = '`match` is reserved for the `each`-block binder `the match` (ratchet E3) — pick another name.';
@@ -15,8 +42,27 @@ const RESERVED_MATCH_MESSAGE = '`match` is reserved for the `each`-block binder
  * block is the one authoring surface.
  */
 const RESERVED_CHANNEL_KEYS = new Set(['present', 'entered', 'exited', 'disappeared', 'detail']);
+/**
+ * Image layers the platform pre-registers (`image:background|main|
+ * overlay`, stdlib MEDIA_CHANNELS) — implied like the `main` ambient
+ * bed; `define layer` covers only layers beyond these (ADR-241 D3).
+ */
+const IMPLIED_IMAGE_LAYERS = new Set(['background', 'main', 'overlay']);
 /** Ring 1 of the boolean-state gate (D9): literal booleans as state names. */
 const BOOLEAN_STATE_WORDS = new Set(['true', 'false', 'yes', 'no']);
+/**
+ * ADR-239 D4 topic normalization — ONE implementation for both halves of
+ * the lookup contract: the analyzer's overlap gates here, and the
+ * story-loader's runtime table lookup (which imports this). Rules:
+ * case-insensitive, leading article stripped, whitespace collapsed.
+ * Whole-topic equality only; never substring matching.
+ */
+function normalizeTopic(text) {
+    const words = text.trim().toLowerCase().split(/\s+/);
+    if (words.length > 1 && (words[0] === 'the' || words[0] === 'a' || words[0] === 'an'))
+        words.shift();
+    return words.join(' ');
+}
 /**
  * Negation prefixes/suffix for ring 3 of the boolean-state gate (D9):
  * `not-`/`un-`/`non-` (hyphenated or fused), `no-` (hyphenated only — bare
@@ -61,6 +107,8 @@ function conditionFingerprint(cond) {
             return `not(${conditionFingerprint(cond.operand)})`;
         case 'chance':
             return `chance:${cond.n}`;
+        case 'client-has':
+            return `client-has:${cond.capability}`;
         case 'condition-ref':
             return `cond:${cond.name}`;
         case 'any-of':
@@ -97,6 +145,8 @@ const STANDARD_ACTION_ROLES = {
     taking: ['taker', 'item'],
 };
 const TOP_SCOPE = { owner: null, fields: null, slots: null, ownStates: null, scoreOwner: null, inEach: false };
+/** Scope of a story-owned clause (ADR-236 D7): no owner, `it` unbound. */
+const STORY_SCOPE = { ...TOP_SCOPE, storyOwned: true };
 function entityScope(owner) {
     return { owner, fields: null, slots: null, ownStates: null, scoreOwner: owner?.id ?? null, inEach: false };
 }
@@ -139,6 +189,7 @@ function conditionReferencesIt(cond) {
             return conditionReferencesIt(cond.operand);
         case 'chance':
         case 'condition-ref':
+        case 'client-has':
             return false;
         case 'any-of':
         case 'none-of':
@@ -187,10 +238,20 @@ class Analyzer {
     hatchNames = new Set();
     /** locale → key → IRPhrase */
     phrases = new Map();
+    /** ADR-255: locale → override alias → IRPhrase (validated against MESSAGE_OVERRIDE_ALIASES). */
+    messageOverrides = new Map();
     // Phase B namespaces:
     traitNames = new Set();
     /** action name → declared grammar-slot names. */
     actionSlots = new Map();
+    /**
+     * emit event id (dotless) → the top-level payload field names it carries
+     * (ADR-253 D1). Collected across every `emit` during resolution so
+     * `checkChannelReturns` can flag a channel returning a field the event never
+     * emits. An event with no collected entry (a platform event, or one never
+     * emitted here) is left unchecked — the field set is unknown, not empty.
+     */
+    emitFields = new Map();
     /** Owner-qualified score id (`pygmy-goats.fed`, story-level bare) → worth. */
     scoreNames = new Map();
     /** Owner-qualified score declarations, for ir.scores emission. */
@@ -210,32 +271,117 @@ class Analyzer {
      * feedable's `hungry` — resolution is across the composer's trait set).
      */
     traitVisibleStates = new Map();
+    /**
+     * `define pronouns` sets by name (ADR-242 D7), collected in pass 1 so a
+     * `pronouns <word>` line resolves against sets declared later in the
+     * file. Span doubles as the pass-2 emission guard (family-channel
+     * precedent: an errored duplicate never emits a second entry).
+     */
+    pronounSetDecls = new Map();
     constructor(ast, diagnostics) {
         this.ast = ast;
         this.diagnostics = diagnostics;
     }
+    /** Extensions admitted by validated `use` lines (ADR-215). */
+    usedExtensions = new Set();
+    /**
+     * Phrasebooks in arbitration order (ADR-250 D3): header `use phrasebook`
+     * lines first (file position), then body `define phrasebook` blocks in
+     * declaration order. Conditions resolve in run() (pass 2), after every
+     * entity symbol exists.
+     */
+    phrasebookDecls = [];
+    /** Book name → declaring span (`analysis.duplicate-phrasebook` gate). */
+    phrasebookNames = new Map();
+    /**
+     * Story key → true when a predicate-less (default/always) book covers
+     * it. Book coverage counts as declaration for the missing-phrase gate
+     * (ADR-250 D4.6); predicated-only coverage earns the partial-coverage
+     * warning at first reference.
+     */
+    bookKeys = new Map();
+    partialCoverageWarned = new Set();
     run() {
         this.collect();
+        // ADR-215: validate `use` lines against the manifest registry — an
+        // unknown name is a compile error (the loader's trusted registry check
+        // backstops rogue IR), a duplicate is one-`use`-per-extension.
+        const announceModes = {};
+        const VALID_ANNOUNCE_MODES = ['all', 'collapsed', 'combined', 'silent'];
+        for (const use of this.ast.header?.uses ?? []) {
+            // ADR-262 D3: validate the `, announce <mode>` suffix and record it.
+            if (use.announce !== undefined) {
+                if (!VALID_ANNOUNCE_MODES.includes(use.announce)) {
+                    this.diagnostics.error('analysis.invalid-announce-mode', `\`announce ${use.announce}\` is not a mode — use one of: ${VALID_ANNOUNCE_MODES.join(', ')}.`, use.span);
+                }
+                else {
+                    announceModes[use.name] = use.announce;
+                }
+            }
+            const manifest = index_js_1.EXTENSION_MANIFESTS.get(use.name);
+            if (!manifest) {
+                const gated = [...index_js_1.EXTENSION_MANIFESTS.values()].filter((m) => !m.core).map((m) => m.name);
+                this.diagnostics.error('analysis.unknown-extension', `\`use ${use.name}\` names no trusted extension — known: ${gated.join(', ')}.`, use.span);
+            }
+            else if (manifest.core) {
+                // ADR-215 Q4: NPC vocabulary is CORE — always on, never `use`d.
+                this.diagnostics.error('analysis.extension-core', `\`${use.name}\` vocabulary is core — it is always available; remove the \`use\` line.`, use.span);
+            }
+            else if (this.usedExtensions.has(use.name)) {
+                this.diagnostics.error('analysis.duplicate-use', `\`use ${use.name}\` is already declared — one \`use\` per extension.`, use.span);
+            }
+            else {
+                this.usedExtensions.add(use.name);
+            }
+        }
+        // ADR-261 D4: scoring's constructs sit behind `use scoring`. Gating them
+        // together is what makes D3 ("absent `use scoring` means the game has no
+        // score") a rule with no exceptions — scoring is on precisely when the
+        // header says so, and there is one place to look. Reported once per
+        // construct kind, at the first offending site, rather than once per line.
+        if (!this.usedExtensions.has('scoring') && this.scoreDecls.length > 0) {
+            this.reportScoringGate('score', this.scoreDecls[0].span);
+        }
+        // Built once (it emits diagnostics), spread in only when present so the
+        // optional `hunger` field never appears as `undefined` on a story without it.
+        const hungerDef = this.buildHunger();
         const ir = {
-            format: ir_1.IR_FORMAT,
+            format: ir_js_1.IR_FORMAT,
+            languageVersion: version_js_1.CHORD_LANGUAGE_VERSION, // ADR-257 D3 — the language version that compiled this story
             meta: {
                 title: this.ast.header?.title ?? '',
                 author: this.ast.header?.author ?? '',
                 fields: this.ast.header?.fields ?? {},
             },
+            uses: [...this.usedExtensions],
+            announceModes,
             story: {
                 states: this.storyStates,
                 reversible: this.ast.header?.statesReversible ?? false,
+                // Story-owned every-turn clauses (ADR-236 D7): built in STORY_SCOPE
+                // so `it` reports the unbound-referent gate; narration broadcasts
+                // (the story is everywhere — D11 satisfied trivially).
+                onClauses: (this.ast.header?.onClauses ?? []).map((c) => ({
+                    ...this.buildOnClause(c, STORY_SCOPE),
+                    narration: 'broadcast',
+                })),
             },
             entities: [],
             conditions: [],
             phrases: { defaultLocale: DEFAULT_LOCALE, locales: {} },
+            messageOverrides: { defaultLocale: DEFAULT_LOCALE, locales: {} },
+            phrasebooks: [],
             verbs: [],
             hatches: [],
             traits: [],
             actions: [],
             scores: this.scoreDecls,
+            ranks: this.buildRanks(),
+            ...(hungerDef !== undefined ? { hunger: hungerDef } : {}),
             sequences: [],
+            machines: [],
+            channels: [],
+            pronounSets: [],
             hasHatches: false,
         };
         for (const decl of this.ast.declarations) {
@@ -262,6 +408,10 @@ class Analyzer {
                     ir.hatches.push({ name: decl.name, modulePath: decl.modulePath, hatchKind: 'text', span: decl.span });
                     break;
                 case 'define-hatch':
+                    // ADR-094 chain hatch: the name must be a replaceable stdlib chain.
+                    if (decl.hatchKind === 'chain' && !catalog_js_1.STDLIB_CHAIN_NAMES.has(decl.name)) {
+                        this.diagnostics.error('analysis.unknown-chain', `\`${decl.name}\` is not a replaceable stdlib chain${this.suggestText(decl.name, [...catalog_js_1.STDLIB_CHAIN_NAMES])}.`, decl.span);
+                    }
                     ir.hatches.push({ name: decl.name, modulePath: decl.modulePath, hatchKind: decl.hatchKind, span: decl.span });
                     break;
                 case 'define-trait':
@@ -270,6 +420,29 @@ class Analyzer {
                 case 'define-action':
                     ir.actions.push(this.buildAction(decl));
                     break;
+                case 'define-machine':
+                    ir.machines.push(this.buildMachine(decl));
+                    break;
+                case 'define-asset':
+                    break; // collected in pass 1 — data references, nothing to emit
+                case 'define-family-channel':
+                    // ADR-241 D2/D4: the declaration joins the channel manifest.
+                    // The pass-1 span guard keeps an errored duplicate from
+                    // producing a second entry.
+                    if (this.familyChannels[decl.family].get(decl.name) === decl.span) {
+                        ir.channels.push({ name: decl.name, family: decl.family, span: decl.span });
+                    }
+                    break;
+                case 'define-channel':
+                    ir.channels.push(this.buildChannel(decl));
+                    break;
+                case 'define-pronouns':
+                    // ADR-242 D7 — the pass-1 span guard keeps a shadowing/duplicate
+                    // declaration from emitting (family-channel precedent).
+                    if (this.pronounSetDecls.get(decl.name) === decl) {
+                        ir.pronounSets.push(this.buildPronounSet(decl));
+                    }
+                    break;
                 case 'define-sequence':
                     ir.sequences.push({
                         name: decl.name.join(' '),
@@ -295,18 +468,421 @@ class Analyzer {
                             entry.condition = this.resolveCondition(decl.condition, TOP_SCOPE);
                     }
                     break;
+                case 'override-message':
+                    // ADR-255: same two-pass split as define-phrase — the optional
+                    // `while <cond>` gate resolves here in pass 2. Only set when the
+                    // alias survived pass-1 validation (an entry exists).
+                    if (decl.condition) {
+                        const entry = this.messageOverrides.get(DEFAULT_LOCALE)?.get(decl.alias);
+                        if (entry)
+                            entry.condition = this.resolveCondition(decl.condition, TOP_SCOPE);
+                    }
+                    break;
+                case 'override-messages':
+                    break; // flat entries collected in pass 1; no per-entry condition
                 case 'define-phrases':
                     break; // collected in pass 1
+                case 'define-phrasebook':
+                case 'import':
+                    break; // collected/diagnosed in pass 1; conditions resolve below
+                case 'define-topics':
+                    break; // applied onto owners after all entities are built (applyTopics)
             }
         }
+        // ADR-250 D3: books in arbitration order; predicates resolve here in
+        // pass 2 (an entity declared after the book may appear in its `while`).
+        ir.phrasebooks = this.phrasebookDecls.map((b) => ({
+            name: b.name,
+            source: b.source,
+            condition: b.condition ? this.resolveCondition(b.condition, TOP_SCOPE) : null,
+            ...(b.entries ? { entries: b.entries } : {}),
+            span: b.span,
+        }));
+        // ADR-241 D3/D4: the implied `main` ambient bed — used by an ambient
+        // statement without a declaration — joins the channel manifest so the
+        // loader registers it (nothing platform-side pre-registers ambient).
+        if (this.impliedMainBedSpan && !this.familyChannels.ambient.has('main')) {
+            ir.channels.push({ name: 'main', family: 'ambient', span: this.impliedMainBedSpan });
+        }
         for (const [locale, table] of this.phrases) {
             ir.phrases.locales[locale] = Object.fromEntries(table);
         }
+        for (const [locale, table] of this.messageOverrides) {
+            ir.messageOverrides.locales[locale] = Object.fromEntries(table);
+        }
         ir.hasHatches = ir.hatches.length > 0;
+        this.applyTopics(ir.entities);
+        this.checkRegions(ir.entities);
+        this.checkDoors(ir.entities);
         this.checkMarkers();
         this.checkDescriptionMarkers();
+        this.checkChannelReturns(ir.channels); // ADR-253 D1: return-field cross-check (all emits collected)
         return ir;
     }
+    /**
+     * ADR-236 D2/D3 never-guess gates over the whole region graph: member
+     * kinds (rooms or regions only), single direct membership (RoomTrait's
+     * `regionId` is single-valued — an ancestor+descendant listing is the
+     * same error), single parent per region, no memberless regions, no
+     * containment cycles. Runs after every entity is built so cross-entity
+     * lookups and spans are all available.
+     */
+    checkRegions(entities) {
+        const byId = new Map(entities.map((e) => [e.id, e]));
+        const isRegionEntity = (e) => e.kinds.some((k) => k.name === 'region');
+        const regions = entities.filter(isRegionEntity);
+        // Memberless region: declared-but-unanswerable, uniformly hard (D2 —
+        // ruled no warning tier; its daemon could otherwise silently never fire).
+        for (const region of regions) {
+            if (region.containing.length === 0) {
+                this.diagnostics.error('analysis.region-memberless', `Region \`${region.name}\` has no \`containing\` line — an empty region is unanswerable (its daemons and crossings could never fire). List its member rooms.`, region.span);
+            }
+        }
+        // Direct membership is stated exactly once, graph-wide.
+        const roomMemberOf = new Map();
+        const parentOf = new Map();
+        for (const region of regions) {
+            for (const member of region.containing) {
+                const target = byId.get(member.id);
+                if (!target)
+                    continue; // unresolved — already reported by resolveEntityId
+                if (isRegionEntity(target)) {
+                    const prior = parentOf.get(member.id);
+                    if (prior) {
+                        this.diagnostics.error('analysis.region-two-parents', `Region \`${target.name}\` is already contained by region \`${prior.parent.name}\` (line ${prior.span.line}) — a region has exactly one parent.`, member.span);
+                    }
+                    else {
+                        parentOf.set(member.id, { parent: region, span: member.span });
+                    }
+                }
+                else if (target.kinds.some((k) => k.name === 'room')) {
+                    const prior = roomMemberOf.get(member.id);
+                    if (prior) {
+                        this.diagnostics.error('analysis.region-double-membership', `\`${target.name}\` is already a member of region \`${prior.region.name}\` (line ${prior.span.line}) — direct membership is stated exactly once (nesting already makes a room part of every ancestor region).`, member.span);
+                    }
+                    else {
+                        roomMemberOf.set(member.id, { region, span: member.span });
+                    }
+                }
+                else {
+                    const kind = target.kinds[0]?.name ?? 'plain thing';
+                    this.diagnostics.error('analysis.region-member-kind', `\`${target.name}\` is a ${kind} — \`containing\` members must be rooms or regions.`, member.span);
+                }
+            }
+        }
+        // Containment cycles (walking child → parent; two-parents kept the
+        // first edge, so the graph is functional and one walk per region ends).
+        const walked = new Map();
+        for (const region of regions) {
+            if (walked.has(region.id))
+                continue;
+            const path = [];
+            let cur = region.id;
+            while (cur !== undefined && !walked.has(cur)) {
+                walked.set(cur, 'visiting');
+                path.push(cur);
+                const edge = parentOf.get(cur);
+                const next = edge?.parent.id;
+                if (next !== undefined && walked.get(next) === 'visiting') {
+                    const names = [...path.slice(path.indexOf(next)), next].map((id) => byId.get(id)?.name ?? id);
+                    this.diagnostics.error('analysis.region-cycle', `Region containment cycle: ${names.map((n) => `\`${n}\``).join(' → ')}.`, edge.span);
+                    break;
+                }
+                cur = next;
+            }
+            for (const id of path)
+                walked.set(id, 'done');
+        }
+    }
+    /**
+     * ADR-234 D3 never-guess gates over the whole door graph: every
+     * `through` target is a door, a door connects exactly one room pair
+     * (the only legal second reference is the exact mirror — other side,
+     * opposite direction), and every declared door is referenced somewhere
+     * (an unconnected door is unanswerable, same hard class as a
+     * memberless region). Runs after every entity is built so cross-entity
+     * lookups and spans are all available.
+     */
+    checkDoors(entities) {
+        const byId = new Map(entities.map((e) => [e.id, e]));
+        const isDoorEntity = (e) => e.kinds.some((k) => k.name === 'door');
+        // First `through` reference per door — the canonical pair.
+        const firstRef = new Map();
+        // Doors whose mirror side has already been stated.
+        const mirrored = new Set();
+        for (const owner of entities) {
+            for (const exit of owner.exits) {
+                if (exit.via === null || exit.via === '')
+                    continue; // plain, or unresolved (already reported)
+                const door = byId.get(exit.via);
+                if (!door)
+                    continue;
+                if (!isDoorEntity(door)) {
+                    const kind = door.kinds[0]?.name ?? 'plain thing';
+                    this.diagnostics.error('analysis.door-through-kind', `\`${door.name}\` is a ${kind} — \`through\` names a door (\`create the ${door.name} / a door\`).`, exit.span);
+                    continue;
+                }
+                const first = firstRef.get(door.id);
+                if (!first) {
+                    firstRef.set(door.id, { owner, exit });
+                    continue;
+                }
+                const samePair = (owner.id === first.owner.id && exit.to === first.exit.to)
+                    || (owner.id === first.exit.to && exit.to === first.owner.id);
+                if (!samePair) {
+                    this.diagnostics.error('analysis.door-multi-pair', `\`${door.name}\` already connects \`${first.owner.name}\` and \`${byId.get(first.exit.to)?.name ?? first.exit.to}\` (line ${first.exit.span.line}) — a door connects exactly two rooms.`, exit.span);
+                    continue;
+                }
+                const isMirror = owner.id === first.exit.to
+                    && exit.to === first.owner.id
+                    && exit.direction === OPPOSITE_DIRECTION[first.exit.direction]
+                    && !mirrored.has(door.id);
+                if (isMirror) {
+                    mirrored.add(door.id);
+                }
+                else {
+                    this.diagnostics.error('analysis.door-pair-mismatch', `\`${door.name}\` is already wired by \`${first.owner.name}\`'s \`${first.exit.direction}\` line (line ${first.exit.span.line}) — the only legal second reference is the exact mirror (\`${OPPOSITE_DIRECTION[first.exit.direction] ?? '?'} to the ${first.owner.name} through the ${door.name}\` in \`${byId.get(first.exit.to)?.name ?? first.exit.to}\`), stated at most once.`, exit.span);
+                }
+            }
+        }
+        // Plain mirror of a door exit (platform-issue-sweep Phase 8 #6): a
+        // plain `<dir> to <room>` line whose reverse side is door-wired would
+        // re-stamp BOTH directions without the door at load, silently unwiring
+        // it (the loader's connectRooms stamps the reverse too). The author
+        // must name the door — or drop the line entirely, since one door-wired
+        // side already connects both rooms.
+        for (const owner of entities) {
+            for (const exit of owner.exits) {
+                if (exit.via !== null)
+                    continue;
+                const target = byId.get(exit.to);
+                if (!target)
+                    continue;
+                const reverse = target.exits.find((e) => e.via !== null && e.via !== '' && e.to === owner.id
+                    && e.direction === OPPOSITE_DIRECTION[exit.direction]);
+                if (reverse) {
+                    const doorName = byId.get(reverse.via)?.name ?? reverse.via;
+                    this.diagnostics.error('analysis.door-plain-mirror', `\`${owner.name}\`'s plain \`${exit.direction}\` line mirrors a door exit — \`${target.name}\` wires \`${reverse.direction}\` through \`${doorName}\` (line ${reverse.span.line}), and a plain mirror would silently unwire the door at load. Name the door (\`${exit.direction} to the ${target.name} through the ${doorName}\`) or drop this line (the door side already connects both rooms).`, exit.span);
+                }
+            }
+        }
+        // Unconnected door: declared-but-unanswerable, uniformly hard (D3 —
+        // same class as region-memberless; its room pair could never resolve).
+        for (const door of entities.filter(isDoorEntity)) {
+            if (!firstRef.has(door.id)) {
+                this.diagnostics.error('analysis.door-unconnected', `Door \`${door.name}\` is never referenced by a \`through\` exit line — an unconnected door is unanswerable (its room pair could never resolve). Add \`<direction> to the <room> through the ${door.name}\` on a room.`, door.span);
+            }
+        }
+    }
+    /**
+     * ADR-239 D4's never-guess table gates + lowering: resolve each
+     * `define topics` block onto its owner entity's `topics` rows. Runs
+     * after every entity is built so owner kinds and cross-tier name
+     * lookups are all available. Gates (each its own diagnostic): a second
+     * block for the same owner, a non-person host, a duplicate topic
+     * (entity or normalized quoted text, aliases included), and a quoted
+     * entry colliding with the name/aka of an entity used in an
+     * entity-tier row of the same table.
+     */
+    applyTopics(entities) {
+        const byId = new Map(entities.map((e) => [e.id, e]));
+        /** owner id → first block's span (duplicate-block gate). */
+        const blockOwners = new Map();
+        for (const decl of this.ast.declarations) {
+            if (decl.kind !== 'define-topics')
+                continue;
+            if (decl.owner.words.length === 0)
+                continue; // header parse error already reported
+            const ownerId = this.resolveEntityId(decl.owner);
+            if (!ownerId)
+                continue; // unknown/ambiguous — standard errors already reported
+            const owner = byId.get(ownerId);
+            const sym = this.byId.get(ownerId) ?? null;
+            if (!owner)
+                continue;
+            const first = blockOwners.get(ownerId);
+            if (first) {
+                this.diagnostics.error('analysis.duplicate-topics-block', `\`${owner.name}\` already has a \`define topics\` block at line ${first.line} — the table lives in one place; merge the rows.`, decl.span);
+                continue;
+            }
+            blockOwners.set(ownerId, decl.span);
+            if (!owner.kinds.some((k) => k.name === 'person')) {
+                const kind = owner.kinds[0] ? `a ${owner.kinds[0].name}` : 'a plain thing';
+                this.diagnostics.error('analysis.topics-host', `\`define topics\` needs a person — \`${owner.name}\` is ${kind}, and only people answer \`ask\`/\`tell\` (a table here could never be reached).`, decl.span);
+                continue;
+            }
+            // Entity-tier refs resolve once, up front: the cross-tier collision
+            // gate must see every entity-tier row's names, even those declared
+            // AFTER a colliding quoted row.
+            const resolvedRefs = decl.rows.map((row) => row.filter.kind === 'entity' ? this.resolveEntityId(row.filter.ref) : null);
+            /** normalized name/aka of entity-tier row entities → display name. */
+            const entityTierNames = new Map();
+            for (const id of resolvedRefs) {
+                if (!id)
+                    continue;
+                const rowSym = this.byId.get(id);
+                if (!rowSym)
+                    continue;
+                entityTierNames.set(normalizeTopic(rowSym.nameLower), rowSym.nameLower);
+                for (const alias of rowSym.aka)
+                    entityTierNames.set(normalizeTopic(alias), rowSym.nameLower);
+            }
+            const scope = entityScope(sym);
+            const rows = [];
+            const seenEntities = new Map();
+            const seenTexts = new Map();
+            for (let i = 0; i < decl.rows.length; i++) {
+                const row = decl.rows[i];
+                if (row.filter.kind === 'entity') {
+                    const id = resolvedRefs[i];
+                    if (!id)
+                        continue; // unresolved — already reported
+                    const dup = seenEntities.get(id);
+                    if (dup) {
+                        this.diagnostics.error('analysis.duplicate-topic', `\`${this.byId.get(id)?.nameLower ?? id}\` is already a topic of this table (line ${dup.line}) — a topic answers in one place; merge the rows.`, row.span);
+                        continue;
+                    }
+                    seenEntities.set(id, row.span);
+                    rows.push({
+                        filter: { kind: 'entity', id },
+                        body: row.body.map((s) => this.resolveStatement(s, scope)),
+                        span: row.span,
+                    });
+                }
+                else {
+                    const texts = [row.filter.primary, ...row.filter.aliases];
+                    let rejected = false;
+                    for (const text of texts) {
+                        const norm = normalizeTopic(text);
+                        const dup = seenTexts.get(norm);
+                        if (dup) {
+                            this.diagnostics.error('analysis.duplicate-topic', `"${text}" is already declared in this table (line ${dup.line}) — aliases included, a topic answers in one place.`, row.filter.span);
+                            rejected = true;
+                            continue;
+                        }
+                        seenTexts.set(norm, row.span);
+                        const collidesWith = entityTierNames.get(norm);
+                        if (collidesWith) {
+                            this.diagnostics.error('analysis.topic-entity-collision', `"${text}" collides with \`${collidesWith}\` — that entity is already an entity-tier row of this table, and the quoted spelling would shadow its quiet entity resolution. Remove one.`, row.filter.span);
+                            rejected = true;
+                        }
+                    }
+                    if (rejected)
+                        continue;
+                    rows.push({
+                        filter: { kind: 'text', primary: row.filter.primary, aliases: row.filter.aliases },
+                        body: row.body.map((s) => this.resolveStatement(s, scope)),
+                        span: row.span,
+                    });
+                }
+                this.checkPhaseOrder(row.body, { mutated: false });
+            }
+            owner.topics = rows;
+        }
+    }
+    /** Machine names seen (duplicate gate). */
+    machineNames = new Set();
+    /** Declared media assets (ADR-216): name → kind + path. */
+    assets = new Map();
+    /**
+     * Build one `define machine` (ADR-215 `use state-machines` depth):
+     * gated on the `use`, states/targets/roles validated, single-word
+     * triggers resolved (declared condition or story state wins, else an
+     * action gerund), bodies in STORY_SCOPE (`it` unbound — the machine is
+     * story-owned).
+     */
+    buildMachine(decl) {
+        if (!this.usedExtensions.has('state-machines')) {
+            this.diagnostics.error('analysis.extension-not-used', '`define machine` is `state-machines` extension vocabulary — add `use state-machines` to the story header.', decl.span);
+        }
+        const name = decl.name.join(' ');
+        if (this.machineNames.has(name)) {
+            this.diagnostics.error('analysis.duplicate-machine', `A machine named \`${name}\` already exists.`, decl.span);
+        }
+        this.machineNames.add(name);
+        const stateNames = new Set(decl.states.map((s) => s.name));
+        if (decl.states.length === 0) {
+            this.diagnostics.error('analysis.machine-states', `Machine \`${name}\` declares no states.`, decl.span);
+        }
+        if (decl.initialState === null) {
+            this.diagnostics.error('analysis.machine-starts', `Machine \`${name}\` needs a \`starts <state>\` line.`, decl.span);
+        }
+        else if (!stateNames.has(decl.initialState)) {
+            this.diagnostics.error('analysis.machine-starts', `\`starts ${decl.initialState}\` names no declared state of \`${name}\`${this.suggestText(decl.initialState, [...stateNames])}.`, decl.span);
+        }
+        const roles = new Map();
+        for (const role of decl.roles) {
+            if (roles.has(role.name)) {
+                this.diagnostics.error('analysis.machine-role', `Role \`${role.name}\` is declared twice on \`${name}\`.`, role.span);
+                continue;
+            }
+            const entity = this.resolveEntityId(role.entity);
+            if (entity !== null)
+                roles.set(role.name, entity);
+        }
+        const buildTransition = (t) => {
+            if (!stateNames.has(t.target)) {
+                this.diagnostics.error('analysis.machine-target', `\`${t.target}\` names no declared state of \`${name}\`${this.suggestText(t.target, [...stateNames])}.`, t.span);
+            }
+            let trigger;
+            switch (t.trigger.kind) {
+                case 'event':
+                    trigger = { kind: 'event', event: t.trigger.event };
+                    break;
+                case 'condition':
+                    trigger = { kind: 'condition', condition: this.resolveCondition(t.trigger.condition, STORY_SCOPE) };
+                    break;
+                case 'word': {
+                    // Vocabulary-free parse: a declared condition or story state is a
+                    // condition trigger; anything else is an action gerund.
+                    if (this.conditionNames.has(t.trigger.word) || this.storyStates.includes(t.trigger.word)) {
+                        trigger = {
+                            kind: 'condition',
+                            condition: this.resolveCondition({ kind: 'condition-ref', name: t.trigger.word, span: t.trigger.span }, STORY_SCOPE),
+                        };
+                    }
+                    else {
+                        trigger = { kind: 'action', action: t.trigger.word, target: null };
+                    }
+                    break;
+                }
+                case 'action': {
+                    let target = null;
+                    if (t.trigger.target) {
+                        const words = t.trigger.target.words.map((w) => w.toLowerCase());
+                        if (words.length === 1 && roles.has(words[0])) {
+                            target = `$${words[0]}`; // the platform binding convention
+                        }
+                        else {
+                            target = this.resolveEntityId(t.trigger.target);
+                        }
+                    }
+                    trigger = { kind: 'action', action: t.trigger.action, target };
+                    break;
+                }
+            }
+            return {
+                trigger,
+                condition: t.condition ? this.resolveCondition(t.condition, STORY_SCOPE) : null,
+                target: t.target,
+                span: t.span,
+            };
+        };
+        return {
+            name,
+            roles: [...roles].map(([roleName, entity]) => ({ name: roleName, entity })),
+            initialState: decl.initialState ?? decl.states[0]?.name ?? '',
+            states: decl.states.map((s) => ({
+                name: s.name,
+                terminal: s.terminal,
+                transitions: s.transitions.map(buildTransition),
+                onEnter: s.onEnter.map((stmt) => this.resolveStatement(stmt, STORY_SCOPE)),
+                onExit: s.onExit.map((stmt) => this.resolveStatement(stmt, STORY_SCOPE)),
+                span: s.span,
+            })),
+            span: decl.span,
+        };
+    }
     /** Resolve a `when <owner> becomes <state>` step anchor (ratchet D10). */
     resolveStepAnchor(step) {
         if (step.timing !== 'becomes' || !step.owner || !step.state)
@@ -377,7 +953,7 @@ class Analyzer {
             if (clause.binding === 'every-turn')
                 continue;
             let key = `${clause.clauseKind}|${clause.action}|${clause.binding}|${clause.role ?? ''}`;
-            if (catalog_1.EVENT_VERBS.has(clause.action)) {
+            if (catalog_js_1.EVENT_VERBS.has(clause.action)) {
                 key += `|${clause.condition ? conditionFingerprint(clause.condition) : ''}`;
             }
             const first = seen.get(key);
@@ -446,6 +1022,16 @@ class Analyzer {
             this.storyStates = this.ast.header.states.map((s) => s.name);
             for (const s of this.ast.header.scores)
                 this.collectScore(s.name, s.worth, s.span, null);
+            // Header `on every turn` clause bodies host inline phrase prose like
+            // every other body context (platform-issue-sweep Phase 8 #14): story-
+            // owned, so ownerless/bare-key scope — the same registration the five
+            // pre-existing contexts use.
+            for (const clause of this.ast.header.onClauses)
+                this.collectInlineTexts(clause.body);
+            // `use phrasebook` lines (ADR-250 D2/D3) — header position puts every
+            // used book ahead of body-declared books in the arbitration order.
+            for (const use of this.ast.header.usePhrasebooks)
+                this.collectUsePhrasebook(use);
         }
         for (const decl of this.ast.declarations) {
             if (decl.kind === 'create')
@@ -466,6 +1052,50 @@ class Analyzer {
                 this.collectPhrasesBlock(decl);
             else if (decl.kind === 'define-phrase')
                 this.collectPhraseDecl(decl);
+            else if (decl.kind === 'define-phrasebook')
+                this.collectPhrasebook(decl);
+            else if (decl.kind === 'override-message')
+                this.collectOverrideMessage(decl);
+            else if (decl.kind === 'override-messages')
+                this.collectOverrideMessages(decl);
+            else if (decl.kind === 'import') {
+                // The compile host resolves imports before analysis (splicing the
+                // fragment's declarations at this position); one surviving here means
+                // no resolver ran — direct parse/analyze callers included.
+                this.diagnostics.error('analysis.import-unresolved', `\`import "${decl.path}"\` was not resolved — compile with an \`importResolver\` host hook.`, decl.span);
+            }
+            else if (decl.kind === 'define-asset') {
+                // ADR-216: declared media assets — DATA references, one namespace.
+                if (this.assets.has(decl.name)) {
+                    this.diagnostics.error('analysis.duplicate-asset', `An asset named \`${decl.name}\` already exists.`, decl.span);
+                }
+                else {
+                    this.assets.set(decl.name, { kind: decl.assetKind, path: decl.path, span: decl.span });
+                }
+            }
+            else if (decl.kind === 'define-family-channel') {
+                // ADR-241 D2: named family channels, per-family namespace.
+                const family = this.familyChannels[decl.family];
+                if (family.has(decl.name)) {
+                    this.diagnostics.error('analysis.duplicate-channel', `An ${decl.family === 'ambient' ? 'ambient bed' : 'image layer'} named \`${decl.name}\` is already declared.`, decl.span);
+                }
+                else {
+                    family.set(decl.name, decl.span);
+                }
+            }
+            else if (decl.kind === 'define-pronouns') {
+                // ADR-242 D7: one namespace beside the standard four — shadowing a
+                // standard word and redefining a set are each errors, never a merge.
+                if (catalog_js_1.PRONOUN_WORDS.has(decl.name)) {
+                    this.diagnostics.error('analysis.pronoun-set-shadows', `\`${decl.name}\` is a standard pronoun set — \`define pronouns\` names a new set; pick another name.`, decl.span);
+                }
+                else if (this.pronounSetDecls.has(decl.name)) {
+                    this.diagnostics.error('analysis.duplicate-pronoun-set', `A pronoun set named \`${decl.name}\` is already defined.`, decl.span);
+                }
+                else {
+                    this.pronounSetDecls.set(decl.name, decl);
+                }
+            }
             else if (decl.kind === 'define-trait') {
                 this.traitNames.add(decl.name);
                 for (const field of decl.data) {
@@ -512,6 +1142,15 @@ class Analyzer {
                 for (const step of decl.steps)
                     this.collectInlineTexts(step.body);
             }
+            else if (decl.kind === 'define-machine') {
+                // Machine state bodies (`on enter` / `on exit`) host inline phrase
+                // prose like every other body context (platform-issue-sweep Phase 8
+                // #14) — ownerless/bare-key scope, matching the header clauses.
+                for (const state of decl.states) {
+                    this.collectInlineTexts(state.onEnter);
+                    this.collectInlineTexts(state.onExit);
+                }
+            }
         }
         // Trait-declared states reach every composer (ratchet D8): merge each
         // trait's state set into the composing entity's, in composition order.
@@ -613,6 +1252,37 @@ class Analyzer {
             for (const clause of e.decl.onClauses)
                 this.collectInlineTexts(clause.body, e.id);
         }
+        // Topic-table row bodies are entity-owned (ADR-239): their inline
+        // phrases register owner-scoped like clause bodies. Owner resolution
+        // here is silent — an unresolved owner is pass 2's error (applyTopics).
+        for (const decl of this.ast.declarations) {
+            if (decl.kind !== 'define-topics')
+                continue;
+            const owner = this.findEntitySilent(decl.owner);
+            if (!owner)
+                continue;
+            for (const row of decl.rows)
+                this.collectInlineTexts(row.body, owner.id);
+        }
+    }
+    /**
+     * Resolve a name to an entity symbol with resolveEntityId's exact
+     * precedence (exact name → alias → unique in-order subset) but NO
+     * diagnostics — for pass-1 uses where pass 2 will report the miss.
+     */
+    findEntitySilent(ref) {
+        const lower = ref.words.join(' ').toLowerCase();
+        const exact = this.entities.filter((e) => e.nameLower === lower);
+        if (exact.length === 1)
+            return exact[0];
+        const byAlias = this.entities.filter((e) => e.aka.includes(lower));
+        if (byAlias.length === 1)
+            return byAlias[0];
+        const refWords = ref.words.map((w) => w.toLowerCase());
+        const subset = this.entities.filter((e) => isInOrderSubset(refWords, e.nameWords));
+        if (subset.length === 1)
+            return subset[0];
+        return null;
     }
     /**
      * Declare-and-emit sugar (§2.6): a `phrase <key>` statement carrying an
@@ -667,7 +1337,7 @@ class Analyzer {
                 this.diagnostics.error('analysis.boolean-state', `\`${s.name}\` is a boolean literal, not a state — booleans are not part of Chord at any scope (given 8). Name what ${ownerDesc} IS in that condition.`, s.span);
             }
         }
-        for (const { pair, trait } of catalog_1.PLATFORM_STATE_PAIRS) {
+        for (const { pair, trait } of catalog_js_1.PLATFORM_STATE_PAIRS) {
             if (names.includes(pair[0]) && names.includes(pair[1])) {
                 const at = states.find((s) => s.name === pair[1]) ?? states[0];
                 this.diagnostics.error('analysis.shadow-state', `\`${pair[0]}\`/\`${pair[1]}\` reproduces a platform-owned pair — compose \`${trait}\` and read the state live (\`is ${pair[0]}\`) instead of storing it.`, at.span);
@@ -752,6 +1422,121 @@ class Analyzer {
         for (const s of decl.scores)
             this.collectScore(s.name, s.worth, s.span, id);
     }
+    /** Construct kinds already reported by the scoring gate (one each). */
+    scoringGateReported = new Set();
+    /**
+     * Report the `use scoring` gate for one construct kind (ADR-261 D4).
+     *
+     * A gated construct must never be silently dead, so this is an error rather
+     * than a warning, backstopped by a `LoadError` in the story-loader for rogue
+     * IR — the two-layer shape ADR-215 uses for `define machine`.
+     *
+     * The third gated construct, a `rank` rung, cannot reach this check: the
+     * ladder is structurally inside the `use scoring` body, so a stray rung is
+     * `parse.rank-outside-scoring` at parse time — an earlier and more precise
+     * diagnostic. The loader's backstop covers the rogue-IR form.
+     */
+    reportScoringGate(kind, span) {
+        if (this.scoringGateReported.has(kind))
+            return;
+        this.scoringGateReported.add(kind);
+        const what = kind === 'score'
+            ? 'A `score … worth N` line needs'
+            : 'An `award` statement needs';
+        this.diagnostics.error('analysis.scoring-needs-use', `${what} \`use scoring\` in the story header — without it the game has no score at all, and SCORE says so.`, span);
+    }
+    /**
+     * Build the `use scoring` rank ladder (ADR-261 D2/D5).
+     *
+     * Rungs may be written in any order and are sorted ascending here, so the
+     * loader and the ledger both receive a sorted ladder. Three gates:
+     *
+     * - **duplicate threshold** — silently keeping one rung would make the
+     *   resolved rank depend on array order (ADR-260 D2);
+     * - **duplicate id** — two names that kebab-case alike collide in
+     *   `if.event.band_crossed`'s payload, which is keyed on the id;
+     * - **rung above max** — an unreachable rank. This check is sound for
+     *   Chord *specifically* because Chord has no statement that changes
+     *   maxScore at runtime, so the sum of declared `worth` is the whole
+     *   ceiling. A TypeScript story calling `setMaxScore` mid-game (as dungeo
+     *   does) has no compile step and is unaffected, by design.
+     */
+    buildRanks() {
+        const declared = this.ast.header?.ranks ?? [];
+        if (declared.length === 0)
+            return [];
+        const maxScore = this.scoreDecls.reduce((sum, s) => sum + s.worth, 0);
+        const byThreshold = new Map();
+        const byId = new Map();
+        const ranks = [];
+        for (const rung of declared) {
+            const id = kebabId(rung.name);
+            if (!id) {
+                this.diagnostics.error('analysis.rank-id-empty', `Rank name "${rung.name}" yields no id — a rank name needs at least one letter or digit.`, rung.span);
+                continue;
+            }
+            const clashingThreshold = byThreshold.get(rung.threshold);
+            if (clashingThreshold !== undefined) {
+                this.diagnostics.error('analysis.duplicate-rank-threshold', `Two rungs share the threshold ${rung.threshold} ("${clashingThreshold}" and "${rung.name}") — which rank applies would depend on source order.`, rung.span);
+                continue;
+            }
+            const clashingId = byId.get(id);
+            if (clashingId !== undefined) {
+                this.diagnostics.error('analysis.duplicate-rank-id', `Rank names "${clashingId}" and "${rung.name}" both reduce to the id \`${id}\` — a promotion event could not tell them apart.`, rung.span);
+                continue;
+            }
+            if (maxScore > 0 && rung.threshold > maxScore) {
+                this.diagnostics.error('analysis.rank-above-max', `Rank "${rung.name}" sits at ${rung.threshold}, above the ${maxScore} points this story declares — no player could reach it.`, rung.span);
+                continue;
+            }
+            byThreshold.set(rung.threshold, rung.name);
+            byId.set(id, rung.name);
+            ranks.push({
+                id,
+                name: rung.name,
+                threshold: rung.threshold,
+                ...(rung.phraseKey !== undefined ? { phraseKey: rung.phraseKey } : {}),
+                span: rung.span,
+            });
+        }
+        return ranks.sort((a, b) => a.threshold - b.threshold);
+    }
+    /**
+     * Lower the `use hunger` body (ADR-263 D1): dedup band thresholds, sort
+     * ascending. `grows`/`fatal` pass through for the loader's daemon and
+     * death-trigger lowering.
+     */
+    buildHunger() {
+        const decl = this.ast.header?.hunger;
+        if (!decl)
+            return undefined;
+        const seen = new Set();
+        const rungs = [];
+        for (const rung of decl.rungs) {
+            if (!rung.band) {
+                this.diagnostics.error('analysis.meter-band-empty', 'A hunger band needs a name.', rung.span);
+                continue;
+            }
+            if (seen.has(rung.threshold)) {
+                this.diagnostics.error('analysis.duplicate-hunger-threshold', `Two hunger bands share threshold ${rung.threshold} — the resolved band would depend on order.`, rung.span);
+                continue;
+            }
+            seen.add(rung.threshold);
+            rungs.push({
+                id: rung.band,
+                threshold: rung.threshold,
+                ...(rung.phraseKey !== undefined ? { phraseKey: rung.phraseKey } : {}),
+                span: rung.span,
+            });
+        }
+        rungs.sort((a, b) => a.threshold - b.threshold);
+        return {
+            ...(decl.grows !== undefined ? { grows: decl.grows } : {}),
+            ...(decl.fatal !== undefined ? { fatal: decl.fatal } : {}),
+            rungs,
+            span: decl.span,
+        };
+    }
     /** Register an owner-attached score (ratchet D12) under its qualified id. */
     collectScore(name, worth, span, ownerKey) {
         const qualified = ownerKey ? `${ownerKey}.${name}` : name;
@@ -779,9 +1564,111 @@ class Analyzer {
             span: decl.span,
         });
     }
+    /** ADR-255: `override message <alias>` — full phrase body under an ACL alias. */
+    collectOverrideMessage(decl) {
+        this.registerMessageOverride(DEFAULT_LOCALE, decl.alias, decl.span, {
+            strategy: decl.strategy ?? null,
+            ...(decl.verbatim ? { verbatim: true } : {}),
+            variants: decl.variants.map((v) => this.variantOf(v)),
+            span: decl.span,
+        });
+    }
+    /** ADR-255: `override messages <locale>` — flat `alias: text` entries. */
+    collectOverrideMessages(decl) {
+        for (const entry of decl.entries) {
+            this.registerMessageOverride(decl.locale, entry.key, entry.span, {
+                strategy: null,
+                variants: [this.variantOf(entry.value)],
+                span: entry.span,
+            });
+        }
+    }
+    /**
+     * ADR-255 D4: register a message override, gating the alias against the
+     * ACL catalog (`analysis.unknown-message-alias`, mirroring `unknown-channel`)
+     * and rejecting a duplicate. The alias — never a dotted platform id — is
+     * resolved to `if.action.*` loader-side (Interface Contract 3).
+     */
+    registerMessageOverride(locale, alias, span, phrase) {
+        if (!alias)
+            return; // header parse error already reported
+        if (!catalog_js_1.MESSAGE_OVERRIDE_ALIASES.has(alias)) {
+            this.diagnostics.error('analysis.unknown-message-alias', `\`${alias}\` is not a standard-action message alias${this.suggestText(alias, [...catalog_js_1.MESSAGE_OVERRIDE_ALIASES])}.`, span);
+            return;
+        }
+        let table = this.messageOverrides.get(locale);
+        if (!table) {
+            table = new Map();
+            this.messageOverrides.set(locale, table);
+        }
+        if (table.has(alias)) {
+            this.diagnostics.error('analysis.duplicate-message-override', `Message override \`${alias}\` is declared twice in ${locale}.`, span);
+            return;
+        }
+        table.set(alias, phrase);
+    }
     variantOf(value) {
         return { text: value.text, markers: value.markers.map((m) => m.content) };
     }
+    /** Duplicate-name gate shared by `define phrasebook` and `use phrasebook`. */
+    registerPhrasebookName(name, span) {
+        const first = this.phrasebookNames.get(name);
+        if (first) {
+            this.diagnostics.error('analysis.duplicate-phrasebook', `A phrasebook named \`${name}\` is already declared at line ${first.line}.`, span);
+            return false;
+        }
+        this.phrasebookNames.set(name, span);
+        return true;
+    }
+    /** Book coverage bookkeeping: key → covered by a default (always) book? */
+    recordBookKey(key, isAlways) {
+        this.bookKeys.set(key, (this.bookKeys.get(key) ?? false) || isAlways);
+    }
+    /** `use phrasebook <name> [while <cond>]` (ADR-250 D2/D3) — pass 1. */
+    collectUsePhrasebook(use) {
+        const manifest = phrasebooks_js_1.PHRASEBOOK_REGISTRY.get(use.name);
+        if (!manifest) {
+            this.diagnostics.error('analysis.unknown-phrasebook', `\`use phrasebook ${use.name}\` names no registered phrasebook${this.suggestText(use.name, [...phrasebooks_js_1.PHRASEBOOK_REGISTRY.keys()])}.`, use.span);
+            return;
+        }
+        if (!this.registerPhrasebookName(use.name, use.span))
+            return;
+        this.phrasebookDecls.push({ name: use.name, source: 'use', condition: use.condition, span: use.span });
+        for (const key of manifest.keys)
+            this.recordBookKey(key, use.condition === null);
+    }
+    /** `define phrasebook` (ADR-250 D1/D3) — pass 1: entry gates + coverage. */
+    collectPhrasebook(decl) {
+        if (!decl.name)
+            return; // header parse error already reported
+        if (!this.registerPhrasebookName(decl.name, decl.span))
+            return;
+        const entries = {};
+        for (const entry of decl.entries) {
+            if (entry.condition) {
+                this.diagnostics.error('analysis.phrasebook-entry-gate', `Entries carry no \`while\` — the book's own predicate is the gate. Move the condition to \`define phrasebook ${decl.name} while …\`, or split the entry into a second book.`, entry.span);
+            }
+            if (entry.key.includes('.')) {
+                this.diagnostics.error('analysis.phrasebook-dotted-key', `\`${entry.key}\` is a platform message ID — phrasebooks voice the story's own keys. To override a platform message, use a story-level \`define phrase ${entry.key}\`.`, entry.span);
+                continue;
+            }
+            if (entry.key === 'br' || RESERVED_CHANNEL_KEYS.has(entry.key)) {
+                this.diagnostics.error('analysis.phrasebook-reserved-key', `\`${entry.key}\` is reserved — pick another entry key.`, entry.span);
+                continue;
+            }
+            if (entries[entry.key]) {
+                this.diagnostics.error('analysis.phrasebook-duplicate-key', `\`${entry.key}\` is declared twice in phrasebook \`${decl.name}\` — competing texts live in different books.`, entry.span);
+                continue;
+            }
+            entries[entry.key] = {
+                strategy: entry.strategy ?? null,
+                variants: entry.variants.map((v) => this.variantOf(v)),
+                span: entry.span,
+            };
+            this.recordBookKey(entry.key, decl.condition === null);
+        }
+        this.phrasebookDecls.push({ name: decl.name, source: 'define', condition: decl.condition, entries, span: decl.span });
+    }
     registerPhrase(locale, key, phrase) {
         if (key === 'br') {
             // `{br}` is the built-in hard-line-break marker (grammar log 2026-07-10).
@@ -816,7 +1703,16 @@ class Analyzer {
         for (const comp of decl.compositions) {
             const built = {
                 name: comp.words.join(' ').toLowerCase(),
-                config: comp.config.map((c) => ({ key: c.key.join(' '), value: c.value, valueKind: c.valueKind })),
+                config: comp.config.map((c) => ({
+                    key: c.key.join(' '),
+                    value: c.value,
+                    valueKind: c.valueKind,
+                    // `[ … ]` list entries resolve to entity IDs here (ADR-215) —
+                    // unresolved names report through the standard unknown-entity gate.
+                    ...(c.valueKind === 'list'
+                        ? { values: (c.listValues ?? []).map((ref) => this.resolveEntityId(ref) ?? '').filter((id) => id !== '') }
+                        : {}),
+                })),
                 condition: comp.condition ? this.resolveCondition(comp.condition, entityScope(sym ?? null)) : null,
                 span: comp.span,
             };
@@ -824,6 +1720,128 @@ class Analyzer {
                 kinds.push(built);
             else
                 traits.push(built);
+            // ADR-215: extension vocabulary is admitted only when its `use` is
+            // declared (core manifests — npc — are always admitted), and its
+            // `with`-fields are the manifest's closed, typed set — unknown keys
+            // and mistyped values are compile errors, never a silent drop at the
+            // loader. `[ … ]` list values exist only as manifest list fields.
+            if (!comp.article) {
+                const contributed = (0, index_js_1.manifestForAdjective)(built.name);
+                if (!contributed) {
+                    for (const cfg of comp.config) {
+                        if (cfg.valueKind === 'list') {
+                            this.diagnostics.error('analysis.config-list-host', `\`[ … ]\` list values belong to extension fields that declare them (e.g. \`patrol route [ … ]\`) — \`${built.name}\` has none.`, cfg.span);
+                        }
+                    }
+                }
+                if (contributed) {
+                    if (!contributed.manifest.core && !this.usedExtensions.has(contributed.manifest.name)) {
+                        this.diagnostics.error('analysis.extension-not-used', `\`${built.name}\` is \`${contributed.manifest.name}\` extension vocabulary — add \`use ${contributed.manifest.name}\` to the story header.`, comp.span);
+                    }
+                    else {
+                        for (const cfg of comp.config) {
+                            const key = cfg.key.join(' ');
+                            const field = contributed.adjective.fields.find((f) => f.key === key);
+                            if (!field) {
+                                const known = contributed.adjective.fields.map((f) => f.key).join(', ');
+                                this.diagnostics.error('analysis.extension-config-key', `\`${key}\` is not a \`${built.name}\` field — known fields: ${known}.`, cfg.span);
+                            }
+                            else if (field.valueKind !== cfg.valueKind) {
+                                this.diagnostics.error('analysis.extension-config-value', `\`${key}\` takes a ${field.valueKind} value, not ${cfg.valueKind === 'name' ? 'an entity name' : `a ${cfg.valueKind}`}.`, cfg.span);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        // ADR-231 D5a pairing gate: each `starts <state>` initializer requires
+        // its paired trait composed on the same entity (`starts locked` needs
+        // `lockable`, `starts closed`/`open` need `openable`, `starts off`/`on`
+        // need `switchable`). Table-driven — STARTS_STATE_PAIRINGS is the one
+        // place future stateful traits extend. Mismatch = load-time error, never
+        // a silent no-op.
+        const startsStates = [];
+        for (const s of decl.startsStates) {
+            const requiredTrait = catalog_js_1.STARTS_STATE_PAIRINGS.get(s.state);
+            if (!requiredTrait)
+                continue; // parser already rejected the word
+            if (!traits.some((t) => t.name === requiredTrait)) {
+                this.diagnostics.error('analysis.starts-state-pairing', `\`starts ${s.state}\` requires \`${requiredTrait}\` composed on this entity.`, s.span);
+                continue;
+            }
+            startsStates.push(s.state);
+        }
+        // ADR-242 D1: `proper` is the first kind-scoped trait adjective —
+        // person-only and unconditional (identity is not turn state). Both
+        // gates are analyzer diagnostics so the author reads the specific
+        // reason, not the loader's generic conditional-composition error.
+        const isPerson = kinds.some((k) => k.name === 'person');
+        for (const comp of decl.compositions) {
+            if (comp.article || comp.words.join(' ').toLowerCase() !== 'proper')
+                continue;
+            if (!isPerson) {
+                this.diagnostics.error('analysis.proper-person-only', `\`proper\` composes only on a person (\`a person, proper\`) — \`${decl.name.words.join(' ')}\` is not a person.`, comp.span);
+            }
+            if (comp.condition) {
+                this.diagnostics.error('analysis.proper-conditional', 'Identity is not conditional — `proper while …` is not supported; a name is proper or it is not.', comp.span);
+            }
+        }
+        // ADR-242 D5: `pronouns <word>` — person-only, at most one line, and
+        // the word resolves against the standard four or a `define pronouns`
+        // set (never guessed; nearest-match suggestion on a miss, ruled Q-2:
+        // no default is injected when the line is absent).
+        let pronouns;
+        if (decl.pronouns.length > 0) {
+            if (!isPerson) {
+                this.diagnostics.error('analysis.pronouns-person-only', `\`pronouns\` is a person line — \`${decl.name.words.join(' ')}\` is not a person.`, decl.pronouns[0].span);
+            }
+            for (const extra of decl.pronouns.slice(1)) {
+                this.diagnostics.error('analysis.pronouns-duplicate', 'This `create` block already has a `pronouns` line.', extra.span);
+            }
+            const word = decl.pronouns[0].word;
+            if (catalog_js_1.PRONOUN_WORDS.has(word) || this.pronounSetDecls.has(word)) {
+                if (isPerson)
+                    pronouns = word;
+            }
+            else {
+                const known = [...catalog_js_1.PRONOUN_WORDS, ...this.pronounSetDecls.keys()];
+                this.diagnostics.error('analysis.unknown-pronouns', `\`${word}\` is not a pronoun set — the standard sets are ${[...catalog_js_1.PRONOUN_WORDS].map((w) => `\`${w}\``).join(', ')}, plus any \`define pronouns\` set${this.suggestText(word, known)}.`, decl.pronouns[0].span);
+            }
+        }
+        // Player-block composition (Gap-2 ruling, David 2026-07-18): the
+        // player composes like any entity — but only `a person` is a legal
+        // kind (a no-op; the player is already an actor), and NPC behavior
+        // adjectives would hand the player to the NPC service. Both gate.
+        if (isPlayer) {
+            for (const kind of kinds) {
+                if (kind.name !== 'person') {
+                    this.diagnostics.error('analysis.player-kind', `The player cannot be \`a ${kind.name}\` — only \`a person\` composes on the player block (as a no-op).`, kind.span);
+                }
+            }
+            for (const trait of traits) {
+                const contributed = (0, index_js_1.manifestForAdjective)(trait.name);
+                if (contributed?.manifest.name === 'npc') {
+                    this.diagnostics.error('analysis.player-behavior', `\`${trait.name}\` is an NPC behavior — the player is not driven by the NPC service.`, trait.span);
+                }
+            }
+        }
+        // ADR-234 D3: a door's location IS its room pair — the loader places
+        // it in room1 per the platform convention; a placement line is a load
+        // error (the region-placement gate is the direct precedent).
+        if (kinds.some((k) => k.name === 'door') && decl.placement) {
+            this.diagnostics.error('analysis.door-placement', `A door has no placement — its location IS its room pair (the loader places it in the first room of its \`through\` exit line). Remove this line.`, decl.placement.span);
+        }
+        // ADR-236 D1: a region's "location" IS its member list — placement
+        // lines on a region block are a load error (mirror of ADR-234 D3's
+        // door-placement gate).
+        const isRegion = kinds.some((k) => k.name === 'region');
+        if (isRegion && decl.placement) {
+            this.diagnostics.error('analysis.region-placement', `A region has no location — its place IS its member list. Remove this line; membership is \`containing <rooms>\`.`, decl.placement.span);
+        }
+        // ADR-236 D2: `containing` is region membership — on any other block it
+        // would be a silent no-op, so it is a load error, never a guess.
+        if (!isRegion && decl.containing.length > 0) {
+            this.diagnostics.error('analysis.region-containing-host', `\`containing\` declares region membership — \`${decl.name.words.join(' ')}\` is not a region. (Contents are placed with \`in\`/\`on\` lines on the contained entity.)`, decl.containing[0].span);
         }
         // Z1: `first time` prose compiles to RoomTrait.initialDescription —
         // only rooms carry that field, so any other kind is a load error
@@ -836,9 +1854,13 @@ class Analyzer {
             name: decl.name.words.join(' '),
             article: decl.name.article,
             aka: decl.aka,
+            // Present only when declared and resolved (ruled Q-2: absent means
+            // the platform's by-number fallback — and zero golden churn).
+            ...(pronouns !== undefined ? { pronouns } : {}),
             isPlayer,
             kinds,
             traits,
+            startsStates,
             placement: decl.placement
                 ? {
                     relation: decl.placement.relation,
@@ -848,7 +1870,18 @@ class Analyzer {
                 : null,
             wears: decl.wears.map((w) => this.resolveEntityId(w) ?? '').filter((w) => w !== ''),
             carries: decl.carries.map((c) => this.resolveEntityId(c) ?? '').filter((c) => c !== ''),
-            exits: decl.exits.map((e) => ({ direction: e.direction, to: this.resolveEntityId(e.to) ?? '', span: e.span })),
+            containing: decl.containing
+                .map((m) => ({ id: this.resolveEntityId(m) ?? '', span: m.span }))
+                .filter((m) => m.id !== ''),
+            exits: decl.exits.map((e) => ({
+                direction: e.direction,
+                to: this.resolveEntityId(e.to) ?? '',
+                // `through the <door>` (ADR-234 D1): resolved like any entity
+                // reference — an unknown name is the standard unresolved-entity
+                // error; '' marks it so checkDoors skips what is already reported.
+                via: e.via ? (this.resolveEntityId(e.via) ?? '') : null,
+                span: e.span,
+            })),
             blockedExits: decl.blockedExits.map((b) => {
                 this.requirePhrase(b.phraseKey, b.span);
                 return {
@@ -860,6 +1893,14 @@ class Analyzer {
             }),
             deadlyExits: decl.deadlyExits.map((d) => {
                 this.requirePhrase(d.phraseKey, d.span);
+                // Compile gate (platform-issue-sweep Phase 8 #15d): the conditional
+                // form is post-scope (mirror: role-bound trait clauses). It used to
+                // fail only at LOAD (loader.ts throw — kept there as the defensive
+                // backstop), which the harness's expect-fail-manifest convention
+                // cannot pin; failing here makes it a compile diagnostic.
+                if (d.condition !== null) {
+                    this.diagnostics.error('analysis.deadly-while-unsupported', '`is deadly while <condition>` is not wired yet — the conditional deadly exit is post-scope. Use an unconditional `is deadly:` or an `on going` clause with `kill the player when <condition>`.', d.span);
+                }
                 return {
                     direction: d.direction,
                     phraseKey: d.phraseKey,
@@ -878,6 +1919,8 @@ class Analyzer {
             descriptionKey: decl.description ? `${id}.description` : null,
             initialDescriptionKey: decl.initialDescription ? `${id}.initial-description` : null,
             onClauses: this.checkDuplicateClauses(decl.onClauses, decl.name.words.join(' ').toLowerCase()).map((c) => this.buildOnClause(c, entityScope(sym ?? null))),
+            // Filled by applyTopics after every entity is built (ADR-239).
+            topics: [],
             span: decl.span,
         };
     }
@@ -998,8 +2041,26 @@ class Analyzer {
                     span: stmt.span,
                 };
             }
-            case 'emit':
-                return { kind: 'emit', event: stmt.event.join(' '), stmtWhen: this.resolveStmtWhen(stmt.stmtWhen, scope), span: stmt.span };
+            case 'emit': {
+                const payload = stmt.payload.map((f) => this.resolveEmitField(f, scope));
+                // ADR-253 D1: record the event's top-level payload field names so a
+                // channel `return`ing an unknown field is caught (checkChannelReturns).
+                const eventId = stmt.event.join(' ');
+                let fields = this.emitFields.get(eventId);
+                if (!fields) {
+                    fields = new Set();
+                    this.emitFields.set(eventId, fields);
+                }
+                for (const f of stmt.payload)
+                    fields.add(f.key.join(' '));
+                return {
+                    kind: 'emit',
+                    event: eventId,
+                    ...(payload.length > 0 ? { payload } : {}),
+                    stmtWhen: this.resolveStmtWhen(stmt.stmtWhen, scope),
+                    span: stmt.span,
+                };
+            }
             case 'set':
                 return {
                     kind: 'set',
@@ -1055,6 +2116,10 @@ class Analyzer {
                     span: stmt.span,
                 };
             case 'award': {
+                // ADR-261 D4: `award` is gated with `score` and `ranks`.
+                if (!this.usedExtensions.has('scoring')) {
+                    this.reportScoringGate('award', stmt.span);
+                }
                 // `award <score-name>` resolves owner-first (ratchet D12): the
                 // enclosing owner's qualified id, then the story-level bare name.
                 let expression = stmt.expression;
@@ -1098,6 +2163,8 @@ class Analyzer {
                     span: stmt.span,
                 };
             }
+            case 'media':
+                return this.lowerMediaStatement(stmt, scope);
             case 'select-on': {
                 const subject = this.resolveValue(stmt.subject, scope);
                 const stateOwner = this.stateOwnerOf(subject, scope);
@@ -1204,6 +2271,230 @@ class Analyzer {
                 return this.resolveMatch(expr.span, scope);
         }
     }
+    /**
+     * Lower one media sugar statement (ADR-216) onto a payloaded `media-*`
+     * emit — pure compile-time sugar, no runtime surface of its own. The IR
+     * event id is the dotless Chord form (ADR-254/256); `@sharpee/story-loader`
+     * translates it to the platform's dotted `media.*` id at the emit seam.
+     * Asset references are typo-checked with a nearest-match suggestion; kind
+     * mismatches gate (`play ambient` plays SOUND assets — an ambient loop
+     * is a sound file).
+     */
+    lowerMediaStatement(stmt, scope) {
+        const stmtWhen = this.resolveStmtWhen(stmt.stmtWhen, scope);
+        const fields = [];
+        let event = '';
+        const requireAsset = (expected) => {
+            if (!stmt.asset)
+                return; // the parser already reported
+            const found = this.assets.get(stmt.asset);
+            if (!found) {
+                this.diagnostics.error('analysis.unknown-asset', `\`${stmt.asset}\` names no declared asset${this.suggestText(stmt.asset, [...this.assets.keys()])}. Declare it: \`define ${expected} ${stmt.asset} from "<file>"\`.`, stmt.span);
+                return;
+            }
+            if (found.kind !== expected) {
+                this.diagnostics.error('analysis.asset-kind', `\`${stmt.asset}\` is a ${found.kind} asset — this statement needs a ${expected} asset.`, stmt.span);
+                return;
+            }
+            fields.push({ key: 'src', value: { kind: 'literal', value: found.path, valueType: 'string' } });
+        };
+        switch (stmt.form) {
+            case 'play-sound':
+                event = 'media-sound-play';
+                requireAsset('sound');
+                break;
+            case 'play-music':
+                event = 'media-music-play';
+                requireAsset('music');
+                if (stmt.looping)
+                    fields.push({ key: 'loop', value: { kind: 'value', value: { kind: 'symbol', name: 'true' } } });
+                break;
+            case 'stop-music':
+                event = 'media-music-stop';
+                break;
+            case 'play-ambient':
+                event = 'media-ambient-play';
+                requireAsset('sound');
+                this.stampAmbientChannel(stmt, fields);
+                break;
+            case 'stop-ambient':
+                event = 'media-ambient-stop';
+                this.stampAmbientChannel(stmt, fields);
+                break;
+            case 'show-image':
+                event = 'media-image-show';
+                requireAsset('image');
+                if (stmt.layer) {
+                    // ADR-241 D3: layers beyond the platform's pre-registered three
+                    // must be declared (`define layer <word>`) — never-guess.
+                    if (!IMPLIED_IMAGE_LAYERS.has(stmt.layer) && !this.familyChannels.layer.has(stmt.layer)) {
+                        this.diagnostics.error('analysis.unknown-channel', `\`${stmt.layer}\` names no declared image layer${this.suggestText(stmt.layer, [...IMPLIED_IMAGE_LAYERS, ...this.familyChannels.layer.keys()])}. Declare it: \`define layer ${stmt.layer}\`.`, stmt.span);
+                    }
+                    fields.push({ key: 'layer', value: { kind: 'literal', value: stmt.layer, valueType: 'string' } });
+                }
+                break;
+            case 'hide-image':
+                event = 'media-image-hide';
+                break;
+            case 'transition':
+                event = 'media-transition';
+                fields.push({ key: 'kind', value: { kind: 'literal', value: stmt.transitionKind ?? '', valueType: 'string' } });
+                break;
+            case 'clear':
+                event = 'media-clear';
+                break;
+        }
+        return { kind: 'emit', event, ...(fields.length > 0 ? { payload: fields } : {}), stmtWhen, span: stmt.span };
+    }
+    /**
+     * ADR-241 D3: resolve an ambient statement's channel word (the default
+     * bed is `main` — Q-1), gate undeclared words (never-guess — Q-3), and
+     * stamp `channel` onto the payload — the field stdlib's ambient
+     * channels filter on. A bare use of the implied `main` bed records its
+     * first use-site so the bed joins the channel manifest (D4).
+     */
+    stampAmbientChannel(stmt, fields) {
+        const word = stmt.channel ?? 'main';
+        if (word === 'main') {
+            if (!this.familyChannels.ambient.has('main'))
+                this.impliedMainBedSpan ??= stmt.span;
+        }
+        else if (!this.familyChannels.ambient.has(word)) {
+            this.diagnostics.error('analysis.unknown-channel', `\`${word}\` names no declared ambient bed${this.suggestText(word, ['main', ...this.familyChannels.ambient.keys()])}. Declare it: \`define ambient ${word}\`.`, stmt.span);
+        }
+        fields.push({ key: 'channel', value: { kind: 'literal', value: word, valueType: 'string' } });
+    }
+    /** Channel names seen (duplicate gate). */
+    channelNames = new Set();
+    /** Declared family channels (ADR-241 D2) by family: word → first declaration span. */
+    familyChannels = {
+        ambient: new Map(),
+        layer: new Map(),
+    };
+    /** First use-site of the implied `main` ambient bed (ADR-241 D3), if any. */
+    impliedMainBedSpan = null;
+    /**
+     * Build one `define channel` (ADR-216; spelling A): mode/from/take are
+     * required, `gated by` must name a client capability flag (Chord
+     * spelling, lowered to the platform's camelCase key). Re-declaring a
+     * STANDARD channel id is legal platform behavior (story override);
+     * duplicating a story channel is not.
+     */
+    buildChannel(decl) {
+        if (this.channelNames.has(decl.name)) {
+            this.diagnostics.error('analysis.duplicate-channel', `A channel named \`${decl.name}\` already exists.`, decl.span);
+        }
+        this.channelNames.add(decl.name);
+        if (decl.mode === null || !['replace', 'append', 'event'].includes(decl.mode)) {
+            this.diagnostics.error('analysis.channel-mode', `Channel \`${decl.name}\` needs \`mode replace\`, \`mode append\`, or \`mode event\`${decl.mode ? ` — got \`${decl.mode}\`` : ''}.`, decl.span);
+        }
+        if (decl.returns === null || decl.fromEvent === null) {
+            this.diagnostics.error('analysis.channel-return', `Channel \`${decl.name}\` needs a \`return <field | "text" | phrase <key>> from <event>\` line.`, decl.span);
+        }
+        let gatedBy = null;
+        if (decl.gatedBy !== null) {
+            if (!catalog_js_1.CLIENT_CAPABILITY_FLAGS.has(decl.gatedBy)) {
+                this.diagnostics.error('analysis.unknown-capability', `\`${decl.gatedBy}\` is not a client capability flag${this.suggestText(decl.gatedBy, [...catalog_js_1.CLIENT_CAPABILITY_FLAGS])}.`, decl.span);
+            }
+            else {
+                gatedBy = (0, catalog_js_1.capabilityKeyOf)(decl.gatedBy);
+            }
+        }
+        return {
+            name: decl.name,
+            family: 'data',
+            mode: (decl.mode ?? 'event'),
+            gatedBy,
+            fromEvent: decl.fromEvent ?? '',
+            returns: decl.returns ?? { kind: 'field', field: '' },
+            span: decl.span,
+        };
+    }
+    /**
+     * ADR-253 D1 field check: a channel returning a `field` (or a `text` template
+     * with `(slot)` names) references event payload fields; error when the named
+     * event emits a payload that lacks one. Runs as a post-pass so every `emit`
+     * is collected first, regardless of declaration order. An event with no
+     * collected payload (platform events, or one never emitted here) is skipped —
+     * its field set is unknown, not empty. `phrase` returns own their slots
+     * (the phrase system), so they are not cross-checked here.
+     */
+    checkChannelReturns(channels) {
+        for (const ch of channels) {
+            if (ch.family !== 'data')
+                continue;
+            const emitted = this.emitFields.get(ch.fromEvent);
+            if (!emitted)
+                continue; // unknown field set — cannot check
+            const required = ch.returns.kind === 'field'
+                ? [ch.returns.field]
+                : ch.returns.kind === 'text'
+                    ? [...ch.returns.text.matchAll(/\(\s*([^)]+?)\s*\)/g)].map((m) => m[1])
+                    : [];
+            for (const field of required) {
+                if (!emitted.has(field)) {
+                    this.diagnostics.error('analysis.channel-return-field', `Channel \`${ch.name}\` returns \`${field}\`, but the \`${ch.fromEvent}\` event carries no such field (it emits: ${[...emitted].join(', ') || '(none)'}).`, ch.span);
+                }
+            }
+        }
+    }
+    /**
+     * `define pronouns` (ADR-242 D7): exactly the five case rows the
+     * assembler's pronoun table keys — a missing or duplicate row is an
+     * error (order is free; named rows, ruled Q-1). Forms pass through as
+     * data; the language provider owns rendering them.
+     */
+    buildPronounSet(decl) {
+        const byCase = new Map();
+        for (const row of decl.rows) {
+            if (byCase.has(row.case)) {
+                this.diagnostics.error('analysis.pronoun-set-duplicate-row', `\`define pronouns ${decl.name}\` already has a \`${row.case}\` row.`, row.span);
+                continue;
+            }
+            byCase.set(row.case, row.form);
+        }
+        for (const c of catalog_js_1.PRONOUN_CASES) {
+            if (!byCase.has(c)) {
+                this.diagnostics.error('analysis.pronoun-set-rows', `\`define pronouns ${decl.name}\` is missing its \`${c}\` row — all five case rows are required.`, decl.span);
+            }
+        }
+        return {
+            name: decl.name,
+            forms: {
+                subject: byCase.get('subject') ?? '',
+                object: byCase.get('object') ?? '',
+                possessive: byCase.get('possessive') ?? '',
+                possessivePronoun: byCase.get('possessive-pronoun') ?? '',
+                reflexive: byCase.get('reflexive') ?? '',
+            },
+            span: decl.span,
+        };
+    }
+    /** Resolve one emit-payload field (ADR-216) — key words join with a space, passed verbatim. */
+    resolveEmitField(field, scope) {
+        return { key: field.key.join(' '), value: this.resolveEmitValue(field.value, scope) };
+    }
+    /** Resolve one emit-payload value (ADR-216) — recursive over arrays/objects. */
+    resolveEmitValue(value, scope) {
+        switch (value.kind) {
+            case 'literal':
+                return { kind: 'literal', value: value.value, valueType: value.literalKind };
+            case 'expr':
+                return { kind: 'value', value: this.resolveValue(value.expr, scope) };
+            case 'array':
+                return { kind: 'array', items: value.items.map((i) => this.resolveEmitValue(i, scope)) };
+            case 'object':
+                return { kind: 'object', fields: value.fields.map((f) => this.resolveEmitField(f, scope)) };
+        }
+    }
+    /**
+     * `it` in a story-owned clause (ADR-236 D7): the story is the owner and
+     * has no entity referent — the unbound-referent case no other clause
+     * home can produce. A load error, never a silent undefined.
+     */
+    reportStoryClauseIt(span) {
+        this.diagnostics.error('analysis.story-clause-it', '`it` is not bound in a story-owned clause — the story has no entity referent. Name the entity, or use `the player`.', span);
+    }
     /**
      * `the match` — the `each`-block binder (ratchet E3). Legal only inside
      * an `each` body, at any nesting depth (the runtime binds innermost).
@@ -1240,8 +2531,11 @@ class Analyzer {
     }
     resolveRefValue(ref, scope) {
         const words = ref.words.map((w) => w.toLowerCase());
-        if (words.length === 1 && words[0] === 'it')
+        if (words.length === 1 && words[0] === 'it') {
+            if (scope.storyOwned)
+                this.reportStoryClauseIt(ref.span);
             return { kind: 'it' };
+        }
         // `the match` in NameRef positions (`change`/`move` targets, predicate
         // things) resolves to the binder exactly as `it` does — before entity
         // lookup; the name itself is reserved at declaration (E3/P3).
@@ -1255,6 +2549,8 @@ class Analyzer {
         }
         // `its <field>` in name position (`the actor has its food`).
         if (words.length > 1 && words[0] === 'its') {
+            if (scope.storyOwned)
+                this.reportStoryClauseIt(ref.span);
             return { kind: 'field', base: { kind: 'it' }, field: words.slice(1).join(' ') };
         }
         const scoped = this.resolveScopedWords(ref.words, scope);
@@ -1320,6 +2616,14 @@ class Analyzer {
                 return { kind: 'not', operand: this.resolveCondition(cond.operand, scope) };
             case 'chance':
                 return { kind: 'chance', n: cond.n };
+            case 'client-has': {
+                // ADR-216: capability words are the closed platform flag set —
+                // validated here, lowered to the camelCase platform key.
+                if (!catalog_js_1.CLIENT_CAPABILITY_FLAGS.has(cond.capability)) {
+                    this.diagnostics.error('analysis.unknown-capability', `\`${cond.capability}\` is not a client capability flag${this.suggestText(cond.capability, [...catalog_js_1.CLIENT_CAPABILITY_FLAGS])}.`, cond.span);
+                }
+                return { kind: 'client-has', capability: (0, catalog_js_1.capabilityKeyOf)(cond.capability) };
+            }
             case 'condition-ref': {
                 if (this.conditionNames.has(cond.name)) {
                     // Never-guess gate (grammar log 2026-07-11): an OPEN condition is a
@@ -1462,15 +2766,15 @@ class Analyzer {
             const validStates = subjectEntity?.states ?? (subject.kind === 'it' ? scope.ownStates ?? [] : []);
             if (validStates.includes(word))
                 return { kind: 'symbol', name: word };
-            if (catalog_1.TRAIT_ADJECTIVES.has(word))
+            if (catalog_js_1.TRAIT_ADJECTIVES.has(word))
                 return { kind: 'symbol', name: word };
             // State adjectives (ratchet D1): read live from world trait state.
-            if (catalog_1.STATE_ADJECTIVES.has(word))
+            if (catalog_js_1.STATE_ADJECTIVES.has(word))
                 return { kind: 'symbol', name: word };
             const exactEntity = this.entities.find((e) => e.nameLower === word.toLowerCase() || e.aka.includes(word.toLowerCase()));
             if (exactEntity)
                 return { kind: 'entity', id: exactEntity.id };
-            const valid = [...validStates, ...catalog_1.TRAIT_ADJECTIVES, ...catalog_1.STATE_ADJECTIVES];
+            const valid = [...validStates, ...catalog_js_1.TRAIT_ADJECTIVES, ...catalog_js_1.STATE_ADJECTIVES];
             this.diagnostics.error('analysis.unknown-value', `\`${word}\` is not a state${subjectEntity ? ` of ${subjectEntity.nameLower}` : ''} or a known trait${this.suggestText(word, valid)}.`, span);
             return { kind: 'symbol', name: word };
         }
@@ -1495,6 +2799,15 @@ class Analyzer {
             return;
         if (owner && table?.has(`${owner.id}.${key}`))
             return;
+        // ADR-250 D4.6: book coverage counts as declaration. Covered only by
+        // predicated books → warn once (off-book it renders nothing).
+        if (this.bookKeys.has(key)) {
+            if (!this.bookKeys.get(key) && !this.partialCoverageWarned.has(key)) {
+                this.partialCoverageWarned.add(key);
+                this.diagnostics.warning('analysis.phrasebook-partial-coverage', `\`${key}\` is only defined in conditional phrasebooks — when no book is active it renders nothing.`, span);
+            }
+            return;
+        }
         const known = table ? [...table.keys()] : [];
         this.diagnostics.error('analysis.missing-phrase', `Phrase \`${key}\` is not declared in ${DEFAULT_LOCALE}${this.suggestText(key, known)}.`, span);
     }
@@ -1506,26 +2819,40 @@ class Analyzer {
     checkMarkers() {
         for (const [, table] of this.phrases) {
             for (const [key, phrase] of table) {
-                for (const variant of phrase.variants) {
-                    // A variant carrying formatter-chain forms ({You}, {the item},
-                    // {verb:…}) is a TEMPLATE — its bare lowercase markers are chain
-                    // verbs ({open}), not producer references (Phase B: §3.2 trait
-                    // phrases). Full chain validation lands with the AC-9 contract.
-                    const isTemplate = variant.markers.some((m) => /[A-Z]/.test(m[0] ?? '') || m.includes(' ') || m.includes(':'));
-                    if (isTemplate)
-                        continue;
-                    for (const marker of variant.markers) {
-                        if (!/^[a-z][a-z0-9-]*$/.test(marker))
-                            continue;
-                        if (marker === 'br')
-                            continue; // built-in line break (grammar log 2026-07-10)
-                        if (this.hatchNames.has(marker))
-                            continue;
-                        if (this.phrases.get(DEFAULT_LOCALE)?.has(marker))
-                            continue;
-                        this.diagnostics.error('analysis.unbound-marker', `\`{${marker}}\` in phrase \`${key}\` is not a declared text producer or phrase${this.suggestText(marker, [...this.hatchNames])}.`, phrase.span);
-                    }
-                }
+                this.checkPhraseMarkers(key, phrase);
+            }
+        }
+        // Phrasebook entries carry the same marker contract (ADR-250 D1 —
+        // entries are ordinary phrase definitions).
+        for (const book of this.phrasebookDecls) {
+            if (!book.entries)
+                continue;
+            for (const [key, phrase] of Object.entries(book.entries)) {
+                this.checkPhraseMarkers(`${book.name}.${key}`, phrase);
+            }
+        }
+    }
+    checkPhraseMarkers(label, phrase) {
+        for (const variant of phrase.variants) {
+            // A variant carrying formatter-chain forms ({You}, {the item},
+            // {verb:…}) is a TEMPLATE — its bare lowercase markers are chain
+            // verbs ({open}), not producer references (Phase B: §3.2 trait
+            // phrases). Full chain validation lands with the AC-9 contract.
+            const isTemplate = variant.markers.some((m) => /[A-Z]/.test(m[0] ?? '') || m.includes(' ') || m.includes(':'));
+            if (isTemplate)
+                continue;
+            for (const marker of variant.markers) {
+                if (!/^[a-z][a-z0-9-]*$/.test(marker))
+                    continue;
+                if (marker === 'br')
+                    continue; // built-in line break (grammar log 2026-07-10)
+                if (this.hatchNames.has(marker))
+                    continue;
+                if (this.phrases.get(DEFAULT_LOCALE)?.has(marker))
+                    continue;
+                if (this.bookKeys.has(marker))
+                    continue; // book coverage counts (ADR-250 D4.6)
+                this.diagnostics.error('analysis.unbound-marker', `\`{${marker}}\` in phrase \`${label}\` is not a declared text producer or phrase${this.suggestText(marker, [...this.hatchNames])}.`, phrase.span);
             }
         }
     }