npm - @frockbot/plugin-shell - Versions diffs - 0.3.1 → 0.3.3 - Mend

@frockbot/plugin-shell 0.3.1 → 0.3.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (44) hide show

package/package.json +32 -29
package/src/agent.test.ts +15 -3
package/src/backend-applets.test.ts +581 -0
package/src/backend-applets.ts +959 -0
package/src/backend-authoring.test.ts +61 -19
package/src/backend-authoring.ts +66 -27
package/src/backend-completion.ts +4 -2
package/src/backend-composition.ts +64 -0
package/src/backend-computer.test.ts +128 -0
package/src/backend-computer.ts +81 -0
package/src/backend-configuration.test.ts +8 -1
package/src/backend-iframe-ui.test.ts +29 -12
package/src/backend-isolate.ts +31 -5
package/src/backend-package-catalog.test.ts +13 -8
package/src/backend-package-catalog.ts +8 -6
package/src/backend-recovery-integration.test.ts +23 -0
package/src/backend-recovery.ts +20 -12
package/src/backend-runner-iframe.test.ts +10 -1
package/src/backend-runner.ts +9 -2
package/src/backend-stop.test.ts +6 -6
package/src/backend-supersede.test.ts +377 -0
package/src/backend.ts +567 -13
package/src/client/AppletCanvas.vue +679 -0
package/src/client/FrockBotApp.vue +195 -21
package/src/client/PackageEntryTrigger.vue +77 -0
package/src/client/PackageIframeHost.vue +148 -47
package/src/client/PackageIframeSettings.vue +8 -6
package/src/client/PackageSurfacePage.vue +39 -0
package/src/client/applets-client.test.ts +204 -0
package/src/client/applets-client.ts +139 -0
package/src/client/applets-state.ts +64 -0
package/src/client/index.test.ts +221 -7
package/src/client/index.ts +398 -6
package/src/client/package-iframe-entries.test.ts +122 -0
package/src/client/package-iframe-entries.ts +112 -0
package/src/client/package-iframe-host-message.test.ts +3 -3
package/src/client/package-iframe-host-message.ts +3 -3
package/src/client/styles.css +118 -1
package/src/composition-views.ts +31 -6
package/src/run-protocol.test.ts +92 -0
package/src/run-protocol.ts +193 -17
package/src/shared.ts +70 -0
package/src/terminal-records.test.ts +52 -1
package/src/terminal-records.ts +48 -0

package/src/backend-authoring.test.ts CHANGED Viewed

@@ -354,18 +354,27 @@ describe("a Bot authoring a Package", () => {
     });
   });
-  test("stores the second immutable artifact and records it in the same manifest", async () => {
+  test("stores every immutable page artifact and records them in the same manifest", async () => {
     const html = "<!doctype html><h1>Hello</h1>";
+    const boardHtml = "<!doctype html><h1>Board</h1>";
     const contentHash = await sha256HexV1(html);
+    const boardHash = await sha256HexV1(boardHtml);
+    const uiArtifact = (hash: string, text: string) => ({
+      contentHash: hash,
+      size: new TextEncoder().encode(text).byteLength,
+      mediaType: "text/html" as const,
+      bundlerVersion: "frockbot-inline-html@1",
+    });
     const bundler = countingBundler((effectId) => ({
       ...bundledResult(effectId),
-      uiArtifact: {
-        contentHash,
-        size: new TextEncoder().encode(html).byteLength,
-        mediaType: "text/html",
-        bundlerVersion: "frockbot-inline-html@1",
-      },
-      uiHtml: html,
+      uiArtifacts: [
+        { id: "main", artifact: uiArtifact(contentHash, html), html },
+        {
+          id: "board",
+          artifact: uiArtifact(boardHash, boardHtml),
+          html: boardHtml,
+        },
+      ],
     }));
     const request = requestFor();
     const outcome = await host({ bundler }).author({
@@ -374,13 +383,32 @@ describe("a Bot authoring a Package", () => {
         ...request.input,
         hooks: ["agent/tool-exposure", "tools/post-execute"],
         ui: {
-          html,
-          mounts: [{ slot: "frockbot.tool-result:hello" }],
+          pages: [
+            {
+              id: "main",
+              html,
+              mounts: [{ slot: "frockbot.tool-result:hello" }],
+            },
+            {
+              id: "board",
+              html: boardHtml,
+              mounts: [{ slot: "frockbot.surface:board" }],
+            },
+          ],
+          entries: [
+            {
+              id: "open",
+              slot: "frockbot.sidebar-actions",
+              label: "Board",
+              icon: "sparkle",
+              opens: { kind: "surface", page: "board" },
+            },
+          ],
         },
       },
     });
     expect(outcome.status).toBe("authored");
-    expect(writtenUi).toEqual([contentHash]);
+    expect(writtenUi).toEqual([contentHash, boardHash]);
     const artifact = storage.values.get(
       artifactKey("b".repeat(64)),
     ) as AuthoredArtifactRecordV1;
@@ -390,13 +418,27 @@ describe("a Bot authoring a Package", () => {
     const manifest = decodeFrockBotManifest(stored.manifest);
     expect(manifest.contributions.client).toEqual({
       kind: "iframe",
-      artifact: {
-        contentHash,
-        size: new TextEncoder().encode(html).byteLength,
-        mediaType: "text/html",
-        bundlerVersion: "frockbot-inline-html@1",
-      },
-      mounts: [{ slot: "frockbot.tool-result:hello" }],
+      pages: [
+        {
+          id: "main",
+          artifact: uiArtifact(contentHash, html),
+          mounts: [{ slot: "frockbot.tool-result:hello" }],
+        },
+        {
+          id: "board",
+          artifact: uiArtifact(boardHash, boardHtml),
+          mounts: [{ slot: "frockbot.surface:board" }],
+        },
+      ],
+      entries: [
+        {
+          id: "open",
+          slot: "frockbot.sidebar-actions",
+          label: "Board",
+          icon: "sparkle",
+          opens: { kind: "surface", page: "board" },
+        },
+      ],
     });
     expect(manifest.hooks).toEqual([
       "agent/tool-exposure",
@@ -853,7 +895,7 @@ describe("a Bot authoring a Package", () => {
     expect(view.contextContract).toContain(
       "interface BotPackageExecutionContextV1",
     );
-    expect(view.contextContract).toContain("interface FrockBotIframeBridgeV1");
+    expect(view.contextContract).toContain("interface FrockBotIframeBridgeV2");
     expect(view.contextContract).toContain("window.frockbot=");
     expect(view.composition.members).toContainEqual(
       expect.objectContaining({

package/src/backend-authoring.ts CHANGED Viewed

@@ -278,12 +278,25 @@ export function createPackageAuthoringHost(
    * Re-authoring may keep or rename tools owned by that same Package, so its
    * currently stored declarations are subtracted from the mounted catalog;
    * every first-party tool and every other authored Package remains reserved.
+   *
+   * The comparison is on bare names. Since ADR 0023 the mounted catalog
+   * reports a progressively disclosed tool as `namespace/name`, while a Package
+   * declares bare names, so comparing the two directly matches nothing and the
+   * guard silently stops refusing anything. Stripping the namespace keeps the
+   * rule this guard has always enforced — a Bot-authored tool name may not
+   * shadow one already registered — rather than quietly relaxing it as a side
+   * effect of a disclosure change.
    */
   async function collidingToolName(
     packageId: string,
     declaredNames: readonly string[],
   ): Promise<string | undefined> {
-    const registered = new Set(options.currentToolNames?.() ?? []);
+    const registered = new Set(
+      (options.currentToolNames?.() ?? []).map((name) => {
+        const separator = name.indexOf("/");
+        return separator < 0 ? name : name.slice(separator + 1);
+      }),
+    );
     const mounted =
       options.mountedGeneration?.() ??
       (await options.composition.lastKnownGood());
@@ -437,9 +450,9 @@ export function createPackageAuthoringHost(
         runId: options.runId,
         packageId: input.packageId,
         sourceHash: input.sourceHash,
-        ...(input.uiHtmlHash === undefined
+        ...(input.uiPageHashes === undefined
           ? {}
-          : { uiHtmlHash: input.uiHtmlHash }),
+          : { uiPageHashes: input.uiPageHashes }),
         ...(input.hooks === undefined ? {} : { hooks: input.hooks }),
       }),
@@ -560,13 +573,20 @@ export function createPackageAuthoringHost(
       );
       const ordinal = (previous?.ordinal ?? 0) + 1;
       const version = authoredVersionV1(ordinal);
-      const uiArtifact = request.input.ui
-        ? {
-            contentHash: await sha256(request.input.ui.html),
-            size: new TextEncoder().encode(request.input.ui.html).byteLength,
-            mediaType: "text/html" as const,
-            bundlerVersion: PACKAGE_UI_ARTIFACT_VERSION,
-          }
+      const uiPages = request.input.ui
+        ? await Promise.all(
+            request.input.ui.pages.map(async (page) => ({
+              id: page.id,
+              html: page.html,
+              mounts: page.mounts,
+              artifact: {
+                contentHash: await sha256(page.html),
+                size: new TextEncoder().encode(page.html).byteLength,
+                mediaType: "text/html" as const,
+                bundlerVersion: PACKAGE_UI_ARTIFACT_VERSION,
+              },
+            })),
+          )
         : undefined;
       const rawManifest = authoredManifestV1({
         packageId,
@@ -574,11 +594,17 @@ export function createPackageAuthoringHost(
         version,
         tools: request.input.tools,
         hooks: request.input.hooks,
-        ...(request.input.ui && uiArtifact
+        ...(request.input.ui && uiPages
           ? {
               ui: {
-                artifact: uiArtifact,
-                mounts: request.input.ui.mounts,
+                pages: uiPages.map((page) => ({
+                  id: page.id,
+                  artifact: page.artifact,
+                  mounts: page.mounts,
+                })),
+                ...(request.input.ui.entries
+                  ? { entries: request.input.ui.entries }
+                  : {}),
               },
             }
           : {}),
@@ -653,8 +679,13 @@ export function createPackageAuthoringHost(
         compatibilityDate: options.compatibilityDate,
         entry: "package.ts",
         sources: [{ path: "package.ts", text: request.input.source }],
-        ...(request.input.ui
-          ? { ui: { path: "ui.html" as const, html: request.input.ui.html } }
+        ...(uiPages
+          ? {
+              uiPages: uiPages.map((page) => ({
+                id: page.id,
+                html: page.html,
+              })),
+            }
           : {}),
       };
       let bundled;
@@ -696,15 +727,23 @@ export function createPackageAuthoringHost(
       }
       const { artifact } = bundled;
-      if (
-        uiArtifact &&
-        (!bundled.uiArtifact ||
-          bundled.uiHtml !== request.input.ui?.html ||
-          bundled.uiArtifact.contentHash !== uiArtifact.contentHash ||
-          bundled.uiArtifact.size !== uiArtifact.size ||
-          bundled.uiArtifact.mediaType !== uiArtifact.mediaType ||
-          bundled.uiArtifact.bundlerVersion !== uiArtifact.bundlerVersion)
-      ) {
+      const returnedPages = bundled.uiArtifacts ?? [];
+      const uiMismatch =
+        uiPages !== undefined &&
+        (returnedPages.length !== uiPages.length ||
+          uiPages.some((page, index) => {
+            const returned = returnedPages[index];
+            return (
+              !returned ||
+              returned.id !== page.id ||
+              returned.html !== page.html ||
+              returned.artifact.contentHash !== page.artifact.contentHash ||
+              returned.artifact.size !== page.artifact.size ||
+              returned.artifact.mediaType !== page.artifact.mediaType ||
+              returned.artifact.bundlerVersion !== page.artifact.bundlerVersion
+            );
+          }));
+      if (uiMismatch || (uiPages === undefined && returnedPages.length > 0)) {
         return refused(
           await recordFailure({
             effectId,
@@ -721,10 +760,10 @@ export function createPackageAuthoringHost(
         artifact.contentHash,
         bundled.module,
       );
-      if (bundled.uiArtifact && bundled.uiHtml) {
+      for (const page of returnedPages) {
         await options.artifacts.putPackageUiArtifact!(
-          bundled.uiArtifact.contentHash,
-          bundled.uiHtml,
+          page.artifact.contentHash,
+          page.html,
         );
       }
       await options.artifacts.putPackageSource(

package/src/backend-completion.ts CHANGED Viewed

@@ -23,7 +23,7 @@ export function completeStoredRun(
   previous: readonly SessionEvent[],
   result: BotTurnCompletion,
   packageRecords?: TerminalPackageRecords<BotSettingsViewV1>,
-): Promise<"completed" | "cancelled"> {
+): Promise<"completed" | "cancelled" | "superseded"> {
   return completeKernelStoredRun(
     storedRunCodecV1,
     storage,
@@ -42,7 +42,9 @@ export function failStoredRun(
   previous: readonly SessionEvent[],
   events: readonly SessionEvent[],
   failure: string,
-): Promise<"failed" | "cancelled" | "preserved-completion" | "missing"> {
+): Promise<
+  "failed" | "cancelled" | "superseded" | "preserved-completion" | "missing"
+> {
   return failKernelStoredRun(
     storedRunCodecV1,
     storage,

package/src/backend-composition.ts CHANGED Viewed

@@ -49,6 +49,9 @@ export function bootstrapCompositionGeneration(
       specifier: pkg.specifier,
       version: pkg.version,
       manifest: pkg.manifest,
+      // A first-party member the application declared an artifact for loads
+      // through the isolate host, not the application's Contribution table.
+      ...(pkg.artifact ? { artifact: pkg.artifact } : {}),
     })),
     { createdAt },
   );
@@ -84,6 +87,23 @@ export interface ShellIsolateMountOptions {
   deadlineMs?: number;
 }
+/**
+ * How an Applet member's tools reach their instance.
+ *
+ * The Applet Durable Object forwards to the facet; a facet stub is not
+ * serializable and never leaves that object, so this is a call, never a stub
+ * (`docs/research/spike-applet-facets.md` §8). Absent when the Bot Durable
+ * Object has no Applet binding: an Applet member's tools are then simply not
+ * registered, exactly as an isolate member fails without a loader.
+ */
+export interface ShellAppletMountOptions {
+  invokeTool(request: {
+    appletId: string;
+    tool: string;
+    input: unknown;
+  }): Promise<{ status: "ok" | "error"; content: string }>;
+}
 export interface ShellCompositionMountOptions {
   botId: string;
   sessionId: string;
@@ -110,6 +130,8 @@ export interface ShellCompositionMountOptions {
   subagentRole?: string;
   /** Absent when the host cannot load isolates; isolate members then fail verify. */
   isolate?: ShellIsolateMountOptions;
+  /** Absent when the host cannot reach Applet instances. */
+  applets?: ShellAppletMountOptions;
 }
 export interface ShellCompositionHost extends CompositionHost {
@@ -226,7 +248,49 @@ export function createShellCompositionHost(
         }
       }
+      // Applet members. Their tools are ordinary tools in this Bot's catalog
+      // (ADR 0022 decision 4), pinned to this generation like every other
+      // member, and routed to the Applet Durable Object. An Applet contributes
+      // no module and no manifest, so there is nothing here to mount, load, or
+      // health-check: the instance's own health check ran when its generation
+      // was published, and its failure is recorded there.
+      const unregisterApplets: (() => void)[] = [];
+      for (const applet of generation.applets ?? []) {
+        if (!options.applets) {
+          failures.push({
+            phase: "resolve",
+            message: `Applet "${applet.appletId}" needs an Applet binding and this host has none`,
+          });
+          continue;
+        }
+        const routing = options.applets;
+        for (const tool of applet.tools) {
+          unregisterApplets.push(
+            runtime.root.tools.register({
+              name: tool.name,
+              // Provenance travels into the catalog the model reads, so a Bot
+              // can tell an Applet's tool from a Package's.
+              description: `${tool.description} (Applet "${applet.appletId}", generation ${applet.generationId})`,
+              inputSchema: tool.inputSchema,
+              idempotent: false,
+              execute: async (input) => {
+                const outcome = await routing.invokeTool({
+                  appletId: applet.appletId,
+                  tool: tool.name,
+                  input: input ?? null,
+                });
+                return {
+                  content: outcome.content,
+                  isError: outcome.status === "error",
+                };
+              },
+            }),
+          );
+        }
+      }
       const dispose = async () => {
+        for (const unregister of unregisterApplets.toReversed()) unregister();
         for (const contribution of active.toReversed()) {
           await contribution.dispose();
         }

package/src/backend-computer.test.ts ADDED Viewed

@@ -0,0 +1,128 @@
+import { describe, expect, test } from "bun:test";
+import type { FrockBotManifest } from "@frockbot/kernel-composition";
+import {
+  createBotComputerSyncHost,
+  declaredPackageRootsV1,
+} from "./backend-computer.ts";
+function pkg(
+  id: string,
+  version: string,
+  roots?: FrockBotManifest["roots"],
+): { id: string; version: string; manifest: FrockBotManifest } {
+  return {
+    id,
+    version,
+    manifest: {
+      schemaVersion: 4,
+      id,
+      displayName: id,
+      version,
+      compatibility: { frockbot: "*" },
+      dependencies: {},
+      contributions: {},
+      permissions: [],
+      ...(roots ? { roots } : {}),
+    },
+  };
+}
+const packages = [
+  pkg("image", "0.0.1", [{ id: "generated", scope: "user" }]),
+  pkg("applets", "0.0.1", [{ id: "source", scope: "user" }]),
+  pkg("clock", "0.0.1"),
+];
+describe("the durable roots a User's Packages declare", () => {
+  test("supplies every enabled Package's declared roots, sorted", () => {
+    expect(
+      declaredPackageRootsV1({
+        installations: [
+          { packageId: "applets", version: "0.0.1", state: "installed" },
+          { packageId: "image", version: "0.0.1", state: "installed" },
+          { packageId: "clock", version: "0.0.1", state: "installed" },
+        ],
+        packages,
+      }),
+    ).toEqual([
+      { packageId: "applets", rootId: "source" },
+      { packageId: "image", rootId: "generated" },
+    ]);
+  });
+  test("a Package that declares no root contributes none", () => {
+    expect(
+      declaredPackageRootsV1({
+        installations: [
+          { packageId: "clock", version: "0.0.1", state: "installed" },
+        ],
+        packages,
+      }),
+    ).toEqual([]);
+  });
+  test("enablement decides: a disabled or failed install syncs nothing", () => {
+    // Materializing files for a Package that cannot run would leave
+    // directories on a Computer that no Bot on it could explain, and would
+    // keep syncing them after an uninstall.
+    for (const state of ["disabled", "failed"] as const) {
+      expect(
+        declaredPackageRootsV1({
+          installations: [{ packageId: "image", version: "0.0.1", state }],
+          packages,
+        }),
+      ).toEqual([]);
+    }
+  });
+  test("the installed version decides which manifest declares the roots", () => {
+    expect(
+      declaredPackageRootsV1({
+        installations: [
+          { packageId: "image", version: "0.0.2", state: "installed" },
+        ],
+        packages,
+      }),
+    ).toEqual([]);
+  });
+  test("one entry per root, whatever the installations say", () => {
+    expect(
+      declaredPackageRootsV1({
+        installations: [
+          { packageId: "image", version: "0.0.1", state: "installed" },
+          { packageId: "image", version: "0.0.1", state: "installed" },
+        ],
+        packages,
+      }),
+    ).toEqual([{ packageId: "image", rootId: "generated" }]);
+  });
+});
+describe("the Computer sync seam", () => {
+  const store = {} as never;
+  test("carries the declared roots to the provider", () => {
+    const host = createBotComputerSyncHost({ WORKSPACE_SYNC_FILES: store }, [
+      { packageId: "applets", rootId: "source" },
+    ]);
+    expect(host?.packageRoots).toEqual([
+      { packageId: "applets", rootId: "source" },
+    ]);
+  });
+  test("omits the field entirely when no Package declared a root", () => {
+    // Absent rather than empty: a provider then behaves exactly as it did
+    // before any host supplied a list.
+    const host = createBotComputerSyncHost({ WORKSPACE_SYNC_FILES: store });
+    expect(host && "packageRoots" in host).toBe(false);
+  });
+  test("no store binding is no sync at all, roots or not", () => {
+    expect(
+      createBotComputerSyncHost({}, [
+        { packageId: "applets", rootId: "source" },
+      ]),
+    ).toBeUndefined();
+  });
+});

package/src/backend-computer.ts CHANGED Viewed

@@ -33,6 +33,81 @@ import type {
   WorkspaceSyncEffectsV1,
 } from "@frockbot/kernel-contracts";
 import type { ComputerSyncHostV1 } from "@frockbot/computer-core";
+import type { FrockBotManifest } from "@frockbot/kernel-composition";
+/**
+ * One installed Package, as the durable-root supplier needs to see it: what
+ * the User installed, and what that exact version's manifest declares.
+ */
+export interface DeclaredPackageRootSourceV1 {
+  /** The User's installations, from the User configuration view. */
+  installations: readonly {
+    packageId: string;
+    version: string;
+    state: "installed" | "disabled" | "failed";
+  }[];
+  /** The application's compiled Packages, each with the manifest it shipped. */
+  packages: readonly {
+    id: string;
+    version: string;
+    manifest: FrockBotManifest;
+  }[];
+}
+/**
+ * The `package-declared` durable roots this User's *enabled* Packages declare.
+ *
+ * "Durable roots, declared by the Computer Package's Workspace layout and by
+ * Package manifests." Until this existed the second half of that sentence had
+ * no supplier: `declaredWorkspaceRootsV1` took a `packageRoots` argument that
+ * nothing in production passed, so `image/generated` — a root the Image
+ * Package has written since it shipped — never reached the durable-root sync
+ * and never appeared on a Computer. This is the missing half, and
+ * `applets/source` (ADR 0022) is the reason it could no longer be missing.
+ *
+ * ENABLEMENT decides membership, by the same `state === "installed"` test
+ * `resolveBotExecutionPlanV1` applies to Capabilities and against the same
+ * exact version the application compiled. A root of a Package the User
+ * disabled or never installed is not synchronized: materializing files for a
+ * Package that cannot run would grow directories on a Computer that no Bot on
+ * it could explain, and would keep syncing them after an uninstall.
+ *
+ * SCOPE is the User's, always. A `package-declared` root names no Bot, so this
+ * takes no Bot and answers the same for every tenant on one Computer.
+ */
+export function declaredPackageRootsV1(
+  source: DeclaredPackageRootSourceV1,
+): { packageId: string; rootId: string }[] {
+  const roots: { packageId: string; rootId: string }[] = [];
+  for (const installation of source.installations) {
+    if (installation.state !== "installed") continue;
+    const declared = source.packages.find(
+      (candidate) =>
+        candidate.id === installation.packageId &&
+        candidate.version === installation.version,
+    );
+    for (const root of declared?.manifest.roots ?? []) {
+      const entry = { packageId: installation.packageId, rootId: root.id };
+      // One entry per root: the sync walks this list, and a duplicate would
+      // reconcile the same root twice in a single pass.
+      if (
+        !roots.some(
+          (candidate) =>
+            candidate.packageId === entry.packageId &&
+            candidate.rootId === entry.rootId,
+        )
+      ) {
+        roots.push(entry);
+      }
+    }
+  }
+  roots.sort(
+    (left, right) =>
+      left.packageId.localeCompare(right.packageId) ||
+      left.rootId.localeCompare(right.rootId),
+  );
+  return roots;
+}
 /**
  * The narrow slice of the Durable Object environment this module reads. Named
@@ -55,9 +130,14 @@ export interface BotComputerSyncEnv {
  * above. What a sync finds on the Computer is attributed to nobody, so knowing
  * which Bot, Session, and Turn asked for the sync would only be an invitation
  * to record a writer this seam cannot support.
+ *
+ * `packageRoots` is the one thing it does take beyond the bindings, because a
+ * Package's declared roots are a fact about the *User's* installation rather
+ * than about the Turn: see {@link declaredPackageRootsV1}.
  */
 export function createBotComputerSyncHost(
   env: object,
+  packageRoots: readonly { packageId: string; rootId: string }[] = [],
 ): ComputerSyncHostV1 | undefined {
   // SAFETY: these surfaces are constructed onto the Durable Object environment
   // rather than declared in the generated `Env`; they are not Worker bindings.
@@ -72,5 +152,6 @@ export function createBotComputerSyncHost(
     ...(bound.WORKSPACE_SYNC_GENERATIONS
       ? { generations: bound.WORKSPACE_SYNC_GENERATIONS }
       : {}),
+    ...(packageRoots.length > 0 ? { packageRoots } : {}),
   };
 }

package/src/backend-configuration.test.ts CHANGED Viewed

@@ -88,8 +88,15 @@ async function compileModelTestApplication(): ReturnType<
   return {
     ...application,
     packages: [
+      // Artifact-backed members are dropped with them: `bun test` gives this
+      // host no Worker Loader, so an isolate member has nowhere to load from
+      // and the Composition would fail verification closed — correct, and not
+      // what this suite is about. workerd's suites mount the real thing.
       ...application.packages.filter(
-        (pkg) => pkg.id !== provider.id && pkg.id !== "custom-models",
+        (pkg) =>
+          pkg.artifact === undefined &&
+          pkg.id !== provider.id &&
+          pkg.id !== "custom-models",
       ),
       provider,
       {