@dxos/app-framework 0.8.4-main.dedc0f3 → 0.8.4-main.dfabb4ec29

package/dist/types/src/ui/hooks/useApp.d.ts

@@ -0,0 +1,89 @@
+import React, { type FC } from 'react';
+import { type FallbackProps } from '@dxos/react-error-boundary';
+import { type ActivationEvent, type Plugin, PluginManager } from '../../core';
+export type StartupProgress = {
+    /** Number of modules that have been activated. */
+    activated: number;
+    /** Total number of modules registered. */
+    total: number;
+    /** Fractional progress (0-1). */
+    progress: number;
+    /**
+     * Raw activation event key (e.g. `org.dxos.app-framework.event.startup`).
+     * Set on event-level transitions, *and* on module-level transitions where
+     * it carries the parent activation event that first triggered the
+     * module's load (plumbed through `_loadCapabilitiesForModules` →
+     * `_loadModule`). Consumers can use this either as the primary id (when
+     * {@link module} is absent) or as an extra "context" field alongside
+     * {@link module}.
+     */
+    event?: string;
+    /**
+     * Raw module id (e.g. `org.dxos.plugin.observability.module.ReactSurface`)
+     * when the in-flight activation is module-level. When present,
+     * {@link event} may also be set, identifying the parent activation that
+     * triggered this module's load.
+     */
+    module?: string;
+    /**
+     * Pre-humanized label for the currently surfaced transition (module
+     * label if {@link module} is set, otherwise the event label), supplied
+     * for consumers that want a sensible default. Hosts that prefer to
+     * render their own label can read the raw {@link event}/{@link module}
+     * fields and ignore this — the framework leaves the policy choice
+     * (which transitions to surface, how to format them, whether to drop
+     * sub-modules entirely) to the host's `Placeholder`.
+     */
+    humanizedName?: string;
+};
+export type PlaceholderProps = {
+    stage?: number;
+    progress?: StartupProgress;
+};
+export type UseAppOptions = {
+    pluginManager?: PluginManager.PluginManager;
+    pluginLoader?: PluginManager.ManagerOptions['pluginLoader'];
+    onPluginRemove?: PluginManager.ManagerOptions['onRemove'];
+    pluginRegistryProvider?: PluginManager.ManagerOptions['pluginRegistryProvider'];
+    plugins?: Plugin.Plugin[];
+    core?: string[];
+    defaults?: string[];
+    /**
+     * Additional activation events to fire before startup.
+     * These are fired alongside SetupReactSurface before the Startup event.
+     */
+    setupEvents?: ActivationEvent.ActivationEvent[];
+    cacheEnabled?: boolean;
+    safeMode?: boolean;
+    debounce?: number;
+    timeout?: number;
+    fallback?: FC<FallbackProps>;
+    placeholder?: FC<PlaceholderProps>;
+};
+/**
+ * Expected usage is for this to be the entrypoint of the application.
+ * Initializes plugins and renders the root components.
+ *
+ * @example
+ * const plugins = [LayoutPlugin(), MyPlugin()];
+ * const core = [LayoutPluginId];
+ * const default = [MyPluginId];
+ * const fallback = <div>Initializing Plugins...</div>;
+ * const App = useApp({ plugins, core, default, fallback });
+ * createRoot(document.getElementById('root')!).render(
+ *   <StrictMode>
+ *     <App />
+ *   </StrictMode>,
+ * );
+ *
+ * @param params.pluginLoader A function which loads new plugins.
+ * @param params.plugins All plugins available to the application.
+ * @param params.core Core plugins which will always be enabled.
+ * @param params.defaults Default plugins are enabled by default but can be disabled by the user.
+ * @param params.cacheEnabled Whether to cache enabled plugins in localStorage.
+ * @param params.safeMode Whether to enable safe mode, which disables optional plugins.
+ * @param params.fallback Fallback component to render if an error occurs during startup.
+ * @param params.placeholder Placeholder component to render during startup.
+ */
+export declare const useApp: ({ pluginManager, pluginLoader: pluginLoaderProp, onPluginRemove, pluginRegistryProvider, plugins: pluginsProp, core: coreProp, defaults: defaultsProp, setupEvents: setupEventsProp, placeholder, fallback, cacheEnabled, safeMode, debounce, timeout, }: UseAppOptions) => () => React.JSX.Element;
+//# sourceMappingURL=useApp.d.ts.map

package/dist/types/src/ui/hooks/useApp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useApp.d.ts","sourceRoot":"","sources":["../../../../../src/ui/hooks/useApp.tsx"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,EAAE,KAAK,EAAE,EAAqD,MAAM,OAAO,CAAC;AAK1F,OAAO,EAAgC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAM9F,OAAO,EAAE,KAAK,eAAe,EAAE,KAAK,MAAM,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAK9E,MAAM,MAAM,eAAe,GAAG;IAC5B,kDAAkD;IAClD,SAAS,EAAE,MAAM,CAAC;IAClB,0CAA0C;IAC1C,KAAK,EAAE,MAAM,CAAC;IACd,iCAAiC;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;;;;;OAQG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;;OAKG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;;;;OAQG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,eAAe,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,aAAa,CAAC,EAAE,aAAa,CAAC,aAAa,CAAC;IAC5C,YAAY,CAAC,EAAE,aAAa,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC;IAC5D,cAAc,CAAC,EAAE,aAAa,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;IAC1D,sBAAsB,CAAC,EAAE,aAAa,CAAC,cAAc,CAAC,wBAAwB,CAAC,CAAC;IAChF,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC;IAC1B,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB;;;OAGG;IACH,WAAW,CAAC,EAAE,eAAe,CAAC,eAAe,EAAE,CAAC;IAChD,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,EAAE,CAAC,aAAa,CAAC,CAAC;IAC7B,WAAW,CAAC,EAAE,EAAE,CAAC,gBAAgB,CAAC,CAAC;CACpC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,MAAM,6PAehB,aAAa,4BAkOf,CAAC"}

package/dist/types/src/ui/hooks/useApp.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=useApp.test.d.ts.map

package/dist/types/src/ui/hooks/useApp.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useApp.test.d.ts","sourceRoot":"","sources":["../../../../../src/ui/hooks/useApp.test.tsx"],"names":[],"mappings":""}

package/dist/types/src/ui/hooks/useCapabilities.d.ts

@@ -0,0 +1,31 @@
+import { type Atom } from '@effect-atom/atom-react';
+import { Capabilities } from '../../common';
+import { type Capability } from '../../core';
+/**
+ * Hook to request capabilities from the plugin context.
+ * @returns An array of capabilities.
+ */
+export declare const useCapabilities: <T>(interfaceDef: Capability.InterfaceDef<T>) => T[];
+/**
+ * Hook to request a capability from the plugin context.
+ * @returns The capability.
+ * @throws If no capability is found.
+ */
+export declare const useCapability: <T>(interfaceDef: Capability.InterfaceDef<T>) => T;
+/**
+ * Hook to get the current value of an atom capability.
+ * Automatically subscribes to changes.
+ * @example const settings = useAtomCapability(ThreadCapabilities.Settings);
+ */
+export declare const useAtomCapability: <T>(atomCapability: Capability.InterfaceDef<Atom.Atom<T>>) => T;
+/**
+ * Hook to get value and updater for an atom capability.
+ * Returns [currentValue, updateFn] similar to useState.
+ * @example const [settings, updateSettings] = useAtomCapabilityState(ThreadCapabilities.Settings);
+ */
+export declare const useAtomCapabilityState: <T>(atomCapability: Capability.InterfaceDef<Atom.Writable<T>>) => [T, (fn: (current: T) => T) => void];
+/**
+ * Hook to get the operation invoker capability.
+ */
+export declare const useOperationInvoker: () => Capabilities.OperationInvoker;
+//# sourceMappingURL=useCapabilities.d.ts.map

package/dist/types/src/ui/hooks/useCapabilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCapabilities.d.ts","sourceRoot":"","sources":["../../../../../src/ui/hooks/useCapabilities.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,IAAI,EAAgB,MAAM,yBAAyB,CAAC;AAKlE,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AAG7C;;;GAGG;AACH,eAAO,MAAM,eAAe,GAAI,CAAC,gBAAgB,UAAU,CAAC,YAAY,CAAC,CAAC,CAAC,QAG1E,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,aAAa,GAAI,CAAC,gBAAgB,UAAU,CAAC,YAAY,CAAC,CAAC,CAAC,MAIxE,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAAI,CAAC,kBAAkB,UAAU,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,KAAG,CAG5F,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,GAAI,CAAC,kBACtB,UAAU,CAAC,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,KACxD,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC,KAAK,IAAI,CAWrC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,mBAAmB,QAAO,YAAY,CAAC,gBAAgE,CAAC"}

package/dist/types/src/{components → ui/hooks}/useLoading.d.ts

@@ -1,4 +1,3 @@
-import { type AppProps } from './App';
 export declare enum LoadingState {
     Loading = 0,
     FadeIn = 1,
@@ -15,5 +14,5 @@ export declare enum LoadingState {
  * 2: Fade-out  - Fade out the loading animation.
  * 3: Done      - Remove the placeholder.
  */
-export declare const useLoading: (state: AppProps["state"], debounce?: number) => LoadingState;
+export declare const useLoading: (ready: boolean, debounce?: number) => LoadingState;
 //# sourceMappingURL=useLoading.d.ts.map

package/dist/types/src/ui/hooks/useLoading.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLoading.d.ts","sourceRoot":"","sources":["../../../../../src/ui/hooks/useLoading.tsx"],"names":[],"mappings":"AAMA,oBAAY,YAAY;IACtB,OAAO,IAAI;IACX,MAAM,IAAI;IACV,OAAO,IAAI;IACX,IAAI,IAAI;CACT;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,UAAU,UAAW,OAAO,oCAoDxC,CAAC"}

package/dist/types/src/ui/hooks/useSettingsState.d.ts

@@ -0,0 +1,10 @@
+import { type Atom } from '@effect-atom/atom-react';
+/**
+ * Hook to read and update a settings atom.
+ * Returns the current value and an update function.
+ */
+export declare const useSettingsState: <T>(atom: Atom.Writable<T>) => {
+    settings: T;
+    updateSettings: (fn: (current: T) => T) => void;
+};
+//# sourceMappingURL=useSettingsState.d.ts.map

package/dist/types/src/ui/hooks/useSettingsState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSettingsState.d.ts","sourceRoot":"","sources":["../../../../../src/ui/hooks/useSettingsState.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,IAAI,EAAiC,MAAM,yBAAyB,CAAC;AAGnF;;;GAGG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,QAC1B,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,KACrB;IAAE,QAAQ,EAAE,CAAC,CAAC;IAAC,cAAc,EAAE,CAAC,EAAE,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC,KAAK,IAAI,CAAA;CAYhE,CAAC"}

package/dist/types/src/ui/hooks/useSurface.d.ts

@@ -0,0 +1,3 @@
+import { Surface } from '../components';
+export declare const useSurface: () => Surface.Context;
+//# sourceMappingURL=useSurface.d.ts.map

package/dist/types/src/ui/hooks/useSurface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSurface.d.ts","sourceRoot":"","sources":["../../../../../src/ui/hooks/useSurface.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAExC,eAAO,MAAM,UAAU,QAAO,OAAO,CAAC,OAErC,CAAC"}

package/dist/types/src/ui/index.d.ts

@@ -0,0 +1,3 @@
+export * from './components';
+export * from './hooks';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/src/ui/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/ui/index.ts"],"names":[],"mappings":"AAIA,cAAc,cAAc,CAAC;AAC7B,cAAc,SAAS,CAAC"}

package/dist/types/src/vite-plugin/boot-loader/BootLoader.stories.d.ts

@@ -0,0 +1,34 @@
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import React from 'react';
+/**
+ * Storybook host that runs the **real** inline driver script (`boot-loader.js`)
+ * against the same DOM structure {@link bootLoaderPlugin} injects in production
+ * via `transformIndexHtml`. The component injects `<style>` + the loader DOM,
+ * evaluates the driver, and exposes `window.__bootLoader` for the stories to
+ * call — no React reimplementation of the state machine.
+ *
+ * On unmount, the host calls `__bootLoader.dismiss()` (which clears the creep
+ * timer and removes the `#boot-loader` node) and clears the global so a fresh
+ * mount re-runs the driver from scratch.
+ */
+type BootLoaderHostProps = {
+    initialStatus?: string;
+    markSvg?: string;
+};
+declare const BootLoaderHost: ({ initialStatus, markSvg }: BootLoaderHostProps) => React.JSX.Element;
+declare const meta: Meta<typeof BootLoaderHost>;
+export default meta;
+type Story = StoryObj<typeof BootLoaderHost>;
+export declare const Default: Story;
+/**
+ * Renders the React `Placeholder` from `@dxos/app-framework/ui` on its own —
+ * useful for eyeballing the handoff target the boot loader dismisses to.
+ */
+export declare const PlaceholderHandoff: Story;
+/**
+ * End-to-end handoff sim: the driver ticks 0 → 100% then the host calls
+ * `dismiss()` and the underlying `Placeholder` fades the mark in / out,
+ * mirroring the production sequence.
+ */
+export declare const Handoff: Story;
+//# sourceMappingURL=BootLoader.stories.d.ts.map

package/dist/types/src/vite-plugin/boot-loader/BootLoader.stories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BootLoader.stories.d.ts","sourceRoot":"","sources":["../../../../../src/vite-plugin/boot-loader/BootLoader.stories.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,IAAI,EAAE,KAAK,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACjE,OAAO,KAAsC,MAAM,OAAO,CAAC;AAU3D;;;;;;;;;;GAUG;AACH,KAAK,mBAAmB,GAAG;IACzB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAMF,QAAA,MAAM,cAAc,+BAA6C,mBAAmB,sBAmDnF,CAAC;AA0IF,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,OAAO,cAAc,CAYrC,CAAC;eAEa,IAAI;AAEnB,KAAK,KAAK,GAAG,QAAQ,CAAC,OAAO,cAAc,CAAC,CAAC;AAE7C,eAAO,MAAM,OAAO,EAAE,KAAU,CAAC;AAEjC;;;GAGG;AACH,eAAO,MAAM,kBAAkB,EAAE,KAGhC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,OAAO,EAAE,KAWrB,CAAC"}

package/dist/types/src/vite-plugin/boot-loader/index.d.ts

@@ -0,0 +1,2 @@
+export * from './loader';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/src/vite-plugin/boot-loader/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/vite-plugin/boot-loader/index.ts"],"names":[],"mappings":"AAIA,cAAc,UAAU,CAAC"}

package/dist/types/src/vite-plugin/boot-loader/loader.d.ts

@@ -0,0 +1,51 @@
+import { type Plugin } from 'vite';
+/**
+ * Options for {@link bootLoaderPlugin}.
+ */
+export type BootLoaderOptions = {
+    /**
+     * Initial status text rendered by the loader (replaced via
+     * `window.__bootLoader.status(...)` once the host starts firing phase callbacks).
+     */
+    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.
+     */
+    markSvg?: string;
+};
+/**
+ * Vite plugin that injects a tiny native-DOM "boot loader" 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 host app drives the loader from `main.tsx`:
+ * - `window.__bootLoader.status(text)` 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.
+ *
+ * Inject order:
+ * - `<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>`.
+ *
+ * Keeping the loader as a sibling of `#root` (rather than a child of it) 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.
+ *
+ * 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.
+ */
+export declare const bootLoaderPlugin: ({ status, markSvg }?: BootLoaderOptions) => Plugin;
+//# sourceMappingURL=loader.d.ts.map

package/dist/types/src/vite-plugin/boot-loader/loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../../../../src/vite-plugin/boot-loader/loader.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,MAAM,CAAC;AAKnC;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,gBAAgB,yBAAyB,iBAAiB,KAAQ,MA+D9E,CAAC"}

package/dist/types/src/vite-plugin/composer/index.d.ts

@@ -0,0 +1,34 @@
+import { type Plugin as VitePlugin } from 'vite';
+import { type BuildMeta, ENTRY_FILENAME, MANIFEST_ASSET_NAME, serializeManifest } from '../manifest';
+export { ENTRY_FILENAME, MANIFEST_ASSET_NAME, serializeManifest };
+export type { BuildMeta };
+export type ComposerPluginOptions = {
+    /** Entry point for the plugin bundle. Defaults to `src/plugin.tsx`. */
+    entry?: string;
+    /** Dev server port. Defaults to {@link PLUGIN_DEV_SERVER_PORT}. */
+    port?: number;
+    /**
+     * Plugin metadata. When provided, a `manifest.json` asset is emitted alongside the bundle
+     * listing every emitted file. The host fetches this manifest at install time and persists
+     * the declared assets in its offline cache so the plugin works without network. The bundle's
+     * entry module is always written as {@link ENTRY_FILENAME} (`index.mjs`).
+     */
+    meta?: BuildMeta;
+};
+/**
+ * Vite plugin for **external Composer plugin projects**. Configures the build to produce
+ * an ESM bundle that externalizes all framework dependencies, which the Composer host app
+ * provides at runtime via import map.
+ *
+ * Handles:
+ * 1. Build config — lib mode entry point, ES format output, rollup externals, code-split chunks.
+ * 2. Dev externalization — marks shared deps as external during `vite serve` and strips
+ *    the `/@id/` prefix that Vite's import analysis adds to external bare specifiers.
+ * 3. JSX dev runtime shim — bridges `react/jsx-dev-runtime` (used by React refresh in dev)
+ *    to `react/jsx-runtime` (which is what the externalized React provides).
+ * 4. Manifest emit — when `meta` is supplied, writes `manifest.json` next to the bundled
+ *    module listing every emitted asset (entry, CSS, chunks, etc.) so the host can eagerly
+ *    cache them for offline use.
+ */
+export declare const composerPlugin: (options?: ComposerPluginOptions) => VitePlugin[];
+//# sourceMappingURL=index.d.ts.map

package/dist/types/src/vite-plugin/composer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/vite-plugin/composer/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,MAAM,IAAI,UAAU,EAAE,MAAM,MAAM,CAAC;AAGjD,OAAO,EAAE,KAAK,SAAS,EAAE,cAAc,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAGrG,OAAO,EAAE,cAAc,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,CAAC;AAClE,YAAY,EAAE,SAAS,EAAE,CAAC;AAwD1B,MAAM,MAAM,qBAAqB,GAAG;IAClC,uEAAuE;IACvE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,mEAAmE;IACnE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;;OAKG;IACH,IAAI,CAAC,EAAE,SAAS,CAAC;CAClB,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,cAAc,aAAc,qBAAqB,KAAG,UAAU,EAiN1E,CAAC"}

package/dist/types/src/vite-plugin/import-map/index.d.ts

@@ -0,0 +1,28 @@
+import { type Plugin } from 'vite';
+/**
+ * Vite plugin for the **host app** (Composer). Generates a browser import map so that
+ * shared packages are loaded once and reused by both the host and any remote plugins.
+ *
+ * In production, emits a dedicated chunk per specifier via virtual wrapper modules,
+ * then injects a `<script type="importmap">` tag into the HTML with the chunk URLs.
+ *
+ * Virtual wrappers are needed because directly emitting chunks for CJS packages loses
+ * their named exports due to Rollup's interop. The wrapper re-exports them explicitly.
+ *
+ * TODO: Restore dev-mode support. The previous dev path mapped each bare specifier to
+ * its absolute `/@fs/` file path during `buildStart`, which forced `this.resolve()` for
+ * hundreds of subpath entrypoints and raced with Vite's optimize-deps static scan —
+ * producing non-deterministic chunk content (~34 chunks drifting per warm-start) and
+ * triggering Vite 8.0.10's `runOptimizer` / `commitProcessing` crashes (`fileHash` /
+ * `browserHash` undefined on partial-discovery batches). Plugin is currently gated to
+ * `apply: 'build'` to avoid both. A working dev-mode implementation would need to
+ * resolve specifiers without participating in the optimize-deps phase — candidates:
+ *   - defer resolution to `transformIndexHtml` (after the optimizer settles)
+ *   - read resolved paths from `environment.depsOptimizer.metadata` rather than calling
+ *     `this.resolve()` ourselves
+ *   - resolve via `require.resolve` directly, bypassing the Vite plugin pipeline entirely
+ */
+export declare const importMapPlugin: (options?: {
+    packages?: string[];
+}) => Plugin[];
+//# sourceMappingURL=index.d.ts.map

package/dist/types/src/vite-plugin/import-map/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/vite-plugin/import-map/index.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,MAAM,CAAC;AAmUnC;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,eAAe,aAAc;IAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,KAAG,MAAM,EA4KzE,CAAC"}

package/dist/types/src/vite-plugin/index.d.ts

@@ -0,0 +1,5 @@
+export * from './boot-loader';
+export * from './composer';
+export * from './import-map';
+export * from './packages';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/src/vite-plugin/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/vite-plugin/index.ts"],"names":[],"mappings":"AAIA,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAG7B,cAAc,YAAY,CAAC"}

package/dist/types/src/vite-plugin/manifest.d.ts

@@ -0,0 +1,41 @@
+import { type Plugin } from '../core';
+/**
+ * Name of the asset written alongside the built module bundle.
+ * The DXOS community registry resolves each published plugin by fetching this file
+ * from the repo's latest GitHub Release, so authors should not rename it.
+ */
+export declare const MANIFEST_ASSET_NAME = "manifest.json";
+/**
+ * Canonical entry filename (re-exported from `@dxos/protocols`) so vite-plugin
+ * consumers don't have to reach into the protocols package directly.
+ */
+export declare const ENTRY_FILENAME = "index.mjs";
+/**
+ * Plugin metadata required to emit a manifest at build time.
+ *
+ * Extends `Plugin.Meta` with a build-time `version` field that is not
+ * relevant to the runtime plugin definition itself.
+ */
+export type BuildMeta = Plugin.Meta & {
+    version: string;
+};
+/**
+ * Serializes a plugin's public metadata + bundle layout into the format consumed
+ * by the host loader (see `UrlLoader.make` and `PluginManifest.parse`).
+ *
+ * The host fetches this manifest, resolves every entry in `assets` against the
+ * manifest URL, and persists them via the platform `PluginAssetCache` so the
+ * plugin works offline. For production builds the entry module is always
+ * {@link ENTRY_FILENAME} and must appear in `assets`. For dev-server manifests
+ * pass `devEntry` (a path relative to the manifest URL) — the host then imports
+ * the entry directly from the dev server and skips offline caching, since the
+ * full asset graph isn't enumerable until build time.
+ *
+ * Exported from a vite-free module so tests and tooling can validate manifests
+ * without paying the cost of loading vite + esbuild.
+ */
+export declare const serializeManifest: (meta: BuildMeta, { assets, devEntry }: {
+    assets: readonly string[];
+    devEntry?: string;
+}) => string;
+//# sourceMappingURL=manifest.d.ts.map

package/dist/types/src/vite-plugin/manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../../../src/vite-plugin/manifest.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,SAAS,CAAC;AAEtC;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,kBAAkB,CAAC;AAEnD;;;GAGG;AACH,eAAO,MAAM,cAAc,cAAwB,CAAC;AAEpD;;;;;GAKG;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,IAAI,GAAG;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAE1D;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,iBAAiB,SACtB,SAAS,wBACO;IAAE,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,KACrE,MASA,CAAC"}

package/dist/types/src/vite-plugin/manifest.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=manifest.test.d.ts.map

package/dist/types/src/vite-plugin/manifest.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.test.d.ts","sourceRoot":"","sources":["../../../../src/vite-plugin/manifest.test.ts"],"names":[],"mappings":""}

package/dist/types/src/vite-plugin/packages.d.ts

@@ -0,0 +1,13 @@
+export declare const DEFAULT_PACKAGES: string[];
+/**
+ * True when the given bare specifier (or one of its subpaths) is provided by the
+ * Composer host at runtime and must not be re-bundled by a plugin.
+ *
+ * Matches only packages listed in {@link DEFAULT_PACKAGES} — the same list
+ * {@link importMapPlugin} consumes — so externalization cannot claim a package
+ * the host isn't actually mapping. Unknown `@dxos/*` packages fall through to
+ * normal bundling, which is the correct default for plugin-owned or yet-to-be
+ * shared workspace packages.
+ */
+export declare const isSharedPackage: (id: string) => boolean;
+//# sourceMappingURL=packages.d.ts.map

package/dist/types/src/vite-plugin/packages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"packages.d.ts","sourceRoot":"","sources":["../../../../src/vite-plugin/packages.ts"],"names":[],"mappings":"AAyCA,eAAO,MAAM,gBAAgB,UAoI5B,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,OAAQ,MAAM,KAAG,OAC2B,CAAC"}