@pylonsync/functions 0.22.47 → 0.22.58

package/src/offline-sw.ts

@@ -0,0 +1,343 @@
+// The offline service worker, served at `/pylon-sw.js` for apps that set
+// `buildManifest({ offline })`.
+//
+// The client bundler writes the worker into the client build with this
+// build's config inlined (`renderServiceWorker`). The worker body is the
+// source of `pylonServiceWorker` itself, serialized with `toString()`, so
+// the tests in offline-sw.test.ts run the same code the browser runs. That
+// imposes one rule on this file: `pylonServiceWorker` and `classifyRequest`
+// may not reference anything outside their own bodies (no imports, no
+// module-level helpers).
+//
+// What it does:
+//   - install: precache the build's client files for the offline routes,
+//     the web app manifest and the icons, then fetch each static offline
+//     route's HTML ("shell") with `X-Pylon-Offline-Shell: 1` and keep it when
+//     the runtime answers `Pylon-Offline-Shell: 1` (the HTML is the same for
+//     every signed-in user).
+//   - navigations: network first. When the network fails (or, for an offline
+//     route, takes longer than `navigationTimeoutMs`), answer with the
+//     route's shell, else the start URL's shell. The client runtime renders
+//     the real URL from the local replica.
+//   - build files: cache first. They are content-hashed, so a cached copy
+//     is always correct.
+//   - everything else (API, auth, sync, dev endpoints): not intercepted, never
+//     cached. Data comes from the sync engine, not the HTTP cache.
+//   - activate: delete caches from other builds. A new deploy installs a new
+//     worker, which waits until every tab of the app is closed (the next
+//     launch) before it takes over, or until the page posts
+//     `{ type: "pylon:skip-waiting" }` (`useAppUpdate().apply()` in
+//     @pylonsync/react does, after the outbox is empty).
+//   - messages: `pylon:session` (the signed-in bit, see below),
+//     `pylon:skip-waiting`, and `pylon:version`, which answers on the
+//     message's port with `{ type: "pylon:version", version }`. The page asks
+//     a waiting worker for its version this way.
+
+/** The build-specific values inlined into `/pylon-sw.js`. */
+export interface ServiceWorkerConfig {
+  /** Hash of everything below. Cache names carry it. */
+  version: string;
+  /** The client build's public prefix (`/_pylon/build/`, or a CDN URL). */
+  buildPrefix: string;
+  /** URLs to keep at install: the offline routes' build files, the web app
+   *  manifest, the icons. */
+  precache: string[];
+  /** Offline routes without dynamic segments: their HTML is kept at install. */
+  shells: string[];
+  /** Every offline route pattern (`/leads/[id]` included). */
+  routes: string[];
+  /** Path of the start URL; its shell answers any navigation with no
+   *  better match. */
+  startPath: string;
+  /** How long a navigation to an offline route waits for the network before
+   *  the worker answers with the shell. */
+  navigationTimeoutMs: number;
+}
+
+/** What the worker does with one request. */
+export type RequestKind =
+  /** A page load: network first, shell when offline. */
+  | "navigate"
+  /** A file of the client build: cache first. */
+  | "build"
+  /** The web app manifest or an icon: cache first. */
+  | "precached"
+  /** Not intercepted, never cached. */
+  | "network";
+
+/**
+ * Classify one request. Pure; `self.location.origin` is passed in.
+ */
+export function classifyRequest(
+  request: { url: string; method: string; mode: string },
+  config: ServiceWorkerConfig,
+  origin: string,
+): RequestKind {
+  if (request.method !== "GET") return "network";
+  let url: URL;
+  try {
+    url = new URL(request.url);
+  } catch {
+    return "network";
+  }
+  const sameOrigin = url.origin === origin;
+  if (sameOrigin) {
+    const path = url.pathname;
+    // Data and control endpoints. Data reaches the page through the sync
+    // engine; a cached API answer would be a stale copy of the replica, and
+    // a cached auth answer could sign in the wrong person.
+    const neverCached = [
+      "/api/",
+      "/auth/",
+      "/_pylon/dev/",
+      "/studio",
+      "/events",
+      "/health",
+      "/metrics",
+      "/.well-known/",
+      "/_pylon/version",
+    ];
+    for (const prefix of neverCached) {
+      if (path === prefix.replace(/\/$/, "") || path.startsWith(prefix)) return "network";
+    }
+    if (path === "/pylon-sw.js") return "network";
+    if (request.mode === "navigate") return "navigate";
+    if (path.startsWith("/_pylon/build/")) return "build";
+  }
+  if (!sameOrigin && config.buildPrefix && url.href.startsWith(config.buildPrefix)) {
+    return "build";
+  }
+  if (sameOrigin && config.precache.indexOf(url.pathname) !== -1) return "precached";
+  return "network";
+}
+
+/**
+ * The worker. `sw` is the ServiceWorkerGlobalScope (`self`); passing it in
+ * keeps the body free of globals so tests can supply their own. `classify`
+ * is `classifyRequest`, passed in for the same reason.
+ */
+export function pylonServiceWorker(
+  sw: any,
+  config: ServiceWorkerConfig,
+  classify: typeof classifyRequest,
+): void {
+  const ASSETS = "pylon-" + config.version + "-assets";
+  const SHELLS = "pylon-" + config.version + "-shells";
+  const STATE_KEY = "/__pylon_sw_state";
+  const SHELL_REQUEST_HEADER = "X-Pylon-Offline-Shell";
+  const SHELL_RESPONSE_HEADER = "Pylon-Offline-Shell";
+
+  function warn(message: string): void {
+    try {
+      sw.console.warn("[pylon offline] " + message);
+    } catch {
+      // No console in this scope.
+    }
+  }
+
+  function splitPath(p: string): string[] {
+    const trimmed = p.replace(/\/+$/, "");
+    return trimmed === "" ? [] : trimmed.slice(1).split("/");
+  }
+
+  // Does `pathname` match a route pattern (`/leads/[id]`, `/docs/[...slug]`)?
+  function matchesPattern(pattern: string, pathname: string): boolean {
+    const pat = splitPath(pattern);
+    const target = splitPath(pathname);
+    for (let i = 0; i < pat.length; i++) {
+      const seg = pat[i];
+      if (seg.startsWith("[...") && seg.endsWith("]")) return target.length > i;
+      if (seg.startsWith("[[...") && seg.endsWith("]]")) return true;
+      if (i >= target.length) return false;
+      if (seg.startsWith("[") && seg.endsWith("]")) continue;
+      if (seg !== target[i]) return false;
+    }
+    return pat.length === target.length;
+  }
+
+  function isOfflineRoute(pathname: string): boolean {
+    for (const route of config.routes) {
+      if (matchesPattern(route, pathname)) return true;
+    }
+    return false;
+  }
+
+  function normalizePath(pathname: string): string {
+    return pathname.length > 1 ? pathname.replace(/\/+$/, "") : pathname;
+  }
+
+  // Fetch each static offline route's HTML and keep the ones the runtime
+  // marks as identical for every signed-in user. Returns false when the
+  // network failed, so the caller does not record the refresh as done.
+  async function refreshShells(): Promise<boolean> {
+    const cache = await sw.caches.open(SHELLS);
+    let reached = false;
+    for (const path of config.shells) {
+      let res: any;
+      try {
+        res = await sw.fetch(path, {
+          headers: { [SHELL_REQUEST_HEADER]: "1" },
+          credentials: "same-origin",
+          cache: "no-store",
+        });
+      } catch {
+        continue;
+      }
+      reached = true;
+      const verdict = res.headers.get(SHELL_RESPONSE_HEADER);
+      if (res.ok && !res.redirected && verdict === "1") {
+        await cache.put(path, res);
+      } else if (res.redirected || (verdict && verdict !== "1") || res.status === 404) {
+        // A definite answer that this page is not a shell for the current
+        // session (a redirect to sign-in, a page that reads the user): drop
+        // the old copy so it is not shown to the wrong session. A server
+        // error keeps the old copy.
+        await cache.delete(path);
+        warn(
+          path +
+            " is not kept for offline use: " +
+            (verdict || (res.redirected ? "redirected to " + res.url : "status " + res.status)),
+        );
+      } else {
+        warn(path + " is not kept for offline use: status " + res.status);
+      }
+    }
+    return reached;
+  }
+
+  // The client posts its signed-in state after every page load. The shells
+  // carry that one bit, so refetch them when it changed.
+  async function syncSession(signedIn: boolean): Promise<void> {
+    const cache = await sw.caches.open(SHELLS);
+    const stored = await cache.match(STATE_KEY);
+    if (stored) {
+      const state = await stored.json();
+      if (state && state.signedIn === signedIn) return;
+    }
+    if (await refreshShells()) {
+      await cache.put(
+        STATE_KEY,
+        new sw.Response(JSON.stringify({ signedIn }), {
+          headers: { "Content-Type": "application/json" },
+        }),
+      );
+    }
+  }
+
+  async function shellFor(pathname: string): Promise<any> {
+    const cache = await sw.caches.open(SHELLS);
+    const exact = await cache.match(normalizePath(pathname));
+    if (exact) return exact;
+    return cache.match(config.startPath);
+  }
+
+  function withTimeout<T>(promise: Promise<T>, ms: number): Promise<T> {
+    return new Promise((resolve, reject) => {
+      const timer = sw.setTimeout(() => reject(new Error("timeout")), ms);
+      promise.then(
+        (v) => {
+          sw.clearTimeout(timer);
+          resolve(v);
+        },
+        (e) => {
+          sw.clearTimeout(timer);
+          reject(e);
+        },
+      );
+    });
+  }
+
+  async function handleNavigation(request: any): Promise<any> {
+    const pathname = new URL(request.url).pathname;
+    const offlineRoute = isOfflineRoute(pathname);
+    const network = sw.fetch(request);
+    try {
+      // Only an offline route has a page to show instead, so only an
+      // offline route stops waiting for a slow network.
+      return await (offlineRoute
+        ? withTimeout(network, config.navigationTimeoutMs)
+        : network);
+    } catch (err) {
+      const shell = await shellFor(pathname);
+      if (shell) return shell;
+      // Nothing kept: wait for the network after all (a slow answer beats
+      // the browser's offline page), and let a real failure through.
+      return network;
+    }
+  }
+
+  async function cacheFirst(request: any): Promise<any> {
+    const cache = await sw.caches.open(ASSETS);
+    const hit = await cache.match(request);
+    if (hit) return hit;
+    const res = await sw.fetch(request);
+    // Keep build files the page loads lazily (a dynamic import, an image
+    // the page imports), so they work offline after their first use.
+    if (res && res.ok) await cache.put(request, res.clone());
+    return res;
+  }
+
+  sw.addEventListener("install", (event: any) => {
+    event.waitUntil(
+      (async () => {
+        const cache = await sw.caches.open(ASSETS);
+        // All-or-nothing: a build file that fails to download fails the
+        // install, and the previous worker keeps serving the previous build.
+        await cache.addAll(config.precache);
+        await refreshShells();
+      })(),
+    );
+  });
+
+  sw.addEventListener("activate", (event: any) => {
+    event.waitUntil(
+      (async () => {
+        const names: string[] = await sw.caches.keys();
+        await Promise.all(
+          names
+            .filter(
+              (n) => n.indexOf("pylon-") === 0 && n !== ASSETS && n !== SHELLS,
+            )
+            .map((n) => sw.caches.delete(n)),
+        );
+        // Control the tab that installed the first worker, so the app works
+        // offline after one visit. With an older worker this runs only after
+        // every tab closed, so it never swaps a build mid-session.
+        await sw.clients.claim();
+      })(),
+    );
+  });
+
+  sw.addEventListener("fetch", (event: any) => {
+    const request = event.request;
+    const kind = classify(request, config, sw.location.origin);
+    if (kind === "navigate") event.respondWith(handleNavigation(request));
+    else if (kind === "build" || kind === "precached") event.respondWith(cacheFirst(request));
+  });
+
+  sw.addEventListener("message", (event: any) => {
+    const data = event.data;
+    if (!data) return;
+    if (data.type === "pylon:session" && typeof data.signedIn === "boolean") {
+      event.waitUntil(syncSession(data.signedIn));
+    } else if (data.type === "pylon:skip-waiting") {
+      event.waitUntil(sw.skipWaiting());
+    } else if (data.type === "pylon:version") {
+      const port = event.ports && event.ports[0];
+      if (port) port.postMessage({ type: "pylon:version", version: config.version });
+    }
+  });
+}
+
+/** The `/pylon-sw.js` source for one build. */
+export function renderServiceWorker(config: ServiceWorkerConfig): string {
+  return (
+    "// Generated by Pylon for this build. Do not edit.\n(" +
+    pylonServiceWorker.toString() +
+    ")(self, " +
+    JSON.stringify(config) +
+    ", " +
+    classifyRequest.toString() +
+    ");\n"
+  );
+}

package/src/runtime-files.test.ts

@@ -0,0 +1,55 @@
+/**
+ * Wire shapes of ctx.files.info and ctx.files.read (runtime.ts). Same
+ * child-process harness as runtime-vector.test.ts: the probe emits frames,
+ * and for read the test replies so the bytes come back decoded.
+ */
+import { expect, test } from "bun:test";
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const RUNTIME = join(import.meta.dir, "runtime.ts");
+
+const SCRIPT = `
+import { buildActionFiles, buildFiles } from ${JSON.stringify(RUNTIME)};
+
+buildFiles("c_i").info("file_1").catch(() => {});
+buildActionFiles("c_r").read("file_2").then((f) => {
+  process.stdout.write(JSON.stringify({ probe: "read", id: f.id, size: f.size, contentType: f.contentType, text: new TextDecoder().decode(f.data) }) + "\\n");
+  process.exit(0);
+}).catch((e) => { console.log(JSON.stringify({ probe: "error", message: String(e) })); process.exit(1); });
+setTimeout(() => process.exit(2), 3000);
+`;
+
+test("info and read emit files_op frames, and read decodes the bytes", async () => {
+  const dir = mkdtempSync(join(tmpdir(), "pylon-fn-files-"));
+  const scriptPath = join(dir, "probe.ts");
+  writeFileSync(scriptPath, SCRIPT);
+  const proc = Bun.spawn(["bun", scriptPath], { stdin: "pipe", stdout: "pipe", stderr: "pipe" });
+  const frames: Record<string, any>[] = [];
+  let replied = false;
+  const decoder = new TextDecoder();
+  let buffered = "";
+  for await (const chunk of proc.stdout) {
+    buffered += decoder.decode(chunk);
+    const lines = buffered.split("\n");
+    buffered = lines.pop() ?? "";
+    for (const line of lines) {
+      if (!line.trim().startsWith("{")) continue;
+      const frame = JSON.parse(line);
+      frames.push(frame);
+      if (frame.type === "files_op" && frame.op === "read" && !replied) {
+        replied = true;
+        const data = Buffer.from("hello file").toString("base64");
+        proc.stdin.write(
+          JSON.stringify({ type: "result", call_id: frame.call_id, data: { id: "file_2", contentType: "text/plain", size: 10, data_base64: data } }) + "\n",
+        );
+        proc.stdin.flush();
+      }
+    }
+  }
+  await proc.exited;
+  expect(frames.find((f) => f.type === "files_op" && f.op === "info")).toMatchObject({ call_id: "c_i", file_id: "file_1" });
+  expect(frames.find((f) => f.type === "files_op" && f.op === "read")).toMatchObject({ call_id: "c_r", file_id: "file_2" });
+  expect(frames.find((f) => f.probe === "read")).toEqual({ probe: "read", id: "file_2", size: 10, contentType: "text/plain", text: "hello file" });
+});

package/src/runtime.ts

@@ -23,6 +23,7 @@ import type {
   EmailOptions,
   EmailSender,
   Files,
+  FileInfo,
   ActionFiles,
   Crdt,
   StoredFile,
@@ -622,8 +623,8 @@ function buildShards(callId: string): Shards {
   };
 }
 
-/** `ctx.files` — signed download URLs, minted host-side. */
-function buildFiles(callId: string): Files {
+/** `ctx.files` — signed download URLs, minted host-side, and what the host knows of a file. */
+export function buildFiles(callId: string): Files {
   return {
     async signedUrl(fileId, opts) {
       return rpc(callId, {
@@ -632,11 +633,14 @@ function buildFiles(callId: string): Files {
         ttl_secs: opts?.ttlSecs,
       }) as Promise<string>;
     },
+    async info(fileId) {
+      return rpc(callId, { type: "files_op", op: "info", file_id: fileId }) as Promise<FileInfo | null>;
+    },
   };
 }
 
-/** `ctx.files` in an action: {@link buildFiles} plus store and delete. */
-function buildActionFiles(callId: string): ActionFiles {
+/** `ctx.files` in an action: {@link buildFiles} plus store, read and delete. */
+export function buildActionFiles(callId: string): ActionFiles {
   return {
     ...buildFiles(callId),
     async store(data, opts) {
@@ -667,6 +671,15 @@ function buildActionFiles(callId: string): ActionFiles {
         file_id: fileId,
       }) as Promise<{ deleted: boolean }>;
     },
+    async read(fileId) {
+      const out = (await rpc(callId, { type: "files_op", op: "read", file_id: fileId })) as {
+        id: string;
+        contentType: string | null;
+        size: number;
+        data_base64: string;
+      };
+      return { id: out.id, contentType: out.contentType ?? null, size: out.size, data: fromBase64(out.data_base64) };
+    },
   };
 }
 

package/src/ssr-barrel-imports.test.ts

@@ -0,0 +1,70 @@
+// Namespace barrels (`radix-ui`): parsing the entry, and rewriting named
+// imports of it into imports of the packages it re-exports.
+
+import { describe, expect, test } from "bun:test";
+import { parseNamespaceBarrel, rewriteBarrelImports } from "./ssr-barrel-imports";
+
+const RADIX = `// src/index.ts
+"use client";
+import * as AlertDialog from "@radix-ui/react-alert-dialog";
+import * as Dialog from "@radix-ui/react-dialog";
+import * as unstable_PasswordToggleField from "@radix-ui/react-password-toggle-field";
+export {
+  AlertDialog,
+  Dialog,
+  unstable_PasswordToggleField
+};
+//# sourceMappingURL=index.mjs.map
+`;
+
+describe("parseNamespaceBarrel", () => {
+  test("maps each exported namespace to its package", () => {
+    expect(Object.fromEntries(parseNamespaceBarrel(RADIX)!)).toEqual({
+      AlertDialog: "@radix-ui/react-alert-dialog",
+      Dialog: "@radix-ui/react-dialog",
+      unstable_PasswordToggleField: "@radix-ui/react-password-toggle-field",
+    });
+  });
+
+  test("anything else is not a barrel", () => {
+    expect(parseNamespaceBarrel(`export const x = 1;`)).toBeNull();
+    expect(parseNamespaceBarrel(`import * as A from "a"; export { A }; console.log(1);`)).toBeNull();
+    expect(parseNamespaceBarrel(`import { a } from "a"; export { a };`)).toBeNull();
+    expect(parseNamespaceBarrel(`import * as A from "a"; export { A, B };`)).toBeNull();
+    expect(parseNamespaceBarrel(``)).toBeNull();
+  });
+});
+
+describe("rewriteBarrelImports", () => {
+  const map = parseNamespaceBarrel(RADIX)!;
+  const barrels = (spec: string) => (spec === "radix-ui" ? map : null);
+  const same = (_barrel: string, spec: string) => spec;
+
+  test("one namespace import per name, keeping local names", () => {
+    expect(
+      rewriteBarrelImports(`import { Dialog as SheetPrimitive } from "radix-ui";`, barrels, same),
+    ).toBe(`import * as SheetPrimitive from "@radix-ui/react-dialog";`);
+    expect(
+      rewriteBarrelImports(`import {\n  AlertDialog,\n  Dialog,\n} from 'radix-ui'`, barrels, same),
+    ).toBe(`import * as AlertDialog from '@radix-ui/react-alert-dialog'; import * as Dialog from '@radix-ui/react-dialog';`);
+  });
+
+  test("type imports, unknown names and other packages stay", () => {
+    expect(rewriteBarrelImports(`import type { Dialog } from "radix-ui";`, barrels, same)).toBe(
+      `import type { Dialog } from "radix-ui";`,
+    );
+    expect(
+      rewriteBarrelImports(`import { Dialog, type Foo, Missing } from "radix-ui";`, barrels, same),
+    ).toBe(
+      `import { type Foo, Missing } from "radix-ui"; import * as Dialog from "@radix-ui/react-dialog";`,
+    );
+    const other = `import { useState } from "react";`;
+    expect(rewriteBarrelImports(other, barrels, same)).toBe(other);
+  });
+
+  test("the target specifier comes from the resolver", () => {
+    expect(
+      rewriteBarrelImports(`import { Dialog } from "radix-ui";`, barrels, () => "/abs/react-dialog/index.mjs"),
+    ).toBe(`import * as Dialog from "/abs/react-dialog/index.mjs";`);
+  });
+});

package/src/ssr-barrel-imports.ts

@@ -0,0 +1,104 @@
+// Per-route vendor code for "barrel" packages.
+//
+// A barrel is a package whose entry only re-exports other packages as
+// namespaces, like `radix-ui`:
+//
+//   import * as Dialog from "@radix-ui/react-dialog";
+//   import * as Select from "@radix-ui/react-select";
+//   export { Dialog, Select };
+//
+// With code splitting, every route that imports anything from the barrel
+// reaches every package it re-exports, so the bundler puts all of them in
+// one shared chunk that loads on every such route (55 KB gzip of Radix on
+// the Veritas home screen, which uses one Radix component). Rewriting
+//
+//   import { Dialog as SheetPrimitive } from "radix-ui";
+//
+// in app source to
+//
+//   import * as SheetPrimitive from "@radix-ui/react-dialog";
+//
+// lets each route reach only the packages it uses, so the splitter keeps
+// the rest out of its chunks. The client bundler applies this to app files
+// (not node_modules) for every bare import whose entry is a barrel.
+
+/**
+ * The namespaces a barrel entry re-exports (exported name → module
+ * specifier), or null when `source` is not a pure namespace barrel: any
+ * statement other than `import * as X from "..."` and `export { ... }` of
+ * those names makes it null.
+ */
+export function parseNamespaceBarrel(source: string): Map<string, string> | null {
+  const code = source
+    .replace(/\/\*[\s\S]*?\*\//g, "")
+    .replace(/^\s*\/\/.*$/gm, "")
+    .replace(/["']use client["'];?/g, "");
+  const imports = new Map<string, string>();
+  let rest = code.replace(
+    /import\s+\*\s+as\s+([A-Za-z_$][\w$]*)\s+from\s+(["'])([^"']+)\2\s*;?/g,
+    (_m, local: string, _q: string, spec: string) => {
+      imports.set(local, spec);
+      return "";
+    },
+  );
+  const exported = new Map<string, string>();
+  let ok = true;
+  rest = rest.replace(/export\s*\{([^}]*)\}\s*;?/g, (_m, list: string) => {
+    for (const item of list.split(",")) {
+      const part = item.trim();
+      if (!part) continue;
+      const m = part.match(/^([A-Za-z_$][\w$]*)(?:\s+as\s+([A-Za-z_$][\w$]*))?$/);
+      const spec = m ? imports.get(m[1]!) : undefined;
+      if (!m || !spec) {
+        ok = false;
+        continue;
+      }
+      exported.set(m[2] ?? m[1]!, spec);
+    }
+    return "";
+  });
+  if (!ok || rest.trim() !== "" || exported.size === 0) return null;
+  return exported;
+}
+
+/**
+ * Rewrite `import { A, B as C } from "<barrel>"` in `source` to one
+ * namespace import per name, from `resolveTarget(spec)` (the specifier the
+ * importing file should use for the re-exported module). Type-only imports
+ * and names the barrel does not re-export stay on the barrel import.
+ * `barrels` maps a bare specifier to its parsed barrel. Returns the source
+ * unchanged when nothing applies.
+ */
+export function rewriteBarrelImports(
+  source: string,
+  barrels: (specifier: string) => Map<string, string> | null,
+  resolveTarget: (barrel: string, spec: string) => string,
+): string {
+  return source.replace(
+    /import\s+(type\s+)?\{([^}]*)\}\s*from\s*(["'])([^"'./][^"']*)\3\s*;?/g,
+    (whole, typeOnly: string | undefined, list: string, quote: string, specifier: string) => {
+      if (typeOnly) return whole;
+      const map = barrels(specifier);
+      if (!map) return whole;
+      const kept: string[] = [];
+      const lines: string[] = [];
+      for (const item of list.split(",")) {
+        const part = item.trim();
+        if (!part) continue;
+        const m = part.match(/^(type\s+)?([A-Za-z_$][\w$]*)(?:\s+as\s+([A-Za-z_$][\w$]*))?$/);
+        const target = m && !m[1] ? map.get(m[2]!) : undefined;
+        if (!m || !target) {
+          kept.push(part);
+          continue;
+        }
+        const local = m[3] ?? m[2]!;
+        lines.push(`import * as ${local} from ${quote}${resolveTarget(specifier, target)}${quote};`);
+      }
+      if (lines.length === 0) return whole;
+      if (kept.length > 0) {
+        lines.unshift(`import { ${kept.join(", ")} } from ${quote}${specifier}${quote};`);
+      }
+      return lines.join(" ");
+    },
+  );
+}