space-data-module-sdk 0.8.3 → 0.8.5

package/src/manifest/plgCodec.js

@@ -1,6 +1,6 @@
 /**
  * Codec for the canonical spacedatastandards.org `PLG` plugin manifest schema
- * (vendored at `schemas/spacedatastandards/PLG.fbs`, v1.0.5).
+ * generated from the installed SDS package's `schema/PLG/main.fbs`.
  *
  * This codec replaces the older internal `PluginManifest` (`PMAN`) schema as
  * the on-the-wire manifest format embedded in plugin wasm artifacts.
@@ -13,13 +13,31 @@ import * as flatbuffers from "flatbuffers/mjs/flatbuffers.js";
 
 import {
   EntryFunction,
+  FlatBufferTypeRef,
   PLG,
+  PLGAcceptedTypeSet,
+  PLGBuildArtifact,
+  PLGFlowEdge,
+  PLGFlowEdgeContract,
+  PLGFlowNode,
+  PLGFlowTrigger,
+  PLGFlowTriggerBinding,
+  PLGHostCapability,
+  PLGMethodManifest,
+  PLGPortManifest,
+  PLGProtocolSpec,
+  PLGTimerSpec,
   PluginCapability,
   PluginDependency,
+  drainBehavior,
+  flowEdgeRoutePolicy,
+  hostCapabilityKind,
+  invokeSurfaceKind,
+  payloadWireFormat,
   publicationState,
   purchaseTier,
   pluginCategory,
-} from "../generated/spacedatastandards/plg/index.js";
+} from "../generated/spacedatastandards/plg/main.js";
 import { toUint8Array } from "../runtime/bufferLike.js";
 
 export const PLG_FILE_IDENTIFIER = "$PLG";
@@ -78,6 +96,29 @@ function normalizeByteVector(value) {
   return null;
 }
 
+function normalizeOptionalString(value) {
+  if (value === undefined || value === null) {
+    return null;
+  }
+  const normalized = String(value).trim();
+  return normalized.length > 0 ? normalized : null;
+}
+
+function normalizeUnsignedInteger(value, fallback = 0) {
+  const normalized = Number(value ?? fallback);
+  if (!Number.isFinite(normalized)) {
+    return fallback;
+  }
+  return Math.max(0, Math.trunc(normalized));
+}
+
+function canonicalEnumKey(value) {
+  return String(value ?? "")
+    .trim()
+    .toLowerCase()
+    .replace(/-/g, "_");
+}
+
 const pluginTypeByName = Object.freeze({
   sensor: pluginCategory.Sensor,
   propagator: pluginCategory.Propagator,
@@ -141,6 +182,138 @@ function resolveListingStatus(value) {
   return listingStatusByName[key] ?? publicationState.Public;
 }
 
+const payloadWireFormatByName = Object.freeze({
+  flatbuffer: payloadWireFormat.FLATBUFFER,
+  aligned_binary: payloadWireFormat.ALIGNED_BINARY,
+});
+
+function resolvePayloadWireFormat(value) {
+  if (typeof value === "number") {
+    return value;
+  }
+  return payloadWireFormatByName[canonicalEnumKey(value)] ?? payloadWireFormat.FLATBUFFER;
+}
+
+function payloadWireFormatName(value) {
+  return resolvePayloadWireFormat(value) === payloadWireFormat.ALIGNED_BINARY
+    ? "aligned-binary"
+    : "flatbuffer";
+}
+
+const flowEdgeRoutePolicyByName = Object.freeze({
+  canonical_only: flowEdgeRoutePolicy.CANONICAL_ONLY,
+  aligned_shared_arena_or_canonical:
+    flowEdgeRoutePolicy.ALIGNED_SHARED_ARENA_OR_CANONICAL,
+});
+
+function resolveFlowEdgeRoutePolicy(value) {
+  if (typeof value === "number") return value;
+  return flowEdgeRoutePolicyByName[canonicalEnumKey(value)] ??
+    flowEdgeRoutePolicy.CANONICAL_ONLY;
+}
+
+function flowEdgeRoutePolicyName(value) {
+  return resolveFlowEdgeRoutePolicy(value) ===
+    flowEdgeRoutePolicy.ALIGNED_SHARED_ARENA_OR_CANONICAL
+    ? "aligned-shared-arena-or-canonical"
+    : "canonical-only";
+}
+
+const invokeSurfaceByName = Object.freeze({
+  direct: invokeSurfaceKind.DIRECT,
+  command: invokeSurfaceKind.COMMAND,
+});
+
+function resolveInvokeSurface(value) {
+  if (typeof value === "number") {
+    return value;
+  }
+  return invokeSurfaceByName[canonicalEnumKey(value)] ?? null;
+}
+
+function invokeSurfaceName(value) {
+  return resolveInvokeSurface(value) === invokeSurfaceKind.COMMAND
+    ? "command"
+    : "direct";
+}
+
+const drainPolicyByName = Object.freeze({
+  single_shot: drainBehavior.SINGLE_SHOT,
+  drain_until_yield: drainBehavior.DRAIN_UNTIL_YIELD,
+  drain_to_empty: drainBehavior.DRAIN_TO_EMPTY,
+});
+
+function resolveDrainPolicy(value) {
+  if (typeof value === "number") {
+    return value;
+  }
+  return drainPolicyByName[canonicalEnumKey(value)] ?? drainBehavior.DRAIN_UNTIL_YIELD;
+}
+
+function drainPolicyName(value) {
+  switch (resolveDrainPolicy(value)) {
+    case drainBehavior.SINGLE_SHOT:
+      return "single-shot";
+    case drainBehavior.DRAIN_TO_EMPTY:
+      return "drain-to-empty";
+    case drainBehavior.DRAIN_UNTIL_YIELD:
+    default:
+      return "drain-until-yield";
+  }
+}
+
+const hostCapabilityByName = Object.freeze({
+  clock: hostCapabilityKind.CLOCK,
+  random: hostCapabilityKind.RANDOM,
+  logging: hostCapabilityKind.LOGGING,
+  timers: hostCapabilityKind.TIMERS,
+  pubsub: hostCapabilityKind.PUBSUB,
+  protocol_dial: hostCapabilityKind.PROTOCOL_DIAL,
+  protocol_handle: hostCapabilityKind.PROTOCOL_HANDLE,
+  storage_query: hostCapabilityKind.STORAGE_QUERY,
+  scene_access: hostCapabilityKind.SCENE_ACCESS,
+  entity_access: hostCapabilityKind.ENTITY_ACCESS,
+  render_hooks: hostCapabilityKind.RENDER_HOOKS,
+  http: hostCapabilityKind.HTTP,
+  filesystem: hostCapabilityKind.FILESYSTEM,
+  pipe: hostCapabilityKind.PIPE,
+  network: hostCapabilityKind.NETWORK,
+  database: hostCapabilityKind.DATABASE,
+  storage_adapter: hostCapabilityKind.STORAGE_ADAPTER,
+  storage_write: hostCapabilityKind.STORAGE_WRITE,
+  wallet_sign: hostCapabilityKind.WALLET_SIGN,
+  ipfs: hostCapabilityKind.IPFS,
+  tls: hostCapabilityKind.TLS,
+  mqtt: hostCapabilityKind.MQTT,
+  websocket: hostCapabilityKind.WEBSOCKET,
+  tcp: hostCapabilityKind.TCP,
+  udp: hostCapabilityKind.UDP,
+  process_exec: hostCapabilityKind.PROCESS_EXEC,
+  context_read: hostCapabilityKind.CONTEXT_READ,
+  context_write: hostCapabilityKind.CONTEXT_WRITE,
+  crypto_hash: hostCapabilityKind.CRYPTO_HASH,
+  crypto_sign: hostCapabilityKind.CRYPTO_SIGN,
+  crypto_verify: hostCapabilityKind.CRYPTO_VERIFY,
+  crypto_encrypt: hostCapabilityKind.CRYPTO_ENCRYPT,
+  crypto_decrypt: hostCapabilityKind.CRYPTO_DECRYPT,
+  crypto_key_agreement: hostCapabilityKind.CRYPTO_KEY_AGREEMENT,
+  crypto_kdf: hostCapabilityKind.CRYPTO_KDF,
+  schedule_cron: hostCapabilityKind.SCHEDULE_CRON,
+  storage_ingest: hostCapabilityKind.STORAGE_INGEST,
+});
+
+function resolveHostCapability(value) {
+  if (typeof value === "number") {
+    return value;
+  }
+  return hostCapabilityByName[canonicalEnumKey(value)] ?? hostCapabilityKind.CLOCK;
+}
+
+function hostCapabilityName(value) {
+  const enumName = hostCapabilityKind[resolveHostCapability(value)];
+  return typeof enumName === "string" ? enumName.toLowerCase() : "clock";
+}
+
 function addStringVector(builder, values, addVectorHelper) {
   const strings = normalizeStringArray(values);
   if (strings.length === 0) {
@@ -207,10 +380,17 @@ function addEntryFunction(builder, entry) {
 }
 
 function addPluginCapability(builder, capability) {
-  const name = typeof capability?.name === "string" ? capability.name : null;
+  const source =
+    typeof capability === "string" ? { name: capability } : capability ?? {};
+  const name =
+    typeof source.name === "string"
+      ? source.name
+      : typeof source.capability === "string"
+        ? source.capability
+        : null;
   const version =
-    typeof capability?.version === "string" ? capability.version : null;
-  const required = capability?.required !== false;
+    typeof source.version === "string" ? source.version : null;
+  const required = source.required !== false;
 
   const nameOffset = name ? builder.createString(name) : 0;
   const versionOffset = version ? builder.createString(version) : 0;
@@ -268,6 +448,829 @@ function addOffsetVector(builder, offsets) {
   return builder.endVector();
 }
 
+function addFlatBufferTypeRef(builder, typeRef = {}) {
+  if (typeof typeRef === "string") {
+    typeRef = { schemaName: typeRef };
+  }
+  const schemaName = normalizeOptionalString(
+    pick(typeRef, "schemaName", "schema_name", "SCHEMA_NAME", "name"),
+  );
+  const fileIdentifier = normalizeOptionalString(
+    pick(typeRef, "fileIdentifier", "file_identifier", "FILE_IDENTIFIER"),
+  );
+  const schemaVersion = normalizeOptionalString(
+    pick(typeRef, "schemaVersion", "schema_version", "SCHEMA_VERSION"),
+  );
+  const rootType = normalizeOptionalString(
+    pick(typeRef, "rootTypeName", "root_type_name", "rootType", "ROOT_TYPE"),
+  );
+  const schemaHash = normalizeByteVector(
+    pick(typeRef, "schemaHash", "schema_hash", "SCHEMA_HASH"),
+  );
+  const acceptsAnyFlatbuffer = Boolean(
+    pick(
+      typeRef,
+      "acceptsAnyFlatbuffer",
+      "accepts_any_flatbuffer",
+      "ACCEPTS_ANY_FLATBUFFER",
+    ) ?? false,
+  );
+  const wireFormat = resolvePayloadWireFormat(
+    pick(typeRef, "wireFormat", "wire_format", "WIRE_FORMAT"),
+  );
+  const fixedStringLength = normalizeUnsignedInteger(
+    pick(typeRef, "fixedStringLength", "fixed_string_length", "FIXED_STRING_LENGTH"),
+  );
+  const byteLength = normalizeUnsignedInteger(
+    pick(typeRef, "byteLength", "byte_length", "BYTE_LENGTH"),
+  );
+  const requiredAlignment = normalizeUnsignedInteger(
+    pick(typeRef, "requiredAlignment", "required_alignment", "REQUIRED_ALIGNMENT"),
+  );
+
+  const schemaNameOffset = schemaName ? builder.createString(schemaName) : 0;
+  const fileIdentifierOffset = fileIdentifier
+    ? builder.createString(fileIdentifier)
+    : 0;
+  const schemaVersionOffset = schemaVersion ? builder.createString(schemaVersion) : 0;
+  const rootTypeOffset = rootType ? builder.createString(rootType) : 0;
+  const schemaHashOffset = addByteVector(
+    builder,
+    schemaHash,
+    FlatBufferTypeRef.startSchemaHashVector,
+  );
+
+  FlatBufferTypeRef.startFlatBufferTypeRef(builder);
+  if (schemaNameOffset) FlatBufferTypeRef.addSchemaName(builder, schemaNameOffset);
+  if (fileIdentifierOffset)
+    FlatBufferTypeRef.addFileIdentifier(builder, fileIdentifierOffset);
+  if (schemaVersionOffset)
+    FlatBufferTypeRef.addSchemaVersion(builder, schemaVersionOffset);
+  if (rootTypeOffset) FlatBufferTypeRef.addRootType(builder, rootTypeOffset);
+  if (schemaHashOffset) FlatBufferTypeRef.addSchemaHash(builder, schemaHashOffset);
+  if (acceptsAnyFlatbuffer)
+    FlatBufferTypeRef.addAcceptsAnyFlatbuffer(builder, acceptsAnyFlatbuffer);
+  if (wireFormat !== payloadWireFormat.FLATBUFFER)
+    FlatBufferTypeRef.addWireFormat(builder, wireFormat);
+  if (fixedStringLength > 0)
+    FlatBufferTypeRef.addFixedStringLength(builder, fixedStringLength);
+  if (byteLength > 0) FlatBufferTypeRef.addByteLength(builder, byteLength);
+  if (requiredAlignment > 0)
+    FlatBufferTypeRef.addRequiredAlignment(builder, requiredAlignment);
+  return FlatBufferTypeRef.endFlatBufferTypeRef(builder);
+}
+
+function typeRefToObject(typeRef) {
+  if (!typeRef) {
+    return null;
+  }
+  const schemaHash = typeRef.schemaHashArray?.() ?? null;
+  const fixedStringLength = typeRef.FIXED_STRING_LENGTH?.() ?? 0;
+  const byteLength = typeRef.BYTE_LENGTH?.() ?? 0;
+  const requiredAlignment = typeRef.REQUIRED_ALIGNMENT?.() ?? 0;
+  return {
+    schemaName: typeRef.SCHEMA_NAME?.() || undefined,
+    fileIdentifier: typeRef.FILE_IDENTIFIER?.() || undefined,
+    schemaVersion: typeRef.SCHEMA_VERSION?.() || undefined,
+    rootTypeName: typeRef.ROOT_TYPE?.() || undefined,
+    ...(schemaHash && schemaHash.length > 0 ? { schemaHash } : {}),
+    ...(typeRef.ACCEPTS_ANY_FLATBUFFER?.()
+      ? { acceptsAnyFlatbuffer: true }
+      : {}),
+    wireFormat: payloadWireFormatName(typeRef.WIRE_FORMAT?.()),
+    ...(fixedStringLength > 0 ? { fixedStringLength } : {}),
+    ...(byteLength > 0 ? { byteLength } : {}),
+    ...(requiredAlignment > 0 ? { requiredAlignment } : {}),
+  };
+}
+
+function normalizeAllowedWireFormats(typeSet = {}) {
+  const values = [];
+  const allowedTypes = Array.isArray(typeSet.allowedTypes)
+    ? typeSet.allowedTypes
+    : Array.isArray(typeSet.ALLOWED_TYPES)
+      ? typeSet.ALLOWED_TYPES
+      : [];
+  for (const allowedType of allowedTypes) {
+    values.push(resolvePayloadWireFormat(allowedType?.wireFormat));
+  }
+  const unique = [];
+  const seen = new Set();
+  for (const value of values.length > 0 ? values : [payloadWireFormat.FLATBUFFER]) {
+    if (seen.has(value)) {
+      continue;
+    }
+    seen.add(value);
+    unique.push(value);
+  }
+  return unique;
+}
+
+function addAcceptedTypeSet(builder, typeSet = {}) {
+  const setId = normalizeOptionalString(
+    pick(typeSet, "setId", "set_id", "SET_ID"),
+  );
+  if (!setId) {
+    return 0;
+  }
+  const allowedTypes = Array.isArray(typeSet.allowedTypes)
+    ? typeSet.allowedTypes
+    : Array.isArray(typeSet.ALLOWED_TYPES)
+      ? typeSet.ALLOWED_TYPES
+      : [];
+  const allowedTypeOffsets = allowedTypes.map((entry) =>
+    addFlatBufferTypeRef(builder, entry),
+  );
+  const allowedTypesOffset = PLGAcceptedTypeSet.createAllowedTypesVector(
+    builder,
+    allowedTypeOffsets,
+  );
+  const allowedWireFormatsOffset =
+    PLGAcceptedTypeSet.createAllowedWireFormatsVector(
+      builder,
+      normalizeAllowedWireFormats(typeSet),
+    );
+  const description = normalizeOptionalString(
+    pick(typeSet, "description", "DESCRIPTION"),
+  );
+  const setIdOffset = builder.createString(setId);
+  const descriptionOffset = description ? builder.createString(description) : 0;
+  PLGAcceptedTypeSet.startPLGAcceptedTypeSet(builder);
+  PLGAcceptedTypeSet.addSetId(builder, setIdOffset);
+  if (allowedTypesOffset)
+    PLGAcceptedTypeSet.addAllowedTypes(builder, allowedTypesOffset);
+  if (allowedWireFormatsOffset)
+    PLGAcceptedTypeSet.addAllowedWireFormats(builder, allowedWireFormatsOffset);
+  if (descriptionOffset)
+    PLGAcceptedTypeSet.addDescription(builder, descriptionOffset);
+  return PLGAcceptedTypeSet.endPLGAcceptedTypeSet(builder);
+}
+
+function acceptedTypeSetToObject(typeSet) {
+  const allowedTypes = [];
+  const allowedTypeCount = typeSet?.allowedTypesLength?.() ?? 0;
+  for (let index = 0; index < allowedTypeCount; index += 1) {
+    const value = typeRefToObject(typeSet.ALLOWED_TYPES(index));
+    if (value) {
+      allowedTypes.push(value);
+    }
+  }
+  return {
+    setId: typeSet.SET_ID(),
+    allowedTypes,
+    allowedWireFormats: Array.from(
+      typeSet.allowedWireFormatsArray?.() ?? [],
+      (value) => payloadWireFormatName(value),
+    ),
+    description: typeSet.DESCRIPTION() || undefined,
+  };
+}
+
+function addPortManifest(builder, port = {}) {
+  const portId = normalizeOptionalString(pick(port, "portId", "port_id", "PORT_ID"));
+  if (!portId) {
+    return 0;
+  }
+  const acceptedTypeSets = Array.isArray(port.acceptedTypeSets)
+    ? port.acceptedTypeSets
+    : Array.isArray(port.ACCEPTED_TYPE_SETS)
+      ? port.ACCEPTED_TYPE_SETS
+      : [];
+  const acceptedTypeSetOffsets = acceptedTypeSets
+    .map((entry) => addAcceptedTypeSet(builder, entry))
+    .filter(Boolean);
+  const acceptedTypeSetsOffset = PLGPortManifest.createAcceptedTypeSetsVector(
+    builder,
+    acceptedTypeSetOffsets,
+  );
+  const displayName = normalizeOptionalString(
+    pick(port, "displayName", "display_name", "DISPLAY_NAME"),
+  );
+  const description = normalizeOptionalString(pick(port, "description", "DESCRIPTION"));
+  const portIdOffset = builder.createString(portId);
+  const displayNameOffset = displayName ? builder.createString(displayName) : 0;
+  const descriptionOffset = description ? builder.createString(description) : 0;
+  PLGPortManifest.startPLGPortManifest(builder);
+  PLGPortManifest.addPortId(builder, portIdOffset);
+  if (displayNameOffset) PLGPortManifest.addDisplayName(builder, displayNameOffset);
+  if (acceptedTypeSetsOffset)
+    PLGPortManifest.addAcceptedTypeSets(builder, acceptedTypeSetsOffset);
+  PLGPortManifest.addMinStreams(
+    builder,
+    normalizeUnsignedInteger(pick(port, "minStreams", "min_streams", "MIN_STREAMS"), 1),
+  );
+  PLGPortManifest.addMaxStreams(
+    builder,
+    normalizeUnsignedInteger(pick(port, "maxStreams", "max_streams", "MAX_STREAMS"), 1),
+  );
+  PLGPortManifest.addRequired(
+    builder,
+    pick(port, "required", "REQUIRED") !== false,
+  );
+  if (descriptionOffset) PLGPortManifest.addDescription(builder, descriptionOffset);
+  return PLGPortManifest.endPLGPortManifest(builder);
+}
+
+function portManifestToObject(port) {
+  const acceptedTypeSets = [];
+  const count = port?.acceptedTypeSetsLength?.() ?? 0;
+  for (let index = 0; index < count; index += 1) {
+    const typeSet = port.ACCEPTED_TYPE_SETS(index);
+    if (typeSet) {
+      acceptedTypeSets.push(acceptedTypeSetToObject(typeSet));
+    }
+  }
+  return {
+    portId: port.PORT_ID(),
+    displayName: port.DISPLAY_NAME() || undefined,
+    acceptedTypeSets,
+    minStreams: port.MIN_STREAMS(),
+    maxStreams: port.MAX_STREAMS(),
+    required: port.REQUIRED(),
+    description: port.DESCRIPTION() || undefined,
+  };
+}
+
+function addMethodManifest(builder, method = {}) {
+  const methodId = normalizeOptionalString(
+    pick(method, "methodId", "method_id", "METHOD_ID", "name"),
+  );
+  if (!methodId) {
+    return 0;
+  }
+  const inputPorts = Array.isArray(method.inputPorts)
+    ? method.inputPorts
+    : Array.isArray(method.INPUT_PORTS)
+      ? method.INPUT_PORTS
+      : [];
+  const outputPorts = Array.isArray(method.outputPorts)
+    ? method.outputPorts
+    : Array.isArray(method.OUTPUT_PORTS)
+      ? method.OUTPUT_PORTS
+      : [];
+  const inputPortOffsets = inputPorts
+    .map((port) => addPortManifest(builder, port))
+    .filter(Boolean);
+  const outputPortOffsets = outputPorts
+    .map((port) => addPortManifest(builder, port))
+    .filter(Boolean);
+  const inputPortsOffset = PLGMethodManifest.createInputPortsVector(
+    builder,
+    inputPortOffsets,
+  );
+  const outputPortsOffset = PLGMethodManifest.createOutputPortsVector(
+    builder,
+    outputPortOffsets,
+  );
+  const displayName = normalizeOptionalString(
+    pick(method, "displayName", "display_name", "DISPLAY_NAME"),
+  );
+  const description = normalizeOptionalString(
+    pick(method, "description", "DESCRIPTION"),
+  );
+  const methodIdOffset = builder.createString(methodId);
+  const displayNameOffset = displayName ? builder.createString(displayName) : 0;
+  const descriptionOffset = description ? builder.createString(description) : 0;
+  PLGMethodManifest.startPLGMethodManifest(builder);
+  PLGMethodManifest.addMethodId(builder, methodIdOffset);
+  if (displayNameOffset)
+    PLGMethodManifest.addDisplayName(builder, displayNameOffset);
+  if (inputPortsOffset) PLGMethodManifest.addInputPorts(builder, inputPortsOffset);
+  if (outputPortsOffset)
+    PLGMethodManifest.addOutputPorts(builder, outputPortsOffset);
+  PLGMethodManifest.addMaxBatch(
+    builder,
+    normalizeUnsignedInteger(pick(method, "maxBatch", "max_batch", "MAX_BATCH"), 1),
+  );
+  PLGMethodManifest.addDrainPolicy(
+    builder,
+    resolveDrainPolicy(pick(method, "drainPolicy", "drain_policy", "DRAIN_POLICY")),
+  );
+  if (descriptionOffset) PLGMethodManifest.addDescription(builder, descriptionOffset);
+  return PLGMethodManifest.endPLGMethodManifest(builder);
+}
+
+function methodManifestToObject(method) {
+  const inputPorts = [];
+  const outputPorts = [];
+  for (let index = 0; index < (method?.inputPortsLength?.() ?? 0); index += 1) {
+    const port = method.INPUT_PORTS(index);
+    if (port) inputPorts.push(portManifestToObject(port));
+  }
+  for (let index = 0; index < (method?.outputPortsLength?.() ?? 0); index += 1) {
+    const port = method.OUTPUT_PORTS(index);
+    if (port) outputPorts.push(portManifestToObject(port));
+  }
+  return {
+    methodId: method.METHOD_ID(),
+    displayName: method.DISPLAY_NAME() || undefined,
+    inputPorts,
+    outputPorts,
+    maxBatch: method.MAX_BATCH(),
+    drainPolicy: drainPolicyName(method.DRAIN_POLICY()),
+    description: method.DESCRIPTION() || undefined,
+  };
+}
+
+function addHostCapability(builder, capability = {}) {
+  const source =
+    typeof capability === "string" ? { capability } : capability ?? {};
+  const scope = normalizeOptionalString(pick(source, "scope", "SCOPE"));
+  const description = normalizeOptionalString(
+    pick(source, "description", "DESCRIPTION"),
+  );
+  const scopeOffset = scope ? builder.createString(scope) : 0;
+  const descriptionOffset = description ? builder.createString(description) : 0;
+  PLGHostCapability.startPLGHostCapability(builder);
+  PLGHostCapability.addCapability(
+    builder,
+    resolveHostCapability(pick(source, "capability", "CAPABILITY", "name")),
+  );
+  if (scopeOffset) PLGHostCapability.addScope(builder, scopeOffset);
+  PLGHostCapability.addRequired(
+    builder,
+    pick(source, "required", "REQUIRED") !== false,
+  );
+  if (descriptionOffset)
+    PLGHostCapability.addDescription(builder, descriptionOffset);
+  return PLGHostCapability.endPLGHostCapability(builder);
+}
+
+function hostCapabilityToObject(capability) {
+  return {
+    capability: hostCapabilityName(capability.CAPABILITY()),
+    scope: capability.SCOPE() || undefined,
+    required: capability.REQUIRED(),
+    description: capability.DESCRIPTION() || undefined,
+  };
+}
+
+function addTimerSpec(builder, timer = {}) {
+  const timerId = normalizeOptionalString(pick(timer, "timerId", "timer_id", "TIMER_ID"));
+  const methodId = normalizeOptionalString(pick(timer, "methodId", "method_id", "METHOD_ID"));
+  if (!timerId || !methodId) {
+    return 0;
+  }
+  const inputPortId = normalizeOptionalString(
+    pick(timer, "inputPortId", "input_port_id", "INPUT_PORT_ID"),
+  );
+  const description = normalizeOptionalString(pick(timer, "description", "DESCRIPTION"));
+  const timerIdOffset = builder.createString(timerId);
+  const methodIdOffset = builder.createString(methodId);
+  const inputPortIdOffset = inputPortId ? builder.createString(inputPortId) : 0;
+  const descriptionOffset = description ? builder.createString(description) : 0;
+  PLGTimerSpec.startPLGTimerSpec(builder);
+  PLGTimerSpec.addTimerId(builder, timerIdOffset);
+  PLGTimerSpec.addMethodId(builder, methodIdOffset);
+  if (inputPortIdOffset) PLGTimerSpec.addInputPortId(builder, inputPortIdOffset);
+  PLGTimerSpec.addDefaultIntervalMs(
+    builder,
+    toBigInt(pick(timer, "defaultIntervalMs", "default_interval_ms", "DEFAULT_INTERVAL_MS")),
+  );
+  if (descriptionOffset) PLGTimerSpec.addDescription(builder, descriptionOffset);
+  return PLGTimerSpec.endPLGTimerSpec(builder);
+}
+
+function timerSpecToObject(timer) {
+  return {
+    timerId: timer.TIMER_ID(),
+    methodId: timer.METHOD_ID(),
+    inputPortId: timer.INPUT_PORT_ID() || undefined,
+    defaultIntervalMs: timer.DEFAULT_INTERVAL_MS(),
+    description: timer.DESCRIPTION() || undefined,
+  };
+}
+
+function addProtocolSpec(builder, protocol = {}) {
+  const protocolId = normalizeOptionalString(
+    pick(protocol, "protocolId", "protocol_id", "PROTOCOL_ID"),
+  );
+  const methodId = normalizeOptionalString(
+    pick(protocol, "methodId", "method_id", "METHOD_ID"),
+  );
+  if (!protocolId || !methodId) {
+    return 0;
+  }
+  const stringFields = {
+    inputPortId: normalizeOptionalString(
+      pick(protocol, "inputPortId", "input_port_id", "INPUT_PORT_ID"),
+    ),
+    outputPortId: normalizeOptionalString(
+      pick(protocol, "outputPortId", "output_port_id", "OUTPUT_PORT_ID"),
+    ),
+    description: normalizeOptionalString(pick(protocol, "description", "DESCRIPTION")),
+    wireId: normalizeOptionalString(pick(protocol, "wireId", "wire_id", "WIRE_ID")),
+    transportKind: normalizeOptionalString(
+      pick(protocol, "transportKind", "transport_kind", "TRANSPORT_KIND"),
+    ),
+    role: normalizeOptionalString(pick(protocol, "role", "ROLE")),
+    specUri: normalizeOptionalString(pick(protocol, "specUri", "spec_uri", "SPEC_URI")),
+    discoveryKey: normalizeOptionalString(
+      pick(protocol, "discoveryKey", "discovery_key", "DISCOVERY_KEY"),
+    ),
+  };
+  const offsets = Object.fromEntries(
+    Object.entries(stringFields).map(([key, value]) => [
+      key,
+      value ? builder.createString(value) : 0,
+    ]),
+  );
+  const protocolIdOffset = builder.createString(protocolId);
+  const methodIdOffset = builder.createString(methodId);
+  PLGProtocolSpec.startPLGProtocolSpec(builder);
+  PLGProtocolSpec.addProtocolId(builder, protocolIdOffset);
+  PLGProtocolSpec.addMethodId(builder, methodIdOffset);
+  if (offsets.inputPortId) PLGProtocolSpec.addInputPortId(builder, offsets.inputPortId);
+  if (offsets.outputPortId)
+    PLGProtocolSpec.addOutputPortId(builder, offsets.outputPortId);
+  if (offsets.description)
+    PLGProtocolSpec.addDescription(builder, offsets.description);
+  if (offsets.wireId) PLGProtocolSpec.addWireId(builder, offsets.wireId);
+  if (offsets.transportKind)
+    PLGProtocolSpec.addTransportKind(builder, offsets.transportKind);
+  if (offsets.role) PLGProtocolSpec.addRole(builder, offsets.role);
+  if (offsets.specUri) PLGProtocolSpec.addSpecUri(builder, offsets.specUri);
+  PLGProtocolSpec.addAutoInstall(
+    builder,
+    pick(protocol, "autoInstall", "auto_install", "AUTO_INSTALL") !== false,
+  );
+  PLGProtocolSpec.addAdvertise(
+    builder,
+    Boolean(pick(protocol, "advertise", "ADVERTISE") ?? false),
+  );
+  if (offsets.discoveryKey)
+    PLGProtocolSpec.addDiscoveryKey(builder, offsets.discoveryKey);
+  PLGProtocolSpec.addDefaultPort(
+    builder,
+    normalizeUnsignedInteger(pick(protocol, "defaultPort", "default_port", "DEFAULT_PORT")),
+  );
+  PLGProtocolSpec.addRequireSecureTransport(
+    builder,
+    Boolean(
+      pick(
+        protocol,
+        "requireSecureTransport",
+        "require_secure_transport",
+        "REQUIRE_SECURE_TRANSPORT",
+      ) ?? false,
+    ),
+  );
+  return PLGProtocolSpec.endPLGProtocolSpec(builder);
+}
+
+function protocolSpecToObject(protocol) {
+  return {
+    protocolId: protocol.PROTOCOL_ID(),
+    methodId: protocol.METHOD_ID(),
+    inputPortId: protocol.INPUT_PORT_ID() || undefined,
+    outputPortId: protocol.OUTPUT_PORT_ID() || undefined,
+    description: protocol.DESCRIPTION() || undefined,
+    wireId: protocol.WIRE_ID() || undefined,
+    transportKind: protocol.TRANSPORT_KIND() || undefined,
+    role: protocol.ROLE() || undefined,
+    specUri: protocol.SPEC_URI() || undefined,
+    autoInstall: protocol.AUTO_INSTALL(),
+    advertise: protocol.ADVERTISE(),
+    discoveryKey: protocol.DISCOVERY_KEY() || undefined,
+    defaultPort: protocol.DEFAULT_PORT(),
+    requireSecureTransport: protocol.REQUIRE_SECURE_TRANSPORT(),
+  };
+}
+
+function addBuildArtifact(builder, artifact = {}) {
+  const artifactId = normalizeOptionalString(
+    pick(artifact, "artifactId", "artifact_id", "ARTIFACT_ID"),
+  );
+  const path = normalizeOptionalString(pick(artifact, "path", "PATH"));
+  if (!artifactId || !path) {
+    return 0;
+  }
+  const kind = normalizeOptionalString(pick(artifact, "kind", "KIND"));
+  const target = normalizeOptionalString(pick(artifact, "target", "TARGET"));
+  const entrySymbol = normalizeOptionalString(
+    pick(artifact, "entrySymbol", "entry_symbol", "ENTRY_SYMBOL"),
+  );
+  const artifactIdOffset = builder.createString(artifactId);
+  const kindOffset = kind ? builder.createString(kind) : 0;
+  const pathOffset = builder.createString(path);
+  const targetOffset = target ? builder.createString(target) : 0;
+  const entrySymbolOffset = entrySymbol ? builder.createString(entrySymbol) : 0;
+  PLGBuildArtifact.startPLGBuildArtifact(builder);
+  PLGBuildArtifact.addArtifactId(builder, artifactIdOffset);
+  if (kindOffset) PLGBuildArtifact.addKind(builder, kindOffset);
+  PLGBuildArtifact.addPath(builder, pathOffset);
+  if (targetOffset) PLGBuildArtifact.addTarget(builder, targetOffset);
+  if (entrySymbolOffset)
+    PLGBuildArtifact.addEntrySymbol(builder, entrySymbolOffset);
+  return PLGBuildArtifact.endPLGBuildArtifact(builder);
+}
+
+function buildArtifactToObject(artifact) {
+  return {
+    artifactId: artifact.ARTIFACT_ID(),
+    kind: artifact.KIND() || undefined,
+    path: artifact.PATH(),
+    target: artifact.TARGET() || undefined,
+    entrySymbol: artifact.ENTRY_SYMBOL() || undefined,
+  };
+}
+
+function addFlowNode(builder, node = {}) {
+  const nodeId = normalizeOptionalString(
+    pick(node, "nodeId", "node_id", "NODE_ID"),
+  );
+  const pluginId = normalizeOptionalString(
+    pick(node, "pluginId", "plugin_id", "PLUGIN_ID"),
+  );
+  if (!nodeId || !pluginId) {
+    throw new TypeError("PLG flow node requires nodeId and pluginId.");
+  }
+  const methodId = normalizeOptionalString(
+    pick(node, "methodId", "method_id", "METHOD_ID"),
+  );
+  const kind = normalizeOptionalString(pick(node, "kind", "KIND"));
+  const dispatchModel = normalizeOptionalString(
+    pick(node, "dispatchModel", "dispatch_model", "DISPATCH_MODEL"),
+  );
+  const config = normalizeByteVector(pick(node, "config", "CONFIG"));
+  const nodeIdOffset = builder.createString(nodeId);
+  const pluginIdOffset = builder.createString(pluginId);
+  const methodIdOffset = methodId ? builder.createString(methodId) : 0;
+  const kindOffset = kind ? builder.createString(kind) : 0;
+  const dispatchModelOffset = dispatchModel
+    ? builder.createString(dispatchModel)
+    : 0;
+  const configOffset = addByteVector(
+    builder,
+    config,
+    PLGFlowNode.startConfigVector,
+  );
+  PLGFlowNode.startPLGFlowNode(builder);
+  PLGFlowNode.addNodeId(builder, nodeIdOffset);
+  PLGFlowNode.addPluginId(builder, pluginIdOffset);
+  if (methodIdOffset) PLGFlowNode.addMethodId(builder, methodIdOffset);
+  if (kindOffset) PLGFlowNode.addKind(builder, kindOffset);
+  if (dispatchModelOffset)
+    PLGFlowNode.addDispatchModel(builder, dispatchModelOffset);
+  if (configOffset) PLGFlowNode.addConfig(builder, configOffset);
+  const uiX = Number(pick(node, "uiX", "ui_x", "UI_X") ?? 0);
+  const uiY = Number(pick(node, "uiY", "ui_y", "UI_Y") ?? 0);
+  if (Number.isFinite(uiX) && uiX !== 0) PLGFlowNode.addUiX(builder, uiX);
+  if (Number.isFinite(uiY) && uiY !== 0) PLGFlowNode.addUiY(builder, uiY);
+  return PLGFlowNode.endPLGFlowNode(builder);
+}
+
+function flowNodeToObject(node) {
+  const config = node.configArray?.() ?? null;
+  return {
+    nodeId: node.NODE_ID(),
+    pluginId: node.PLUGIN_ID(),
+    methodId: node.METHOD_ID() || undefined,
+    kind: node.KIND() || undefined,
+    dispatchModel: node.DISPATCH_MODEL() || undefined,
+    ...(config && config.length > 0
+      ? { config: new Uint8Array(config) }
+      : {}),
+    uiX: node.UI_X(),
+    uiY: node.UI_Y(),
+  };
+}
+
+function addFlowEdge(builder, edge = {}) {
+  const fromNodeId = normalizeOptionalString(
+    pick(edge, "fromNodeId", "from_node_id", "FROM_NODE_ID"),
+  );
+  const fromPortId = normalizeOptionalString(
+    pick(edge, "fromPortId", "from_port_id", "FROM_PORT_ID"),
+  );
+  const toNodeId = normalizeOptionalString(
+    pick(edge, "toNodeId", "to_node_id", "TO_NODE_ID"),
+  );
+  const toPortId = normalizeOptionalString(
+    pick(edge, "toPortId", "to_port_id", "TO_PORT_ID"),
+  );
+  if (!fromNodeId || !fromPortId || !toNodeId || !toPortId) {
+    const missing = [
+      ["fromNodeId", fromNodeId],
+      ["fromPortId", fromPortId],
+      ["toNodeId", toNodeId],
+      ["toPortId", toPortId],
+    ]
+      .filter(([, value]) => !value)
+      .map(([field]) => field)
+      .join(", ");
+    throw new TypeError(`PLG flow edge requires ${missing}.`);
+  }
+  const edgeId = normalizeOptionalString(
+    pick(edge, "edgeId", "edge_id", "EDGE_ID"),
+  );
+  const edgeIdOffset = edgeId ? builder.createString(edgeId) : 0;
+  const fromNodeIdOffset = builder.createString(fromNodeId);
+  const fromPortIdOffset = builder.createString(fromPortId);
+  const toNodeIdOffset = builder.createString(toNodeId);
+  const toPortIdOffset = builder.createString(toPortId);
+  const contract = pick(edge, "contract", "CONTRACT");
+  if (!contract) {
+    throw new TypeError("PLG flow edge requires an exact contract.");
+  }
+  const canonicalType = pick(
+    contract,
+    "canonicalType",
+    "canonical_type",
+    "CANONICAL_TYPE",
+  );
+  const opaque =
+    pick(contract, "opaque", "OPAQUE") === true;
+  // $PLG 1.0.13: exactly one of CANONICAL_TYPE or OPAQUE = true. Neither is a
+  // forgotten type; both is a contradiction.
+  if (!canonicalType && !opaque) {
+    throw new TypeError(
+      "PLG flow edge contract requires canonicalType, or OPAQUE = true when the edge carries bytes with no SDS identity by design.",
+    );
+  }
+  if (canonicalType && opaque) {
+    throw new TypeError(
+      "PLG flow edge contract declares both canonicalType and OPAQUE = true; exactly one is permitted.",
+    );
+  }
+  const alignedType = pick(
+    contract,
+    "alignedType",
+    "aligned_type",
+    "ALIGNED_TYPE",
+  );
+  const alignedEligible =
+    pick(contract, "alignedEligible", "aligned_eligible", "ALIGNED_ELIGIBLE") === true;
+  if (opaque && (alignedEligible || alignedType)) {
+    throw new TypeError(
+      "PLG flow edge contract marked OPAQUE cannot be aligned-eligible or carry an alignedType: an opaque edge has no layout to prove.",
+    );
+  }
+  const canonicalTypeOffset = canonicalType
+    ? addFlatBufferTypeRef(builder, canonicalType)
+    : 0;
+  const alignedTypeOffset = alignedType
+    ? addFlatBufferTypeRef(builder, alignedType)
+    : 0;
+  PLGFlowEdgeContract.startPLGFlowEdgeContract(builder);
+  if (canonicalTypeOffset) {
+    PLGFlowEdgeContract.addCanonicalType(builder, canonicalTypeOffset);
+  }
+  if (alignedTypeOffset) {
+    PLGFlowEdgeContract.addAlignedType(builder, alignedTypeOffset);
+  }
+  if (opaque) {
+    PLGFlowEdgeContract.addOpaque(builder, true);
+  }
+  PLGFlowEdgeContract.addCanonicalFallbackAvailable(
+    builder,
+    pick(
+      contract,
+      "canonicalFallbackAvailable",
+      "canonical_fallback_available",
+      "CANONICAL_FALLBACK_AVAILABLE",
+    ) !== false,
+  );
+  PLGFlowEdgeContract.addAlignedEligible(
+    builder,
+    pick(contract, "alignedEligible", "aligned_eligible", "ALIGNED_ELIGIBLE") === true,
+  );
+  PLGFlowEdgeContract.addRoutePolicy(
+    builder,
+    resolveFlowEdgeRoutePolicy(
+      pick(contract, "routePolicy", "route_policy", "ROUTE_POLICY"),
+    ),
+  );
+  const contractOffset = PLGFlowEdgeContract.endPLGFlowEdgeContract(builder);
+
+  PLGFlowEdge.startPLGFlowEdge(builder);
+  if (edgeIdOffset) PLGFlowEdge.addEdgeId(builder, edgeIdOffset);
+  PLGFlowEdge.addFromNodeId(builder, fromNodeIdOffset);
+  PLGFlowEdge.addFromPortId(builder, fromPortIdOffset);
+  PLGFlowEdge.addToNodeId(builder, toNodeIdOffset);
+  PLGFlowEdge.addToPortId(builder, toPortIdOffset);
+  PLGFlowEdge.addContract(builder, contractOffset);
+  return PLGFlowEdge.endPLGFlowEdge(builder);
+}
+
+function flowEdgeToObject(edge) {
+  // The VERIFIER half of the $PLG 1.0.13 bargain: the schema left CONTRACT and
+  // CANONICAL_TYPE optional so pre-1.0.13 buffers stay readable, so a SIGNED
+  // edge without a coherent contract is rejected here rather than by flatc.
+  const contract = edge.CONTRACT?.();
+  if (!contract) {
+    throw new TypeError("Decoded PLG flow edge is missing its exact contract.");
+  }
+  const canonicalType = contract.CANONICAL_TYPE?.() ?? null;
+  const opaque = contract.OPAQUE?.() === true;
+  if (!canonicalType && !opaque) {
+    throw new TypeError(
+      "Decoded PLG flow edge contract carries neither CANONICAL_TYPE nor OPAQUE = true.",
+    );
+  }
+  if (canonicalType && opaque) {
+    throw new TypeError(
+      "Decoded PLG flow edge contract carries both CANONICAL_TYPE and OPAQUE = true; exactly one is permitted.",
+    );
+  }
+  const alignedEligible = contract.ALIGNED_ELIGIBLE();
+  if (opaque && alignedEligible) {
+    throw new TypeError(
+      "Decoded PLG flow edge contract is OPAQUE and ALIGNED_ELIGIBLE; an opaque edge has no layout to prove.",
+    );
+  }
+  const alignedType = contract.ALIGNED_TYPE?.();
+  return {
+    edgeId: edge.EDGE_ID() || undefined,
+    fromNodeId: edge.FROM_NODE_ID(),
+    fromPortId: edge.FROM_PORT_ID(),
+    toNodeId: edge.TO_NODE_ID(),
+    toPortId: edge.TO_PORT_ID(),
+    contract: {
+      canonicalType: canonicalType ? typeRefToObject(canonicalType) : null,
+      alignedType: alignedType ? typeRefToObject(alignedType) : null,
+      canonicalFallbackAvailable: contract.CANONICAL_FALLBACK_AVAILABLE(),
+      alignedEligible,
+      opaque,
+      routePolicy: flowEdgeRoutePolicyName(contract.ROUTE_POLICY()),
+    },
+  };
+}
+
+function addFlowTrigger(builder, trigger = {}) {
+  const triggerId = normalizeOptionalString(
+    pick(trigger, "triggerId", "trigger_id", "TRIGGER_ID"),
+  );
+  if (!triggerId) {
+    throw new TypeError("PLG flow trigger requires triggerId.");
+  }
+  const kind = normalizeOptionalString(pick(trigger, "kind", "KIND"));
+  const source = normalizeOptionalString(pick(trigger, "source", "SOURCE"));
+  const httpPath = normalizeOptionalString(
+    pick(trigger, "httpPath", "http_path", "HTTP_PATH"),
+  );
+  const triggerIdOffset = builder.createString(triggerId);
+  const kindOffset = kind ? builder.createString(kind) : 0;
+  const sourceOffset = source ? builder.createString(source) : 0;
+  const httpPathOffset = httpPath ? builder.createString(httpPath) : 0;
+  return PLGFlowTrigger.createPLGFlowTrigger(
+    builder,
+    triggerIdOffset,
+    kindOffset,
+    sourceOffset,
+    toBigInt(
+      pick(
+        trigger,
+        "defaultIntervalMs",
+        "default_interval_ms",
+        "DEFAULT_INTERVAL_MS",
+      ),
+    ),
+    httpPathOffset,
+  );
+}
+
+function flowTriggerToObject(trigger) {
+  return {
+    triggerId: trigger.TRIGGER_ID(),
+    kind: trigger.KIND() || undefined,
+    source: trigger.SOURCE() || undefined,
+    defaultIntervalMs: trigger.DEFAULT_INTERVAL_MS(),
+    httpPath: trigger.HTTP_PATH() || undefined,
+  };
+}
+
+function addFlowTriggerBinding(builder, binding = {}) {
+  const triggerId = normalizeOptionalString(
+    pick(binding, "triggerId", "trigger_id", "TRIGGER_ID"),
+  );
+  const targetNodeId = normalizeOptionalString(
+    pick(binding, "targetNodeId", "target_node_id", "TARGET_NODE_ID"),
+  );
+  const targetPortId = normalizeOptionalString(
+    pick(binding, "targetPortId", "target_port_id", "TARGET_PORT_ID"),
+  );
+  if (!triggerId || !targetNodeId || !targetPortId) {
+    throw new TypeError(
+      "PLG flow trigger binding requires triggerId, targetNodeId, and targetPortId.",
+    );
+  }
+  return PLGFlowTriggerBinding.createPLGFlowTriggerBinding(
+    builder,
+    builder.createString(triggerId),
+    builder.createString(targetNodeId),
+    builder.createString(targetPortId),
+  );
+}
+
+function flowTriggerBindingToObject(binding) {
+  return {
+    triggerId: binding.TRIGGER_ID(),
+    targetNodeId: binding.TARGET_NODE_ID(),
+    targetPortId: binding.TARGET_PORT_ID(),
+  };
+}
+
 /**
  * Encode a PLG manifest object to a canonical `$PLG`-identified FlatBuffer.
  * Returns a Uint8Array over a fresh buffer.
@@ -488,9 +1491,9 @@ export function encodePlgManifest(manifest = {}) {
       ? builder.createString(keyId)
       : 0;
 
-  const allowedDomainsOffset = addStringVector(
+  const allowedXpubsOffset = addStringVector(
     builder,
-    pick(manifest, "allowedDomains", "allowed_domains", "ALLOWED_DOMAINS"),
+    pick(manifest, "allowedXpubs", "allowed_xpubs", "ALLOWED_XPUBS"),
   );
 
   const maxGrantTimeoutMs = toBigInt(
@@ -599,6 +1602,145 @@ export function encodePlgManifest(manifest = {}) {
     PLG.startSignatureVector,
   );
 
+  const invokeSurfaces = pick(
+    manifest,
+    "invokeSurfaces",
+    "invoke_surfaces",
+    "INVOKE_SURFACES",
+  );
+  const invokeSurfaceValues = Array.isArray(invokeSurfaces)
+    ? invokeSurfaces.map((entry) => resolveInvokeSurface(entry)).filter((entry) => entry !== null)
+    : [];
+  const invokeSurfacesOffset =
+    invokeSurfaceValues.length > 0
+      ? PLG.createInvokeSurfacesVector(builder, invokeSurfaceValues)
+      : 0;
+
+  const methods = pick(manifest, "methods", "METHODS");
+  const methodOffsets = Array.isArray(methods)
+    ? methods.map((method) => addMethodManifest(builder, method)).filter(Boolean)
+    : [];
+  const methodsOffset =
+    methodOffsets.length > 0 ? PLG.createMethodsVector(builder, methodOffsets) : 0;
+
+  const hostCapabilities = pick(
+    manifest,
+    "hostCapabilities",
+    "host_capabilities",
+    "HOST_CAPABILITIES",
+    "capabilities",
+    "CAPABILITIES",
+  );
+  const hostCapabilityOffsets = Array.isArray(hostCapabilities)
+    ? hostCapabilities.map((capability) => addHostCapability(builder, capability))
+    : [];
+  const hostCapabilitiesOffset =
+    hostCapabilityOffsets.length > 0
+      ? PLG.createHostCapabilitiesVector(builder, hostCapabilityOffsets)
+      : 0;
+
+  const timers = pick(manifest, "timers", "TIMERS");
+  const timerOffsets = Array.isArray(timers)
+    ? timers.map((timer) => addTimerSpec(builder, timer)).filter(Boolean)
+    : [];
+  const timersOffset =
+    timerOffsets.length > 0 ? PLG.createTimersVector(builder, timerOffsets) : 0;
+
+  const protocols = pick(manifest, "protocols", "PROTOCOLS");
+  const protocolOffsets = Array.isArray(protocols)
+    ? protocols.map((protocol) => addProtocolSpec(builder, protocol)).filter(Boolean)
+    : [];
+  const protocolsOffset =
+    protocolOffsets.length > 0
+      ? PLG.createProtocolsVector(builder, protocolOffsets)
+      : 0;
+
+  const schemasUsed = pick(
+    manifest,
+    "schemasUsed",
+    "schemas_used",
+    "SCHEMAS_USED",
+  );
+  const schemaUsedOffsets = Array.isArray(schemasUsed)
+    ? schemasUsed.map((schema) => addFlatBufferTypeRef(builder, schema))
+    : [];
+  const schemasUsedOffset =
+    schemaUsedOffsets.length > 0
+      ? PLG.createSchemasUsedVector(builder, schemaUsedOffsets)
+      : 0;
+
+  const buildArtifacts = pick(
+    manifest,
+    "buildArtifacts",
+    "build_artifacts",
+    "BUILD_ARTIFACTS",
+  );
+  const buildArtifactOffsets = Array.isArray(buildArtifacts)
+    ? buildArtifacts.map((artifact) => addBuildArtifact(builder, artifact)).filter(Boolean)
+    : [];
+  const buildArtifactsOffset =
+    buildArtifactOffsets.length > 0
+      ? PLG.createBuildArtifactsVector(builder, buildArtifactOffsets)
+      : 0;
+
+  const runtimeTargetsOffset = addStringVector(
+    builder,
+    pick(manifest, "runtimeTargets", "runtime_targets", "RUNTIME_TARGETS"),
+  );
+
+  const flowNodes = pick(manifest, "flowNodes", "flow_nodes", "FLOW_NODES");
+  const flowNodeOffsets = Array.isArray(flowNodes)
+    ? flowNodes.map((node) => addFlowNode(builder, node)).filter(Boolean)
+    : [];
+  const flowNodesOffset =
+    flowNodeOffsets.length > 0
+      ? PLG.createFlowNodesVector(builder, flowNodeOffsets)
+      : 0;
+
+  const flowEdges = pick(manifest, "flowEdges", "flow_edges", "FLOW_EDGES");
+  const flowEdgeOffsets = Array.isArray(flowEdges)
+    ? flowEdges.map((edge) => addFlowEdge(builder, edge)).filter(Boolean)
+    : [];
+  const flowEdgesOffset =
+    flowEdgeOffsets.length > 0
+      ? PLG.createFlowEdgesVector(builder, flowEdgeOffsets)
+      : 0;
+
+  const flowTriggers = pick(
+    manifest,
+    "flowTriggers",
+    "flow_triggers",
+    "FLOW_TRIGGERS",
+  );
+  const flowTriggerOffsets = Array.isArray(flowTriggers)
+    ? flowTriggers
+        .map((trigger) => addFlowTrigger(builder, trigger))
+        .filter(Boolean)
+    : [];
+  const flowTriggersOffset =
+    flowTriggerOffsets.length > 0
+      ? PLG.createFlowTriggersVector(builder, flowTriggerOffsets)
+      : 0;
+
+  const flowTriggerBindings = pick(
+    manifest,
+    "flowTriggerBindings",
+    "flow_trigger_bindings",
+    "FLOW_TRIGGER_BINDINGS",
+  );
+  const flowTriggerBindingOffsets = Array.isArray(flowTriggerBindings)
+    ? flowTriggerBindings
+        .map((binding) => addFlowTriggerBinding(builder, binding))
+        .filter(Boolean)
+    : [];
+  const flowTriggerBindingsOffset =
+    flowTriggerBindingOffsets.length > 0
+      ? PLG.createFlowTriggerBindingsVector(
+          builder,
+          flowTriggerBindingOffsets,
+        )
+      : 0;
+
   PLG.startPLG(builder);
   PLG.addPluginId(builder, pluginIdOffset);
   PLG.addName(builder, nameOffset);
@@ -637,8 +1779,8 @@ export function encodePlgManifest(manifest = {}) {
   PLG.addEncrypted(builder, encrypted);
   if (requiredScopeOffset) PLG.addRequiredScope(builder, requiredScopeOffset);
   if (keyIdOffset) PLG.addKeyId(builder, keyIdOffset);
-  if (allowedDomainsOffset)
-    PLG.addAllowedDomains(builder, allowedDomainsOffset);
+  if (allowedXpubsOffset)
+    PLG.addAllowedXpubs(builder, allowedXpubsOffset);
   if (maxGrantTimeoutMs !== 0n)
     PLG.addMaxGrantTimeoutMs(builder, maxGrantTimeoutMs);
   if (minPermissionsOffset)
@@ -657,6 +1799,20 @@ export function encodePlgManifest(manifest = {}) {
     PLG.addAcceptedPaymentMethods(builder, acceptedPaymentMethodsOffset);
   PLG.addListingStatus(builder, listingStatusValue);
   if (signatureOffset) PLG.addSignature(builder, signatureOffset);
+  if (invokeSurfacesOffset) PLG.addInvokeSurfaces(builder, invokeSurfacesOffset);
+  if (methodsOffset) PLG.addMethods(builder, methodsOffset);
+  if (hostCapabilitiesOffset)
+    PLG.addHostCapabilities(builder, hostCapabilitiesOffset);
+  if (timersOffset) PLG.addTimers(builder, timersOffset);
+  if (protocolsOffset) PLG.addProtocols(builder, protocolsOffset);
+  if (schemasUsedOffset) PLG.addSchemasUsed(builder, schemasUsedOffset);
+  if (buildArtifactsOffset) PLG.addBuildArtifacts(builder, buildArtifactsOffset);
+  if (runtimeTargetsOffset) PLG.addRuntimeTargets(builder, runtimeTargetsOffset);
+  if (flowNodesOffset) PLG.addFlowNodes(builder, flowNodesOffset);
+  if (flowEdgesOffset) PLG.addFlowEdges(builder, flowEdgesOffset);
+  if (flowTriggersOffset) PLG.addFlowTriggers(builder, flowTriggersOffset);
+  if (flowTriggerBindingsOffset)
+    PLG.addFlowTriggerBindings(builder, flowTriggerBindingsOffset);
   const rootOffset = PLG.endPLG(builder);
   PLG.finishPLGBuffer(builder, rootOffset);
   return builder.asUint8Array();
@@ -699,17 +1855,17 @@ export function decodePlgManifest(data) {
       ? root.entryFunctionsLength()
       : 0;
   for (let i = 0; i < entryLen; i++) {
-    const entry = root.entryFunctions(i);
+    const entry = root.ENTRY_FUNCTIONS(i);
     if (!entry) continue;
     entryFunctions.push({
-      name: entry.name(),
-      description: entry.description() || undefined,
+      name: entry.NAME(),
+      description: entry.DESCRIPTION() || undefined,
       inputSchemas: readStringVector(
         entry,
         "inputSchemasLength",
-        "inputSchemas",
+        "INPUT_SCHEMAS",
       ),
-      outputSchema: entry.outputSchema() || undefined,
+      outputSchema: entry.OUTPUT_SCHEMA() || undefined,
     });
   }
 
@@ -719,12 +1875,12 @@ export function decodePlgManifest(data) {
       ? root.capabilitiesLength()
       : 0;
   for (let i = 0; i < capLen; i++) {
-    const cap = root.capabilities(i);
+    const cap = root.CAPABILITIES(i);
     if (!cap) continue;
     capabilities.push({
-      name: cap.name() || undefined,
-      version: cap.version() || undefined,
-      required: !!cap.required(),
+      name: cap.NAME() || undefined,
+      version: cap.VERSION() || undefined,
+      required: !!cap.REQUIRED(),
     });
   }
 
@@ -734,80 +1890,165 @@ export function decodePlgManifest(data) {
       ? root.dependenciesLength()
       : 0;
   for (let i = 0; i < depLen; i++) {
-    const dep = root.dependencies(i);
+    const dep = root.DEPENDENCIES(i);
     if (!dep) continue;
     dependencies.push({
-      pluginId: dep.pluginId() || undefined,
-      minVersion: dep.minVersion() || undefined,
-      maxVersion: dep.maxVersion() || undefined,
+      pluginId: dep.PLUGIN_ID() || undefined,
+      minVersion: dep.MIN_VERSION() || undefined,
+      maxVersion: dep.MAX_VERSION() || undefined,
     });
   }
 
+  const invokeSurfaces = Array.from(
+    root.invokeSurfacesArray?.() ?? [],
+    (value) => invokeSurfaceName(value),
+  );
+  const methods = [];
+  for (let index = 0; index < (root.methodsLength?.() ?? 0); index += 1) {
+    const method = root.METHODS(index);
+    if (method) {
+      methods.push(methodManifestToObject(method));
+    }
+  }
+  const hostCapabilities = [];
+  for (let index = 0; index < (root.hostCapabilitiesLength?.() ?? 0); index += 1) {
+    const capability = root.HOST_CAPABILITIES(index);
+    if (capability) {
+      hostCapabilities.push(hostCapabilityToObject(capability));
+    }
+  }
+  const timers = [];
+  for (let index = 0; index < (root.timersLength?.() ?? 0); index += 1) {
+    const timer = root.TIMERS(index);
+    if (timer) {
+      timers.push(timerSpecToObject(timer));
+    }
+  }
+  const protocols = [];
+  for (let index = 0; index < (root.protocolsLength?.() ?? 0); index += 1) {
+    const protocol = root.PROTOCOLS(index);
+    if (protocol) {
+      protocols.push(protocolSpecToObject(protocol));
+    }
+  }
+  const schemasUsed = [];
+  for (let index = 0; index < (root.schemasUsedLength?.() ?? 0); index += 1) {
+    const schema = typeRefToObject(root.SCHEMAS_USED(index));
+    if (schema) {
+      schemasUsed.push(schema);
+    }
+  }
+  const buildArtifacts = [];
+  for (let index = 0; index < (root.buildArtifactsLength?.() ?? 0); index += 1) {
+    const artifact = root.BUILD_ARTIFACTS(index);
+    if (artifact) {
+      buildArtifacts.push(buildArtifactToObject(artifact));
+    }
+  }
+  const flowNodes = [];
+  for (let index = 0; index < (root.flowNodesLength?.() ?? 0); index += 1) {
+    const node = root.FLOW_NODES(index);
+    if (node) flowNodes.push(flowNodeToObject(node));
+  }
+  const flowEdges = [];
+  for (let index = 0; index < (root.flowEdgesLength?.() ?? 0); index += 1) {
+    const edge = root.FLOW_EDGES(index);
+    if (edge) flowEdges.push(flowEdgeToObject(edge));
+  }
+  const flowTriggers = [];
+  for (let index = 0; index < (root.flowTriggersLength?.() ?? 0); index += 1) {
+    const trigger = root.FLOW_TRIGGERS(index);
+    if (trigger) flowTriggers.push(flowTriggerToObject(trigger));
+  }
+  const flowTriggerBindings = [];
+  for (
+    let index = 0;
+    index < (root.flowTriggerBindingsLength?.() ?? 0);
+    index += 1
+  ) {
+    const binding = root.FLOW_TRIGGER_BINDINGS(index);
+    if (binding) {
+      flowTriggerBindings.push(flowTriggerBindingToObject(binding));
+    }
+  }
+
   return {
-    pluginId: root.pluginId(),
-    name: root.name(),
-    version: root.version(),
-    description: root.description() || undefined,
-    tagline: root.tagline() || undefined,
-    pluginType: root.pluginType(),
-    publisherName: root.publisherName() || undefined,
-    publisherHandle: root.publisherHandle() || undefined,
-    publisherUrl: root.publisherUrl() || undefined,
-    supportUrl: root.supportUrl() || undefined,
-    tags: readStringVector(root, "tagsLength", "tags"),
-    features: readStringVector(root, "featuresLength", "features"),
+    pluginId: root.PLUGIN_ID(),
+    name: root.NAME(),
+    version: root.VERSION(),
+    description: root.DESCRIPTION() || undefined,
+    tagline: root.TAGLINE() || undefined,
+    pluginType: root.PLUGIN_TYPE(),
+    publisherName: root.PUBLISHER_NAME() || undefined,
+    publisherHandle: root.PUBLISHER_HANDLE() || undefined,
+    publisherUrl: root.PUBLISHER_URL() || undefined,
+    supportUrl: root.SUPPORT_URL() || undefined,
+    tags: readStringVector(root, "tagsLength", "TAGS"),
+    features: readStringVector(root, "featuresLength", "FEATURES"),
     screenshotUrls: readStringVector(
       root,
       "screenshotUrlsLength",
-      "screenshotUrls",
+      "SCREENSHOT_URLS",
     ),
-    bannerUrl: root.bannerUrl() || undefined,
-    abiVersion: root.abiVersion(),
+    bannerUrl: root.BANNER_URL() || undefined,
+    abiVersion: root.ABI_VERSION(),
     wasmHash: root.wasmHashArray() ?? null,
-    wasmSize: root.wasmSize(),
-    wasmCid: root.wasmCid() || undefined,
+    wasmSize: root.WASM_SIZE(),
+    wasmCid: root.WASM_CID() || undefined,
     encryptedWasmHash: root.encryptedWasmHashArray() ?? null,
-    encryptedWasmSize: root.encryptedWasmSize(),
+    encryptedWasmSize: root.ENCRYPTED_WASM_SIZE(),
     entryFunctions,
     requiredSchemas: readStringVector(
       root,
       "requiredSchemasLength",
-      "requiredSchemas",
+      "REQUIRED_SCHEMAS",
     ),
     dependencies,
     capabilities,
-    providerPeerId: root.providerPeerId() || undefined,
-    providerEpmCid: root.providerEpmCid() || undefined,
-    encrypted: !!root.encrypted(),
-    requiredScope: root.requiredScope() || undefined,
-    keyId: root.keyId() || undefined,
-    allowedDomains: readStringVector(
+    providerPeerId: root.PROVIDER_PEER_ID() || undefined,
+    providerEpmCid: root.PROVIDER_EPM_CID() || undefined,
+    encrypted: !!root.ENCRYPTED(),
+    requiredScope: root.REQUIRED_SCOPE() || undefined,
+    keyId: root.KEY_ID() || undefined,
+    allowedXpubs: readStringVector(
       root,
-      "allowedDomainsLength",
-      "allowedDomains",
+      "allowedXpubsLength",
+      "ALLOWED_XPUBS",
     ),
-    maxGrantTimeoutMs: root.maxGrantTimeoutMs(),
+    maxGrantTimeoutMs: root.MAX_GRANT_TIMEOUT_MS(),
     minPermissions: readStringVector(
       root,
       "minPermissionsLength",
-      "minPermissions",
+      "MIN_PERMISSIONS",
     ),
-    createdAt: root.createdAt(),
-    updatedAt: root.updatedAt(),
-    documentationUrl: root.documentationUrl() || undefined,
-    changelogUrl: root.changelogUrl() || undefined,
-    iconUrl: root.iconUrl() || undefined,
-    license: root.license() || undefined,
-    paymentModel: root.paymentModel(),
-    priceUsdCents: root.priceUsdCents(),
-    subscriptionPeriodDays: root.subscriptionPeriodDays(),
+    createdAt: root.CREATED_AT(),
+    updatedAt: root.UPDATED_AT(),
+    documentationUrl: root.DOCUMENTATION_URL() || undefined,
+    changelogUrl: root.CHANGELOG_URL() || undefined,
+    iconUrl: root.ICON_URL() || undefined,
+    license: root.LICENSE() || undefined,
+    paymentModel: root.PAYMENT_MODEL(),
+    priceUsdCents: root.PRICE_USD_CENTS(),
+    subscriptionPeriodDays: root.SUBSCRIPTION_PERIOD_DAYS(),
     acceptedPaymentMethods: readStringVector(
       root,
       "acceptedPaymentMethodsLength",
-      "acceptedPaymentMethods",
+      "ACCEPTED_PAYMENT_METHODS",
     ),
-    listingStatus: root.listingStatus(),
+    listingStatus: root.LISTING_STATUS(),
     signature: root.signatureArray() ?? null,
+    invokeSurfaces,
+    methods,
+    hostCapabilities,
+    timers,
+    protocols,
+    schemasUsed,
+    buildArtifacts,
+    runtimeTargets: readStringVector(root, "runtimeTargetsLength", "RUNTIME_TARGETS"),
+    flowNodes,
+    flowEdges,
+    flowTriggers,
+    flowTriggerBindings,
   };
 }