space-data-module-sdk 0.7.0 → 0.8.1

package/src/bundle/wasm.js

@@ -1,5 +1,11 @@
 import { canonicalBytes } from "../auth/canonicalize.js";
-import { decodePluginManifest, encodePluginManifest } from "../manifest/index.js";
+import {
+  decodePluginManifest,
+  decodePlgManifest,
+  encodePlgManifest,
+  isPlgManifestBuffer,
+  legacyManifestToPlg,
+} from "../manifest/index.js";
 import { toUint8Array } from "../runtime/bufferLike.js";
 import { sha256Bytes } from "../utils/crypto.js";
 import { bytesToHex } from "../utils/encoding.js";
@@ -7,10 +13,10 @@ import { createDeploymentPlanBundleEntry } from "../deployment/index.js";
 import {
   DEFAULT_MANIFEST_EXPORT_SYMBOL,
   DEFAULT_MANIFEST_SIZE_SYMBOL,
-  SDS_BUNDLE_SECTION_NAME,
   SDS_CUSTOM_SECTION_PREFIX,
   SDS_DEPLOYMENT_ENTRY_ID,
   SDS_DEPLOYMENT_SECTION_NAME,
+  SDS_MBL_CONTAINER_NAME,
 } from "./constants.js";
 import {
   decodeModuleBundle,
@@ -20,7 +26,11 @@ import {
   moduleBundleEncodingToName,
   moduleBundleRoleToName,
 } from "./codec.js";
-import { extractPublicationRecordCollection } from "../transport/records.js";
+import {
+  appendPublicationRecordCollection,
+  encodePublicationRecordCollection,
+  extractPublicationRecordCollection,
+} from "../transport/records.js";
 
 const textDecoder = new TextDecoder();
 const textEncoder = new TextEncoder();
@@ -222,20 +232,36 @@ function normalizeJsonPayload(value) {
   return new Uint8Array(canonicalBytes(value));
 }
 
+function encodeBundleManifest(manifest) {
+  return encodePlgManifest(legacyManifestToPlg(manifest));
+}
+
+function decodeBundleManifest(payloadBytes) {
+  return isPlgManifestBuffer(payloadBytes)
+    ? decodePlgManifest(payloadBytes)
+    : decodePluginManifest(payloadBytes);
+}
+
 function normalizeManifestEntry(manifest, manifestBytes) {
   if (!manifest && !manifestBytes) {
     return null;
   }
-  const payload = manifestBytes ?? encodePluginManifest(manifest);
+  const payload = manifestBytes ?? encodeBundleManifest(manifest);
+  const isPlg = isPlgManifestBuffer(payload);
   return {
     entryId: "manifest",
     role: "manifest",
     sectionName: "sds.manifest",
     payloadEncoding: "flatbuffer",
-    typeRef: {
-      schemaName: "PluginManifest.fbs",
-      fileIdentifier: "PMAN",
-    },
+    typeRef: isPlg
+      ? {
+          schemaName: "PLG.fbs",
+          fileIdentifier: "$PLG",
+        }
+      : {
+          schemaName: "PluginManifest.fbs",
+          fileIdentifier: "PMAN",
+        },
     payload,
     description: "Canonical plugin manifest.",
   };
@@ -326,7 +352,7 @@ function buildParsedEntries(bundle) {
       parsedEntry.payloadEncodingName === "flatbuffer"
     ) {
       try {
-        parsedEntry.decodedManifest = decodePluginManifest(payloadBytes);
+        parsedEntry.decodedManifest = decodeBundleManifest(payloadBytes);
       } catch {
         parsedEntry.decodedManifest = null;
       }
@@ -376,7 +402,7 @@ export async function createSingleFileBundle(options = {}) {
     options.manifestBytes !== undefined
       ? normalizeBytes(options.manifestBytes, "manifestBytes")
       : options.manifest
-        ? encodePluginManifest(options.manifest)
+        ? encodeBundleManifest(options.manifest)
         : null;
   const manifestEntry = normalizeManifestEntry(options.manifest, manifestBytes);
   const rawEntries = [
@@ -392,7 +418,7 @@ export async function createSingleFileBundle(options = {}) {
     version: 1,
     strippedCustomSectionPrefix:
       options.customSectionPrefix ?? SDS_CUSTOM_SECTION_PREFIX,
-    bundleSectionName: options.bundleSectionName ?? SDS_BUNDLE_SECTION_NAME,
+    bundleSectionName: options.bundleSectionName ?? SDS_MBL_CONTAINER_NAME,
     hashAlgorithm: "sha256",
   };
   const canonical = await computeCanonicalModuleHash(wasmBytes, {
@@ -415,10 +441,14 @@ export async function createSingleFileBundle(options = {}) {
   const baseWasmBytes = stripWasmCustomSections(wasmBytes, (section) =>
     section.name.startsWith(canonicalization.strippedCustomSectionPrefix),
   );
-  const outputWasmBytes = appendWasmCustomSection(
+  const outputWasmBytes = appendPublicationRecordCollection(
     baseWasmBytes,
-    canonicalization.bundleSectionName,
-    bundleBytes,
+    encodePublicationRecordCollection({
+      version: protectedArtifact?.version,
+      mbl: bundle,
+      enc: protectedArtifact?.enc,
+      pnm: protectedArtifact?.pnm,
+    }),
   );
   return {
     bundle,
@@ -434,25 +464,16 @@ export async function createSingleFileBundle(options = {}) {
 
 export async function parseSingleFileBundle(bytes, options = {}) {
   const protectedArtifact = extractPublicationRecordCollection(bytes);
+  if (!protectedArtifact?.mbl) {
+    throw new Error("Missing required REC trailer containing an MBL record.");
+  }
   const wasmBytes = normalizeBytes(
-    protectedArtifact?.payloadBytes ?? bytes,
+    protectedArtifact.payloadBytes,
     "wasm bytes",
   );
   const customSections = listWasmCustomSections(wasmBytes);
-  const bundleSectionName = String(
-    options.bundleSectionName ?? SDS_BUNDLE_SECTION_NAME,
-  );
-  const bundleSections = customSections.filter(
-    (section) => section.name === bundleSectionName,
-  );
-  if (bundleSections.length === 0) {
-    throw new Error(`Missing required custom section "${bundleSectionName}".`);
-  }
-  if (bundleSections.length > 1) {
-    throw new Error(`Expected one "${bundleSectionName}" section, found ${bundleSections.length}.`);
-  }
-  const bundleBytes = bundleSections[0].dataBytes;
-  const bundle = decodeModuleBundle(bundleBytes);
+  const bundle = protectedArtifact.mbl;
+  const bundleBytes = protectedArtifact.mblBytes ?? encodeModuleBundle(bundle);
   const prefix =
     bundle.canonicalization?.strippedCustomSectionPrefix ??
     SDS_CUSTOM_SECTION_PREFIX;
@@ -464,7 +485,7 @@ export async function parseSingleFileBundle(bytes, options = {}) {
   let manifest = null;
   if (manifestEntry) {
     try {
-      manifest = decodePluginManifest(new Uint8Array(manifestEntry.payload ?? []));
+      manifest = decodeBundleManifest(new Uint8Array(manifestEntry.payload ?? []));
     } catch {
       manifest = null;
     }
@@ -477,8 +498,8 @@ export async function parseSingleFileBundle(bytes, options = {}) {
     ) ?? null;
   return {
     wasmBytes,
-    protectedArtifactBytes: protectedArtifact?.protectedBytes ?? null,
-    publicationRecords: protectedArtifact ?? null,
+    protectedArtifactBytes: protectedArtifact.protectedBytes,
+    publicationRecords: protectedArtifact,
     bundleBytes,
     bundle,
     entries: parsedEntries,

package/src/compiler/compileModule.js

@@ -894,6 +894,7 @@ export async function protectModuleArtifact(options = {}) {
   };
 
   let singleFileBundle = null;
+  let singleFileBundleRecords = null;
   if (options.singleFileBundle === true) {
     const additionalEntries = [
       ...(Array.isArray(options.bundleEntries) ? options.bundleEntries : []),
@@ -905,9 +906,13 @@ export async function protectModuleArtifact(options = {}) {
       authorization: signedAuthorization,
       entries: additionalEntries,
     });
+    singleFileBundleRecords = extractPublicationRecordCollection(
+      singleFileBundle.wasmBytes,
+    );
   }
 
-  const bundleBytes = singleFileBundle?.wasmBytes ?? wasmBytes;
+  const bundleBytes = singleFileBundleRecords?.payloadBytes ?? wasmBytes;
+  const bundleRecord = singleFileBundleRecords?.mbl ?? null;
   let publicationNotice = null;
   let publicationRecordsBytes = null;
   let protectedArtifactBytes = null;
@@ -931,6 +936,7 @@ export async function protectModuleArtifact(options = {}) {
       signer,
     });
     publicationRecordsBytes = encodePublicationRecordCollection({
+      mbl: bundleRecord,
       enc: parsedEncryptedBase.enc,
       pnm: publicationNotice,
     });
@@ -943,6 +949,7 @@ export async function protectModuleArtifact(options = {}) {
       parsedProtectedBlob: {
         payloadBytes: parsedEncryptedBase.payloadBytes,
         recordCollectionBytes: publicationRecordsBytes,
+        mbl: bundleRecord,
         enc: parsedEncryptedBase.enc,
         pnm: publicationNotice,
       },
@@ -959,6 +966,7 @@ export async function protectModuleArtifact(options = {}) {
       signer,
     });
     publicationRecordsBytes = encodePublicationRecordCollection({
+      mbl: bundleRecord,
       pnm: publicationNotice,
     });
     protectedArtifactBytes = appendPublicationRecordCollection(

package/src/compliance/index.js

@@ -2,8 +2,10 @@ import {
   findManifestFiles,
   getWasmExportNames,
   getWasmExportNamesFromFile,
+  hasLegacyPmanManifest,
   loadManifestFromFile,
   loadComplianceConfig,
+  locateEmbeddedPlgManifest,
   resolveManifestFiles,
   validatePluginArtifact,
   validatePluginManifest,
@@ -49,8 +51,10 @@ export {
   findManifestFiles,
   getWasmExportNames,
   getWasmExportNamesFromFile,
+  hasLegacyPmanManifest,
   loadManifestFromFile,
   loadComplianceConfig,
+  locateEmbeddedPlgManifest,
   RecommendedCapabilityIds,
   StandaloneWasiCapabilityIds,
   resolveManifestFiles,

package/src/compliance/pluginCompliance.js

@@ -16,6 +16,11 @@ import {
   RecommendedCapabilityIds,
   StandaloneWasiCapabilityIds,
 } from "../capabilities.js";
+import {
+  PLG_FILE_IDENTIFIER,
+  decodePlgManifest,
+  isPlgManifestBuffer,
+} from "../manifest/plgCodec.js";
 
 const RecommendedCapabilitySet = new Set(RecommendedCapabilityIds);
 const StandaloneWasiCapabilitySet = new Set(StandaloneWasiCapabilityIds);
@@ -1356,11 +1361,143 @@ export async function getWasmExportNamesFromFile(wasmPath) {
   return getWasmExportNames(wasmBytes);
 }
 
+const PLG_IDENTIFIER_BYTES = Uint8Array.from(
+  Array.from(PLG_FILE_IDENTIFIER, (ch) => ch.charCodeAt(0)),
+);
+const LEGACY_PMAN_IDENTIFIER_BYTES = Uint8Array.from([0x50, 0x4d, 0x41, 0x4e]);
+
+function indexOfBytes(haystack, needle, startIndex = 0) {
+  if (!haystack || needle.length === 0 || haystack.length < needle.length) {
+    return -1;
+  }
+  for (let i = startIndex; i <= haystack.length - needle.length; i += 1) {
+    let matched = true;
+    for (let j = 0; j < needle.length; j += 1) {
+      if (haystack[i + j] !== needle[j]) {
+        matched = false;
+        break;
+      }
+    }
+    if (matched) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+/**
+ * Scan wasm bytes for the canonical `$PLG` FlatBuffer identifier and, when
+ * found, return both the raw offset and the smallest aligned candidate buffer
+ * that a downstream decoder can try to parse. The wasm `data` sections embed
+ * the manifest bytes verbatim; FlatBuffer headers are `<root_offset:u32><$PLG>`
+ * so we walk backwards one 4-byte word and hand the caller a slice starting
+ * there.
+ */
+export function locateEmbeddedPlgManifest(wasmBytes) {
+  const bytes = wasmBytes instanceof Uint8Array
+    ? wasmBytes
+    : new Uint8Array(wasmBytes);
+  const identifierOffset = indexOfBytes(bytes, PLG_IDENTIFIER_BYTES);
+  if (identifierOffset < 4) {
+    return null;
+  }
+  const start = identifierOffset - 4;
+  // Upper bound on the manifest size — grab up to 64KB and let the caller
+  // decide how much to trim. FlatBuffer decoders only read what they need.
+  const end = Math.min(bytes.length, start + 65536);
+  const candidate = bytes.subarray(start, end);
+  if (!isPlgManifestBuffer(candidate)) {
+    return null;
+  }
+  return { start, identifierOffset, bytes: candidate };
+}
+
+export function hasLegacyPmanManifest(wasmBytes) {
+  const bytes = wasmBytes instanceof Uint8Array
+    ? wasmBytes
+    : new Uint8Array(wasmBytes);
+  return indexOfBytes(bytes, LEGACY_PMAN_IDENTIFIER_BYTES) !== -1;
+}
+
+function validateEmbeddedManifestBytes({
+  wasmBytes,
+  manifest,
+  issues,
+  sourceLabel,
+}) {
+  if (hasLegacyPmanManifest(wasmBytes)) {
+    pushIssue(
+      issues,
+      "error",
+      "legacy-pman-manifest-embedded",
+      "Plugin artifact embeds legacy PMAN manifest bytes — rebuild with the PLG codec.",
+      sourceLabel,
+    );
+  }
+
+  const located = locateEmbeddedPlgManifest(wasmBytes);
+  if (!located) {
+    pushIssue(
+      issues,
+      "error",
+      "missing-plg-manifest-bytes",
+      `Plugin artifact does not embed a canonical \"${PLG_FILE_IDENTIFIER}\" manifest buffer.`,
+      sourceLabel,
+    );
+    return;
+  }
+
+  let decoded;
+  try {
+    decoded = decodePlgManifest(located.bytes);
+  } catch (error) {
+    pushIssue(
+      issues,
+      "error",
+      "plg-manifest-decode-failed",
+      `Failed to decode embedded PLG manifest: ${error?.message ?? error}`,
+      sourceLabel,
+    );
+    return;
+  }
+
+  const sourcePluginId = manifest?.pluginId ?? manifest?.plugin_id ?? null;
+  if (
+    isNonEmptyString(sourcePluginId) &&
+    isNonEmptyString(decoded?.pluginId) &&
+    sourcePluginId !== decoded.pluginId
+  ) {
+    pushIssue(
+      issues,
+      "error",
+      "plg-manifest-plugin-id-mismatch",
+      `Embedded PLG manifest pluginId \"${decoded.pluginId}\" does not match source manifest pluginId \"${sourcePluginId}\".`,
+      sourceLabel,
+    );
+  }
+
+  const sourceVersion = manifest?.version ?? null;
+  if (
+    isNonEmptyString(sourceVersion) &&
+    isNonEmptyString(decoded?.version) &&
+    sourceVersion !== decoded.version
+  ) {
+    pushIssue(
+      issues,
+      "warning",
+      "plg-manifest-version-mismatch",
+      `Embedded PLG manifest version \"${decoded.version}\" does not match source manifest version \"${sourceVersion}\".`,
+      sourceLabel,
+    );
+  }
+}
+
 export async function validatePluginArtifact(options) {
   const {
     manifest,
     manifestPath = null,
     wasmPath = null,
+    wasmBytes: inputWasmBytes = null,
     exportNames = null,
     sourceName = manifestPath ?? "manifest",
   } = options;
@@ -1368,15 +1505,26 @@ export async function validatePluginArtifact(options) {
   const issues = [...report.issues];
   let resolvedExportNames = [];
   let checkedArtifact = false;
+  let loadedWasmBytes = null;
   const declaredInvokeSurfaces = Array.isArray(manifest?.invokeSurfaces)
     ? manifest.invokeSurfaces.filter((surface) => InvokeSurfaceSet.has(surface))
     : [];
 
-  if (Array.isArray(exportNames)) {
+  if (inputWasmBytes) {
+    loadedWasmBytes =
+      inputWasmBytes instanceof Uint8Array
+        ? inputWasmBytes
+        : new Uint8Array(inputWasmBytes);
+    resolvedExportNames = Array.isArray(exportNames)
+      ? [...exportNames]
+      : getWasmExportNames(loadedWasmBytes);
+    checkedArtifact = true;
+  } else if (Array.isArray(exportNames)) {
     resolvedExportNames = [...exportNames];
     checkedArtifact = true;
   } else if (isNonEmptyString(wasmPath)) {
-    resolvedExportNames = await getWasmExportNamesFromFile(wasmPath);
+    loadedWasmBytes = new Uint8Array(await readFile(wasmPath));
+    resolvedExportNames = getWasmExportNames(loadedWasmBytes);
     checkedArtifact = true;
   }
 
@@ -1424,6 +1572,14 @@ export async function validatePluginArtifact(options) {
         wasmPath ?? sourceName,
       );
     }
+    if (loadedWasmBytes) {
+      validateEmbeddedManifestBytes({
+        wasmBytes: loadedWasmBytes,
+        manifest,
+        issues,
+        sourceLabel: wasmPath ?? sourceName,
+      });
+    }
   } else {
     pushIssue(
       issues,

package/src/embeddedManifest.js

@@ -2,8 +2,19 @@ import fs from "node:fs";
 import path from "node:path";
 
 import { encodePluginManifest } from "./manifest/index.js";
-
-function toManifestBytes(manifest) {
+import { legacyManifestToPlg } from "./manifest/legacyToPlg.js";
+import { encodePlgManifest } from "./manifest/plgCodec.js";
+
+/**
+ * Convert a manifest input to the raw FlatBuffer bytes that will be
+ * embedded in the plugin artifact.
+ *
+ * The embedded manifest is the canonical spacedatastandards.org PLG
+ * schema (`$PLG` file_identifier) by default. Pass `format: "pman"` to
+ * emit the internal PluginManifest schema instead (legacy path, retained
+ * for tests that still compare against PMAN bytes).
+ */
+function toManifestBytes(manifest, format = "plg") {
   if (manifest instanceof Uint8Array) {
     return manifest;
   }
@@ -17,7 +28,13 @@ function toManifestBytes(manifest) {
       manifest.byteLength,
     );
   }
-  return encodePluginManifest(manifest);
+  if (format === "pman") {
+    return encodePluginManifest(manifest);
+  }
+  // Default: PLG. Accept both PLG-shaped and legacy PluginManifest-shaped
+  // inputs; the converter is a no-op for PLG-native shapes.
+  const plgShape = legacyManifestToPlg(manifest);
+  return encodePlgManifest(plgShape);
 }
 
 function renderByteRows(bytes) {
@@ -34,7 +51,10 @@ function renderByteRows(bytes) {
 }
 
 export function generateEmbeddedManifestSource(options = {}) {
-  const manifestBytes = toManifestBytes(options.manifest);
+  const manifestBytes = toManifestBytes(
+    options.manifest,
+    options.format ?? "plg",
+  );
   if (manifestBytes.length === 0) {
     throw new Error("generateEmbeddedManifestSource requires manifest bytes.");
   }
@@ -91,7 +111,7 @@ export function writeEmbeddedManifestArtifacts(options = {}) {
     throw new Error("writeEmbeddedManifestArtifacts requires outputDir.");
   }
 
-  const manifestBytes = toManifestBytes(manifest);
+  const manifestBytes = toManifestBytes(manifest, options.format ?? "plg");
   fs.mkdirSync(outputDir, { recursive: true });
 
   const binaryPath = path.join(outputDir, binaryFileName);

package/src/generated/orbpro/invoke/plugin-invoke-request.js

@@ -1,6 +1,6 @@
 // automatically generated by the FlatBuffers compiler, do not modify
 /* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
-import * as flatbuffers from "flatbuffers/mjs/flatbuffers.js";
+import * as flatbuffers from "../../../vendor/flatbuffers/flatbuffers.js";
 import { TypedArenaBuffer } from '../../orbpro/stream/typed-arena-buffer.js';
 /**
  * Canonical invoke envelope consumed by direct ABI and command-mode execution.
@@ -128,4 +128,4 @@ export class PluginInvokeRequestT {
         return PluginInvokeRequest.createPluginInvokeRequest(builder, methodId, inputFrames, payloadArena);
     }
 }
-//# sourceMappingURL=plugin-invoke-request.js.map
+//# sourceMappingURL=plugin-invoke-request.js.map

package/src/generated/orbpro/invoke/plugin-invoke-response.js

@@ -1,6 +1,6 @@
 // automatically generated by the FlatBuffers compiler, do not modify
 /* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
-import * as flatbuffers from "flatbuffers/mjs/flatbuffers.js";
+import * as flatbuffers from "../../../vendor/flatbuffers/flatbuffers.js";
 import { TypedArenaBuffer } from '../../orbpro/stream/typed-arena-buffer.js';
 /**
  * Canonical invoke result emitted by direct ABI and command-mode execution.
@@ -181,4 +181,4 @@ export class PluginInvokeResponseT {
         return PluginInvokeResponse.createPluginInvokeResponse(builder, this.statusCode, this.yielded, this.backlogRemaining, outputFrames, payloadArena, errorCode, errorMessage);
     }
 }
-//# sourceMappingURL=plugin-invoke-response.js.map
+//# sourceMappingURL=plugin-invoke-response.js.map

package/src/generated/orbpro/stream/flat-buffer-type-ref.js

@@ -1,6 +1,6 @@
 // automatically generated by the FlatBuffers compiler, do not modify
 /* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
-import * as flatbuffers from "flatbuffers/mjs/flatbuffers.js";
+import * as flatbuffers from "../../../vendor/flatbuffers/flatbuffers.js";
 import { PayloadWireFormat } from "../../orbpro/stream/payload-wire-format.js";
 function normalizePayloadWireFormat(value) {
     if (value === PayloadWireFormat.ALIGNED_BINARY) {
@@ -202,4 +202,4 @@ export class FlatBufferTypeRefT {
         return FlatBufferTypeRef.createFlatBufferTypeRef(builder, schemaName, fileIdentifier, schemaHash, this.acceptsAnyFlatbuffer, normalizePayloadWireFormat(this.wireFormat), rootTypeName, this.fixedStringLength, this.byteLength, this.requiredAlignment);
     }
 }
-//# sourceMappingURL=flat-buffer-type-ref.js.map
+//# sourceMappingURL=flat-buffer-type-ref.js.map

package/src/generated/orbpro/stream/typed-arena-buffer.js

@@ -1,6 +1,6 @@
 // automatically generated by the FlatBuffers compiler, do not modify
 /* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
-import * as flatbuffers from "flatbuffers/mjs/flatbuffers.js";
+import * as flatbuffers from "../../../vendor/flatbuffers/flatbuffers.js";
 import { BufferMutability } from "../../orbpro/stream/buffer-mutability.js";
 import { BufferOwnership } from "../../orbpro/stream/buffer-ownership.js";
 import { FlatBufferTypeRef, } from "../../orbpro/stream/flat-buffer-type-ref.js";
@@ -230,4 +230,4 @@ export class TypedArenaBufferT {
         return TypedArenaBuffer.createTypedArenaBuffer(builder, typeRef, portId, this.alignment, this.offset, this.size, this.ownership, this.generation, this.mutability, this.traceId, this.streamId, this.sequence, this.endOfStream);
     }
 }
-//# sourceMappingURL=typed-arena-buffer.js.map
+//# sourceMappingURL=typed-arena-buffer.js.map

package/src/generated/spacedatastandards/plg/entry-function.js

@@ -0,0 +1,86 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import * as flatbuffers from "flatbuffers";
+class EntryFunction {
+  constructor() {
+    __publicField(this, "bb", null);
+    __publicField(this, "bb_pos", 0);
+  }
+  __init(i, bb) {
+    this.bb_pos = i;
+    this.bb = bb;
+    return this;
+  }
+  static getRootAsEntryFunction(bb, obj) {
+    return (obj || new EntryFunction()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+  }
+  static getSizePrefixedRootAsEntryFunction(bb, obj) {
+    bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+    return (obj || new EntryFunction()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+  }
+  name(optionalEncoding) {
+    const offset = this.bb.__offset(this.bb_pos, 4);
+    return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+  }
+  description(optionalEncoding) {
+    const offset = this.bb.__offset(this.bb_pos, 6);
+    return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+  }
+  inputSchemas(index, optionalEncoding) {
+    const offset = this.bb.__offset(this.bb_pos, 8);
+    return offset ? this.bb.__string(this.bb.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null;
+  }
+  inputSchemasLength() {
+    const offset = this.bb.__offset(this.bb_pos, 8);
+    return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+  }
+  outputSchema(optionalEncoding) {
+    const offset = this.bb.__offset(this.bb_pos, 10);
+    return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+  }
+  static startEntryFunction(builder) {
+    builder.startObject(4);
+  }
+  static addName(builder, nameOffset) {
+    builder.addFieldOffset(0, nameOffset, 0);
+  }
+  static addDescription(builder, descriptionOffset) {
+    builder.addFieldOffset(1, descriptionOffset, 0);
+  }
+  static addInputSchemas(builder, inputSchemasOffset) {
+    builder.addFieldOffset(2, inputSchemasOffset, 0);
+  }
+  static createInputSchemasVector(builder, data) {
+    builder.startVector(4, data.length, 4);
+    for (let i = data.length - 1; i >= 0; i--) {
+      builder.addOffset(data[i]);
+    }
+    return builder.endVector();
+  }
+  static startInputSchemasVector(builder, numElems) {
+    builder.startVector(4, numElems, 4);
+  }
+  static addOutputSchema(builder, outputSchemaOffset) {
+    builder.addFieldOffset(3, outputSchemaOffset, 0);
+  }
+  static endEntryFunction(builder) {
+    const offset = builder.endObject();
+    builder.requiredField(offset, 4);
+    return offset;
+  }
+  static createEntryFunction(builder, nameOffset, descriptionOffset, inputSchemasOffset, outputSchemaOffset) {
+    EntryFunction.startEntryFunction(builder);
+    EntryFunction.addName(builder, nameOffset);
+    EntryFunction.addDescription(builder, descriptionOffset);
+    EntryFunction.addInputSchemas(builder, inputSchemasOffset);
+    EntryFunction.addOutputSchema(builder, outputSchemaOffset);
+    return EntryFunction.endEntryFunction(builder);
+  }
+}
+export {
+  EntryFunction
+};