octane 0.2.6 → 0.2.7

package/dist/runtime.server.d.ts

@@ -70,7 +70,7 @@ interface Frame {
     deferred: boolean;
     asyncScope: string;
     /** Parser context supplied by, or inherited through, the component call site. */
-    namespace?: 'html' | 'svg' | 'mathml';
+    namespace: 'html' | 'svg' | 'mathml' | undefined;
 }
 /** Compiler ABI: validate and scope one native element during a DEV SSR render. */
 export declare function ssrElement(tag: string, location: string | undefined, render: () => string, htmlIntegrationPoint?: boolean): string;

package/dist/runtime.server.js

@@ -2297,7 +2297,8 @@ function ssrComponent(parent, comp, props, inherit, key, identityScoped) {
       occ: null,
       path: null,
       deferred: false,
-      asyncScope: ASYNC_SCOPE
+      asyncScope: ASYNC_SCOPE,
+      namespace: explicitNamespace ?? void 0
     } : {
       parent: pf,
       seg: nextChildSegment(pf),
@@ -2306,9 +2307,9 @@ function ssrComponent(parent, comp, props, inherit, key, identityScoped) {
       occ: null,
       path: null,
       deferred: false,
-      asyncScope: ASYNC_SCOPE
+      asyncScope: ASYNC_SCOPE,
+      namespace: explicitNamespace ?? pf.namespace
     };
-    frame.namespace = explicitNamespace ?? pf?.namespace;
     return renderComponentFramed(comp, props, parent, frame, inherit);
   } finally {
     if (identityScoped !== true) ASYNC_SCOPE = previousIdentityScope;
@@ -2550,6 +2551,7 @@ function vtSsrAnnotate(html, attrs) {
   return html.slice(0, insertion) + inject + html.slice(insertion);
 }
 function vtSsrClaimArm(html, kind) {
+  if (!VT_SSR_HAS_CANDIDATES) return html;
   const start = vtSsrFirstVisibleOpenTag(html);
   if (start === -1) return html;
   const end = vtSsrOpenTagEnd(html, start + 1);
@@ -3688,14 +3690,12 @@ function namespaceHeadElement(headKey, tag, attrs, text, authoredKey) {
   return createElement(namespaceHead, config);
 }
 function spliceHead(body, head) {
-  if (head === "" && !isDocumentRoot(body)) return body;
+  if (!isDocumentRoot(body)) return head === "" ? body : head + body;
   const headClose = body.indexOf("</head>");
   if (headClose !== -1) return body.slice(0, headClose) + head + body.slice(headClose);
-  if (isDocumentRoot(body)) {
-    const openingEnd = documentTagEnd(body, body.indexOf("<html") + 5);
-    if (openingEnd !== -1)
-      return body.slice(0, openingEnd) + "<head>" + head + "</head>" + body.slice(openingEnd);
-  }
+  const openingEnd = documentTagEnd(body, body.indexOf("<html") + 5);
+  if (openingEnd !== -1)
+    return body.slice(0, openingEnd) + "<head>" + head + "</head>" + body.slice(openingEnd);
   if (head === "") return body;
   return head + body;
 }
@@ -3955,7 +3955,8 @@ function runFullFramedPass(component, props, resolved, nonceAttr = "", identifie
     occ: null,
     path: "",
     deferred: false,
-    asyncScope: ""
+    asyncScope: "",
+    namespace: void 0
   };
   CURRENT_COMP = component;
   CURRENT_PROPS = props;
@@ -4061,7 +4062,8 @@ function runDiscoveryRound(jobs, resolved, identifierPrefix) {
         occ: null,
         path: null,
         deferred: false,
-        asyncScope: job.frame.asyncScope
+        asyncScope: job.frame.asyncScope,
+        namespace: void 0
       };
       try {
         renderComponentFramed(job.comp, job.props, job.parentScope, frame);

package/dist/signals/index.d.ts

@@ -1,4 +1,4 @@
-/** Experimental scoped signals. This entry does not import a renderer. */
+/** Stable scoped signals. This entry does not import a renderer. */
 export { createScope } from './engine.js';
 export { query } from './requests.js';
 export { ScopeDisposedError, SignalCycleError, SignalFrameError, SignalSerializationError, SignalWriteError, } from './errors.js';

package/dist/signals/types.d.ts

@@ -1,4 +1,4 @@
-/** Nominal marker for the experimental native signal API; it has no runtime payload. */
+/** Nominal marker for the native signal API; it has no runtime payload. */
 export declare const SIGNAL_HANDLE: unique symbol;
 export declare const QUERY_REQUEST: unique symbol;
 export type ConnectionState = 'none' | 'connecting' | 'open' | 'closed';

package/dist/universal-core.js

@@ -779,6 +779,7 @@ function draftOwner(record, parent, replayPath) {
     componentRevision: record.componentRevision,
     parent,
     replayPath,
+    priorClaimedSibling: parent?.children[parent.children.length - 1] ?? null,
     hooks: new Map(record.hooks),
     clonedHooks: /* @__PURE__ */ new Set(),
     seenEffects: [],
@@ -788,7 +789,6 @@ function draftOwner(record, parent, replayPath) {
     sequentialClaimCursor: 0,
     childOwnerBuckets: null,
     childClaimCursors: null,
-    childReplayOrdinals: null,
     contextValues: record.contextValues === null ? null : new Map(record.contextValues),
     appliedUpdates: /* @__PURE__ */ new Map(),
     needsRender: false,
@@ -802,11 +802,25 @@ function draftOwner(record, parent, replayPath) {
     contextStable: null
   };
 }
-function childReplayPath(parent, component, identityPath, key) {
-  const ordinals = parent.childReplayOrdinals ??= createOwnerIdentityIndex();
-  const ordinal = readOwnerIdentity(ordinals, component, identityPath, key) ?? 0;
-  writeOwnerIdentity(ordinals, component, identityPath, key, ordinal + 1);
-  return [...parent.replayPath, { component, identityPath, key, ordinal }];
+function ownerReplayPath(owner) {
+  if (owner.replayPath !== null) return owner.replayPath;
+  const record = owner.record;
+  let ordinal = 0;
+  for (let sibling = owner.priorClaimedSibling; sibling !== null; sibling = sibling.priorClaimedSibling) {
+    const previous = sibling.record;
+    if (previous.component === record.component && Object.is(previous.key, record.key) && identityPathsEqual(previous.identityPath, record.identityPath)) {
+      ordinal++;
+    }
+  }
+  return owner.replayPath = [
+    ...ownerReplayPath(owner.parent),
+    {
+      component: record.component,
+      identityPath: record.identityPath,
+      key: record.key,
+      ordinal
+    }
+  ];
 }
 function childOwnerBucket(parent, component, identityPath, key) {
   let buckets = parent.childOwnerBuckets;
@@ -859,7 +873,7 @@ function findClaimableChildRecord(parent, component, identityPath, key) {
 function adoptChildOwner(parent, record, component, identityPath, key) {
   const attempt = currentAttempt();
   parent.claimedChildren.add(record);
-  const draft = draftOwner(record, parent, childReplayPath(parent, component, identityPath, key));
+  const draft = draftOwner(record, parent, null);
   parent.children.push(draft);
   attempt.owners.push(draft);
   return draft;
@@ -944,14 +958,13 @@ function executeOwner(owner, build, initialRenderCount = 0) {
   for (let renderCount = initialRenderCount; ; renderCount++) {
     ACTIVE_UNIVERSAL_WARM_PLANS.length = warmPlanCheckpoint;
     if (renderCount === 25) throw new Error("Too many universal render-phase updates.");
-    if (renderCount > 0) resetDraftChildren(owner);
-    owner.seenEffects = [];
-    owner.children = [];
+    if (renderCount > 0) {
+      resetDraftChildren(owner);
+      owner.seenEffects = [];
+    }
     owner.retainedChildren = null;
-    owner.claimedChildren = /* @__PURE__ */ new Set();
     owner.sequentialClaimCursor = 0;
     owner.childClaimCursors = null;
-    owner.childReplayOrdinals = null;
     owner.contextStable = null;
     owner.needsRender = false;
     owner.implicitSlot = 0;
@@ -1135,7 +1148,6 @@ function resetDraftChildren(owner) {
   owner.claimedChildren = /* @__PURE__ */ new Set();
   owner.sequentialClaimCursor = 0;
   owner.childClaimCursors = null;
-  owner.childReplayOrdinals = null;
 }
 function retainCommittedOwnerTree(owner) {
   owner.hooks = new Map(owner.record.hooks);
@@ -1146,13 +1158,8 @@ function retainCommittedOwnerTree(owner) {
   owner.claimedChildren = new Set(owner.record.children);
   owner.sequentialClaimCursor = 0;
   owner.childClaimCursors = null;
-  owner.childReplayOrdinals = null;
   for (const childRecord of owner.record.children) {
-    const child = draftOwner(
-      childRecord,
-      owner,
-      childReplayPath(owner, childRecord.component, childRecord.identityPath, childRecord.key)
-    );
+    const child = draftOwner(childRecord, owner, null);
     owner.children.push(child);
     currentAttempt().owners.push(child);
     retainCommittedOwnerTree(child);
@@ -1229,11 +1236,7 @@ function retainCommittedTryArm(owner) {
   const range = findLogicalRange(owner.record.root.rootRecordForRetention(), childRecord.rangeKey);
   if (range === null) return null;
   resetDraftChildren(owner);
-  const child = draftOwner(
-    childRecord,
-    owner,
-    childReplayPath(owner, childRecord.component, childRecord.identityPath, childRecord.key)
-  );
+  const child = draftOwner(childRecord, owner, null);
   owner.children.push(child);
   owner.claimedChildren.add(childRecord);
   currentAttempt().owners.push(child);
@@ -1250,6 +1253,7 @@ function retainCommittedActivity(owner) {
   const range = record.mounted ? record.range ?? findLogicalRange(attempt.root.rootRecordForRetention(), record.rangeKey) : null;
   resetDraftChildren(owner);
   const retained = draftOwner(record, parent, owner.replayPath);
+  retained.priorClaimedSibling = owner.priorClaimedSibling;
   retained.visibility = owner.visibility;
   retained.canHandleSuspense = owner.canHandleSuspense;
   retained.boundaryThenable = owner.boundaryThenable;
@@ -2779,7 +2783,7 @@ function isThenable(value) {
 function findSuspendedMemo(owner, slot, deps) {
   if (deps === null) return null;
   for (const entry of currentAttempt().replayEntries) {
-    if (Object.is(entry.slot, slot) && depsEqual(entry.deps, deps) && suspendedOwnerPathEqual(entry.ownerPath, owner.replayPath)) {
+    if (Object.is(entry.slot, slot) && depsEqual(entry.deps, deps) && suspendedOwnerPathEqual(entry.ownerPath, ownerReplayPath(owner))) {
       return entry;
     }
   }
@@ -2794,12 +2798,12 @@ function collectSuspendedMemos(attempt) {
         continue;
       }
       if (entries.some(
-        (entry) => Object.is(entry.slot, slot) && suspendedOwnerPathEqual(entry.ownerPath, owner.replayPath)
+        (entry) => Object.is(entry.slot, slot) && suspendedOwnerPathEqual(entry.ownerPath, ownerReplayPath(owner))
       )) {
         continue;
       }
       entries.push({
-        ownerPath: owner.replayPath,
+        ownerPath: ownerReplayPath(owner),
         slot,
         deps: hook.deps,
         value: hook.value
@@ -4318,7 +4322,7 @@ function runOwnedCommit(owner, work) {
     if (!reportUniversalUncaughtError(owner.root, error)) throw error;
   }
 }
-function cloneSerializableValue(value, seen = /* @__PURE__ */ new WeakSet()) {
+function cloneSerializableValue(value, seen) {
   if (value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "bigint" || typeof value === "boolean") {
     return value;
   }
@@ -4328,6 +4332,7 @@ function cloneSerializableValue(value, seen = /* @__PURE__ */ new WeakSet()) {
   if (value.$$kind === "octane.universal.resource") {
     throw new TypeError("A resource handle must use the resource encoding branch.");
   }
+  seen ??= /* @__PURE__ */ new WeakSet();
   if (seen.has(value)) throw new TypeError("Serializable host values cannot contain cycles.");
   seen.add(value);
   try {
@@ -4503,6 +4508,7 @@ class UniversalRootImpl {
   passiveTasks = [];
   hostAttachments = null;
   collapsedTemplates = null;
+  codecResourceHandle = null;
   initializeHostAttachments() {
     const capability = this.driver.attachments;
     if (capability === void 0) return;
@@ -5083,25 +5089,24 @@ class UniversalRootImpl {
     if (codec === void 0) {
       return this.transport === null ? value : cloneSerializableValue(value);
     }
+    const createResourceHandle = this.codecResourceHandle ??= (id) => {
+      if (typeof id !== "string" && typeof id !== "number" || String(id).length === 0) {
+        throw new TypeError("A universal resource handle ID must be a non-empty string or number.");
+      }
+      return Object.freeze({
+        $$kind: "octane.universal.resource",
+        renderer: this.renderer,
+        root: this.resourceRoot,
+        id
+      });
+    };
     const result = codec.encode({
       container: this.container,
       renderer: this.renderer,
       hostType,
       name,
       value,
-      createResourceHandle: (id) => {
-        if (typeof id !== "string" && typeof id !== "number" || String(id).length === 0) {
-          throw new TypeError(
-            "A universal resource handle ID must be a non-empty string or number."
-          );
-        }
-        return Object.freeze({
-          $$kind: "octane.universal.resource",
-          renderer: this.renderer,
-          root: this.resourceRoot,
-          id
-        });
-      }
+      createResourceHandle
     });
     if (result === null || typeof result !== "object") {
       throw new TypeError(
@@ -7997,11 +8002,6 @@ class UniversalRootImpl {
         }
         if ((treeFeatures & UNIVERSAL_TREE_EVENT) !== 0) {
           const handlers = this.handlers;
-          for (const listener of previousReplacedEventListeners) {
-            EVENT_DISPATCHERS.delete(listener);
-            this.publishedListeners.delete(listener);
-            handlers.delete(listener);
-          }
           for (const listener of previousCollapsedEventListeners) {
             EVENT_DISPATCHERS.delete(listener);
             this.publishedListeners.delete(listener);
@@ -8010,14 +8010,22 @@ class UniversalRootImpl {
           for (const [record, events] of stagedEvents) {
             if (!stagedVisibleEventRecords.has(record)) continue;
             for (const event of events.values()) {
+              previousReplacedEventListeners.delete(event.listener);
               handlers.set(event.listener, event);
-              this.publishedListeners.add(event.listener);
-              EVENT_DISPATCHERS.set(
-                event.listener,
-                (payload) => this.dispatchEvent(event.listener, payload)
-              );
+              if (!this.publishedListeners.has(event.listener)) {
+                this.publishedListeners.add(event.listener);
+                EVENT_DISPATCHERS.set(
+                  event.listener,
+                  (payload) => this.dispatchEvent(event.listener, payload)
+                );
+              }
             }
           }
+          for (const listener of previousReplacedEventListeners) {
+            EVENT_DISPATCHERS.delete(listener);
+            this.publishedListeners.delete(listener);
+            handlers.delete(listener);
+          }
           for (const event of nextCollapsedEvents) {
             handlers.set(event.listener, event);
             if (!this.publishedListeners.has(event.listener)) {

package/dist/version.js

@@ -1,4 +1,4 @@
-const version = "0.2.6";
+const version = "0.2.7";
 export {
   version
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "octane",
-  "version": "0.2.6",
+  "version": "0.2.7",
   "license": "MIT",
   "type": "module",
   "sideEffects": [