@inkandswitch/patchwork-pkg-base 0.0.73 → 0.0.74

package/packages/isolation/dist/assets/{component-DA0d3480.js → component-Daum8ibW.js}

@@ -1068,7 +1068,9 @@ function rewriteAutomergeDepsInSource(source, mapper) {
 }
 function markerNameFromUrl(url) {
   const { first } = splitFirstSegment(url);
-  return first.startsWith(REGISTRY_MARKER_PREFIX) ? first : null;
+  if (!first.startsWith(REGISTRY_MARKER_PREFIX)) return null;
+  const { pkg } = splitMarkerHeads(first.slice(REGISTRY_MARKER_PREFIX.length));
+  return `${REGISTRY_MARKER_PREFIX}${pkg}`;
 }
 function resolvePackageRequest(url, mapper) {
   return mapper.resolveMarker(url) ?? url;
@@ -1637,27 +1639,46 @@ function startHostDragDropBridge(rpcPort, getIframe, allowlistDrop) {
   };
 }
 
+function resolveGatedAttribute(element, attribute, allowed, label = attribute) {
+  const requested = (element.getAttribute(attribute) ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+  const granted = [];
+  for (const entry of requested) {
+    if (allowed.includes(entry)) {
+      granted.push(entry);
+    } else {
+      console.warn(
+        `[patchwork-isolation] ${label}: "${entry}" is not permitted. New entries need independent security analysis before being added.`
+      );
+    }
+  }
+  return granted;
+}
+
 const ALLOWED_PROVIDERS = [
   "patchwork:contact",
   "patchwork:selected-doc",
   // The active theme id (a plain string). Carries no automerge URLs or user
   // identity, so it is safe to relay into the iframe; lets isolated tools
   // (e.g. the titlebar theme tool) mirror the host's active theme.
-  "patchwork:current-theme"
+  "patchwork:current-theme",
+  // A worker connection. The worker runs on the host and only its
+  // `{readable, writable}` pair is transferred in, so its config and secrets
+  // stay out here. This allows every worker kind, but each subscription has its
+  // own port, so a tool only gets the streams for the worker it asked for.
+  "patchwork:worker-channel"
 ];
-function resolveBridgedProviders(element) {
-  const requested = (element.getAttribute("shared-providers") ?? "").split(",").map((s) => s.trim()).filter(Boolean);
-  const bridged = [];
-  for (const provider of requested) {
-    if (ALLOWED_PROVIDERS.includes(provider)) {
-      bridged.push(provider);
-    } else {
-      console.warn(
-        `[patchwork-isolation] shared-providers: "${provider}" is not in ALLOWED_PROVIDERS. New provider types need independent security analysis before being added.`
-      );
+function transferablesIn(value) {
+  if (!value || typeof value !== "object") return [];
+  const out = [];
+  for (const candidate of Object.values(value)) {
+    if (candidate instanceof ReadableStream || candidate instanceof WritableStream || candidate instanceof MessagePort || candidate instanceof ArrayBuffer) {
+      out.push(candidate);
     }
   }
-  return bridged;
+  return out;
+}
+function resolveBridgedProviders(element) {
+  return resolveGatedAttribute(element, "shared-providers", ALLOWED_PROVIDERS);
 }
 function makeBridgedValueFilter(checks) {
   return async (selectorType, value) => {
@@ -1700,11 +1721,14 @@ function startHostProvidersBridge(rpcPort, hostElement, allowedTypes = [], value
         if (e.data?.type === "change") {
           const value = valueFilter ? await valueFilter(selector.type, e.data.value) : e.data.value;
           if (value === void 0) return;
-          rpcPort.postMessage({
-            type: "providers-bridge-change",
-            id,
-            value
-          });
+          rpcPort.postMessage(
+            {
+              type: "providers-bridge-change",
+              id,
+              value
+            },
+            transferablesIn(value)
+          );
         }
       });
       hostPort.start();
@@ -1744,6 +1768,36 @@ function startHostProvidersBridge(rpcPort, hostElement, allowedTypes = [], value
   };
 }
 
+const ALLOWED_OPEN_TOOLS = ["llm-config-tray"];
+function resolveSharedTools(element) {
+  return resolveGatedAttribute(element, "shared-tools", ALLOWED_OPEN_TOOLS);
+}
+function startHostOpenToolBridge(rpcPort, hostElement, allowedComponents = []) {
+  const allowed = new Set(allowedComponents);
+  const onMessage = (event) => {
+    const msg = event.data;
+    if (msg?.type !== "open-tool") return;
+    const detail = msg.detail;
+    const component = detail?.component;
+    if (!component || !allowed.has(component)) {
+      log(`open-tool rejected: ${component}`);
+      return;
+    }
+    log(`open-tool: ${component}`);
+    hostElement.dispatchEvent(
+      new CustomEvent("patchwork:open-tool", {
+        detail,
+        bubbles: true,
+        composed: true
+      })
+    );
+  };
+  rpcPort.addEventListener("message", onMessage);
+  return () => {
+    rpcPort.removeEventListener("message", onMessage);
+  };
+}
+
 async function boot(deps) {
   const {
     installLocalStorageStub,
@@ -1752,8 +1806,6 @@ async function boot(deps) {
     createRpcClient,
     createProvidersBridge,
     setupEsModuleShims,
-    installWorkerShim,
-    workerBootstrapSource,
     createRegistry,
     createRootComponentData,
     createDragDrop
@@ -1808,7 +1860,11 @@ async function boot(deps) {
   });
   rpcPort = init.rpcPort;
   rpc = createRpcClient(rpcPort);
-  providers = createProvidersBridge(rpcPort, log);
+  providers = createProvidersBridge(
+    rpcPort,
+    log,
+    init.data.bridgedProviders ?? []
+  );
   registry = createRegistry(log);
   rootComponentData = createRootComponentData(log);
   dragDrop = createDragDrop(log);
@@ -1821,6 +1877,13 @@ async function boot(deps) {
     }),
     true
   );
+  document.addEventListener(
+    "patchwork:open-tool",
+    ((event) => {
+      rpcPort.postMessage({ type: "open-tool", detail: event.detail });
+    }),
+    true
+  );
   const d = init.data;
   log("init", { root: d.rootComponentId });
   if (d.hostStyles) {
@@ -1859,15 +1922,6 @@ async function boot(deps) {
     const hostOrigin = d.hostOrigin;
     installFetchProxy(hostOrigin, rpc.fetchResource, log);
     installLinkInterception(hostOrigin, log);
-    installWorkerShim({
-      fetchModule: rpc.fetchModule,
-      fetchResource: rpc.fetchResource,
-      esmsSource: d.esmsSource,
-      workerBootstrapSource,
-      importMap: d.importMap,
-      hostOrigin,
-      log
-    });
     const syncAdapter = new messagechannel.MessageChannelNetworkAdapter(
       init.syncPort
     );
@@ -2054,7 +2108,8 @@ function createRpcClient(port) {
   return { fetchModule, fetchResource, handle };
 }
 
-function createProvidersBridge(rpcPort, log) {
+function createProvidersBridge(rpcPort, log, bridgedTypes = []) {
+  const bridged = new Set(bridgedTypes);
   const bridgedSubscriptions = /* @__PURE__ */ new Map();
   let bridgeId = 0;
   function handle(event) {
@@ -2064,13 +2119,29 @@ function createProvidersBridge(rpcPort, log) {
       log("providers-bridge: received change for id:", msg.id, "value:", msg.value);
       const port = bridgedSubscriptions.get(msg.id);
       if (port) {
-        port.postMessage({ type: "change", value: msg.value });
+        const transfer = [];
+        const value = msg.value;
+        if (value && typeof value === "object") {
+          for (const candidate of Object.values(
+            value
+          )) {
+            if (candidate instanceof ReadableStream || candidate instanceof WritableStream || candidate instanceof MessagePort || candidate instanceof ArrayBuffer) {
+              transfer.push(candidate);
+            }
+          }
+        }
+        port.postMessage({ type: "change", value }, transfer);
       }
       return true;
     }
     if (msg.type === "providers-bridge-rejected") {
       log("providers-bridge: rejected by host for id:", msg.id);
+      const port = bridgedSubscriptions.get(msg.id);
       bridgedSubscriptions.delete(msg.id);
+      if (port) {
+        port.postMessage({ type: "unavailable", reason: "rejected" });
+        port.close();
+      }
       return true;
     }
     return false;
@@ -2079,6 +2150,10 @@ function createProvidersBridge(rpcPort, log) {
     document.addEventListener("patchwork:subscribe", ((event) => {
       const detail = event.detail;
       if (!detail?.selector?.type || !detail?.port) return;
+      if (!bridged.has(detail.selector.type)) {
+        log("providers-bridge: not bridged, leaving unclaimed:", detail.selector.type);
+        return;
+      }
       log("providers-bridge: captured unclaimed subscription:", detail.selector.type, detail.selector);
       event.stopPropagation();
       const id = ++bridgeId;
@@ -2132,209 +2207,6 @@ async function setupEsModuleShims(config) {
   return importShim;
 }
 
-function installWorkerShim(deps) {
-  const {
-    fetchModule,
-    fetchResource,
-    esmsSource,
-    workerBootstrapSource,
-    importMap,
-    hostOrigin,
-    log
-  } = deps;
-  const OriginalWorker = self.Worker;
-  function shouldIntercept(url, isModule) {
-    return isModule && (url.startsWith(hostOrigin + "/") || url.startsWith("blob:"));
-  }
-  self.Worker = function PatchedWorker(scriptURL, options) {
-    const url = typeof scriptURL === "string" ? scriptURL : scriptURL.toString();
-    if (!shouldIntercept(url, options?.type === "module")) {
-      return new OriginalWorker(scriptURL, options);
-    }
-    log("worker shim: intercepting", url.slice(0, 80));
-    const channel = new MessageChannel();
-    channel.port1.addEventListener("message", (event) => {
-      const m = event.data;
-      if (m?.type === "fetch-package")
-        relay(fetchModule(m.url), "fetch-package", m.id);
-      else if (m?.type === "fetch-resource")
-        relay(fetchResource(m.url), "fetch-resource", m.id);
-    });
-    channel.port1.start();
-    function relay(work, type, id) {
-      work.then(
-        (r) => {
-          const transfer = type === "fetch-resource" ? [r.body] : [];
-          channel.port1.postMessage(
-            { type: `${type}-response`, id, ...r },
-            transfer
-          );
-        },
-        (err) => channel.port1.postMessage({
-          type: `${type}-error`,
-          id,
-          error: err instanceof Error ? err.message : String(err)
-        })
-      );
-    }
-    const worker = buildHarnessWorker();
-    resolveEntry(url).then(
-      (entrySource) => worker.postMessage(
-        { type: "isolation-relay-port", entryUrl: url, entrySource },
-        [channel.port2]
-      ),
-      (err) => {
-        log("worker shim: failed to load entry source", err);
-        worker.postMessage({
-          type: "isolation-relay-error",
-          error: err instanceof Error ? err.message : String(err)
-        });
-      }
-    );
-    return worker;
-  };
-  async function resolveEntry(url) {
-    if (!url.startsWith("blob:")) return void 0;
-    return (await fetch(url)).text();
-  }
-  function buildHarnessWorker() {
-    const params = { importMap, hostOrigin };
-    const blobSource = [
-      `(${workerBootstrapSource})(${JSON.stringify(params)});`,
-      esmsSource,
-      `self.__isolationWorkerStart().catch((e) => { throw e; });`
-    ].join("\n");
-    const blobUrl = URL.createObjectURL(
-      new Blob([blobSource], { type: "text/javascript" })
-    );
-    const worker = new OriginalWorker(blobUrl);
-    setTimeout(() => URL.revokeObjectURL(blobUrl), 1e4);
-    return worker;
-  }
-}
-
-function workerBootstrap(params) {
-  let appHandler = null;
-  const appBuffer = [];
-  try {
-    Object.defineProperty(self, "onmessage", {
-      configurable: true,
-      get: () => appHandler,
-      set(fn) {
-        appHandler = fn;
-        if (fn) for (const ev of appBuffer.splice(0)) fn(ev);
-      }
-    });
-  } catch {
-  }
-  let relayPort;
-  let reqId = 0;
-  const pending = /* @__PURE__ */ new Map();
-  const relayReady = new Promise((resolve, reject) => {
-    self.addEventListener("message", (event) => {
-      const m = event.data;
-      if (m && m.type === "isolation-relay-port") {
-        resolve({
-          port: event.ports[0],
-          entryUrl: m.entryUrl,
-          entrySource: m.entrySource
-        });
-      } else if (m && m.type === "isolation-relay-error") {
-        reject(new Error(m.error));
-      } else if (appHandler) {
-        appHandler(event);
-      } else {
-        appBuffer.push(event);
-      }
-    });
-  });
-  function request(type, url) {
-    return new Promise((resolve, reject) => {
-      const id = ++reqId;
-      pending.set(id, { resolve, reject });
-      relayPort.postMessage({ type, id, url });
-    });
-  }
-  function onRelayMessage(event) {
-    const m = event.data;
-    if (!m || typeof m.id !== "number") return;
-    const p = pending.get(m.id);
-    if (!p) return;
-    pending.delete(m.id);
-    if (m.type === "fetch-package-response")
-      p.resolve({ source: m.source, resolvedUrl: m.resolvedUrl });
-    else if (m.type === "fetch-resource-response")
-      p.resolve({ body: m.body, contentType: m.contentType });
-    else if (m.type.endsWith("-error")) p.reject(new Error(m.error));
-  }
-  function fixImportMethod(src) {
-    return src.replace(
-      /^(\s+)import\s*\(([^)]*)\)\s*\{/gm,
-      '$1["import"]($2) {'
-    );
-  }
-  let blobEntry;
-  self.esmsInitOptions = {
-    shimMode: true,
-    async source(url) {
-      if (blobEntry && url === blobEntry.url) {
-        return {
-          source: fixImportMethod(blobEntry.source),
-          url: blobEntry.url,
-          type: "js"
-        };
-      }
-      if (url.startsWith(params.hostOrigin + "/")) {
-        const r = await request(
-          "fetch-package",
-          url
-        );
-        return {
-          source: fixImportMethod(r.source),
-          url: r.resolvedUrl,
-          type: "js"
-        };
-      }
-      const res = await fetch(url);
-      if (!res.ok) throw new Error(`worker source ${url}: HTTP ${res.status}`);
-      return {
-        source: await res.text(),
-        url: res.url || url,
-        type: "js"
-      };
-    }
-  };
-  self.__isolationWorkerStart = async function start() {
-    const importShim = self.importShim;
-    if (!importShim)
-      throw new Error("worker: es-module-shims failed to initialize");
-    const init = await relayReady;
-    relayPort = init.port;
-    relayPort.addEventListener("message", onRelayMessage);
-    relayPort.start();
-    if (params.importMap) importShim.addImportMap(params.importMap);
-    const nativeFetch = self.fetch;
-    self.fetch = async (input, fetchInit) => {
-      const u = typeof input === "string" ? input : input.toString();
-      if (u.startsWith(params.hostOrigin)) {
-        const r = await request(
-          "fetch-resource",
-          u
-        );
-        return new Response(r.body, {
-          status: 200,
-          headers: { "Content-Type": r.contentType }
-        });
-      }
-      return nativeFetch(input, fetchInit);
-    };
-    if (init.entrySource !== void 0) {
-      blobEntry = { url: init.entryUrl, source: init.entrySource };
-    }
-    await importShim(init.entryUrl);
-  };
-}
-
 function createRegistry(log) {
   let pending = [];
   let importShim;
@@ -2499,8 +2371,6 @@ function generateIframeSrcdoc(appearance) {
       createRpcClient: ${createRpcClient.toString()},
       createProvidersBridge: ${createProvidersBridge.toString()},
       setupEsModuleShims: ${setupEsModuleShims.toString()},
-      installWorkerShim: ${installWorkerShim.toString()},
-      workerBootstrapSource: ${JSON.stringify(workerBootstrap.toString())},
       createRegistry: ${createRegistry.toString()},
       createRootComponentData: ${createRootComponentData.toString()},
       createDragDrop: ${createDragDrop.toString()},
@@ -2670,6 +2540,7 @@ function bootIsolation(host) {
     });
     log("intermediary repo and allowlist ready");
     const bridgedProviders = resolveBridgedProviders(host);
+    const sharedTools = resolveSharedTools(host);
     const bridgedValueFilter = makeBridgedValueFilter({
       isAllowed: (url) => allowlist.hasUrl(url),
       requestAccess: (url) => requestBridgedUrlAccess(
@@ -2705,11 +2576,14 @@ function bootIsolation(host) {
         bridgedProviders,
         bridgedValueFilter
       ),
+      // Lets an isolated tool open a host tool, like the LLM config tray.
+      startHostOpenToolBridge(hostRpcPort, host, sharedTools),
       watchRegistries(hostRpcPort, mapper)
     );
     createIframe(rpcChannel.port2, intermediary.iframePort, mapper, assets, {
       rootComponentId,
-      importMap
+      importMap,
+      bridgedProviders
     });
   }
   function createIframe(rpcPort, syncPort, mapper, assets, config) {
@@ -2737,6 +2611,9 @@ function bootIsolation(host) {
           // initial boot rather than lost, since a pre-port push no-ops.
           rootComponentData: readRootComponentData(host),
           registryEntries,
+          // The iframe only claims these, so other selectors can still reach a
+          // provider inside the iframe.
+          bridgedProviders: config.bridgedProviders,
           esmsSource: assets.esmsSource,
           hostStyles: assets.hostStyles,
           importMap: config.importMap,
@@ -2825,7 +2702,8 @@ const mountIsolation = (element) => {
     attributeFilter: [
       "root-component",
       "automerge-allowlist",
-      "shared-providers"
+      "shared-providers",
+      "shared-tools"
     ]
   });
   return () => {
@@ -2836,4 +2714,4 @@ const mountIsolation = (element) => {
 };
 
 export { mountIsolation };
-//# sourceMappingURL=component-DA0d3480.js.map
+//# sourceMappingURL=component-Daum8ibW.js.map