@xema/omni-protocol 0.1.13 → 0.1.15

package/README.md

@@ -30,7 +30,8 @@ An adapter is loaded from a separate package and may be compiled against a diffe
 version, so its output is untrusted input. Every validator takes `unknown` and returns every
 violation it found rather than throwing on the first, so a caller reports all of them at once.
 Validating a snapshot before it replaces provider state is what stops a malformed task reaching
-the agent's workspace.
+the agent's workspace; validating a result with `validateResult(result, method)` before acting on
+it is what stops a status the host does not know being shown as an outcome.
 
 ```ts
 const violations = validateSnapshot(snapshot, manifest);
@@ -70,7 +71,8 @@ expect(result.disconnectWasClean).toBe(true);
 ```
 
 Run the contract scenarios beside it — authentication restore and expiry, capability withdrawal,
-reconnect with missed assignments, break denial and retry, wrap timeout, browser isolation.
+reconnect with missed assignments, break denial and retry, a break asked for on a task, who a
+break asks, wrap timeout, browser isolation.
 
 > **Assert both directions.** Every helper rejects a violating input as well as accepting a
 > conforming one. A suite that only asserts "this conforming case does not throw" passes unchanged

package/dist/testing.d.ts

@@ -95,6 +95,33 @@ export declare function assertReconnectWithMissedAssignments<C extends Channel>(
  * both.
  */
 export declare function assertDeniedAndRetriedBreak(approvals: readonly BreakApproval[]): void;
+/** One provider as the host sees it when freezing a break attempt's participant set. */
+export interface BreakCandidate {
+    id: string;
+    authentication: AuthenticationState["status"];
+    /** Whether the agent can currently receive work from it: connected, with a capacity stated. */
+    holdsCapacity: boolean;
+}
+/**
+ * The participant set of a break attempt is every connected provider from which the agent can
+ * currently receive work. A provider whose login is not usable -- `expired` above all -- is not
+ * one, whatever else is true of it: nothing can be asked of it, and a host that waits on it
+ * stalls the break for everyone. A usable provider holding capacity is one, and cannot be left
+ * out. `refreshing` is usable: identity and capabilities remain available and work continues.
+ */
+export declare function assertBreakParticipants(candidates: readonly BreakCandidate[], participants: readonly string[]): void;
+/** One published moment of a break asked for on a task: the approval, and how many tasks were outstanding. */
+export interface BreakOnTaskStep {
+    approval: BreakApproval;
+    outstanding: number;
+}
+/**
+ * A break asked for on a task begins when the work ends. `steps` is the sequence the provider
+ * published, first to last: the request is made while work is outstanding, the commit is reported
+ * as `starting-after-task` while it remains, and `in-effect` arrives only once nothing is
+ * outstanding -- never beside a task, and never later than the step that has none.
+ */
+export declare function assertBreakBeginsAfterTask(steps: readonly BreakOnTaskStep[]): void;
 /**
  * Validates the deadline derived from media end and the task's fixed wrap allowance.
  *

package/dist/testing.js

@@ -1,5 +1,5 @@
 import { browserSessionKey, sameCapabilities, } from "./index.js";
-import { assertNoViolations, validateAuthenticationState, validateEventEnvelope, validateManifest, validateSnapshot, } from "./validation.js";
+import { assertNoViolations, validateAuthenticationState, validateEventEnvelope, validateManifest, validateResult, validateSnapshot, } from "./validation.js";
 export { ProtocolConformanceError, assertNoViolations } from "./validation.js";
 /**
  * A part of the contract a run may never reach: state nothing obliges an adapter to publish, so
@@ -245,7 +245,10 @@ export async function exerciseAdapter(adapter, context, options = {}) {
         // Capacity is stated, not requested: nothing may be allocated until it is, so a connection
         // that will not accept one is a connection nothing can be given to.
         const capacity = await connection.setCapacity({ count: 1 });
-        if (capacity.status === "failed") {
+        const malformed = validateResult(capacity, "setCapacity", "connection.setCapacity");
+        violations.push(...malformed);
+        // A refusal is read only from a result that has the shape of one.
+        if (malformed.length === 0 && capacity.status === "failed") {
             violations.push({
                 rule: "connection.setCapacity.failed",
                 path: "connection.setCapacity",
@@ -487,6 +490,58 @@ export function assertDeniedAndRetriedBreak(approvals) {
         throw new Error(`Break retry scenario must end granted or in effect, ended ${String(last)}`);
     }
 }
+const usableLogin = (status) => status === "authenticated" || status === "refreshing";
+/**
+ * The participant set of a break attempt is every connected provider from which the agent can
+ * currently receive work. A provider whose login is not usable -- `expired` above all -- is not
+ * one, whatever else is true of it: nothing can be asked of it, and a host that waits on it
+ * stalls the break for everyone. A usable provider holding capacity is one, and cannot be left
+ * out. `refreshing` is usable: identity and capabilities remain available and work continues.
+ */
+export function assertBreakParticipants(candidates, participants) {
+    const chosen = new Set(participants);
+    for (const id of participants) {
+        if (!candidates.some(candidate => candidate.id === id))
+            throw new Error(`${id} is not a provider the host knows`);
+    }
+    for (const candidate of candidates) {
+        const expected = usableLogin(candidate.authentication) && candidate.holdsCapacity;
+        if (expected && !chosen.has(candidate.id)) {
+            throw new Error(`${candidate.id} can give the agent work and must be a participant`);
+        }
+        if (!expected && chosen.has(candidate.id)) {
+            const why = usableLogin(candidate.authentication) ? "holds no capacity" : `is ${candidate.authentication}`;
+            throw new Error(`${candidate.id} ${why} and is not a participant: nothing can be asked of it`);
+        }
+    }
+}
+/**
+ * A break asked for on a task begins when the work ends. `steps` is the sequence the provider
+ * published, first to last: the request is made while work is outstanding, the commit is reported
+ * as `starting-after-task` while it remains, and `in-effect` arrives only once nothing is
+ * outstanding -- never beside a task, and never later than the step that has none.
+ */
+export function assertBreakBeginsAfterTask(steps) {
+    const asked = steps.findIndex(step => step.approval === "awaiting-decision" || step.approval === "granted");
+    if (asked < 0)
+        throw new Error("Break-on-task scenario requires a request");
+    if ((steps[asked]?.outstanding ?? 0) < 1)
+        throw new Error("Break-on-task scenario requires the request to be made while a task is outstanding");
+    const committed = steps.findIndex((step, index) => index > asked && step.approval === "starting-after-task");
+    if (committed < 0)
+        throw new Error("A break committed on a task is reported as starting-after-task while the work remains");
+    steps.forEach((step, index) => {
+        if (step.approval === "in-effect" && step.outstanding > 0) {
+            throw new Error(`steps[${index}] reports in-effect with ${step.outstanding} task(s) outstanding: a break begins when the work ends`);
+        }
+        if (step.approval === "starting-after-task" && step.outstanding < 1) {
+            throw new Error(`steps[${index}] reports starting-after-task with nothing outstanding: the break should have begun`);
+        }
+    });
+    if (steps.at(-1)?.approval !== "in-effect") {
+        throw new Error(`Break-on-task scenario must end in effect, ended ${String(steps.at(-1)?.approval)}`);
+    }
+}
 /**
  * Validates the deadline derived from media end and the task's fixed wrap allowance.
  *

package/dist/validation.d.ts

@@ -34,4 +34,13 @@ export interface ReaderContext {
 export declare function validateTeamRoster(roster: unknown, path?: string, context?: ReaderContext): ProtocolViolation[];
 export declare function validateSnapshot(snapshot: unknown, manifest: unknown, path?: string, context?: ReaderContext): ProtocolViolation[];
 export declare function validateEventEnvelope(envelope: unknown, manifest: unknown, path?: string, context?: ReaderContext): ProtocolViolation[];
+/** The connection methods whose results `validateResult` knows. */
+export type ResultMethod = "execute" | "dial" | "setCapacity" | "requestBreak" | "commitBreak" | "cancelBreak" | "endBreak" | "executeTeamBreak" | "executeTeamConsult" | "openMedia";
+/**
+ * Validates what a connection method answered. A result is untrusted for the same reason a
+ * snapshot is: it comes from an adapter that may be compiled against another version, and Omni
+ * shows the agent what it says. A status the method does not answer, a failure status without a
+ * failure, a success carrying one, or an `omni.` code the contract lacks are each refused.
+ */
+export declare function validateResult(result: unknown, method: ResultMethod, path?: string): ProtocolViolation[];
 export declare function validateAuthenticationState(state: unknown, path?: string): ProtocolViolation[];

package/dist/validation.js

@@ -9,7 +9,7 @@
 // Each list is pinned to its type both ways -- a member the type lacks, or a member the list
 // lacks, fails to compile -- so what the validators accept cannot drift from what the
 // declarations say.
-import { ALLOWED_BROWSER_URL_SCHEMES, BREAK_KINDS, BROWSER_ISOLATION_SCHEMES, IDLE_CAPABILITIES, OMNI_SUPPORTED_PROTOCOL_VERSIONS, negotiateProtocolVersion, } from "./index.js";
+import { ALLOWED_BROWSER_URL_SCHEMES, BREAK_KINDS, BROWSER_ISOLATION_SCHEMES, IDLE_CAPABILITIES, OMNI_FAILURE_CODES, OMNI_SUPPORTED_PROTOCOL_VERSIONS, negotiateProtocolVersion, } from "./index.js";
 export class ProtocolConformanceError extends Error {
     violations;
     constructor(violations, summary = "Adapter violates the Omni protocol") {
@@ -808,6 +808,12 @@ export function validateSnapshot(snapshot, manifest, path = "snapshot", context
             }
         });
     }
+    // A break in effect begins when the work ends, so it holds no task. A snapshot reporting both
+    // describes a state the agent cannot be in, whichever half is stale.
+    if (isPlainObject(snapshot.break) && snapshot.break.approval === "in-effect"
+        && Array.isArray(snapshot.tasks) && snapshot.tasks.length > 0) {
+        into.add("break.in-effect.tasks", `${path}.tasks`, "a break in effect holds no task: it begins when the work ends, and until then the state is starting-after-task");
+    }
     // Presence is the permission, and it cuts both ways: data a provider never declared a
     // capability for is data Omni would show against a control the agent does not have.
     const idle = isPlainObject(manifest) && isPlainObject(manifest.idleCapabilities) ? manifest.idleCapabilities : {};
@@ -889,9 +895,7 @@ function validateTaskOutcome(value, path, into) {
                 into.add("event.taskEnded.outcome.failed", `${path}.failure`, "a failed outcome must carry a failure");
             }
             else {
-                into.filled(value.failure.code, "failure.code", `${path}.failure.code`, "a failure needs a code");
-                into.filled(value.failure.message, "failure.message", `${path}.failure.message`, "a failure needs a message");
-                into.require(typeof value.failure.retryable === "boolean", "failure.retryable", `${path}.failure.retryable`, "a failure must say whether it is retryable");
+                validateFailureInto(value.failure, `${path}.failure`, into);
             }
             break;
         default:
@@ -1013,6 +1017,75 @@ export function validateEventEnvelope(envelope, manifest, path = "event", contex
     return into.violations;
 }
 // ---------------------------------------------------------------------------
+// Results. A result crosses the same boundary a snapshot does, from an adapter that may be
+// compiled against another version, and Omni shows the agent what it says.
+// ---------------------------------------------------------------------------
+/** A `ProtocolFailure`, wherever one appears: on a result, or on a task's failed outcome. */
+function validateFailureInto(value, path, into) {
+    if (!isPlainObject(value)) {
+        into.add("failure.shape", path, "a failure must be an object");
+        return;
+    }
+    if (into.filled(value.code, "failure.code", `${path}.code`, "a failure needs a code")) {
+        // A provider names its own codes freely; the `omni.` namespace is the contract's, and a code
+        // in it that the contract lacks is one Omni would show without knowing what it means.
+        if (value.code.startsWith("omni.")) {
+            into.require(OMNI_FAILURE_CODES.includes(value.code), "failure.code.unknown", `${path}.code`, `not a contract failure code: ${value.code}`);
+        }
+    }
+    into.filled(value.message, "failure.message", `${path}.message`, "a failure needs a message");
+    into.require(typeof value.retryable === "boolean", "failure.retryable", `${path}.retryable`, "a failure must say whether it is retryable");
+    if (value.retryAfterMs !== undefined) {
+        into.require(typeof value.retryAfterMs === "number" && Number.isFinite(value.retryAfterMs) && value.retryAfterMs >= 0, "failure.retryAfterMs", `${path}.retryAfterMs`, "retryAfterMs must be a non-negative number when present");
+    }
+}
+// Pinned to the result unions: each method's one success status, and the status that carries a
+// failure. A method added to `Connection` without a row here is a compile error at the call site.
+const RESULT_STATUSES = {
+    execute: { success: "applied", failure: "failed" },
+    dial: { success: "dialled", failure: "failed" },
+    setCapacity: { success: "accepted", failure: "failed" },
+    requestBreak: { success: "requested", failure: "failed" },
+    commitBreak: { success: "committed", failure: "failed" },
+    cancelBreak: { success: "cancelled", failure: "failed" },
+    endBreak: { success: "ended", failure: "failed" },
+    executeTeamBreak: { success: "applied", failure: "failed" },
+    executeTeamConsult: { success: "applied", failure: "failed" },
+    openMedia: { success: "opened", failure: "unavailable" },
+};
+/**
+ * Validates what a connection method answered. A result is untrusted for the same reason a
+ * snapshot is: it comes from an adapter that may be compiled against another version, and Omni
+ * shows the agent what it says. A status the method does not answer, a failure status without a
+ * failure, a success carrying one, or an `omni.` code the contract lacks are each refused.
+ */
+export function validateResult(result, method, path = "result") {
+    const into = new Collector();
+    const statuses = RESULT_STATUSES[method];
+    if (!isPlainObject(result)) {
+        into.add("result.shape", path, `${method} must answer an object`);
+        return into.violations;
+    }
+    if (result.status === statuses.success) {
+        into.require(result.failure === undefined, "result.failure.unexpected", `${path}.failure`, `${statuses.success} carries no failure`);
+        if (method === "openMedia") {
+            into.require(isPlainObject(result.session), "result.session", `${path}.session`, "opened carries the media session");
+        }
+    }
+    else if (result.status === statuses.failure) {
+        if (result.failure === undefined) {
+            into.add("result.failure.required", `${path}.failure`, `${statuses.failure} carries the failure that says why`);
+        }
+        else {
+            validateFailureInto(result.failure, `${path}.failure`, into);
+        }
+    }
+    else {
+        into.add("result.status", `${path}.status`, `${method} answers ${statuses.success} or ${statuses.failure}, not ${String(result.status)}`);
+    }
+    return into.violations;
+}
+// ---------------------------------------------------------------------------
 // Authentication.
 // ---------------------------------------------------------------------------
 function validateUser(value, rule, path, into) {

package/guide.md

@@ -1002,7 +1002,6 @@ Request/response polling does not have those properties and is not a transport f
 | `@xema/omni-protocol` | Provider adapter contract and shared domain types |
 | `@xema/omni-protocol/testing` | Adapter conformance helpers |
 | `@xema/omni-protocol/validation` | Runtime validators Omni and adapters both use to reject malformed data |
-| `@xema/omni-protocol/design` | Host design-language integration. Specified separately; no part of it is a provider surface. |
 
 ## Declaring an adapter
 
@@ -2226,7 +2225,8 @@ Starts one outbound call from the idle dialpad. It is present only when the voic
 declares `dial`.
 
 - `destination` is the original number selected or entered by the agent.
-- `source` is `contact` or `manual` and must comply with `destinationPolicy`.
+- The provider holds `destination` to its declared `destinationPolicy`: under `contacts-only`, a
+  number that is not one of its contacts answers `failed` with `omni.destination-not-permitted`.
 - `dialled` confirms that outbound call creation completed.
 - `failed` contains a `ProtocolFailure` and confirms no call was placed.
 
@@ -2260,7 +2260,7 @@ rendering one as the other tells an agent to wait for somebody who is never comi
 | `awaiting-decision` | A person has to decide. The agent is waiting on somebody. |
 | `granted` | A person decided yes. Omni may now tell this provider to stop the agent; until it does, work continues normally, and this says nothing about why Omni has not. |
 | `starting-after-task` | Omni has told the provider to stop; the break begins when the current task ends. No new work arrives meanwhile, and nobody needs to act. |
-| `in-effect` | The agent is on the break now. |
+| `in-effect` | The agent is on the break now. It holds no task: a break begins when the work ends, so a snapshot reporting `in-effect` beside a task is refused as `break.in-effect.tasks`. |
 
 A denial is a decision, not a standing approval state. The provider transitions the request directly
 to `not-requested`; Omni returns the agent to idle and never asks again on their behalf. They saw the
@@ -2365,6 +2365,11 @@ Requests permission to stop the agent later; it does not itself stop work. The p
 offering work and reports `awaiting-decision` or `granted` through `break-state` events. If the request is denied, the
 provider reports `not-requested` directly, with `decisionReason` when one was supplied.
 
+**An agent asks from anywhere — idle or on a task** — and Omni offers the request in the task
+workspace as it does on the idle dashboard. Asked on a task, the break is decided and committed like
+any other and begins when the work ends: that is `starting-after-task`, and
+`assertBreakBeginsAfterTask` is the scenario that holds a provider to it.
+
 #### Break reasons
 
 A provider that defines not-ready reason codes publishes them on `Snapshot.break.reasons`,
@@ -2480,6 +2485,11 @@ Omni coordinates one attempt as follows:
 
 1. Freeze the participant set to every connected provider from which the agent can currently
    receive work. A provider joining during the attempt is given no capacity until it finishes.
+   A provider whose authentication is `expired` is not one the agent can receive work from and is
+   not a participant: nothing is asked of it, the break proceeds without it, and when the login
+   is restored it is reconciled from its snapshot as a set-aside provider is, with no capacity
+   until then. `refreshing` keeps a provider in — its identity and capabilities remain available
+   and work continues. `assertBreakParticipants` holds a host to this set.
 2. Enter `requesting-break`. Keep the agent's normal capacity in place throughout this phase.
 3. Send one `requestBreak` to every participant. A provider reports `awaiting-decision` or
    `granted`; neither state stops work. A denial transitions directly to `not-requested` and
@@ -2705,6 +2715,12 @@ provider whose lead is already at the ceiling answers the join `failed`.
 they joined -- is answered `failed`, whatever their ceiling; the request stands for another lead,
 or until it is withdrawn or declined.
 
+**A lead on a break does not join.** A break is a reported state in which the agent is not working,
+and a join is work. Omni offers Join to a lead only while their own `BreakState.approval` is neither
+`starting-after-task` nor `in-effect` -- a committed break waiting for the lead's current work to
+finish is not given more -- and a provider answers a `join` from a lead on such a break `failed`.
+The request stands for another lead, as it does when this one is already on a call.
+
 **On `decline`, or a request the agent withdraws with `{ type: "lead", action: "cancel" }`, the
 provider clears `lead` from the agent's task** and drops the request from every roster. Nothing
 else changes; the agent is still on the call.
@@ -2919,6 +2935,11 @@ Applies a `TaskCommandRequest` to one provider-local task.
   deciding a member's break that another lead has already decided is `applied` when the decisions
   agree and `failed`, saying so in `message`, when they differ. `commitBreak()` on a break already
   in effect is `committed` for the same reason.
+- **A result is untrusted for the same reason a snapshot is.** It comes from an adapter that may be
+  compiled against another version, and Omni shows the agent what it says. Omni validates it at
+  the boundary with `validateResult(result, "execute")` — a status the method does not answer, a
+  `failed` without its failure, a success carrying one, or an `omni.` code this contract lacks is
+  refused, and the command is treated as unsettled.
 - **A settled result is a fact; an unsettled promise is not.** Transport uncertainty may reject the
   promise with no result at all, and that means *unknown*, not *failed*, and a snapshot follows —
   see **An unsettled result is unknown**. `failed` must never be returned for something the
@@ -3161,6 +3182,7 @@ same exported checks are used by Omni and adapter tests so their interpretations
 | `validateEventEnvelope(envelope, manifest)` | Envelope identity, timestamp, and the payload for each event type. |
 | `validateContact(contact)` | Contact field shapes and attribute keys. Every field is optional, so this checks what is present rather than what is missing. |
 | `validateScheduledActivity(activity)` | Required activity fields and start/end ordering. |
+| `validateResult(result, method)` | What a connection method answered: the status it gives, a failure where the status says so and nowhere else, the failure's shape, and that an `omni.` code is one this contract names. |
 | `validateAuthenticationState(state)` | The identity each state must carry, the capabilities a usable login declares, and the expiry that only `authenticated` may. |
 
 Each returns `ProtocolViolation[]` rather than throwing, so a caller can report every problem at
@@ -3246,6 +3268,8 @@ cannot be established from TypeScript structure alone.
 | `assertReached(result, subjects)` | The exercise met every subject named; throws listing those it did not. Pair it with a clean `exerciseAdapter` result. |
 | `assertAuthenticationRestoreAndExpiry(states)` | A restored authenticated session can refresh and ends in expiry. Every state is validated. |
 | `assertReconnectWithMissedAssignments(before, reconnect, ids)` | A reconnect snapshot restores assignments received while offline. |
+| `assertBreakParticipants(candidates, participants)` | A break attempt asks every usable provider holding capacity, `refreshing` included, and nothing of a provider whose login is `expired`. |
+| `assertBreakBeginsAfterTask(steps)` | A break asked for on a task is committed as `starting-after-task` while work remains and reaches `in-effect` only once nothing is outstanding — never beside a task, never later than the step that has none. |
 | `assertDeniedAndRetriedBreak(states)` | A denial transitions directly to `not-requested`; a later request can still be granted. |
 | `assertWrapTimeout(task, mediaEndedAt, deadline, toleranceMs?)` | The wrap deadline equals media end plus the task allowance, within a tolerance that defaults to 1000ms; a task with no allowance has no deadline, and one observed is the violation. |
 | `assertBrowserIsolationAndReuse(left, right, expected)` | Browser reuse follows only the declared isolation scheme. |
@@ -3259,11 +3283,8 @@ Adapters should run the relevant scenarios against deterministic test state befo
 
 ## A provider does not style the workspace
 
-The package ships a `design` entry point, and none of it is for adapters. It is host UI
-extensibility — how a deployment themes Omni — and it is specified with the host, not here, which
-is why no part of it is declared under **Shapes**.
-
-What belongs in this contract is the boundary. A provider says what a control **is** through its
+How a deployment themes Omni is the host's concern and is specified with the host, not here. What
+belongs in this contract is the boundary. A provider says what a control **is** through its
 capabilities and what its work is **called** through `phaseLabels` and `taskTypePresentation`; how
 any of it is drawn is Omni's. A task cannot select a design language, inject a component, or
 override the agent's theme and font preferences.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xema/omni-protocol",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "description": "The Omni protocol: the contract every provider adapter implements",
   "type": "module",
   "license": "MIT",
@@ -18,10 +18,6 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
-    "./design": {
-      "types": "./dist/design.d.ts",
-      "import": "./dist/design.js"
-    },
     "./testing": {
       "types": "./dist/testing.d.ts",
       "import": "./dist/testing.js"

package/dist/design.d.ts

@@ -1,49 +0,0 @@
-export type ThemePreference = "system" | "light" | "dark";
-export type ResolvedTheme = Exclude<ThemePreference, "system">;
-export type Density = "compact" | "comfortable" | "spacious";
-/** Semantic values consumed by Omni's layout, independent of a CSS framework. */
-export interface DesignTokens {
-    accent: string;
-    accentText: string;
-    surface: string;
-    surfaceMuted: string;
-    selected: string;
-    text: string;
-    mutedText: string;
-    border: string;
-    info: string;
-    success: string;
-    warning: string;
-    danger: string;
-    radius: string;
-    radiusLarge: string;
-    shadow: string;
-    controlFont: string;
-    controlWeight: string;
-    controlTracking: string;
-    controlHeight: string;
-}
-export type ControlKind = "button" | "icon-button" | "checkbox" | "input" | "textarea" | "select" | "tabs" | "menu" | "badge" | "card" | "progress";
-export interface DesignLanguageManifest {
-    id: string;
-    displayName: string;
-    supportedThemes: ReadonlyArray<ResolvedTheme>;
-    supportedControls: ReadonlyArray<ControlKind>;
-    defaultDensity: Density;
-}
-export interface DesignLanguage {
-    manifest: DesignLanguageManifest;
-    tokens: Record<ResolvedTheme, DesignTokens>;
-}
-/**
- * A framework bridge can use any native control representation: an Angular
- * component type, a React component, or an Omni DOM renderer. The protocol
- * deliberately does not make one UI framework part of the ABI.
- */
-export interface DesignLanguageAdapter<TControl = unknown> {
-    readonly language: DesignLanguage;
-    resolveControl(kind: ControlKind): TControl | Promise<TControl>;
-}
-export declare function defineDesignLanguage<TControl, T extends DesignLanguageAdapter<TControl>>(adapter: T): T;
-/** Maps semantic tokens to the stable CSS custom properties understood by Omni. */
-export declare function designTokenProperties(tokens: DesignTokens): Record<string, string>;

package/dist/design.js

@@ -1,27 +0,0 @@
-export function defineDesignLanguage(adapter) {
-    return adapter;
-}
-/** Maps semantic tokens to the stable CSS custom properties understood by Omni. */
-export function designTokenProperties(tokens) {
-    return {
-        "--omni-accent": tokens.accent,
-        "--omni-accent-text": tokens.accentText,
-        "--omni-surface": tokens.surface,
-        "--omni-surface-muted": tokens.surfaceMuted,
-        "--omni-selected": tokens.selected,
-        "--omni-text": tokens.text,
-        "--omni-muted-text": tokens.mutedText,
-        "--omni-border": tokens.border,
-        "--omni-info": tokens.info,
-        "--omni-success": tokens.success,
-        "--omni-warning": tokens.warning,
-        "--omni-danger": tokens.danger,
-        "--omni-radius": tokens.radius,
-        "--omni-radius-large": tokens.radiusLarge,
-        "--omni-shadow": tokens.shadow,
-        "--omni-control-font": tokens.controlFont,
-        "--omni-control-weight": tokens.controlWeight,
-        "--omni-control-tracking": tokens.controlTracking,
-        "--omni-control-height": tokens.controlHeight,
-    };
-}