@takazudo/zdtp 0.4.1 → 0.4.3

package/dist/{load-routing-XyKgftpe.js → load-routing-DtNTKoLW.js}

@@ -146,7 +146,7 @@ function L(e) {
   return e.replace(/\/\*[\s\S]*?\*\//g, (r) => " ".repeat(r.length));
 }
 function U(e, r, t) {
-  const n = r.startsWith("--") ? r.slice(2) : r, o = H(n), s = new RegExp("(--" + o + ":)(\\s*)([\\s\\S]+?);"), a = L(e), l = s.exec(a);
+  const n = r.startsWith("--") ? r.slice(2) : r, o = H(n), s = new RegExp("(?<![\\w-])(--" + o + ":)(\\s*)([\\s\\S]+?);"), a = L(e), l = s.exec(a);
   if (!l) return { content: e, status: "unknown" };
   const [k, c, f] = l, y = l.index, w = y + k.length, v = y + c.length + f.length, p = w - 1, O = e.slice(v, p).trim(), S = t.trim();
   return O === S ? { content: e, status: "unchanged" } : { content: e.slice(0, y) + c + f + t + ";" + e.slice(w), status: "changed" };

package/dist/panel-config-3tBEHjvZ.js

@@ -0,0 +1,493 @@
+function j(e, t) {
+  return e.paletteCssVarTemplate.replace("{n}", String(t));
+}
+function b(e) {
+  const t = e.colorExtras;
+  if (!t) return;
+  const r = e.tiers.find(
+    (a) => !a.referencesTier && a.items.length > 0 && a.items[0].type.kind === "color"
+  );
+  if (!r)
+    return {
+      id: t.id,
+      label: t.label,
+      paletteSize: 0,
+      baseRoles: t.baseRoles,
+      paletteCssVarTemplate: "--zudo-stub-p{n}",
+      semanticDefaults: {},
+      semanticCssNames: {},
+      baseDefaults: t.baseDefaults,
+      defaultShikiTheme: t.defaultShikiTheme,
+      colorSchemes: t.colorSchemes,
+      panelSettings: t.panelSettings
+    };
+  const i = r.items, u = i.length, s = (i[0]?.cssVar ?? "--palette-{n}").replace(/\d+$/, "{n}"), c = /* @__PURE__ */ new Map();
+  for (let a = 0; a < i.length; a++)
+    c.set(i[a].id, a);
+  const f = e.tiers.find(
+    (a) => a.referencesTier === r.id
+  ), n = {}, l = {};
+  if (f)
+    for (const a of f.items) {
+      l[a.id] = a.cssVar;
+      const d = c.get(a.default);
+      n[a.id] = d ?? 0;
+    }
+  return {
+    id: t.id,
+    label: t.label,
+    paletteSize: u,
+    baseRoles: t.baseRoles,
+    paletteCssVarTemplate: s,
+    semanticDefaults: n,
+    semanticCssNames: l,
+    baseDefaults: t.baseDefaults,
+    defaultShikiTheme: t.defaultShikiTheme,
+    colorSchemes: t.colorSchemes,
+    panelSettings: t.panelSettings
+  };
+}
+function V(e) {
+  const t = e.find((r) => r.id === "color");
+  if (t)
+    return b(t);
+}
+function $(e) {
+  const t = e.find((r) => r.id === "color-secondary");
+  return t ? b(t) ?? null : null;
+}
+function y(e, t) {
+  if (Object.is(e, t)) return !0;
+  if (e === null || t === null || typeof e != typeof t || typeof e != "object") return !1;
+  if (Array.isArray(e)) {
+    if (!Array.isArray(t) || e.length !== t.length) return !1;
+    for (let o = 0; o < e.length; o++)
+      if (!y(e[o], t[o])) return !1;
+    return !0;
+  }
+  if (Array.isArray(t)) return !1;
+  const r = Object.keys(e), i = Object.keys(t);
+  if (r.length !== i.length) return !1;
+  const u = new Set(i);
+  for (const o of r)
+    if (!u.has(o) || !y(e[o], t[o]))
+      return !1;
+  return !0;
+}
+const k = {
+  storagePrefix: "zudo-design-token-panel",
+  consoleNamespace: "zudo",
+  modalClassPrefix: "zudo-design-token-panel-modal",
+  schemaId: "zudo-design-tokens/v1",
+  exportFilenameBase: "zudo-design-tokens",
+  // Empty tab list — hosts MUST configure real tabs via configurePanel().
+  tabs: [],
+  colorPresets: {},
+  // No bundled apply endpoint / routing — hosts wire their own.
+  applyEndpoint: void 0,
+  applyRouting: void 0
+}, w = /* @__PURE__ */ Symbol.for("@takazudo/zdtp:singleton");
+function g() {
+  const e = globalThis;
+  let t = e[w];
+  return t || (t = {
+    instances: /* @__PURE__ */ new Map(),
+    defaultPrefix: null,
+    pendingColorPresets: null,
+    pendingPostConfigureHooks: [],
+    lifecycleHooks: {}
+  }, e[w] = t), t;
+}
+function E(e) {
+  return {
+    instanceId: e,
+    open() {
+      g().lifecycleHooks.open?.(e);
+    },
+    close() {
+      g().lifecycleHooks.close?.(e);
+    },
+    toggle() {
+      g().lifecycleHooks.toggle?.(e);
+    },
+    destroy() {
+      g().lifecycleHooks.destroy?.(e);
+      const t = g();
+      if (t.instances.delete(e), t.defaultPrefix === e) {
+        const r = [...t.instances.keys()];
+        t.defaultPrefix = r.length > 0 ? r[r.length - 1] : null;
+      }
+    }
+  };
+}
+function R(e) {
+  g().lifecycleHooks = {
+    configured: e.configured,
+    open: e.open,
+    close: e.close,
+    toggle: e.toggle,
+    destroy: e.destroy
+  };
+}
+function _(e) {
+  const t = g(), r = e.storagePrefix, i = t.instances.get(r);
+  if (i) {
+    const n = (l) => ({ ...l, applySink: void 0 });
+    if (y(n(i.suppliedConfig), n(e)))
+      return t.defaultPrefix = r, i.handle;
+    throw new Error(
+      `[design-token-panel] configurePanel() was already called with different values for storagePrefix "${r}". Configuration is one-shot per prefix per page lifecycle. To re-configure this prefix, call handle.destroy() first, then configurePanel() again. (Use a distinct storagePrefix for a second panel instance.)`
+    );
+  }
+  const u = t.pendingColorPresets, o = u ? { ...e, colorPresets: u } : { ...e };
+  t.pendingColorPresets = null;
+  const s = t.instances.size === 0, c = s ? [...t.pendingPostConfigureHooks] : [];
+  s && (t.pendingPostConfigureHooks.length = 0);
+  const f = {
+    config: o,
+    // Snapshot the as-supplied config before any runtime merges. Used by the
+    // idempotency guard so view-transition re-calls with the original inline
+    // config keep passing even after setPanelColorPresets mutates `config`.
+    suppliedConfig: { ...e },
+    pendingColorPresets: null,
+    postConfigureHooks: c,
+    handle: E(r)
+  };
+  t.instances.set(r, f), t.defaultPrefix = r;
+  for (const n of f.postConfigureHooks)
+    n();
+  return t.lifecycleHooks.configured?.(r), f.handle;
+}
+function m() {
+  const e = g();
+  return e.defaultPrefix === null ? null : e.instances.get(e.defaultPrefix) ?? null;
+}
+function M(e) {
+  const t = m();
+  if (t === null) {
+    const r = g();
+    if (r.pendingPostConfigureHooks.includes(e)) return;
+    r.pendingPostConfigureHooks.push(e);
+    return;
+  }
+  t.postConfigureHooks.includes(e) || (t.postConfigureHooks.push(e), e());
+}
+function C() {
+  return m()?.config ?? k;
+}
+function H() {
+  return [...g().instances.values()].map((e) => e.config);
+}
+function O(e) {
+  return g().instances.get(e)?.config ?? null;
+}
+function N() {
+  const e = g();
+  e.instances.clear(), e.defaultPrefix = null, e.pendingColorPresets = null, e.pendingPostConfigureHooks.length = 0;
+}
+function K(e = C()) {
+  return $(e.tabs);
+}
+function z(e) {
+  return `${e.storagePrefix}-state-v2`;
+}
+function D(e) {
+  return `${e.storagePrefix}-state-v3`;
+}
+function F(e) {
+  return `${e.storagePrefix}-state`;
+}
+function J(e) {
+  return `${e.storagePrefix}-open`;
+}
+function B(e) {
+  return `${e.storagePrefix}-position`;
+}
+function L(e) {
+  return `${e.storagePrefix}-size`;
+}
+function G(e) {
+  return `${e.storagePrefix}-density`;
+}
+function I(e) {
+  return `${e.storagePrefix}:visible`;
+}
+function U(e) {
+  return `${e.storagePrefix}:autoload`;
+}
+function q(e) {
+  return `${e.storagePrefix}-root`;
+}
+const x = k.storagePrefix, S = "toggle-design-token-panel";
+function Y(e) {
+  return e.storagePrefix === x ? S : e.toggleEvent ?? `toggle-${e.storagePrefix}`;
+}
+const A = "__zdtp:open-state-changed";
+function W(e) {
+  return `${A}:${e.storagePrefix}`;
+}
+function X(e, t) {
+  return `${e.modalClassPrefix}${t}`;
+}
+function Q(e) {
+  return `${e.exportFilenameBase}.json`;
+}
+function Z(e) {
+  if (e === null || typeof e != "object" || Array.isArray(e))
+    throw new Error("[design-token-panel] PanelConfig must be a non-null object");
+  const t = e;
+  for (const r of [
+    "storagePrefix",
+    "consoleNamespace",
+    "modalClassPrefix",
+    "schemaId",
+    "exportFilenameBase"
+  ])
+    if (typeof t[r] != "string" || t[r].length === 0)
+      throw new Error(
+        `[design-token-panel] PanelConfig.${r} must be a non-empty string (got ${typeof t[r]})`
+      );
+  if (v(t.tabs), t.toggleEvent !== void 0 && (typeof t.toggleEvent != "string" || t.toggleEvent.length === 0))
+    throw new Error(
+      `[design-token-panel] PanelConfig.toggleEvent must be a non-empty string when set (got ${typeof t.toggleEvent})`
+    );
+  if (t.applyEndpoint !== void 0 && typeof t.applyEndpoint != "string")
+    throw new Error(
+      `[design-token-panel] PanelConfig.applyEndpoint must be a string when set (got ${typeof t.applyEndpoint})`
+    );
+  if (t.applyRouting !== void 0) {
+    if (t.applyRouting === null || typeof t.applyRouting != "object" || Array.isArray(t.applyRouting))
+      throw new Error("[design-token-panel] PanelConfig.applyRouting must be a plain object");
+    for (const [r, i] of Object.entries(t.applyRouting))
+      if (typeof i != "string")
+        throw new Error(
+          `[design-token-panel] PanelConfig.applyRouting[${JSON.stringify(r)}] must be a string`
+        );
+  }
+  if (t.legacyIdRenameMap !== void 0) {
+    if (t.legacyIdRenameMap === null || typeof t.legacyIdRenameMap != "object" || Array.isArray(t.legacyIdRenameMap))
+      throw new Error("[design-token-panel] PanelConfig.legacyIdRenameMap must be a plain object");
+    for (const [r, i] of Object.entries(t.legacyIdRenameMap))
+      if (i !== null && typeof i != "string")
+        throw new Error(
+          `[design-token-panel] PanelConfig.legacyIdRenameMap[${JSON.stringify(r)}] must be a string or null (got ${typeof i})`
+        );
+  }
+}
+function v(e) {
+  if (!Array.isArray(e))
+    throw new Error("[design-token-panel] PanelConfig.tabs must be an array");
+  const t = /* @__PURE__ */ new Set();
+  for (const r of e) {
+    if (r === null || typeof r != "object" || Array.isArray(r))
+      throw new Error("[design-token-panel] PanelConfig.tabs: each tab must be a non-null object");
+    const i = r;
+    if (typeof i.id != "string" || i.id.length === 0)
+      throw new Error("[design-token-panel] PanelConfig.tabs: each tab must have a non-empty string id");
+    if (t.has(i.id))
+      throw new Error(
+        `[design-token-panel] PanelConfig.tabs: duplicate tab id "${i.id}"`
+      );
+    t.add(i.id), T(i.id, i);
+  }
+}
+function T(e, t) {
+  if (!Array.isArray(t.tiers))
+    throw new Error(
+      `[design-token-panel] PanelConfig.tabs["${e}"].tiers must be an array`
+    );
+  const r = /* @__PURE__ */ new Set(), i = /* @__PURE__ */ new Map();
+  for (const o of t.tiers) {
+    if (o === null || typeof o != "object" || Array.isArray(o))
+      throw new Error(
+        `[design-token-panel] PanelConfig.tabs["${e}"].tiers: each tier must be a non-null object`
+      );
+    const s = o;
+    if (typeof s.id != "string" || s.id.length === 0)
+      throw new Error(
+        `[design-token-panel] PanelConfig.tabs["${e}"].tiers: each tier must have a non-empty string id`
+      );
+    if (r.has(s.id))
+      throw new Error(
+        `[design-token-panel] PanelConfig.tabs["${e}"]: duplicate tier id "${s.id}"`
+      );
+    if (r.add(s.id), !Array.isArray(s.items))
+      throw new Error(
+        `[design-token-panel] PanelConfig.tabs["${e}"].tiers["${s.id}"].items must be an array`
+      );
+    let c;
+    for (const f of s.items) {
+      if (f === null || typeof f != "object" || Array.isArray(f)) continue;
+      const l = f.type;
+      if (l === null || typeof l != "object" || Array.isArray(l)) continue;
+      const a = l.kind;
+      if (typeof a == "string") {
+        if (c === void 0)
+          c = a;
+        else if (c !== a)
+          throw new Error(
+            `[design-token-panel] PanelConfig.tabs["${e}"].tiers["${s.id}"]: mixed item kinds — found "${c}" and "${a}" in the same tier (all items must share the same kind)`
+          );
+      }
+    }
+    c !== void 0 && i.set(s.id, c);
+  }
+  const u = /* @__PURE__ */ new Set();
+  for (const o of t.tiers) {
+    const s = o, c = s.id;
+    for (const f of s.items) {
+      if (f === null || typeof f != "object" || Array.isArray(f))
+        throw new Error(
+          `[design-token-panel] PanelConfig.tabs["${e}"].tiers["${c}"].items: each item must be a non-null object`
+        );
+      const n = f;
+      if (typeof n.id != "string" || n.id.length === 0)
+        throw new Error(
+          `[design-token-panel] PanelConfig.tabs["${e}"].tiers["${c}"].items: each item must have a non-empty string id`
+        );
+      if (u.has(n.id))
+        throw new Error(
+          `[design-token-panel] PanelConfig.tabs["${e}"]: duplicate item id "${n.id}" (item ids must be unique across all tiers within a tab)`
+        );
+      if (u.add(n.id), typeof n.cssVar != "string" || !n.cssVar.startsWith("--"))
+        throw new Error(
+          `[design-token-panel] PanelConfig.tabs["${e}"].tiers["${c}"].items["${n.id}"].cssVar must start with "--" (got ${JSON.stringify(n.cssVar)})`
+        );
+      if (n.cssVar.length <= 2)
+        throw new Error(
+          `[design-token-panel] PanelConfig.tabs["${e}"].tiers["${c}"].items["${n.id}"].cssVar must be non-empty after "--"`
+        );
+    }
+  }
+  for (const o of t.tiers) {
+    const s = o, c = s.id;
+    if (s.referencesTier !== void 0) {
+      if (typeof s.referencesTier != "string")
+        throw new Error(
+          `[design-token-panel] PanelConfig.tabs["${e}"].tiers["${c}"].referencesTier must be a string`
+        );
+      const f = s.referencesTier;
+      if (!r.has(f))
+        throw new Error(
+          `[design-token-panel] PanelConfig.tabs["${e}"].tiers["${c}"].referencesTier: tier "${f}" does not exist in this tab`
+        );
+      const n = i.get(c), l = i.get(f);
+      if (n !== void 0 && l !== void 0 && n !== "text" && n !== l)
+        throw new Error(
+          `[design-token-panel] PanelConfig.tabs["${e}"].tiers["${c}"].referencesTier: referencing tier has kind "${n}" but referenced tier "${f}" has kind "${l}" (cross-kind reference is only allowed when the referencing tier has kind "text")`
+        );
+    }
+  }
+  if (t.colorExtras !== void 0) {
+    const o = t.colorExtras;
+    if (o === null || typeof o != "object" || Array.isArray(o))
+      throw new Error(
+        `[design-token-panel] PanelConfig.tabs["${e}"].colorExtras must be a plain object`
+      );
+    for (const n of ["id", "defaultShikiTheme"])
+      if (typeof o[n] != "string" || o[n].length === 0)
+        throw new Error(
+          `[design-token-panel] PanelConfig.tabs["${e}"].colorExtras.${n} must be a non-empty string (got ${typeof o[n]})`
+        );
+    for (const n of ["colorSchemes", "baseRoles", "baseDefaults"])
+      if (o[n] === void 0 || o[n] === null || typeof o[n] != "object" || Array.isArray(o[n]))
+        throw new Error(
+          `[design-token-panel] PanelConfig.tabs["${e}"].colorExtras.${n} must be a plain object`
+        );
+    if (o.panelSettings === void 0 || o.panelSettings === null || typeof o.panelSettings != "object" || Array.isArray(o.panelSettings))
+      throw new Error(
+        `[design-token-panel] PanelConfig.tabs["${e}"].colorExtras.panelSettings must be a plain object`
+      );
+    const s = o.panelSettings;
+    if (typeof s.colorScheme != "string" || s.colorScheme.length === 0)
+      throw new Error(
+        `[design-token-panel] PanelConfig.tabs["${e}"].colorExtras.panelSettings.colorScheme must be a non-empty string`
+      );
+    if (s.colorMode !== !1) {
+      if (s.colorMode === null || typeof s.colorMode != "object" || Array.isArray(s.colorMode))
+        throw new Error(
+          `[design-token-panel] PanelConfig.tabs["${e}"].colorExtras.panelSettings.colorMode must be false or a plain object`
+        );
+      const n = s.colorMode;
+      for (const l of ["lightScheme", "darkScheme"])
+        if (typeof n[l] != "string" || n[l].length === 0)
+          throw new Error(
+            `[design-token-panel] PanelConfig.tabs["${e}"].colorExtras.panelSettings.colorMode.${l} must be a non-empty string`
+          );
+      if (n.defaultMode !== "light" && n.defaultMode !== "dark")
+        throw new Error(
+          `[design-token-panel] PanelConfig.tabs["${e}"].colorExtras.panelSettings.colorMode.defaultMode must be "light" or "dark" (got ${JSON.stringify(n.defaultMode)})`
+        );
+    }
+    const f = t.tiers.find((n) => {
+      if (n.referencesTier !== void 0) return !1;
+      const l = n.items;
+      if (!Array.isArray(l) || l.length === 0) return !1;
+      const a = l[0];
+      if (a === null || typeof a != "object" || Array.isArray(a)) return !1;
+      const d = a.type;
+      return d === null || typeof d != "object" || Array.isArray(d) ? !1 : d.kind === "color";
+    });
+    if (f) {
+      const n = f.id, l = f.items, a = l[0]?.cssVar;
+      if (a !== void 0) {
+        const d = a.replace(/\d+$/, "{n}");
+        if (d.includes("{n}"))
+          for (let p = 0; p < l.length; p++) {
+            const h = l[p], P = d.replace("{n}", String(p));
+            if (h.cssVar !== P)
+              throw new Error(
+                `[design-token-panel] PanelConfig.tabs["${e}"].tiers["${n}"].items[${p}].cssVar is ${JSON.stringify(h.cssVar)} but expected ${JSON.stringify(P)} — palette item cssVars must share one prefix and be numbered 0..n-1 in tier order (template derived from first item: ${JSON.stringify(d)})`
+              );
+          }
+        else if (l.length > 1)
+          throw new Error(
+            `[design-token-panel] PanelConfig.tabs["${e}"].tiers["${n}"].items[0].cssVar ${JSON.stringify(a)} has no trailing digit — palette item cssVars must share one prefix and be numbered 0..n-1 in tier order (e.g. "--pal-0" … "--pal-15")`
+          );
+      }
+    }
+  }
+}
+function ee(e = C()) {
+  return e.applyRouting ?? {};
+}
+function te(e) {
+  const t = m();
+  if (t === null) {
+    g().pendingColorPresets = e;
+    return;
+  }
+  t.config = { ...t.config, colorPresets: e };
+}
+export {
+  L as A,
+  G as B,
+  S as D,
+  N as _,
+  I as a,
+  z as b,
+  _ as c,
+  D as d,
+  Z as e,
+  J as f,
+  C as g,
+  B as h,
+  F as i,
+  U as j,
+  Q as k,
+  y as l,
+  X as m,
+  K as n,
+  ee as o,
+  b as p,
+  W as q,
+  j as r,
+  te as s,
+  R as t,
+  M as u,
+  Y as v,
+  H as w,
+  O as x,
+  q as y,
+  V as z
+};

package/dist/panel.d.ts

@@ -16,4 +16,3 @@ interface DesignTokenTweakPanelProps {
 }
 export default function DesignTokenTweakPanel({ instanceConfig: instanceConfigProp, }?: DesignTokenTweakPanelProps): import("preact").JSX.Element;
 export type { TweakState } from './state/tweak-state';
-//# sourceMappingURL=panel.d.ts.map

package/dist/server/create-apply-handler.d.ts

@@ -45,4 +45,3 @@ export interface PerFileResult {
  * ```
  */
 export declare function createApplyHandler(options: ApplyHandlerOptions): (req: Request) => Promise<Response>;
-//# sourceMappingURL=create-apply-handler.d.ts.map

package/dist/server/index.d.ts

@@ -21,4 +21,3 @@ export type { ApplyHandlerOptions, PerFileResult } from './create-apply-handler'
 export { serializeFileWrite } from './serialize-write';
 export { CSS_VAR_NAME_RE, isPathSafe, isValidCssVarName, validateAndSanitizeTokens, } from './path-safety';
 export { loadRoutingFromFile, type ApplyRoutingMap } from './load-routing';
-//# sourceMappingURL=index.d.ts.map

package/dist/server/index.js

@@ -1,4 +1,4 @@
-import { C as s, c as i, i as l, a as r, l as t, s as o, v as d } from "../load-routing-XyKgftpe.js";
+import { C as s, c as i, i as l, a as r, l as t, s as o, v as d } from "../load-routing-DtNTKoLW.js";
 export {
   s as CSS_VAR_NAME_RE,
   i as createApplyHandler,

package/dist/server/load-routing.d.ts

@@ -36,4 +36,3 @@ export type ApplyRoutingMap = Record<string, string>;
  * ```
  */
 export declare function loadRoutingFromFile(absPath: string): ApplyRoutingMap;
-//# sourceMappingURL=load-routing.d.ts.map

package/dist/server/path-safety.d.ts

@@ -33,4 +33,3 @@ export declare function validateAndSanitizeTokens(tokens: Record<string, unknown
     sanitized?: Record<string, string>;
     error?: string;
 };
-//# sourceMappingURL=path-safety.d.ts.map

package/dist/server/serialize-write.d.ts

@@ -4,4 +4,3 @@
  * one settles (success or error). Calls for different paths run in parallel.
  */
 export declare function serializeFileWrite<T>(absPath: string, fn: () => Promise<T>): Promise<T>;
-//# sourceMappingURL=serialize-write.d.ts.map

package/dist/state/autoload-state.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Owner-autoload — persisted feature state and feature contract.
+ *
+ * ## Flag semantics
+ *
+ * `${storagePrefix}:autoload` (written as `'1'` when armed, `'0'` or absent
+ * when not) is the owner-mode flag. It means:
+ *   "This browser visited the site as the site owner — autoload the
+ *    design-token panel on every subsequent page visit."
+ *
+ * ## General-visitor vs owner behavior
+ *
+ * - **General visitor** (flag absent or `!== '1'`): the panel bundle is NOT
+ *   eagerly fetched. Gate #1 (`shouldAutoload`) returns false, so no bundle
+ *   request fires on page load. The panel remains entirely invisible.
+ * - **Owner** (flag === `'1'`): Gate #1 fires, the host-adapter fetches the
+ *   bundle eagerly, and Gate #2 (`reapplyFromStorage` in `index.tsx`) mounts
+ *   the Preact shell CLOSED so the element-path inspector is available even
+ *   while the panel UI is hidden.
+ *
+ * ## enableAutoload() / disableAutoload() contract (implemented by S2 #419)
+ *
+ * `enableAutoload()` (console API, wired by S2):
+ *   1. Sets `:autoload = '1'`.
+ *   2. Sets `-elpath-enabled = '1'` once (arms the alt+click inspector).
+ *   3. Loads the panel bundle (if not already loaded).
+ *   4. Mounts the Preact shell CLOSED via `hideInstance`.
+ *
+ * `disableAutoload()` (console API, wired by S2):
+ *   1. Clears `:autoload`.
+ *   2. Clears `:visible`.
+ *   3. Clears `-elpath-enabled`.
+ *   4. Clears the open-state key (`getOpenKey(cfg)` from `state/tweak-state`).
+ *   5. Unmounts the Preact shell.
+ *
+ * ## Auto-remember
+ *
+ * Any action that shows the panel (console `showDesignPanel()`, the header-
+ * button open event, or the `showInstance` path in `index.tsx`) MUST also
+ * write `:autoload = '1'`. Once an owner opens the panel the flag is set so
+ * subsequent page loads reload it automatically. (Wired by S2 / S3.)
+ *
+ * ## Element-path coupling
+ *
+ * `enableAutoload()` arms the element-path inspector by writing
+ * `-elpath-enabled = '1'` once. The user can still turn it off later via the
+ * in-panel toggle. The inspector overlay requires the Preact shell to be
+ * mounted (it runs inside `ElementPathOrchestrator`), so the CLOSED mount
+ * keeps the overlay functional even when the panel UI itself is hidden.
+ *
+ * ## The two gates that must consider autoload
+ *
+ * Gate #1 — host-adapter eager-load gate: the host adapter (e.g.
+ * `astro/host-adapter.ts`) decides whether to FETCH the panel bundle on page
+ * load. It MUST call `shouldAutoload(cfg)` and skip the fetch when the result
+ * is false. This keeps general-visitor page loads entirely free of the bundle
+ * request.
+ *
+ * Gate #2 — `index.tsx reapplyFromStorage`: the existing `reapplyFromStorage`
+ * function mounts the shell CLOSED when `hasPersistedOverrides(cfg)` or
+ * `loadElementPathEnabled()` is true. It MUST also trigger on
+ * `shouldAutoload(cfg)` so an owner-mode page load mounts the Preact shell
+ * (and therefore the element-path inspector) even when no token overrides
+ * are persisted yet.
+ */
+import type { PanelConfig } from '../config/panel-config';
+/**
+ * Return `true` iff this browser has the owner-autoload flag set.
+ *
+ * SSR-safe (returns `false` when `window` is not available) and quota-
+ * tolerant (returns `false` on any storage error). Reads exactly
+ * `${cfg.storagePrefix}:autoload` and matches against the literal string
+ * `'1'`; any other stored value (including `'0'` or an absent key) is `false`.
+ */
+export declare function shouldAutoload(cfg: PanelConfig): boolean;
+/**
+ * Write the owner-autoload flag. Pass `true` to arm autoload (`'1'`), `false`
+ * to disarm (`'0'`). SSR-safe and quota-tolerant — errors are swallowed
+ * silently so this never throws in restricted storage contexts.
+ *
+ * Prefer `clearAutoload` when you want to fully remove the key (e.g. on
+ * `disableAutoload`) rather than leave a `'0'` sentinel.
+ */
+export declare function setAutoload(cfg: PanelConfig, on: boolean): void;
+/**
+ * Remove the owner-autoload flag from storage entirely.
+ *
+ * Called by `disableAutoload()` (S2) as part of the full owner-mode teardown.
+ * SSR-safe and quota-tolerant.
+ */
+export declare function clearAutoload(cfg: PanelConfig): void;

package/dist/state/persist.d.ts

@@ -33,7 +33,6 @@ export declare function usePersist(setState: SetState<TweakState>, cfg?: PanelCo
     persistTypography: (updater: (prev: TokenOverrides) => TokenOverrides) => void;
     persistFont: (updater: (prev: TokenOverrides) => TokenOverrides) => void;
     persistSize: (updater: (prev: TokenOverrides) => TokenOverrides) => void;
-    persistPanelPosition: (updater: (prev: TweakState["panelPosition"]) => TweakState["panelPosition"]) => void;
     persistSecondary: (updater: (prev: ColorTweakState | undefined) => ColorTweakState | undefined) => void;
 };
 export type Persist = ReturnType<typeof usePersist>['persist'];
@@ -44,7 +43,5 @@ export type PersistTypography = ReturnType<typeof usePersist>['persistTypography
 /** Upstream alias for `PersistTypography`. See `persistFont` above. */
 export type PersistFont = PersistTypography;
 export type PersistSize = ReturnType<typeof usePersist>['persistSize'];
-export type PersistPanelPosition = ReturnType<typeof usePersist>['persistPanelPosition'];
 export type PersistSecondary = ReturnType<typeof usePersist>['persistSecondary'];
 export {};
-//# sourceMappingURL=persist.d.ts.map