space-data-module-sdk 0.2.0 → 0.2.6

package/src/manifest/codec.js

@@ -4,6 +4,7 @@ import {
   PluginManifest,
   PluginManifestT,
 } from "../generated/orbpro/manifest.js";
+import { normalizeInvokeSurfaceName } from "../invoke/codec.js";
 import { toUint8Array } from "../runtime/bufferLike.js";
 import { toEmbeddedPluginManifest } from "./normalize.js";
 
@@ -25,7 +26,15 @@ export function decodePluginManifest(data) {
   if (!PluginManifest.bufferHasIdentifier(bb)) {
     throw new Error("Plugin manifest buffer identifier mismatch.");
   }
-  return PluginManifest.getRootAsPluginManifest(bb).unpack();
+  const unpacked = PluginManifest.getRootAsPluginManifest(bb).unpack();
+  return {
+    ...unpacked,
+    invokeSurfaces: Array.isArray(unpacked.invokeSurfaces)
+      ? unpacked.invokeSurfaces
+          .map((value) => normalizeInvokeSurfaceName(value))
+          .filter(Boolean)
+      : [],
+  };
 }
 
 export function encodePluginManifest(manifest) {
@@ -37,4 +46,3 @@ export function encodePluginManifest(manifest) {
   PluginManifest.finishPluginManifestBuffer(builder, value.pack(builder));
   return builder.asUint8Array();
 }
-

package/src/manifest/index.js

@@ -1,9 +1,12 @@
 export * from "../generated/orbpro/manifest.js";
-export { FlatBufferTypeRefT } from "../generated/orbpro/stream/flat-buffer-type-ref.js";
+export { PayloadWireFormat } from "../generated/orbpro/stream/payload-wire-format.js";
+export {
+  FlatBufferTypeRefT,
+  FlatBufferTypeRefT as PayloadTypeRef,
+} from "../generated/orbpro/stream/flat-buffer-type-ref.js";
 export { decodePluginManifest, encodePluginManifest } from "./codec.js";
 export { toEmbeddedPluginManifest } from "./normalize.js";
 export {
   generateEmbeddedManifestSource,
   writeEmbeddedManifestArtifacts,
 } from "../embeddedManifest.js";
-

package/src/manifest/normalize.js

@@ -4,6 +4,7 @@ import {
   CapabilityKind,
   DrainPolicy as ManifestDrainPolicy,
   HostCapabilityT,
+  InvokeSurface,
   MethodManifestT,
   PluginFamily,
   PluginManifestT,
@@ -75,6 +76,11 @@ const capabilityKindByName = Object.freeze({
   render_hooks: CapabilityKind.RENDER_HOOKS,
 });
 
+const invokeSurfaceByName = Object.freeze({
+  direct: InvokeSurface.DIRECT,
+  command: InvokeSurface.COMMAND,
+});
+
 function normalizeSchemaHash(value) {
   if (!value) {
     return [];
@@ -93,6 +99,25 @@ function normalizeSchemaHash(value) {
   return bytes;
 }
 
+function normalizePayloadWireFormat(value) {
+  if (value === 1) {
+    return "aligned-binary";
+  }
+  const normalized = String(value ?? "")
+    .trim()
+    .toLowerCase()
+    .replace(/_/g, "-");
+  return normalized === "aligned-binary" ? "aligned-binary" : "flatbuffer";
+}
+
+function normalizeUnsignedInteger(value, fallback = 0) {
+  const normalized = Number(value ?? fallback);
+  if (!Number.isFinite(normalized)) {
+    return fallback;
+  }
+  return Math.max(0, Math.trunc(normalized));
+}
+
 function normalizePluginFamily(value) {
   if (typeof value === "number") {
     return value;
@@ -125,6 +150,33 @@ function normalizeCapabilityKind(value) {
   return capabilityKindByName[normalized] ?? null;
 }
 
+function normalizeInvokeSurface(value) {
+  if (typeof value === "number") {
+    return value;
+  }
+  const normalized = String(value ?? "")
+    .trim()
+    .toLowerCase();
+  return invokeSurfaceByName[normalized] ?? null;
+}
+
+function normalizeInvokeSurfaces(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const seen = new Set();
+  const normalized = [];
+  for (const entry of value) {
+    const surface = normalizeInvokeSurface(entry);
+    if (surface === null || seen.has(surface)) {
+      continue;
+    }
+    seen.add(surface);
+    normalized.push(surface);
+  }
+  return normalized;
+}
+
 function toFlatBufferTypeRefT(value = {}) {
   if (value instanceof FlatBufferTypeRefT) {
     return value;
@@ -134,6 +186,11 @@ function toFlatBufferTypeRefT(value = {}) {
     value.fileIdentifier ?? null,
     normalizeSchemaHash(value.schemaHash),
     value.acceptsAnyFlatbuffer === true,
+    normalizePayloadWireFormat(value.wireFormat),
+    value.rootTypeName ?? null,
+    normalizeUnsignedInteger(value.fixedStringLength),
+    normalizeUnsignedInteger(value.byteLength),
+    normalizeUnsignedInteger(value.requiredAlignment),
   );
 }
 
@@ -300,6 +357,7 @@ export function toEmbeddedPluginManifest(input = {}) {
         ? input.buildArtifacts.map((entry) => toBuildArtifactT(entry))
         : [],
       Number(input.abiVersion ?? 1),
+      normalizeInvokeSurfaces(input.invokeSurfaces),
     ),
     warnings,
   };

package/src/runtime/constants.js

@@ -43,9 +43,21 @@ export const RuntimeTarget = Object.freeze({
   EDGE: "edge",
 });
 
+export const InvokeSurface = Object.freeze({
+  DIRECT: "direct",
+  COMMAND: "command",
+});
+
 export const DefaultManifestExports = Object.freeze({
   pluginBytesSymbol: "plugin_get_manifest_flatbuffer",
   pluginSizeSymbol: "plugin_get_manifest_flatbuffer_size",
   flowBytesSymbol: "flow_get_manifest_flatbuffer",
   flowSizeSymbol: "flow_get_manifest_flatbuffer_size",
 });
+
+export const DefaultInvokeExports = Object.freeze({
+  invokeSymbol: "plugin_invoke_stream",
+  allocSymbol: "plugin_alloc",
+  freeSymbol: "plugin_free",
+  commandSymbol: "_start",
+});

package/src/runtime/index.d.ts

@@ -0,0 +1,13 @@
+export {
+  DefaultInvokeExports,
+  DefaultManifestExports,
+  DrainPolicy,
+  ExternalInterfaceDirection,
+  ExternalInterfaceKind,
+  InvokeSurface,
+  RuntimeTarget,
+} from "../index.js";
+
+export function isArrayBufferLike(value: unknown): boolean;
+export function hasByteAddressableBuffer(value: unknown): boolean;
+export function toUint8Array(value: unknown): Uint8Array | null;

package/src/runtime/index.js

@@ -0,0 +1,2 @@
+export * from "./bufferLike.js";
+export * from "./constants.js";