@volter/editor-game 0.5.66 → 0.5.67

package/src/runtime/adapter/first-party-audio-system.ts

@@ -0,0 +1,230 @@
+/**
+ * The first-party `AudioAdapter` over the game runtime's master-gain bus
+ * (`setup/setup-audio.ts`'s `AudioContext.masterGain`) — the seam
+ * `Game.play.pause()` calls to silence a first-party world's audio, plus the
+ * graph snapshot and the native analyser taps the editor's Audio panel and
+ * gameplay recorder read.
+ *
+ * Its NAVIGATION sibling (`createNavigationAdapter`) is the three.js twin's —
+ * `@volter/threejs-runtime/adapter/first-party-navigation-system` — for the same
+ * reason this one is here: each lives with the subsystem it wraps.
+ *
+ * Restoring after a mute puts the gain back at whatever value it held right
+ * before muting (not a hardcoded `1`), which composes correctly with an
+ * independent manual mute: pausing while already user-muted resumes muted,
+ * exactly as a user would expect.
+ */
+
+import type {
+  AudioAdapter,
+  AudioGraphNode,
+  AudioMeterFrame,
+  AudioMeterHandle,
+  AudioRecordingHandle,
+} from '@volter/editor-project/adapter/system-adapter';
+import type { AudioContext as GameAudio } from '../setup/setup-audio';
+
+/**
+ * First-party `AudioAdapter` over the engine's master-gain bus
+ * (`setup-audio.ts`'s `AudioContext.masterGain`) — the seam `Game.play.pause()`
+ * (D10, T7.6) calls to silence a first-party world's audio. Restoring after a
+ * mute puts the gain back at whatever value it held right before muting (not
+ * a hardcoded `1`) — this composes correctly with an independent manual mute
+ * (the editor's `MuteButton`, `PlayBar.tsx`): pausing while already
+ * user-muted resumes muted, exactly as a user would expect.
+ */
+function audioNodeTypeName(value: object): string {
+  const name = (value as { constructor?: { name?: string } }).constructor?.name;
+  return name && name !== 'Object' ? name : 'AudioNode';
+}
+
+/** This world's real native context, when it has one (headless worlds do not). */
+function nativeAudioContext(audio: GameAudio): (BaseAudioContext & Partial<AudioContext>) | null {
+  const context = (audio.listener as { context?: BaseAudioContext } | undefined)?.context;
+  return context && typeof context.state === 'string'
+    ? (context as BaseAudioContext & Partial<AudioContext>)
+    : null;
+}
+
+/**
+ * Live meter handles per adapter, so a world teardown can release analyser
+ * taps a consumer forgot to dispose.
+ *
+ * This registry follows `acquireMeters` out of `audio-introspection.ts`: the
+ * safety net has to live wherever the taps are created, and they are created
+ * here now. Keyed weakly so an adapter that is simply dropped takes its entry
+ * with it.
+ */
+const meterHandlesByAdapter = new WeakMap<AudioAdapter, Set<AudioMeterHandle>>();
+
+/** Release every meter tap still open on `adapter` (world stop / teardown). */
+export function releaseAudioMeters(adapter: AudioAdapter): void {
+  const handles = meterHandlesByAdapter.get(adapter);
+  if (!handles) return;
+  for (const handle of [...handles]) handle.dispose();
+}
+
+export function createAudioSystemAdapter(audio: GameAudio): AudioAdapter {
+  let muted = false;
+  let priorGain = audio.masterGain.gain.value;
+  const liveMeterHandles = new Set<AudioMeterHandle>();
+  const adapter: AudioAdapter = {
+    resume: () => audio.resume(),
+    setMuted(next: boolean) {
+      if (next === muted) return;
+      muted = next;
+      if (next) {
+        priorGain = audio.masterGain.gain.value;
+        audio.masterGain.gain.value = 0;
+      } else {
+        audio.masterGain.gain.value = priorGain;
+      }
+    },
+    isMuted: () => muted,
+
+    /**
+     * The engine's own bus hierarchy.
+     *
+     * This lived in `audio-introspection.ts` — the Tone-backed module — which
+     * meant the editor could only ever show an audio graph for a game that had
+     * loaded Tone. Nothing here needs Tone: it is the destination, the master
+     * gain, the three engine buses and the THREE listener. The Tone half (nodes
+     * a game routed through `connectToneBusToMasterGain`) is APPENDED by that
+     * module when it attaches, which is the honest split — Tone routes are
+     * Tone's to report.
+     */
+    graphSnapshot(): AudioGraphNode[] {
+      const contextState = nativeAudioContext(audio)?.state;
+      const destination: AudioGraphNode = {
+        id: 'destination',
+        type: 'AudioDestinationNode',
+        label: 'Output',
+        outputs: [],
+      };
+      if (contextState !== undefined) destination.state = contextState;
+      const nodes: AudioGraphNode[] = [
+        destination,
+        {
+          id: 'master',
+          type: audioNodeTypeName(audio.masterGain),
+          label: 'Master',
+          outputs: ['destination'],
+        },
+        {
+          id: 'bus-music',
+          type: audioNodeTypeName(audio.buses.music),
+          label: 'Music bus',
+          outputs: ['master'],
+        },
+        {
+          id: 'bus-sfx',
+          type: audioNodeTypeName(audio.buses.sfx),
+          label: 'SFX bus',
+          outputs: ['master'],
+        },
+        {
+          id: 'bus-voice',
+          type: audioNodeTypeName(audio.buses.voice),
+          label: 'Voice bus',
+          outputs: ['master'],
+        },
+      ];
+      if (audio.listener) {
+        nodes.push({
+          id: 'listener',
+          type: audioNodeTypeName(audio.listener),
+          label: '3D listener (THREE)',
+          outputs: ['master'],
+        });
+      }
+      return nodes;
+    },
+
+    /**
+     * Per-bus linear-RMS levels, via native `AnalyserNode` taps.
+     *
+     * Zero Tone — analysers work identically whether or not Tone is bridged,
+     * and disposal is a plain disconnect. It was in the Tone module purely by
+     * where it was written, so a game that never touches Tone had no meters.
+     */
+    acquireMeters(): AudioMeterHandle | null {
+      const meterContext = nativeAudioContext(audio);
+      if (!meterContext || typeof meterContext.createAnalyser !== 'function') {
+        return null; // headless world — metering is impossible, and says so
+      }
+      const taps = (
+        [
+          ['master', 'Master', audio.masterGain],
+          ['bus-music', 'Music', audio.buses.music],
+          ['bus-sfx', 'SFX', audio.buses.sfx],
+          ['bus-voice', 'Voice', audio.buses.voice],
+        ] as const
+      ).map(([id, label, gain]) => {
+        const analyser = meterContext.createAnalyser();
+        analyser.fftSize = 1024;
+        gain.connect(analyser); // a TAP (analyser is a sink), not an insert
+        return { id, label, gain, analyser, buffer: new Float32Array(analyser.fftSize) };
+      });
+      let disposed = false;
+      const handle: AudioMeterHandle = {
+        read: (): AudioMeterFrame[] =>
+          taps.map(({ id, label, analyser, buffer }) => {
+            analyser.getFloatTimeDomainData(buffer);
+            let sum = 0;
+            for (let i = 0; i < buffer.length; i++) {
+              const sample = buffer[i] as number;
+              sum += sample * sample;
+            }
+            return { id, label, level: Math.sqrt(sum / buffer.length) };
+          }),
+        dispose: (): void => {
+          if (disposed) return;
+          disposed = true;
+          for (const tap of taps) {
+            try {
+              tap.gain.disconnect(tap.analyser);
+            } catch {
+              // already torn down with the context — nothing to release
+            }
+          }
+          liveMeterHandles.delete(handle);
+        },
+      };
+      liveMeterHandles.add(handle);
+      return handle;
+    },
+
+    /** Native Web Audio tap used by the editor's gameplay recorder. It is a
+     * sink beside the speakers, never an insert, so recording cannot change
+     * what the player hears. A suspended context produces no audio frames and
+     * stalls MediaRecorder muxing, so it cannot supply a recording track. */
+    acquireRecordingStream(): AudioRecordingHandle | null {
+      const recordingContext = nativeAudioContext(audio);
+      if (
+        !recordingContext ||
+        recordingContext.state !== 'running' ||
+        typeof recordingContext.createMediaStreamDestination !== 'function'
+      ) {
+        return null;
+      }
+      const destination = recordingContext.createMediaStreamDestination();
+      audio.masterGain.connect(destination);
+      let disposed = false;
+      return {
+        stream: destination.stream,
+        dispose(): void {
+          if (disposed) return;
+          disposed = true;
+          try {
+            audio.masterGain.disconnect(destination);
+          } catch {
+            // The world/context may already have been torn down.
+          }
+          for (const track of destination.stream.getTracks()) track.stop();
+        },
+      };
+    },
+  };
+  meterHandlesByAdapter.set(adapter, liveMeterHandles);
+  return adapter;
+}

package/src/runtime/adapter/ingest/contract-debug-adapter.ts

@@ -0,0 +1,114 @@
+/**
+ * Projects a game's DECLARED system surface (`window.vgaiGame.systems`, see
+ * `game-contract.ts`) onto the host's existing {@link DebugAdapter} — the one
+ * seam `game.commands()` / `game.state()` / `game.providers()` already read
+ * through for first-party content (`command-listener.ts`'s
+ * `dispatchBridgeMethod` → `getActiveSystems().debug`).
+ *
+ * Why a projection rather than a second door: an agent driving an ingested
+ * game must not have to learn a parallel vocabulary. A first-party game
+ * registers verbs with `ctx.debug.registerCommand`; an ingested game declares
+ * them in its entry shim. Both arrive at the SAME `DebugAdapter`, so every
+ * consumer downstream — the CLI's `vgai eval`, `@vgai/e2e`'s `GameClient`, the
+ * editor's Debug Console and State Watch panels — works unchanged and unaware
+ * of the provenance.
+ *
+ * What this deliberately does NOT do:
+ * - **Validate arguments.** The first-party path validates against a declared
+ *   Zod tuple; a shim beside a foreign game is plain JS and has none. A verb
+ *   validates itself and throws its own error, which surfaces wrapped as
+ *   `DEBUG_COMMAND_FAILED` — the host never invents a schema to check against.
+ * - **Fabricate an event ring.** There is no tick loop behind an ingested
+ *   game's declarations, so `events()` is empty. That is accurate (nothing was
+ *   emitted), not a stub standing in for a missing feature.
+ */
+
+import type { VgaiGameSystems } from '@volter/editor-project/adapter/ingest/game-contract';
+import type {
+  DebugAdapter,
+  DebugCommandInfo,
+  TickStampedEvent,
+} from '@volter/editor-project/adapter/system-adapter';
+import { DebugError } from '../../debug-registry';
+
+/**
+ * Build a {@link DebugAdapter} over a declared system surface, or `null` when
+ * the game declared no verbs and no state. `null` is the honest floor: the
+ * bridge then reports `DEBUG_ADAPTER_UNAVAILABLE` exactly as it did before,
+ * rather than serving an empty adapter that reads as "this game has no state"
+ * when the truth is "this game declared nothing".
+ */
+export function createContractDebugAdapter(
+  systems: VgaiGameSystems | undefined | null,
+): DebugAdapter | null {
+  const commandList = systems?.commands ?? [];
+  const providerList = systems?.state ?? [];
+  if (commandList.length === 0 && providerList.length === 0) return null;
+
+  // Snapshot into name-keyed maps once. A later duplicate shadows an earlier
+  // one and the listing de-duplicates with it, so `commands()` can never
+  // advertise a name `invoke()` would resolve differently.
+  const byCommand = new Map(commandList.map((c) => [c.name, c]));
+  const byProvider = new Map(providerList.map((p) => [p.name, p]));
+
+  return {
+    providers: () =>
+      [...byProvider.values()].map((p) => ({ name: p.name, tier: p.tier ?? 'observable' })),
+
+    state: (name: string): unknown => {
+      const provider = byProvider.get(name);
+      if (!provider) {
+        throw new DebugError(
+          'STATE_PROVIDER_NOT_FOUND',
+          `No state provider named "${name}" is declared by this game.`,
+          { registered: [...byProvider.keys()] },
+        );
+      }
+      return provider.read();
+    },
+
+    stateAll: (): Record<string, unknown> => {
+      const out: Record<string, unknown> = {};
+      for (const [name, provider] of byProvider) {
+        // One throwing provider must not cost the caller every other reading —
+        // the same per-key isolation the first-party registry gives.
+        try {
+          out[name] = provider.read();
+        } catch (err) {
+          out[name] = { __error: String(err) };
+        }
+      }
+      return out;
+    },
+
+    commands: (): DebugCommandInfo[] =>
+      [...byCommand.values()].map((c) => ({
+        name: c.name,
+        description: c.description,
+        argsJsonSchema: c.argsJsonSchema,
+        // An ingested game runs entirely in the browser realm the host mounted
+        // it in; there is no server leg for its verbs to route to.
+        locus: 'client' as const,
+      })),
+
+    invoke: async (name: string, args: unknown[]): Promise<unknown> => {
+      const command = byCommand.get(name);
+      if (!command) {
+        throw new DebugError(
+          'DEBUG_COMMAND_NOT_REGISTERED',
+          `No command named "${name}" is declared by this game.`,
+          { registered: [...byCommand.keys()] },
+        );
+      }
+      try {
+        return await command.run(...args);
+      } catch (err) {
+        throw new DebugError('DEBUG_COMMAND_FAILED', `Command "${name}" threw: ${String(err)}`, {
+          name,
+        });
+      }
+    },
+
+    events: (): TickStampedEvent[] => [],
+  };
+}

package/src/runtime/adapter/ingest/contract-system-adapters.ts

@@ -0,0 +1,256 @@
+/**
+ * Projects a game's declared {@link VgaiGameSystemAdapters}
+ * (`window.vgaiGame.systems.systemAdapters`) onto the host's ordinary
+ * {@link SystemAdapters} bag — the ingest-realm counterpart of a first-party
+ * world's `ctx.registerSystemAdapter`, and the sibling of
+ * `contract-debug-adapter.ts` (which owns the `debug` slot).
+ *
+ * ## Why a projection with a verdict per slot
+ *
+ * The ingestion bar (docs/BRINGING-AN-EXISTING-GAME.md §The ingestion
+ * checklist) admits exactly two terminal states per slot: IMPLEMENTED or
+ * IMPLEMENTED-EMPTY. `SystemAdapters` alone cannot express the second — an
+ * omitted key means "unsupported", which is the same shape as "nobody looked".
+ * So this returns THREE lists, and the caller hands the non-`bound` ones to the
+ * coverage report, where a positively-answered absence prints as terminal and an
+ * unanswered slot prints as a work order.
+ *
+ * ## Why the shape check
+ *
+ * A slot that declares `{}` would otherwise register as "implemented" and light
+ * up an editor panel over an object with no methods. Each slot therefore names
+ * the members its interface makes REQUIRED, and a declaration missing any of
+ * them is `malformed` — reported by name, never silently bound and never
+ * silently dropped. This is the same honesty the anti-shim rule asks of the
+ * other direction: a wrong "present" claim is as much a defect as a wrong
+ * "empty" one.
+ *
+ * ## Why `physics` also gets a KEYING check
+ *
+ * The physics slot is the one whose vocabulary follows the SURFACE
+ * ({@link PHYSICS_KEYING_BY_SURFACE}): a three-surface game keys by host node
+ * id, a canvas-surface game by the display object it already holds. Both shapes
+ * carry the same four member names, so presence-and-typeof cannot tell them
+ * apart — a carrier keyed for the other surface would pass every check here and
+ * then be called with values it has none of, which is the "green coverage row
+ * bought with four methods that have no caller" defect this whole slot was left
+ * open to avoid. So a mount that KNOWS its surface says so, and a mismatch is
+ * `malformed` by name. A caller with no surface fact (`undefined`) does not
+ * check — it has nothing to check against, and inventing a default would be a
+ * guess wearing a verdict.
+ *
+ * Nothing here calls a declared method. Presence and shape only.
+ */
+
+import type {
+  ContractSystemEmptySlot,
+  ContractSystemMalformedSlot,
+  ContractSystemSlot,
+} from '@volter/editor-project/adapter/ingest/contract-system-slots';
+import type { SystemAdapters } from '@volter/editor-project/adapter/system-adapter';
+
+export type {
+  ContractSystemEmptySlot,
+  ContractSystemMalformedSlot,
+} from '@volter/editor-project/adapter/ingest/contract-system-slots';
+
+import type {
+  VgaiGameSystemAdapters,
+  VgaiGameSystemEmpty,
+  VgaiGameSystems,
+} from '@volter/editor-project/adapter/ingest/game-contract';
+import { GAME_SYSTEM_ADAPTERS_SHAPE } from '@volter/editor-project/adapter/ingest/game-contract-seams';
+import {
+  AUDIO_ADAPTER_SHAPE,
+  CAMERA_ADAPTER_SHAPE,
+  NAVIGATION_ADAPTER_SHAPE,
+  NETWORKING_ADAPTER_SHAPE,
+  PHYSICS_ADAPTER_SHAPE,
+  RENDER_DEBUG_ADAPTER_SHAPE,
+} from '@volter/editor-project/adapter/system-seam-contract';
+
+/** The slots a game may declare through the contract (`debug` is projected from
+ *  `commands`/`state` instead — see {@link VgaiGameSystemAdapters}). */
+export type { ContractSystemSlot } from '@volter/editor-project/adapter/ingest/contract-system-slots';
+
+/**
+ * The members each slot's interface makes NON-optional. A declaration missing
+ * one of these cannot honour the interface, whatever else it carries.
+ *
+ * This table is the single place the required surface is spelled; it is checked
+ * against the interfaces by the compiler at the point of use below (each list
+ * is typed as keys of its own adapter), so it cannot drift into naming a member
+ * that does not exist.
+ */
+const SYSTEM_SHAPES = {
+  physics: PHYSICS_ADAPTER_SHAPE,
+  networking: NETWORKING_ADAPTER_SHAPE,
+  navigation: NAVIGATION_ADAPTER_SHAPE,
+  audio: AUDIO_ADAPTER_SHAPE,
+  camera: CAMERA_ADAPTER_SHAPE,
+  renderDebug: RENDER_DEBUG_ADAPTER_SHAPE,
+} as const satisfies Record<ContractSystemSlot, object>;
+
+/**
+ * The render surface a declaration is being read ON — the same three words
+ * `IngestKind`/`AdapterSurface` already use, so nothing has to be declared
+ * twice.
+ */
+export type ContractSurface = 'three' | 'canvas' | 'dom';
+
+/**
+ * THE surface→physics-vocabulary rule, stated once.
+ *
+ * `null` for `dom`: that surface has no physics consumer at all, so nothing
+ * here can say which keying would be right for it and the check stands down
+ * rather than inventing an answer.
+ */
+const PHYSICS_KEYING_BY_SURFACE: Readonly<Record<ContractSurface, 'node-id' | 'display' | null>> = {
+  three: 'node-id',
+  canvas: 'display',
+  dom: null,
+};
+
+/** Fixed slot order, so two reports of the same mount are diffable line for
+ *  line (the same rule the coverage report's row order follows). */
+export const CONTRACT_SYSTEM_SLOTS = Object.keys(
+  GAME_SYSTEM_ADAPTERS_SHAPE,
+) as ContractSystemSlot[];
+
+export interface ContractSystemAdapterProjection {
+  /** Real adapters, ready to spread onto a `MountedRoot`'s `systems`. */
+  readonly bound: Partial<Pick<SystemAdapters, ContractSystemSlot>>;
+  /** Slots answered IMPLEMENTED-EMPTY, with the evidence. */
+  readonly empty: readonly ContractSystemEmptySlot[];
+  /** Slots declared but unusable — bound to nothing, reported by name. */
+  readonly malformed: readonly ContractSystemMalformedSlot[];
+}
+
+const EMPTY_PROJECTION: ContractSystemAdapterProjection = {
+  bound: {},
+  empty: [],
+  malformed: [],
+};
+
+function isEmptyRecord(value: object): value is VgaiGameSystemEmpty {
+  return (value as { present?: unknown }).present === false;
+}
+
+function missingMembers(slot: ContractSystemSlot, value: object): string[] {
+  const missing: string[] = [];
+  for (const [member, spec] of Object.entries(
+    SYSTEM_SHAPES[slot] as Readonly<Record<string, { readonly optional: boolean }>>,
+  )) {
+    if (spec.optional) continue;
+    if (typeof (value as Record<string, unknown>)[member] !== 'function') {
+      missing.push(member);
+    }
+  }
+  return missing;
+}
+
+/**
+ * The reason a declared physics carrier cannot serve `surface`, or `null` when
+ * it can (including when the caller supplied no surface to check against).
+ *
+ * The keying a carrier actually has is its tag's own answer, and an ABSENT tag
+ * IS `'node-id'` — see `PhysicsAdapter`'s comment for why the original
+ * vocabulary is the untagged one.
+ */
+function physicsKeyingMismatch(value: object, surface: ContractSurface | undefined): string | null {
+  const want = surface ? PHYSICS_KEYING_BY_SURFACE[surface] : null;
+  if (want === null) return null;
+  const got = (value as { keyedBy?: unknown }).keyedBy === 'display' ? 'display' : 'node-id';
+  if (got === want) return null;
+  return (
+    `declared a ${got}-keyed physics carrier on the ${surface} surface, whose gizmo path ` +
+    `addresses bodies by ${want} — the four members are all present but nothing on this lane ` +
+    `can call them with values they accept (a ${surface}-surface carrier declares ` +
+    `\`keyedBy: '${want}'\`)`
+  );
+}
+
+/** One slot's verdict, before it is filed into the three lists. */
+type SlotVerdict =
+  | { readonly kind: 'skip' }
+  | { readonly kind: 'bound' }
+  | { readonly kind: 'empty'; readonly evidence: string }
+  | { readonly kind: 'malformed'; readonly reason: string };
+
+/**
+ * THE per-slot decision, in the order the module header states: is it declared
+ * at all, is it the positively-answered empty, does it carry the members its
+ * interface requires, and (physics only) is it keyed for this surface.
+ *
+ * Split out of {@link projectContractSystemAdapters} so the projection itself
+ * is a loop over verdicts — one place decides, one place files.
+ */
+function classifyDeclaredSlot(
+  slot: ContractSystemSlot,
+  value: unknown,
+  surface: ContractSurface | undefined,
+): SlotVerdict {
+  if (value === undefined || value === null) return { kind: 'skip' };
+  if (typeof value !== 'object') {
+    return {
+      kind: 'malformed',
+      reason: `declared as ${typeof value}; expected an adapter object or { present: false, evidence }`,
+    };
+  }
+  if (isEmptyRecord(value)) {
+    const evidence = (value as VgaiGameSystemEmpty).evidence;
+    // An empty claim with no evidence is exactly the "wrong empty claim" the
+    // bar calls a defect — it asserts an absence nobody can re-check.
+    if (typeof evidence !== 'string' || evidence.trim() === '') {
+      return {
+        kind: 'malformed',
+        reason: 'declared `present: false` with no `evidence` string to back the absence',
+      };
+    }
+    return { kind: 'empty', evidence };
+  }
+  const missing = missingMembers(slot, value);
+  if (missing.length > 0) {
+    return {
+      kind: 'malformed',
+      reason: `declared an adapter missing required member(s): ${missing.join(', ')}`,
+    };
+  }
+  const mismatch = slot === 'physics' ? physicsKeyingMismatch(value, surface) : null;
+  if (mismatch !== null) return { kind: 'malformed', reason: mismatch };
+  return { kind: 'bound' };
+}
+
+/**
+ * Read the declared slots and sort each into exactly one verdict. A game that
+ * declared no `systemAdapters` at all projects to three empty lists — which is
+ * the "nobody answered" case, and is deliberately NOT the same as declaring
+ * every slot empty.
+ *
+ * `surface` is the mount's own surface fact when it has one; see the module
+ * header for what it buys and why its absence checks nothing.
+ */
+export function projectContractSystemAdapters(
+  systems: VgaiGameSystems | undefined | null,
+  surface?: ContractSurface | undefined,
+): ContractSystemAdapterProjection {
+  const declared = systems?.systemAdapters;
+  if (!declared) return EMPTY_PROJECTION;
+
+  const bound: Record<string, unknown> = {};
+  const empty: ContractSystemEmptySlot[] = [];
+  const malformed: ContractSystemMalformedSlot[] = [];
+
+  for (const slot of CONTRACT_SYSTEM_SLOTS) {
+    const verdict = classifyDeclaredSlot(slot, declared[slot], surface);
+    if (verdict.kind === 'bound') bound[slot] = declared[slot];
+    else if (verdict.kind === 'empty') empty.push({ slot, evidence: verdict.evidence });
+    else if (verdict.kind === 'malformed') malformed.push({ slot, reason: verdict.reason });
+  }
+
+  return {
+    bound: bound as ContractSystemAdapterProjection['bound'],
+    empty,
+    malformed,
+  };
+}