@takazudo/zdtp 0.4.13 → 0.4.15

package/dist/apply/build-apply-overrides.d.ts

@@ -55,8 +55,8 @@
  * degraded-init paths) can pass `colorDefaults: undefined`; in that case the
  * whole color block is treated as changed.
  *
- * For non-color tokens, `TokenOverrides` is already a sparse diff (only
- * overridden tokens appear in the map) — no baseline comparison is needed.
+ * For non-color tokens, the sparse maps may retain empty or default-equal
+ * values. Those entries are omitted so Apply matches UI and diff-only export.
  *
  * Pure / no IO — safe to import anywhere (browser, Node, tests).
  */

package/dist/apply/compute-hunks.d.ts

@@ -0,0 +1,23 @@
+/** A single CSS custom-property change suitable for an apply preview. */
+export interface ApplyHunk {
+    cssVar: string;
+    /** One-based line number of the declaration in the proposed file. */
+    line: number;
+    /** Complete declaration line before the rewrite. */
+    before: string;
+    /** Complete declaration line after the rewrite. */
+    after: string;
+    /** Neighbouring proposed-file lines, excluding the declaration itself. */
+    context: {
+        before: string[];
+        after: string[];
+    };
+}
+/**
+ * Compute one preview hunk per changed cssVar.
+ *
+ * `changedCssVars` is authoritative: unrelated textual differences never
+ * become hunks. Input order is retained so the response follows request/apply
+ * order, including when multiple declarations share one physical line.
+ */
+export declare function computeHunks(beforeSource: string, afterSource: string, changedCssVars: readonly string[], contextLineCount?: number): ApplyHunk[];

package/dist/apply/last-applied.d.ts

@@ -0,0 +1,5 @@
+import type { PanelConfig } from '../config/panel-config';
+export type FlatOverrides = Record<string, string>;
+export declare function loadLastApplied(cfg: PanelConfig): FlatOverrides;
+export declare function saveLastApplied(overrides: FlatOverrides, cfg: PanelConfig): void;
+export declare function unsavedCssVars(current: FlatOverrides, baseline: FlatOverrides): string[];

package/dist/apply/reconcile-applied.d.ts

@@ -0,0 +1,19 @@
+import type { PanelConfig } from '../config/panel-config';
+import type { ColorTweakState, TweakState } from '../state/tweak-state';
+/**
+ * Remove only overrides the server confirms it wrote. CSS variables are
+ * resolved through the manifest token index so color, secondary-color,
+ * reserved, and generic tab state all follow the same address-based path.
+ *
+ * A same-alias semantic mapping can be emitted because its bg/fg dependency
+ * moved even though the mapping itself did not. Since base-role variables are
+ * outside disk Apply, reconcile that dependency when its derived semantic var
+ * was written. Unwritten aliases are first materialized to their current
+ * numeric index so partial writes never discard their emitted value.
+ */
+export declare function reconcileApplied(state: TweakState, writtenCssVars: readonly string[], cfg: PanelConfig, colorDefaults: ColorTweakState, secondaryDefaults?: ColorTweakState): TweakState;
+export declare function writtenCssVarsFromResponse(response: {
+    updated?: readonly {
+        changed?: readonly string[];
+    }[];
+}): string[];

package/dist/apply-modal.d.ts

@@ -1,58 +1,12 @@
-/**
- * Apply modal — previews the diff between the current `TweakState` and the
- * scheme defaults, then POSTs the diff to the dev-only
- * `/api/dev/design-tokens-apply` endpoint so the tweaks are written back
- * into the host's design-system CSS files on disk.
- *
- * Wiring summary
- * --------------
- * - Diff building is delegated to `./apply/build-apply-overrides`, which
- *   consumes the new `ColorTweakState` shape (palette + semanticMappings) and
- *   emits the flat `{ cssVar: value }` map using `SEMANTIC_CSS_NAMES`.
- * - Per-file grouping (for the preview and for the success view) uses
- *   `./apply/route-tokens-to-files` — the exact same routing the dev-API
- *   handler runs server-side, so the preview matches the server's view of
- *   the world byte-for-byte.
- * - Styling uses bundled BEM classes derived from
- *   `panelConfig.modalClassPrefix` via `modalClass(...)`. The matching CSS
- *   lives in `styles/panel.css` keyed on the default modal class prefix;
- *   consumers that override the prefix opt out of bundled CSS and ship
- *   their own. No Tailwind classes remain.
- *
- * Dialog lifecycle (unchanged)
- * ----------------------------
- * Uses the native `<dialog>` element. Every dismissal path (× / backdrop /
- * Escape / programmatic close) routes through `dialog.close()`, which fires
- * the native `close` event exactly once; `onClose` then fires exactly once
- * per dismissal regardless of the path taken.
- */
 import { type PanelConfig } from './config/panel-config';
 import { type ColorTweakState, type TweakState } from './state/tweak-state';
 export interface ApplyModalProps {
     state: TweakState;
     open: boolean;
     onClose: () => void;
-    /**
-     * Scheme baseline used to diff the current `state.color` against when
-     * computing the flat cssVar overrides. When absent, the entire color block
-     * is treated as changed — useful for tests, but real callers (the panel
-     * itself) always pass the active scheme's initial `ColorTweakState`.
-     */
     colorDefaults?: ColorTweakState;
-    /**
-     * Fired exactly once after the user confirms a successful apply by clicking
-     * "Done". The parent is expected to clear the persisted state envelope,
-     * clear any inline-applied styles, and reset in-memory state to empty.
-     */
-    onApplied: () => void;
-    /**
-     * The mounted panel instance's config (multi-instance, #357). When supplied,
-     * the modal resolves its apply routing / endpoint / secondary cluster / modal
-     * classes from THIS instance rather than the active default instance — so an
-     * Apply on panel A targets A's endpoint+routing, not whichever instance was
-     * configured last. Omitted (e.g. a direct test render) → `getPanelConfig()`,
-     * preserving the single-panel path.
-     */
+    onApplied: (writtenCssVars: string[]) => void;
     instanceConfig?: PanelConfig;
 }
+export declare function flattenApplyOverrides(state: TweakState, colorDefaults: ColorTweakState | undefined, cfg: PanelConfig): Record<string, string>;
 export declare function ApplyModal(props: ApplyModalProps): import("preact").JSX.Element;

package/dist/astro/host-adapter.js

@@ -1,6 +1,6 @@
-import { c as y, g as m, a as w, b, i as P } from "../panel-config-COHesW2B.js";
-import { g, Z as k } from "../tweak-state-BKNxtHzb.js";
-import { s as A, l as D, a as E, i as c, r as f, c as _, b as I, d } from "../autoload-state-CfL2VUe1.js";
+import { c as y, g as m, a as w, b, i as P } from "../panel-config-CRf-ONSV.js";
+import { g, Z as k } from "../tweak-state-BGp_7Tfh.js";
+import { s as A, l as D, a as E, i as c, r as f, c as _, b as I, d } from "../autoload-state-7BQYXI7Y.js";
 const u = "tokenpanel-config";
 function S() {
   if (typeof document > "u")

package/dist/astro/index.js

@@ -1,6 +1,6 @@
-import { s as t } from "../panel-config-COHesW2B.js";
+import { s as t } from "../panel-config-CRf-ONSV.js";
 import { c as d } from "../color-schemes-CgzOBqGO.js";
-import { F as r, G as m, a as g, S as z } from "../manifest-DCReQE0k.js";
+import { F as r, G as m, a as g, S as z } from "../manifest-DvuKi7I4.js";
 const e = {
   colorScheme: "Default Dark",
   colorMode: !1

package/dist/{autoload-state-CfL2VUe1.js → autoload-state-7BQYXI7Y.js}

@@ -1,4 +1,4 @@
-import { g as n, j as o } from "./panel-config-COHesW2B.js";
+import { g as n, j as o } from "./panel-config-CRf-ONSV.js";
 function c() {
   return typeof document < "u" && document !== null && typeof document.getElementById == "function";
 }

package/dist/bin/server.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
-import { realpathSync as E } from "node:fs";
-import { createServer as H } from "node:http";
-import { resolve as p } from "node:path";
-import { l as $, c as x } from "../load-routing-D4H2VOl5.js";
-function g(o, t) {
+import { realpathSync as $ } from "node:fs";
+import { createServer as E } from "node:http";
+import { resolve as h } from "node:path";
+import { l as H, c as L } from "../load-routing-BtCE1hGI.js";
+function w(o, t) {
   return typeof o != "string" || o.length === 0 || t.length === 0 ? !1 : t.includes(o);
 }
-function w(o) {
+function y(o) {
   return {
     "Access-Control-Allow-Origin": o,
     "Access-Control-Allow-Methods": "POST, OPTIONS",
@@ -14,7 +14,7 @@ function w(o) {
     "Access-Control-Max-Age": "600"
   };
 }
-const k = 24681, b = "127.0.0.1", N = `Usage: zdtp-server [options]
+const b = 24681, O = "127.0.0.1", x = `Usage: zdtp-server [options]
 
 Run a small Node http server that wraps the design-token apply handler.
 
@@ -25,8 +25,8 @@ Options:
                             single directory the bin is allowed to write into.
   --routing <path>          REQUIRED. Path to the routing JSON file
                             (prefix -> repo-relative CSS file path).
-  --port <number>           TCP port to bind. Default: ${k}.
-  --host <addr>             Host/interface to bind. Default: ${b}.
+  --port <number>           TCP port to bind. Default: ${b}.
+  --host <addr>             Host/interface to bind. Default: ${O}.
                             Use 0.0.0.0 to expose on the LAN (off by default).
   --allow-origin <origin>   Origin allowed to POST to /apply. Repeatable.
                             At least one is required for any browser to apply.
@@ -39,13 +39,13 @@ Examples:
     --routing ./my.routing.json \\
     --allow-origin http://localhost:34434
 `;
-function v(o) {
+function N(o) {
   const t = {
     root: null,
     writeRoot: null,
     routing: null,
-    port: k,
-    host: b,
+    port: b,
+    host: O,
     allowOrigins: [],
     quiet: !1,
     help: !1
@@ -102,9 +102,9 @@ function c(o, t, e) {
     throw new Error(`${e} requires a value`);
   return n;
 }
-const y = "/apply", D = "/healthz";
-function L(o) {
-  const t = p(o.root ?? process.cwd()), e = p(t, o.writeRoot), n = p(t, o.routing);
+const k = "/apply", v = "/healthz";
+function D(o) {
+  const t = h(o.root ?? process.cwd()), e = h(t, o.writeRoot), n = h(t, o.routing);
   return {
     rootDir: t,
     writeRoot: e,
@@ -119,13 +119,13 @@ function a(o, t, e) {
   const n = JSON.stringify(e);
   o.statusCode = t, o.setHeader("Content-Type", "application/json"), o.setHeader("Content-Length", Buffer.byteLength(n).toString()), o.end(n);
 }
-const O = 1048576;
+const A = 1048576;
 function j(o) {
   return new Promise((t, e) => {
     const n = [];
     let s = 0;
     o.on("data", (r) => {
-      if (s += r.byteLength, s > O) {
+      if (s += r.byteLength, s > A) {
         t(413), o.destroy();
         return;
       }
@@ -154,13 +154,15 @@ function V(o, t) {
   if (!o)
     try {
       const e = JSON.parse(t);
-      if (!e.ok || !Array.isArray(e.updated)) return;
-      const n = e.updated.reduce(
-        (i, l) => i + (Array.isArray(l.changed) ? l.changed.length : 0),
+      if (!e.ok) return;
+      const n = e.dryRun === !0 ? e.files : e.updated;
+      if (!Array.isArray(n)) return;
+      const s = n.reduce(
+        (i, f) => i + (Array.isArray(f.changed) ? f.changed.length : 0),
         0
-      ), s = e.updated.length, r = e.updated.filter((i) => Array.isArray(i.changed) && i.changed.length > 0).map((i) => i.file);
+      ), r = n.length, l = n.filter((i) => Array.isArray(i.changed) && i.changed.length > 0).map((i) => i.file), u = e.dryRun === !0 ? "dry-run" : "applied";
       console.log(
-        `[design-token-panel] applied ${n} tokens to ${s} files (changed: ${r.length > 0 ? r.join(", ") : "none"})`
+        `[design-token-panel] ${u} ${s} ${s === 1 ? "token" : "tokens"} to ${r} ${r === 1 ? "file" : "files"} (changed: ${l.length > 0 ? l.join(", ") : "none"})`
       ), Array.isArray(e.unknownCssVars) && e.unknownCssVars.length > 0 && console.log(
         `[design-token-panel] unknown: ${e.unknownCssVars.length} cssVar(s) not found (${e.unknownCssVars.join(", ")})`
       ), Array.isArray(e.unknownOutsideBlockCssVars) && e.unknownOutsideBlockCssVars.length > 0 && console.log(
@@ -172,9 +174,9 @@ function V(o, t) {
 function B(o) {
   const { applyHandler: t, config: e } = o;
   return async function(s, r) {
-    const i = s.url ?? "/", l = (s.method ?? "GET").toUpperCase(), u = typeof s.headers.origin == "string" ? s.headers.origin : null;
+    const l = s.url ?? "/", u = (s.method ?? "GET").toUpperCase(), d = typeof s.headers.origin == "string" ? s.headers.origin : null;
     try {
-      if (i === D && l === "GET") {
+      if (l === v && u === "GET") {
         a(r, 200, {
           ok: !0,
           writeRoot: e.writeRoot,
@@ -183,51 +185,51 @@ function B(o) {
         });
         return;
       }
-      if (i === y) {
-        if (l === "OPTIONS") {
-          if (!g(u, e.allowOrigins)) {
+      if (l === k) {
+        if (u === "OPTIONS") {
+          if (!w(d, e.allowOrigins)) {
             a(r, 403, { ok: !1, error: "Origin not allowed" });
             return;
           }
-          const S = w(u);
+          const S = y(d);
           for (const [C, P] of Object.entries(S))
             r.setHeader(C, P);
           r.statusCode = 204, r.end();
           return;
         }
-        if (l !== "POST") {
+        if (u !== "POST") {
           r.setHeader("Allow", "POST, OPTIONS"), a(r, 405, { ok: !1, error: "Method not allowed" });
           return;
         }
-        const d = s.headers["content-type"];
-        if (typeof d != "string" || !d.toLowerCase().includes("application/json")) {
+        const p = s.headers["content-type"];
+        if (typeof p != "string" || !p.toLowerCase().includes("application/json")) {
           a(r, 415, { ok: !1, error: "Content-Type must be application/json" });
           return;
         }
-        if (!g(u, e.allowOrigins)) {
+        if (!w(d, e.allowOrigins)) {
           a(r, 403, { ok: !1, error: "Origin not allowed" });
           return;
         }
-        const f = await j(s);
-        if (f === 413) {
+        const i = await j(s);
+        if (i === 413) {
           a(r, 413, {
             ok: !1,
             error: "Payload Too Large",
-            limit: O
+            limit: A
           });
           return;
         }
-        const A = f, m = new Request(`http://localhost${y}`, {
+        const f = i, m = new Request(`http://localhost${k}`, {
           method: "POST",
           headers: U(s),
-          body: A
-        }), h = await t(m), R = await h.clone().text(), T = w(u);
-        await I(r, h, T), V(e.quiet, R);
+          body: f
+        }), g = await t(m), R = await g.clone().text(), T = y(d);
+        await I(r, g, T), V(e.quiet, R);
         return;
       }
       a(r, 404, { ok: !1, error: "Not found" });
-    } catch (d) {
-      console.error("[design-token-panel] Unhandled error:", d), r.headersSent ? r.end() : a(r, 500, { ok: !1, error: "Internal server error" });
+    } catch (p) {
+      console.error("[design-token-panel] Unhandled error:", p), r.headersSent ? r.end() : a(r, 500, { ok: !1, error: "Internal server error" });
     }
   };
 }
@@ -247,28 +249,28 @@ function q(o, t) {
 function F() {
   let o;
   try {
-    o = v(process.argv.slice(2));
+    o = N(process.argv.slice(2));
   } catch (r) {
     console.error(`[design-token-panel] ${r.message}`), console.error(""), console.error("Run --help for usage."), process.exit(1);
   }
-  o.help && (process.stdout.write(N), process.exit(0));
-  const t = L(o);
+  o.help && (process.stdout.write(x), process.exit(0));
+  const t = D(o);
   let e;
   try {
-    e = $(t.routingPath);
+    e = H(t.routingPath);
   } catch (r) {
     console.error(`[design-token-panel] Failed to load routing: ${r.message}`), process.exit(1);
   }
-  const n = x({
+  const n = L({
     rootDir: t.rootDir,
     writeRoot: t.writeRoot,
     routing: e
-  }), s = H(B({ applyHandler: n, config: t }));
+  }), s = E(B({ applyHandler: n, config: t }));
   q(s, t.port), s.listen(t.port, t.host, () => {
     if (!t.quiet) {
-      const r = s.address(), i = typeof r == "object" && r ? r.port : t.port;
+      const r = s.address(), l = typeof r == "object" && r ? r.port : t.port;
       console.log(
-        `[design-token-panel] listening on http://${t.host}:${i} (writeRoot: ${t.writeRoot})`
+        `[design-token-panel] listening on http://${t.host}:${l} (writeRoot: ${t.writeRoot})`
       ), t.allowOrigins.length === 0 && console.log(
         "[design-token-panel] WARNING: no --allow-origin set; browser POST /apply will be rejected."
       );
@@ -278,7 +280,7 @@ function F() {
 const _ = (() => {
   if (typeof process.argv[1] != "string") return !1;
   try {
-    const o = E(process.argv[1]), t = new URL(`file://${p(o)}`).href, e = import.meta.url;
+    const o = $(process.argv[1]), t = new URL(`file://${h(o)}`).href, e = import.meta.url;
     return t === e;
   } catch {
     return !1;

package/dist/bulk/bulk-actions.d.ts

@@ -0,0 +1,45 @@
+import type { ComponentChildren } from 'preact';
+import type { TierConfig } from '../tokens/tier-model';
+import { type NumericValue } from '../utils/numeric-transform';
+import type { FlatTabEntry, RowContribution, TokenAddress } from '../tabs/flat/types';
+export interface BulkOperations {
+    multiply: string;
+    add: string;
+    roundToStep: string;
+    setTo: string;
+}
+export declare const DEFAULT_BULK_OPERATIONS: BulkOperations;
+export interface BulkPatchEntry {
+    address: TokenAddress;
+    value: string;
+}
+export interface BulkContributionOptions {
+    entriesByTier: ReadonlyMap<string, readonly FlatTabEntry[]>;
+    selectedKeys: ReadonlySet<string>;
+    operations: BulkOperations;
+    onToggle: (entry: FlatTabEntry, checked: boolean) => void;
+    onSelectTier: (tier: TierConfig, checked: boolean) => void;
+    onQuick: (tier: TierConfig, factor: number) => void;
+}
+/** Return the declared unit for a numeric token kind. */
+export declare function numericEntryUnit(entry: FlatTabEntry): string;
+/**
+ * Bulk selection is deliberately narrower than numeric row rendering. A row
+ * must be a writable literal length/number with a parseable current value.
+ * Reference tiers, readonly rows, and active pill sentinels cannot safely
+ * participate in a numeric transform.
+ */
+export declare function isBulkSelectable(entry: FlatTabEntry): boolean;
+export declare const isSelectable: typeof isBulkSelectable;
+export declare function numericValueForEntry(entry: FlatTabEntry): NumericValue | null;
+/** Compute one preview value from the action-bar operation fields. */
+export declare function transformBulkEntry(entry: FlatTabEntry, operations: BulkOperations): string | null;
+export declare function createBulkContribution(options: BulkContributionOptions): RowContribution;
+export interface BulkActionBarProps {
+    entries: readonly FlatTabEntry[];
+    operations: BulkOperations;
+    onOperationsChange: (operations: BulkOperations) => void;
+    onClear: () => void;
+    onApply: (patch: readonly BulkPatchEntry[]) => void;
+}
+export declare function BulkActionBar({ entries, operations, onOperationsChange, onClear, onApply, }: BulkActionBarProps): ComponentChildren;

package/dist/bulk/index.d.ts

@@ -0,0 +1,2 @@
+export { BulkActionBar, DEFAULT_BULK_OPERATIONS, createBulkContribution, isBulkSelectable, isSelectable, numericEntryUnit, numericValueForEntry, transformBulkEntry, } from './bulk-actions';
+export type { BulkActionBarProps, BulkContributionOptions, BulkOperations, BulkPatchEntry, } from './bulk-actions';

package/dist/chain/index.d.ts

@@ -0,0 +1,2 @@
+export { ChainButton, ChainPopover, TOKEN_CHAIN_CONTRIBUTION, TokenChainButton, TokenChainPopover, type TokenChainButtonProps, type TokenChainPopoverProps, } from './token-chain-popover';
+export { TokenChainProvider, useTokenChainContext, type TokenChainContextValue, type TokenChainProviderProps, } from './token-chain-context';

package/dist/chain/token-chain-context.d.ts

@@ -0,0 +1,19 @@
+import type { ComponentChildren } from 'preact';
+import type { PanelConfig } from '../config/panel-config';
+import type { TweakState } from '../state/tweak-state';
+import { type TokenGraph } from '../utils/token-graph';
+export interface TokenChainContextValue {
+    graph: TokenGraph;
+}
+export interface TokenChainProviderProps {
+    instanceConfig: PanelConfig;
+    state: TweakState | null;
+    children?: ComponentChildren;
+}
+/**
+ * Keeps the dependency graph tied to the mounted panel instance and its live
+ * tweak state. A chain control rendered outside this provider simply degrades
+ * to no chain affordance, which keeps the row primitives useful in isolation.
+ */
+export declare function TokenChainProvider({ instanceConfig, state, children, }: TokenChainProviderProps): import("preact").JSX.Element;
+export declare function useTokenChainContext(): TokenChainContextValue | null;

package/dist/chain/token-chain-popover.d.ts

@@ -0,0 +1,22 @@
+import type { JSX } from 'preact';
+import { type TokenAddress } from '../utils/token-index';
+import type { RowContribution } from '../tabs/flat/types';
+export interface TokenChainPopoverProps {
+    address: TokenAddress;
+    anchorRef: React.RefObject<HTMLElement | null>;
+    onClose: () => void;
+}
+/**
+ * Body of the per-token chain surface. It is mounted only while its trigger
+ * is open, so the first page probe is deferred until the user asks for it.
+ */
+export declare function TokenChainPopover({ address, anchorRef, onClose, }: TokenChainPopoverProps): JSX.Element | null;
+export interface TokenChainButtonProps {
+    address: TokenAddress;
+}
+/** Chain trigger used by flat rows and Color-tab custom rows. */
+export declare function TokenChainButton({ address }: TokenChainButtonProps): JSX.Element | null;
+/** Shared FlatTab contribution for every non-Color row. */
+export declare const TOKEN_CHAIN_CONTRIBUTION: RowContribution;
+export declare const ChainPopover: typeof TokenChainPopover;
+export declare const ChainButton: typeof TokenChainButton;

package/dist/changed/contribution.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Changed-state row contribution.
+ *
+ * The S2 token evaluator is deliberately the only source of truth here.  A
+ * row's visual state, Changed-only filtering, ghost value, and revert affordance
+ * all consult the same `isChanged` result for the row's stable token address.
+ */
+import type { PanelConfig } from '../config/panel-config';
+import type { TweakState } from '../state/tweak-state';
+import { revertEntry, type ColorBaseline } from '../utils/token-diff';
+import type { TokenIndex, TokenAddress } from '../utils/token-index';
+import type { RowContribution } from '../tabs/flat/types';
+export interface ChangedContributionOptions {
+    index: TokenIndex;
+    state: TweakState;
+    baseline: ColorBaseline;
+    cfg: PanelConfig;
+    /** True while the active tab's transient Changed-only filter is enabled. */
+    changedOnly?: boolean;
+    /** Reverts one stable token address through the shell transaction. */
+    onRevert: (address: TokenAddress) => void;
+}
+/**
+ * Build the contribution used by FlatTab-based token lists.  `revertEntry`
+ * remains in the shell callback rather than here so this presentation seam
+ * never mutates state directly.
+ */
+export declare function changedContribution(options: ChangedContributionOptions): RowContribution;
+/** Explicit factory alias for feature callers and downstream consumers. */
+export declare const createChangedContribution: typeof changedContribution;
+export declare const changedStateContribution: typeof changedContribution;
+export { revertEntry };

package/dist/changed/footer-content.d.ts

@@ -0,0 +1,16 @@
+import type { JSX } from 'preact';
+import type { PanelConfig } from '../config/panel-config';
+import type { ColorBaseline } from '../utils/token-diff';
+import type { TweakState } from '../state/tweak-state';
+import type { TokenIndex } from '../utils/token-index';
+export declare const COPY_REVERT_MS = 2000;
+export interface ChangedFooterContentProps {
+    index: TokenIndex;
+    state: TweakState;
+    baseline: ColorBaseline;
+    cfg: PanelConfig;
+    onRevertAll: () => void;
+}
+/** Footer summary + evaluator-backed Copy diff / Revert all actions. */
+export declare function ChangedFooterContent({ index, state, baseline, cfg, onRevertAll, }: ChangedFooterContentProps): JSX.Element;
+export declare const ChangedFooter: typeof ChangedFooterContent;

package/dist/changed/index.d.ts

@@ -0,0 +1,4 @@
+export { changedContribution, changedStateContribution, createChangedContribution, revertEntry, } from './contribution';
+export { ChangedFooter, ChangedFooterContent, COPY_REVERT_MS } from './footer-content';
+export { ChangedOnlyToggle } from './tab-filter';
+export { ChangedTabBadge, TabChangedBadge } from './tab-badge';

package/dist/changed/tab-badge.d.ts

@@ -0,0 +1,8 @@
+import type { JSX } from 'preact';
+export interface ChangedTabBadgeProps {
+    tabId: string;
+    count: number;
+}
+/** Count badge rendered inside a tab button without affecting tab overflow. */
+export declare function ChangedTabBadge({ tabId, count }: ChangedTabBadgeProps): JSX.Element | null;
+export declare const TabChangedBadge: typeof ChangedTabBadge;

package/dist/changed/tab-filter.d.ts

@@ -0,0 +1,8 @@
+import type { JSX } from 'preact';
+export interface ChangedOnlyToggleProps {
+    enabled: boolean;
+    count: number;
+    onChange: (enabled: boolean) => void;
+}
+/** Transient active-tab Changed-only filter (never persisted). */
+export declare function ChangedOnlyToggle({ enabled, count, onChange, }: ChangedOnlyToggleProps): JSX.Element;

package/dist/config/panel-config.d.ts

@@ -72,6 +72,10 @@ export type ApplyRoutingMap = Record<string, string>;
 export interface DomTweakerConfig {
     themeCss?: string;
 }
+export interface PanelDockConfig {
+    /** Whether docked panels reserve space in the host document. Defaults to body-margin. */
+    reflow?: 'body-margin' | 'none';
+}
 /**
  * Apply sink interface — allows routing CSS-var writes somewhere other than
  * the host `:root` (e.g. a shadow root, an iframe document, or a spy in
@@ -150,6 +154,8 @@ export interface PanelConfig {
      * panel config.
      */
     domTweaker?: DomTweakerConfig;
+    /** Docked-panel integration. Omitted values use body-margin host reflow. */
+    dock?: PanelDockConfig;
     /**
      * Host-supplied tab configuration for the data-driven tab strip.
      *
@@ -470,8 +476,22 @@ export declare function storageKey_open(cfg: PanelConfig): string;
 export declare function storageKey_position(cfg: PanelConfig): string;
 /** User-resized panel size `{ width, height }` (pixels). Lives alongside position. */
 export declare function storageKey_size(cfg: PanelConfig): string;
+/** Persisted shell dock mode. */
+export declare function storageKey_dock(cfg: PanelConfig): string;
+/** Per-axis docked dimensions (`right` width and `bottom` height). */
+export declare function storageKey_dockSize(cfg: PanelConfig): string;
 /** Tab-grid density preference (one of `0` / `1` / `2`). Lives alongside size/position. */
 export declare function storageKey_density(cfg: PanelConfig): string;
+/** Font specimen toolbar state (`{ text, preset, overridden, width }`). */
+export declare function storageKey_specimen(cfg: PanelConfig): string;
+/** Persisted A/B snapshot slot. `slot` is lower-case for storage continuity. */
+export declare function storageKey_snapshot(cfg: PanelConfig, slot: 'a' | 'b'): string;
+/** Persisted snapshot A slot. */
+export declare function storageKey_snapshotA(cfg: PanelConfig): string;
+/** Persisted snapshot B slot. */
+export declare function storageKey_snapshotB(cfg: PanelConfig): string;
+/** Last flattened override set known to match the apply baseline. */
+export declare function storageKey_lastApplied(cfg: PanelConfig): string;
 /**
  * Adapter-level visibility-intent flag.
  *
@@ -532,31 +552,6 @@ export interface ZdtpGlobalApi {
     hide: () => void | Promise<void>;
     toggle: () => void | Promise<void>;
 }
-/**
- * Install `window.zdtp = { show, hide, toggle }`, the fixed-name console
- * sugar for the common single-panel case (issue #523).
- *
- * Guard rules:
- *  - A pre-existing `window.zdtp` WITHOUT this package's marker is assumed to
- *    be host-defined — never overwritten. Logs a `console.warn` so the host
- *    can see why `zdtp.show()` did not appear.
- *  - A pre-existing `window.zdtp` WITH the marker means this package already
- *    installed the alias (from the other call site, or an earlier run of this
- *    same one). First install wins — the call is a silent no-op. In the Astro
- *    flow this manifests as "the adapter wins": its bootstrap script always
- *    runs (and installs the alias) before the panel module's lazy dynamic
- *    import can resolve and reach the package-root install site.
- *
- * `show` / `hide` / `toggle` are caller-supplied closures, so which instance
- * they target is up to the caller — the package-root install site (below,
- * `index.tsx`) wraps `showDesignTokenPanel()` etc., which re-resolve
- * `getPanelConfig()` (the CURRENT default instance) on every call; the Astro
- * host-adapter install site instead binds to the specific `PanelInstanceHandle`
- * captured at its own install time, which does NOT track a later change of
- * default (see PORTABLE-CONTRACT.md §6.5 for the full nuance). Either way,
- * for a multi-instance page use `configurePanel(cfg).open()` etc. on the
- * specific instance's own handle instead of relying on this alias.
- */
 export declare function installZdtpGlobalAlias(api: ZdtpGlobalApi): void;
 /**
  * Runtime validation at the host-adapter trust boundary. The Astro inline
@@ -575,6 +570,8 @@ export declare function assertValidPanelConfig(value: unknown): asserts value is
  * has not configured one — callers MUST treat empty as "apply disabled".
  */
 export declare function resolveApplyRouting(cfg?: PanelConfig): ApplyRoutingMap;
+/** Whether the host has supplied both pieces required for disk-rewrite Apply. */
+export declare function isApplyConfigured(cfg?: PanelConfig): boolean;
 /**
  * Lazily attach a host-supplied color-preset map AFTER `configurePanel(...)`.
  *