space-data-module-sdk 0.8.11 → 0.8.13

package/src/capabilities.js

@@ -47,3 +47,94 @@ export const StandaloneWasiCapabilityIds = Object.freeze([
   "filesystem",
   "pipe",
 ]);
+
+/**
+ * Capabilities a PORTABLE artifact may not claim against the canonical browser
+ * runtime target. The browser HOST can route several of these when the
+ * embedder injects an adapter (see BrowserHostSupportedCapabilities) — this
+ * list is the DECLARATION policy, not the dispatch table: a published module
+ * cannot assume its embedder wired one.
+ *
+ * It lives here, beside the other capability vocabularies, rather than inside
+ * the compliance module, because two browser-facing surfaces need it: the flow
+ * compiler (which subtracts `browser` from a composed artifact's derived
+ * runtimeTargets on exactly this list, so the compiler never stamps a target
+ * its own compliance pass would reject) and the runtime-target gate (which
+ * must not admit an artifact to a leg on the `wasi` portability baseline while
+ * it carries a capability that leg cannot serve).
+ */
+export const BrowserIncompatibleCapabilityIds = Object.freeze([
+  "pipe",
+  "network",
+  "tcp",
+  "udp",
+  "mqtt",
+  "tls",
+  "database",
+  "storage_write",
+  "protocol_dial",
+  "protocol_handle",
+  "process_exec",
+  "wallet_sign",
+  "ipfs",
+]);
+
+/**
+ * ENGINE-HOSTED capabilities: the three that reach into a live 3D engine —
+ * its scene graph, its entity collection, its render loop.
+ *
+ * These used to sit in `BrowserIncompatibleCapabilityIds`, which was exactly
+ * backwards and produced a compliance paradox: they are also in
+ * `RecommendedCapabilityIds`, so a module was simultaneously told to declare
+ * them and refused for declaring them alongside the only runtime where they
+ * can possibly work. The flow compiler compounded it by unconditionally
+ * subtracting `browser` from any composed flow whose capability union touched
+ * one — meaning no flow that needs the engine could ever target the runtime
+ * the engine lives in.
+ *
+ * The truth, established by sweep:
+ *   - The ONE implementation of `scene_access` in the stack is OrbPro's
+ *     `ProviderAccessPort` + the SDK's `providerAccessEngineAdapter`, both of
+ *     which require a live Cesium/OrbPro `Scene`. That is a BROWSER object.
+ *   - `NodeHostSupportedCapabilities` contains none of the three, and
+ *     `assertCapability()` fails them closed with `host-capability-unsupported`.
+ *   - `entity_access` and `render_hooks` have no serving implementation on any
+ *     runtime yet — only manifest-vocabulary codec entries. They are declared
+ *     engine-hosted here because that is where they can ever be served, not
+ *     because they are wired today.
+ *
+ * So they are wasmedge-incompatible, not browser-incompatible. (The `wasi`
+ * portability baseline already refuses them via
+ * `StandaloneWasiCapabilityIds` — nothing outside that five-member subset is
+ * admitted to a standalone WASI artifact.)
+ *
+ * Ruling: graph/findings/official-harness-shapes.md §8.4
+ * Task:   graph/tasks/harness-w0-immediate-fixes.md (W0.4)
+ */
+export const EngineHostedCapabilityIds = Object.freeze([
+  "scene_access",
+  "entity_access",
+  "render_hooks",
+]);
+
+/**
+ * Capabilities the headless WasmEdge leg cannot serve. There is no scene, no
+ * entity collection and no render loop in a headless server runtime, and no
+ * adapter can invent one.
+ */
+export const WasmEdgeIncompatibleCapabilityIds = Object.freeze([
+  ...EngineHostedCapabilityIds,
+]);
+
+/**
+ * Which capabilities each runtime leg cannot serve.
+ *
+ * Consumed by `runtimeTargetGate.js` (load-time admission), the flow compiler's
+ * `collectFlowRuntimeTargets` (derived runtimeTargets), and
+ * `pluginCompliance.js` (publish-time declaration policy) — all three read
+ * THIS table, so a leg's policy is stated once.
+ */
+export const LegIncompatibleCapabilityIds = Object.freeze({
+  browser: BrowserIncompatibleCapabilityIds,
+  wasmedge: WasmEdgeIncompatibleCapabilityIds,
+});

package/src/compliance/index.js

@@ -11,8 +11,12 @@ import {
   validatePluginManifest,
 } from "./pluginCompliance.js";
 import {
+  BrowserIncompatibleCapabilityIds,
+  EngineHostedCapabilityIds,
+  LegIncompatibleCapabilityIds,
   RecommendedCapabilityIds,
   StandaloneWasiCapabilityIds,
+  WasmEdgeIncompatibleCapabilityIds,
 } from "../capabilities.js";
 import { validateManifestAgainstStandardsCatalog } from "../standards/index.js";
 
@@ -48,6 +52,10 @@ export async function validateArtifactWithStandards(options = {}) {
 }
 
 export {
+  BrowserIncompatibleCapabilityIds,
+  EngineHostedCapabilityIds,
+  LegIncompatibleCapabilityIds,
+  WasmEdgeIncompatibleCapabilityIds,
   findManifestFiles,
   getWasmExportNames,
   getWasmExportNamesFromFile,

package/src/compliance/pluginCompliance.js

@@ -13,6 +13,7 @@ import {
   RuntimeTarget,
 } from "../runtime/constants.js";
 import {
+  LegIncompatibleCapabilityIds,
   RecommendedCapabilityIds,
   StandaloneWasiCapabilityIds,
 } from "../capabilities.js";
@@ -25,6 +26,10 @@ import {
   isPayloadSchemaHashValid,
   payloadSchemaIdentitiesEqual,
 } from "../manifest/typeRefs.js";
+import {
+  PluginFamilyNames,
+  pluginFamilyByName,
+} from "../manifest/normalize.js";
 import { isLegacyWildcardPort } from "./legacyWildcardPorts.js";
 import { SDS_MANIFEST_SECTION_NAME } from "../bundle/constants.js";
 import {
@@ -49,24 +54,18 @@ const ExternalInterfaceDirectionSet = new Set(
 const ExternalInterfaceKindSet = new Set(Object.values(ExternalInterfaceKind));
 const ProtocolRoleSet = new Set(Object.values(ProtocolRole));
 const ProtocolTransportKindSet = new Set(Object.values(ProtocolTransportKind));
-const BrowserIncompatibleCapabilitySet = new Set([
-  "pipe",
-  "network",
-  "tcp",
-  "udp",
-  "mqtt",
-  "tls",
-  "database",
-  "storage_write",
-  "protocol_dial",
-  "protocol_handle",
-  "process_exec",
-  "wallet_sign",
-  "ipfs",
-  "scene_access",
-  "entity_access",
-  "render_hooks",
-]);
+// One entry per runtime leg that has a declaration policy, built from the
+// single table in capabilities.js. This used to be a browser-only constant,
+// which is why an engine-hosted capability could only ever be described as
+// "not available in the browser" — the exact inverse of the truth.
+const LegIncompatibleCapabilitySets = Object.freeze(
+  Object.fromEntries(
+    Object.entries(LegIncompatibleCapabilityIds).map(([leg, ids]) => [
+      leg,
+      new Set(ids),
+    ]),
+  ),
+);
 const StandaloneWasiProtocolTransportKindSet = new Set([
   ProtocolTransportKind.WASI_PIPE,
 ]);
@@ -142,6 +141,45 @@ function validateStringField(issues, value, location, label) {
   return true;
 }
 
+/**
+ * `pluginFamily` is an ENUM, not a free string.
+ *
+ * This used to be `validateStringField`, so any spelling passed compliance and
+ * `normalizePluginFamily` then silently coerced it to ANALYSIS — the two
+ * halves of the same defect. Compliance now enforces the same vocabulary the
+ * normalizer refuses on, so a bad family is caught at check time with the
+ * valid set named, instead of at load time as a mislabelled module.
+ *
+ * Ruling: graph/findings/official-harness-shapes.md §4.7 / §8.3
+ */
+function validatePluginFamilyField(issues, value, location) {
+  if (!isNonEmptyString(value)) {
+    pushIssue(
+      issues,
+      "error",
+      "missing-string",
+      "pluginFamily must be a non-empty string.",
+      location,
+    );
+    return false;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (pluginFamilyByName[normalized] === undefined) {
+    pushIssue(
+      issues,
+      "error",
+      "unknown-plugin-family",
+      `pluginFamily "${value}" is not a member of the plugin family vocabulary. ` +
+        `Valid families: ${PluginFamilyNames.join(", ")}. ` +
+        `A new family is appended to schemas/PluginManifest.fbs (a projection ` +
+        `of the authoritative SDS pluginCategory), never invented in a manifest.`,
+      location,
+    );
+    return false;
+  }
+  return true;
+}
+
 function validateCapabilityEntry(capability, issues, location) {
   if (isNonEmptyString(capability)) {
     return capability;
@@ -1428,21 +1466,27 @@ function validateRuntimeTargets(runtimeTargets, declaredCapabilities, issues, so
       );
     }
   }
-  if (
-    seenTargets.has(RuntimeTarget.BROWSER) &&
-    Array.isArray(declaredCapabilities)
-  ) {
-    for (const capability of declaredCapabilities) {
-      if (!BrowserIncompatibleCapabilitySet.has(capability)) {
+  if (Array.isArray(declaredCapabilities)) {
+    // Check EVERY declared leg that has a policy, not just the browser. An
+    // engine-hosted capability (scene_access/entity_access/render_hooks) is
+    // browser-ONLY, so the conflict it can raise is against `wasmedge`.
+    for (const target of seenTargets) {
+      const incompatible = LegIncompatibleCapabilitySets[target];
+      if (!incompatible) {
         continue;
       }
-      pushIssue(
-        issues,
-        "error",
-        "capability-runtime-conflict",
-        `Capability "${capability}" is not available in the canonical browser runtime target.`,
-        `${sourceName}.capabilities`,
-      );
+      for (const capability of declaredCapabilities) {
+        if (!incompatible.has(capability)) {
+          continue;
+        }
+        pushIssue(
+          issues,
+          "error",
+          "capability-runtime-conflict",
+          `Capability "${capability}" is not available in the canonical ${target} runtime target.`,
+          `${sourceName}.capabilities`,
+        );
+      }
     }
   }
 }
@@ -1750,7 +1794,7 @@ export function validatePluginManifest(manifest, options = {}) {
   validateStringField(issues, manifest.pluginId, `${sourceName}.pluginId`, "pluginId");
   validateStringField(issues, manifest.name, `${sourceName}.name`, "name");
   validateStringField(issues, manifest.version, `${sourceName}.version`, "version");
-  validateStringField(issues, manifest.pluginFamily, `${sourceName}.pluginFamily`, "pluginFamily");
+  validatePluginFamilyField(issues, manifest.pluginFamily, `${sourceName}.pluginFamily`);
 
   const rawDeclaredCapabilities = manifest.capabilities;
   let declaredCapabilities = null;

package/src/flow/flowCompiler.js

@@ -56,6 +56,7 @@ import {
 } from "../compiler/pthreadArtifactGuard.js";
 import { resolveWasiThreadsToolchain } from "../compiler/wasiThreadsToolchain.js";
 import {
+  LegIncompatibleCapabilityIds,
   validateArtifactWithStandards,
   validatePluginManifest,
 } from "../compliance/index.js";
@@ -66,6 +67,7 @@ import {
   payloadSchemaIdentitiesEqual,
 } from "../manifest/index.js";
 import { appendWasmCustomSection } from "../bundle/wasm.js";
+import { runtimeTargetSatisfies } from "../host/runtimeTargetGate.js";
 import { SDS_MANIFEST_SECTION_NAME } from "../bundle/constants.js";
 import { verifyModuleArtifact } from "../bundle/signing.js";
 import { DOMAIN_MODULE_PUBLICATION_V1 } from "../bundle/sigdomain.js";
@@ -162,6 +164,16 @@ export function flowEngineLinkage(flow) {
   );
 }
 
+// The runtimes a COMPOSED flow artifact can possibly reach. The flow runtime
+// template is baked once, as the isomorphic browser/WasmEdge artifact — it is
+// never a standalone `wasi` command, a `node` package, a `desktop` bundle, or
+// an `edge` worker, so those targets are not in the universe a composition can
+// claim. A node's own declaration can only ever SUBTRACT from this set.
+const COMPOSED_FLOW_RUNTIME_TARGET_UNIVERSE = Object.freeze([
+  "browser",
+  "wasmedge",
+]);
+
 const GUEST_LINK_OBJECT_FILENAME = "module-link.o";
 const GUEST_LINK_METADATA_FILENAME = "metadata.json";
 const GUEST_LINK_LINKED_DIRNAME = "guest-link-linked";
@@ -882,7 +894,9 @@ function collectComponentDependencies({ nodePluginIds, dependencies, issues, cap
         "warning",
         "unresolved-component-dependency",
         `Component dependency "${declared.pluginId}" (declared by "${declaredBy}") is not resolvable from the ` +
-          "dependency set; it is propagated into the bundle DEPENDENCIES but its capabilities cannot be verified.",
+          "dependency set; it is propagated into the bundle DEPENDENCIES but neither its capabilities nor its " +
+          "runtimeTargets can be verified — so it constrains neither the flow's capability union nor its " +
+          "derived runtime targets, and the composed artifact may claim a runtime this component cannot reach.",
         "flow.dependencies",
       );
     }
@@ -890,6 +904,190 @@ function collectComponentDependencies({ nodePluginIds, dependencies, issues, cap
   return [...components.values()].sort((a, b) => a.pluginId.localeCompare(b.pluginId));
 }
 
+// Per-leg incompatibility, read from the ONE table in capabilities.js rather
+// than a browser-only constant. An engine-hosted capability
+// (scene_access/entity_access/render_hooks) is browser-ONLY, so the leg it
+// narrows away is `wasmedge`; the old browser-only form could only ever
+// subtract `browser`, which is how a flow that needs the engine ended up
+// unable to target the runtime the engine lives in.
+const LegIncompatibleCapabilitySets = Object.freeze(
+  Object.fromEntries(
+    Object.entries(LegIncompatibleCapabilityIds).map(([leg, ids]) => [
+      leg,
+      new Set(ids),
+    ]),
+  ),
+);
+
+function declaredRuntimeTargets(manifest) {
+  const declared = Array.isArray(manifest?.runtimeTargets)
+    ? manifest.runtimeTargets
+        .map((target) => String(target ?? "").trim().toLowerCase())
+        .filter(Boolean)
+    : [];
+  return declared.length > 0 ? declared : null;
+}
+
+/**
+ * collectFlowRuntimeTargets derives the COMPOSED artifact's runtimeTargets from
+ * its constituents instead of asserting a fixed pair.
+ *
+ * A flow runs only where ALL of its parts run, so the composition's target set
+ * is the INTERSECTION of the declared target sets of every node plugin and
+ * every resolved component dependency, taken inside the universe a composed
+ * artifact can reach at all (browser + WasmEdge). A part that declares no
+ * targets is unconstraining — it says nothing, so it subtracts nothing. The
+ * admission test is `runtimeTargetSatisfies`, THE SAME ONE every loader uses,
+ * so a declaration cannot mean one thing to the compiler and another at the
+ * door.
+ *
+ * The CAPABILITY UNION subtracts too. A declared target set is not the only
+ * way a part can be non-browser: a plugin that carries `wallet_sign` and
+ * simply omits `runtimeTargets` says nothing about where it runs, yet the
+ * composition provably cannot run in a browser, because compliance forbids
+ * exactly that capability against a browser target. Deriving only from the
+ * declarations left the commonest manifest shape re-creating the original
+ * defect — the compiler stamping a target its own compliance pass then
+ * rejects. So a leg is also dropped whenever the flow's capability union meets
+ * that leg's entry in `LegIncompatibleCapabilityIds`, and the diagnostic names
+ * the capability that cost it. That table is per-leg, not browser-only: the
+ * engine-hosted capabilities (scene_access/entity_access/render_hooks) narrow
+ * away `wasmedge`, in the other direction.
+ *
+ * This is the difference between a truthful manifest and a wish. The hardcoded
+ * ["browser","wasmedge"] made every composition claim the browser, which made
+ * `capability-runtime-conflict` fire on any flow containing a node with a
+ * browser-incompatible capability (wallet_sign, tcp, storage_write, …) — so a
+ * WasmEdge-only flow was not merely mislabelled, it was IMPOSSIBLE TO BAKE.
+ * Deriving the set keeps the real invariant intact (a browser-incompatible
+ * capability and a browser target still cannot coexist) while letting the
+ * legitimate WasmEdge-only composition exist.
+ */
+function collectFlowRuntimeTargets({
+  resolvedNodes,
+  componentDependencies,
+  dependencies,
+  capabilities,
+  issues,
+}) {
+  let targets = new Set(COMPOSED_FLOW_RUNTIME_TARGET_UNIVERSE);
+  // pluginId -> the declared set, for the diagnostic when nothing survives.
+  const constraints = new Map();
+  // target -> why it is gone. Losing a runtime is never silent.
+  const droppedBecause = new Map();
+
+  const narrow = (allowed, reasonFor) => {
+    for (const target of [...targets]) {
+      if (allowed(target)) continue;
+      targets.delete(target);
+      if (!droppedBecause.has(target)) {
+        droppedBecause.set(target, reasonFor(target));
+      }
+    }
+  };
+
+  const consider = (pluginId, manifest) => {
+    if (!pluginId || constraints.has(pluginId)) return;
+    const declared = declaredRuntimeTargets(manifest);
+    if (!declared) return;
+    constraints.set(pluginId, [...declared].sort());
+    // ONE RULE, shared with the loaders (`runtimeTargetSatisfies`). Two rules
+    // for one field is how a manifest comes to mean different things to the
+    // compiler and to the door: a `["wasi","wasmedge"]` part had the browser
+    // leg stripped from every flow it joined while the browser harness happily
+    // admitted that same declaration. `wasi` is the portability baseline, so
+    // it admits both legs unless the part's own capabilities say otherwise;
+    // proof-based narrowing is the capability-union pass below.
+    narrow(
+      (target) =>
+        runtimeTargetSatisfies(declared, target, manifest?.capabilities),
+      () =>
+        `"${pluginId}" declares runtimeTargets [${[...declared].sort().join(", ")}]`,
+    );
+  };
+
+  for (const entry of resolvedNodes) {
+    if (!entry?.dependency) continue;
+    consider(entry.node?.pluginId, entry.dependency.manifest);
+  }
+  for (const component of componentDependencies ?? []) {
+    if (!component?.resolved) continue;
+    consider(
+      component.pluginId,
+      dependencies.get(component.pluginId)?.manifest,
+    );
+  }
+
+  const unionCapabilities = [...(capabilities ?? [])];
+  for (const leg of COMPOSED_FLOW_RUNTIME_TARGET_UNIVERSE) {
+    const incompatible = LegIncompatibleCapabilitySets[leg];
+    if (!incompatible) continue;
+    const offending = unionCapabilities
+      .filter((capability) => incompatible.has(capability))
+      .sort();
+    if (offending.length === 0) continue;
+    narrow(
+      (target) => target !== leg,
+      () =>
+        `the flow's capability union contains ${offending
+          .map((capability) => `"${capability}"`)
+          .join(", ")}, which the canonical ${leg} runtime target cannot serve`,
+    );
+  }
+
+  const ordered = COMPOSED_FLOW_RUNTIME_TARGET_UNIVERSE.filter((target) =>
+    targets.has(target),
+  );
+  const reasons = [...droppedBecause.entries()]
+    .map(([target, why]) => `${target} (${why})`)
+    .join("; ");
+  if (ordered.length === 0) {
+    pushIssue(
+      issues,
+      "error",
+      "empty-runtime-target-intersection",
+      "No runtime runs every part of this flow: every candidate target was ruled " +
+        `out — ${reasons}. A composed flow can only target the runtimes shared by ` +
+        "all of its nodes and resolved component dependencies; split the flow, or " +
+        "widen the constraining plugin's runtimeTargets.",
+      "flow.nodes",
+    );
+  } else if (droppedBecause.size > 0) {
+    pushIssue(
+      issues,
+      "warning",
+      "narrowed-runtime-targets",
+      `This flow composes to runtimeTargets [${ordered.join(", ")}] — narrower than ` +
+        `the isomorphic pair. Dropped: ${reasons}. The artifact is still written to ` +
+        "dist/isomorphic/module.wasm, but it is NOT loadable on the dropped runtime " +
+        "and every harness for that leg will refuse it by name.",
+      "flow.nodes",
+    );
+  }
+  return ordered;
+}
+
+/**
+ * Rebuild the derived target set from a check record produced by an older SDK
+ * (one with no `runtimeTargets` field). Issues are discarded here on purpose —
+ * the caller re-raises the only one that matters, an empty result, as a throw.
+ */
+function recomputeFlowRuntimeTargets(check, dependencies) {
+  return collectFlowRuntimeTargets({
+    resolvedNodes: (check?.nodes ?? [])
+      .filter((node) => node.dispatchModel !== "host")
+      .map((node) => ({
+        node,
+        dependency: dependencies.get(node.pluginId) ?? null,
+      }))
+      .filter((entry) => entry.dependency),
+    componentDependencies: check?.componentDependencies,
+    dependencies,
+    capabilities: check?.capabilities ?? [],
+    issues: [],
+  });
+}
+
 /**
  * findFlowCycles returns every elementary cycle reachable in the node graph
  * as { nodeIds, edges } (iterative DFS with back-edge extraction; each cycle
@@ -1773,6 +1971,14 @@ export function checkFlowProgram({ flow, dependencies = new Map() } = {}) {
     capabilities,
   });
 
+  const runtimeTargets = collectFlowRuntimeTargets({
+    resolvedNodes,
+    componentDependencies,
+    dependencies,
+    capabilities,
+    issues,
+  });
+
   const errors = issues.filter((issue) => issue.severity === "error");
   return {
     ok: errors.length === 0,
@@ -1780,6 +1986,7 @@ export function checkFlowProgram({ flow, dependencies = new Map() } = {}) {
     errors,
     warnings: issues.filter((issue) => issue.severity === "warning"),
     capabilities: [...capabilities].sort(),
+    runtimeTargets,
     engineLinkage,
     threadModel,
     componentDependencies,
@@ -1908,6 +2115,23 @@ export function buildFlowModuleManifest({ flow, check, dependencies }) {
   const checkedNodeById = new Map(
     check.nodes.map((node) => [node.nodeId, node]),
   );
+  // `check.runtimeTargets` is the derived intersection. It is absent only when
+  // a caller hands in a check record built by an older SDK; recompute rather
+  // than silently re-asserting the historical pair — and THROW on the empty
+  // intersection instead of swallowing it. A check record has an issue sink;
+  // this path does not, and an artifact that declares no runtime at all is
+  // read as unconstrained by every loader downstream, which is the most
+  // permissive possible answer to the least certain question.
+  const runtimeTargets = Array.isArray(check.runtimeTargets)
+    ? [...check.runtimeTargets]
+    : recomputeFlowRuntimeTargets(check, dependencies);
+  if (runtimeTargets.length === 0) {
+    throw new Error(
+      `Flow "${flow?.programId ?? "(unknown)"}" has no runtime target: no runtime runs ` +
+        "every one of its parts. Refusing to build a manifest that declares nothing — " +
+        "run checkFlowProgram and read the empty-runtime-target-intersection error.",
+    );
+  }
 
   const hostModelNodeIds = new Set(
     check.nodes.filter((node) => node.dispatchModel === "host").map((node) => node.nodeId),
@@ -2032,13 +2256,17 @@ export function buildFlowModuleManifest({ flow, check, dependencies }) {
     externalInterfaces,
     methods,
     schemasUsed,
-    runtimeTargets: ["browser", "wasmedge"],
+    // DERIVED, never asserted: the runtimes shared by every node plugin and
+    // resolved component dependency (see collectFlowRuntimeTargets). A flow of
+    // fully isomorphic nodes keeps both targets; a flow containing one
+    // WasmEdge-only node is a WasmEdge-only flow and says so.
+    runtimeTargets,
     buildArtifacts: [
       {
         artifactId: `${cIdent(flow.programId)}-flow-runtime`,
         kind: "wasm",
         path: "dist/isomorphic/module.wasm",
-        target: "browser,wasmedge",
+        target: runtimeTargets.join(","),
       },
     ],
     flowNodes: nodes.map((node) => {

package/src/flow/flowRuntimeHost.js

@@ -15,6 +15,10 @@
  */
 
 import { createBrowserWasiShim } from "../host/wasiShim.js";
+import {
+  assertArtifactRuntimeTarget,
+  detectBrowserLeg,
+} from "../host/runtimeTargetGate.js";
 import {
   isPayloadSchemaHashValid,
   normalizePayloadSchemaHash,
@@ -211,6 +215,28 @@ export async function createFlowRuntimeHost(options = {}) {
     wasmModule = await WebAssembly.compile(bytes);
   }
 
+  // THE COMPOSED FLOW'S DOOR. A composed artifact now derives its
+  // runtimeTargets from its parts, so a WasmEdge-only flow is a real thing —
+  // and this host is how one gets loaded. It is genuinely runtime-agnostic
+  // (the same function backs the Node/WasmEdge leg), so the leg is stated by
+  // the caller; absent that, a real browser is detected and gated. Passing
+  // runtimeTarget: null opts out explicitly, which is not the same as
+  // forgetting.
+  const declaredLeg =
+    options.runtimeTarget === undefined
+      ? detectBrowserLeg()
+        ? "browser"
+        : null
+      : options.runtimeTarget;
+  if (declaredLeg) {
+    assertArtifactRuntimeTarget({
+      wasmModule,
+      manifest: options.manifest,
+      leg: String(declaredLeg).trim().toLowerCase(),
+      what: "composed flow artifact",
+    });
+  }
+
   const wasi = createBrowserWasiShim({
     args: options.args ?? ["flow-runtime"],
     env: options.env ?? {},

package/src/flow/isomorphicFlowHost.js

@@ -220,6 +220,14 @@ export async function createIsomorphicFlowRuntimeHost(options = {}) {
   );
   const parent = await createFlowRuntimeHost({
     wasmSource: parentArtifactBytes,
+    // UNCONDITIONAL, with no opt-out. This host mounts every isomorphic child
+    // through the BROWSER module harness, whose gate cannot be turned off — so
+    // an escape hatch here would only ever produce an ungated parent with
+    // gated children, and a half-gate is not a gate. There is no legitimate
+    // non-browser use of this host precisely because of that mount; callers
+    // that want the runtime-agnostic host call createFlowRuntimeHost, which
+    // does take a stated leg.
+    runtimeTarget: "browser",
     args: options.args,
     env: options.env,
     logOutput: options.logOutput,

package/src/generated/orbpro/manifest/plugin-family.d.ts

@@ -12,6 +12,14 @@ export declare enum PluginFamily {
     SDF = 7,
     INFRASTRUCTURE = 8,
     FLOW = 9,
-    BRIDGE = 10
+    BRIDGE = 10,
+    MANEUVER = 11,
+    ORBIT_DETERMINATION = 12,
+    FOUNDATION = 13,
+    PARSER = 14,
+    VALIDATOR = 15,
+    EXPORTER = 16,
+    PUBLISHER = 17,
+    BASILISK = 18
 }
 //# sourceMappingURL=plugin-family.d.ts.map

package/src/generated/orbpro/manifest/plugin-family.js

@@ -16,5 +16,13 @@ export var PluginFamily;
     PluginFamily[PluginFamily["INFRASTRUCTURE"] = 8] = "INFRASTRUCTURE";
     PluginFamily[PluginFamily["FLOW"] = 9] = "FLOW";
     PluginFamily[PluginFamily["BRIDGE"] = 10] = "BRIDGE";
+    PluginFamily[PluginFamily["MANEUVER"] = 11] = "MANEUVER";
+    PluginFamily[PluginFamily["ORBIT_DETERMINATION"] = 12] = "ORBIT_DETERMINATION";
+    PluginFamily[PluginFamily["FOUNDATION"] = 13] = "FOUNDATION";
+    PluginFamily[PluginFamily["PARSER"] = 14] = "PARSER";
+    PluginFamily[PluginFamily["VALIDATOR"] = 15] = "VALIDATOR";
+    PluginFamily[PluginFamily["EXPORTER"] = 16] = "EXPORTER";
+    PluginFamily[PluginFamily["PUBLISHER"] = 17] = "PUBLISHER";
+    PluginFamily[PluginFamily["BASILISK"] = 18] = "BASILISK";
 })(PluginFamily || (PluginFamily = {}));
 //# sourceMappingURL=plugin-family.js.map

package/src/generated/orbpro/manifest/plugin-family.ts

@@ -17,4 +17,12 @@ export enum PluginFamily {
   INFRASTRUCTURE = 8,
   FLOW = 9,
   BRIDGE = 10,
+  MANEUVER = 11,
+  ORBIT_DETERMINATION = 12,
+  FOUNDATION = 13,
+  PARSER = 14,
+  VALIDATOR = 15,
+  EXPORTER = 16,
+  PUBLISHER = 17,
+  BASILISK = 18,
 }