@dxos/app-framework 0.8.4-main.a4bbb77 → 0.8.4-main.abd8ff62ef

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,sBA4CnF,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,52 @@
+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=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,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,gBAAgB,yBAAyB,iBAAiB,KAAQ,MAmD9E,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 `3967`. */
+    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;AAEjD,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,2CAA2C;IAC3C,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,EAqL1E,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;AAgUnC;;;;;;;;;;;;;;;;;;;;;;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,37 @@
+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. The entry module is always {@link ENTRY_FILENAME}; it
+ * must appear in `assets`.
+ *
+ * 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 }: {
+    assets: readonly 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;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,iBAAiB,SAAU,SAAS,cAAc;IAAE,MAAM,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,KAAG,MAQ5F,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,UAqI5B,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,OAAQ,MAAM,KAAG,OAC2B,CAAC"}