@aparte/plugin-approval 0.16.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 aparté
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,40 @@
+# @aparte/plugin-approval
+
+Approval **modes** for [aparté](https://github.com/apartejs/aparte) tool calls — `plan`, `ask`, `auto-edit`,
+`auto` — from a classification of your own tool names, with a `<aparte-approval-mode>` switch for the
+composer's toolbar. It decides; it never executes anything and stores nothing.
+
+```bash
+npm install @aparte/plugin-approval @aparte/core
+```
+
+```ts
+import { aparteGlobalConfig } from '@aparte/core';
+import { setupApproval } from '@aparte/plugin-approval';
+
+const approval = setupApproval({
+  classify: {
+    read:  ['read_file', 'search', /^list_/],
+    write: ['write_file', 'edit_file'],
+    exec:  ['run_command'],
+  },
+  mode: 'ask',
+}, aparteGlobalConfig);  // the config last, like every setup*: it defaults to the global
+approval.setMode('plan');   // or let the person switch it:
+```
+
+```html
+<aparte-composer-toolbar>
+  <aparte-approval-mode></aparte-approval-mode>
+</aparte-composer-toolbar>
+```
+
+**The table** — `plan` runs read-only tools and refuses the rest with a sentence the model reads
+(so it describes what it would do instead); `ask` asks before every write or execution, through the
+same composer panel a `needsApproval` tool uses; `auto-edit` lets writes through and asks before an
+execution; `auto` never asks. A tool in no list keeps its own `needsApproval`.
+
+Under the hood it is one core seam: `config.setApprovalPolicy()`, a per-call policy the client's
+approval channel consults before asking. `@aparte/core` is the only **peer dependency**.
+
+> ESM-only. Part of the aparté monorepo.

package/dist/aparte-approval-mode.d.ts

@@ -0,0 +1,52 @@
+/**
+ * `<aparte-approval-mode>` — the switch between the four modes, for the composer's toolbar.
+ *
+ * Mounted where the host wants it, like `<aparte-model-selector>`: the composer is light
+ * DOM with no registry, so a control is placed by writing its tag inside
+ * `<aparte-composer-toolbar>`. It resolves the config it sits in (`resolveConfig`) and the
+ * controller `setupApproval` installed there — with none, it renders disabled and says
+ * so once in the console, the way core does for a missing presenter: an affordance that
+ * cannot act is not offered.
+ */
+import { type AparteConfig, type AparteConfigAware } from '@aparte/core';
+import { type ApprovalMode } from './policy.js';
+/**
+ * A select over the four approval modes — plan, ask, auto-edit, auto — bound to the
+ * `setupApproval()` of the config this element resolves.
+ *
+ * @element aparte-approval-mode
+ *
+ * @example Beside the model selector, in the composer's toolbar
+ * ```html
+ * <aparte-composer>
+ *   <aparte-composer-input></aparte-composer-input>
+ *   <aparte-composer-toolbar>
+ *     <aparte-approval-mode></aparte-approval-mode>
+ *   </aparte-composer-toolbar>
+ * </aparte-composer>
+ * ```
+ *
+ * @fires aparte-approval-mode-change - After a switch: `{ mode, previousMode }`. Bubbles and crosses shadow roots.
+ */
+export declare class AparteApprovalMode extends HTMLElement implements AparteConfigAware {
+    private _cfg;
+    private _controller;
+    private _unsubscribe;
+    private _configUnsubscribe;
+    private _bound;
+    private _labels;
+    private readonly _onChange;
+    /** The label of each mode, for a localised host. Missing entries keep the English default. */
+    get labels(): Partial<Record<ApprovalMode, string>>;
+    set labels(next: Partial<Record<ApprovalMode, string>>);
+    /** The current mode, or `null` with no setup. */
+    get mode(): ApprovalMode | null;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    /** See `AparteConfigAware`: a boundary moved, so the controller may be another one. */
+    aparteConfigChanged(next: AparteConfig): void;
+    private _bind;
+    private _render;
+    private _syncValue;
+}
+//# sourceMappingURL=aparte-approval-mode.d.ts.map

package/dist/aparte-approval-mode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aparte-approval-mode.d.ts","sourceRoot":"","sources":["../src/aparte-approval-mode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAEH,KAAK,YAAY,EAAE,KAAK,iBAAiB,EAE5C,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAkB,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AAShE;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,kBAAmB,SAAQ,WAAY,YAAW,iBAAiB;IAC5E,OAAO,CAAC,IAAI,CAA6B;IACzC,OAAO,CAAC,WAAW,CAAiC;IACpD,OAAO,CAAC,YAAY,CAA6B;IACjD,OAAO,CAAC,kBAAkB,CAA6B;IACvD,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,OAAO,CAA6C;IAC5D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAWxB;IAEF,8FAA8F;IAC9F,IAAI,MAAM,IAAI,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC,CAAyB;IAC5E,IAAI,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC,EAGrD;IAED,iDAAiD;IACjD,IAAI,IAAI,IAAI,YAAY,GAAG,IAAI,CAAgD;IAE/E,iBAAiB,IAAI,IAAI;IASzB,oBAAoB,IAAI,IAAI;IAS5B,uFAAuF;IACvF,mBAAmB,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI;IAI7C,OAAO,CAAC,KAAK;IAgBb,OAAO,CAAC,OAAO;IAef,OAAO,CAAC,UAAU;CAKrB"}

package/dist/approval-B7URDqOS.js

@@ -0,0 +1,79 @@
+import { aparteGlobalConfig } from "@aparte/core";
+const APPROVAL_MODES = ["plan", "ask", "auto-edit", "auto"];
+const matches = (name, m) => typeof m === "string" ? m === name : name.search(m) !== -1;
+function classifyTool(name, classification) {
+  if (classification.exec?.some((m) => matches(name, m))) return "exec";
+  if (classification.write?.some((m) => matches(name, m))) return "write";
+  if (classification.read?.some((m) => matches(name, m))) return "read";
+  return void 0;
+}
+const NOUN = { read: "reads", write: "changes files or state", exec: "runs a command" };
+function rulingFor(mode, cls, call) {
+  if (mode === "auto") return { verdict: "allow" };
+  if (cls === void 0) return void 0;
+  if (cls === "read") return { verdict: "allow" };
+  if (mode === "plan") {
+    return {
+      verdict: "deny",
+      reason: `Plan mode: \`${call.name}\` ${NOUN[cls]}, and only read-only tools run in this mode. Describe what you would do instead; the user can switch the mode to let you do it.`
+    };
+  }
+  if (mode === "auto-edit") return cls === "write" ? { verdict: "allow" } : { verdict: "ask" };
+  return { verdict: "ask" };
+}
+function createApprovalPolicy(getMode, classification) {
+  return (call) => rulingFor(getMode(), classifyTool(call.name, classification), call);
+}
+const controllers = /* @__PURE__ */ new WeakMap();
+const installed = /* @__PURE__ */ new WeakMap();
+const isInstalled = (config) => config.getApprovalPolicy() === installed.get(config);
+function setupApproval(options, config = aparteGlobalConfig) {
+  controllers.get(config)?.dispose();
+  let mode = options.mode ?? "ask";
+  const listeners = /* @__PURE__ */ new Set();
+  if (options.onModeChange) listeners.add(options.onModeChange);
+  const controller = {
+    modes: APPROVAL_MODES,
+    getMode: () => mode,
+    setMode(next) {
+      if (!APPROVAL_MODES.includes(next) || next === mode) return;
+      const previous = mode;
+      mode = next;
+      for (const l of listeners) l(next, previous);
+    },
+    classify: (name) => classifyTool(name, options.classify),
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    dispose() {
+      if (controllers.get(config) === controller) {
+        if (isInstalled(config)) config.setApprovalPolicy(null);
+        controllers.delete(config);
+        installed.delete(config);
+      }
+      listeners.clear();
+    }
+  };
+  const policy = createApprovalPolicy(() => mode, options.classify);
+  controllers.set(config, controller);
+  installed.set(config, policy);
+  config.setApprovalPolicy(policy);
+  return controller;
+}
+function getApprovalController(config = aparteGlobalConfig) {
+  const controller = controllers.get(config);
+  if (!controller) return void 0;
+  return isInstalled(config) ? controller : void 0;
+}
+export {
+  APPROVAL_MODES as A,
+  createApprovalPolicy as a,
+  classifyTool as c,
+  getApprovalController as g,
+  rulingFor as r,
+  setupApproval as s
+};
+//# sourceMappingURL=approval-B7URDqOS.js.map

package/dist/approval-B7URDqOS.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"approval-B7URDqOS.js","sources":["../src/policy.ts","../src/approval.ts"],"sourcesContent":["/**\n * The modes, the classes, and the table that joins them.\n *\n * A MODE is what the person switches (\"plan\", \"auto\"); a CLASS is what a tool does\n * (`read`, `write`, `exec`), declared by the host on ITS tool names — the names are\n * wire format the host owns, and no library can know that `run_command` executes and\n * `search_docs` reads. The table below is the whole policy: nine cells, no\n * configuration, so a consumer can read it in one glance and predict every ruling.\n *\n * Nothing here executes anything, remembers anything, or draws anything: it is a pure\n * function from (mode, class, call) to a ruling core already knows how to honour.\n */\nimport type { AparteApprovalPolicy, AparteApprovalRuling, AparteToolCall } from '@aparte/core';\n\n/**\n * `plan` runs read-only tools and refuses the rest with a sentence the model reads;\n * `ask` asks before every write or execution; `auto-edit` lets writes through and asks\n * before an execution; `auto` never asks.\n */\nexport type ApprovalMode = 'plan' | 'ask' | 'auto-edit' | 'auto';\n\n/** The four modes, in the order a switch presents them. */\nexport const APPROVAL_MODES: readonly ApprovalMode[] = ['plan', 'ask', 'auto-edit', 'auto'];\n\n/** What a tool does — the axis the modes decide on. */\nexport type ToolClass = 'read' | 'write' | 'exec';\n\n/** A tool name, exactly, or a pattern over names. */\nexport type ToolMatcher = string | RegExp;\n\n/**\n * The host's tool names, by what they do. A name in no list is UNCLASSIFIED: its\n * own `needsApproval` decides (and `auto` still lets it through — auto is auto).\n */\nexport interface ApprovalClassification {\n    read?: readonly ToolMatcher[];\n    write?: readonly ToolMatcher[];\n    exec?: readonly ToolMatcher[];\n}\n\n// `search`, not `test`: `test` advances `lastIndex` on a `g` or `y` regex the caller\n// owns, so the same name would classify differently on alternate calls — and the gate\n// predicate and the answering channel evaluate the policy one after the other.\nconst matches = (name: string, m: ToolMatcher): boolean =>\n    typeof m === 'string' ? m === name : name.search(m) !== -1;\n\n/** The class of a tool name under a classification, or `undefined` when it is in no list. */\nexport function classifyTool(name: string, classification: ApprovalClassification): ToolClass | undefined {\n    if (classification.exec?.some((m) => matches(name, m))) return 'exec';\n    if (classification.write?.some((m) => matches(name, m))) return 'write';\n    if (classification.read?.some((m) => matches(name, m))) return 'read';\n    return undefined;\n}\n\nconst NOUN: Record<ToolClass, string> = { read: 'reads', write: 'changes files or state', exec: 'runs a command' };\n\n/**\n * The ruling for one call, from the table. `undefined` means \"no opinion\" — the tool's\n * own `needsApproval` decides, which is what core does when a policy says nothing.\n */\nexport function rulingFor(mode: ApprovalMode, cls: ToolClass | undefined, call: AparteToolCall): AparteApprovalRuling | undefined {\n    if (mode === 'auto') return { verdict: 'allow' };\n    if (cls === undefined) return undefined;\n    if (cls === 'read') return { verdict: 'allow' };\n    if (mode === 'plan') {\n        return {\n            verdict: 'deny',\n            reason: `Plan mode: \\`${call.name}\\` ${NOUN[cls]}, and only read-only tools run in this mode. ` +\n                'Describe what you would do instead; the user can switch the mode to let you do it.',\n        };\n    }\n    if (mode === 'auto-edit') return cls === 'write' ? { verdict: 'allow' } : { verdict: 'ask' };\n    return { verdict: 'ask' };\n}\n\n/**\n * A core `AparteApprovalPolicy` that reads the CURRENT mode on every call — so a\n * switch flipped mid-run applies to the next tool call, not the next conversation.\n */\nexport function createApprovalPolicy(getMode: () => ApprovalMode, classification: ApprovalClassification): AparteApprovalPolicy {\n    return (call) => rulingFor(getMode(), classifyTool(call.name, classification), call);\n}\n","/**\n * `setupApproval` — one call installs a mode-driven approval policy on a config.\n *\n * The plugin owns the MODE (a value the person switches) and the TABLE (policy.ts);\n * core owns the mechanism — `setApprovalPolicy`, the gate, the panel that asks, the\n * refusal the model reads. Nothing is executed here and nothing is stored: a mode\n * survives exactly as long as the page, and a host that wants it remembered reads\n * `getMode()` / `onModeChange` and writes wherever it keeps its preferences.\n */\nimport { aparteGlobalConfig, type AparteConfig, type AparteApprovalPolicy } from '@aparte/core';\nimport {\n    APPROVAL_MODES, createApprovalPolicy, classifyTool,\n    type ApprovalMode, type ApprovalClassification, type ToolClass,\n} from './policy.js';\n\nexport interface ApprovalSetupOptions {\n    /** Your tool names, by what they do. Unlisted names keep their own `needsApproval`. */\n    classify: ApprovalClassification;\n    /** The starting mode. Default: `ask`. */\n    mode?: ApprovalMode;\n    /** Called after every switch, with the new and the previous mode. */\n    onModeChange?: (mode: ApprovalMode, previous: ApprovalMode) => void;\n}\n\n/** What `setupApproval` returns: the mode, readable and switchable, and the way out. */\nexport interface ApprovalController {\n    /** The four modes, in the order a switch presents them. */\n    readonly modes: readonly ApprovalMode[];\n    getMode(): ApprovalMode;\n    /** Switch the mode; the next tool call is ruled under it. Unknown values are ignored. */\n    setMode(mode: ApprovalMode): void;\n    /** The class this setup gives a tool name, or `undefined`. */\n    classify(name: string): ToolClass | undefined;\n    /** Be told of every switch — from `setMode` or from a `<aparte-approval-mode>`. Returns the unsubscribe. */\n    subscribe(listener: (mode: ApprovalMode, previous: ApprovalMode) => void): () => void;\n    /** Remove the policy from the config and forget this controller. */\n    dispose(): void;\n}\n\nconst controllers = new WeakMap<AparteConfig, ApprovalController>();\n// The policy each controller installed, so a controller whose policy is gone — a\n// `config.reset()`, a `setApprovalPolicy(null)` from elsewhere — reads as no setup\n// rather than as a switch wired to nothing.\nconst installed = new WeakMap<AparteConfig, AparteApprovalPolicy>();\n/** Whether the policy on `config` is still the one this module installed there. */\nconst isInstalled = (config: AparteConfig): boolean =>\n    config.getApprovalPolicy() === installed.get(config);\n\n/**\n * Install the policy on `config` (the global one by default) and return its controller.\n *\n * Calling it twice on one config replaces the first setup — its policy is removed and\n * its listeners dropped — so a hot-reloading host does not stack policies.\n *\n * @example\n * ```ts\n * import { setupApproval } from '@aparte/plugin-approval';\n *\n * const approval = setupApproval({\n *   classify: {\n *     read:  ['read_file', 'search', /^list_/],\n *     write: ['write_file', 'edit_file'],\n *     exec:  ['run_command'],\n *   },\n *   mode: 'ask',\n * });                          // the config last, like every setup*: it defaults to the global\n * approval.setMode('plan');   // or drop <aparte-approval-mode> in the composer's toolbar\n * ```\n */\nexport function setupApproval(options: ApprovalSetupOptions, config: AparteConfig = aparteGlobalConfig): ApprovalController {\n    controllers.get(config)?.dispose();\n\n    let mode: ApprovalMode = options.mode ?? 'ask';\n    const listeners = new Set<(mode: ApprovalMode, previous: ApprovalMode) => void>();\n    if (options.onModeChange) listeners.add(options.onModeChange);\n\n    const controller: ApprovalController = {\n        modes: APPROVAL_MODES,\n        getMode: () => mode,\n        setMode(next) {\n            if (!APPROVAL_MODES.includes(next) || next === mode) return;\n            const previous = mode;\n            mode = next;\n            for (const l of listeners) l(next, previous);\n        },\n        classify: (name) => classifyTool(name, options.classify),\n        subscribe(listener) {\n            listeners.add(listener);\n            return () => { listeners.delete(listener); };\n        },\n        dispose() {\n            if (controllers.get(config) === controller) {\n                // Only the policy this setup installed: a config whose policy was since\n                // replaced by someone else keeps that replacement.\n                if (isInstalled(config)) config.setApprovalPolicy(null);\n                controllers.delete(config);\n                installed.delete(config);\n            }\n            listeners.clear();\n        },\n    };\n\n    const policy = createApprovalPolicy(() => mode, options.classify);\n    // Bookkeeping BEFORE the config is told: `setApprovalPolicy` notifies, and a mounted\n    // switch re-resolves its controller on that notify — it must find this one.\n    controllers.set(config, controller);\n    installed.set(config, policy);\n    config.setApprovalPolicy(policy);\n    return controller;\n}\n\n/**\n * The controller `setupApproval` installed on a config, or `undefined` — also when\n * its policy has since been removed from the config (a `reset()`, a\n * `setApprovalPolicy(null)`): a switch must not look wired to a policy that is gone.\n * What a `<aparte-approval-mode>` element resolves through the config it sits in.\n */\nexport function getApprovalController(config: AparteConfig = aparteGlobalConfig): ApprovalController | undefined {\n    const controller = controllers.get(config);\n    if (!controller) return undefined;\n    return isInstalled(config) ? controller : undefined;\n}\n"],"names":[],"mappings":";AAsBO,MAAM,iBAA0C,CAAC,QAAQ,OAAO,aAAa,MAAM;AAqB1F,MAAM,UAAU,CAAC,MAAc,MAC3B,OAAO,MAAM,WAAW,MAAM,OAAO,KAAK,OAAO,CAAC,MAAM;AAGrD,SAAS,aAAa,MAAc,gBAA+D;AACtG,MAAI,eAAe,MAAM,KAAK,CAAC,MAAM,QAAQ,MAAM,CAAC,CAAC,EAAG,QAAO;AAC/D,MAAI,eAAe,OAAO,KAAK,CAAC,MAAM,QAAQ,MAAM,CAAC,CAAC,EAAG,QAAO;AAChE,MAAI,eAAe,MAAM,KAAK,CAAC,MAAM,QAAQ,MAAM,CAAC,CAAC,EAAG,QAAO;AAC/D,SAAO;AACX;AAEA,MAAM,OAAkC,EAAE,MAAM,SAAS,OAAO,0BAA0B,MAAM,iBAAA;AAMzF,SAAS,UAAU,MAAoB,KAA4B,MAAwD;AAC9H,MAAI,SAAS,OAAQ,QAAO,EAAE,SAAS,QAAA;AACvC,MAAI,QAAQ,OAAW,QAAO;AAC9B,MAAI,QAAQ,OAAQ,QAAO,EAAE,SAAS,QAAA;AACtC,MAAI,SAAS,QAAQ;AACjB,WAAO;AAAA,MACH,SAAS;AAAA,MACT,QAAQ,gBAAgB,KAAK,IAAI,MAAM,KAAK,GAAG,CAAC;AAAA,IAAA;AAAA,EAGxD;AACA,MAAI,SAAS,YAAa,QAAO,QAAQ,UAAU,EAAE,SAAS,QAAA,IAAY,EAAE,SAAS,MAAA;AACrF,SAAO,EAAE,SAAS,MAAA;AACtB;AAMO,SAAS,qBAAqB,SAA6B,gBAA8D;AAC5H,SAAO,CAAC,SAAS,UAAU,QAAA,GAAW,aAAa,KAAK,MAAM,cAAc,GAAG,IAAI;AACvF;AC1CA,MAAM,kCAAkB,QAAA;AAIxB,MAAM,gCAAgB,QAAA;AAEtB,MAAM,cAAc,CAAC,WACjB,OAAO,wBAAwB,UAAU,IAAI,MAAM;AAuBhD,SAAS,cAAc,SAA+B,SAAuB,oBAAwC;AACxH,cAAY,IAAI,MAAM,GAAG,QAAA;AAEzB,MAAI,OAAqB,QAAQ,QAAQ;AACzC,QAAM,gCAAgB,IAAA;AACtB,MAAI,QAAQ,aAAc,WAAU,IAAI,QAAQ,YAAY;AAE5D,QAAM,aAAiC;AAAA,IACnC,OAAO;AAAA,IACP,SAAS,MAAM;AAAA,IACf,QAAQ,MAAM;AACV,UAAI,CAAC,eAAe,SAAS,IAAI,KAAK,SAAS,KAAM;AACrD,YAAM,WAAW;AACjB,aAAO;AACP,iBAAW,KAAK,UAAW,GAAE,MAAM,QAAQ;AAAA,IAC/C;AAAA,IACA,UAAU,CAAC,SAAS,aAAa,MAAM,QAAQ,QAAQ;AAAA,IACvD,UAAU,UAAU;AAChB,gBAAU,IAAI,QAAQ;AACtB,aAAO,MAAM;AAAE,kBAAU,OAAO,QAAQ;AAAA,MAAG;AAAA,IAC/C;AAAA,IACA,UAAU;AACN,UAAI,YAAY,IAAI,MAAM,MAAM,YAAY;AAGxC,YAAI,YAAY,MAAM,EAAG,QAAO,kBAAkB,IAAI;AACtD,oBAAY,OAAO,MAAM;AACzB,kBAAU,OAAO,MAAM;AAAA,MAC3B;AACA,gBAAU,MAAA;AAAA,IACd;AAAA,EAAA;AAGJ,QAAM,SAAS,qBAAqB,MAAM,MAAM,QAAQ,QAAQ;AAGhE,cAAY,IAAI,QAAQ,UAAU;AAClC,YAAU,IAAI,QAAQ,MAAM;AAC5B,SAAO,kBAAkB,MAAM;AAC/B,SAAO;AACX;AAQO,SAAS,sBAAsB,SAAuB,oBAAoD;AAC7G,QAAM,aAAa,YAAY,IAAI,MAAM;AACzC,MAAI,CAAC,WAAY,QAAO;AACxB,SAAO,YAAY,MAAM,IAAI,aAAa;AAC9C;"}

package/dist/approval.d.ts

@@ -0,0 +1,63 @@
+/**
+ * `setupApproval` — one call installs a mode-driven approval policy on a config.
+ *
+ * The plugin owns the MODE (a value the person switches) and the TABLE (policy.ts);
+ * core owns the mechanism — `setApprovalPolicy`, the gate, the panel that asks, the
+ * refusal the model reads. Nothing is executed here and nothing is stored: a mode
+ * survives exactly as long as the page, and a host that wants it remembered reads
+ * `getMode()` / `onModeChange` and writes wherever it keeps its preferences.
+ */
+import { type AparteConfig } from '@aparte/core';
+import { type ApprovalMode, type ApprovalClassification, type ToolClass } from './policy.js';
+export interface ApprovalSetupOptions {
+    /** Your tool names, by what they do. Unlisted names keep their own `needsApproval`. */
+    classify: ApprovalClassification;
+    /** The starting mode. Default: `ask`. */
+    mode?: ApprovalMode;
+    /** Called after every switch, with the new and the previous mode. */
+    onModeChange?: (mode: ApprovalMode, previous: ApprovalMode) => void;
+}
+/** What `setupApproval` returns: the mode, readable and switchable, and the way out. */
+export interface ApprovalController {
+    /** The four modes, in the order a switch presents them. */
+    readonly modes: readonly ApprovalMode[];
+    getMode(): ApprovalMode;
+    /** Switch the mode; the next tool call is ruled under it. Unknown values are ignored. */
+    setMode(mode: ApprovalMode): void;
+    /** The class this setup gives a tool name, or `undefined`. */
+    classify(name: string): ToolClass | undefined;
+    /** Be told of every switch — from `setMode` or from a `<aparte-approval-mode>`. Returns the unsubscribe. */
+    subscribe(listener: (mode: ApprovalMode, previous: ApprovalMode) => void): () => void;
+    /** Remove the policy from the config and forget this controller. */
+    dispose(): void;
+}
+/**
+ * Install the policy on `config` (the global one by default) and return its controller.
+ *
+ * Calling it twice on one config replaces the first setup — its policy is removed and
+ * its listeners dropped — so a hot-reloading host does not stack policies.
+ *
+ * @example
+ * ```ts
+ * import { setupApproval } from '@aparte/plugin-approval';
+ *
+ * const approval = setupApproval({
+ *   classify: {
+ *     read:  ['read_file', 'search', /^list_/],
+ *     write: ['write_file', 'edit_file'],
+ *     exec:  ['run_command'],
+ *   },
+ *   mode: 'ask',
+ * });                          // the config last, like every setup*: it defaults to the global
+ * approval.setMode('plan');   // or drop <aparte-approval-mode> in the composer's toolbar
+ * ```
+ */
+export declare function setupApproval(options: ApprovalSetupOptions, config?: AparteConfig): ApprovalController;
+/**
+ * The controller `setupApproval` installed on a config, or `undefined` — also when
+ * its policy has since been removed from the config (a `reset()`, a
+ * `setApprovalPolicy(null)`): a switch must not look wired to a policy that is gone.
+ * What a `<aparte-approval-mode>` element resolves through the config it sits in.
+ */
+export declare function getApprovalController(config?: AparteConfig): ApprovalController | undefined;
+//# sourceMappingURL=approval.d.ts.map

package/dist/approval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"approval.d.ts","sourceRoot":"","sources":["../src/approval.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAsB,KAAK,YAAY,EAA6B,MAAM,cAAc,CAAC;AAChG,OAAO,EAEH,KAAK,YAAY,EAAE,KAAK,sBAAsB,EAAE,KAAK,SAAS,EACjE,MAAM,aAAa,CAAC;AAErB,MAAM,WAAW,oBAAoB;IACjC,uFAAuF;IACvF,QAAQ,EAAE,sBAAsB,CAAC;IACjC,yCAAyC;IACzC,IAAI,CAAC,EAAE,YAAY,CAAC;IACpB,qEAAqE;IACrE,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,YAAY,EAAE,QAAQ,EAAE,YAAY,KAAK,IAAI,CAAC;CACvE;AAED,wFAAwF;AACxF,MAAM,WAAW,kBAAkB;IAC/B,2DAA2D;IAC3D,QAAQ,CAAC,KAAK,EAAE,SAAS,YAAY,EAAE,CAAC;IACxC,OAAO,IAAI,YAAY,CAAC;IACxB,yFAAyF;IACzF,OAAO,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,CAAC;IAClC,8DAA8D;IAC9D,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAAC;IAC9C,4GAA4G;IAC5G,SAAS,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,YAAY,EAAE,QAAQ,EAAE,YAAY,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;IACtF,oEAAoE;IACpE,OAAO,IAAI,IAAI,CAAC;CACnB;AAWD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,oBAAoB,EAAE,MAAM,GAAE,YAAiC,GAAG,kBAAkB,CAwC1H;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,GAAE,YAAiC,GAAG,kBAAkB,GAAG,SAAS,CAI/G"}

package/dist/custom-elements.json

@@ -0,0 +1,664 @@
+{
+  "schemaVersion": "1.0.0",
+  "readme": "",
+  "modules": [
+    {
+      "kind": "javascript-module",
+      "path": "src/aparte-approval-mode.ts",
+      "declarations": [
+        {
+          "kind": "class",
+          "description": "A select over the four approval modes — plan, ask, auto-edit, auto — bound to the\n`setupApproval()` of the config this element resolves.",
+          "name": "AparteApprovalMode",
+          "members": [
+            {
+              "kind": "field",
+              "name": "_cfg",
+              "type": {
+                "text": "AparteConfig | null"
+              },
+              "privacy": "private",
+              "default": "null"
+            },
+            {
+              "kind": "field",
+              "name": "_controller",
+              "type": {
+                "text": "ApprovalController | undefined"
+              },
+              "privacy": "private"
+            },
+            {
+              "kind": "field",
+              "name": "_unsubscribe",
+              "type": {
+                "text": "(() => void) | null"
+              },
+              "privacy": "private",
+              "default": "null"
+            },
+            {
+              "kind": "field",
+              "name": "_configUnsubscribe",
+              "type": {
+                "text": "(() => void) | null"
+              },
+              "privacy": "private",
+              "default": "null"
+            },
+            {
+              "kind": "field",
+              "name": "_bound",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false"
+            },
+            {
+              "kind": "field",
+              "name": "_labels",
+              "type": {
+                "text": "Partial<Record<ApprovalMode, string>>"
+              },
+              "privacy": "private",
+              "default": "{}"
+            },
+            {
+              "kind": "field",
+              "name": "_onChange",
+              "privacy": "private",
+              "readonly": true
+            },
+            {
+              "kind": "field",
+              "name": "labels",
+              "type": {
+                "text": "Partial<Record<ApprovalMode, string>>"
+              },
+              "description": "The label of each mode, for a localised host. Missing entries keep the English default."
+            },
+            {
+              "kind": "field",
+              "name": "mode",
+              "type": {
+                "text": "ApprovalMode | null"
+              },
+              "description": "The current mode, or `null` with no setup.",
+              "readonly": true
+            },
+            {
+              "kind": "method",
+              "name": "aparteConfigChanged",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "next",
+                  "type": {
+                    "text": "AparteConfig"
+                  }
+                }
+              ],
+              "description": "See `AparteConfigAware`: a boundary moved, so the controller may be another one."
+            },
+            {
+              "kind": "method",
+              "name": "_bind",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "cfg",
+                  "type": {
+                    "text": "AparteConfig"
+                  }
+                }
+              ]
+            },
+            {
+              "kind": "method",
+              "name": "_render",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              }
+            },
+            {
+              "kind": "method",
+              "name": "_syncValue",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              }
+            }
+          ],
+          "events": [
+            {
+              "description": "After a switch: `{ mode, previousMode }`. Bubbles and crosses shadow roots.",
+              "name": "aparte-approval-mode-change"
+            }
+          ],
+          "superclass": {
+            "name": "HTMLElement"
+          },
+          "tagName": "aparte-approval-mode",
+          "customElement": true,
+          "examples": [
+            "Beside the model selector, in the composer's toolbar\n```html\n<aparte-composer>\n<aparte-composer-input></aparte-composer-input>\n<aparte-composer-toolbar>\n<aparte-approval-mode></aparte-approval-mode>\n</aparte-composer-toolbar>\n</aparte-composer>\n```"
+          ]
+        }
+      ],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "AparteApprovalMode",
+          "declaration": {
+            "name": "AparteApprovalMode",
+            "module": "src/aparte-approval-mode.ts"
+          }
+        },
+        {
+          "kind": "custom-element-definition",
+          "name": "aparte-approval-mode",
+          "declaration": {
+            "name": "AparteApprovalMode",
+            "module": "src/aparte-approval-mode.ts"
+          }
+        }
+      ]
+    },
+    {
+      "kind": "javascript-module",
+      "path": "src/approval.ts",
+      "declarations": [
+        {
+          "kind": "function",
+          "name": "setupApproval",
+          "return": {
+            "type": {
+              "text": "ApprovalController"
+            }
+          },
+          "parameters": [
+            {
+              "name": "options",
+              "type": {
+                "text": "ApprovalSetupOptions"
+              }
+            },
+            {
+              "name": "config",
+              "default": "aparteGlobalConfig",
+              "type": {
+                "text": "AparteConfig"
+              }
+            }
+          ],
+          "description": "Install the policy on `config` (the global one by default) and return its controller.\n\nCalling it twice on one config replaces the first setup — its policy is removed and\nits listeners dropped — so a hot-reloading host does not stack policies."
+        },
+        {
+          "kind": "function",
+          "name": "getApprovalController",
+          "return": {
+            "type": {
+              "text": "ApprovalController | undefined"
+            }
+          },
+          "parameters": [
+            {
+              "name": "config",
+              "default": "aparteGlobalConfig",
+              "type": {
+                "text": "AparteConfig"
+              }
+            }
+          ],
+          "description": "The controller `setupApproval` installed on a config, or `undefined` — also when\nits policy has since been removed from the config (a `reset()`, a\n`setApprovalPolicy(null)`): a switch must not look wired to a policy that is gone.\nWhat a `<aparte-approval-mode>` element resolves through the config it sits in."
+        }
+      ],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "setupApproval",
+          "declaration": {
+            "name": "setupApproval",
+            "module": "src/approval.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "getApprovalController",
+          "declaration": {
+            "name": "getApprovalController",
+            "module": "src/approval.ts"
+          }
+        }
+      ]
+    },
+    {
+      "kind": "javascript-module",
+      "path": "src/index.node.ts",
+      "declarations": [],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "setupApproval",
+          "declaration": {
+            "name": "setupApproval",
+            "module": "./approval.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "getApprovalController",
+          "declaration": {
+            "name": "getApprovalController",
+            "module": "./approval.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "ApprovalSetupOptions",
+          "declaration": {
+            "name": "ApprovalSetupOptions",
+            "module": "./approval.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "ApprovalController",
+          "declaration": {
+            "name": "ApprovalController",
+            "module": "./approval.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "APPROVAL_MODES",
+          "declaration": {
+            "name": "APPROVAL_MODES",
+            "module": "./policy.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "classifyTool",
+          "declaration": {
+            "name": "classifyTool",
+            "module": "./policy.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "rulingFor",
+          "declaration": {
+            "name": "rulingFor",
+            "module": "./policy.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "createApprovalPolicy",
+          "declaration": {
+            "name": "createApprovalPolicy",
+            "module": "./policy.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "ApprovalMode",
+          "declaration": {
+            "name": "ApprovalMode",
+            "module": "./policy.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "ToolClass",
+          "declaration": {
+            "name": "ToolClass",
+            "module": "./policy.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "ToolMatcher",
+          "declaration": {
+            "name": "ToolMatcher",
+            "module": "./policy.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "ApprovalClassification",
+          "declaration": {
+            "name": "ApprovalClassification",
+            "module": "./policy.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "AparteApprovalMode",
+          "declaration": {
+            "name": "AparteApprovalMode",
+            "module": "./aparte-approval-mode.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "AparteApprovalPolicy",
+          "declaration": {
+            "name": "AparteApprovalPolicy",
+            "package": "@aparte/core"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "AparteApprovalRuling",
+          "declaration": {
+            "name": "AparteApprovalRuling",
+            "package": "@aparte/core"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "AparteToolCall",
+          "declaration": {
+            "name": "AparteToolCall",
+            "package": "@aparte/core"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "AparteApprovalModeChangeEventDetail",
+          "declaration": {
+            "name": "AparteApprovalModeChangeEventDetail",
+            "package": "@aparte/core"
+          }
+        }
+      ]
+    },
+    {
+      "kind": "javascript-module",
+      "path": "src/index.ts",
+      "declarations": [],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "setupApproval",
+          "declaration": {
+            "name": "setupApproval",
+            "module": "./approval.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "getApprovalController",
+          "declaration": {
+            "name": "getApprovalController",
+            "module": "./approval.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "ApprovalSetupOptions",
+          "declaration": {
+            "name": "ApprovalSetupOptions",
+            "module": "./approval.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "ApprovalController",
+          "declaration": {
+            "name": "ApprovalController",
+            "module": "./approval.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "APPROVAL_MODES",
+          "declaration": {
+            "name": "APPROVAL_MODES",
+            "module": "./policy.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "classifyTool",
+          "declaration": {
+            "name": "classifyTool",
+            "module": "./policy.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "rulingFor",
+          "declaration": {
+            "name": "rulingFor",
+            "module": "./policy.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "createApprovalPolicy",
+          "declaration": {
+            "name": "createApprovalPolicy",
+            "module": "./policy.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "ApprovalMode",
+          "declaration": {
+            "name": "ApprovalMode",
+            "module": "./policy.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "ToolClass",
+          "declaration": {
+            "name": "ToolClass",
+            "module": "./policy.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "ToolMatcher",
+          "declaration": {
+            "name": "ToolMatcher",
+            "module": "./policy.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "ApprovalClassification",
+          "declaration": {
+            "name": "ApprovalClassification",
+            "module": "./policy.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "AparteApprovalMode",
+          "declaration": {
+            "name": "AparteApprovalMode",
+            "module": "./aparte-approval-mode.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "AparteApprovalPolicy",
+          "declaration": {
+            "name": "AparteApprovalPolicy",
+            "package": "@aparte/core"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "AparteApprovalRuling",
+          "declaration": {
+            "name": "AparteApprovalRuling",
+            "package": "@aparte/core"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "AparteToolCall",
+          "declaration": {
+            "name": "AparteToolCall",
+            "package": "@aparte/core"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "AparteApprovalModeChangeEventDetail",
+          "declaration": {
+            "name": "AparteApprovalModeChangeEventDetail",
+            "package": "@aparte/core"
+          }
+        }
+      ]
+    },
+    {
+      "kind": "javascript-module",
+      "path": "src/policy.ts",
+      "declarations": [
+        {
+          "kind": "variable",
+          "name": "APPROVAL_MODES",
+          "type": {
+            "text": "readonly ApprovalMode[]"
+          },
+          "default": "['plan', 'ask', 'auto-edit', 'auto']",
+          "description": "The four modes, in the order a switch presents them."
+        },
+        {
+          "kind": "function",
+          "name": "classifyTool",
+          "return": {
+            "type": {
+              "text": "ToolClass | undefined"
+            }
+          },
+          "parameters": [
+            {
+              "name": "name",
+              "type": {
+                "text": "string"
+              }
+            },
+            {
+              "name": "classification",
+              "type": {
+                "text": "ApprovalClassification"
+              }
+            }
+          ],
+          "description": "The class of a tool name under a classification, or `undefined` when it is in no list."
+        },
+        {
+          "kind": "function",
+          "name": "rulingFor",
+          "return": {
+            "type": {
+              "text": "AparteApprovalRuling | undefined"
+            }
+          },
+          "parameters": [
+            {
+              "name": "mode",
+              "type": {
+                "text": "ApprovalMode"
+              }
+            },
+            {
+              "name": "cls",
+              "type": {
+                "text": "ToolClass | undefined"
+              }
+            },
+            {
+              "name": "call",
+              "type": {
+                "text": "AparteToolCall"
+              }
+            }
+          ],
+          "description": "The ruling for one call, from the table. `undefined` means \"no opinion\" — the tool's\nown `needsApproval` decides, which is what core does when a policy says nothing."
+        },
+        {
+          "kind": "function",
+          "name": "createApprovalPolicy",
+          "return": {
+            "type": {
+              "text": "AparteApprovalPolicy"
+            }
+          },
+          "parameters": [
+            {
+              "name": "getMode",
+              "type": {
+                "text": "() => ApprovalMode"
+              }
+            },
+            {
+              "name": "classification",
+              "type": {
+                "text": "ApprovalClassification"
+              }
+            }
+          ],
+          "description": "A core `AparteApprovalPolicy` that reads the CURRENT mode on every call — so a\nswitch flipped mid-run applies to the next tool call, not the next conversation."
+        }
+      ],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "APPROVAL_MODES",
+          "declaration": {
+            "name": "APPROVAL_MODES",
+            "module": "src/policy.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "classifyTool",
+          "declaration": {
+            "name": "classifyTool",
+            "module": "src/policy.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "rulingFor",
+          "declaration": {
+            "name": "rulingFor",
+            "module": "src/policy.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "createApprovalPolicy",
+          "declaration": {
+            "name": "createApprovalPolicy",
+            "module": "src/policy.ts"
+          }
+        }
+      ]
+    }
+  ]
+}

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * `@aparte/plugin-approval` — approval MODES for tool calls: plan, ask, auto-edit, auto.
+ *
+ * Core owns the mechanism (a per-call approval policy on the config, the gate in the
+ * loop, the panel that asks at the composer, the refusal the model reads); the product
+ * owns the policy — which of ITS tool names read, write or execute — and this plugin is
+ * the small piece between them: a classification, a switchable mode, a nine-cell table,
+ * and a `<aparte-approval-mode>` select for the composer's toolbar. It executes
+ * nothing and stores nothing.
+ */
+export { setupApproval, getApprovalController } from './approval.js';
+export type { ApprovalSetupOptions, ApprovalController } from './approval.js';
+export { APPROVAL_MODES, classifyTool, rulingFor, createApprovalPolicy } from './policy.js';
+export type { ApprovalMode, ToolClass, ToolMatcher, ApprovalClassification } from './policy.js';
+export { AparteApprovalMode } from './aparte-approval-mode.js';
+export type { AparteApprovalPolicy, AparteApprovalRuling, AparteToolCall, AparteApprovalModeChangeEventDetail, } from '@aparte/core';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AACrE,YAAY,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAC9E,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,SAAS,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAC5F,YAAY,EAAE,YAAY,EAAE,SAAS,EAAE,WAAW,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAChG,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAC/D,YAAY,EACR,oBAAoB,EAAE,oBAAoB,EAAE,cAAc,EAAE,mCAAmC,GAClG,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,99 @@
+import { A as APPROVAL_MODES, g as getApprovalController } from "./approval-B7URDqOS.js";
+import { c, a, r, s } from "./approval-B7URDqOS.js";
+import { resolveConfig, subscribeConfigChange, escapeAttr, escapeHtml } from "@aparte/core";
+const DEFAULT_LABELS = {
+  plan: "Plan",
+  ask: "Ask",
+  "auto-edit": "Auto-edit",
+  auto: "Auto"
+};
+class AparteApprovalMode extends HTMLElement {
+  _cfg = null;
+  _controller;
+  _unsubscribe = null;
+  _configUnsubscribe = null;
+  _bound = false;
+  _labels = {};
+  _onChange = (e) => {
+    const detail = e.detail;
+    const next = detail?.value;
+    if (!this._controller || !APPROVAL_MODES.includes(next)) return;
+    const previous = this._controller.getMode();
+    this._controller.setMode(next);
+    if (this._controller.getMode() !== previous) {
+      this.dispatchEvent(new CustomEvent("aparte-approval-mode-change", {
+        bubbles: true,
+        composed: true,
+        detail: { mode: next, previousMode: previous }
+      }));
+    }
+  };
+  /** The label of each mode, for a localised host. Missing entries keep the English default. */
+  get labels() {
+    return this._labels;
+  }
+  set labels(next) {
+    this._labels = next ?? {};
+    if (this.isConnected) this._render();
+  }
+  /** The current mode, or `null` with no setup. */
+  get mode() {
+    return this._controller?.getMode() ?? null;
+  }
+  connectedCallback() {
+    this._bind(resolveConfig(this));
+    this._configUnsubscribe = subscribeConfigChange(this, () => this._bind(resolveConfig(this)));
+  }
+  disconnectedCallback() {
+    this._unsubscribe?.();
+    this._unsubscribe = null;
+    this._configUnsubscribe?.();
+    this._configUnsubscribe = null;
+    this._bound = false;
+    this.querySelector("aparte-select")?.removeEventListener("aparte-select-change", this._onChange);
+  }
+  /** See `AparteConfigAware`: a boundary moved, so the controller may be another one. */
+  aparteConfigChanged(next) {
+    this._bind(next);
+  }
+  _bind(cfg) {
+    const next = getApprovalController(cfg);
+    if (this._bound && cfg === this._cfg && next === this._controller) return;
+    this._bound = true;
+    this._cfg = cfg;
+    this._unsubscribe?.();
+    this._controller = next;
+    if (!this._controller) {
+      console.warn("[aparte] <aparte-approval-mode> found no approval setup on the config it resolves — call setupApproval() from @aparte/plugin-approval on that config (the scoped one if you passed a `config`, aparteGlobalConfig otherwise).");
+    }
+    this._unsubscribe = this._controller?.subscribe(() => this._syncValue()) ?? null;
+    this._render();
+  }
+  _render() {
+    const controller = this._controller;
+    const current = controller?.getMode();
+    const options = APPROVAL_MODES.map((m) => `<aparte-option value="${escapeAttr(m)}">${escapeHtml(this._labels[m] ?? DEFAULT_LABELS[m])}</aparte-option>`).join("");
+    this.querySelector("aparte-select")?.removeEventListener("aparte-select-change", this._onChange);
+    const aria = String(this._cfg?.getLocale()["approvalModeLabel"] || "Approval mode");
+    this.innerHTML = `<aparte-select${current ? ` value="${escapeAttr(current)}"` : ""}${controller ? "" : " disabled"} aria-label="${escapeAttr(aria)}">${options}</aparte-select>`;
+    this.querySelector("aparte-select")?.addEventListener("aparte-select-change", this._onChange);
+  }
+  _syncValue() {
+    const select = this.querySelector("aparte-select");
+    const mode = this._controller?.getMode();
+    if (select && mode && select.value !== mode) select.value = mode;
+  }
+}
+if (typeof customElements !== "undefined" && !customElements.get("aparte-approval-mode")) {
+  customElements.define("aparte-approval-mode", AparteApprovalMode);
+}
+export {
+  APPROVAL_MODES,
+  AparteApprovalMode,
+  c as classifyTool,
+  a as createApprovalPolicy,
+  getApprovalController,
+  r as rulingFor,
+  s as setupApproval
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../src/aparte-approval-mode.ts"],"sourcesContent":["/**\n * `<aparte-approval-mode>` — the switch between the four modes, for the composer's toolbar.\n *\n * Mounted where the host wants it, like `<aparte-model-selector>`: the composer is light\n * DOM with no registry, so a control is placed by writing its tag inside\n * `<aparte-composer-toolbar>`. It resolves the config it sits in (`resolveConfig`) and the\n * controller `setupApproval` installed there — with none, it renders disabled and says\n * so once in the console, the way core does for a missing presenter: an affordance that\n * cannot act is not offered.\n */\nimport {\n    resolveConfig, subscribeConfigChange, escapeHtml, escapeAttr,\n    type AparteConfig, type AparteConfigAware, type AparteSelectChangeDetail,\n    type AparteApprovalModeChangeEventDetail,\n} from '@aparte/core';\nimport { getApprovalController, type ApprovalController } from './approval.js';\nimport { APPROVAL_MODES, type ApprovalMode } from './policy.js';\n\nconst DEFAULT_LABELS: Record<ApprovalMode, string> = {\n    plan: 'Plan',\n    ask: 'Ask',\n    'auto-edit': 'Auto-edit',\n    auto: 'Auto',\n};\n\n/**\n * A select over the four approval modes — plan, ask, auto-edit, auto — bound to the\n * `setupApproval()` of the config this element resolves.\n *\n * @element aparte-approval-mode\n *\n * @example Beside the model selector, in the composer's toolbar\n * ```html\n * <aparte-composer>\n *   <aparte-composer-input></aparte-composer-input>\n *   <aparte-composer-toolbar>\n *     <aparte-approval-mode></aparte-approval-mode>\n *   </aparte-composer-toolbar>\n * </aparte-composer>\n * ```\n *\n * @fires aparte-approval-mode-change - After a switch: `{ mode, previousMode }`. Bubbles and crosses shadow roots.\n */\nexport class AparteApprovalMode extends HTMLElement implements AparteConfigAware {\n    private _cfg: AparteConfig | null = null;\n    private _controller: ApprovalController | undefined;\n    private _unsubscribe: (() => void) | null = null;\n    private _configUnsubscribe: (() => void) | null = null;\n    private _bound = false;\n    private _labels: Partial<Record<ApprovalMode, string>> = {};\n    private readonly _onChange = (e: Event): void => {\n        const detail = (e as CustomEvent<AparteSelectChangeDetail>).detail;\n        const next = detail?.value as ApprovalMode;\n        if (!this._controller || !APPROVAL_MODES.includes(next)) return;\n        const previous = this._controller.getMode();\n        this._controller.setMode(next);\n        if (this._controller.getMode() !== previous) {\n            this.dispatchEvent(new CustomEvent<AparteApprovalModeChangeEventDetail>('aparte-approval-mode-change', {\n                bubbles: true, composed: true, detail: { mode: next, previousMode: previous },\n            }));\n        }\n    };\n\n    /** The label of each mode, for a localised host. Missing entries keep the English default. */\n    get labels(): Partial<Record<ApprovalMode, string>> { return this._labels; }\n    set labels(next: Partial<Record<ApprovalMode, string>>) {\n        this._labels = next ?? {};\n        if (this.isConnected) this._render();\n    }\n\n    /** The current mode, or `null` with no setup. */\n    get mode(): ApprovalMode | null { return this._controller?.getMode() ?? null; }\n\n    connectedCallback(): void {\n        this._bind(resolveConfig(this));\n        // A setup that arrives AFTER this element mounted (a later script, a dynamic\n        // import), or one that goes away (`dispose()`, `config.reset()`): the config\n        // notifies on `setApprovalPolicy`, and the switch re-resolves its controller\n        // rather than staying disabled — or wired to nothing — for the life of the page.\n        this._configUnsubscribe = subscribeConfigChange(this, () => this._bind(resolveConfig(this)));\n    }\n\n    disconnectedCallback(): void {\n        this._unsubscribe?.();\n        this._unsubscribe = null;\n        this._configUnsubscribe?.();\n        this._configUnsubscribe = null;\n        this._bound = false;\n        this.querySelector('aparte-select')?.removeEventListener('aparte-select-change', this._onChange);\n    }\n\n    /** See `AparteConfigAware`: a boundary moved, so the controller may be another one. */\n    aparteConfigChanged(next: AparteConfig): void {\n        this._bind(next);\n    }\n\n    private _bind(cfg: AparteConfig): void {\n        const next = getApprovalController(cfg);\n        // An unrelated notify (a locale, a provider) must not rebuild the select under an\n        // open dropdown: same config, same controller, nothing to rebind.\n        if (this._bound && cfg === this._cfg && next === this._controller) return;\n        this._bound = true;\n        this._cfg = cfg;\n        this._unsubscribe?.();\n        this._controller = next;\n        if (!this._controller) {\n            console.warn('[aparte] <aparte-approval-mode> found no approval setup on the config it resolves — call setupApproval() from @aparte/plugin-approval on that config (the scoped one if you passed a `config`, aparteGlobalConfig otherwise).');\n        }\n        this._unsubscribe = this._controller?.subscribe(() => this._syncValue()) ?? null;\n        this._render();\n    }\n\n    private _render(): void {\n        const controller = this._controller;\n        const current = controller?.getMode();\n        const options = APPROVAL_MODES.map((m) =>\n            `<aparte-option value=\"${escapeAttr(m)}\">${escapeHtml(this._labels[m] ?? DEFAULT_LABELS[m])}</aparte-option>`).join('');\n        this.querySelector('aparte-select')?.removeEventListener('aparte-select-change', this._onChange);\n        // The select carries no class of ours: `aparte-approval-mode aparte-select` is\n        // already the address a consumer restyling it writes.\n        // The accessible name follows the locale like the option labels do — a\n        // literal here was the one string a localised host could not translate.\n        const aria = String(this._cfg?.getLocale()['approvalModeLabel'] || 'Approval mode');\n        this.innerHTML = `<aparte-select${current ? ` value=\"${escapeAttr(current)}\"` : ''}${controller ? '' : ' disabled'} aria-label=\"${escapeAttr(aria)}\">${options}</aparte-select>`;\n        this.querySelector('aparte-select')?.addEventListener('aparte-select-change', this._onChange);\n    }\n\n    private _syncValue(): void {\n        const select = this.querySelector('aparte-select') as (HTMLElement & { value: string }) | null;\n        const mode = this._controller?.getMode();\n        if (select && mode && select.value !== mode) select.value = mode;\n    }\n}\n\nif (typeof customElements !== 'undefined' && !customElements.get('aparte-approval-mode')) {\n    customElements.define('aparte-approval-mode', AparteApprovalMode);\n}\n"],"names":[],"mappings":";;;AAkBA,MAAM,iBAA+C;AAAA,EACjD,MAAM;AAAA,EACN,KAAK;AAAA,EACL,aAAa;AAAA,EACb,MAAM;AACV;AAoBO,MAAM,2BAA2B,YAAyC;AAAA,EACrE,OAA4B;AAAA,EAC5B;AAAA,EACA,eAAoC;AAAA,EACpC,qBAA0C;AAAA,EAC1C,SAAS;AAAA,EACT,UAAiD,CAAA;AAAA,EACxC,YAAY,CAAC,MAAmB;AAC7C,UAAM,SAAU,EAA4C;AAC5D,UAAM,OAAO,QAAQ;AACrB,QAAI,CAAC,KAAK,eAAe,CAAC,eAAe,SAAS,IAAI,EAAG;AACzD,UAAM,WAAW,KAAK,YAAY,QAAA;AAClC,SAAK,YAAY,QAAQ,IAAI;AAC7B,QAAI,KAAK,YAAY,QAAA,MAAc,UAAU;AACzC,WAAK,cAAc,IAAI,YAAiD,+BAA+B;AAAA,QACnG,SAAS;AAAA,QAAM,UAAU;AAAA,QAAM,QAAQ,EAAE,MAAM,MAAM,cAAc,SAAA;AAAA,MAAS,CAC/E,CAAC;AAAA,IACN;AAAA,EACJ;AAAA;AAAA,EAGA,IAAI,SAAgD;AAAE,WAAO,KAAK;AAAA,EAAS;AAAA,EAC3E,IAAI,OAAO,MAA6C;AACpD,SAAK,UAAU,QAAQ,CAAA;AACvB,QAAI,KAAK,YAAa,MAAK,QAAA;AAAA,EAC/B;AAAA;AAAA,EAGA,IAAI,OAA4B;AAAE,WAAO,KAAK,aAAa,QAAA,KAAa;AAAA,EAAM;AAAA,EAE9E,oBAA0B;AACtB,SAAK,MAAM,cAAc,IAAI,CAAC;AAK9B,SAAK,qBAAqB,sBAAsB,MAAM,MAAM,KAAK,MAAM,cAAc,IAAI,CAAC,CAAC;AAAA,EAC/F;AAAA,EAEA,uBAA6B;AACzB,SAAK,eAAA;AACL,SAAK,eAAe;AACpB,SAAK,qBAAA;AACL,SAAK,qBAAqB;AAC1B,SAAK,SAAS;AACd,SAAK,cAAc,eAAe,GAAG,oBAAoB,wBAAwB,KAAK,SAAS;AAAA,EACnG;AAAA;AAAA,EAGA,oBAAoB,MAA0B;AAC1C,SAAK,MAAM,IAAI;AAAA,EACnB;AAAA,EAEQ,MAAM,KAAyB;AACnC,UAAM,OAAO,sBAAsB,GAAG;AAGtC,QAAI,KAAK,UAAU,QAAQ,KAAK,QAAQ,SAAS,KAAK,YAAa;AACnE,SAAK,SAAS;AACd,SAAK,OAAO;AACZ,SAAK,eAAA;AACL,SAAK,cAAc;AACnB,QAAI,CAAC,KAAK,aAAa;AACnB,cAAQ,KAAK,+NAA+N;AAAA,IAChP;AACA,SAAK,eAAe,KAAK,aAAa,UAAU,MAAM,KAAK,WAAA,CAAY,KAAK;AAC5E,SAAK,QAAA;AAAA,EACT;AAAA,EAEQ,UAAgB;AACpB,UAAM,aAAa,KAAK;AACxB,UAAM,UAAU,YAAY,QAAA;AAC5B,UAAM,UAAU,eAAe,IAAI,CAAC,MAChC,yBAAyB,WAAW,CAAC,CAAC,KAAK,WAAW,KAAK,QAAQ,CAAC,KAAK,eAAe,CAAC,CAAC,CAAC,kBAAkB,EAAE,KAAK,EAAE;AAC1H,SAAK,cAAc,eAAe,GAAG,oBAAoB,wBAAwB,KAAK,SAAS;AAK/F,UAAM,OAAO,OAAO,KAAK,MAAM,YAAY,mBAAmB,KAAK,eAAe;AAClF,SAAK,YAAY,iBAAiB,UAAU,WAAW,WAAW,OAAO,CAAC,MAAM,EAAE,GAAG,aAAa,KAAK,WAAW,gBAAgB,WAAW,IAAI,CAAC,KAAK,OAAO;AAC9J,SAAK,cAAc,eAAe,GAAG,iBAAiB,wBAAwB,KAAK,SAAS;AAAA,EAChG;AAAA,EAEQ,aAAmB;AACvB,UAAM,SAAS,KAAK,cAAc,eAAe;AACjD,UAAM,OAAO,KAAK,aAAa,QAAA;AAC/B,QAAI,UAAU,QAAQ,OAAO,UAAU,aAAa,QAAQ;AAAA,EAChE;AACJ;AAEA,IAAI,OAAO,mBAAmB,eAAe,CAAC,eAAe,IAAI,sBAAsB,GAAG;AACtF,iBAAe,OAAO,wBAAwB,kBAAkB;AACpE;"}

package/dist/index.node.d.ts

@@ -0,0 +1,16 @@
+/**
+ * `@aparte/plugin-approval` — the DOM-free entry, for Node and SSR.
+ *
+ * Everything a server can legitimately use: the setup, the controller, the table.
+ * What is NOT here is `<aparte-approval-mode>`, which needs a document. Resolved
+ * through core's `node` condition, `import '@aparte/plugin-approval'` on a server
+ * registers the policy and nothing else — `scripts/check-node-import.mjs` asserts
+ * this entry keeps importing without a DOM.
+ */
+export { setupApproval, getApprovalController } from './approval.js';
+export type { ApprovalSetupOptions, ApprovalController } from './approval.js';
+export { APPROVAL_MODES, classifyTool, rulingFor, createApprovalPolicy } from './policy.js';
+export type { ApprovalMode, ToolClass, ToolMatcher, ApprovalClassification } from './policy.js';
+export type { AparteApprovalMode } from './aparte-approval-mode.js';
+export type { AparteApprovalPolicy, AparteApprovalRuling, AparteToolCall, AparteApprovalModeChangeEventDetail, } from '@aparte/core';
+//# sourceMappingURL=index.node.d.ts.map

package/dist/index.node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.node.d.ts","sourceRoot":"","sources":["../src/index.node.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AACrE,YAAY,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAC9E,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,SAAS,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAC5F,YAAY,EAAE,YAAY,EAAE,SAAS,EAAE,WAAW,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAGhG,YAAY,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AACpE,YAAY,EACR,oBAAoB,EAAE,oBAAoB,EAAE,cAAc,EAAE,mCAAmC,GAClG,MAAM,cAAc,CAAC"}

package/dist/index.node.js

@@ -0,0 +1,10 @@
+import { A, c, a, g, r, s } from "./approval-B7URDqOS.js";
+export {
+  A as APPROVAL_MODES,
+  c as classifyTool,
+  a as createApprovalPolicy,
+  g as getApprovalController,
+  r as rulingFor,
+  s as setupApproval
+};
+//# sourceMappingURL=index.node.js.map

package/dist/index.node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.node.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/policy.d.ts

@@ -0,0 +1,47 @@
+/**
+ * The modes, the classes, and the table that joins them.
+ *
+ * A MODE is what the person switches ("plan", "auto"); a CLASS is what a tool does
+ * (`read`, `write`, `exec`), declared by the host on ITS tool names — the names are
+ * wire format the host owns, and no library can know that `run_command` executes and
+ * `search_docs` reads. The table below is the whole policy: nine cells, no
+ * configuration, so a consumer can read it in one glance and predict every ruling.
+ *
+ * Nothing here executes anything, remembers anything, or draws anything: it is a pure
+ * function from (mode, class, call) to a ruling core already knows how to honour.
+ */
+import type { AparteApprovalPolicy, AparteApprovalRuling, AparteToolCall } from '@aparte/core';
+/**
+ * `plan` runs read-only tools and refuses the rest with a sentence the model reads;
+ * `ask` asks before every write or execution; `auto-edit` lets writes through and asks
+ * before an execution; `auto` never asks.
+ */
+export type ApprovalMode = 'plan' | 'ask' | 'auto-edit' | 'auto';
+/** The four modes, in the order a switch presents them. */
+export declare const APPROVAL_MODES: readonly ApprovalMode[];
+/** What a tool does — the axis the modes decide on. */
+export type ToolClass = 'read' | 'write' | 'exec';
+/** A tool name, exactly, or a pattern over names. */
+export type ToolMatcher = string | RegExp;
+/**
+ * The host's tool names, by what they do. A name in no list is UNCLASSIFIED: its
+ * own `needsApproval` decides (and `auto` still lets it through — auto is auto).
+ */
+export interface ApprovalClassification {
+    read?: readonly ToolMatcher[];
+    write?: readonly ToolMatcher[];
+    exec?: readonly ToolMatcher[];
+}
+/** The class of a tool name under a classification, or `undefined` when it is in no list. */
+export declare function classifyTool(name: string, classification: ApprovalClassification): ToolClass | undefined;
+/**
+ * The ruling for one call, from the table. `undefined` means "no opinion" — the tool's
+ * own `needsApproval` decides, which is what core does when a policy says nothing.
+ */
+export declare function rulingFor(mode: ApprovalMode, cls: ToolClass | undefined, call: AparteToolCall): AparteApprovalRuling | undefined;
+/**
+ * A core `AparteApprovalPolicy` that reads the CURRENT mode on every call — so a
+ * switch flipped mid-run applies to the next tool call, not the next conversation.
+ */
+export declare function createApprovalPolicy(getMode: () => ApprovalMode, classification: ApprovalClassification): AparteApprovalPolicy;
+//# sourceMappingURL=policy.d.ts.map

package/dist/policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"policy.d.ts","sourceRoot":"","sources":["../src/policy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAE/F;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,KAAK,GAAG,WAAW,GAAG,MAAM,CAAC;AAEjE,2DAA2D;AAC3D,eAAO,MAAM,cAAc,EAAE,SAAS,YAAY,EAAyC,CAAC;AAE5F,uDAAuD;AACvD,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;AAElD,qDAAqD;AACrD,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,MAAM,CAAC;AAE1C;;;GAGG;AACH,MAAM,WAAW,sBAAsB;IACnC,IAAI,CAAC,EAAE,SAAS,WAAW,EAAE,CAAC;IAC9B,KAAK,CAAC,EAAE,SAAS,WAAW,EAAE,CAAC;IAC/B,IAAI,CAAC,EAAE,SAAS,WAAW,EAAE,CAAC;CACjC;AAQD,6FAA6F;AAC7F,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,cAAc,EAAE,sBAAsB,GAAG,SAAS,GAAG,SAAS,CAKxG;AAID;;;GAGG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,YAAY,EAAE,GAAG,EAAE,SAAS,GAAG,SAAS,EAAE,IAAI,EAAE,cAAc,GAAG,oBAAoB,GAAG,SAAS,CAahI;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,YAAY,EAAE,cAAc,EAAE,sBAAsB,GAAG,oBAAoB,CAE9H"}

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@aparte/plugin-approval",
+  "version": "0.16.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "Approval modes for aparté tool calls — plan, ask, auto-edit, auto — from a classification of your tool names, with a switch for the composer's toolbar.",
+  "customElements": "dist/custom-elements.json",
+  "type": "module",
+  "sideEffects": true,
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "@aparte-workspace/source": "./src/index.ts",
+      "node": {
+        "types": "./dist/index.node.d.ts",
+        "default": "./dist/index.node.js"
+      },
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "peerDependencies": {
+    "@aparte/core": ">=0.16.0 <1.0.0"
+  },
+  "devDependencies": {
+    "@custom-elements-manifest/analyzer": "^0.11.0",
+    "typescript": "^5.4.0",
+    "vite": "^6.0.0",
+    "@aparte/core": "0.16.0"
+  },
+  "keywords": [
+    "aparte",
+    "plugin",
+    "tool",
+    "approval",
+    "human-in-the-loop",
+    "agent"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/apartejs/aparte.git",
+    "directory": "packages/plugins/approval"
+  },
+  "bugs": {
+    "url": "https://github.com/apartejs/aparte/issues"
+  },
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build && tsc -b --emitDeclarationOnly --force && pnpm run analyze",
+    "analyze": "cem analyze",
+    "preview": "vite preview",
+    "test": "vitest",
+    "test:run": "vitest run",
+    "test:coverage": "vitest run --coverage"
+  }
+}