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

package/dist/lib/browser/testing/react.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/testing/react.tsx"],
+  "sourcesContent": ["//\n// Copyright 2026 DXOS.org\n//\n\nimport { RegistryContext } from '@effect-atom/atom-react';\nimport { render as rtlRender, type RenderOptions, type RenderResult } from '@testing-library/react';\nimport React, { type FC, Fragment, type PropsWithChildren, type ReactNode } from 'react';\n\nimport { ContextProtocolProvider } from '@dxos/web-context-react';\n\nimport { Capabilities } from '../common';\nimport { PluginManagerContext } from '../context';\nimport { topologicalSort } from '../helpers';\nimport { PluginManagerProvider } from '../ui/components/PluginManager/PluginManagerProvider';\nimport { SurfaceComponent } from '../ui/components/Surface/SurfaceComponent';\nimport { type TestHarness } from './harness';\n\nexport type HarnessRenderOptions = Omit<RenderOptions, 'wrapper'> & {\n  /** Additional providers to wrap around the harness tree (applied innermost first). */\n  reactContexts?: FC<PropsWithChildren>[];\n};\n\n/**\n * Renders `ui` wrapped in the same provider tree as `useApp` plus every contributed\n * `Capabilities.ReactContext`.\n */\nexport const render = (harness: TestHarness, ui: ReactNode, options?: HarnessRenderOptions): RenderResult => {\n  const { reactContexts = [], ...rest } = options ?? {};\n  const Wrapper = ({ children }: PropsWithChildren) => (\n    <HarnessProviders harness={harness} extra={reactContexts}>\n      {children}\n    </HarnessProviders>\n  );\n  return rtlRender(<>{ui}</>, { ...rest, wrapper: Wrapper });\n};\n\nexport type RenderSurfaceProps = {\n  role: string;\n  data?: unknown;\n  limit?: number;\n  fallback?: FC<{ error: Error; data?: any }>;\n  placeholder?: ReactNode;\n};\n\n/**\n * Renders a `Surface` with the given role/data inside the harness provider tree.\n */\nexport const renderSurface = (\n  harness: TestHarness,\n  props: RenderSurfaceProps,\n  options?: HarnessRenderOptions,\n): RenderResult => {\n  const { role, data, limit, fallback, placeholder } = props;\n  return render(\n    harness,\n    <SurfaceComponent role={role} data={data as any} limit={limit} fallback={fallback} placeholder={placeholder} />,\n    options,\n  );\n};\n\ntype HarnessProvidersProps = PropsWithChildren<{\n  harness: TestHarness;\n  extra: FC<PropsWithChildren>[];\n}>;\n\nconst HarnessProviders = ({ harness, extra, children }: HarnessProvidersProps) => {\n  const contributed = harness.getAll(Capabilities.ReactContext);\n  const ContributedContext = composeContexts(contributed);\n  const ExtraContext = composeExtra(extra);\n  return (\n    <PluginManagerProvider value={harness.manager}>\n      <ContextProtocolProvider value={harness.manager} context={PluginManagerContext}>\n        <RegistryContext.Provider value={harness.registry}>\n          <ContributedContext>\n            <ExtraContext>{children}</ExtraContext>\n          </ContributedContext>\n        </RegistryContext.Provider>\n      </ContextProtocolProvider>\n    </PluginManagerProvider>\n  );\n};\n\nconst composeContexts = (contexts: Capabilities.ReactContext[]): FC<PropsWithChildren> => {\n  if (contexts.length === 0) {\n    return Passthrough;\n  }\n  return topologicalSort(contexts)\n    .map(({ context }) => context)\n    .reduce((Acc, Next) => ({ children }: PropsWithChildren) => (\n      <Acc>\n        <Next>{children}</Next>\n      </Acc>\n    ));\n};\n\n// Composes in innermost-first order: the first context in the array wraps\n// `children` directly; subsequent contexts wrap the accumulator.\nconst composeExtra = (contexts: FC<PropsWithChildren>[]): FC<PropsWithChildren> => {\n  if (contexts.length === 0) {\n    return Passthrough;\n  }\n  return contexts.reduce<FC<PropsWithChildren>>(\n    (Acc, Next) =>\n      ({ children }: PropsWithChildren) => (\n        <Next>\n          <Acc>{children}</Acc>\n        </Next>\n      ),\n    Passthrough,\n  );\n};\n\nconst Passthrough: FC<PropsWithChildren> = ({ children }) => <Fragment>{children}</Fragment>;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;AAIA,SAASA,uBAAuB;AAChC,SAASC,UAAUC,iBAAwD;AAC3E,OAAOC,SAAkBC,gBAAwD;AAEjF,SAASC,+BAA+B;AAkBjC,IAAMC,SAAS,CAACC,SAAsBC,IAAeC,YAAAA;AAC1D,QAAM,EAAEC,gBAAgB,CAAA,GAAI,GAAGC,KAAAA,IAASF,WAAW,CAAC;AACpD,QAAMG,UAAU,CAAC,EAAEC,SAAQ,MACzB,sBAAA,cAACC,kBAAAA;IAAiBP;IAAkBQ,OAAOL;KACxCG,QAAAA;AAGL,SAAOG,UAAU,sBAAA,cAAA,MAAA,UAAA,MAAGR,EAAAA,GAAQ;IAAE,GAAGG;IAAMM,SAASL;EAAQ,CAAA;AAC1D;AAaO,IAAMM,gBAAgB,CAC3BX,SACAY,OACAV,YAAAA;AAEA,QAAM,EAAEW,MAAMC,MAAMC,OAAOC,UAAUC,YAAW,IAAKL;AACrD,SAAOb,OACLC,SACA,sBAAA,cAACkB,kBAAAA;IAAiBL;IAAYC;IAAmBC;IAAcC;IAAoBC;MACnFf,OAAAA;AAEJ;AAOA,IAAMK,mBAAmB,CAAC,EAAEP,SAASQ,OAAOF,SAAQ,MAAyB;AAC3E,QAAMa,cAAcnB,QAAQoB,OAAOC,qBAAaC,YAAY;AAC5D,QAAMC,qBAAqBC,gBAAgBL,WAAAA;AAC3C,QAAMM,eAAeC,aAAalB,KAAAA;AAClC,SACE,sBAAA,cAACmB,uBAAAA;IAAsBC,OAAO5B,QAAQ6B;KACpC,sBAAA,cAACC,yBAAAA;IAAwBF,OAAO5B,QAAQ6B;IAASE,SAASC;KACxD,sBAAA,cAACC,gBAAgBC,UAAQ;IAACN,OAAO5B,QAAQmC;KACvC,sBAAA,cAACZ,oBAAAA,MACC,sBAAA,cAACE,cAAAA,MAAcnB,QAAAA,CAAAA,CAAAA,CAAAA,CAAAA;AAM3B;AAEA,IAAMkB,kBAAkB,CAACY,aAAAA;AACvB,MAAIA,SAASC,WAAW,GAAG;AACzB,WAAOC;EACT;AACA,SAAOC,gBAAgBH,QAAAA,EACpBI,IAAI,CAAC,EAAET,QAAO,MAAOA,OAAAA,EACrBU,OAAO,CAACC,KAAKC,SAAS,CAAC,EAAErC,SAAQ,MAChC,sBAAA,cAACoC,KAAAA,MACC,sBAAA,cAACC,MAAAA,MAAMrC,QAAAA,CAAAA,CAAAA;AAGf;AAIA,IAAMoB,eAAe,CAACU,aAAAA;AACpB,MAAIA,SAASC,WAAW,GAAG;AACzB,WAAOC;EACT;AACA,SAAOF,SAASK,OACd,CAACC,KAAKC,SACJ,CAAC,EAAErC,SAAQ,MACT,sBAAA,cAACqC,MAAAA,MACC,sBAAA,cAACD,KAAAA,MAAKpC,QAAAA,CAAAA,GAGZgC,WAAAA;AAEJ;AAEA,IAAMA,cAAqC,CAAC,EAAEhC,SAAQ,MAAO,sBAAA,cAACsC,UAAAA,MAAUtC,QAAAA;",
+  "names": ["RegistryContext", "render", "rtlRender", "React", "Fragment", "ContextProtocolProvider", "render", "harness", "ui", "options", "reactContexts", "rest", "Wrapper", "children", "HarnessProviders", "extra", "rtlRender", "wrapper", "renderSurface", "props", "role", "data", "limit", "fallback", "placeholder", "SurfaceComponent", "contributed", "getAll", "Capabilities", "ReactContext", "ContributedContext", "composeContexts", "ExtraContext", "composeExtra", "PluginManagerProvider", "value", "manager", "ContextProtocolProvider", "context", "PluginManagerContext", "RegistryContext", "Provider", "registry", "contexts", "length", "Passthrough", "topologicalSort", "map", "reduce", "Acc", "Next", "Fragment"]
+}

package/dist/lib/browser/ui/index.mjs

@@ -1,8 +1,7 @@
 import {
   App,
   LoadingState,
-  PluginManagerProvider,
-  Surface,
+  Placeholder,
   useApp,
   useAtomCapability,
   useAtomCapabilityState,
@@ -10,24 +9,32 @@ import {
   useCapability,
   useLoading,
   useOperationInvoker,
-  useOperationResolver,
-  usePluginManager,
+  useProcessManagerRuntime,
   useSettingsState,
+  useSpaceCallback,
+  useSpaceService
+} from "../chunk-UVTGHZQF.mjs";
+import {
+  PluginManagerProvider,
+  Surface,
+  usePluginManager,
   useSurface
-} from "../chunk-4CTRO67U.mjs";
-import "../chunk-FHQTHCX7.mjs";
-import "../chunk-5RJNZV7K.mjs";
-import "../chunk-REORGDJT.mjs";
-import "../chunk-NPUEVX42.mjs";
-import "../chunk-YAFEA4GV.mjs";
-import "../chunk-HE27PNNQ.mjs";
-import "../chunk-PKQT6C53.mjs";
-import "../chunk-FNKT2QQ2.mjs";
-import "../chunk-YNFPIQGB.mjs";
+} from "../chunk-QLML5QFJ.mjs";
+import "../chunk-FJ4765WW.mjs";
+import "../chunk-KFDF7KR3.mjs";
+import "../chunk-5AHASNDW.mjs";
+import "../chunk-5GY3YOEL.mjs";
+import "../chunk-FO3IYSLV.mjs";
+import "../chunk-KLHQNYJ2.mjs";
+import "../chunk-VJ5PFAWC.mjs";
+import "../chunk-66IXTIVK.mjs";
+import "../chunk-SLX73WRZ.mjs";
+import "../chunk-IW44C7UL.mjs";
 import "../chunk-J5LGTIGS.mjs";
 export {
   App,
   LoadingState,
+  Placeholder,
   PluginManagerProvider,
   Surface,
   useApp,
@@ -37,9 +44,11 @@ export {
   useCapability,
   useLoading,
   useOperationInvoker,
-  useOperationResolver,
   usePluginManager,
+  useProcessManagerRuntime,
   useSettingsState,
+  useSpaceCallback,
+  useSpaceService,
   useSurface
 };
 //# sourceMappingURL=index.mjs.map

package/dist/lib/node-esm/{capability-EVZK4REM.mjs → capability-RLKFFLTB.mjs}

@@ -2,22 +2,23 @@ import { createRequire } from 'node:module';const require = createRequire(import
 import {
   make,
   make2
-} from "./chunk-2A4PRBIX.mjs";
-import "./chunk-VUIUFIGT.mjs";
+} from "./chunk-BYHYYJZH.mjs";
+import "./chunk-OUEMWPIW.mjs";
 import {
   capabilities_exports
-} from "./chunk-UFW652GS.mjs";
-import "./chunk-JAZVHID3.mjs";
-import "./chunk-Z4TJPSMP.mjs";
-import "./chunk-DTCHT2X2.mjs";
-import "./chunk-7OWSHPYK.mjs";
-import "./chunk-CJCQS2YL.mjs";
+} from "./chunk-PW2VYGOS.mjs";
+import "./chunk-KFZEB6BV.mjs";
+import "./chunk-WK7OIQKI.mjs";
+import "./chunk-42UNAKYO.mjs";
+import "./chunk-SFYCO3PT.mjs";
+import "./chunk-XOCUANHO.mjs";
+import "./chunk-6S45OMUP.mjs";
 import {
   capability_exports
-} from "./chunk-SB5ODNPX.mjs";
+} from "./chunk-CTKEZHKF.mjs";
 import "./chunk-HSLMI22Q.mjs";
 
-// src/plugin-operation/history/capability.ts
+// src/plugin-process-manager/history/capability.ts
 import * as Effect from "effect/Effect";
 var capability_default = capability_exports.makeModule(Effect.fnUntraced(function* () {
   const capabilities = yield* capability_exports.Service;
@@ -32,4 +33,4 @@ var capability_default = capability_exports.makeModule(Effect.fnUntraced(functio
 export {
   capability_default as default
 };
-//# sourceMappingURL=capability-EVZK4REM.mjs.map
+//# sourceMappingURL=capability-RLKFFLTB.mjs.map

package/dist/lib/node-esm/capability-RLKFFLTB.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/plugin-process-manager/history/capability.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\n\nimport { OperationInvoker } from '@dxos/operation';\n\nimport { Capabilities } from '../../common';\nimport { Capability } from '../../core';\nimport * as HistoryTracker from './history-tracker';\nimport * as UndoRegistry from './undo-registry';\n\n//\n// Capability Module - contributes both UndoRegistry and HistoryTracker.\n//\n\nexport default Capability.makeModule(\n  Effect.fnUntraced(function* () {\n    // Get the context for synchronous access in callbacks.\n    const capabilities = yield* Capability.Service;\n\n    // Create UndoRegistry.\n    const undoRegistry = UndoRegistry.make(() => capabilities.getAll(Capabilities.UndoMapping).flat());\n\n    // Create HistoryTracker (depends on UndoRegistry and OperationInvoker).\n    const invoker = yield* Capability.get(Capabilities.OperationInvoker);\n    // Cast to internal type - the factory always returns OperationInvokerInternal.\n    const historyTracker = HistoryTracker.make(invoker as OperationInvoker.OperationInvokerInternal, undoRegistry);\n\n    return [\n      Capability.contributes(Capabilities.UndoRegistry, undoRegistry),\n      Capability.contributes(Capabilities.HistoryTracker, historyTracker),\n    ];\n  }),\n);\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;AAIA,YAAYA,YAAY;AAaxB,IAAA,qBAAeC,mBAAWC,WACjBC,kBAAW,aAAA;AAEhB,QAAMC,eAAe,OAAOH,mBAAWI;AAGvC,QAAMC,eAA4BC,KAAK,MAAMH,aAAaI,OAAOC,qBAAaC,WAAW,EAAEC,KAAI,CAAA;AAG/F,QAAMC,UAAU,OAAOX,mBAAWY,IAAIJ,qBAAaK,gBAAgB;AAEnE,QAAMC,iBAAgCR,MAAKK,SAAsDN,YAAAA;AAEjG,SAAO;IACLL,mBAAWe,YAAYP,qBAAaQ,cAAcX,YAAAA;IAClDL,mBAAWe,YAAYP,qBAAaS,gBAAgBH,cAAAA;;AAExD,CAAA,CAAA;",
+  "names": ["Effect", "Capability", "makeModule", "fnUntraced", "capabilities", "Service", "undoRegistry", "make", "getAll", "Capabilities", "UndoMapping", "flat", "invoker", "get", "OperationInvoker", "historyTracker", "contributes", "UndoRegistry", "HistoryTracker"]
+}

package/dist/lib/node-esm/{chunk-UEWJDI2L.mjs → chunk-37Z53PXZ.mjs}

@@ -2,9 +2,9 @@ import { createRequire } from 'node:module';const require = createRequire(import
 
 // src/context.ts
 import { createContext } from "@dxos/web-context";
-var PluginManagerContext = createContext("dxos.org/app-framework/plugin-manager");
+var PluginManagerContext = createContext("org.dxos.app-framework.plugin-manager");
 
 export {
   PluginManagerContext
 };
-//# sourceMappingURL=chunk-UEWJDI2L.mjs.map
+//# sourceMappingURL=chunk-37Z53PXZ.mjs.map

package/dist/lib/node-esm/{chunk-UEWJDI2L.mjs.map → chunk-37Z53PXZ.mjs.map}

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/context.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { createContext } from '@dxos/web-context';\n\nimport { type PluginManager } from './core';\n\nexport const PluginManagerContext = createContext<PluginManager.PluginManager>('dxos.org/app-framework/plugin-manager');\n"],
-  "mappings": ";;;AAIA,SAASA,qBAAqB;AAIvB,IAAMC,uBAAuBC,cAA2C,uCAAA;",
-  "names": ["createContext", "PluginManagerContext", "createContext"]
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { createContext } from '@dxos/web-context';\n\nimport { type PluginManager } from './core';\n\nexport const PluginManagerContext = createContext<PluginManager.PluginManager>('org.dxos.app-framework.plugin-manager');\n"],
+  "mappings": ";;;AAIA,SAASA,qBAAqB;AAIvB,IAAMC,uBAAuBD,cAA2C,uCAAA;",
+  "names": ["createContext", "PluginManagerContext"]
 }

package/dist/lib/node-esm/chunk-42UNAKYO.mjs

@@ -0,0 +1,423 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  isPlugin
+} from "./chunk-6S45OMUP.mjs";
+import {
+  __export
+} from "./chunk-HSLMI22Q.mjs";
+
+// src/core/url-loader.ts
+var url_loader_exports = {};
+__export(url_loader_exports, {
+  RemotePluginLoadError: () => RemotePluginLoadError,
+  getInstalledVersion: () => getInstalledVersion,
+  getRemoteEntries: () => getRemoteEntries,
+  isLocalUrl: () => isLocalUrl,
+  make: () => make,
+  preload: () => preload,
+  setInstalledVersion: () => setInstalledVersion,
+  uninstall: () => uninstall
+});
+import * as Effect3 from "effect/Effect";
+import * as Option from "effect/Option";
+import { BaseError as BaseError3 } from "@dxos/errors";
+import { log } from "@dxos/log";
+
+// src/core/plugin-asset-cache.ts
+var plugin_asset_cache_exports = {};
+__export(plugin_asset_cache_exports, {
+  PluginAssetCacheError: () => PluginAssetCacheError,
+  noop: () => noop
+});
+import * as Effect from "effect/Effect";
+import { BaseError } from "@dxos/errors";
+var PluginAssetCacheError = class extends BaseError.extend("PluginAssetCacheError", "Plugin asset cache operation failed") {
+};
+var noop = () => ({
+  cache: () => Effect.void,
+  evict: () => Effect.void,
+  resolve: (_pluginId, url) => Effect.succeed(url),
+  list: () => Effect.succeed([])
+});
+
+// src/core/plugin-manifest.ts
+var plugin_manifest_exports = {};
+__export(plugin_manifest_exports, {
+  Manifest: () => Manifest,
+  PLUGIN_DEV_SERVER_PORT: () => PLUGIN_DEV_SERVER_PORT,
+  PluginManifestError: () => PluginManifestError,
+  fetchManifest: () => fetchManifest,
+  parse: () => parse
+});
+import * as FetchHttpClient from "@effect/platform/FetchHttpClient";
+import * as HttpClient from "@effect/platform/HttpClient";
+import * as HttpClientRequest from "@effect/platform/HttpClientRequest";
+import * as HttpClientResponse from "@effect/platform/HttpClientResponse";
+import * as Effect2 from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { BaseError as BaseError2 } from "@dxos/errors";
+import { PLUGIN_ENTRY_FILENAME } from "@dxos/protocols";
+var PLUGIN_DEV_SERVER_PORT = 3967;
+var PluginManifestError = class extends BaseError2.extend("PluginManifestError", "Plugin manifest is invalid") {
+};
+var Manifest = Schema.Struct({
+  id: Schema.String,
+  name: Schema.String,
+  version: Schema.String,
+  assets: Schema.Array(Schema.String),
+  devEntry: Schema.String.pipe(Schema.optional)
+});
+var resolve = (manifestUrl, manifest) => {
+  const dev = manifest.devEntry !== void 0;
+  return {
+    id: manifest.id,
+    name: manifest.name,
+    version: manifest.version,
+    entryUrl: new URL(dev ? manifest.devEntry : PLUGIN_ENTRY_FILENAME, manifestUrl).toString(),
+    assetUrls: manifest.assets.map((asset) => new URL(asset, manifestUrl).toString()),
+    dev
+  };
+};
+var parse = (manifestUrl, payload) => {
+  const manifest = Schema.decodeUnknownSync(Manifest)(payload);
+  if (manifest.devEntry === void 0 && !manifest.assets.includes(PLUGIN_ENTRY_FILENAME)) {
+    throw new Error(`Manifest at ${manifestUrl} does not list ${PLUGIN_ENTRY_FILENAME} in assets.`);
+  }
+  return resolve(manifestUrl, manifest);
+};
+var fetchManifest = (manifestUrl) => Effect2.gen(function* () {
+  const response = yield* HttpClientRequest.get(manifestUrl).pipe(HttpClient.execute, Effect2.mapError((cause) => new PluginManifestError({
+    context: {
+      manifestUrl,
+      reason: "fetch-failed"
+    },
+    cause
+  })));
+  if (response.status >= 400) {
+    return yield* Effect2.fail(new PluginManifestError({
+      context: {
+        manifestUrl,
+        reason: "http-error",
+        status: response.status
+      }
+    }));
+  }
+  const manifest = yield* HttpClientResponse.schemaBodyJson(Manifest)(response).pipe(Effect2.mapError((cause) => new PluginManifestError({
+    context: {
+      manifestUrl,
+      reason: "parse-failed"
+    },
+    cause
+  })));
+  if (manifest.devEntry === void 0 && !manifest.assets.includes(PLUGIN_ENTRY_FILENAME)) {
+    return yield* Effect2.fail(new PluginManifestError({
+      context: {
+        manifestUrl,
+        reason: "invalid"
+      },
+      cause: `assets does not include ${PLUGIN_ENTRY_FILENAME}`
+    }));
+  }
+  return resolve(manifestUrl, manifest);
+}).pipe(Effect2.scoped, Effect2.provide(FetchHttpClient.layer));
+
+// src/core/url-loader.ts
+var __dxlog_file = "/__w/dxos/dxos/packages/sdk/app-framework/src/core/url-loader.ts";
+var DEFAULT_KEY = "org.dxos.composer.remote-plugins";
+var RemotePluginLoadError = class extends BaseError3.extend("RemotePluginLoadError", "Failed to load remote plugin") {
+};
+var defaultStorage = () => ({
+  get: (key) => localStorage.getItem(key),
+  set: (key, value) => localStorage.setItem(key, value)
+});
+var getPersistedRemotePlugins = (storage, key) => {
+  try {
+    const parsed = JSON.parse(storage.get(key) ?? "[]");
+    if (!Array.isArray(parsed)) {
+      return [];
+    }
+    return parsed.filter((entry) => typeof entry === "object" && entry !== null && typeof entry.id === "string" && typeof entry.url === "string");
+  } catch {
+    return [];
+  }
+};
+var persistRemotePlugin = (storage, key, entry) => {
+  try {
+    const entries = getPersistedRemotePlugins(storage, key).filter((existing) => existing.id !== entry.id);
+    entries.push(entry);
+    storage.set(key, JSON.stringify(entries));
+  } catch (error) {
+    log.warn("failed to persist remote plugin entry", {
+      entry,
+      error
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 40, S: void 0 });
+  }
+};
+var removePersistedRemotePlugin = (storage, key, pluginId) => {
+  try {
+    const entries = getPersistedRemotePlugins(storage, key).filter((existing) => existing.id !== pluginId);
+    storage.set(key, JSON.stringify(entries));
+  } catch (error) {
+    log.warn("failed to remove remote plugin entry", {
+      pluginId,
+      error
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 51, S: void 0 });
+  }
+};
+var isUrl = (locator) => {
+  try {
+    const url = new URL(locator);
+    return url.protocol === "http:" || url.protocol === "https:";
+  } catch {
+    return false;
+  }
+};
+var isLocalUrl = (locator) => {
+  try {
+    const hostname = new URL(locator).hostname.toLowerCase();
+    return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname === "[::1]";
+  } catch {
+    return false;
+  }
+};
+var getRemoteEntries = (options = {}) => {
+  const storage = options.storage ?? defaultStorage();
+  const key = options.key ?? DEFAULT_KEY;
+  return getPersistedRemotePlugins(storage, key);
+};
+var setInstalledVersion = (id, version, options = {}) => {
+  const storage = options.storage ?? defaultStorage();
+  const key = options.key ?? DEFAULT_KEY;
+  const entries = getPersistedRemotePlugins(storage, key);
+  const index = entries.findIndex((entry) => entry.id === id);
+  if (index === -1) {
+    return;
+  }
+  entries[index] = {
+    ...entries[index],
+    version
+  };
+  try {
+    storage.set(key, JSON.stringify(entries));
+  } catch (error) {
+    log.warn("failed to update installed version for remote plugin", {
+      id,
+      version,
+      error
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 103, S: void 0 });
+  }
+};
+var getInstalledVersion = (id, options = {}) => {
+  const storage = options.storage ?? defaultStorage();
+  const key = options.key ?? DEFAULT_KEY;
+  return getPersistedRemotePlugins(storage, key).find((entry) => entry.id === id)?.version;
+};
+var normalizePluginExport = (mod) => {
+  const exported = mod.default;
+  if (isPlugin(exported)) {
+    return exported;
+  }
+  if (typeof exported === "function") {
+    const result = exported();
+    if (isPlugin(result)) {
+      return result;
+    }
+  }
+  throw new Error("Remote module default export is not a Plugin or a zero-arg plugin factory.");
+};
+var loadStylesheets = (manifest, cache) => Effect3.gen(function* () {
+  if (typeof document === "undefined") {
+    return;
+  }
+  const cssUrls = manifest.assetUrls.filter((url) => url.endsWith(".css"));
+  for (const url of cssUrls) {
+    const resolved = yield* cache.resolve(manifest.id, url);
+    if (document.querySelector(`link[data-dxos-plugin-id="${manifest.id}"][href="${resolved}"]`)) {
+      continue;
+    }
+    const link = document.createElement("link");
+    link.rel = "stylesheet";
+    link.href = resolved;
+    link.dataset.dxosPluginId = manifest.id;
+    document.head.appendChild(link);
+  }
+});
+var loadFromManifest = (manifestUrl, cache) => Effect3.gen(function* () {
+  log.info("loading remote plugin", {
+    manifestUrl
+  }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 152, S: this });
+  const manifest = yield* fetchManifest(manifestUrl).pipe(Effect3.mapError((cause) => new RemotePluginLoadError({
+    context: {
+      locator: manifestUrl,
+      reason: "manifest-error"
+    },
+    cause
+  })));
+  const wrapCacheError = Effect3.mapError((cause) => new RemotePluginLoadError({
+    context: {
+      locator: manifestUrl,
+      reason: "cache-error"
+    },
+    cause
+  }));
+  if (!manifest.dev) {
+    const cachedUrls = manifest.assetUrls.indexOf(manifestUrl) === -1 ? [
+      manifestUrl,
+      ...manifest.assetUrls
+    ] : manifest.assetUrls;
+    yield* cache.cache(manifest.id, cachedUrls).pipe(wrapCacheError);
+  }
+  const entryUrl = manifest.dev ? manifest.entryUrl : yield* cache.resolve(manifest.id, manifest.entryUrl).pipe(wrapCacheError);
+  const mod = yield* Effect3.tryPromise({
+    try: () => import(
+      /* @vite-ignore */
+      entryUrl
+    ),
+    catch: (cause) => new RemotePluginLoadError({
+      context: {
+        locator: manifestUrl,
+        reason: "import-failed"
+      },
+      cause
+    })
+  });
+  const plugin = normalizePluginExport(mod);
+  if (!plugin.meta.id || !plugin.meta.name) {
+    return yield* Effect3.fail(new RemotePluginLoadError({
+      context: {
+        locator: manifestUrl,
+        reason: "meta-missing"
+      }
+    }));
+  }
+  if (plugin.meta.id !== manifest.id) {
+    return yield* Effect3.fail(new RemotePluginLoadError({
+      context: {
+        locator: manifestUrl,
+        reason: "meta-mismatch",
+        metaId: plugin.meta.id,
+        manifestId: manifest.id
+      }
+    }));
+  }
+  if (!manifest.dev) {
+    yield* loadStylesheets(manifest, cache).pipe(wrapCacheError);
+  }
+  return {
+    plugin,
+    manifest
+  };
+});
+var preload = (options = {}) => Effect3.gen(function* () {
+  const storage = options.storage ?? defaultStorage();
+  const key = options.key ?? DEFAULT_KEY;
+  const cache = options.cache ?? noop();
+  const onPluginLoaded = options.onPluginLoaded;
+  const entries = getPersistedRemotePlugins(storage, key);
+  if (entries.length === 0) {
+    return [];
+  }
+  log.info("preloading remote plugins", {
+    count: entries.length
+  }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 240, S: this });
+  const total = entries.length;
+  let loaded = 0;
+  const results = yield* Effect3.all(entries.map((entry) => loadFromManifest(entry.url, cache).pipe(
+    Effect3.tapError((error) => Effect3.sync(() => log.warn("failed to preload remote plugin", {
+      entry,
+      error
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 245, S: this }))),
+    Effect3.option,
+    // Tick the progress hook on both success and recoverable failure so
+    // the counter monotonically reaches `total`. The host-supplied
+    // callback is best-effort: any synchronous throw flows through
+    // `Effect.try` and gets logged + ignored so a buggy hook can't
+    // derail the preload.
+    Effect3.tap(() => Effect3.sync(() => {
+      loaded += 1;
+    }).pipe(Effect3.andThen(Effect3.try(() => onPluginLoaded?.(loaded, total))), Effect3.tapError((error) => Effect3.sync(() => log.warn("onPluginLoaded threw", {
+      loaded,
+      total,
+      error
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 255, S: this }))), Effect3.ignore))
+  )), {
+    concurrency: "unbounded"
+  });
+  return results.flatMap((result) => Option.match(result, {
+    onNone: () => [],
+    onSome: ({ plugin }) => [
+      plugin
+    ]
+  }));
+});
+var make = (builtinPlugins, options = {}) => {
+  const storage = options.storage ?? defaultStorage();
+  const key = options.key ?? DEFAULT_KEY;
+  const cache = options.cache ?? noop();
+  return (locator) => Effect3.gen(function* () {
+    const builtin = builtinPlugins.find((plugin2) => plugin2.meta.id === locator);
+    if (builtin) {
+      return {
+        plugin: builtin
+      };
+    }
+    if (!isUrl(locator)) {
+      return yield* Effect3.fail(new RemotePluginLoadError({
+        context: {
+          locator,
+          reason: "invalid-locator"
+        }
+      }));
+    }
+    const { plugin, manifest } = yield* loadFromManifest(locator, cache);
+    if (!manifest.dev) {
+      const duplicate = builtinPlugins.find((existing) => existing.meta.id === plugin.meta.id);
+      if (duplicate) {
+        return yield* Effect3.fail(new RemotePluginLoadError({
+          context: {
+            locator,
+            reason: "duplicate-id",
+            id: plugin.meta.id
+          }
+        }));
+      }
+      persistRemotePlugin(storage, key, {
+        id: plugin.meta.id,
+        url: locator
+      });
+    }
+    return {
+      plugin,
+      dev: manifest.dev
+    };
+  });
+};
+var uninstall = (pluginId, options = {}) => Effect3.gen(function* () {
+  const storage = options.storage ?? defaultStorage();
+  const key = options.key ?? DEFAULT_KEY;
+  const cache = options.cache ?? noop();
+  removePersistedRemotePlugin(storage, key, pluginId);
+  if (typeof document !== "undefined") {
+    document.querySelectorAll(`link[data-dxos-plugin-id="${pluginId}"]`).forEach((node) => node.remove());
+  }
+  yield* cache.evict(pluginId).pipe(Effect3.tapError((error) => Effect3.sync(() => log.warn("failed to evict plugin assets", {
+    pluginId,
+    error
+  }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 337, S: this }))), Effect3.ignore);
+});
+
+export {
+  plugin_asset_cache_exports,
+  PLUGIN_DEV_SERVER_PORT,
+  plugin_manifest_exports,
+  RemotePluginLoadError,
+  isLocalUrl,
+  getRemoteEntries,
+  setInstalledVersion,
+  getInstalledVersion,
+  preload,
+  make,
+  uninstall,
+  url_loader_exports
+};
+//# sourceMappingURL=chunk-42UNAKYO.mjs.map