octane 0.13.0 → 0.13.1

package/LICENSE

@@ -19,3 +19,31 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
+
+---
+
+The dependency graph algorithms in src/signals/graph.ts are adapted from
+Alien Signals 3.2.1, commit 8734d386d925025d0e99419bd9161c17b112c5ee:
+https://github.com/stackblitz/alien-signals
+
+MIT License
+
+Copyright (c) 2024-present Johnson Chu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/cjs/runtime.server.cjs

@@ -4039,7 +4039,10 @@ const ViewTransition = /* @__PURE__ */ (0, import_component_flags.markComponentF
       attrs.push(["vt-parent-" + kind.toLowerCase() + "-x", value ?? (handler ? "auto" : "none")]);
     }
     const annotated = vtSsrAnnotate(inner, attrs);
-    return ssrHtml(ssrBlock(props.scope === "element" ? vtSsrAnnotateScope(annotated) : annotated));
+    const body = props.scope === "element" ? vtSsrAnnotateScope(annotated) : annotated;
+    const children = props.children;
+    const unframed = typeof children === "function" || children !== null && typeof children === "object" && SERVER_HTML in children;
+    return ssrHtml(unframed ? ssrBlock(body) : body);
   },
   import_component_flags.COMPONENT_FLAGS_AUTHOR_BOUNDARY,
   "ViewTransition"

package/dist/cjs/signals/engine.cjs

@@ -34,8 +34,10 @@ __export(engine_exports, {
   getResourceSelectionAuthority: () => getResourceSelectionAuthority,
   getSignalScope: () => getSignalScope,
   installPublicScope: () => installPublicScope,
+  resumeScopeReads: () => resumeScopeReads,
   signalDeclarationSequence: () => signalDeclarationSequence,
-  startSignalBatch: () => import_graph.startSignalBatch
+  startSignalBatch: () => import_graph.startSignalBatch,
+  suspendScopeReads: () => suspendScopeReads
 });
 module.exports = __toCommonJS(engine_exports);
 var import_error_codes_client_generated = require("../error-codes.client.generated.cjs");
@@ -131,12 +133,6 @@ class ScopeImpl {
   frames = void 0;
   /** Holds a writable or asynchronous derived cell that new render inputs cannot re-select. */
   unkeyedState = false;
-  /** An attempt that never committed restarts with new inputs and keeps these cells. */
-  supersede() {
-    if (this.resources) for (const binding of this.resources.values()) binding.supersede();
-    if (this.derivedBindings)
-      for (const binding of this.derivedBindings.values()) binding.supersede();
-  }
   seedEntries;
   traceLimit;
   events = void 0;
@@ -144,33 +140,6 @@ class ScopeImpl {
   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;
-    this.streams?.suspend();
-    if (this.requests) for (const entry of this.requests.values()) entry.stopAttempt();
-    if (this.derivedBindings)
-      for (const binding of this.derivedBindings.values()) binding.suspend();
-  }
-  resumeReads() {
-    if (this.disposed || this.readBarrier !== void 0) return;
-    (0, import_graph.signalBatch)(() => {
-      if (this.resources)
-        for (const [node, binding] of this.resources) {
-          (0, import_graph.refreshNode)(node);
-          this.streams?.resume(node, binding);
-        }
-      if (this.requests)
-        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");
-          }
-        }
-      if (this.derivedBindings)
-        for (const binding of this.derivedBindings.values()) binding.resume();
-    });
-  }
   get scopeKey() {
     return this.key;
   }
@@ -180,117 +149,14 @@ class ScopeImpl {
   get retired() {
     return this.disposed;
   }
-  createNode(key, kind, allowDuringRead = false) {
-    (0, import_graph.assertAlive)(this);
-    if (this.seedable && !allowDuringRead) (0, import_graph.assertWritable)();
-    requireKey(key, "Signal key");
-    if (this.nodes.has(key)) throw new TypeError((0, import_error_codes_client_generated.formatClientError)(132, key));
-    const seeds = this.seedEntries;
-    if (seeds)
-      for (const read of ["value", "latest", "snapshot"]) {
-        const seed = seeds.get(seedKey(key, read));
-        if (seed && seed.entry.kind !== kind) {
-          throw new import_errors.SignalFrameError((0, import_error_codes_client_generated.formatClientError)(133, key));
-        }
-      }
-    const node = new import_graph.ScopedNode(this, key, kind);
-    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((0, import_error_codes_client_generated.formatClientError)(134, key, existing.kind));
-      }
-      return [existing, false];
-    }
-    return [this.createNode(key, kind, true), true];
-  }
-  initialSeed(key) {
-    const seeds = this.seedEntries;
-    return seeds && (seeds.get(seedKey(key)) ?? seeds.get(seedKey(key, "snapshot")));
-  }
-  retainedSeed(key) {
-    const seeds = this.seedEntries;
-    if (!seeds) return void 0;
-    const seed = seeds.get(seedKey(key, "latest")) ?? this.initialSeed(key);
-    return seed?.entry.available === false ? void 0 : seed;
-  }
-  initializeRetention(node) {
-    const seed = this.retainedSeed(node.key);
-    if (!seed) return;
-    node.lastState = seedState(seed);
-    node.last = seed.value;
-    node.hasLast = true;
-  }
-  consumeSeed(key) {
-    const seeds = this.seedEntries;
-    if (seeds)
-      for (const read of ["value", "latest", "snapshot"]) {
-        seeds.delete(seedKey(key, read));
-      }
-  }
   signal$(key, initial) {
-    const node = this.createNode(key, "signal");
-    const seed = this.initialSeed(key) ?? this.retainedSeed(key);
+    const node = createScopeNode(this, key, "signal");
+    const seed = initialScopeSeed(this, key) ?? retainedScopeSeed(this, key);
     node.state = (0, import_graph.readyState)(seed ? seed.value : initial);
     node.lastState = node.state;
     node.last = node.state.snapshot.value;
     node.hasLast = true;
-    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;
-  }
-  createDerivedDeclaration(key, compute, options, Binding, sequence = 0, captures, declaring = 0) {
-    if (typeof compute !== "function") throw new TypeError((0, import_error_codes_client_generated.formatClientError)(122));
-    const [node, created] = this.declaredNode(key, "derived");
-    if (!created) {
-      const binding2 = this.derivedBindings?.get(node);
-      return binding2?.redeclare(compute, sequence, captures, declaring) ?? node;
-    }
-    const binding = new Binding(this, node, compute, options);
-    binding.declared(sequence, captures, declaring);
-    (this.derivedBindings ??= /* @__PURE__ */ new Map()).set(node, binding);
-    this.initializeRetention(node);
-    this.consumeSeed(key);
-    return node;
-  }
-  createResourceDeclaration(key, describe, initialize, unique = false, sequence = 0, captures, declaring = 0) {
-    if (typeof describe !== "function") throw new TypeError((0, import_error_codes_client_generated.formatClientError)(137));
-    let node;
-    if (unique) node = this.createNode(key, "async");
-    else {
-      const [declared, created] = this.declaredNode(key, "async");
-      if (!created) {
-        const binding = this.resources?.get(declared);
-        return binding?.redeclare(describe, sequence, captures, declaring) ?? declared;
-      }
-      node = declared;
-    }
-    const seed = this.initialSeed(key);
-    const retained = this.retainedSeed(key);
-    this.initializeRetention(node);
-    (0, import_graph.signalBatch)(() => {
-      const binding = initialize(this, node, describe, seed, retained);
-      binding.declared(sequence, captures, declaring);
-      (this.resources ??= /* @__PURE__ */ new Map()).set(node, binding);
-      (0, import_graph.refreshNode)(node);
-      this.streams?.flush(node, binding);
-    });
-    this.consumeSeed(key);
+    consumeScopeSeed(this, key);
     return node;
   }
   // Server native reads serialize, and hydration adopts, internal owner scopes
@@ -338,6 +204,85 @@ class ScopeImpl {
     });
   }
 }
+function suspendScopeReads(scope) {
+  if (scope.disposed || scope.readBarrier === void 0) return;
+  scope.streams?.suspend();
+  if (scope.requests) for (const entry of scope.requests.values()) entry.stopAttempt();
+  if (scope.derivedBindings)
+    for (const binding of scope.derivedBindings.values()) binding.suspend();
+}
+function resumeScopeReads(scope) {
+  if (scope.disposed || scope.readBarrier !== void 0) return;
+  (0, import_graph.signalBatch)(() => {
+    if (scope.resources)
+      for (const [node, binding] of scope.resources) {
+        (0, import_graph.refreshNode)(node);
+        scope.streams?.resume(node, binding);
+      }
+    if (scope.requests)
+      for (const entry of scope.requests.values()) {
+        if (scope.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");
+        }
+      }
+    if (scope.derivedBindings)
+      for (const binding of scope.derivedBindings.values()) binding.resume();
+  });
+}
+function createScopeNode(owner, key, kind, allowDuringRead = false) {
+  (0, import_graph.assertAlive)(owner);
+  if (owner.seedable && !allowDuringRead) (0, import_graph.assertWritable)();
+  requireKey(key, "Signal key");
+  if (owner.nodes.has(key)) throw new TypeError((0, import_error_codes_client_generated.formatClientError)(132, key));
+  const seeds = owner.seedEntries;
+  if (seeds)
+    for (const read of ["value", "latest", "snapshot"]) {
+      const seed = seeds.get(seedKey(key, read));
+      if (seed && seed.entry.kind !== kind) {
+        throw new import_errors.SignalFrameError((0, import_error_codes_client_generated.formatClientError)(133, key));
+      }
+    }
+  const node = new import_graph.ScopedNode(owner, key, kind);
+  owner.nodes.set(key, node);
+  return node;
+}
+function declaredScopeNode(owner, key, kind) {
+  (0, import_graph.assertAlive)(owner);
+  requireKey(key, "Signal key");
+  const existing = owner.nodes.get(key);
+  if (existing) {
+    if (existing.kind !== kind) {
+      throw new TypeError((0, import_error_codes_client_generated.formatClientError)(134, key, existing.kind));
+    }
+    return [existing, false];
+  }
+  return [createScopeNode(owner, key, kind, true), true];
+}
+function initialScopeSeed(owner, key) {
+  const seeds = owner.seedEntries;
+  return seeds && (seeds.get(seedKey(key)) ?? seeds.get(seedKey(key, "snapshot")));
+}
+function retainedScopeSeed(owner, key) {
+  const seeds = owner.seedEntries;
+  if (!seeds) return void 0;
+  const seed = seeds.get(seedKey(key, "latest")) ?? initialScopeSeed(owner, key);
+  return seed?.entry.available === false ? void 0 : seed;
+}
+function initializeScopeRetention(owner, node) {
+  const seed = retainedScopeSeed(owner, node.key);
+  if (!seed) return;
+  node.lastState = seedState(seed);
+  node.last = seed.value;
+  node.hasLast = true;
+}
+function consumeScopeSeed(owner, key) {
+  const seeds = owner.seedEntries;
+  if (seeds)
+    for (const read of ["value", "latest", "snapshot"]) {
+      seeds.delete(seedKey(key, read));
+    }
+}
 function presentedSeed(entries, key, read) {
   return entries.get(seedKey(key, read)) ?? (read === "value" ? void 0 : entries.get(seedKey(key)));
 }
@@ -612,10 +557,10 @@ function installPublicScope() {
   const prototype = ScopeImpl.prototype;
   prototype.derived$ = function(key, compute) {
     if (typeof compute !== "function") throw new TypeError((0, import_error_codes_client_generated.formatClientError)(122));
-    const node = this.createNode(key, "derived");
+    const node = createScopeNode(this, key, "derived");
     node.compute = (target) => (0, import_graph.derivedState)(target, compute);
-    this.initializeRetention(node);
-    this.consumeSeed(key);
+    initializeScopeRetention(this, node);
+    consumeScopeSeed(this, key);
     return node;
   };
   prototype.get = function(handle$) {
@@ -681,19 +626,30 @@ function createLocalScope(scopeKey) {
 }
 function createDeclaredSignalCell(owner, key, initial, preferInitial = false) {
   if (!(owner instanceof ScopeImpl)) throw new TypeError((0, import_error_codes_client_generated.formatClientError)(148));
-  return owner.createSignalDeclaration(key, initial, preferInitial);
+  const [node, created] = declaredScopeNode(owner, key, "signal");
+  if (!created) return node;
+  const seed = initialScopeSeed(owner, key) ?? retainedScopeSeed(owner, 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;
+  consumeScopeSeed(owner, key);
+  return node;
 }
 function createDerivedCellWith(owner, key, compute, options, Binding, sequence = 0, captures, declaring = 0) {
   if (!(owner instanceof ScopeImpl)) throw new TypeError((0, import_error_codes_client_generated.formatClientError)(149));
-  return owner.createDerivedDeclaration(
-    key,
-    compute,
-    options,
-    Binding,
-    sequence,
-    captures,
-    declaring
-  );
+  if (typeof compute !== "function") throw new TypeError((0, import_error_codes_client_generated.formatClientError)(122));
+  const [node, created] = declaredScopeNode(owner, key, "derived");
+  if (!created) {
+    const binding2 = owner.derivedBindings?.get(node);
+    return binding2?.redeclare(compute, sequence, captures, declaring) ?? node;
+  }
+  const binding = new Binding(owner, node, compute, options);
+  binding.declared(sequence, captures, declaring);
+  (owner.derivedBindings ??= /* @__PURE__ */ new Map()).set(node, binding);
+  initializeScopeRetention(owner, node);
+  consumeScopeSeed(owner, key);
+  return node;
 }
 let declarationSequence = 0;
 function signalDeclarationSequence(site) {
@@ -701,27 +657,56 @@ function signalDeclarationSequence(site) {
 }
 function createResourceCellWith(owner, key, describe, initialize, unique = false, sequence = 0, captures, declaring = 0) {
   if (!(owner instanceof ScopeImpl)) throw new TypeError((0, import_error_codes_client_generated.formatClientError)(150));
-  return owner.createResourceDeclaration(
-    key,
-    describe,
-    initialize,
-    unique,
-    sequence,
-    captures,
-    declaring
-  );
+  if (typeof describe !== "function") throw new TypeError((0, import_error_codes_client_generated.formatClientError)(137));
+  let node;
+  if (unique) node = createScopeNode(owner, key, "async");
+  else {
+    const [declared, created] = declaredScopeNode(owner, key, "async");
+    if (!created) {
+      const binding = owner.resources?.get(declared);
+      return binding?.redeclare(describe, sequence, captures, declaring) ?? declared;
+    }
+    node = declared;
+  }
+  const seed = initialScopeSeed(owner, key);
+  const retained = retainedScopeSeed(owner, key);
+  initializeScopeRetention(owner, node);
+  (0, import_graph.signalBatch)(() => {
+    const binding = initialize(owner, node, describe, seed, retained);
+    binding.declared(sequence, captures, declaring);
+    (owner.resources ??= /* @__PURE__ */ new Map()).set(node, binding);
+    (0, import_graph.refreshNode)(node);
+    owner.streams?.flush(node, binding);
+  });
+  consumeScopeSeed(owner, key);
+  return node;
 }
 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;
+  if (!binding) return false;
+  (0, import_graph.assertAlive)(binding.owner);
+  (0, import_graph.assertWritable)();
+  const entry = binding.selected;
+  if (!entry || entry.request.identity !== requestKey) return false;
+  const streaming = entry.request.definition.kind === "stream";
+  if (!streaming) entry.stopAttempt();
+  entry.state = (0, import_graph.readyState)(value, {
+    requestKey: entry.request.identity,
+    connection: streaming ? entry.state.snapshot.connection : "none",
+    complete: streaming ? entry.state.snapshot.complete : true
+  });
+  entry.deliver();
+  return true;
 }
 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;
+  const binding = handle$.owner.resources?.get(handle$);
+  if (!binding) return;
+  return binding.selected ? binding.selectionAuthority : void 0;
 }
 function bindScopeStreamedSelection(owner, identity) {
   if (!(owner instanceof ScopeImpl)) return false;
@@ -758,6 +743,8 @@ function failScopeStreamedResult(owner, identity, error) {
   getResourceSelectionAuthority,
   getSignalScope,
   installPublicScope,
+  resumeScopeReads,
   signalDeclarationSequence,
-  startSignalBatch
+  startSignalBatch,
+  suspendScopeReads
 });

package/dist/cjs/signals/facade.cjs

@@ -183,7 +183,11 @@ function supersedeOwner(owner) {
   if (retiredIdentities.has(identity)) return false;
   const scope = identityScopes.get(identity);
   if (scope?.unkeyedState) return false;
-  scope?.supersede();
+  if (scope) {
+    if (scope.resources) for (const binding of scope.resources.values()) binding.supersede();
+    if (scope.derivedBindings)
+      for (const binding of scope.derivedBindings.values()) binding.supersede();
+  }
   return true;
 }
 function createSignalOwnerLifecycle(owner) {
@@ -213,7 +217,7 @@ function createSignalOwnerLifecycle(owner) {
       frozenDocuments.set(owner, barrier);
       const existing = scopes();
       for (const scope of existing) scope.readBarrier = barrier;
-      for (const scope of existing) scope.suspendReads();
+      for (const scope of existing) (0, import_engine.suspendScopeReads)(scope);
     },
     resume() {
       if (this.retired || barrier === void 0) return;
@@ -225,7 +229,7 @@ function createSignalOwnerLifecycle(owner) {
       release = void 0;
       for (const scope of existing) {
         if (barrier !== void 0 || this.retired) break;
-        scope.resumeReads();
+        (0, import_engine.resumeScopeReads)(scope);
       }
     },
     retire() {
@@ -323,19 +327,6 @@ class Descriptor {
    * the read path's check never changes or misses the descriptor's shape.
    */
   lexical;
-  /** @internal See __declared. */
-  static declared(handle$) {
-    if (!(handle$ instanceof Descriptor) || handle$.owner === void 0) return handle$;
-    const declared = handle$;
-    const Class = declared.constructor;
-    return declared.lexical ??= new Class(
-      declared.key,
-      declared.kind,
-      declared.create,
-      declared.site,
-      declared
-    );
-  }
   /** The owner a use resolves for: its reader, or for a lexical handle its declaring owner. */
   reader() {
     return this.lexical === this ? this.owner : requireOwner();
@@ -437,7 +428,16 @@ class Descriptor {
   }
 }
 function __declared(handle$) {
-  return Descriptor.declared(handle$);
+  if (!(handle$ instanceof Descriptor) || handle$.owner === void 0) return handle$;
+  const declared = handle$;
+  const Class = declared.constructor;
+  return declared.lexical ??= new Class(
+    declared.key,
+    declared.kind,
+    declared.create,
+    declared.site,
+    declared
+  );
 }
 class SignalDescriptor extends Descriptor {
   set(value) {
@@ -556,18 +556,18 @@ function attachStreamedSignalResult(receiver, owner, identity) {
   const consumer = {
     accept(frame) {
       if (acceptStreamedSignalResult(owner, frame)) return;
-      if (streams.isPending(frame.identity)) return false;
+      if ((0, import_scope_streams.isScopeStreamPending)(streams, frame.identity)) return false;
       fail(new import_errors.SignalStreamError("identity"));
       throw new import_errors.SignalStreamError("identity");
     },
     retainCompleted(frames) {
-      return streams.retainCompleted(identity, frames);
+      return (0, import_scope_streams.retainCompletedScopeStream)(streams, identity, frames);
     },
     fail
   };
   try {
     let detach = receiver.attachResult(identity, consumer);
-    const stopWaiting = streams.whenReady(identity, () => {
+    const stopWaiting = (0, import_scope_streams.whenScopeStreamReady)(streams, identity, () => {
       detach = receiver.attachResult(identity, consumer);
     });
     return () => {