space-data-module-sdk 0.1.0 → 0.2.5

package/src/index.js

@@ -3,6 +3,16 @@ export * from "./compliance/index.js";
 export * from "./auth/index.js";
 export * from "./transport/index.js";
 export * from "./compiler/index.js";
+export * from "./bundle/index.js";
 export * from "./standards/index.js";
-export { DefaultManifestExports } from "./runtime/constants.js";
-
+export * from "./host/index.js";
+export * from "./invoke/index.js";
+export {
+  DefaultInvokeExports,
+  DefaultManifestExports,
+  DrainPolicy,
+  ExternalInterfaceDirection,
+  ExternalInterfaceKind,
+  InvokeSurface,
+  RuntimeTarget,
+} from "./runtime/constants.js";

package/src/invoke/codec.js

@@ -0,0 +1,278 @@
+import * as flatbuffers from "flatbuffers";
+
+import {
+  PluginInvokeRequest,
+  PluginInvokeRequestT,
+} from "../generated/orbpro/invoke/plugin-invoke-request.js";
+import {
+  PluginInvokeResponse,
+  PluginInvokeResponseT,
+} from "../generated/orbpro/invoke/plugin-invoke-response.js";
+import { InvokeSurface } from "../generated/orbpro/manifest/invoke-surface.js";
+import { BufferMutability } from "../generated/orbpro/stream/buffer-mutability.js";
+import { BufferOwnership } from "../generated/orbpro/stream/buffer-ownership.js";
+import { FlatBufferTypeRefT } from "../generated/orbpro/stream/flat-buffer-type-ref.js";
+import { TypedArenaBuffer, TypedArenaBufferT } from "../generated/orbpro/stream/typed-arena-buffer.js";
+import { toUint8Array } from "../runtime/bufferLike.js";
+
+function toByteBuffer(data) {
+  if (data instanceof flatbuffers.ByteBuffer) {
+    return data;
+  }
+  const bytes = toUint8Array(data);
+  if (bytes) {
+    return new flatbuffers.ByteBuffer(bytes);
+  }
+  throw new TypeError(
+    "Expected ByteBuffer, Uint8Array, ArrayBufferView, or ArrayBuffer.",
+  );
+}
+
+function normalizeSchemaHash(value) {
+  if (!value) {
+    return [];
+  }
+  if (value instanceof Uint8Array) {
+    return Array.from(value);
+  }
+  if (ArrayBuffer.isView(value)) {
+    return Array.from(new Uint8Array(value.buffer, value.byteOffset, value.byteLength));
+  }
+  if (Array.isArray(value)) {
+    return value.map((byte) => Number(byte) & 0xff);
+  }
+  const normalized = String(value).trim().replace(/^0x/i, "");
+  if (!normalized || normalized.length % 2 !== 0) {
+    return [];
+  }
+  const bytes = [];
+  for (let index = 0; index < normalized.length; index += 2) {
+    bytes.push(parseInt(normalized.slice(index, index + 2), 16));
+  }
+  return bytes;
+}
+
+function normalizeUnsignedInteger(value, fallback = 0) {
+  const normalized = Number(value ?? fallback);
+  if (!Number.isFinite(normalized)) {
+    return fallback;
+  }
+  return Math.max(0, Math.trunc(normalized));
+}
+
+function normalizeBigInt(value, fallback = BigInt(0)) {
+  if (typeof value === "bigint") {
+    return value;
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return BigInt(Math.trunc(value));
+  }
+  if (typeof value === "string" && value.trim()) {
+    try {
+      return BigInt(value.trim());
+    } catch {
+      return fallback;
+    }
+  }
+  return fallback;
+}
+
+function normalizePayloadWireFormat(value) {
+  if (value === 1 || value === "aligned-binary") {
+    return "aligned-binary";
+  }
+  return "flatbuffer";
+}
+
+function toFlatBufferTypeRefT(value = {}, payloadLength = 0) {
+  if (value instanceof FlatBufferTypeRefT) {
+    return value;
+  }
+  const wireFormat = normalizePayloadWireFormat(value.wireFormat);
+  const requiredAlignment = normalizeUnsignedInteger(value.requiredAlignment);
+  const fixedStringLength = normalizeUnsignedInteger(value.fixedStringLength);
+  const byteLength =
+    wireFormat === "aligned-binary"
+      ? normalizeUnsignedInteger(value.byteLength, payloadLength)
+      : normalizeUnsignedInteger(value.byteLength);
+  return new FlatBufferTypeRefT(
+    value.schemaName ?? null,
+    value.fileIdentifier ?? null,
+    normalizeSchemaHash(value.schemaHash),
+    value.acceptsAnyFlatbuffer === true,
+    wireFormat,
+    value.rootTypeName ?? null,
+    fixedStringLength,
+    byteLength,
+    requiredAlignment,
+  );
+}
+
+function alignOffset(offset, alignment) {
+  if (alignment <= 1) {
+    return offset;
+  }
+  const remainder = offset % alignment;
+  return remainder === 0 ? offset : offset + alignment - remainder;
+}
+
+function normalizeArenaFrame(frame = {}, offset) {
+  const payload = toUint8Array(frame.payload ?? new Uint8Array()) ?? new Uint8Array();
+  const typeRef = toFlatBufferTypeRefT(frame.typeRef ?? frame.allowedType ?? {}, payload.length);
+  const alignment = Math.max(
+    1,
+    normalizeUnsignedInteger(
+      frame.alignment,
+      typeRef.requiredAlignment > 0 ? typeRef.requiredAlignment : 8,
+    ),
+  );
+  const alignedOffset = alignOffset(offset, alignment);
+  return {
+    payload,
+    padding: alignedOffset - offset,
+    buffer: new TypedArenaBufferT(
+      typeRef,
+      frame.portId ?? null,
+      alignment,
+      alignedOffset,
+      payload.length,
+      frame.ownership ?? BufferOwnership.BORROWED,
+      normalizeUnsignedInteger(frame.generation),
+      frame.mutability ?? BufferMutability.IMMUTABLE,
+      normalizeBigInt(frame.traceId),
+      normalizeUnsignedInteger(frame.streamId),
+      normalizeBigInt(frame.sequence),
+      frame.endOfStream === true,
+    ),
+  };
+}
+
+function packArenaFrames(frames = []) {
+  const packedFrames = [];
+  const arena = [];
+  let offset = 0;
+  for (const frame of frames) {
+    const normalized = normalizeArenaFrame(frame, offset);
+    for (let index = 0; index < normalized.padding; index += 1) {
+      arena.push(0);
+    }
+    arena.push(...normalized.payload);
+    offset = normalized.buffer.offset + normalized.buffer.size;
+    packedFrames.push(normalized.buffer);
+  }
+  return {
+    frames: packedFrames,
+    arena: Uint8Array.from(arena),
+  };
+}
+
+function materializeArenaFrames(frames = [], arenaBytes) {
+  return frames.map((frame) => {
+    const offset = normalizeUnsignedInteger(frame.offset);
+    const size = normalizeUnsignedInteger(frame.size);
+    const payload = new Uint8Array(arenaBytes.slice(offset, offset + size));
+    return {
+      ...frame,
+      payload,
+      typeRef: frame.typeRef ?? null,
+    };
+  });
+}
+
+function encodeRoot(builderFactory, finish, value) {
+  const builder = new flatbuffers.Builder(1024);
+  finish(builder, builderFactory(value).pack(builder));
+  return builder.asUint8Array();
+}
+
+export function encodePluginInvokeRequest(request = {}) {
+  const { frames, arena } = packArenaFrames(
+    Array.isArray(request.inputs) ? request.inputs : request.inputFrames ?? [],
+  );
+  return encodeRoot(
+    (value) =>
+      new PluginInvokeRequestT(value.methodId ?? null, frames, Array.from(arena)),
+    PluginInvokeRequest.finishPluginInvokeRequestBuffer,
+    request,
+  );
+}
+
+export function decodePluginInvokeRequest(data) {
+  const bb = toByteBuffer(data);
+  if (!PluginInvokeRequest.bufferHasIdentifier(bb)) {
+    throw new Error("Plugin invoke request buffer identifier mismatch.");
+  }
+  const unpacked = PluginInvokeRequest.getRootAsPluginInvokeRequest(bb).unpack();
+  const arena = Uint8Array.from(unpacked.payloadArena ?? []);
+  const inputs = materializeArenaFrames(unpacked.inputFrames ?? [], arena);
+  return {
+    methodId: unpacked.methodId ?? null,
+    inputFrames: inputs,
+    inputs,
+    payloadArena: arena,
+  };
+}
+
+export function encodePluginInvokeResponse(response = {}) {
+  const { frames, arena } = packArenaFrames(
+    Array.isArray(response.outputs) ? response.outputs : response.outputFrames ?? [],
+  );
+  return encodeRoot(
+    (value) =>
+      new PluginInvokeResponseT(
+        Number(value.statusCode ?? 0),
+        value.yielded === true,
+        normalizeUnsignedInteger(value.backlogRemaining),
+        frames,
+        Array.from(arena),
+        value.errorCode ?? null,
+        value.errorMessage ?? null,
+      ),
+    PluginInvokeResponse.finishPluginInvokeResponseBuffer,
+    response,
+  );
+}
+
+export function decodePluginInvokeResponse(data) {
+  const bb = toByteBuffer(data);
+  if (!PluginInvokeResponse.bufferHasIdentifier(bb)) {
+    throw new Error("Plugin invoke response buffer identifier mismatch.");
+  }
+  const unpacked = PluginInvokeResponse.getRootAsPluginInvokeResponse(bb).unpack();
+  const arena = Uint8Array.from(unpacked.payloadArena ?? []);
+  const outputs = materializeArenaFrames(unpacked.outputFrames ?? [], arena);
+  return {
+    statusCode: unpacked.statusCode ?? 0,
+    yielded: unpacked.yielded === true,
+    backlogRemaining: unpacked.backlogRemaining ?? 0,
+    outputFrames: outputs,
+    outputs,
+    payloadArena: arena,
+    errorCode: unpacked.errorCode ?? null,
+    errorMessage: unpacked.errorMessage ?? null,
+  };
+}
+
+export function normalizeInvokeSurfaceName(value) {
+  if (value === InvokeSurface.COMMAND || value === "command") {
+    return "command";
+  }
+  if (value === InvokeSurface.DIRECT || value === "direct") {
+    return "direct";
+  }
+  return null;
+}
+
+export function normalizeInvokeSurfaces(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const surfaces = [];
+  for (const entry of value) {
+    const normalized = normalizeInvokeSurfaceName(entry);
+    if (normalized && !surfaces.includes(normalized)) {
+      surfaces.push(normalized);
+    }
+  }
+  return surfaces;
+}

package/src/invoke/index.js

@@ -0,0 +1,9 @@
+export * from "../generated/orbpro/invoke.js";
+export {
+  decodePluginInvokeRequest,
+  decodePluginInvokeResponse,
+  encodePluginInvokeRequest,
+  encodePluginInvokeResponse,
+  normalizeInvokeSurfaceName,
+  normalizeInvokeSurfaces,
+} from "./codec.js";

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,
@@ -39,15 +40,47 @@ const capabilityKindByName = Object.freeze({
   random: CapabilityKind.RANDOM,
   logging: CapabilityKind.LOGGING,
   timers: CapabilityKind.TIMERS,
+  schedule_cron: CapabilityKind.SCHEDULE_CRON,
+  cron: CapabilityKind.SCHEDULE_CRON,
   pubsub: CapabilityKind.PUBSUB,
+  http: CapabilityKind.HTTP,
+  filesystem: CapabilityKind.FILESYSTEM,
+  pipe: CapabilityKind.PIPE,
+  network: CapabilityKind.NETWORK,
+  database: CapabilityKind.DATABASE,
   protocol_dial: CapabilityKind.PROTOCOL_DIAL,
   protocol_handle: CapabilityKind.PROTOCOL_HANDLE,
+  tls: CapabilityKind.TLS,
+  mqtt: CapabilityKind.MQTT,
+  websocket: CapabilityKind.WEBSOCKET,
+  tcp: CapabilityKind.TCP,
+  udp: CapabilityKind.UDP,
+  process_exec: CapabilityKind.PROCESS_EXEC,
+  exec: CapabilityKind.PROCESS_EXEC,
+  context_read: CapabilityKind.CONTEXT_READ,
+  context_write: CapabilityKind.CONTEXT_WRITE,
+  storage_adapter: CapabilityKind.STORAGE_ADAPTER,
   storage_query: CapabilityKind.STORAGE_QUERY,
+  storage_write: CapabilityKind.STORAGE_WRITE,
+  wallet_sign: CapabilityKind.WALLET_SIGN,
+  ipfs: CapabilityKind.IPFS,
+  crypto_hash: CapabilityKind.CRYPTO_HASH,
+  crypto_sign: CapabilityKind.CRYPTO_SIGN,
+  crypto_verify: CapabilityKind.CRYPTO_VERIFY,
+  crypto_encrypt: CapabilityKind.CRYPTO_ENCRYPT,
+  crypto_decrypt: CapabilityKind.CRYPTO_DECRYPT,
+  crypto_key_agreement: CapabilityKind.CRYPTO_KEY_AGREEMENT,
+  crypto_kdf: CapabilityKind.CRYPTO_KDF,
   scene_access: CapabilityKind.SCENE_ACCESS,
   entity_access: CapabilityKind.ENTITY_ACCESS,
   render_hooks: CapabilityKind.RENDER_HOOKS,
 });
 
+const invokeSurfaceByName = Object.freeze({
+  direct: InvokeSurface.DIRECT,
+  command: InvokeSurface.COMMAND,
+});
+
 function normalizeSchemaHash(value) {
   if (!value) {
     return [];
@@ -66,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;
@@ -98,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;
@@ -107,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),
   );
 }
 
@@ -238,6 +322,11 @@ export function toEmbeddedPluginManifest(input = {}) {
       "externalInterfaces are not yet representable in the embedded FlatBuffer manifest schema and were omitted from the compiled artifact.",
     );
   }
+  if (Array.isArray(input.runtimeTargets) && input.runtimeTargets.length > 0) {
+    warnings.push(
+      "runtimeTargets are not yet representable in the embedded FlatBuffer manifest schema and were omitted from the compiled artifact.",
+    );
+  }
 
   const capabilities = Array.isArray(input.capabilities)
     ? input.capabilities
@@ -268,8 +357,8 @@ export function toEmbeddedPluginManifest(input = {}) {
         ? input.buildArtifacts.map((entry) => toBuildArtifactT(entry))
         : [],
       Number(input.abiVersion ?? 1),
+      normalizeInvokeSurfaces(input.invokeSurfaces),
     ),
     warnings,
   };
 }
-

package/src/runtime/constants.js

@@ -14,17 +14,40 @@ export const ExternalInterfaceKind = Object.freeze({
   CLOCK: "clock",
   RANDOM: "random",
   TIMER: "timer",
+  SCHEDULE: "schedule",
   PUBSUB: "pubsub",
   PROTOCOL: "protocol",
   HTTP: "http",
+  WEBSOCKET: "websocket",
+  MQTT: "mqtt",
+  TCP: "tcp",
+  UDP: "udp",
+  TLS: "tls",
   FILESYSTEM: "filesystem",
   PIPE: "pipe",
   NETWORK: "network",
   DATABASE: "database",
+  EXEC: "exec",
+  CRYPTO: "crypto",
+  CONTEXT: "context",
   LOCAL_RUNTIME: "local-runtime",
   HOST_SERVICE: "host-service",
 });
 
+export const RuntimeTarget = Object.freeze({
+  NODE: "node",
+  BROWSER: "browser",
+  WASI: "wasi",
+  SERVER: "server",
+  DESKTOP: "desktop",
+  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",
@@ -32,3 +55,9 @@ export const DefaultManifestExports = Object.freeze({
   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/transport/pki.js

@@ -14,8 +14,6 @@ import {
   x25519SharedSecret,
 } from "../utils/wasmCrypto.js";
 
-const HKDF_SALT_LABEL = new TextEncoder().encode("space-data-module-sdk");
-
 function normalizePublicKey(value) {
   if (typeof value === "string") {
     return hexToBytes(value);
@@ -66,9 +64,6 @@ export async function encryptBytesForRecipient({
   }
   const sender = senderKeyPair ?? (await generateX25519Keypair());
   const salt = await randomBytes(32);
-  salt.set(
-    HKDF_SALT_LABEL.slice(0, Math.min(HKDF_SALT_LABEL.length, salt.length)),
-  );
   const iv = await randomBytes(12);
   const sharedSecret = await deriveSharedSecret(
     sender.privateKey,

package/src/utils/encoding.js

@@ -48,7 +48,15 @@ export function bytesToBase64(bytes) {
   return Buffer.from(toUint8Array(bytes)).toString("base64");
 }
 
+const MAX_BASE64_LENGTH = 256 * 1024 * 1024;
+
 export function base64ToBytes(base64) {
-  return new Uint8Array(Buffer.from(String(base64 ?? "").trim(), "base64"));
+  const str = String(base64 ?? "").trim();
+  if (str.length > MAX_BASE64_LENGTH) {
+    throw new RangeError(
+      `Base64 input exceeds ${MAX_BASE64_LENGTH} character limit.`,
+    );
+  }
+  return new Uint8Array(Buffer.from(str, "base64"));
 }
 

package/src/utils/wasmCrypto.js

@@ -24,6 +24,11 @@ export async function sha256Bytes(value) {
   return wallet.utils.sha256(toUint8Array(value));
 }
 
+export async function sha512Bytes(value) {
+  const wallet = await getWasmWallet();
+  return wallet.utils.sha512(toUint8Array(value));
+}
+
 export async function hkdfBytes(ikm, salt, info, length) {
   const wallet = await getWasmWallet();
   return wallet.utils.hkdf(
@@ -47,6 +52,50 @@ export async function x25519SharedSecret(privateKey, publicKey) {
   );
 }
 
+export async function secp256k1PublicKey(privateKey) {
+  const wallet = await getWasmWallet();
+  return wallet.curves.publicKeyFromPrivate(toUint8Array(privateKey));
+}
+
+export async function secp256k1SignDigest(digest, privateKey) {
+  const wallet = await getWasmWallet();
+  return wallet.curves.secp256k1.sign(
+    toUint8Array(digest),
+    toUint8Array(privateKey),
+  );
+}
+
+export async function secp256k1VerifyDigest(digest, signature, publicKey) {
+  const wallet = await getWasmWallet();
+  return wallet.curves.secp256k1.verify(
+    toUint8Array(digest),
+    toUint8Array(signature),
+    toUint8Array(publicKey),
+  );
+}
+
+export async function ed25519PublicKey(seed) {
+  const wallet = await getWasmWallet();
+  return wallet.curves.ed25519.publicKeyFromSeed(toUint8Array(seed));
+}
+
+export async function ed25519Sign(message, seed) {
+  const wallet = await getWasmWallet();
+  return wallet.curves.ed25519.sign(
+    toUint8Array(message),
+    toUint8Array(seed),
+  );
+}
+
+export async function ed25519Verify(message, signature, publicKey) {
+  const wallet = await getWasmWallet();
+  return wallet.curves.ed25519.verify(
+    toUint8Array(message),
+    toUint8Array(signature),
+    toUint8Array(publicKey),
+  );
+}
+
 export async function aesGcmEncrypt(key, plaintext, iv, aad = null) {
   const wallet = await getWasmWallet();
   return wallet.utils.aesGcm.encrypt(
@@ -67,4 +116,3 @@ export async function aesGcmDecrypt(key, ciphertext, tag, iv, aad = null) {
     aad ? toUint8Array(aad) : undefined,
   );
 }
-