@mh-gg/base 0.1.1-alpha.20260613T085325975Z

package/test/matterhorn-core.test.cjs

@@ -0,0 +1,731 @@
+const assert = require("node:assert/strict");
+const crypto = require("node:crypto");
+const test = require("node:test");
+
+const {
+  APP_PACK_KIND,
+  HOST_PACK_KIND,
+  PLAYER_PACK_KIND,
+  assertManifestIntegrity,
+  assertProductionPluginGates,
+  assertTrustedManifest,
+  capabilityAudit,
+  createInMemoryPackRegistry,
+  createMemoryTrustStore,
+  createPublisherTrustStore,
+  choosePlayerPacks,
+  computeAppProtocolHash,
+  createAppPackManifest,
+  createHostPackManifest,
+  createPackBundle,
+  createPlayerPackManifest,
+  createMatterhornAppContract,
+  definePlayerPlugin,
+  hashCanonical,
+  loadPackReference,
+  manifestHash,
+  parsePackReferenceUrl,
+  playerSupportsApp,
+  resolveHostPluginGraph,
+  satisfiesVersion,
+  signManifest,
+  stripManifestSignatures,
+  validateAppPackManifest,
+  validateHostPackManifest,
+  validatePlayerPackManifest,
+  verifyPackBundle,
+  verifySignedManifest
+} = require("../src/index.cjs");
+
+const publisher = {
+  id: "com.matterhorn",
+  name: "Matterhorn Official",
+  publicKey: "rk_pub_test"
+};
+
+const signatures = [
+  {
+    publicKey: "rk_pub_test",
+    signature: "sig_test"
+  }
+];
+
+const hostPlugins = [
+  {
+    id: "@mh-gg/plugin-kanban",
+    version: "1.0.0",
+    stateSchemaHash: "sha256-kanban-state",
+    operationSchemaHash: "sha256-kanban-ops"
+  },
+  {
+    id: "@mh-gg/plugin-roles",
+    version: "1.0.0",
+    stateSchemaHash: "sha256-roles-state",
+    operationSchemaHash: "sha256-roles-ops",
+    eventSchemaHash: "sha256-roles-events"
+  }
+];
+
+function appProtocolHash() {
+  return computeAppProtocolHash({
+    appPackId: "com.matterhorn.kanban",
+    appVersion: "1.0.0",
+    hostPlugins
+  });
+}
+
+function appPack(overrides = {}) {
+  return {
+    kind: APP_PACK_KIND,
+    id: "com.matterhorn.kanban",
+    name: "Kanban",
+    version: "1.0.0",
+    publisher,
+    matterhornVersion: ">=0.1 <0.2",
+    hostPack: {
+      url: "https://registry.matterhorn.gg/kanban/1.0.0/host-pack.json",
+      integrity: "sha256-hostpack"
+    },
+    playerPacks: [
+      {
+        id: "com.matterhorn.kanban.desktop",
+        name: "Kanban Desktop",
+        url: "https://apps.matterhorn.gg/kanban/desktop/1.0.0/player-pack.json",
+        integrity: "sha256-player",
+        recommendedFor: {
+          devices: ["desktop"],
+          roles: ["admin", "member"]
+        }
+      }
+    ],
+    compatibility: {
+      appProtocolHash: appProtocolHash(),
+      operationSchemaHash: "sha256-ops",
+      stateSchemaHash: "sha256-state"
+    },
+    capabilities: {
+      required: ["room.state", "room.roles"]
+    },
+    trust: {
+      createdAt: "2026-05-26T00:00:00Z",
+      signatures
+    },
+    ...overrides
+  };
+}
+
+function hostPack(overrides = {}) {
+  return {
+    kind: HOST_PACK_KIND,
+    id: "com.matterhorn.kanban.host",
+    appPackId: "com.matterhorn.kanban",
+    version: "1.0.0",
+    plugins: [
+      {
+        id: "@mh-gg/plugin-kanban",
+        version: "1.0.0",
+        source: "npm:@mh-gg/plugin-kanban@1.0.0",
+        integrity: "sha256-kanban"
+      }
+    ],
+    compatibility: {
+      appProtocolHash: appProtocolHash(),
+      pluginGraphHash: "sha256-graph"
+    },
+    runtime: {
+      minMatterhornVersion: "0.1.0",
+      sandbox: "process"
+    },
+    capabilities: {
+      required: ["room.state", "room.roles"]
+    },
+    trust: {
+      signatures
+    },
+    ...overrides
+  };
+}
+
+function playerPack(overrides = {}) {
+  return {
+    kind: PLAYER_PACK_KIND,
+    id: "com.matterhorn.kanban.desktop",
+    name: "Kanban Desktop",
+    version: "1.0.0",
+    publisher,
+    entrypoints: {
+      default: "https://apps.matterhorn.gg/kanban/desktop/1.0.0/"
+    },
+    supports: [
+      {
+        appPackId: "com.matterhorn.kanban",
+        appPackRange: "^1.0.0",
+        appProtocolHash: appProtocolHash()
+      }
+    ],
+    recommendedFor: {
+      devices: ["desktop"],
+      roles: ["admin", "member"]
+    },
+    mode: "external",
+    trust: {
+      integrity: "sha256-player",
+      signatures
+    },
+    ...overrides
+  };
+}
+
+test("manifest hash ignores signatures but preserves signed content", () => {
+  const first = appPack();
+  const second = appPack({
+    trust: {
+      createdAt: "2026-05-26T00:00:00Z",
+      signatures: [{ publicKey: "rk_pub_other", signature: "sig_other" }]
+    }
+  });
+  const changed = appPack({ name: "Kanban Changed" });
+
+  assert.equal(manifestHash(first), manifestHash(second));
+  assert.notEqual(manifestHash(first), manifestHash(changed));
+  assert.deepEqual(stripManifestSignatures(first).trust, {
+    createdAt: "2026-05-26T00:00:00Z"
+  });
+  assert.match(hashCanonical({ b: 2, a: "x" }), /^sha256-/);
+});
+
+test("validates app, host, and player pack manifests", () => {
+  assert.equal(validateAppPackManifest(appPack()).id, "com.matterhorn.kanban");
+  assert.equal(validateHostPackManifest(hostPack()).id, "com.matterhorn.kanban.host");
+  assert.equal(validatePlayerPackManifest(playerPack()).id, "com.matterhorn.kanban.desktop");
+
+  assert.throws(() => validateAppPackManifest(appPack({ kind: "wrong" })), /Expected kind matterhorn\.app-pack/);
+  assert.throws(() => validateHostPackManifest(hostPack({ plugins: [] })), /plugins must not be empty/);
+  assert.throws(() => validatePlayerPackManifest(playerPack({ mode: "iframe" })), /mode is invalid/);
+});
+
+test("computes deterministic protocol contracts from plugin schema hashes", () => {
+  const protocolA = computeAppProtocolHash({
+    appPackId: "com.matterhorn.kanban",
+    appVersion: "1.0.0",
+    hostPlugins
+  });
+  const protocolB = computeAppProtocolHash({
+    appPackId: "com.matterhorn.kanban",
+    appVersion: "1.0.0",
+    hostPlugins: [...hostPlugins].reverse()
+  });
+
+  assert.equal(protocolA, protocolB);
+
+  const contract = createMatterhornAppContract({
+    appPack: appPack(),
+    hostPlugins
+  });
+
+  assert.deepEqual(contract.hostPlugins.map((plugin) => plugin.id), [
+    "@mh-gg/plugin-kanban",
+    "@mh-gg/plugin-roles"
+  ]);
+  assert.equal(contract.appPackId, "com.matterhorn.kanban");
+  assert.equal(contract.appProtocolHash, protocolA);
+
+  assert.throws(
+    () => createMatterhornAppContract({
+      appPack: appPack({ compatibility: { ...appPack().compatibility, appProtocolHash: "sha256-wrong" } }),
+      hostPlugins
+    }),
+    /App protocol hash mismatch/
+  );
+});
+
+test("checks manifest integrity using content-addressed hashes", () => {
+  const manifest = appPack();
+  const expected = manifestHash(manifest);
+
+  assert.equal(assertManifestIntegrity(manifest, expected).hash, expected);
+  assert.throws(() => assertManifestIntegrity(manifest, "sha256-wrong"), /Manifest integrity mismatch/);
+});
+
+test("signs and verifies manifests against their content hash", () => {
+  const { privateKey, publicKey } = crypto.generateKeyPairSync("ed25519");
+  const publicKeyPem = publicKey.export({ type: "spki", format: "pem" });
+  const trustedPublisher = { ...publisher, publicKey: publicKeyPem };
+  const signed = signManifest(
+    appPack({ publisher: trustedPublisher }),
+    privateKey.export({ type: "pkcs8", format: "pem" }),
+    publicKeyPem
+  );
+
+  assert.equal(signed.trust.signatures[0].publicKey, publicKeyPem);
+  assert.equal(verifySignedManifest(signed).ok, true);
+  assert.equal(assertTrustedManifest(signed, createPublisherTrustStore({ publishers: { [publisher.id]: "trusted" } })).ok, true);
+
+  const memoryTrust = createMemoryTrustStore();
+  assert.throws(() => assertTrustedManifest(signed, memoryTrust), /not trusted/);
+  memoryTrust.trustPublisher({ publisherId: publisher.id, publicKey: publicKeyPem });
+  assert.equal(assertTrustedManifest(signed, memoryTrust).ok, true);
+
+  const attacker = crypto.generateKeyPairSync("ed25519");
+  const attackerPublicKeyPem = attacker.publicKey.export({ type: "spki", format: "pem" });
+  const forged = signManifest(
+    appPack({ publisher: trustedPublisher }),
+    attacker.privateKey.export({ type: "pkcs8", format: "pem" }),
+    attackerPublicKeyPem
+  );
+  assert.throws(
+    () => assertTrustedManifest(forged, createPublisherTrustStore({ publishers: { [publisher.id]: "trusted" } })),
+    /trusted signature/
+  );
+  assert.equal(verifySignedManifest({ ...signed, name: "Tampered" }).ok, false);
+  assert.equal(verifySignedManifest({
+    ...signed,
+    trust: { ...signed.trust, signatures: [{ publicKey: "bad-key", signature: "bad-signature" }] }
+  }).ok, false);
+});
+
+test("selects trusted compatible player packs by preference, device, and role", () => {
+  const app = appPack();
+  const preferred = playerPack({
+    id: "com.matterhorn.kanban.mobile",
+    recommendedFor: {
+      devices: ["mobile"],
+      roles: ["member"]
+    }
+  });
+  const fallback = playerPack({ id: "com.matterhorn.kanban.desktop" });
+  const incompatible = playerPack({
+    id: "com.matterhorn.other",
+    supports: [{ appPackId: "com.matterhorn.other", appPackRange: "^1.0.0", appProtocolHash: app.compatibility.appProtocolHash }]
+  });
+  const untrusted = playerPack({
+    id: "com.matterhorn.untrusted",
+    publisher: { ...publisher, id: "example.untrusted" }
+  });
+
+  assert.equal(playerSupportsApp(preferred, app), true);
+  assert.equal(playerSupportsApp(incompatible, app), false);
+
+  const selected = choosePlayerPacks({
+    appPack: app,
+    playerPacks: [fallback, incompatible, preferred, untrusted],
+    isTrustedPublisher: (candidate) => candidate.id === "com.matterhorn",
+    userPreferences: {
+      defaultByAppPack: {
+        "com.matterhorn.kanban": "com.matterhorn.kanban.mobile"
+      }
+    },
+    device: { class: "mobile" },
+    actor: { role: "member" }
+  });
+
+  assert.deepEqual(selected.map((player) => player.id), [
+    "com.matterhorn.kanban.mobile",
+    "com.matterhorn.kanban.desktop"
+  ]);
+});
+
+test("matches exact, wildcard, and caret app pack versions", () => {
+  assert.equal(satisfiesVersion("1.0.0", "1.0.0"), true);
+  assert.equal(satisfiesVersion("1.0.1", "1.0.0"), false);
+  assert.equal(satisfiesVersion("2.0.0", "*"), true);
+  assert.equal(satisfiesVersion("1.2.0", "^1.0.0"), true);
+  assert.equal(satisfiesVersion("2.0.0", "^1.0.0"), false);
+  assert.equal(satisfiesVersion("0.9.9", "^1.0.0"), false);
+  assert.throws(() => satisfiesVersion("1.0", "^1.0.0"), /version must be a x\.y\.z version/);
+});
+
+test("scores room, group, and low-bandwidth player preferences deterministically", () => {
+  const app = appPack();
+  const lowBandwidth = playerPack({
+    id: "com.matterhorn.kanban.low",
+    recommendedFor: {
+      devices: ["low-bandwidth"]
+    }
+  });
+  const groupChoice = playerPack({ id: "com.matterhorn.kanban.group" });
+  const roomChoice = playerPack({ id: "com.matterhorn.kanban.room" });
+
+  const selected = choosePlayerPacks({
+    room: { id: "room_design" },
+    appPack: app,
+    playerPacks: [lowBandwidth, groupChoice, roomChoice],
+    userPreferences: {
+      defaultByRoom: {
+        room_design: "com.matterhorn.kanban.room"
+      }
+    },
+    groupPreferences: {
+      recommendedFrontends: {
+        "com.matterhorn.kanban": "com.matterhorn.kanban.group"
+      }
+    },
+    device: {
+      class: "desktop",
+      lowBandwidth: true
+    }
+  });
+
+  assert.deepEqual(selected.map((player) => player.id), [
+    "com.matterhorn.kanban.room",
+    "com.matterhorn.kanban.group",
+    "com.matterhorn.kanban.low"
+  ]);
+});
+
+test("validates optional manifest fields and malformed inputs", () => {
+  assert.equal(validateAppPackManifest(appPack({
+    compatibility: {
+      ...appPack().compatibility,
+      eventSchemaHash: "sha256-events"
+    }
+  })).compatibility.eventSchemaHash, "sha256-events");
+
+  assert.equal(validateHostPackManifest(hostPack({
+    runtime: {
+      minMatterhornVersion: "0.1.0",
+      sandbox: "wasm"
+    },
+    capabilities: {
+      required: ["room.state"],
+      optional: ["network.fetch"]
+    }
+  })).runtime.sandbox, "wasm");
+
+  assert.equal(validatePlayerPackManifest(playerPack({
+    entrypoints: {
+      default: "https://apps.matterhorn.gg/default/",
+      admin: "https://apps.matterhorn.gg/admin/",
+      mobile: "https://apps.matterhorn.gg/mobile/",
+      kiosk: "https://apps.matterhorn.gg/kiosk/",
+      embedded: "https://apps.matterhorn.gg/embed/"
+    },
+    supports: [
+      {
+        appPackId: "com.matterhorn.kanban",
+        appPackRange: "^1.0.0",
+        appProtocolHash: appProtocolHash(),
+        pluginIds: ["@mh-gg/plugin-kanban"]
+      }
+    ],
+    recommendedFor: {
+      devices: ["tablet"],
+      roles: ["admin"],
+      groups: ["group_ops"]
+    }
+  })).supports[0].pluginIds[0], "@mh-gg/plugin-kanban");
+
+  assert.deepEqual(stripManifestSignatures({ kind: "matterhorn.app" }), { kind: "matterhorn.app" });
+  assert.throws(() => validatePlayerPackManifest(null), /player pack must be an object/);
+  assert.throws(() => assertManifestIntegrity(appPack(), "not-a-hash"), /expectedHash must be a sha256 hash/);
+});
+
+test("loads pack manifests from local refs, workspace refs, and rejects bad integrity", async (t) => {
+  const fs = require("node:fs/promises");
+  const os = require("node:os");
+  const path = require("node:path");
+  const {
+    loadPackManifest,
+    loadPackArtifact,
+    normalizePackRef,
+    sha256Bytes
+  } = require("../src/index.cjs");
+  const app = appPack();
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), "matterhorn-core-pack-"));
+  const file = path.join(dir, "app.json");
+  const bytes = Buffer.from(JSON.stringify(app));
+  await fs.writeFile(file, bytes);
+
+  assert.deepEqual(normalizePackRef(file), { url: file });
+  const loaded = await loadPackManifest({ url: file, integrity: sha256Bytes(bytes), kind: "matterhorn.app-pack" });
+  assert.equal(loaded.ok, true);
+  assert.equal(loaded.manifest.id, app.id);
+  assert.equal((await loadPackArtifact({ url: file, integrity: sha256Bytes(bytes) })).ok, true);
+
+  const workspaceLoaded = await loadPackManifest({ url: "workspace:@mh-gg/example#app", integrity: manifestHash(app) }, {
+    workspaceResolver(url) {
+      assert.equal(url, "workspace:@mh-gg/example#app");
+      return app;
+    }
+  });
+  assert.equal(workspaceLoaded.manifestHash, manifestHash(app));
+
+  const wrong = await loadPackManifest({ url: file, integrity: "sha256-wrong", kind: "matterhorn.app-pack" });
+  assert.equal(wrong.ok, false);
+  assert.equal(wrong.code, "INTEGRITY_MISMATCH");
+
+  await fs.writeFile(path.join(dir, "bad.json"), "not json");
+  assert.equal((await loadPackManifest({ url: path.join(dir, "bad.json") })).code, "MALFORMED_JSON");
+  await fs.writeFile(path.join(dir, "wrong-kind.json"), JSON.stringify({ ...app, kind: "other" }));
+  assert.equal((await loadPackManifest({ url: path.join(dir, "wrong-kind.json"), kind: "matterhorn.app-pack" })).code, "MANIFEST_KIND_MISMATCH");
+  await assert.rejects(() => loadPackManifest({ url: "ftp://example.com/app.json" }), /ENOENT|unsupported|no such file/i);
+});
+
+test("resolves plugin graphs, dependencies, conflicts, and stable hashes", () => {
+  const { resolvePluginGraph, pluginIdentity, hashCanonical } = require("../src/index.cjs");
+  const roles = { id: "roles", version: "1.0.0", schemas: { state: { descriptor: { roles: true } }, operations: { grant: {} } } };
+  const tasks = { id: "tasks", version: "1.2.0", dependencies: { required: [{ id: "roles", range: "^1.0.0" }] }, schemas: { state: {}, operations: {} } };
+  const graph = resolvePluginGraph([tasks, roles]);
+  assert.deepEqual(graph.plugins.map((plugin) => plugin.id), ["roles", "tasks"]);
+  assert.equal(graph.pluginGraphHash, hashCanonical(graph.descriptors));
+  assert.equal(pluginIdentity(roles).id, "roles");
+  assert.throws(() => resolvePluginGraph([tasks]), /requires missing dependency/);
+  assert.throws(() => resolvePluginGraph([roles, { ...tasks, dependencies: { required: [{ id: "roles", range: "^2.0.0" }] } }]), /requires roles/);
+  assert.throws(() => resolvePluginGraph([roles, { ...tasks, conflicts: [{ id: "roles" }] }]), /conflicts/);
+  const cyclicA = { id: "a", version: "1.0.0", dependencies: { required: [{ id: "b" }] }, schemas: { state: {}, operations: {} } };
+  const cyclicB = { id: "b", version: "1.0.0", dependencies: { required: [{ id: "a" }] }, schemas: { state: {}, operations: {} } };
+  assert.throws(() => resolvePluginGraph([cyclicA, cyclicB]), /cycle/);
+});
+
+test("trust store, capability prompts, and production gates fail closed", () => {
+  const {
+    createMemoryTrustStore,
+    normalizeCapabilities,
+    createCapabilityPrompt,
+    evaluateCapabilityGrant,
+    formatCapabilityAudit,
+    enforceProductionPluginPolicy
+  } = require("../src/index.cjs");
+  const store = createMemoryTrustStore();
+  const pub = { id: "com.matterhorn", name: "Matterhorn", publicKey: "key" };
+  assert.equal(store.isTrusted(pub), false);
+  store.trustPublisher({ publisherId: pub.id, publicKey: pub.publicKey, scope: "user" });
+  assert.equal(store.isTrusted(pub), true);
+  store.blockPublisher({ publisherId: pub.id, publicKey: pub.publicKey, scope: "group" });
+  assert.equal(store.isTrusted(pub, { scope: "group" }), false);
+  assert.equal(store.export().length, 2);
+
+  assert.deepEqual(normalizeCapabilities({ required: ["room.state"], optional: ["room.state", "ai.invoke"] }), { required: ["room.state"], optional: ["ai.invoke"] });
+  const prompt = createCapabilityPrompt({ publisher: pub, sources: [{ required: ["room.state", "ai.invoke"], optional: ["relay.route"] }], granted: ["room.state", "relay.route"], denied: ["ai.invoke"] });
+  const grant = evaluateCapabilityGrant(prompt);
+  assert.equal(grant.ok, false);
+  assert.deepEqual(grant.deniedRequired, ["ai.invoke"]);
+  assert.match(formatCapabilityAudit(prompt), /high-risk ai\.invoke/);
+  assert.throws(() => enforceProductionPluginPolicy({ production: true, publisherTrusted: false }), /untrusted/);
+  assert.throws(() => enforceProductionPluginPolicy({ production: true, plugins: [{ id: "bad", reduce: async () => ({}) }], capabilityPrompt: { required: [], optional: [] } }), /async reducer/);
+  assert.deepEqual(enforceProductionPluginPolicy({ production: false }), { ok: true, mode: "development" });
+});
+
+
+test("creates and verifies pack bundles with pinned manifest integrity", () => {
+  const host = hostPack();
+  const player = playerPack();
+  const app = appPack({
+    hostPack: { ...appPack().hostPack, integrity: manifestHash(host) },
+    playerPacks: [{
+      ...appPack().playerPacks[0],
+      id: player.id,
+      integrity: manifestHash(player)
+    }]
+  });
+
+  assert.equal(createAppPackManifest(app).id, app.id);
+  assert.equal(createHostPackManifest(host).id, host.id);
+  assert.equal(createPlayerPackManifest(player).id, player.id);
+
+  const bundle = createPackBundle({ appPack: app, hostPack: host, playerPacks: [player] });
+  assert.equal(bundle.contract.appPackId, app.id);
+  assert.equal(bundle.hostPackHash, manifestHash(host));
+  assert.equal(bundle.playerPackHashes[player.id], manifestHash(player));
+  assert.equal(verifyPackBundle({ appPack: app, hostPack: host, playerPacks: [player] }).ok, true);
+  assert.equal(verifyPackBundle({ appPack: app, hostPack: { ...host, appPackId: "wrong" }, playerPacks: [player] }).ok, false);
+});
+
+test("defines player plugins with compatibility metadata", () => {
+  const plugin = definePlayerPlugin({
+    id: "com.matterhorn.kanban.player-plugin",
+    version: "1.0.0",
+    supports: [{ appPackId: "com.matterhorn.kanban", appPackRange: "^1.0.0", appProtocolHash: appProtocolHash() }]
+  });
+  assert.equal(plugin.id, "com.matterhorn.kanban.player-plugin");
+  assert.throws(() => definePlayerPlugin({ version: "1.0.0" }), /player plugin.id/);
+});
+
+test("loads pack references, resolves plugin graphs, and audits capabilities", async () => {
+  const app = appPack();
+  const registry = createInMemoryPackRegistry({ "https://registry.example/app.json": app });
+  const ref = registry.ref("https://registry.example/app.json");
+  const loaded = await loadPackReference(ref, { fetchJson: registry.fetchJson });
+  assert.equal(loaded.id, app.id);
+  assert.deepEqual(parsePackReferenceUrl("workspace:@mh-gg/example#manifest"), {
+    scheme: "workspace",
+    packageName: "@mh-gg/example",
+    exportName: "manifest"
+  });
+
+  const graphPack = hostPack({
+    plugins: [
+      { id: "roles", version: "1.0.0", source: "workspace:roles", integrity: "sha256-roles" },
+      { id: "tasks", version: "1.0.0", source: "workspace:tasks", integrity: "sha256-tasks", dependsOn: [{ id: "roles" }] }
+    ]
+  });
+  const graph = resolveHostPluginGraph(graphPack, { roles: { id: "roles" }, tasks: { id: "tasks" } });
+  assert.deepEqual(graph.refs.map((ref) => ref.id), ["roles", "tasks"]);
+  assert.deepEqual(graph.plugins.map((plugin) => plugin.id), ["roles", "tasks"]);
+
+  const audit = capabilityAudit({ capabilities: { required: ["room.state"], optional: ["relay.mesh"] }, available: ["room.state"] });
+  assert.equal(audit.ok, true);
+  assert.deepEqual(audit.missingOptional, ["relay.mesh"]);
+
+  assert.throws(
+    () => resolveHostPluginGraph(hostPack({ plugins: [{ id: "tasks", version: "1.0.0", source: "workspace:tasks", integrity: "sha256-tasks", dependsOn: [{ id: "roles" }] }] })),
+    /depends on missing plugin roles/
+  );
+  assert.throws(
+    () => resolveHostPluginGraph(hostPack({ plugins: [
+      { id: "a", version: "1.0.0", source: "workspace:a", integrity: "sha256-a", dependsOn: [{ id: "b" }] },
+      { id: "b", version: "1.0.0", source: "workspace:b", integrity: "sha256-b", dependsOn: [{ id: "a" }] }
+    ] })),
+    /dependency cycle/
+  );
+});
+
+test("publisher trust and production plugin gates fail closed", () => {
+  const trustStore = createPublisherTrustStore({ publishers: { "com.matterhorn.kanban.host": "trusted" } });
+  assert.equal(trustStore.isTrusted("com.matterhorn.kanban.host"), true);
+  trustStore.block("bad.publisher");
+  assert.equal(trustStore.isBlocked("bad.publisher"), true);
+
+  const safe = hostPack({ runtime: { minMatterhornVersion: "0.1.0", sandbox: "process" } });
+  assert.equal(assertProductionPluginGates({
+    hostPack: safe,
+    trustStore,
+    requireSignature: false,
+    availableCapabilities: ["room.state", "room.roles"]
+  }).ok, true);
+
+  assert.throws(() => assertTrustedManifest(appPack(), undefined, { requireSignature: false }), /not trusted/);
+
+  assert.throws(() => assertProductionPluginGates({
+    hostPack: safe,
+    requireSignature: false,
+    availableCapabilities: ["room.state", "room.roles"]
+  }), /trust store is required/);
+
+  assert.throws(() => assertProductionPluginGates({
+    hostPack: hostPack({ runtime: { minMatterhornVersion: "0.1.0", sandbox: "none" } }),
+    trustStore,
+    requireSignature: false,
+    availableCapabilities: ["room.state", "room.roles"]
+  }), /without a sandbox/);
+
+  assert.throws(() => assertProductionPluginGates({
+    hostPack: safe,
+    trustStore,
+    availableCapabilities: ["room.state", "room.roles"]
+  }), /publisher is required/);
+
+  assert.throws(() => assertTrustedManifest(appPack(), createPublisherTrustStore()), /not trusted/);
+});
+
+test("covers pack-loading, trust, registry, and host-plugin graph edge cases", async () => {
+  const fs = require("node:fs/promises");
+  const os = require("node:os");
+  const path = require("node:path");
+  const {
+    createMemoryTrustStore,
+    loadPackArtifact,
+    loadPackManifest,
+    normalizePackRef,
+    sha256Bytes
+  } = require("../src/index.cjs");
+
+  const app = appPack();
+  const host = hostPack({
+    plugins: [
+      { id: "base", version: "1.0.0", source: "workspace:base", integrity: "sha256-base", capabilities: { required: ["room.state"], optional: ["relay.route"] } },
+      { id: "optional", version: "1.0.0", source: "workspace:optional", integrity: "sha256-optional", dependsOn: [{ id: "missing", optional: true }] }
+    ]
+  });
+  const graph = resolveHostPluginGraph(host, { base: { id: "base" }, optional: { id: "optional" } });
+  assert.deepEqual(graph.refs.map((ref) => ref.id), ["base", "optional"]);
+  assert.deepEqual(graph.refs[0].capabilities.required, ["room.state"]);
+
+  assert.throws(() => resolveHostPluginGraph(hostPack({ plugins: [
+    { id: "a", version: "1.0.0", source: "workspace:a", integrity: "sha256-a", conflictsWith: ["b"] },
+    { id: "b", version: "1.0.0", source: "workspace:b", integrity: "sha256-b" }
+  ] })), /conflicts/);
+  assert.throws(() => resolveHostPluginGraph(hostPack({ plugins: [
+    { id: "a", version: "1.0.0", source: "workspace:a", integrity: "sha256-a", dependsOn: [{ id: "b", version: "2.0.0" }] },
+    { id: "b", version: "1.0.0", source: "workspace:b", integrity: "sha256-b" }
+  ] })), /depends on b@2\.0\.0/);
+  assert.throws(() => parsePackReferenceUrl("workspace:"), /missing a package/);
+  assert.throws(() => parsePackReferenceUrl("file:"), /missing a path/);
+  assert.throws(() => parsePackReferenceUrl("ipfs://abc"), /Unsupported pack reference/);
+
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), "matterhorn-core-extra-"));
+  const appFile = path.join(dir, "app.json");
+  await fs.writeFile(appFile, JSON.stringify(app));
+  const fileUrlLoaded = await loadPackReference({ url: `file:${appFile}`, integrity: manifestHash(app) });
+  assert.equal(fileUrlLoaded.id, app.id);
+
+  const exportFile = path.join(dir, "exports.json");
+  await fs.writeFile(exportFile, JSON.stringify({ app }));
+  const fileExportLoaded = await loadPackReference({ url: `file:${exportFile}#app`, integrity: manifestHash(app) });
+  assert.equal(fileExportLoaded.id, app.id);
+
+  const httpBytes = Buffer.from(JSON.stringify(app));
+  const httpArtifact = await loadPackArtifact({ url: "https://registry.example/app.json", integrity: sha256Bytes(httpBytes) }, {
+    fetch: async () => ({ ok: true, arrayBuffer: async () => httpBytes })
+  });
+  assert.equal(httpArtifact.ok, true);
+  const httpTextArtifact = await loadPackArtifact({ url: "https://registry.example/app-text.json" }, {
+    allowRemoteWithoutIntegrity: true,
+    fetch: async () => ({ ok: true, text: async () => JSON.stringify(app) })
+  });
+  assert.equal(httpTextArtifact.ok, true);
+  await assert.rejects(() => loadPackArtifact({ url: "https://registry.example/missing.json", integrity: "sha256-missing" }, { fetch: async () => ({ ok: false }) }), /Unable to fetch/);
+
+  await fs.writeFile(path.join(dir, "weird.json"), JSON.stringify({ kind: "matterhorn.weird" }));
+  const invalidKind = await loadPackManifest({ url: path.join(dir, "weird.json") });
+  assert.equal(invalidKind.code, "MANIFEST_INVALID");
+  await fs.writeFile(path.join(dir, "empty.json"), JSON.stringify({}));
+  assert.equal((await loadPackManifest({ url: path.join(dir, "empty.json") })).code, "MANIFEST_KIND_MISSING");
+  assert.deepEqual(normalizePackRef({ url: appFile, kind: APP_PACK_KIND }), { url: appFile, kind: APP_PACK_KIND });
+
+  const workspaceLoaded = await loadPackReference({ url: "workspace:@mh-gg/core-edge#app", integrity: manifestHash(app) }, { workspace: { "@mh-gg/core-edge": { app } } });
+  assert.equal(workspaceLoaded.id, app.id);
+  await assert.rejects(() => loadPackReference({ url: "workspace:@mh-gg/core-edge#missing", integrity: manifestHash(app) }, { workspace: { "@mh-gg/core-edge": { app } } }), /does not export/);
+  await assert.rejects(() => loadPackReference({ url: "workspace:@mh-gg/not-registered", integrity: manifestHash(app) }, { workspace: {} }), /not registered/);
+  const fetched = await loadPackReference({ url: "https://registry.example/app.json#app", integrity: manifestHash(app) }, { fetchJson: async () => ({ app }) });
+  assert.equal(fetched.id, app.id);
+  await assert.rejects(() => loadPackReference({ url: "https://registry.example/app.json", integrity: manifestHash(app) }), /fetchJson is required/);
+
+  const memoryTrust = createMemoryTrustStore([{ publisherId: publisher.id, publicKey: "*", scope: "user" }]);
+  assert.equal(memoryTrust.isTrusted({ ...publisher, publicKey: "another-key" }), true);
+  assert.equal(memoryTrust.isTrusted(null), false);
+  assert.equal(memoryTrust.blockPublisher({ publisherId: publisher.id, publicKey: "another-key" }).blocked, true);
+  assert.equal(memoryTrust.isTrusted({ ...publisher, publicKey: "another-key" }), false);
+
+  const publisherTrust = createPublisherTrustStore({ publishers: { "reviewed.pub": { status: "review", note: "manual review" } } });
+  assert.equal(publisherTrust.status("reviewed.pub"), "review");
+  publisherTrust.trust("trusted.pub");
+  publisherTrust.review("review.pub");
+  assert.equal(publisherTrust.snapshot().publishers["trusted.pub"].status, "trusted");
+  assert.throws(() => createPublisherTrustStore({ publishers: { "bad.pub": "unknown" } }), /Invalid trust status/);
+
+  const registry = createInMemoryPackRegistry();
+  const published = registry.publish("https://registry.example/published.json", app);
+  assert.equal(published.integrity, manifestHash(app));
+  assert.deepEqual(registry.list(), ["https://registry.example/published.json"]);
+  assert.equal((await registry.fetchJson(published.url)).id, app.id);
+  assert.equal(registry.ref(published.url).integrity, manifestHash(app));
+  assert.throws(() => registry.ref("missing"), /not found/);
+  await assert.rejects(() => registry.fetchJson("missing"), /not found/);
+
+  const blockedTrust = createPublisherTrustStore({ publishers: { [app.publisher.id]: "blocked" } });
+  assert.throws(() => assertTrustedManifest(app, blockedTrust, { requireSignature: false }), /blocked/);
+  const reviewTrust = createPublisherTrustStore({ publishers: { [app.publisher.id]: "review" } });
+  assert.equal(assertTrustedManifest(app, reviewTrust, { requireTrusted: false, requireSignature: false }).status, "review");
+  assert.throws(() => assertTrustedManifest(app, createPublisherTrustStore({ publishers: { [app.publisher.id]: "trusted" } })), /trusted signature/);
+
+  const localTrustStore = createPublisherTrustStore({ publishers: { "com.matterhorn.kanban.host": "trusted" } });
+  const missingCapabilityGate = assertProductionPluginGates({
+    hostPack: hostPack({ capabilities: { required: ["network.fetch"], optional: [] }, runtime: { minMatterhornVersion: "0.1.0", sandbox: "process" } }),
+    trustStore: localTrustStore,
+    requireSignature: false,
+    availableCapabilities: [],
+    allowMissingCapabilities: true
+  });
+  assert.equal(missingCapabilityGate.capabilityAudit.ok, false);
+});