@pie-players/pie-assessment-toolkit 0.3.66 → 0.3.67

package/dist/index.d.ts

@@ -53,6 +53,7 @@ export type { ToolConfigDiagnostic, ToolConfigDiagnosticSeverity, ToolConfigStri
 export type { ToolbarButtonItem, ToolbarItem, ToolbarItemBase, ToolbarLinkItem, } from "./services/toolbar-items.js";
 export { isExternalIconUrl, isInlineSvgIcon, isToolbarLinkItem, isValidToolbarItemShape, } from "./services/toolbar-items.js";
 export { normalizeToolsConfig, normalizeToolAlias, normalizeToolList, parseToolList, } from "./services/tools-config-normalizer.js";
+export { isHostDeniedFeature } from "./policy/core/feature-decision.js";
 export { frameworkErrorFromToolConfigValidation, normalizeAndValidateToolsConfig, } from "./services/tool-config-validation.js";
 export type { ParsedToolInstanceId, ToolScopeLevel, } from "./services/tool-instance-id.js";
 export { createScopedToolId, parseScopedToolId, toOverlayToolId, } from "./services/tool-instance-id.js";

package/dist/index.js

@@ -42,6 +42,7 @@ export { ToolkitCoordinator } from "./services/ToolkitCoordinator.js";
 export { formatFrameworkErrorForConsole, frameworkErrorFromToolConfigDiagnostics, frameworkErrorFromUnknown, toFrameworkErrorModel, } from "./services/framework-error.js";
 export { isExternalIconUrl, isInlineSvgIcon, isToolbarLinkItem, isValidToolbarItemShape, } from "./services/toolbar-items.js";
 export { normalizeToolsConfig, normalizeToolAlias, normalizeToolList, parseToolList, } from "./services/tools-config-normalizer.js";
+export { isHostDeniedFeature } from "./policy/core/feature-decision.js";
 export { frameworkErrorFromToolConfigValidation, normalizeAndValidateToolsConfig, } from "./services/tool-config-validation.js";
 export { createScopedToolId, parseScopedToolId, toOverlayToolId, } from "./services/tool-instance-id.js";
 export { PlaybackState, TTSService } from "./services/TTSService.js";

package/dist/policy/core/ToolPolicyEngine.d.ts

@@ -113,6 +113,18 @@ export declare class ToolPolicyEngine {
      * {@link FeaturePolicyDecision.assessmentBound}.
      */
     decideFeature(featureId: string): FeaturePolicyDecision;
+    /**
+     * The host gates that hold for a feature id, or `null` when none fires.
+     *
+     * `policy.allowed` / `policy.blocked` name capabilities, not placements, so
+     * they are the one part of the host pipeline that is meaningful without a
+     * placement level — and the only lever a host has over a capability that
+     * renders as its own surface, since a `region` capability is rejected from
+     * `tools.placement` by configuration validation. `provider-disabled` and
+     * `placement-membership` are deliberately not applied: both are statements
+     * about a toolbar the feature was never on.
+     */
+    private hostFeatureGate;
     /**
      * Convenience wrapper for hosts that just want the visible tool
      * IDs. Equivalent to `decide(...).visibleTools.map(e => e.toolId)`.

package/dist/policy/core/ToolPolicyEngine.js

@@ -16,8 +16,8 @@
  * PR 1 ships the engine *without callers*. PR 2 wires it into
  * `ToolkitCoordinator`. PR 3 switches `<pie-item-toolbar>` over.
  */
-import { normalizeToolsConfig } from "../../services/tools-config-normalizer.js";
-import { interpretFeatureResult } from "./feature-decision.js";
+import { normalizeToolList, normalizeToolsConfig, } from "../../services/tools-config-normalizer.js";
+import { hostFeatureDenial, interpretFeatureResult, } from "./feature-decision.js";
 import { composeDecision } from "./compose-decision.js";
 import { resolveDefaultPnpEnforcement } from "./pnp-policy-inputs.js";
 import { PnpPolicySource } from "../sources/PnpPolicySource.js";
@@ -111,6 +111,9 @@ export class ToolPolicyEngine {
      */
     decideFeature(featureId) {
         this.assertNotDisposed();
+        const hostDenial = this.hostFeatureGate(featureId);
+        if (hostDenial)
+            return hostDenial;
         return interpretFeatureResult(featureId, this.pnpPolicySource.resolveFeature(featureId, {
             assessment: this.assessment ?? undefined,
             currentItemRef: this.currentItemRef ?? undefined,
@@ -120,6 +123,29 @@ export class ToolPolicyEngine {
         // The engine can.
         { assessmentBound: this.assessment !== null });
     }
+    /**
+     * The host gates that hold for a feature id, or `null` when none fires.
+     *
+     * `policy.allowed` / `policy.blocked` name capabilities, not placements, so
+     * they are the one part of the host pipeline that is meaningful without a
+     * placement level — and the only lever a host has over a capability that
+     * renders as its own surface, since a `region` capability is rejected from
+     * `tools.placement` by configuration validation. `provider-disabled` and
+     * `placement-membership` are deliberately not applied: both are statements
+     * about a toolbar the feature was never on.
+     */
+    hostFeatureGate(featureId) {
+        const context = { assessmentBound: this.assessment !== null };
+        const blocked = normalizeToolList(this.tools.policy.blocked);
+        if (blocked.includes(featureId)) {
+            return hostFeatureDenial(featureId, "host-blocked", blocked, context);
+        }
+        const allowed = normalizeToolList(this.tools.policy.allowed);
+        if (allowed.length > 0 && !allowed.includes(featureId)) {
+            return hostFeatureDenial(featureId, "host-allowlist", allowed, context);
+        }
+        return null;
+    }
     /**
      * Convenience wrapper for hosts that just want the visible tool
      * IDs. Equivalent to `decide(...).visibleTools.map(e => e.toolId)`.

package/dist/policy/core/feature-decision.d.ts

@@ -23,6 +23,13 @@
 import type { PnpPolicyResult } from "../sources/PnpPolicySource.js";
 import type { PnpPolicySourceRule } from "./policy-source-tag.js";
 import type { ToolPolicyResolutionDecision, ToolPolicySourceType } from "./provenance.js";
+/**
+ * A feature verdict comes from one of the six PNP precedence levels, or from a
+ * host gate that never reaches them: `tools.policy.blocked` and a non-empty
+ * `tools.policy.allowed` are absolute for the id they name, exactly as they are
+ * on the placement-scoped path.
+ */
+export type FeaturePolicyRule = PnpPolicySourceRule | "host-allowlist" | "host-blocked";
 export interface FeaturePolicyDecision {
     /** The PNP/AfA support id that was evaluated (e.g. `"signLanguage"`). */
     featureId: string;
@@ -34,8 +41,8 @@ export interface FeaturePolicyDecision {
     granted: boolean;
     action: ToolPolicyResolutionDecision["action"];
     /** Which precedence rule produced the verdict. */
-    rule: PnpPolicySourceRule;
-    precedence: 1 | 2 | 3 | 4 | 5 | 6;
+    rule: FeaturePolicyRule;
+    precedence: 0 | 1 | 2 | 3 | 4 | 5 | 6;
     sourceType: ToolPolicySourceType;
     /** Human-readable explanation, suitable for a policy debugger. */
     reason: string;
@@ -74,6 +81,25 @@ export interface FeatureDecisionContext {
     /** Whether the engine has an assessment bound. */
     assessmentBound: boolean;
 }
+/**
+ * A host gate denied the feature outright, so no policy source was consulted.
+ *
+ * `precedence: 0` and the two `host-*` rules are the same values
+ * `composeDecision(...)` records for the placement-scoped path, so a debugger
+ * reads one vocabulary for both. `assessmentBound` is still reported: a host
+ * blocklist is a verdict whether or not an assessment was bound, and the flag
+ * only ever qualifies a *policy* denial.
+ */
+export declare function hostFeatureDenial(featureId: string, rule: "host-allowlist" | "host-blocked", hostValue: readonly string[], context: FeatureDecisionContext): FeaturePolicyDecision;
+/**
+ * Whether a host gate produced the verdict, rather than a policy source.
+ *
+ * The distinction is load-bearing for a content-dependent capability that
+ * declares `resolvesWithoutGrant`: an absent grant is a case it is allowed to
+ * answer from the content alone, while a host denial is the host's off switch
+ * and nothing may reopen it.
+ */
+export declare function isHostDeniedFeature(decision: Pick<FeaturePolicyDecision, "rule"> | null | undefined): boolean;
 /**
  * Interpret a single-feature `PnpPolicySource.resolveFeature(...)` result.
  *

package/dist/policy/core/feature-decision.js

@@ -29,6 +29,41 @@
  * a precedence level that does not exist.
  */
 const unboundAssessmentReason = (featureId) => `No assessment is bound, so no policy source could grant "${featureId}"`;
+/**
+ * A host gate denied the feature outright, so no policy source was consulted.
+ *
+ * `precedence: 0` and the two `host-*` rules are the same values
+ * `composeDecision(...)` records for the placement-scoped path, so a debugger
+ * reads one vocabulary for both. `assessmentBound` is still reported: a host
+ * blocklist is a verdict whether or not an assessment was bound, and the flag
+ * only ever qualifies a *policy* denial.
+ */
+export function hostFeatureDenial(featureId, rule, hostValue, context) {
+    return {
+        featureId,
+        granted: false,
+        action: "block",
+        rule,
+        precedence: 0,
+        sourceType: "host",
+        reason: rule === "host-blocked"
+            ? "Listed in tools.policy.blocked"
+            : `Not listed in tools.policy.allowed (${hostValue.join(", ")})`,
+        required: false,
+        assessmentBound: context.assessmentBound,
+    };
+}
+/**
+ * Whether a host gate produced the verdict, rather than a policy source.
+ *
+ * The distinction is load-bearing for a content-dependent capability that
+ * declares `resolvesWithoutGrant`: an absent grant is a case it is allowed to
+ * answer from the content alone, while a host denial is the host's off switch
+ * and nothing may reopen it.
+ */
+export function isHostDeniedFeature(decision) {
+    return (decision?.rule === "host-blocked" || decision?.rule === "host-allowlist");
+}
 /**
  * Interpret a single-feature `PnpPolicySource.resolveFeature(...)` result.
  *

package/dist/policy/engine.d.ts

@@ -21,7 +21,7 @@
  */
 export { ToolPolicyEngine, type PnpEnforcementMode, type ResolvedEngineInputs, type ToolPolicyChangeEvent, type ToolPolicyChangeListener, type ToolPolicyEngineArgs, type ToolPolicyEngineInputs, } from "./core/ToolPolicyEngine.js";
 export { TOOL_POLICY_ENGINE_KEY, type ToolPolicyEngineContext, } from "./core/engine-context.js";
-export type { FeaturePolicyDecision } from "./core/feature-decision.js";
+export { isHostDeniedFeature, type FeaturePolicyDecision, type FeaturePolicyRule, } from "./core/feature-decision.js";
 export type { RequiredToolBlockedDetails, ToolPolicyDecision, ToolPolicyDecisionRequest, ToolPolicyDiagnostic, ToolPolicyDiagnosticCode, ToolPolicyEntry, ToolPolicyHostGate, ToolScope, } from "./core/decision-types.js";
 export type { PolicySource, PolicySourceDecisionContext, PolicySourceProvenanceEntry, PolicySourceResult, } from "./core/PolicySource.js";
 export type { PolicySourceTag, PnpPolicySourceRule, PnpPolicySourceTag, CustomPolicySourceTag, } from "./core/policy-source-tag.js";

package/dist/policy/engine.js

@@ -21,3 +21,4 @@
  */
 export { ToolPolicyEngine, } from "./core/ToolPolicyEngine.js";
 export { TOOL_POLICY_ENGINE_KEY, } from "./core/engine-context.js";
+export { isHostDeniedFeature, } from "./core/feature-decision.js";

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

@@ -0,0 +1,106 @@
+/**
+ * Whether a content capability has anything to show, for one entity and one
+ * 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`
+ * 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
+ * grant.
+ *
+ * Policy answers in three states rather than two, because a host gate is not the
+ * absence of a grant: `resolvesWithoutGrant` lets a capability answer from the
+ * content when nobody was granted anything, and a host that switched the
+ * capability off must not be read as nobody having spoken. Resolution order is
+ * denial, then grant, then the content exception.
+ *
+ * It lives here, data-only and DOM-free, because two renderers ask it. The
+ * section player asks continuously: policy and catalogs both change under a
+ * mounted card, and it re-resolves to reconcile what is on screen. Print asks
+ * once — one learner, one profile, decided before the page exists, with nothing
+ * to toggle. A second implementation for the one-shot case would be two
+ * renderers disagreeing about the same card, which is the failure this exists to
+ * prevent.
+ *
+ * Capability-neutral, and gated as such: nothing here names a support id, a
+ * catalog type, or a surface. The caller passes the registrations and the slot,
+ * a capability interprets its own cards, and the resolution owns only the
+ * two-halves rule and its one documented exception.
+ */
+import type { ToolRegistration } from "../services/ToolRegistry.js";
+import type { CatalogOwnerSnapshot } from "../services/AccessibilityCatalogResolver.js";
+/** What policy answered about one feature 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;
+}
+/**
+ * No source granted it and none denied it. A capability declaring
+ * {@link ToolRegistration.resolvesWithoutGrant} may still answer from the
+ * content: silence is what an authored-presentation alternate looks like,
+ * since no profile speaks for one either way.
+ */
+ | {
+    outcome: "silent";
+}
+/**
+ * A host gate denied it — the off switch, not the absence of a grant. It
+ * outranks `resolvesWithoutGrant`, because a host saying a capability has no
+ * place in this delivery is a statement authored content cannot overrule.
+ */
+ | {
+    outcome: "denied";
+};
+/** Which half of a capability's resolution failed. */
+export type ContentCapabilityPhase = "policy" | "content";
+/** A capability that is in play, and everything its renderer needs to mount it. */
+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
+     * serves both an authored-presentation case and an accommodation can still
+     * tell them apart at render time.
+     */
+    featureId: string;
+    parameters?: unknown;
+    /** Whatever the capability's own `resolve` returned; never inspected here. */
+    content: unknown;
+}
+export interface ResolveContentCapabilitiesArgs {
+    /**
+     * The capabilities to consider. A caller with a registry passes
+     * `getToolsBySurface(surface)`, which is what keeps a renderer from naming
+     * one.
+     */
+    registrations: readonly ToolRegistration[];
+    /** The entity's cards, or `null` when no resolver is available. */
+    catalogs: CatalogOwnerSnapshot | null;
+    /**
+     * Policy's answer about one feature 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
+     * `"silent"` cannot carry: a host that switched the capability off said
+     * something, and a capability allowed to answer from content alone must not
+     * treat that as nobody having spoken.
+     */
+    policyFor: (featureId: 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
+     * capability's defect reach the learner's content.
+     */
+    onError?: (registration: ToolRegistration, phase: ContentCapabilityPhase, error: unknown) => void;
+}
+/**
+ * The capabilities in play, in the order the caller offered them.
+ *
+ * Registry order is preserved so a renderer's slot ordering stays a property of
+ * the registry rather than of resolution timing.
+ */
+export declare function resolveContentCapabilities(args: ResolveContentCapabilitiesArgs): ResolvedContentCapability[];

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

@@ -0,0 +1,136 @@
+/**
+ * Whether a content capability has anything to show, for one entity and one
+ * 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`
+ * 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
+ * grant.
+ *
+ * Policy answers in three states rather than two, because a host gate is not the
+ * absence of a grant: `resolvesWithoutGrant` lets a capability answer from the
+ * content when nobody was granted anything, and a host that switched the
+ * capability off must not be read as nobody having spoken. Resolution order is
+ * denial, then grant, then the content exception.
+ *
+ * It lives here, data-only and DOM-free, because two renderers ask it. The
+ * section player asks continuously: policy and catalogs both change under a
+ * mounted card, and it re-resolves to reconcile what is on screen. Print asks
+ * once — one learner, one profile, decided before the page exists, with nothing
+ * to toggle. A second implementation for the one-shot case would be two
+ * renderers disagreeing about the same card, which is the failure this exists to
+ * prevent.
+ *
+ * Capability-neutral, and gated as such: nothing here names a support id, a
+ * catalog type, or a surface. The caller passes the registrations and the slot,
+ * 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)
+            return null;
+        grant = answer.grant;
+    }
+    catch (error) {
+        args.onError?.(registration, "policy", error);
+        return null;
+    }
+    // The exception, and the only one: a capability whose content can declare
+    // itself authored presentation is consulted even when policy granted nothing,
+    // because an item family designed to be delivered with its alternate on screen
+    // is not an accommodation and no profile grants or revokes it. The capability
+    // still decides — `granted` is how it tells the two cases apart.
+    if (!grant && !registration.resolvesWithoutGrant)
+        return null;
+    if (!registration.requiresAuthoredContent) {
+        // Nothing to look for in the content, so the grant is the whole answer. A
+        // capability reaching here without one has no second half to supply it.
+        if (!grant)
+            return null;
+        return {
+            registration,
+            featureId: grant.featureId,
+            parameters: grant.parameters,
+            content: null,
+        };
+    }
+    const context = {
+        featureId: grant?.featureId ?? "",
+        parameters: grant?.parameters,
+        catalogs: args.catalogs,
+        granted: Boolean(grant),
+    };
+    let content;
+    try {
+        content = registration.requiresAuthoredContent.resolve(context);
+    }
+    catch (error) {
+        args.onError?.(registration, "content", error);
+        return null;
+    }
+    // Absent content is the honest answer to "is there anything to show", not a
+    // failure: the item carries no resource for this capability.
+    if (content === null || content === undefined)
+        return null;
+    return {
+        registration,
+        featureId: context.featureId,
+        parameters: context.parameters,
+        content,
+    };
+}
+/**
+ * The capabilities in play, in the order the caller offered them.
+ *
+ * Registry order is preserved so a renderer's slot ordering stays a property of
+ * the registry rather than of resolution timing.
+ */
+export function resolveContentCapabilities(args) {
+    return args.registrations.flatMap((registration) => {
+        const resolved = resolveOne(registration, args);
+        return resolved ? [resolved] : [];
+    });
+}

package/dist/tools/internal.d.ts

@@ -21,6 +21,8 @@
 export type { HostedToolContext, HostedToolSize, ResolvedToolContext, ToolActivation, ToolContentDependency, ToolContentDependencyContext, ToolModuleLoader, ToolProviderDescriptor, ToolRegistration, ToolRenderElement, ToolSingletonScope, ToolSurfaceRenderContext, ToolSurfaceRenderResult, ToolSurfaceServices, ToolToolbarButtonDefinition, ToolToolbarRenderResult, ToolWindowShellConfig, ToolbarContext, } from "../services/ToolRegistry.js";
 export { ToolRegistry } from "../services/ToolRegistry.js";
 export type { CatalogOwnerCard, CatalogOwnerSnapshot, } from "../services/AccessibilityCatalogResolver.js";
+export type { ContentCapabilityPhase, ContentCapabilityPolicy, ResolveContentCapabilitiesArgs, ResolvedContentCapability, } from "./content-capability-resolution.js";
+export { resolveContentCapabilities } from "./content-capability-resolution.js";
 export type { ToolContext, ToolLevel } from "../services/tool-context.js";
 export { hasChoiceInteraction, hasMathContent, hasReadableText, hasScienceContent, } from "../services/tool-context.js";
 export { createScopedToolId } from "../services/tool-instance-id.js";

package/dist/tools/internal.js

@@ -19,6 +19,7 @@
  * point — the mechanism is the same one our own registrations use.
  */
 export { ToolRegistry } from "../services/ToolRegistry.js";
+export { resolveContentCapabilities } from "./content-capability-resolution.js";
 export { hasChoiceInteraction, hasMathContent, hasReadableText, hasScienceContent, } from "../services/tool-context.js";
 // Scoped tool instance ids, so two placements of one tool do not share state.
 export { createScopedToolId } from "../services/tool-instance-id.js";

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@pie-players/pie-assessment-toolkit",
-	"version": "0.3.66",
+	"version": "0.3.67",
 	"type": "module",
 	"description": "PIE assessment toolkit: composable services + reference implementation for assessment players and tool coordination",
 	"license": "MIT",
@@ -41,6 +41,10 @@
 			"types": "./dist/components/section-toolbar-element.d.ts",
 			"import": "./dist/components/section-toolbar-element.js"
 		},
+		"./services/AccessibilityCatalogResolver": {
+			"types": "./dist/services/AccessibilityCatalogResolver.d.ts",
+			"import": "./dist/services/AccessibilityCatalogResolver.js"
+		},
 		"./services/pnp-standard-features": {
 			"types": "./dist/services/pnp-standard-features.d.ts",
 			"import": "./dist/services/pnp-standard-features.js"
@@ -79,15 +83,15 @@
 		"test": "bun test"
 	},
 	"dependencies": {
-		"@pie-players/pie-calculator": "0.3.66",
-		"@pie-players/pie-context": "0.3.66",
-		"@pie-players/pie-players-shared": "0.3.66",
-		"@pie-players/pie-tts": "0.3.66",
+		"@pie-players/pie-calculator": "0.3.67",
+		"@pie-players/pie-context": "0.3.67",
+		"@pie-players/pie-players-shared": "0.3.67",
+		"@pie-players/pie-tts": "0.3.67",
 		"speech-rule-engine": "^5.0.0-rc.4"
 	},
 	"peerDependencies": {
-		"@pie-players/pie-calculator-desmos": "0.3.66",
-		"@pie-players/tts-client-server": "0.3.66"
+		"@pie-players/pie-calculator-desmos": "0.3.67",
+		"@pie-players/tts-client-server": "0.3.67"
 	},
 	"peerDependenciesMeta": {
 		"@pie-players/pie-calculator-desmos": {
@@ -100,8 +104,8 @@
 	"devDependencies": {
 		"@biomejs/biome": "^2.5.7",
 		"@happy-dom/global-registrator": "^20.11.1",
-		"@pie-players/pie-calculator-desmos": "0.3.66",
-		"@pie-players/tts-client-server": "0.3.66",
+		"@pie-players/pie-calculator-desmos": "0.3.67",
+		"@pie-players/tts-client-server": "0.3.67",
 		"svelte": "^5.56.8",
 		"typescript": "^5.9.3"
 	},