octane 0.2.11 → 0.2.13

package/dist/signals/encoding.js

@@ -1,96 +1,6 @@
-import { SignalSerializationError } from "./errors.js";
-function unsupported() {
-  throw new 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();
-  }
-}
+import { decodeSignalValue, encodeSignalValue, snapshotSignalValue } from "../data-encoding.js";
 export {
   decodeSignalValue,
-  encodeSignalValue
+  encodeSignalValue,
+  snapshotSignalValue
 };

package/dist/signals/engine.d.ts

@@ -1,11 +1,20 @@
-import { ScopedNode, endSignalBatch, startSignalBatch, type GraphOwner, type NodeState, type SignalObserver, type SignalReadMode } from './graph.js';
+import { ScopedNode, endSignalBatch, startSignalBatch, type GraphOwner, type CandidateProducer, type NodeState, type SignalObserver, type SignalReadMode, type SignalCandidateFrame } from './graph.js';
 import { type NativeSerializedScope } from './read-protocol.js';
-import { type QueryDefinition, type RequestEntry, type ResourceBinding } from './requests.js';
-import type { AdoptionFrame, DerivedSignal, QueryRequest, Resource, Scope, ScopeInspection, ScopeOptions, ScopeSeed, SignalHandle, SignalSeedEntry, SignalTraceEvent, WritableSignal } from './types.js';
+import type { initializeResource, QueryDefinition, RequestEntry, ResourceBinding } from './requests.js';
+import type { StreamFrameIdentity, StreamedSignalResultFrame } from '../streamed-signals-protocol.js';
+import type { AdoptionFrame, DerivedSignal, DerivedCompute, DerivedOptions, QueryRequest, Resource, Scope, ScopeInspection, ScopeOptions, ScopeSeed, skip, SignalHandle, SignalSeedEntry, SignalTraceEvent, WritableSignal } from './types.js';
 interface DecodedSeedEntry {
     readonly entry: SignalSeedEntry;
     readonly value: unknown;
 }
+/** Owner lifecycle shared by scalar and asynchronous declaration implementations. */
+export interface DerivedBindingLifecycle {
+    suspend(): boolean;
+    resume(): void;
+    dispose(): void;
+    forkCandidate?(target: ScopedNode, frame: SignalCandidateFrame): CandidateProducer | undefined;
+}
+type DerivedBindingFactory<T> = new (owner: ScopeImpl, node: ScopedNode<T>, compute: DerivedCompute<T>, options?: DerivedOptions) => DerivedBindingLifecycle;
 interface FrameData {
     readonly owner: ScopeImpl;
     readonly entries: Map<string, DecodedSeedEntry>;
@@ -19,6 +28,14 @@ export declare class ScopeImpl implements Scope, GraphOwner {
     readonly requests: Map<string, RequestEntry>;
     readonly queryDefinitions: Map<string, QueryDefinition>;
     readonly resources: Map<ScopedNode<any>, ResourceBinding<any>>;
+    readonly streamedSelections: Map<string, StreamFrameIdentity>;
+    readonly streamedFrames: Map<string, StreamedSignalResultFrame[]>;
+    readonly streamedFailures: Map<string, {
+        identity: StreamFrameIdentity;
+        error: Error;
+    }>;
+    private readonly streamedReady;
+    readonly derivedBindings: Map<ScopedNode<any>, DerivedBindingLifecycle>;
     readonly frames: Set<AdoptionFrameImpl>;
     private readonly seedEntries;
     private readonly traceLimit;
@@ -26,18 +43,36 @@ export declare class ScopeImpl implements Scope, GraphOwner {
     private sequence;
     private lifetime;
     private disposed;
+    readBarrier: Promise<void> | undefined;
+    /** Internal document lifecycle: mark every owner before cancellation runs user code. */
+    suspendReads(): void;
+    resumeReads(): void;
     constructor(key: string, options: ScopeOptions, seedable?: boolean);
     get scopeKey(): string;
     get epoch(): number;
     get retired(): boolean;
     private createNode;
+    private declaredNode;
     private initialSeed;
     private retainedSeed;
     private initializeRetention;
     private consumeSeed;
     signal$<T>(key: string, initial: T): WritableSignal<T>;
+    createSignalDeclaration<T>(key: string, initial: T, preferInitial?: boolean): WritableSignal<T>;
     derived$<T>(key: string, compute: (() => T) & (T extends PromiseLike<unknown> ? never : unknown)): DerivedSignal<T>;
-    asyncSignal$<T>(key: string, describe: () => QueryRequest<T>): Resource<T>;
+    /** Candidate state is private; the ordinary node/binding maps stay untouched. */
+    forkCandidate(node: ScopedNode, target: ScopedNode, frame: SignalCandidateFrame): CandidateProducer | undefined;
+    createDerivedDeclaration<T>(key: string, compute: DerivedCompute<T>, options: DerivedOptions | undefined, Binding: DerivedBindingFactory<T>): DerivedSignal<T>;
+    createResourceDeclaration<T>(key: string, describe: () => QueryRequest<T> | typeof skip, initialize: typeof initializeResource, unique?: boolean): Resource<T>;
+    bindStreamedSelection(identity: StreamFrameIdentity): boolean;
+    isStreamedSelectionPending(identity: StreamFrameIdentity): boolean;
+    whenStreamedSelectionReady(identity: StreamFrameIdentity, ready: () => void): () => void;
+    streamedSelectionReady(binding: ResourceBinding): void;
+    retainCompletedStreamedResult(identity: StreamFrameIdentity, frames: StreamedSignalResultFrame[]): boolean;
+    discardCompletedStreamedSelection(identity: StreamFrameIdentity): void;
+    acceptStreamedResult(frame: StreamedSignalResultFrame): boolean;
+    failStreamedResult(identity: StreamFrameIdentity, error: Error): boolean;
+    private flushStreamedResult;
     private own;
     get<T>(handle$: SignalHandle<T>): T;
     set<T>(handle$: WritableSignal<T>, value: T | ((previous: T) => T)): void;
@@ -70,4 +105,18 @@ declare class AdoptionFrameImpl implements AdoptionFrame {
 export declare function createScope(options: ScopeOptions): Scope;
 /** Only the native hook adapter may create a component-owned, non-serializable scope. */
 export declare function createLocalScope(scopeKey: string): Scope;
+export declare function createDeclaredSignalCell<T>(owner: Scope, key: string, initial: T, preferInitial?: boolean): WritableSignal<T>;
+export declare function createDerivedCellWith<T>(owner: Scope, key: string, compute: DerivedCompute<T>, options: DerivedOptions | undefined, Binding: DerivedBindingFactory<T>): DerivedSignal<T>;
+export declare function createResourceCellWith<T>(owner: Scope, key: string, describe: () => QueryRequest<T> | typeof skip, initialize: typeof initializeResource, unique?: boolean): Resource<T>;
+export declare function adoptResourceValue<T>(handle$: SignalHandle<T>, requestKey: string | undefined, value: T): boolean;
+/** @internal Return the concrete owner for a proven runtime handle. */
+export declare function getSignalScope(handle$: SignalHandle<unknown>): Scope | undefined;
+/** @internal Exact selection generation used to pin an optimistic query write. */
+export declare function getResourceSelectionAuthority(handle$: SignalHandle<unknown>): object | undefined;
+/** @internal Bind receiver-owned selection authority before result delivery. */
+export declare function bindScopeStreamedSelection(owner: Scope, identity: StreamFrameIdentity): boolean;
+/** @internal Publish a receiver-validated result into an exact current request. */
+export declare function acceptScopeStreamedResult(owner: Scope, frame: StreamedSignalResultFrame): boolean;
+/** @internal Fail one exact streamed attempt after receiver timeout or rejection. */
+export declare function failScopeStreamedResult(owner: Scope, identity: StreamFrameIdentity, error: Error): boolean;
 export { startSignalBatch, endSignalBatch };

package/dist/signals/engine.js

@@ -1,7 +1,14 @@
-import { decodeSignalValue, encodeSignalValue } from "./encoding.js";
-import { ScopeDisposedError, SignalFrameError, SignalSerializationError } from "./errors.js";
+import { decodeSignalValue, encodeSignalValue, snapshotSignalValue } from "./encoding.js";
+import {
+  ScopeDisposedError,
+  SignalFrameError,
+  SignalSerializationError,
+  SignalStreamError
+} from "./errors.js";
+import { sameStreamFrameIdentity } from "../streamed-signals-protocol.js";
 import {
   ScopedNode,
+  CandidateUnsupportedError,
   assertAlive,
   assertWritable,
   derivedState,
@@ -26,9 +33,6 @@ import {
   registerNativeBatchHooks,
   reportNativeRead
 } from "./read-protocol.js";
-import {
-  initializeResource
-} from "./requests.js";
 let activeFrames;
 registerNativeBatchHooks({ startBatch: startSignalBatch, endBatch: endSignalBatch });
 function requireKey(key, label) {
@@ -48,7 +52,7 @@ function seedState(seed) {
   });
 }
 function decodeSeed(scopeKey, seed) {
-  seed = decodeSignalValue(encodeSignalValue(seed));
+  seed = snapshotSignalValue(seed);
   if (!seed || seed.version !== 1 || seed.scopeKey !== scopeKey || !Array.isArray(seed.entries)) {
     throw new SignalFrameError(`A signal seed must match scope "${scopeKey}" and version 1.`);
   }
@@ -69,10 +73,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 SignalFrameError("Async seed entries require a query identity.");
       }
+      decodeSignalValue(entry.request.argument);
       request = {
         queryKey: entry.request.queryKey,
         kind: entry.request.kind,
-        argument: encodeSignalValue(decodeSignalValue(entry.request.argument))
+        argument: entry.request.argument
       };
     } else if (entry.request !== void 0) {
       throw new SignalFrameError("Only async seed entries may contain a query identity.");
@@ -82,7 +87,7 @@ function decodeSeed(scopeKey, seed) {
       entry: {
         key: entry.key,
         kind: entry.kind,
-        value: encodeSignalValue(value),
+        value: entry.value,
         complete: entry.complete,
         ...read !== "value" ? { read } : {},
         ...entry.available === false ? { available: false } : {},
@@ -113,6 +118,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;
@@ -120,6 +130,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;
+    signalBatch(() => {
+      for (const [node, binding] of this.resources) {
+        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;
   }
@@ -129,9 +172,9 @@ class ScopeImpl {
   get retired() {
     return this.disposed;
   }
-  createNode(key, kind) {
+  createNode(key, kind, allowDuringRead = false) {
     assertAlive(this);
-    if (this.seedable) assertWritable();
+    if (this.seedable && !allowDuringRead) assertWritable();
     requireKey(key, "Signal key");
     if (this.nodes.has(key))
       throw new TypeError(`Signal key "${key}" already exists in this scope.`);
@@ -145,6 +188,18 @@ class ScopeImpl {
     this.nodes.set(key, node);
     return node;
   }
+  declaredNode(key, kind) {
+    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"));
   }
@@ -174,28 +229,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 = 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 = () => derivedState(node, compute);
+    node.compute = (target) => 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 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 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);
     signalBatch(() => {
-      const binding = initializeResource(this, node, describe, seed, retained);
+      const binding = initialize(this, node, describe, seed, retained);
       this.resources.set(node, binding);
       refreshNode(node);
+      this.flushStreamedResult(node, binding);
     });
     this.consumeSeed(key);
     return node;
   }
+  bindStreamedSelection(identity) {
+    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 && !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 && 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 (!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) {
+    assertAlive(this);
+    const selected = this.streamedSelections.get(frame.identity.nodeKey);
+    if (!selected || !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) {
+    assertAlive(this);
+    const selected = this.streamedSelections.get(identity.nodeKey);
+    if (!selected || !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 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$) {
     assertAlive(this);
     if (!(handle$ instanceof ScopedNode) || handle$.owner !== this) {
@@ -204,7 +413,8 @@ class ScopeImpl {
     return handle$;
   }
   get(handle$) {
-    return strictValue(readNode(this.own(handle$)));
+    const node = this.own(handle$);
+    return strictValue(readNode(node), node.key);
   }
   set(handle$, value) {
     this.own(handle$).set(value);
@@ -381,6 +591,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();
@@ -512,10 +728,53 @@ 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 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 ScopedNode && handle$.owner instanceof ScopeImpl ? handle$.owner : void 0;
+}
+function getResourceSelectionAuthority(handle$) {
+  if (!(handle$ instanceof 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;
+}
 export {
   ScopeImpl,
+  acceptScopeStreamedResult,
+  adoptResourceValue,
+  bindScopeStreamedSelection,
+  createDeclaredSignalCell,
+  createDerivedCellWith,
   createLocalScope,
+  createResourceCellWith,
   createScope,
   endSignalBatch,
+  failScopeStreamedResult,
+  getResourceSelectionAuthority,
+  getSignalScope,
   startSignalBatch
 };

package/dist/signals/errors.d.ts

@@ -7,9 +7,16 @@ export declare class SignalWriteError extends Error {
 export declare class SignalCycleError extends Error {
     constructor(key: string);
 }
+export declare class SignalIdleError extends Error {
+    constructor(key: string);
+}
 export declare class SignalFrameError extends Error {
     constructor(message: string);
 }
+export declare class SignalStreamError extends Error {
+    readonly code: string;
+    constructor(code: string);
+}
 export declare class SignalSerializationError extends Error {
     constructor(message: string);
 }

package/dist/signals/errors.js

@@ -16,12 +16,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);
@@ -32,6 +46,8 @@ export {
   ScopeDisposedError,
   SignalCycleError,
   SignalFrameError,
+  SignalIdleError,
   SignalSerializationError,
+  SignalStreamError,
   SignalWriteError
 };