@dxos/app-framework 0.8.4-main.d05539e30a → 0.8.4-main.d9fc60f731

package/src/vite-plugin/boot-loader/loader-app/store.ts

@@ -0,0 +1,149 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { type Accessor, createSignal } from 'solid-js';
+
+import { type StatusPayload } from './types';
+
+//
+// Creep tuning. The ring auto-creeps toward a moving ceiling so a long
+// activation silence never reads as a frozen disc. See the original
+// hand-written driver for the rationale behind each constant.
+//
+
+/** Creep timer cadence, in milliseconds. */
+export const CREEP_TICK_MS = 100;
+/** State-1 ease rate — a gentle "we're alive" hint before real progress lands. */
+export const STATE_1_RATE = 0.05;
+/** State-1 asymptote (percent) the creep eases toward before host progress. */
+export const STATE_1_ASYMPTOTE = 40;
+/** State-2 ease rate — bridges the gap between sparse host `progress()` calls. */
+export const STATE_2_RATE = 0.05;
+/** State-2 lead (percent) the ceiling sits ahead of the last host value. */
+export const STATE_2_BUMP = 15;
+/** Hard ceiling the auto-creep never crosses (host must drive the rest). */
+export const ABSOLUTE_CEILING = 90;
+
+/** Loader lifecycle phase. */
+export type Phase = 'creep' | 'host' | 'dismissing';
+
+/** A single rendered status line; `id` keys the `<For>` and survives in-place range ticks. */
+export type StatusLine = {
+  id: number;
+  text: string;
+  event?: string;
+  module?: string;
+};
+
+/**
+ * Asymptotic ease — `next = raw + (ceiling - raw) * rate`, clamped so it never
+ * overshoots (or regresses past) the ceiling. Pure; unit-tested.
+ */
+export const easeToward = (raw: number, ceiling: number, rate: number): number =>
+  raw >= ceiling - 0.1 ? raw : raw + (ceiling - raw) * rate;
+
+/**
+ * Clamp a host-supplied fraction to a percent in [0, 100]. Invalid / negative /
+ * non-finite values collapse to 0 rather than poisoning the CSS var. Pure;
+ * unit-tested.
+ */
+export const clampPercent = (fraction?: number): number =>
+  typeof fraction !== 'number' || !Number.isFinite(fraction) || fraction < 0 ? 0 : Math.min(1, fraction) * 100;
+
+/** Display text for a payload — appends the `(index/total)` suffix when a range is present. */
+export const displayText = (payload: StatusPayload): string =>
+  payload.range ? `${payload.humanized} (${payload.range.index}/${payload.range.total})` : payload.humanized;
+
+/**
+ * Reactive loader store — owns the progress percent, the status-line log, and
+ * the lifecycle phase, plus the auto-creep timer. All DOM-free, so the creep
+ * math and status reduction are testable as plain functions; `Loader.tsx` binds
+ * the accessors to the DOM and `bridge.ts` wraps the mutators as the imperative
+ * `window.__bootLoader` facade.
+ */
+export type LoaderStore = {
+  /** Progress as a percent in [0, 100] (the CSS `--boot-loader-bar-progress` value). */
+  progress: Accessor<number>;
+  /** Appended status lines, newest last. */
+  lines: Accessor<StatusLine[]>;
+  /** Current lifecycle phase. */
+  phase: Accessor<Phase>;
+  /** Apply a status update (append, or replace-in-place for range ticks). */
+  pushStatus: (payload: StatusPayload) => void;
+  /** Enter host-driven progress with `fraction` ∈ [0, 1]; never regresses. */
+  setProgress: (fraction?: number) => void;
+  /** Snap to 100%, stop the creep, and enter the dismissing phase. */
+  ready: () => void;
+  /** Stop the creep timer (call on teardown). */
+  dispose: () => void;
+};
+
+export const createLoaderStore = (initialStatus?: string): LoaderStore => {
+  const [progress, setProgressPct] = createSignal(0);
+  const [lines, setLines] = createSignal<StatusLine[]>(initialStatus ? [{ id: 0, text: initialStatus }] : []);
+  const [phase, setPhase] = createSignal<Phase>('creep');
+
+  let creepCeiling = STATE_1_ASYMPTOTE;
+  let creepRate = STATE_1_RATE;
+  let nextId = initialStatus ? 1 : 0;
+  let timer: ReturnType<typeof setInterval> | null = null;
+
+  const startCreep = (): void => {
+    if (timer == null) {
+      timer = setInterval(() => setProgressPct((raw) => easeToward(raw, creepCeiling, creepRate)), CREEP_TICK_MS);
+    }
+  };
+
+  const stopCreep = (): void => {
+    if (timer != null) {
+      clearInterval(timer);
+      timer = null;
+    }
+  };
+
+  const pushStatus = (payload: StatusPayload): void => {
+    const text = displayText(payload);
+    setLines((current) => {
+      const previous = current.at(-1);
+      // Dedup back-to-back identical transitions (same text + structured fields).
+      if (
+        previous &&
+        previous.text === text &&
+        (previous.event ?? null) === (payload.event ?? null) &&
+        (previous.module ?? null) === (payload.module ?? null)
+      ) {
+        return current;
+      }
+      // Range tick — replace the current line in place rather than appending,
+      // so a counted phase produces one entry with an updating suffix.
+      if (payload.range && previous) {
+        return [...current.slice(0, -1), { ...previous, text }];
+      }
+      return [...current, { id: nextId++, text, event: payload.event, module: payload.module }];
+    });
+  };
+
+  const setProgress = (fraction?: number): void => {
+    setPhase('host');
+    const pct = clampPercent(fraction);
+    // The ring never regresses: hold the current value if the host reports lower.
+    setProgressPct((current) => Math.max(current, pct));
+    // Switch the creep to its state-2 cadence and lead the host value by a bump.
+    creepRate = STATE_2_RATE;
+    creepCeiling = Math.min(Math.max(creepCeiling, pct + STATE_2_BUMP), ABSOLUTE_CEILING);
+    startCreep();
+  };
+
+  const ready = (): void => {
+    stopCreep();
+    setProgressPct(100);
+    setPhase('dismissing');
+  };
+
+  const dispose = (): void => stopCreep();
+
+  startCreep();
+
+  return { progress, lines, phase, pushStatus, setProgress, ready, dispose };
+};

package/src/vite-plugin/boot-loader/loader-app/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../../../../../../tsconfig.base.json",
+  "compilerOptions": {
+    "jsx": "preserve",
+    "jsxImportSource": "solid-js",
+    "strict": false,
+    "noEmit": true,
+    "composite": false
+  },
+  "include": ["."]
+}

package/src/vite-plugin/boot-loader/loader-app/types.ts

@@ -0,0 +1,78 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+/**
+ * Status payload accepted by `window.__bootLoader.status(...)`. The caller owns
+ * formatting — `humanized` is the exact text rendered — while `event` / `module`
+ * carry the structured activation ids for the boot trace, and `range` drives an
+ * in-place `(index/total)` counter for long counted phases.
+ */
+export type StatusPayload = {
+  /**
+   * Raw activation event key (e.g. `dxos.org/plugin/observability/activate`)
+   * when the transition is event-level.
+   */
+  event?: string;
+
+  /**
+   * Raw module id (e.g. `org.dxos.plugin.observability.module.ReactSurface`)
+   * when the transition is module-level.
+   */
+  module?: string;
+
+  /** Exact text to display (e.g. "Activating Observability: react-surface"). */
+  humanized: string;
+
+  /**
+   * Optional `(index/total)` tick. When present the loader replaces the current
+   * line in place ("Loading plugins (12/80)") instead of appending a new entry —
+   * keeps the visible log compact during long counted phases.
+   */
+  range?: { index: number; total: number };
+};
+
+/**
+ * Imperative facade exposed on `window.__bootLoader`, installed by the inlined
+ * loader bundle and driven by the host app (the React relay forwards `useApp`'s
+ * startup progress through it).
+ */
+export type BootLoaderApi = {
+  /** Update the visible status line. */
+  status: (payload: StatusPayload) => void;
+  /** Enter host-driven progress — `fraction` ∈ [0, 1]. */
+  progress: (fraction?: number) => void;
+  /** Play the dismissal outro, then remove the loader DOM (graceful path). */
+  ready: () => void;
+  /** Remove the loader DOM immediately (fast-load backstop / terminal). */
+  dismiss: () => void;
+};
+
+/**
+ * Config baked into `index.html` by `bootLoaderPlugin` ahead of the loader
+ * bundle, so the compiled app stays static (compiled once, independent of the
+ * host's brand mark / initial status).
+ */
+export type BootLoaderConfig = {
+  /**
+   * Id of the static backdrop element the plugin injects and the loader mounts
+   * into — the single coupling between `transformIndexHtml` and the app. The
+   * plugin owns the authoritative value and passes it here so `entry.tsx` reads
+   * it rather than hardcoding (the CSS selector mirrors it — see `boot-loader.css`).
+   */
+  rootId?: string;
+  /** Inline SVG markup for the brand mark rendered inside the ring. */
+  markSvg?: string;
+  /** Initial status text rendered before the host fires its first `status(...)`. */
+  status?: string;
+};
+
+/** Fallback backdrop id when no config is present (kept in sync with `loader.ts` + the CSS). */
+export const DEFAULT_ROOT_ID = 'boot-loader';
+
+declare global {
+  interface Window {
+    __bootLoader?: BootLoaderApi;
+    __BOOT_LOADER_CONFIG__?: BootLoaderConfig;
+  }
+}

package/src/vite-plugin/boot-loader/loader.ts

@@ -2,10 +2,28 @@
 // Copyright 2026 DXOS.org
 //
 
+// @ts-ignore — @types/babel__core present transitively but not declared here.
+import * as babel from '@babel/core';
+// @ts-ignore — @babel/preset-typescript ships no .d.ts.
+import babelPresetTypeScript from '@babel/preset-typescript';
+// @ts-ignore — babel-preset-solid ships no .d.ts.
+import babelPresetSolid from 'babel-preset-solid';
+import { build, type Plugin as EsbuildPlugin } from 'esbuild';
+import { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { type Plugin } from 'vite';
 
-import css from './boot-loader.css?raw';
-import driverScript from './boot-loader.js?raw';
+import css from './loader-app/boot-loader.css?raw';
+// The loader-app Solid sources are inlined as raw text (never parsed by
+// dx-compile — app-framework is a React package, so its build can't compile
+// Solid JSX). They are compiled to a self-contained browser IIFE at the
+// consuming app's build time by {@link compileLoaderBundle} below.
+import bridgeSrc from './loader-app/bridge.ts?raw';
+import entrySrc from './loader-app/entry.tsx?raw';
+import loaderSrc from './loader-app/Loader.tsx?raw';
+import mountSrc from './loader-app/mount.tsx?raw';
+import storeSrc from './loader-app/store.ts?raw';
+import typesSrc from './loader-app/types.ts?raw';
 
 /**
  * Options for {@link bootLoaderPlugin}.
@@ -18,56 +36,130 @@ export type BootLoaderOptions = {
   status?: string;
 
   /**
-   * Inline SVG markup for an optional brand mark rendered above the progress bar.
-   * The mark renders at full opacity with whatever fills the SVG declares, so
-   * pass a colour-palette logo for the strongest visual identity. SVGs that use
-   * `fill="currentColor"` still inherit the loader's `prefers-color-scheme`
-   * text colour. Leave empty/undefined to render only the bar.
+   * Inline SVG markup for an optional brand mark rendered inside the progress
+   * ring. The mark renders at full opacity with whatever fills the SVG declares,
+   * so pass a colour-palette logo for the strongest visual identity. SVGs that
+   * use `fill="currentColor"` still inherit the loader's `prefers-color-scheme`
+   * text colour. Leave empty/undefined to render only the ring.
    */
   markSvg?: string;
 };
 
+const VIRTUAL_NS = 'boot-loader-app';
+
+// Relative-import graph of the loader-app, keyed by module name (no extension).
+// `tsx` modules carry JSX (compiled via `babel-preset-solid`); `ts` modules are
+// type-stripped only. `solid-js` imports introduced by the Solid transform
+// resolve from `node_modules` against `resolveDir`.
+const MODULES: Record<string, { contents: string; tsx: boolean }> = {
+  entry: { contents: entrySrc, tsx: true },
+  mount: { contents: mountSrc, tsx: true },
+  Loader: { contents: loaderSrc, tsx: true },
+  bridge: { contents: bridgeSrc, tsx: false },
+  store: { contents: storeSrc, tsx: false },
+  types: { contents: typesSrc, tsx: false },
+};
+
+// Walk up from the compiled plugin to find a `node_modules` containing
+// `solid-js` (a dependency of this package). Used as esbuild's `resolveDir`.
+const resolveDir = dirname(fileURLToPath(import.meta.url));
+
+/**
+ * Compile the loader-app from its inlined raw sources into a single
+ * self-contained IIFE (Solid runtime bundled in) suitable for inlining into
+ * `index.html`. Mirrors dx-compile's Solid pipeline: `@babel/preset-typescript`
+ * strips types, then `babel-preset-solid` compiles JSX into reactive primitives.
+ */
+const compileLoaderBundle = async (): Promise<string> => {
+  const virtualSolid = (): EsbuildPlugin => ({
+    name: 'boot-loader-app-virtual',
+    setup: (esbuild) => {
+      esbuild.onResolve({ filter: /^\.\// }, (args) => {
+        const name = args.path.replace(/^\.\//, '').replace(/\.(tsx?|jsx?)$/, '');
+        return name in MODULES ? { path: name, namespace: VIRTUAL_NS } : undefined;
+      });
+
+      esbuild.onLoad({ filter: /.*/, namespace: VIRTUAL_NS }, async (args) => {
+        const module = MODULES[args.path];
+        const result = await babel.transformAsync(module.contents, {
+          filename: `${args.path}.${module.tsx ? 'tsx' : 'ts'}`,
+          babelrc: false,
+          configFile: false,
+          // Presets run last-to-first: TS strips first, then Solid sees plain JSX.
+          presets: [
+            [babelPresetSolid, { generate: 'dom', hydratable: false }],
+            [babelPresetTypeScript, { allowDeclareFields: true }],
+          ],
+        });
+        if (!result?.code) {
+          throw new Error(`babel-preset-solid returned no code for ${args.path}`);
+        }
+        return { contents: result.code, loader: 'js', resolveDir };
+      });
+    },
+  });
+
+  const result = await build({
+    stdin: { contents: "import './entry';", loader: 'ts', resolveDir, sourcefile: 'boot-loader-entry.ts' },
+    bundle: true,
+    format: 'iife',
+    platform: 'browser',
+    target: 'es2020',
+    minify: true,
+    write: false,
+    legalComments: 'none',
+    define: { 'process.env.NODE_ENV': '"production"' },
+    plugins: [virtualSolid()],
+  });
+
+  return result.outputFiles[0].text;
+};
+
+let bundlePromise: Promise<string> | undefined;
+const getLoaderBundle = (): Promise<string> => (bundlePromise ??= compileLoaderBundle());
+
 /**
- * Vite plugin that injects a tiny native-DOM "boot loader" into the host app's
+ * Vite plugin that injects a Solid "boot loader" app into the host app's
  * `index.html`.
  *
- * The loader paints on the very first frame, before any JS bundle is fetched —
- * so the user sees something immediately on cold load instead of staring at a
- * blank document while the compiled module graph is parsed. The brand mark
- * sits centred inside a thin determinate progress ring; both layers are
- * composited so the ring's fill stays visually smooth even while the JS main
- * thread is busy.
+ * The full-screen backdrop paints on the very first frame from an inline
+ * `<style>` (before any JS bundle is fetched), so the user sees the loading
+ * surface immediately on cold load instead of a blank document. A compiled,
+ * self-contained Solid IIFE — inlined ahead of the app bundle — then renders
+ * the determinate progress ring + status log into that backdrop and exposes the
+ * host-facing driver on `window.__bootLoader`.
  *
- * The host app drives the loader from `main.tsx`:
- * - `window.__bootLoader.status(text)` updates the status line per phase.
+ * The host app drives the loader (the React relay forwards `useApp`'s startup
+ * progress):
+ * - `window.__bootLoader.status(payload)` updates the status line per phase.
  * - `window.__bootLoader.progress(fraction)` grows the determinate ring (0–1).
- * - `window.__bootLoader.dismiss()` removes the loader once React has mounted.
+ * - `window.__bootLoader.ready()` plays the dismissal outro, then self-removes.
+ * - `window.__bootLoader.dismiss()` removes the loader immediately (fast path).
  *
- * Inject order:
+ * Inject order (all at the start of `<body>`, except the stylesheet):
  * - `<style>` → `<head>` (parses before any bundled stylesheet).
- * - `<div id="boot-loader">…</div>` → start of `<body>` (sibling of `#root`).
- * - inline `<script>` defining `window.__bootLoader` → start of `<body>`.
+ * - `<div id="boot-loader">` → the static backdrop the CSS styles instantly.
+ * - inline `<script>` config (`window.__BOOT_LOADER_CONFIG__`) → before the bundle.
+ * - inline `<script>` loader bundle → renders the Solid app into the backdrop.
  *
- * Keeping the loader as a sibling of `#root` (rather than a child of it) means
+ * Keeping the loader a sibling of `#root` (rather than a child) means
  * `createRoot(document.getElementById('root')).render(...)` does not fight the
- * loader for ownership; the host explicitly calls `dismiss()` after the first
- * React commit, which gives a deterministic handoff.
+ * loader for ownership; the framework explicitly dismisses after the first
+ * React commit for a deterministic handoff.
  *
  * Color tokens are exposed as CSS custom properties (`--boot-loader-bg-light`,
- * `--boot-loader-bg-dark`, etc.) defined in `boot-loader.css`, so consumers can
- * override them at the document level without us re-parameterizing this plugin.
+ * etc.) in `boot-loader.css`, so consumers can override them at the document
+ * level without re-parameterizing this plugin.
  */
 export const bootLoaderPlugin = ({ status, markSvg }: BootLoaderOptions = {}): Plugin => {
   return {
     name: 'app-framework:boot-loader',
-    transformIndexHtml() {
-      // The mark slot uses `children: <raw-svg>` (vite emits string children as
-      // raw HTML, not text-escaped) so the host can pass an SVG file's contents
-      // straight through. The mark and ring are siblings inside `#boot-loader-disc`
-      // so CSS grid-stacking can centre the mark inside the ring without the ring's
-      // radial-gradient mask clipping the SVG.
-      const markChildren = markSvg ? [{ tag: 'div', attrs: { id: 'boot-loader-mark' }, children: markSvg }] : [];
-
+    async transformIndexHtml() {
+      const bundle = await getLoaderBundle();
+      // Authoritative backdrop id: injected here, passed to the bundle via
+      // config (so `entry.tsx` reads it), and mirrored by the CSS selector in
+      // `boot-loader.css`. The inner DOM ↔ CSS contract is guarded by the story.
+      const rootId = 'boot-loader';
       return [
         {
           tag: 'style',
@@ -78,44 +170,22 @@ export const bootLoaderPlugin = ({ status, markSvg }: BootLoaderOptions = {}): P
           tag: 'div',
           injectTo: 'body-prepend',
           attrs: {
-            id: 'boot-loader',
+            id: rootId,
             role: 'status',
             'aria-live': 'polite',
             'aria-label': 'Initializing',
           },
-          children: [
-            {
-              tag: 'div',
-              attrs: { id: 'boot-loader-disc' },
-              children: [
-                { tag: 'div', attrs: { id: 'boot-loader-bar' }, children: '' },
-                { tag: 'div', attrs: { id: 'boot-loader-dot' }, children: '' },
-                ...markChildren,
-              ],
-            },
-            {
-              tag: 'div',
-              attrs: { id: 'boot-loader-status' },
-              children: [
-                {
-                  tag: 'div',
-                  attrs: { id: 'boot-loader-status-fade' },
-                },
-                {
-                  tag: 'div',
-                  attrs: { id: 'boot-loader-status-track' },
-                  children: status
-                    ? [{ tag: 'div', attrs: { class: 'boot-loader-status-line' }, children: status }]
-                    : [],
-                },
-              ],
-            },
-          ],
+          children: '',
+        },
+        {
+          tag: 'script',
+          injectTo: 'body-prepend',
+          children: `window.__BOOT_LOADER_CONFIG__=${JSON.stringify({ rootId, markSvg, status })};`,
         },
         {
           tag: 'script',
           injectTo: 'body-prepend',
-          children: driverScript,
+          children: bundle,
         },
       ];
     },

package/src/vite-plugin/manifest.test.ts

@@ -4,12 +4,22 @@
 
 import { describe, test } from 'vitest';
 
-import { serializeManifest } from './manifest';
+import { DXN } from '@dxos/keys';
+
+import { Plugin } from '../core';
+import { type BuildMeta, serializeManifest } from './manifest';
+
+// Build a `BuildMeta` (runtime `Meta` plus the build-time `version`, which may be a
+// non-semver dev tag and so lives outside the `key` DXN).
+const buildMeta = (options: Plugin.MakeMetaOptions, version: string): BuildMeta => ({
+  ...Plugin.makeMeta(options),
+  version,
+});
 
 describe('serializeManifest', () => {
   test('serializes plugin meta plus assets', ({ expect }) => {
     const json = serializeManifest(
-      { id: 'org.example.plugin', name: 'Example', description: 'Demo', tags: ['new'], version: '1.2.3' },
+      buildMeta({ key: DXN.make('org.example.plugin'), name: 'Example', description: 'Demo', tags: ['new'] }, '1.2.3'),
       { assets: ['index.mjs', 'style.css', 'chunks/lib-abc.js'] },
     );
     expect(JSON.parse(json)).toEqual({
@@ -23,10 +33,10 @@ describe('serializeManifest', () => {
   });
 
   test('includes devEntry when supplied (dev-server manifest)', ({ expect }) => {
-    const json = serializeManifest(
-      { id: 'org.example.plugin', name: 'Example', version: '0.0.0-dev' },
-      { assets: [], devEntry: 'src/plugin.tsx' },
-    );
+    const json = serializeManifest(buildMeta({ key: DXN.make('org.example.plugin'), name: 'Example' }, '0.0.0-dev'), {
+      assets: [],
+      devEntry: 'src/plugin.tsx',
+    });
     expect(JSON.parse(json)).toEqual({
       id: 'org.example.plugin',
       name: 'Example',
@@ -37,10 +47,9 @@ describe('serializeManifest', () => {
   });
 
   test('omits devEntry from the output when undefined', ({ expect }) => {
-    const json = serializeManifest(
-      { id: 'org.example.plugin', name: 'Example', version: '1.0.0' },
-      { assets: ['index.mjs'] },
-    );
+    const json = serializeManifest(buildMeta({ key: DXN.make('org.example.plugin'), name: 'Example' }, '1.0.0'), {
+      assets: ['index.mjs'],
+    });
     expect(Object.keys(JSON.parse(json))).not.toContain('devEntry');
   });
 });

package/src/vite-plugin/manifest.ts

@@ -45,13 +45,19 @@ export type BuildMeta = Plugin.Meta & { version: string };
 export const serializeManifest = (
   meta: BuildMeta,
   { assets, devEntry }: { assets: readonly string[]; devEntry?: string },
-): string =>
-  JSON.stringify(
+): string => {
+  // The published manifest is keyed by the bare NSID `id`; the `key` DXN is an
+  // in-process convenience and is intentionally omitted to keep the registry
+  // wire-format stable. `version` is the build-time package version (may be a
+  // non-semver dev tag), carried by `BuildMeta` rather than derived from `key`.
+  const { key: _key, ...rest } = meta;
+  return JSON.stringify(
     {
-      ...meta,
+      ...rest,
       assets,
       ...(devEntry !== undefined ? { devEntry } : {}),
     },
     null,
     2,
   );
+};

package/tsconfig.json

@@ -2,7 +2,9 @@
   "extends": "../../../tsconfig.base.json",
   "compilerOptions": {},
   "exclude": [
-    "/node_modules/"
+    "/node_modules/",
+    "src/**/*.solid-stories.tsx",
+    "src/vite-plugin/boot-loader/loader-app"
   ],
   "include": [
     "src"
@@ -26,6 +28,9 @@
     {
       "path": "../../common/invariant"
     },
+    {
+      "path": "../../common/keys"
+    },
     {
       "path": "../../common/log"
     },
@@ -53,15 +58,9 @@
     {
       "path": "../../core/compute/compute"
     },
-    {
-      "path": "../../core/compute/functions"
-    },
     {
       "path": "../../core/compute/operation"
     },
-    {
-      "path": "../../core/echo/echo"
-    },
     {
       "path": "../../core/echo/echo-db"
     },

package/dist/lib/browser/chunk-BRK6GYNB.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/plugin-process-manager/history/errors.ts", "../../../src/plugin-process-manager/history/undo-mapping.ts", "../../../src/plugin-process-manager/history/undo-registry.ts", "../../../src/plugin-process-manager/history/history-tracker.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { BaseError } from '@dxos/errors';\n\nexport class EmptyHistoryError extends BaseError.extend('EmptyHistoryError', 'Cannot undo: history is empty.') {}\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport type { Operation } from '@dxos/compute';\n\n/**\n * Label type for translatable text (canonical definition in @dxos/app-toolkit).\n */\ntype Label = string | [string, { ns: string; count?: number; defaultValue?: string }];\n\n/**\n * Extract the input type from an OperationDefinition.\n */\nexport type InputOf<T> = T extends Operation.Definition<infer I, any> ? I : never;\n\n/**\n * Extract the output type from an OperationDefinition.\n */\nexport type OutputOf<T> = T extends Operation.Definition<any, infer O> ? O : never;\n\n/**\n * Message provider for undo toast.\n * Can be a static Label or a function that derives the message from input/output.\n */\nexport type MessageProvider<Op extends Operation.Definition<any, any>> =\n  | Label\n  | ((input: InputOf<Op>, output: OutputOf<Op>) => Label);\n\n/**\n * Undo mapping that links a forward operation to its inverse.\n * Type parameters ensure deriveContext has correctly typed arguments.\n *\n * @template Op - The forward operation definition type.\n * @template Inv - The inverse operation definition type.\n */\nexport interface UndoMapping<\n  Op extends Operation.Definition<any, any> = Operation.Definition<any, any>,\n  Inv extends Operation.Definition<any, any> = Operation.Definition<any, any>,\n> {\n  /** The forward operation. */\n  readonly operation: Op;\n\n  /** The inverse operation to invoke for undo. */\n  readonly inverse: Inv;\n\n  /**\n   * Derives the input for the inverse operation from the forward operation's input and output.\n   * @param input - The input that was passed to the forward operation.\n   * @param output - The output that was returned by the forward operation.\n   * @returns The input to pass to the inverse operation, or undefined to indicate the operation is not undoable.\n   */\n  readonly deriveContext: (input: InputOf<Op>, output: OutputOf<Op>) => InputOf<Inv> | undefined;\n\n  /**\n   * Optional message to show in the undo toast.\n   * Can be a static Label or a function that derives the message from input/output.\n   */\n  readonly message?: MessageProvider<Op>;\n}\n\n/**\n * Props for creating an UndoMapping.\n */\nexport interface UndoMappingProps<\n  Op extends Operation.Definition<any, any>,\n  Inv extends Operation.Definition<any, any>,\n> {\n  /** The forward operation. */\n  operation: Op;\n\n  /** The inverse operation to invoke for undo. */\n  inverse: Inv;\n\n  /**\n   * Derives the input for the inverse operation from the forward operation's input and output.\n   * Return undefined to indicate the operation is not undoable.\n   */\n  deriveContext: (input: InputOf<Op>, output: OutputOf<Op>) => InputOf<Inv> | undefined;\n\n  /**\n   * Optional message to show in the undo toast.\n   * Can be a static Label or a function that derives the message from input/output.\n   */\n  message?: MessageProvider<Op>;\n}\n\n/**\n * Creates a type-safe undo mapping.\n *\n * @example\n * ```ts\n * // Static message\n * const mapping = UndoMapping.make({\n *   operation: DeleteThread,\n *   inverse: RestoreThread,\n *   deriveContext: (input, output) => ({\n *     thread: output.thread,\n *     anchor: output.anchor,\n *   }),\n *   message: ['thread deleted label', { ns: '@dxos/plugin-thread' }],\n * });\n *\n * // Dynamic message based on input/output\n * const mapping = UndoMapping.make({\n *   operation: RemoveObjects,\n *   inverse: RestoreObjects,\n *   deriveContext: (_input, output) => output,\n *   message: (input, _output) =>\n *     input.objects.length === 1\n *       ? ['object deleted label', { ns: getTypename(input.objects[0]) }]\n *       : ['objects deleted label', { ns: '@dxos/plugin-space' }],\n * });\n * ```\n */\nexport const make = <Op extends Operation.Definition<any, any>, Inv extends Operation.Definition<any, any>>(\n  props: UndoMappingProps<Op, Inv>,\n): UndoMapping<Op, Inv> => props;\n\n/**\n * Resolves a message provider to a Label.\n */\nexport const resolveMessage = <Op extends Operation.Definition<any, any>>(\n  message: MessageProvider<Op> | undefined,\n  input: InputOf<Op>,\n  output: OutputOf<Op>,\n): Label | undefined => {\n  if (message === undefined) {\n    return undefined;\n  }\n  if (typeof message === 'function') {\n    return message(input, output);\n  }\n  return message;\n};\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport type { Operation } from '@dxos/compute';\n\nimport type * as UndoMapping from './undo-mapping';\n\n//\n// Public Interface\n//\n\n/**\n * Lookup result from UndoRegistry.\n */\nexport type UndoMappingResult = {\n  inverse: Operation.Definition<any, any>;\n  /** Returns undefined to indicate the operation is not undoable. */\n  deriveContext: (input: any, output: any) => any | undefined;\n  /** Message provider - may be a static Label or a function. */\n  message?: UndoMapping.MessageProvider<Operation.Definition<any, any>>;\n};\n\n/**\n * UndoRegistry interface - looks up inverse operations.\n */\nexport interface UndoRegistry {\n  lookup: (operation: Operation.Definition<any, any>) => UndoMappingResult | undefined;\n}\n\n//\n// Factory\n//\n\n/**\n * Creates an UndoRegistry that looks up inverse operations.\n */\nexport const make = (getMappings: () => UndoMapping.UndoMapping[]): UndoRegistry => {\n  const lookup = (operation: Operation.Definition<any, any>): UndoMappingResult | undefined => {\n    const mappings = getMappings();\n    const mapping = mappings.find((m) => m.operation.meta.key === operation.meta.key);\n    if (!mapping) {\n      return undefined;\n    }\n\n    return {\n      inverse: mapping.inverse,\n      deriveContext: mapping.deriveContext,\n      message: mapping.message,\n    };\n  };\n\n  return { lookup };\n};\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\nimport * as Stream from 'effect/Stream';\n\nimport { runAndForwardErrors } from '@dxos/effect';\nimport { log } from '@dxos/log';\nimport { OperationInvoker } from '@dxos/operation';\n\nimport { UndoOperation } from '../../common';\nimport { EmptyHistoryError } from './errors';\nimport type { HistoryEntry } from './types';\nimport { resolveMessage } from './undo-mapping';\nimport type { UndoRegistry } from './undo-registry';\n\nconst HISTORY_LIMIT = 100;\n\n//\n// Public Interface\n//\n\n/**\n * HistoryTracker interface - tracks operation history and provides undo.\n */\nexport interface HistoryTracker {\n  undo: () => Effect.Effect<void, Error>;\n  undoPromise: () => Promise<{ error?: Error }>;\n  canUndo: () => boolean;\n}\n\n//\n// Factory\n//\n\n/**\n * Creates a HistoryTracker that subscribes to invocation events and provides undo.\n */\nexport const make = (\n  invoker: OperationInvoker.OperationInvokerInternal,\n  undoRegistry: UndoRegistry,\n): HistoryTracker => {\n  const history: HistoryEntry[] = [];\n\n  // Subscribe to invocation stream.\n  const handleInvocation = (event: OperationInvoker.InvocationEvent) => {\n    const mapping = undoRegistry.lookup(event.operation);\n    if (!mapping) {\n      // Operation is not undoable, skip.\n      return;\n    }\n\n    const inverseInput = mapping.deriveContext(event.input, event.output);\n    if (inverseInput === undefined) {\n      // Operation is conditionally not undoable (deriveContext returned undefined).\n      log('operation not undoable', { key: event.operation.meta.key });\n      return;\n    }\n\n    const entry: HistoryEntry = {\n      operation: event.operation,\n      input: event.input,\n      output: event.output,\n      inverse: mapping.inverse,\n      inverseInput,\n      timestamp: event.timestamp,\n    };\n\n    history.push(entry);\n    log('history entry added', { key: event.operation.meta.key, historyLength: history.length });\n\n    // Trim history if it exceeds limit.\n    if (history.length > HISTORY_LIMIT) {\n      history.splice(0, history.length - HISTORY_LIMIT);\n    }\n\n    // Show undo toast (resolve message if it's a function).\n    const resolvedMessage = resolveMessage(mapping.message, event.input, event.output);\n    Effect.runFork(\n      invoker.invoke(UndoOperation.ShowUndo, {\n        message: resolvedMessage,\n      }),\n    );\n  };\n\n  // Fork a fiber to consume the invocation stream.\n  Effect.runFork(\n    Stream.fromPubSub(invoker.invocations).pipe(\n      Stream.runForEach((event) => Effect.sync(() => handleInvocation(event))),\n    ),\n  );\n\n  const undo = (): Effect.Effect<void, Error> => {\n    return Effect.gen(function* () {\n      const entry = history.pop();\n      if (!entry) {\n        return yield* Effect.fail(new EmptyHistoryError());\n      }\n\n      log('undoing operation', { key: entry.operation.meta.key, inverseKey: entry.inverse.meta.key });\n\n      // Use _invokeCore to skip event emission (avoid undo-of-undo loops).\n      yield* invoker._invokeCore(entry.inverse, entry.inverseInput);\n\n      log('undo completed', { key: entry.operation.meta.key });\n    });\n  };\n\n  const undoPromise = async (): Promise<{ error?: Error }> => {\n    return runAndForwardErrors(undo())\n      .then(() => ({}))\n      .catch((error) => {\n        log.catch(error);\n        return { error };\n      });\n  };\n\n  const canUndo = (): boolean => {\n    return history.length > 0;\n  };\n\n  return {\n    undo,\n    undoPromise,\n    canUndo,\n  };\n};\n"],
-  "mappings": "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",
-  "names": ["BaseError", "EmptyHistoryError", "extend", "make", "props", "resolveMessage", "message", "input", "output", "undefined", "make", "getMappings", "lookup", "operation", "mappings", "mapping", "find", "m", "meta", "key", "undefined", "inverse", "deriveContext", "message", "make", "Effect", "Stream", "runAndForwardErrors", "log", "HISTORY_LIMIT", "make", "handleInvocation", "log", "input", "event", "output", "inverse", "mapping", "inverseInput", "timestamp", "history", "entry", "key", "operation", "historyLength", "length", "message", "resolvedMessage", "Effect", "fail", "inverseKey", "invoker", "_invokeCore", "meta", "error", "undoPromise", "canUndo"]
-}