@pie-players/pie-assessment-toolkit 0.3.74 → 0.3.75

package/dist/services/tts/text-processing.js

@@ -1,3 +1,4 @@
+import { flatTreeParentElement, flatTreeTextNodes, rangeHoldsTextPosition, rangeIntersectsComposedNode, } from "./flat-tree.js";
 export const normalizeTextForSpeech = (text) => text.trim().replace(/\s+/g, " ");
 // Single source of truth for aligning spoken text to visible / math text.
 // Letters are matched with `\p{L}` so the tokenizer is Unicode-aware — accented
@@ -50,15 +51,15 @@ export const isElementHiddenForTTS = (element) => {
     return false;
 };
 export const isNodeHiddenForTTS = (node, root) => {
-    let current = node.nodeType === 1
-        ? node
-        : node.parentElement;
+    // Up the flat tree, so a node in a shadow root inherits its host's
+    // visibility and a slotted node the visibility of the slot rendering it.
+    let current = node.nodeType === 1 ? node : flatTreeParentElement(node);
     while (current) {
         if (isElementHiddenForTTS(current))
             return true;
         if (root && current === root)
             break;
-        current = current.parentElement;
+        current = flatTreeParentElement(current);
     }
     return false;
 };
@@ -112,15 +113,14 @@ export const isElementSuppressedForTTS = (element) => {
     return true;
 };
 export const isNodeSuppressedForTTS = (node, root) => {
-    let current = node.nodeType === 1
-        ? node
-        : node.parentElement;
+    // Through shadow hosts as well: suppression on a host covers its shadow tree.
+    let current = node.nodeType === 1 ? node : flatTreeParentElement(node);
     while (current) {
         if (isElementSuppressedForTTS(current))
             return true;
         if (root && current === root)
             break;
-        current = current.parentElement;
+        current = flatTreeParentElement(current);
     }
     return false;
 };
@@ -146,11 +146,7 @@ export const isNodeExcludedFromSpeech = (node, root) => isNodeHiddenForTTS(node,
  * nothing".
  */
 export const collectRangeTextForSpeech = (range, root) => {
-    if (typeof document === "undefined" ||
-        typeof document.createTreeWalker !==
-            "function" ||
-        typeof NodeFilter === "undefined" ||
-        typeof range.intersectsNode !== "function") {
+    if (typeof range.intersectsNode !== "function") {
         // Degraded, and deliberately not silent about the difference: callers still
         // enforce whole-selection suppression from the range's common ancestor, so
         // the construct guard holds even here. What is lost is per-node filtering
@@ -159,25 +155,49 @@ export const collectRangeTextForSpeech = (range, root) => {
     }
     const parts = [];
     let filtered = false;
-    const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT);
-    let current = walker.nextNode();
-    while (current) {
-        const textNode = current;
-        if (range.intersectsNode(textNode)) {
+    for (const textNode of flatTreeTextNodes(root)) {
+        if (rangeIntersectsComposedNode(range, textNode)) {
             if (isNodeExcludedFromSpeech(textNode, root)) {
                 filtered = true;
             }
             else {
-                const raw = textNode.textContent || "";
-                const start = textNode === range.startContainer ? range.startOffset : 0;
-                const end = textNode === range.endContainer ? range.endOffset : raw.length;
-                parts.push(raw.slice(start, end));
+                parts.push(textInRange(textNode, range));
             }
         }
-        current = walker.nextNode();
     }
     return { text: parts.join(""), filtered };
 };
+/** The part of `textNode`'s text that `range` holds, for a node it intersects. */
+export const textInRange = (textNode, range) => {
+    const raw = textNode.textContent || "";
+    const start = textNode === range.startContainer ? range.startOffset : 0;
+    const end = textNode === range.endContainer ? range.endOffset : raw.length;
+    return raw.slice(start, end);
+};
+/**
+ * Whether `range` holds all of `element`'s speakable text: its first and last
+ * speakable characters, which a contiguous range holding both holds everything
+ * between. An element with no speakable text, an image for one, is held when the
+ * range touches it, since no part of it can be selected alone.
+ */
+export const rangeHoldsSpeakableElement = (range, element, root) => {
+    let first = null;
+    let last = null;
+    for (const textNode of flatTreeTextNodes(element)) {
+        if (isNodeExcludedFromSpeech(textNode, root))
+            continue;
+        const raw = textNode.textContent || "";
+        const firstOffset = raw.search(/\S/);
+        if (firstOffset === -1)
+            continue;
+        first ??= { node: textNode, offset: firstOffset };
+        last = { node: textNode, offset: raw.trimEnd().length - 1 };
+    }
+    if (!first || !last)
+        return rangeIntersectsComposedNode(range, element);
+    return (rangeHoldsTextPosition(range, first.node, first.offset) &&
+        rangeHoldsTextPosition(range, last.node, last.offset));
+};
 export const shouldInsertWordBoundarySpace = (previousChar, nextChar, options) => {
     if (!previousChar || !nextChar)
         return false;
@@ -210,10 +230,7 @@ export const shouldInsertWordBoundarySpace = (previousChar, nextChar, options) =
 };
 export const collectVisibleTextAndMap = (element, options) => {
     const map = new Map();
-    if (typeof document === "undefined" ||
-        typeof document.createTreeWalker !==
-            "function" ||
-        typeof NodeFilter === "undefined") {
+    if (typeof document === "undefined") {
         return { text: "", map };
     }
     const outChars = [];
@@ -222,11 +239,8 @@ export const collectVisibleTextAndMap = (element, options) => {
     let lastCharWasWhitespace = false;
     let lastMapped = null;
     let previousVisibleChar = null;
-    const walker = document.createTreeWalker(element, NodeFilter.SHOW_TEXT);
-    let current = walker.nextNode();
-    while (current) {
-        const textNode = current;
-        const parent = textNode.parentElement;
+    for (const textNode of flatTreeTextNodes(element)) {
+        const parent = flatTreeParentElement(textNode);
         if (parent && !isNodeExcludedFromSpeech(textNode, element)) {
             const raw = textNode.textContent || "";
             const firstVisibleMatch = raw.match(/\S/);
@@ -274,7 +288,6 @@ export const collectVisibleTextAndMap = (element, options) => {
                 }
             }
         }
-        current = walker.nextNode();
     }
     const text = outChars.join("").trimEnd();
     while (map.has(text.length)) {

package/dist/services/tts/text-segmentation.d.ts

@@ -7,3 +7,10 @@ export interface SentenceSegmentationOptions {
     useSentenceSegmenter?: boolean;
 }
 export declare const segmentSentences: (text: string, options?: SentenceSegmentationOptions) => SentenceSegment[];
+/**
+ * `text` in pieces of at most `maxLength` characters: whole sentences while they
+ * fit, a sentence too long for one piece cut at its last space that fits, and a
+ * word too long for one piece cut where the limit falls. Each piece is a trimmed
+ * substring of `text`, at its offset there.
+ */
+export declare const splitTextToLength: (text: string, maxLength: number, options?: SentenceSegmentationOptions) => SentenceSegment[];

package/dist/services/tts/text-segmentation.js

@@ -35,3 +35,50 @@ export const segmentSentences = (text, options) => {
     }
     return parsed.length > 0 ? parsed : [{ text, offset: 0 }];
 };
+/**
+ * `text` in pieces of at most `maxLength` characters: whole sentences while they
+ * fit, a sentence too long for one piece cut at its last space that fits, and a
+ * word too long for one piece cut where the limit falls. Each piece is a trimmed
+ * substring of `text`, at its offset there.
+ */
+export const splitTextToLength = (text, maxLength, options) => {
+    const limit = Math.max(1, Math.floor(maxLength));
+    const pieces = [];
+    let start = -1;
+    let end = -1;
+    const flush = () => {
+        if (start >= 0)
+            pieces.push({ text: text.slice(start, end), offset: start });
+        start = -1;
+    };
+    const append = (spanStart, spanEnd) => {
+        if (start >= 0 && spanEnd - start <= limit) {
+            end = spanEnd;
+            return;
+        }
+        flush();
+        let cursor = spanStart;
+        while (spanEnd - cursor > limit) {
+            const window = text.slice(cursor, cursor + limit + 1);
+            const space = window.search(/\s\S*$/);
+            const cut = space > 0 ? cursor + space : cursor + limit;
+            pieces.push({ text: text.slice(cursor, cut).trimEnd(), offset: cursor });
+            cursor = cut;
+            while (cursor < spanEnd && /\s/.test(text[cursor]))
+                cursor++;
+        }
+        if (cursor < spanEnd) {
+            start = cursor;
+            end = spanEnd;
+        }
+    };
+    for (const sentence of segmentSentences(text, options)) {
+        const leading = sentence.text.search(/\S/);
+        if (leading === -1)
+            continue;
+        const spanStart = sentence.offset + leading;
+        append(spanStart, sentence.offset + sentence.text.trimEnd().length);
+    }
+    flush();
+    return pieces;
+};

package/dist/services/tts-runtime-config.d.ts

@@ -1,5 +1,5 @@
 import type { TTSConfig } from "./TTSService.js";
-import type { TextToSpeechToolProviderConfig } from "./tools-config-normalizer.js";
+import type { TextToSpeechToolProviderConfig, ToolProviderConfig } from "./tools-config-normalizer.js";
 import { type SREMathSpeechOptions } from "./tts/math-speech.js";
 export type TTSLayoutMode = "reserved-row" | "expanding-row" | "floating-overlay" | "left-aligned";
 export interface TTSHostToolbarLayout {
@@ -26,9 +26,10 @@ export interface NormalizedTTSSpeedOption {
     isDefault: boolean;
 }
 export interface TTSRuntimeSettings {
-    backend?: "browser" | "polly" | "google" | "server";
+    /** `browser` speaks through the Web Speech API; `server` through a TTS server. */
+    backend?: "browser" | "server";
+    /** The service behind a `server` backend. */
     serverProvider?: "polly" | "google" | "custom";
-    provider?: "polly" | "google" | "custom";
     engine?: "standard" | "neural";
     sampleRate?: number;
     format?: "mp3" | "ogg" | "pcm";
@@ -37,6 +38,15 @@ export interface TTSRuntimeSettings {
     rate?: number;
     pitch?: number;
     apiEndpoint?: string;
+    /**
+     * The host's locale, used for a read whose content names no language: it
+     * drives text normalization and segmentation, is sent as `language` on the
+     * `pie` transport and as `lang_id` on the `custom` transport when nothing
+     * names a language, and a server given no voice picks one for it. The
+     * content language a read resolves (markup `lang`, the tool's `language`,
+     * the toolkit's `content-language`, then `lang_id`) wins over it.
+     * `docs/architecture/internationalization.md#tts-language` is the contract.
+     */
     language?: string;
     transportMode?: "pie" | "custom";
     endpointMode?: "synthesizePath" | "rootPost";
@@ -51,6 +61,12 @@ export interface TTSRuntimeSettings {
     validateEndpoint?: boolean;
     cache?: boolean;
     speedRate?: "slow" | "medium" | "fast";
+    /**
+     * The custom transport's locale, sent on every read in place of the content
+     * language. Where markup and the tool name no language it is also the read's
+     * content language, so text processing and catalog lookups follow it. Leave
+     * it unset to let content language reach the service.
+     */
     lang_id?: string;
     /**
      * Optional inline TTS speed buttons.
@@ -88,17 +104,6 @@ export interface TTSRuntimeSettings {
     providerOptions?: Record<string, unknown>;
 }
 export declare const normalizeTTSLayoutMode: (value: unknown, fallback?: TTSLayoutMode) => TTSLayoutMode;
-/** Legacy numeric helper defaults. Rendered controls add visible Normal separately. */
-export declare const DEFAULT_TTS_SPEED_OPTIONS: readonly number[];
-export declare const normalizeTTSSpeedOptionConfigs: (value: unknown) => TTSSpeedOption[];
-/**
- * Resolves inline toolbar speed options from host config.
- * - Omitted/non-array: default speed buttons.
- * - Empty array: hide speed buttons.
- * - Arrays that sanitize to no valid values: default speed buttons.
- * - 1.0× is never shown as a discrete speed button.
- */
-export declare const normalizeTTSSpeedOptions: (value: unknown) => number[];
 export declare const normalizeTTSSpeedControlOptions: (value: unknown) => NormalizedTTSSpeedOption[];
 export declare const formatTTSSpeedOptionsAsText: (values: number[]) => string;
 /**
@@ -107,10 +112,13 @@ export declare const formatTTSSpeedOptionsAsText: (values: number[]) => string;
  * - Non-empty text with no parseable finite numbers → same as invalid-only array config: defaults.
  */
 export declare const parseTTSSpeedOptionsFromText: (text: string) => number[];
-export declare const resolveTTSRuntimeSettings: (config: TextToSpeechToolProviderConfig | TTSRuntimeSettings | undefined) => TTSRuntimeSettings;
+/**
+ * The runtime settings of a `textToSpeech` provider entry: its top-level keys
+ * with defaults applied. `enabled` and the runtime `provider` object belong to
+ * the tool registration and are dropped.
+ */
+export declare const resolveTTSRuntimeSettings: (config: TextToSpeechToolProviderConfig | ToolProviderConfig | TTSRuntimeSettings | undefined) => TTSRuntimeSettings;
 export declare const resolveTTSBackend: (config: TTSRuntimeSettings) => NonNullable<TTSRuntimeSettings["backend"]>;
-export declare const resolveRuntimeProvider: (config: TTSRuntimeSettings, backend: NonNullable<TTSRuntimeSettings["backend"]>) => TTSRuntimeSettings["serverProvider"];
-export declare const resolveTransportMode: (config: TTSRuntimeSettings, runtimeProvider: TTSRuntimeSettings["serverProvider"]) => NonNullable<TTSRuntimeSettings["transportMode"]>;
 /**
  * The provider configuration built from host settings: the contract's portable
  * fields plus the server adapter's, under the adapter's names.

package/dist/services/tts-runtime-config.js

@@ -6,26 +6,16 @@ const VALID_TTS_LAYOUT_MODES = new Set([
     "left-aligned",
 ]);
 const toRecord = (value) => value && typeof value === "object" ? value : {};
-const isServerBackend = (backend) => backend === "polly" || backend === "google" || backend === "server";
 const withDefault = (value, fallback) => value === undefined ? fallback : value;
 export const normalizeTTSLayoutMode = (value, fallback = "left-aligned") => typeof value === "string" &&
     VALID_TTS_LAYOUT_MODES.has(value)
     ? value
     : fallback;
-/** Legacy numeric helper defaults. Rendered controls add visible Normal separately. */
-export const DEFAULT_TTS_SPEED_OPTIONS = Object.freeze([0.8, 1.25]);
 const DEFAULT_TTS_SPEED_CONTROL_OPTIONS = Object.freeze([
     { rate: 0.8, label: "Slow", ariaLabel: "Slow speed" },
     { rate: 1, label: "Normal", ariaLabel: "Normal speed", default: true },
     { rate: 1.25, label: "Fast", ariaLabel: "Fast speed" },
 ]);
-const normalizeSpeedRate = (entry) => {
-    if (typeof entry !== "number" || !Number.isFinite(entry) || entry <= 0) {
-        return undefined;
-    }
-    const rounded = Math.round(entry * 100) / 100;
-    return rounded === 1 ? undefined : rounded;
-};
 const normalizeControlSpeedRate = (entry) => {
     if (typeof entry !== "number" || !Number.isFinite(entry) || entry <= 0) {
         return undefined;
@@ -51,56 +41,6 @@ const normalizeSpeedAriaLabel = (label, ariaLabel, usedDefaultLabel) => {
         return ariaLabel;
     return `${label} ${ariaLabel}`;
 };
-const normalizeTTSSpeedOptionConfig = (entry) => {
-    if (typeof entry === "number")
-        return normalizeSpeedRate(entry);
-    if (!entry || typeof entry !== "object" || Array.isArray(entry))
-        return undefined;
-    const record = entry;
-    const rate = normalizeSpeedRate(record.rate);
-    if (rate === undefined)
-        return undefined;
-    const label = trimOptionalText(record.label);
-    const ariaLabel = trimOptionalText(record.ariaLabel);
-    return {
-        rate,
-        ...(label ? { label } : {}),
-        ...(ariaLabel ? { ariaLabel } : {}),
-    };
-};
-export const normalizeTTSSpeedOptionConfigs = (value) => {
-    if (!Array.isArray(value))
-        return [...DEFAULT_TTS_SPEED_OPTIONS];
-    if (value.length === 0)
-        return [];
-    const dedupedRates = new Set();
-    const normalized = [];
-    for (const entry of value) {
-        const option = normalizeTTSSpeedOptionConfig(entry);
-        if (option === undefined)
-            continue;
-        const rate = typeof option === "number" ? option : option.rate;
-        if (dedupedRates.has(rate))
-            continue;
-        dedupedRates.add(rate);
-        normalized.push(option);
-    }
-    return normalized.length ? normalized : [...DEFAULT_TTS_SPEED_OPTIONS];
-};
-/**
- * Resolves inline toolbar speed options from host config.
- * - Omitted/non-array: default speed buttons.
- * - Empty array: hide speed buttons.
- * - Arrays that sanitize to no valid values: default speed buttons.
- * - 1.0× is never shown as a discrete speed button.
- */
-export const normalizeTTSSpeedOptions = (value) => {
-    if (!Array.isArray(value))
-        return [...DEFAULT_TTS_SPEED_OPTIONS];
-    if (value.length === 0)
-        return [];
-    return normalizeTTSSpeedOptionConfigs(value).map((option) => typeof option === "number" ? option : option.rate);
-};
 export const normalizeTTSSpeedControlOptions = (value) => {
     const input = Array.isArray(value)
         ? value
@@ -203,8 +143,7 @@ const applyRuntimeDefaults = (config) => {
         ...config,
         layoutMode: normalizeTTSLayoutMode(config.layoutMode),
     };
-    const backend = config.backend || "browser";
-    if (!isServerBackend(backend))
+    if (config.backend !== "server")
         return withLayoutDefaults;
     const withServerDefaults = {
         ...withLayoutDefaults,
@@ -216,48 +155,30 @@ const applyRuntimeDefaults = (config) => {
         rate: withDefault(withLayoutDefaults.rate, 1.0),
         language: withDefault(withLayoutDefaults.language, "en-US"),
     };
-    if (backend === "polly") {
+    if (config.serverProvider === "polly") {
         return {
             ...withServerDefaults,
-            defaultVoice: withDefault(withServerDefaults.defaultVoice, "Joanna"),
             engine: withDefault(withServerDefaults.engine, "neural"),
             format: withDefault(withServerDefaults.format, "mp3"),
             speechMarksMode: withDefault(withServerDefaults.speechMarksMode, "word+sentence"),
         };
     }
-    if (backend === "google") {
-        return {
-            ...withServerDefaults,
-            defaultVoice: withDefault(withServerDefaults.defaultVoice, "en-US-Wavenet-A"),
-        };
-    }
     return withServerDefaults;
 };
+/**
+ * The runtime settings of a `textToSpeech` provider entry: its top-level keys
+ * with defaults applied. `enabled` and the runtime `provider` object belong to
+ * the tool registration and are dropped.
+ */
 export const resolveTTSRuntimeSettings = (config) => {
-    const configRecord = toRecord(config);
-    const settingsRecord = toRecord(configRecord.settings);
-    const { provider, ...merged } = { ...configRecord, ...settingsRecord };
-    // A runtime provider object in `provider` is for the tool registration; the
-    // runtime settings carry only a server provider id.
-    return applyRuntimeDefaults({
-        ...merged,
-        ...(typeof provider === "string" ? { provider } : {}),
-    });
+    const { enabled: _enabled, provider: _provider, ...settings } = toRecord(config);
+    return applyRuntimeDefaults(settings);
 };
 export const resolveTTSBackend = (config) => config.backend || "browser";
-export const resolveRuntimeProvider = (config, backend) => {
-    if (backend === "polly" || backend === "google")
-        return backend;
-    if (backend === "server") {
-        return config.serverProvider || config.provider;
-    }
-    return config.serverProvider || config.provider;
-};
-export const resolveTransportMode = (config, runtimeProvider) => config.transportMode || (runtimeProvider === "custom" ? "custom" : "pie");
 export const buildRuntimeTTSConfig = (config) => {
-    const backend = resolveTTSBackend(config);
-    const runtimeProvider = resolveRuntimeProvider(config, backend);
-    const transportMode = resolveTransportMode(config, runtimeProvider);
+    const runtimeProvider = resolveTTSBackend(config) === "server" ? config.serverProvider : undefined;
+    const polly = runtimeProvider === "polly";
+    const transportMode = config.transportMode || (runtimeProvider === "custom" ? "custom" : "pie");
     const mathSpeech = normalizeSREMathSpeechOptions(config.mathSpeech);
     const runtimeConfig = {
         voice: config.defaultVoice,
@@ -266,16 +187,16 @@ export const buildRuntimeTTSConfig = (config) => {
         providerOptions: {
             ...toRecord(config.providerOptions),
             ...(config.language ? { locale: config.language } : {}),
-            ...(backend === "polly" && config.engine
+            ...(polly && config.engine
                 ? { engine: config.engine }
                 : {}),
-            ...(backend === "polly" && typeof config.sampleRate === "number"
+            ...(polly && typeof config.sampleRate === "number"
                 ? { sampleRate: config.sampleRate }
                 : {}),
-            ...(backend === "polly" && config.format
+            ...(polly && config.format
                 ? { format: config.format }
                 : {}),
-            ...(backend === "polly"
+            ...(polly
                 ? {
                     speechMarkTypes: config.speechMarksMode === "word+sentence"
                         ? ["word", "sentence"]

package/dist/tools/content-capability-resolution.d.ts

@@ -3,7 +3,7 @@
  * profile.
  *
  * Two independent halves, and a capability is in play only when both answer yes:
- * policy granted one of its support ids, and its own `requiresAuthoredContent`
+ * policy granted its support id, and its own `requiresAuthoredContent`
  * found the resource in this entity's catalogs. Neither implies the other — a
  * learner with an accommodation still sees nothing on an item carrying no
  * resource, and an item carrying one shows nothing to a learner without the
@@ -30,11 +30,9 @@
  */
 import type { ToolRegistration } from "../services/ToolRegistry.js";
 import type { CatalogOwnerSnapshot } from "../services/AccessibilityCatalogResolver.js";
-/** What policy answered about one feature id. */
+/** What policy answered about one capability's support id. */
 export type ContentCapabilityPolicy = {
     outcome: "granted";
-    /** The support id that was granted — a capability may declare several. */
-    featureId: string;
     /** Feature parameters carried by the decision, if any. */
     parameters?: unknown;
 }
@@ -61,12 +59,12 @@ export type ContentCapabilityPhase = "policy" | "content";
 export interface ResolvedContentCapability {
     registration: ToolRegistration;
     /**
-     * The granted support id, or `""` when the capability resolved without a
-     * grant. Passed through to the render context unchanged, so a capability that
+     * Whether policy granted the capability; `false` when it resolved from content
+     * alone. Passed through to the render context unchanged, so a capability that
      * serves both an authored-presentation case and an accommodation can still
      * tell them apart at render time.
      */
-    featureId: string;
+    granted: boolean;
     parameters?: unknown;
     /** Whatever the capability's own `resolve` returned; never inspected here. */
     content: unknown;
@@ -81,7 +79,7 @@ export interface ResolveContentCapabilitiesArgs {
     /** The entity's cards, or `null` when no resolver is available. */
     catalogs: CatalogOwnerSnapshot | null;
     /**
-     * Policy's answer about one feature id, in three states.
+     * Policy's answer about one support id, which is a tool id, in three states.
      *
      * Granting requires a documented need, so an unconfigured feature is
      * `"silent"`, never granted. What the third state buys is the distinction
@@ -89,7 +87,7 @@ export interface ResolveContentCapabilitiesArgs {
      * something, and a capability allowed to answer from content alone must not
      * treat that as nobody having spoken.
      */
-    policyFor: (featureId: string) => ContentCapabilityPolicy;
+    policyFor: (supportId: string) => ContentCapabilityPolicy;
     /**
      * Report a capability that threw. It is dropped either way; this is how a
      * caller surfaces it as its own recoverable warning rather than letting one

package/dist/tools/content-capability-resolution.js

@@ -3,7 +3,7 @@
  * profile.
  *
  * Two independent halves, and a capability is in play only when both answer yes:
- * policy granted one of its support ids, and its own `requiresAuthoredContent`
+ * policy granted its support id, and its own `requiresAuthoredContent`
  * found the resource in this entity's catalogs. Neither implies the other — a
  * learner with an accommodation still sees nothing on an item carrying no
  * resource, and an item carrying one shows nothing to a learner without the
@@ -28,51 +28,15 @@
  * a capability interprets its own cards, and the resolution owns only the
  * two-halves rule and its one documented exception.
  */
-/** The support ids a capability answers to, defaulting to its own id. */
-const supportIdsOf = (registration) => registration.pnpSupportIds?.length
-    ? registration.pnpSupportIds
-    : [registration.toolId];
-/**
- * Everything policy has to say about one capability: a grant, an off switch, or
- * nothing.
- *
- * Denial is checked ahead of a grant on each id rather than after the scan,
- * because the two can only disagree when a host blocked one of a capability's ids
- * while a profile granted another, and there the off switch is the later, more
- * specific statement about this delivery.
- *
- * A host gate names *capabilities*, so the tool id is probed too when it is not
- * already a declared support id — otherwise a capability whose id differs from
- * its support ids would slip a host block. That probe is gate-only: a grant on
- * the tool id is ignored, or blocking would double as a second way to switch a
- * capability on.
- */
-function policyForCapability(registration, args) {
-    const supportIds = supportIdsOf(registration);
-    for (const supportId of supportIds) {
-        const answer = args.policyFor(supportId);
-        if (answer.outcome === "denied")
-            return { grant: null, denied: true };
-        if (answer.outcome === "granted")
-            return { grant: answer, denied: false };
-    }
-    if (supportIds.includes(registration.toolId)) {
-        return { grant: null, denied: false };
-    }
-    return {
-        grant: null,
-        denied: args.policyFor(registration.toolId).outcome === "denied",
-    };
-}
 function resolveOne(registration, args) {
     let grant = null;
     try {
-        const answer = policyForCapability(registration, args);
-        // Nothing reopens a host denial — not a grant it outranked, and not the
-        // content exception below.
-        if (answer.denied)
+        const answer = args.policyFor(registration.toolId);
+        // Nothing reopens a host denial, not even the content exception below.
+        if (answer.outcome === "denied")
             return null;
-        grant = answer.grant;
+        if (answer.outcome === "granted")
+            grant = answer;
     }
     catch (error) {
         args.onError?.(registration, "policy", error);
@@ -92,13 +56,12 @@ function resolveOne(registration, args) {
             return null;
         return {
             registration,
-            featureId: grant.featureId,
+            granted: true,
             parameters: grant.parameters,
             content: null,
         };
     }
     const context = {
-        featureId: grant?.featureId ?? "",
         parameters: grant?.parameters,
         catalogs: args.catalogs,
         granted: Boolean(grant),
@@ -117,7 +80,7 @@ function resolveOne(registration, args) {
         return null;
     return {
         registration,
-        featureId: context.featureId,
+        granted: context.granted,
         parameters: context.parameters,
         content,
     };