octane 0.2.11 → 0.2.13

package/dist/cjs/signals/encoding.cjs

@@ -18,104 +18,15 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var encoding_exports = {};
 __export(encoding_exports, {
-  decodeSignalValue: () => decodeSignalValue,
-  encodeSignalValue: () => encodeSignalValue
+  decodeSignalValue: () => import_data_encoding.decodeSignalValue,
+  encodeSignalValue: () => import_data_encoding.encodeSignalValue,
+  snapshotSignalValue: () => import_data_encoding.snapshotSignalValue
 });
 module.exports = __toCommonJS(encoding_exports);
-var import_errors = require("./errors.cjs");
-function unsupported() {
-  throw new import_errors.SignalSerializationError(
-    "Signal request arguments and seeds require acyclic plain data: undefined, null, booleans, finite numbers, strings, dense arrays, and plain objects with enumerable string data properties."
-  );
-}
-function encodeSignalValue(value, ancestors = /* @__PURE__ */ new Set()) {
-  if (value === void 0) return ["undefined"];
-  if (value === null) return ["null"];
-  if (typeof value === "boolean") return ["boolean", value];
-  if (typeof value === "string") return ["string", value];
-  if (typeof value === "number") {
-    if (!Number.isFinite(value)) return unsupported();
-    return ["number", Object.is(value, -0) ? "-0" : value];
-  }
-  if (typeof value !== "object" || ancestors.has(value)) return unsupported();
-  const prototype = Object.getPrototypeOf(value);
-  if (!Array.isArray(value) && prototype !== Object.prototype && prototype !== null) {
-    return unsupported();
-  }
-  ancestors.add(value);
-  try {
-    if (Array.isArray(value)) {
-      const keys2 = Reflect.ownKeys(value);
-      if (keys2.length !== value.length + 1) return unsupported();
-      const items = [];
-      for (let i = 0; i < value.length; i++) {
-        const descriptor = Object.getOwnPropertyDescriptor(value, String(i));
-        if (!descriptor || !descriptor.enumerable || !("value" in descriptor)) return unsupported();
-        items.push(encodeSignalValue(descriptor.value, ancestors));
-      }
-      return ["array", items];
-    }
-    const keys = Reflect.ownKeys(value);
-    if (keys.some((key) => typeof key !== "string")) return unsupported();
-    const entries = [];
-    for (const key of keys.sort()) {
-      const descriptor = Object.getOwnPropertyDescriptor(value, key);
-      if (!descriptor.enumerable || !("value" in descriptor)) return unsupported();
-      entries.push([key, encodeSignalValue(descriptor.value, ancestors)]);
-    }
-    return ["object", entries];
-  } finally {
-    ancestors.delete(value);
-  }
-}
-function decodeSignalValue(encoded) {
-  if (!Array.isArray(encoded)) return unsupported();
-  const [tag, value] = encoded;
-  switch (tag) {
-    case "undefined":
-      if (encoded.length !== 1) return unsupported();
-      return void 0;
-    case "null":
-      if (encoded.length !== 1) return unsupported();
-      return null;
-    case "boolean":
-      if (encoded.length !== 2 || typeof value !== "boolean") return unsupported();
-      return value;
-    case "number":
-      if (encoded.length !== 2) return unsupported();
-      if (value === "-0") return -0;
-      if (typeof value !== "number" || !Number.isFinite(value) || Object.is(value, -0)) {
-        return unsupported();
-      }
-      return value;
-    case "string":
-      if (encoded.length !== 2 || typeof value !== "string") return unsupported();
-      return value;
-    case "array":
-      if (encoded.length !== 2 || !Array.isArray(value)) return unsupported();
-      return Object.freeze(value.map((item) => decodeSignalValue(item)));
-    case "object": {
-      if (encoded.length !== 2 || !Array.isArray(value)) return unsupported();
-      const object = {};
-      let previous;
-      for (const entry of value) {
-        if (!Array.isArray(entry) || entry.length !== 2 || typeof entry[0] !== "string" || previous !== void 0 && entry[0] <= previous) {
-          return unsupported();
-        }
-        previous = entry[0];
-        Object.defineProperty(object, entry[0], {
-          value: decodeSignalValue(entry[1]),
-          enumerable: true
-        });
-      }
-      return Object.freeze(object);
-    }
-    default:
-      return unsupported();
-  }
-}
+var import_data_encoding = require("../data-encoding.cjs");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   decodeSignalValue,
-  encodeSignalValue
+  encodeSignalValue,
+  snapshotSignalValue
 });

package/dist/cjs/signals/engine.cjs

@@ -19,17 +19,26 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var engine_exports = {};
 __export(engine_exports, {
   ScopeImpl: () => ScopeImpl,
+  acceptScopeStreamedResult: () => acceptScopeStreamedResult,
+  adoptResourceValue: () => adoptResourceValue,
+  bindScopeStreamedSelection: () => bindScopeStreamedSelection,
+  createDeclaredSignalCell: () => createDeclaredSignalCell,
+  createDerivedCellWith: () => createDerivedCellWith,
   createLocalScope: () => createLocalScope,
+  createResourceCellWith: () => createResourceCellWith,
   createScope: () => createScope,
   endSignalBatch: () => import_graph.endSignalBatch,
+  failScopeStreamedResult: () => failScopeStreamedResult,
+  getResourceSelectionAuthority: () => getResourceSelectionAuthority,
+  getSignalScope: () => getSignalScope,
   startSignalBatch: () => import_graph.startSignalBatch
 });
 module.exports = __toCommonJS(engine_exports);
 var import_encoding = require("./encoding.cjs");
 var import_errors = require("./errors.cjs");
+var import_streamed_signals_protocol = require("../streamed-signals-protocol.cjs");
 var import_graph = require("./graph.cjs");
 var import_read_protocol = require("./read-protocol.cjs");
-var import_requests = require("./requests.cjs");
 let activeFrames;
 (0, import_read_protocol.registerNativeBatchHooks)({ startBatch: import_graph.startSignalBatch, endBatch: import_graph.endSignalBatch });
 function requireKey(key, label) {
@@ -49,7 +58,7 @@ function seedState(seed) {
   });
 }
 function decodeSeed(scopeKey, seed) {
-  seed = (0, import_encoding.decodeSignalValue)((0, import_encoding.encodeSignalValue)(seed));
+  seed = (0, import_encoding.snapshotSignalValue)(seed);
   if (!seed || seed.version !== 1 || seed.scopeKey !== scopeKey || !Array.isArray(seed.entries)) {
     throw new import_errors.SignalFrameError(`A signal seed must match scope "${scopeKey}" and version 1.`);
   }
@@ -70,10 +79,11 @@ function decodeSeed(scopeKey, seed) {
       if (!entry.request || typeof entry.request.queryKey !== "string" || !entry.request.queryKey.trim() || !["promise", "stream"].includes(entry.request.kind)) {
         throw new import_errors.SignalFrameError("Async seed entries require a query identity.");
       }
+      (0, import_encoding.decodeSignalValue)(entry.request.argument);
       request = {
         queryKey: entry.request.queryKey,
         kind: entry.request.kind,
-        argument: (0, import_encoding.encodeSignalValue)((0, import_encoding.decodeSignalValue)(entry.request.argument))
+        argument: entry.request.argument
       };
     } else if (entry.request !== void 0) {
       throw new import_errors.SignalFrameError("Only async seed entries may contain a query identity.");
@@ -83,7 +93,7 @@ function decodeSeed(scopeKey, seed) {
       entry: {
         key: entry.key,
         kind: entry.kind,
-        value: (0, import_encoding.encodeSignalValue)(value),
+        value: entry.value,
         complete: entry.complete,
         ...read !== "value" ? { read } : {},
         ...entry.available === false ? { available: false } : {},
@@ -114,6 +124,11 @@ class ScopeImpl {
   requests = /* @__PURE__ */ new Map();
   queryDefinitions = /* @__PURE__ */ new Map();
   resources = /* @__PURE__ */ new Map();
+  streamedSelections = /* @__PURE__ */ new Map();
+  streamedFrames = /* @__PURE__ */ new Map();
+  streamedFailures = /* @__PURE__ */ new Map();
+  streamedReady = /* @__PURE__ */ new Map();
+  derivedBindings = /* @__PURE__ */ new Map();
   frames = /* @__PURE__ */ new Set();
   seedEntries;
   traceLimit;
@@ -121,6 +136,39 @@ class ScopeImpl {
   sequence = 0;
   lifetime = 0;
   disposed = false;
+  readBarrier;
+  /** Internal document lifecycle: mark every owner before cancellation runs user code. */
+  suspendReads() {
+    if (this.disposed || this.readBarrier === void 0) return;
+    for (const key of this.streamedSelections.keys()) {
+      if (this.streamedFrames.get(key)?.at(-1)?.kind === "complete") continue;
+      this.streamedSelections.delete(key);
+      this.streamedFrames.delete(key);
+      this.streamedReady.delete(key);
+    }
+    this.streamedFailures.clear();
+    for (const entry of this.requests.values()) entry.stopAttempt();
+    for (const binding of this.derivedBindings.values()) binding.suspend();
+  }
+  resumeReads() {
+    if (this.disposed || this.readBarrier !== void 0) return;
+    (0, import_graph.signalBatch)(() => {
+      for (const [node, binding] of this.resources) {
+        (0, import_graph.refreshNode)(node);
+        const identity = this.streamedSelections.get(node.key);
+        if (identity && this.streamedFrames.has(node.key) && binding.bindStreamedSelection(identity)) {
+          this.flushStreamedResult(node, binding);
+        }
+      }
+      for (const entry of this.requests.values()) {
+        if (this.readBarrier !== void 0) break;
+        if (!entry.active && !entry.state.snapshot.complete && entry.state.snapshot.status !== "error" && entry.consumers.size) {
+          entry.start(entry.state.snapshot.status !== "ready");
+        }
+      }
+      for (const binding of this.derivedBindings.values()) binding.resume();
+    });
+  }
   get scopeKey() {
     return this.key;
   }
@@ -130,9 +178,9 @@ class ScopeImpl {
   get retired() {
     return this.disposed;
   }
-  createNode(key, kind) {
+  createNode(key, kind, allowDuringRead = false) {
     (0, import_graph.assertAlive)(this);
-    if (this.seedable) (0, import_graph.assertWritable)();
+    if (this.seedable && !allowDuringRead) (0, import_graph.assertWritable)();
     requireKey(key, "Signal key");
     if (this.nodes.has(key))
       throw new TypeError(`Signal key "${key}" already exists in this scope.`);
@@ -146,6 +194,18 @@ class ScopeImpl {
     this.nodes.set(key, node);
     return node;
   }
+  declaredNode(key, kind) {
+    (0, import_graph.assertAlive)(this);
+    requireKey(key, "Signal key");
+    const existing = this.nodes.get(key);
+    if (existing) {
+      if (existing.kind !== kind) {
+        throw new TypeError(`Signal key "${key}" already has kind "${existing.kind}".`);
+      }
+      return [existing, false];
+    }
+    return [this.createNode(key, kind, true), true];
+  }
   initialSeed(key) {
     return this.seedEntries.get(seedKey(key)) ?? this.seedEntries.get(seedKey(key, "snapshot"));
   }
@@ -175,28 +235,182 @@ class ScopeImpl {
     this.consumeSeed(key);
     return node;
   }
+  createSignalDeclaration(key, initial, preferInitial = false) {
+    const [node, created] = this.declaredNode(key, "signal");
+    if (!created) return node;
+    const seed = this.initialSeed(key) ?? this.retainedSeed(key);
+    node.state = (0, import_graph.readyState)(seed && !preferInitial ? seed.value : initial);
+    node.lastState = node.state;
+    node.last = node.state.snapshot.value;
+    node.hasLast = true;
+    this.consumeSeed(key);
+    return node;
+  }
   derived$(key, compute) {
     if (typeof compute !== "function") throw new TypeError("derived$ requires a function.");
     const node = this.createNode(key, "derived");
-    node.compute = () => (0, import_graph.derivedState)(node, compute);
+    node.compute = (target) => (0, import_graph.derivedState)(target, compute);
     this.initializeRetention(node);
     this.consumeSeed(key);
     return node;
   }
-  asyncSignal$(key, describe) {
-    if (typeof describe !== "function") throw new TypeError("asyncSignal$ requires a description.");
-    const node = this.createNode(key, "async");
+  /** Candidate state is private; the ordinary node/binding maps stay untouched. */
+  forkCandidate(node, target, frame) {
+    if (this.nodes.get(node.key) !== node || this.readBarrier || this.frames.size) {
+      throw new import_graph.CandidateUnsupportedError("Candidate frames require live, non-adopting nodes.");
+    }
+    const resource = this.resources.get(node);
+    if (resource) return resource.forkCandidate(target);
+    const binding = this.derivedBindings.get(node);
+    if (binding) {
+      if (!binding.forkCandidate) {
+        throw new import_graph.CandidateUnsupportedError(
+          "Async derived candidates are not supported by this prototype."
+        );
+      }
+      return binding.forkCandidate(target, frame);
+    }
+    target.compute = node.compute;
+  }
+  createDerivedDeclaration(key, compute, options, Binding) {
+    if (typeof compute !== "function") throw new TypeError("derived$ requires a function.");
+    const [node, created] = this.declaredNode(key, "derived");
+    if (!created) return node;
+    const binding = new Binding(this, node, compute, options);
+    this.derivedBindings.set(node, binding);
+    this.initializeRetention(node);
+    this.consumeSeed(key);
+    return node;
+  }
+  createResourceDeclaration(key, describe, initialize, unique = false) {
+    if (typeof describe !== "function")
+      throw new TypeError("A query resource requires a description.");
+    let node;
+    if (unique) node = this.createNode(key, "async");
+    else {
+      const [declared, created] = this.declaredNode(key, "async");
+      if (!created) return declared;
+      node = declared;
+    }
     const seed = this.initialSeed(key);
     const retained = this.retainedSeed(key);
     this.initializeRetention(node);
     (0, import_graph.signalBatch)(() => {
-      const binding = (0, import_requests.initializeResource)(this, node, describe, seed, retained);
+      const binding = initialize(this, node, describe, seed, retained);
       this.resources.set(node, binding);
       (0, import_graph.refreshNode)(node);
+      this.flushStreamedResult(node, binding);
     });
     this.consumeSeed(key);
     return node;
   }
+  bindStreamedSelection(identity) {
+    (0, import_graph.assertAlive)(this);
+    const node = this.nodes.get(identity.nodeKey);
+    if (node && node.kind !== "async") return false;
+    const previous = this.streamedSelections.get(identity.nodeKey);
+    if (previous && !(0, import_streamed_signals_protocol.sameStreamFrameIdentity)(previous, identity)) {
+      this.streamedFrames.delete(identity.nodeKey);
+      this.streamedFailures.delete(identity.nodeKey);
+      this.streamedReady.delete(identity.nodeKey);
+    }
+    this.streamedSelections.set(identity.nodeKey, identity);
+    if (!node) return true;
+    return this.resources.get(node)?.bindStreamedSelection(identity) === true;
+  }
+  isStreamedSelectionPending(identity) {
+    const selected = this.streamedSelections.get(identity.nodeKey);
+    const node = this.nodes.get(identity.nodeKey);
+    return !this.retired && selected !== void 0 && (0, import_streamed_signals_protocol.sameStreamFrameIdentity)(selected, identity) && node?.kind === "async" && this.resources.get(node)?.isStreamedSelectionReady(selected) === false;
+  }
+  whenStreamedSelectionReady(identity, ready) {
+    const node = this.nodes.get(identity.nodeKey);
+    if (node && this.resources.get(node)?.isStreamedSelectionReady(identity)) return () => {
+    };
+    const registration = { identity, ready };
+    this.streamedReady.set(identity.nodeKey, registration);
+    return () => {
+      if (this.streamedReady.get(identity.nodeKey) === registration)
+        this.streamedReady.delete(identity.nodeKey);
+    };
+  }
+  streamedSelectionReady(binding) {
+    if (this.readBarrier !== void 0 || this.retired) return;
+    this.flushStreamedResult(binding.node, binding);
+    const registration = this.streamedReady.get(binding.node.key);
+    if (registration && binding.isStreamedSelectionReady(registration.identity)) {
+      this.streamedReady.delete(binding.node.key);
+      registration.ready();
+    }
+  }
+  retainCompletedStreamedResult(identity, frames) {
+    if (!this.isStreamedSelectionPending(identity) || frames.at(-1)?.kind !== "complete")
+      return false;
+    const previous = this.streamedFrames.get(identity.nodeKey);
+    if (previous?.at(-1)?.kind === "complete") return false;
+    let sequence = previous?.length ?? 0;
+    for (const frame of frames) {
+      if (!(0, import_streamed_signals_protocol.sameStreamFrameIdentity)(identity, frame.identity) || frame.sequence !== sequence++)
+        return false;
+    }
+    if (previous) previous.push(...frames);
+    else this.streamedFrames.set(identity.nodeKey, frames);
+    return true;
+  }
+  discardCompletedStreamedSelection(identity) {
+    if (this.streamedSelections.get(identity.nodeKey) !== identity || this.streamedFrames.get(identity.nodeKey)?.at(-1)?.kind !== "complete")
+      return;
+    this.streamedFrames.delete(identity.nodeKey);
+    this.streamedSelections.delete(identity.nodeKey);
+    this.streamedReady.delete(identity.nodeKey);
+    this.streamedFailures.delete(identity.nodeKey);
+  }
+  acceptStreamedResult(frame) {
+    (0, import_graph.assertAlive)(this);
+    const selected = this.streamedSelections.get(frame.identity.nodeKey);
+    if (!selected || !(0, import_streamed_signals_protocol.sameStreamFrameIdentity)(selected, frame.identity)) return false;
+    const node = this.nodes.get(frame.identity.nodeKey);
+    if (!node) {
+      let frames = this.streamedFrames.get(frame.identity.nodeKey);
+      if (!frames) this.streamedFrames.set(frame.identity.nodeKey, frames = []);
+      frames.push(frame);
+      return true;
+    }
+    if (node.kind !== "async") return false;
+    return this.resources.get(node)?.acceptStreamed(frame) === true;
+  }
+  failStreamedResult(identity, error) {
+    (0, import_graph.assertAlive)(this);
+    const selected = this.streamedSelections.get(identity.nodeKey);
+    if (!selected || !(0, import_streamed_signals_protocol.sameStreamFrameIdentity)(selected, identity)) return false;
+    const node = this.nodes.get(identity.nodeKey);
+    if (!node) {
+      this.streamedFailures.set(identity.nodeKey, { identity, error });
+      return true;
+    }
+    if (node.kind !== "async") return false;
+    return this.resources.get(node)?.failStreamed(identity, error) === true;
+  }
+  flushStreamedResult(node, binding) {
+    if (this.readBarrier !== void 0) return;
+    const identity = this.streamedSelections.get(node.key);
+    if (!identity || !binding.isStreamedSelectionReady(identity)) return;
+    const frames = this.streamedFrames.get(node.key);
+    if (frames) {
+      this.streamedFrames.delete(node.key);
+      for (const frame of frames) {
+        if (!binding.acceptStreamed(frame)) {
+          binding.failStreamed(identity, new import_errors.SignalStreamError("identity"));
+          break;
+        }
+      }
+    }
+    const failure = this.streamedFailures.get(node.key);
+    if (failure) {
+      this.streamedFailures.delete(node.key);
+      binding.failStreamed(failure.identity, failure.error);
+    }
+  }
   own(handle$) {
     (0, import_graph.assertAlive)(this);
     if (!(handle$ instanceof import_graph.ScopedNode) || handle$.owner !== this) {
@@ -205,7 +419,8 @@ class ScopeImpl {
     return handle$;
   }
   get(handle$) {
-    return (0, import_graph.strictValue)((0, import_graph.readNode)(this.own(handle$)));
+    const node = this.own(handle$);
+    return (0, import_graph.strictValue)((0, import_graph.readNode)(node), node.key);
   }
   set(handle$, value) {
     this.own(handle$).set(value);
@@ -382,6 +597,12 @@ class ScopeImpl {
       this.lifetime++;
       for (const resource of this.resources.values()) resource.dispose();
       this.resources.clear();
+      this.streamedSelections.clear();
+      this.streamedFrames.clear();
+      this.streamedFailures.clear();
+      this.streamedReady.clear();
+      for (const binding of this.derivedBindings.values()) binding.dispose();
+      this.derivedBindings.clear();
       this.requests.clear();
       this.queryDefinitions.clear();
       for (const frame of this.frames) frame.release();
@@ -513,11 +734,54 @@ function createScope(options) {
 function createLocalScope(scopeKey) {
   return new ScopeImpl(scopeKey, { scopeKey }, false);
 }
+function createDeclaredSignalCell(owner, key, initial, preferInitial = false) {
+  if (!(owner instanceof ScopeImpl)) throw new TypeError("A direct signal needs an Octane scope.");
+  return owner.createSignalDeclaration(key, initial, preferInitial);
+}
+function createDerivedCellWith(owner, key, compute, options, Binding) {
+  if (!(owner instanceof ScopeImpl))
+    throw new TypeError("A direct derived signal needs an Octane scope.");
+  return owner.createDerivedDeclaration(key, compute, options, Binding);
+}
+function createResourceCellWith(owner, key, describe, initialize, unique = false) {
+  if (!(owner instanceof ScopeImpl)) throw new TypeError("A direct query needs an Octane scope.");
+  return owner.createResourceDeclaration(key, describe, initialize, unique);
+}
+function adoptResourceValue(handle$, requestKey, value) {
+  if (!(handle$ instanceof import_graph.ScopedNode) || !(handle$.owner instanceof ScopeImpl)) return false;
+  const binding = handle$.owner.resources.get(handle$);
+  return binding ? binding.adopt(requestKey, value) : false;
+}
+function getSignalScope(handle$) {
+  return handle$ instanceof import_graph.ScopedNode && handle$.owner instanceof ScopeImpl ? handle$.owner : void 0;
+}
+function getResourceSelectionAuthority(handle$) {
+  if (!(handle$ instanceof import_graph.ScopedNode) || !(handle$.owner instanceof ScopeImpl)) return;
+  return handle$.owner.resources.get(handle$)?.authority;
+}
+function bindScopeStreamedSelection(owner, identity) {
+  return owner instanceof ScopeImpl ? owner.bindStreamedSelection(identity) : false;
+}
+function acceptScopeStreamedResult(owner, frame) {
+  return owner instanceof ScopeImpl ? owner.acceptStreamedResult(frame) : false;
+}
+function failScopeStreamedResult(owner, identity, error) {
+  return owner instanceof ScopeImpl ? owner.failStreamedResult(identity, error) : false;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ScopeImpl,
+  acceptScopeStreamedResult,
+  adoptResourceValue,
+  bindScopeStreamedSelection,
+  createDeclaredSignalCell,
+  createDerivedCellWith,
   createLocalScope,
+  createResourceCellWith,
   createScope,
   endSignalBatch,
+  failScopeStreamedResult,
+  getResourceSelectionAuthority,
+  getSignalScope,
   startSignalBatch
 });

package/dist/cjs/signals/errors.cjs

@@ -21,7 +21,9 @@ __export(errors_exports, {
   ScopeDisposedError: () => ScopeDisposedError,
   SignalCycleError: () => SignalCycleError,
   SignalFrameError: () => SignalFrameError,
+  SignalIdleError: () => SignalIdleError,
   SignalSerializationError: () => SignalSerializationError,
+  SignalStreamError: () => SignalStreamError,
   SignalWriteError: () => SignalWriteError
 });
 module.exports = __toCommonJS(errors_exports);
@@ -43,12 +45,26 @@ class SignalCycleError extends Error {
     this.name = "SignalCycleError";
   }
 }
+class SignalIdleError extends Error {
+  constructor(key) {
+    super(`Signal "${key}" has no selected value.`);
+    this.name = "SignalIdleError";
+  }
+}
 class SignalFrameError extends Error {
   constructor(message) {
     super(message);
     this.name = "SignalFrameError";
   }
 }
+class SignalStreamError extends Error {
+  code;
+  constructor(code) {
+    super(`Streamed signal failed with code "${code}".`);
+    this.code = code;
+    this.name = "SignalStreamError";
+  }
+}
 class SignalSerializationError extends Error {
   constructor(message) {
     super(message);
@@ -60,6 +76,8 @@ class SignalSerializationError extends Error {
   ScopeDisposedError,
   SignalCycleError,
   SignalFrameError,
+  SignalIdleError,
   SignalSerializationError,
+  SignalStreamError,
   SignalWriteError
 });