dev-cockpit 0.1.0 → 0.2.1

package/README.md

@@ -3,26 +3,29 @@
 A reusable, domain-neutral terminal UI dev cockpit. One window for the long-running processes you babysit during development: code, logs, health, and the keystrokes to fix things when they break.
 
 ```
-┌── Repos ── Output ── Health ── Help ────────────────── [↔ / tab] cycle ──┐
-│ Repos                                                                     │
-│   web      docker     idle                                               │
-│   db       docker     idle                                               │
-│   cache    docker     idle                                               │
-│                                                                           │
-│ Recent errors:                                                            │
-│   web │ Stack trace at /srv/app/handler.ts:42                            │
-└───────────────────────────────────────────────────────────────────────────┘
+┌── Targets ── Output ── Health ── Help ────────────────────────────────────┐
+│ Targets                         │ Actions for `web` (docker)             │
+│   ▸ web      [docker]          │   [r] Restart web      (default)       │
+│     ticker   [process]         │   [L] Tail logs                        │
+│     api                        │                                        │
+│                                │                                        │
+│                                │                                        │
+└────────────────────────────────┴────────────────────────────────────────┘
+                                              [↑↓] select  [r] restart  [L] tail
 ```
 
 ## What's in the box
 
-- **Four-pane TUI** — Repos / Output / Health / Help, tab-cycle nav, filter + search modals.
-- **Watchers** — long-running processes spawned once on boot; their stdout streams into Output, tagged by id.
-- **Docker log tailing** — stream `docker compose logs -f <services>` into the same Output pane with regex-driven highlights for errors / stack traces.
-- **Health framework** — five built-in check types (`container-running`, `port-open`, `http-ok`, `file-exists`, `exec-zero`) plus profile-contributed ones; each gets a row on the Health pane and a single-keystroke remediation.
-- **Profile interface** — drop-in adapter so a domain-specific tool can wire its own discoverer / repos / health / commands / cockpit handlers without forking the shell.
+- **Four-pane TUI** — Targets / Output / Health / Help, tab-cycle navigation, filter + search modals, narrow-terminal layouts.
+- **Processes** — long-running commands spawned once on boot; stdout/stderr streamed into Output, tagged by id, with shell-out execution so pipes/redirects/quoted args just work.
+- **Docker log tailing** — stream `docker compose logs -f <services>` into Output with regex-driven highlights (configurable severity per pattern).
+- **Health framework** — five built-in check types (`container-running`, `port-open`, `http-ok`, `file-exists`, `exec-zero`) plus profile-contributed ones; each gets a row + a single-keystroke remediation.
+- **Mount overlay manager** — `dev-cockpit mount` writes a docker-compose overlay + manifest, with an interactive picker, branch / dirty / broken-symlink status table, and profile hooks for restart + dependency-restore on clear.
+- **Actions library** — `config.actions[]` + `Profile.actions` (declarative shell-out OR programmatic `invoke` callbacks). Reach via the vim-style `:` palette or single-keystroke binding scoped to a Targets row.
+- **Profile interface** — drop-in adapter so a domain-specific tool plugs in its discoverer / repos / health / actions / commands / cockpit handlers without forking the shell.
 - **Live markdown Help** — pages render inside the cockpit; profiles can layer their own docs over the generic ones.
 - **Native OS notifications** — fire on state transitions only (no spam). Detached helper, never blocks process exit.
+- **A11y** — `NO_COLOR` strips all styles; semantic glyphs (`✓` `⚠` `✗` `●` `○`) carry severity / status info without color.
 
 ## Install
 
@@ -32,29 +35,41 @@ npm install -g dev-cockpit
 
 Or `npm link` from a checkout for development.
 
+Requires Node ≥ 20.12 (chalk + inquirer use `node:util.styleText`). The bin guards this at startup with a friendly error message.
+
 ## Quick start
 
 ```sh
 cd your-project
-dev-cockpit init-config -i    # interactive wizard, 7 steps with auto-detection
+dev-cockpit init-config -i    # interactive wizard, 8 steps with auto-detection
 dev-cockpit doctor             # validate + print initial health
 dev-cockpit dev                # boot the cockpit
 ```
 
-The wizard sniffs your project: if there's a `compose.yaml` it suggests services to tail, if `package.json` has a `dev` script it offers it as a watcher, if there are workspaces it surfaces them as repo entries. Most prompts just need an enter.
+The wizard sniffs your project: docker compose services from `compose.yaml`, long-running processes from `package.json` (`dev`, `watch`), one-shot actions from the rest of your scripts (`test`, `build`, `lint`, `format`), workspaces as repo entries. Most prompts just need an enter.
 
 ## Configuration
 
-Single file, `cockpit.yaml` at your project root. Schema enforced by zod (`version: 1`). Full reference: [`docs/config-reference.md`](./docs/config-reference.md). Minimal example:
+Single file, `cockpit.yaml` at your project root. Schema enforced by zod (`version: 2`). Full reference: [`docs/config-reference.md`](./docs/config-reference.md). Minimal example:
 
 ```yaml
-version: 1
+version: 2
 appName: my-app
 
-watchers:
+processes:
   - id: vite
     command: npm run dev
 
+actions:
+  - id: test
+    label: Run tests
+    command: npm test
+    key: t                 # `:` palette + single-keystroke binding
+  - id: lint
+    label: Lint
+    command: npm run lint
+    key: l
+
 docker:
   composeFile: compose.yaml
   services:
@@ -76,20 +91,29 @@ notifications:
   enabled: true
 ```
 
+Wrappers upgrading from v1 (pre-rename) configs run `dev-cockpit migrate-config` to persist the v1 → v2 migration (auto-applied in memory on load with a stderr warning).
+
 ## Profiles
 
 A profile is a domain-specific bundle that plugs into dev-cockpit's lifecycle. It contributes any combination of:
 
 - `discoverer`        — workspace root resolution
-- `reposProvider`     — Repos-pane entries
+- `reposProvider`     — Targets-pane entries (kind: `repo`)
 - `healthChecks`      — pre-built `HealthCheck[]` (programmatic, beyond the five built-ins)
 - `setupCli`          — extra CLI commands (the profile's own `select`, `release`, etc.)
 - `helpSources`       — markdown docs that layer over the generic Help
+- `defaultHelpPage`   — landing page slug for the Help tab
+- `defaultPane`       — which tab the cockpit lands on (overrides `config.defaultPane`)
 - `configSchemaExt`   — zod schema validating the profile's `profile.<appName>` namespace
+- `actions`           — static action defaults merged into the registry
+- `wizardSteps`       — extra `init-config -i` steps; output lands under `profile.<appName>:`
 - `mountCandidatesProvider` — auto-detected bind-mount candidates
-- `boot`              — async lifecycle hook returning Cockpit pane handlers + `subscribeFsEvents` + `cleanup`
+- `mountSymlinks`     — IDE-facing symlink strategy for mount apply / clear
+- `onMountApply` / `onMountClear` — post-mount lifecycle hooks (restart docker, run installer, etc.)
+- `mountStatusEnricher` — extra columns in `mount status`
+- `boot`              — async lifecycle hook returning Cockpit pane handlers + dynamic `actions` (per-row invoke callbacks) + `subscribeFsEvents` + `cleanup`
 
-A profile is its own npm package — its bin entry composes `buildCli({ profile })` and that's it. The skeleton:
+A profile is its own npm package — its bin entry composes `buildCli({ profile })` and that's it.
 
 ```ts
 import type { Profile } from 'dev-cockpit';
@@ -97,11 +121,22 @@ import type { Profile } from 'dev-cockpit';
 export const myProfile: Profile = {
   appName: 'my-app',
   healthChecks: [...],
-  boot: ({ config, workspaceRoot }) => ({
-    cockpitHandlers: { runRepoAction, onWatchToggle, onLint, onOpenError },
-    subscribeFsEvents: (listener) => watcherManager.subscribeFsEvents(listener),
-    cleanup: () => watcherManager.stop(),
-  }),
+  boot: ({ config, workspaceRoot }) => {
+    const manager = new WatcherManager(...);
+    manager.start();
+    return {
+      // Per-repo programmatic actions: closure over the live WatcherManager.
+      actions: managedRepos.map((repo) => ({
+        id: `repo-rebuild:${repo.name}`,
+        label: `Rebuild ${repo.name}`,
+        scope: `repos:${repo.name}`,
+        key: 'r',
+        invoke: () => manager.rebuild(repo.name),
+      })),
+      subscribeFsEvents: (listener) => manager.subscribeFsEvents(listener),
+      cleanup: () => manager.stop(),
+    };
+  },
 };
 
 // Bin entry — that's it.
@@ -117,7 +152,7 @@ buildCli({ profile: myProfile }).parse(process.argv);
 | Commands | [`docs/commands.md`](./docs/commands.md) |
 | `init-config` wizard | [`docs/init-config.md`](./docs/init-config.md) |
 | Panes | [`docs/panes.md`](./docs/panes.md) |
-| Watchers | [`docs/watchers.md`](./docs/watchers.md) |
+| Processes | [`docs/processes.md`](./docs/processes.md) |
 | Health | [`docs/health.md`](./docs/health.md) |
 | Mounts | [`docs/mount.md`](./docs/mount.md) |
 | Notifications | [`docs/notifications.md`](./docs/notifications.md) |
@@ -128,4 +163,4 @@ buildCli({ profile: myProfile }).parse(process.argv);
 
 ## Status
 
-Pre-1.0. The public surface (`Profile` interface, `buildCli`, the four core commands, `cockpit.yaml` schema with `version: 1`) is stable enough for first consumers to depend on; expect minor churn until the post-1.0 roadmap items land. See `CHANGELOG.md` for what's shipped.
+Pre-1.0. The public surface (`Profile` interface, `buildCli`, the four core commands plus `migrate-config`, `cockpit.yaml` schema with `version: 2`) is stable enough for first consumers to depend on; expect minor churn until the rest of the post-1.0 roadmap items land. See `CHANGELOG.md` for what's shipped.

package/bin/dev-cockpit.mjs

@@ -1,4 +1,30 @@
 #!/usr/bin/env node
+
+// Engine guard. dev-cockpit's import graph (inquirer, ink/@inquirer/core
+// transitives) uses `node:util.styleText` — added in Node 20.12 — at parse
+// time, so older Node fails with a cryptic `SyntaxError: ... does not
+// provide an export named 'styleText'`. Catch it here with a friendly
+// message before any heavy import resolves.
+{
+  const [major, minor] = process.versions.node.split('.').map(Number);
+  if (major < 20 || (major === 20 && minor < 12)) {
+    process.stderr.write(
+      `\ndev-cockpit: Node 20.12+ required (you are on ${process.versions.node}).\n` +
+      `  Run \`nvm use 22\` (or install Node >= 20.12) and retry.\n\n`,
+    );
+    process.exit(1);
+  }
+}
+
+// A11y: honour NO_COLOR strictly. chalk reads NO_COLOR at module-load time
+// and disables foreground/background colours, but it keeps "style" modifiers
+// (bold, inverse, dim) intact. Some terminals still render those visibly.
+// Forcing FORCE_COLOR=0 before any import ensures chalk's level drops to 0,
+// stripping styles too — true monochrome under NO_COLOR.
+if (process.env.NO_COLOR !== undefined && process.env.NO_COLOR !== '') {
+  process.env.FORCE_COLOR = '0';
+}
+
 // Filter Node 22's ExperimentalWarning about JSON modules. The warning fires
 // from a transitive dep (cli-boxes uses `import boxes from './boxes.json' with
 // {type: 'json'}`) the moment the cockpit shell's import graph resolves. It's
@@ -7,10 +33,6 @@
 // before cli-boxes loads.
 const orig = process.emitWarning.bind(process);
 process.emitWarning = (w, ...rest) => {
-  // The JSON-modules warning fires as a plain string with the type passed
-  // separately (`process.emitWarning(text, 'ExperimentalWarning')`), so we
-  // match on the message text directly. The `.name` check from earlier
-  // only worked when the caller handed us an Error object.
   const msg = typeof w === 'string' ? w : (w?.message ?? '');
   if (/JSON modules/i.test(msg)) return;
   return orig(w, ...rest);

package/dist/actions/builtin.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Built-in action synthesis.
+ *
+ * Generates default ActionConfig entries for kinds that have a natural
+ * single-keystroke action — docker services and processes both get `r` to
+ * restart by default. Users can shadow them by declaring an action with
+ * the same scope + key (declared wins during dispatch).
+ *
+ * Built-in ids are prefixed with `__builtin:` so the executor can detect
+ * them and run the right programmatic handler instead of shelling out.
+ */
+import type { BaseCockpitConfig } from '../core/config.js';
+import type { ActionConfig } from './types.js';
+export declare const BUILTIN_PREFIX = "__builtin:";
+export declare const BUILTIN_RESTART_DOCKER = "__builtin:restart-docker:";
+export declare const BUILTIN_RESTART_PROCESS = "__builtin:restart-process:";
+/**
+ * Synthesize built-in restart actions for every docker service and process
+ * declared in the config. Each action lives at `scope: repos:<id>` with
+ * `key: 'r'`. Commands carry a sentinel string only; the executor branches
+ * on the action's id, not its command.
+ */
+export declare function buildBuiltinActions(config: BaseCockpitConfig): ActionConfig[];
+export declare function isBuiltinAction(action: ActionConfig): boolean;
+//# sourceMappingURL=builtin.d.ts.map

package/dist/actions/builtin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builtin.d.ts","sourceRoot":"","sources":["../../src/actions/builtin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C,eAAO,MAAM,cAAc,eAAe,CAAC;AAC3C,eAAO,MAAM,sBAAsB,8BAAqC,CAAC;AACzE,eAAO,MAAM,uBAAuB,+BAAsC,CAAC;AAE3E;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,iBAAiB,GAAG,YAAY,EAAE,CA0B7E;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAE7D"}

package/dist/actions/dispatch.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Action dispatch helpers — pure lookup functions used by pane keystroke
+ * handlers and the right-hand Repos action panel.
+ *
+ * Precedence rule: user-declared (non-builtin) wins over built-in on
+ * matching (scope, key) collisions. This lets a user shadow the default
+ * `r` on a docker/process row with their own command.
+ */
+import type { ActionConfig } from './types.js';
+/**
+ * Actions that apply when the given row key is selected in Repos. Matches:
+ *   - scope === `repos:${rowKey}`  (row-specific)
+ *   - scope === 'repos'            (any row)
+ *
+ * Built-ins are placed AFTER declared so callers that take the first match
+ * get the user override automatically.
+ */
+export declare function actionsForRepoRow(actions: readonly ActionConfig[], rowKey: string): ActionConfig[];
+/** First action in scope matching the keypress, or undefined. */
+export declare function findActionByKey(actions: readonly ActionConfig[], rowKey: string, keypress: string): ActionConfig | undefined;
+//# sourceMappingURL=dispatch.d.ts.map

package/dist/actions/dispatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatch.d.ts","sourceRoot":"","sources":["../../src/actions/dispatch.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAG/C;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,SAAS,YAAY,EAAE,EAChC,MAAM,EAAE,MAAM,GACb,YAAY,EAAE,CAehB;AAED,iEAAiE;AACjE,wBAAgB,eAAe,CAC7B,OAAO,EAAE,SAAS,YAAY,EAAE,EAChC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,GACf,YAAY,GAAG,SAAS,CAE1B"}

package/dist/actions/registry.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Build the action registry from config + profile sources.
+ *
+ * Merge rule: config entries win on `id` collision. Profile actions act
+ * as defaults the wrapper can override or remove (by re-declaring with
+ * the same id and a different command, or by omitting from config to
+ * keep the profile default).
+ */
+import type { ActionConfig } from './types.js';
+export declare function buildActionRegistry(configActions: readonly ActionConfig[], profileActions?: readonly ActionConfig[]): ActionConfig[];
+//# sourceMappingURL=registry.d.ts.map

package/dist/actions/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/actions/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C,wBAAgB,mBAAmB,CACjC,aAAa,EAAE,SAAS,YAAY,EAAE,EACtC,cAAc,GAAE,SAAS,YAAY,EAAO,GAC3C,YAAY,EAAE,CAKhB"}

package/dist/actions/types.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Action subsystem types.
+ *
+ * An "action" is a named, optionally keystroke-bound shell command surfaced
+ * through the cockpit's `:` command palette and/or via direct keypress in a
+ * pane (when `key` + `scope` are set). Actions land via two sources merged
+ * at boot:
+ *   1. config.actions[] in cockpit.yaml — user/wrapper declarations
+ *   2. profile.actions   — profile-bundle defaults
+ *
+ * Config entries win on `id` collision.
+ *
+ * Scope semantics:
+ *   - 'global'        — appears in the `:` palette regardless of focus
+ *   - 'repos'         — appears in `:` AND fires on Repos pane regardless of
+ *                       which row is selected (key dispatch applies to any
+ *                       Repos selection)
+ *   - 'repos:<id>'    — only fires on Repos pane when that specific row is
+ *                       selected; appears in the right-hand action panel
+ *
+ * If `key` is set, the action is dispatchable by a single keypress in the
+ * matching scope. Without `key`, the action is only reachable via `:`.
+ */
+/**
+ * Action scope string. Runtime values:
+ *   - 'global'
+ *   - 'repos'
+ *   - 'repos:<id>' where <id> matches /^[\w-]+$/
+ * Validated at the schema boundary; expressed as plain string in TS to keep
+ * the zod inference aligned with the runtime type (template-literal types
+ * can't be produced by `.regex()`).
+ */
+export type ActionScope = string;
+/** Per-invocation context passed to programmatic action handlers. */
+export interface ActionInvokeContext {
+    /** Workspace root resolved by the cockpit's discoverer / config path. */
+    workspaceRoot: string;
+    /** Action that was matched (the same object the executor received). */
+    action: ActionConfig;
+    /** The Repos row id that was selected when the action fired, if any. */
+    rowKey?: string;
+    /** Push a line into the Output pane, tagged by the action's id. */
+    log: (line: string) => void;
+    /** Push a stderr-shaped warn line into the Output pane. */
+    errLog: (line: string) => void;
+}
+export interface ActionConfig {
+    /** Stable identifier — used by config-vs-profile dedup. */
+    id: string;
+    /** Display label in the `:` palette and the Repos action panel. */
+    label: string;
+    /**
+     * Shell command. Executed via `sh -c <command>` (cmd /c on Windows) so
+     * users can write pipes, redirects, env-prefixes, and quoted args. Mutually
+     * exclusive with `invoke`.
+     */
+    command?: string;
+    /**
+     * Programmatic handler — fires instead of shelling out. Profile-only:
+     * functions don't survive a YAML round-trip, so `config.actions[]` entries
+     * never carry this. Use for actions that mutate in-memory cockpit / profile
+     * state (rebuild via WatcherManager, toggle a chokidar watcher, etc.).
+     */
+    invoke?: (ctx: ActionInvokeContext) => void | Promise<void>;
+    /** Working directory; relative paths resolve against workspaceRoot. */
+    cwd?: string;
+    /** Action visibility / dispatch context. Default: 'global'. */
+    scope?: ActionScope;
+    /**
+     * Optional single-keystroke binding. Matched against the keypress within
+     * the action's scope. Case-sensitive at dispatch time so users can declare
+     * uppercase-only bindings. If absent, the action is reachable only via `:`.
+     */
+    key?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/actions/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/actions/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;;;;;;;GAQG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC;AAEjC,qEAAqE;AACrE,MAAM,WAAW,mBAAmB;IAClC,yEAAyE;IACzE,aAAa,EAAE,MAAM,CAAC;IACtB,uEAAuE;IACvE,MAAM,EAAE,YAAY,CAAC;IACrB,wEAAwE;IACxE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,mEAAmE;IACnE,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5B,2DAA2D;IAC3D,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAChC;AAED,MAAM,WAAW,YAAY;IAC3B,2DAA2D;IAC3D,EAAE,EAAE,MAAM,CAAC;IACX,mEAAmE;IACnE,KAAK,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,mBAAmB,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5D,uEAAuE;IACvE,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,+DAA+D;IAC/D,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB;;;;OAIG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;CACd"}

package/dist/buildCli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"buildCli.d.ts","sourceRoot":"","sources":["../src/buildCli.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIpC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAU/C,MAAM,WAAW,eAAe;IAC9B,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAkBD,wBAAgB,QAAQ,CAAC,IAAI,GAAE,eAAoB,GAAG,OAAO,CAwF5D"}
+{"version":3,"file":"buildCli.d.ts","sourceRoot":"","sources":["../src/buildCli.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIpC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAW/C,MAAM,WAAW,eAAe;IAC9B,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAkBD,wBAAgB,QAAQ,CAAC,IAAI,GAAE,eAAoB,GAAG,OAAO,CAgH5D"}

package/dist/chunk-6XGHLLYT.js

@@ -0,0 +1,46 @@
+import { createRequire as __createRequireDC } from 'node:module';
+const require = __createRequireDC(import.meta.url);
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __require,
+  __commonJS,
+  __export,
+  __toESM
+};
+//# sourceMappingURL=chunk-6XGHLLYT.js.map

package/dist/chunk-6XGHLLYT.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}