@symbiote-native/svelte 3.0.3 → 3.0.5

package/build/components/virtualized-list/index.svelte

@@ -12,8 +12,7 @@
   //
   // This file authors the raw `scroll-view` intrinsic directly, and needs to: it walks an indexable
   // `plan.cells` list rather than taking an opaque children Snippet, so it can mark sticky cells
-  // itself. (There is no ScrollView component to render instead — it was deleted 2026-09-10 and an
-  // app writes the tag too.)
+  // itself. (There is no ScrollView component to render instead — an app writes the tag too.)
   //
   // It does NOT author the CONTENT node. `registerScrollViewBehavior()` puts a `buildStructure` on
   // the scroll tags, and exactly one thing may build `RCTScrollContentView` — emitting one here as

package/build/components/virtualized-section-list/index.svelte

@@ -63,12 +63,9 @@
       Platform.OS,
     ),
   );
-  // DIAGNOSTIC (2026-08-13, tracking why stickyHeaderIndices comes back undefined on Android
-  // despite the demo passing the bare `stickySectionHeadersEnabled` shorthand): the previous
-  // logging only showed the RESULT (VirtualizedList's own dlog), never the INPUTS this $derived
-  // actually read — isolated verification proved bare-shorthand forwarding through this exact
-  // two-hop generic-component chain works correctly in a standalone repro, so this must show
-  // what differs in the real component tree.
+  // Diagnostic: logs every INPUT this $derived reads, not just VirtualizedList's own result —
+  // `stickyHeaderIndices` can come back undefined on Android with the bare
+  // `stickySectionHeadersEnabled` shorthand, and only the inputs show what differs.
   $effect(() => {
     dlog(
       `VirtualizedSectionList sticky-inputs enabled=${String(props.stickySectionHeadersEnabled)} ` +

package/build/create-portal/index.js

@@ -1,9 +1,6 @@
-// Portal — the Svelte adapter's same-surface portal: the twin of React's `createPortal`
-// (adapters/react/src/create-portal/index.ts), Solid's `<Portal mount={…}>`
-// (adapters/solid/src/create-portal/index.tsx) and Angular's PortalDirective/PortalOutletDirective
-// pair. This adapter shipped `createTunnel` and no portal in any spelling until 2026-08-20; the
-// two do NOT overlap (see the table at the bottom of this header), so the tunnel was never a
-// substitute.
+// Portal — the Svelte adapter's same-surface portal: the twin of React's `createPortal`, Solid's
+// `<Portal mount={…}>` and Angular's PortalDirective/PortalOutletDirective pair. Does NOT overlap
+// with `createTunnel` (table at the bottom of this header) — the tunnel is not a substitute.
 //
 // WHY IT IS A COMPONENT (`<Portal mount={…}>`) AND NOT A CALL (`createPortal(content, target)`).
 // NOT for Solid's reason. Solid had to avoid the call form because Solid evaluates JSX eagerly at

package/build/dom-shim/animation.d.ts

@@ -0,0 +1,10 @@
+import type { ShimElement } from './element';
+export type IKeyframe = Readonly<Record<string, string>>;
+export type IShimAnimation = {
+    onfinish: (() => void) | null;
+    effect: unknown;
+    readonly playState: 'idle' | 'running' | 'finished';
+    readonly currentTime: number;
+    cancel(): void;
+};
+export declare function animateShimElement(element: ShimElement, keyframes: readonly IKeyframe[], duration: number): IShimAnimation;

package/build/dom-shim/animation.js

@@ -0,0 +1,80 @@
+// `Element.animate()`, the subset `svelte/transition`/`svelte/animate` call: Svelte's own tick
+// loop already bakes each frame's `css(t, u)` into the keyframe array, so this only replays them
+// over real time (`.currentTime`/`.playState`/`.onfinish`/`.effect`/`.cancel()` contract).
+import { isSymbioteNode, requestCommitFor, routeProp, } from '@symbiote-native/engine';
+import { areShimAnimationsEnabled } from './animations-gate.js';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+// `opacity` parses to a number, matching a real CSSStyleDeclaration read back; every other key
+// (transform, filter, ...) passes through as the authored string.
+function applyKeyframe(node, style, frame) {
+    const next = isRecord(style) ? { ...style } : {};
+    for (const [key, value] of Object.entries(frame)) {
+        next[key] = key === 'opacity' ? Number(value) : value;
+    }
+    routeProp(node, 'style', next);
+    // Our own rAF loop, not a framework render - nothing else publishes this write per frame.
+    requestCommitFor(node);
+}
+class ShimAnimation {
+    node;
+    currentStyle;
+    keyframes;
+    duration;
+    onfinish = null;
+    effect = null;
+    playState = 'idle';
+    startTime = undefined;
+    rafId = undefined;
+    cancelled = false;
+    constructor(node, currentStyle, keyframes, duration) {
+        this.node = node;
+        this.currentStyle = currentStyle;
+        this.keyframes = keyframes;
+        this.duration = duration;
+        if (node === undefined || keyframes.length === 0 || duration <= 0) {
+            this.playState = 'finished';
+            // Guarded like `tick`: a same-tick `cancel()` (Svelte replacing this animation before the
+            // microtask runs) must not fire a handler for a transition that never got to play.
+            void Promise.resolve().then(() => {
+                if (!this.cancelled)
+                    this.onfinish?.();
+            });
+            return;
+        }
+        this.playState = 'running';
+        this.rafId = requestAnimationFrame(this.tick);
+    }
+    get currentTime() {
+        return this.startTime === undefined ? 0 : Date.now() - this.startTime;
+    }
+    tick = (now) => {
+        if (this.cancelled || this.node === undefined)
+            return;
+        this.startTime ??= now;
+        const progress = Math.min((now - this.startTime) / this.duration, 1);
+        const index = Math.round(progress * (this.keyframes.length - 1));
+        const frame = this.keyframes[index];
+        if (frame !== undefined)
+            applyKeyframe(this.node, this.currentStyle, frame);
+        if (progress >= 1) {
+            this.playState = 'finished';
+            this.onfinish?.();
+            return;
+        }
+        this.rafId = requestAnimationFrame(this.tick);
+    };
+    cancel() {
+        this.cancelled = true;
+        this.playState = 'idle';
+        if (this.rafId !== undefined)
+            cancelAnimationFrame(this.rafId);
+    }
+}
+// A node not yet live plays no animation - the same shape Svelte's own dummy zero-duration
+// animation already takes, so a caller sees a normal, already-finished Animation.
+export function animateShimElement(element, keyframes, duration) {
+    const node = element.engineNode;
+    return new ShimAnimation(areShimAnimationsEnabled() && isSymbioteNode(node) ? node : undefined, element.p.style, keyframes, duration);
+}

package/build/dom-shim/animations-gate.d.ts

@@ -0,0 +1,2 @@
+export declare function setShimAnimationsEnabled(value: boolean): void;
+export declare function areShimAnimationsEnabled(): boolean;

package/build/dom-shim/animations-gate.js

@@ -0,0 +1,10 @@
+// TODO: включить, когда API стабилизируется: `animate:flip` работает, shuffle-реордер нет
+// Экран `TransitionAnimateDemo` снят с Canary, вернуть вместе с включением
+// Пока выключено для потребителя, тесты включают через `setShimAnimationsEnabled`
+let enabled = false;
+export function setShimAnimationsEnabled(value) {
+    enabled = value;
+}
+export function areShimAnimationsEnabled() {
+    return enabled;
+}

package/build/dom-shim/computed-style.d.ts

@@ -0,0 +1,3 @@
+import type { ShimElement } from './element';
+export type IComputedStyle = Readonly<Record<string, string>>;
+export declare function computedStyleOf(element: ShimElement): IComputedStyle;

package/build/dom-shim/computed-style.js

@@ -0,0 +1,34 @@
+// The bare global `getComputedStyle`, which svelte/transition's fade/fly/scale/slide/blur call
+// directly, not `document.getComputedStyle`. A Proxy, since a caller reads an arbitrary key built
+// at runtime (slide derives `paddingTop`/`marginBottom` from its `axis` option).
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+const DEFAULTS = {
+    opacity: '1',
+    transform: 'none',
+    filter: 'none',
+    display: 'flex',
+    strokeLinecap: 'butt',
+    strokeWidth: '0',
+};
+function styleValueOf(element, key) {
+    const style = element.p.style;
+    const raw = isRecord(style) ? style[key] : undefined;
+    if (raw !== undefined)
+        return typeof raw === 'number' ? `${raw}px` : String(raw);
+    // Two tokens, not `DEFAULTS`' single `'0px'` - `flip()` destructures this into [ox, oy] and
+    // divides by clientWidth/Height, so a lone token leaves oy as NaN (real default is `50% 50%`).
+    if (key === 'transformOrigin') {
+        const { width, height } = element.getBoundingClientRect();
+        return `${width / 2}px ${height / 2}px`;
+    }
+    return DEFAULTS[key] ?? '0px';
+}
+export function computedStyleOf(element) {
+    return new Proxy({}, {
+        get(_target, key) {
+            return typeof key === 'string' ? styleValueOf(element, key) : undefined;
+        },
+    });
+}

package/build/dom-shim/document.d.ts

@@ -2,6 +2,7 @@ import { ShimElement } from './element';
 import { ShimText } from './text';
 import { ShimComment } from './comment';
 import { ShimDocumentFragment } from './document-fragment';
+import { type IComputedStyle } from './computed-style';
 export declare class ShimDocument {
     readonly body: ShimElement;
     createElement(tag: string, options?: {
@@ -17,7 +18,7 @@ export declare class ShimDocument {
     importNode(node: ShimText, deep: boolean): ShimText;
     importNode(node: ShimComment, deep: boolean): ShimComment;
     importNode(node: ShimDocumentFragment, deep: boolean): ShimDocumentFragment;
-    getComputedStyle(): Record<string, never>;
+    getComputedStyle(element: ShimElement): IComputedStyle;
 }
 export declare function getShimDocument(): ShimDocument;
 export declare function resetShimDocumentForTests(): void;

package/build/dom-shim/document.js

@@ -1,14 +1,12 @@
-// The shim's `document` singleton — the six factories `init_operations()` and `from_tree`
-// require (svelte-adapter-dom-shim skill §3b), plus the two cheap stubs §4 calls for
-// explicitly (`document.body`, `getComputedStyle`) so a forbidden/dead path degrades to a
-// harmless no-op instead of a hard crash. No `<svelte:head|window|body|document>` support
-// beyond that stub — those tags are rejected at build time by the preprocessor (§7), not
-// handled here.
+// The shim's `document` singleton - the six factories `init_operations()`/`from_tree` require,
+// plus `document.body` (a minimal unattached node) and `getComputedStyle` (computed-style.ts).
+// No `<svelte:head|window|body|document>` - rejected at build time by the preprocessor.
 import { ShimElement } from './element.js';
 import { ShimText } from './text.js';
 import { ShimComment } from './comment.js';
 import { ShimDocumentFragment } from './document-fragment.js';
 import { registerShimDocumentFactory } from './shim-node.js';
+import { computedStyleOf } from './computed-style.js';
 export class ShimDocument {
     // The delegation root real Svelte events bubble toward (`dom/elements/events.js:122`).
     // Our own event names never delegate (§5c: no camelCase name matches Svelte's 23-name
@@ -39,11 +37,10 @@ export class ShimDocument {
     importNode(node, deep) {
         return node.cloneNode(deep);
     }
-    // §4: not read by any mandatory path; stubbed so a forbidden transition (which we reject
-    // at build time anyway, §7) degrades to an inert value rather than a hard crash if it is
-    // ever reached some other way.
-    getComputedStyle() {
-        return {};
+    // Kept in step with the bare global patch-globals.ts installs (computed-style.ts is the one
+    // implementation both call).
+    getComputedStyle(element) {
+        return computedStyleOf(element);
     }
 }
 let singleton;

package/build/dom-shim/element.d.ts

@@ -1,4 +1,5 @@
-import { type ISymbioteNode } from '@symbiote-native/engine';
+import { type IDomRect, type ISymbioteNode } from '@symbiote-native/engine';
+import { type IKeyframe, type IShimAnimation } from './animation';
 import { ShimNode } from './shim-node';
 export type IShimPropBag = Record<string, unknown>;
 export declare abstract class ShimElementBase extends ShimNode {
@@ -30,6 +31,19 @@ export declare class ShimElement extends ShimElementBase {
     addEventListener(name: string, handler: (event: unknown) => void): void;
     removeEventListener(name: string): void;
     cloneNode(deep?: boolean): ShimElement;
+    get parentElement(): ShimElement | null;
+    get clientWidth(): number;
+    get clientHeight(): number;
+    getBoundingClientRect(): IDomRect & {
+        top: number;
+        left: number;
+        right: number;
+        bottom: number;
+    };
+    dispatchEvent(): boolean;
+    animate(keyframes: readonly IKeyframe[], options: {
+        duration: number;
+    }): IShimAnimation;
     createEngineNode(): ISymbioteNode;
     onMadeLive(): void;
 }

package/build/dom-shim/element.js

@@ -22,9 +22,11 @@
 // A per-key diff in the setter is MANDATORY (§3g(c)), not an optimization: Svelte's
 // `set_custom_element_data` has no early-out guard and runs on every effect re-fire, so
 // without the diff every prop gets rewritten whenever any one of them changes.
-import { createElement, dlog, routeProp, toPublicInstance, } from '@symbiote-native/engine';
+import { createElement, dlog, getBoundingClientRect, isSymbioteNode, routeProp, toPublicInstance, } from '@symbiote-native/engine';
 import { descriptorFor } from '@symbiote-native/components';
 import { normalizeSvelteClass } from '../class-value.js';
+import { animateShimElement, } from './animation.js';
+import { areShimAnimationsEnabled } from './animations-gate.js';
 import { BOOLEAN_PROP_NAMES, CANONICAL_BY_LOWER, CANONICAL_PROP_NAMES, } from './canonical-prop-names.js';
 import { ShimNode } from './shim-node.js';
 import { discoverStyleCacheKey } from './style-cache.js';
@@ -251,6 +253,48 @@ export class ShimElement extends ShimElementBase {
         }
         return clone;
     }
+    // `flip`'s `get_zoom()` walks this until `null`; without it the walk hit `undefined` and threw
+    // `Cannot read properties of undefined ('parentElement')`, aborting the whole reorder.
+    get parentElement() {
+        const result = this.parent instanceof ShimElement ? this.parent : null;
+        dlog(`parentElement tag=${this.tagName} -> ${result === null ? 'null' : result.tagName}`);
+        return result;
+    }
+    // `flip` divides by these for its scale factor; unset they read as `NaN`, not zero.
+    get clientWidth() {
+        return this.getBoundingClientRect().width;
+    }
+    get clientHeight() {
+        return this.getBoundingClientRect().height;
+    }
+    // Real DOM shape (top/left/right/bottom derived), for svelte/animate's `flip` and
+    // svelte/transition's `crossfade`, both of which measure before and after a reorder.
+    getBoundingClientRect() {
+        const node = this.engineNode;
+        const rect = areShimAnimationsEnabled() && isSymbioteNode(node)
+            ? getBoundingClientRect(node, false)
+            : undefined;
+        dlog(`getBoundingClientRect tag=${this.tagName} hasNode=${isSymbioteNode(node)} rect=${JSON.stringify(rect)}`);
+        const { x, y, width, height } = rect ?? { x: 0, y: 0, width: 0, height: 0 };
+        return {
+            x,
+            y,
+            width,
+            height,
+            top: y,
+            left: x,
+            right: x + width,
+            bottom: y + height,
+        };
+    }
+    // `transitions.js`'s `dispatch_event` fires introstart/introend/outrostart/outroend at this;
+    // nothing in this adapter listens, so a no-op is the correct answer, not a missing method.
+    dispatchEvent() {
+        return true;
+    }
+    animate(keyframes, options) {
+        return animateShimElement(this, keyframes, options.duration);
+    }
     // measure/measureInWindow/measureLayout/setNativeProps/focus/blur — the imperative API a
     // `bind:this` host ref hands back — ride on the engine node's prototype, so toPublicInstance is
     // the identity and this reads the same as Vue's renderer (renderer/index.ts) and React's

package/build/dom-shim/patch-globals.js

@@ -2,9 +2,8 @@
 // (svelte-adapter-dom-shim skill §2, §3a, §6). Must run before `mount()` (§3f) — not
 // necessarily before `svelte` is imported.
 //
-// Single-root only, by design (§10, decided during Svelte adapter planning 2026-08-11): one
-// Symbiote app = one process = one Svelte root, so `restoreGlobals()` needs no ref-counting —
-// `unmount()` calls it unconditionally.
+// Single-root only, by design (§10): one Symbiote app = one process = one Svelte root, so
+// `restoreGlobals()` needs no ref-counting — `unmount()` calls it unconditionally.
 //
 // Deliberately NOT patched, and must stay that way (§6b, §6c, §6d) — both verified against the
 // real vendored RN source (.vendors/react-native/packages/react-native/Libraries/Core/), not
@@ -30,6 +29,7 @@ import { ShimComment } from './comment.js';
 import { ShimDocumentFragment } from './document-fragment.js';
 import { ShimNode } from './shim-node.js';
 import { getShimDocument } from './document.js';
+import { computedStyleOf } from './computed-style.js';
 const PATCHED_KEYS = [
     'Node',
     'Element',
@@ -41,7 +41,36 @@ const PATCHED_KEYS = [
     'document',
     'customElements',
     'HTMLMediaElement',
+    'getComputedStyle',
+    'CustomEvent',
 ];
+// `svelte/transition`'s fade/fly/scale/slide/blur call this BARE global, not
+// `document.getComputedStyle`, so it must be a real assigned property too.
+function getComputedStyleGlobal(element) {
+    return element instanceof ShimElement
+        ? computedStyleOf(element)
+        : computedStyleOf(new ShimElement('view'));
+}
+// `createEventDispatcher`'s own event object; `svelte/events`'s `on()` also constructs one.
+// RN installs no CustomEvent of its own, so this must be a real assigned property, matching the
+// same class of trap as `customElements`/`HTMLMediaElement` below.
+class FakeCustomEvent {
+    type;
+    detail;
+    bubbles;
+    cancelable;
+    defaultPrevented = false;
+    constructor(type, options) {
+        this.type = type;
+        this.detail = options?.detail;
+        this.bubbles = options?.bubbles ?? false;
+        this.cancelable = options?.cancelable ?? false;
+    }
+    preventDefault() {
+        if (this.cancelable)
+            this.defaultPrevented = true;
+    }
+}
 // Real DOM's `CustomElementRegistry`. `set_custom_element_data` (svelte's
 // dom/elements/attributes.js) reads the BARE global `customElements` unconditionally, with no
 // `typeof` guard — an undeclared global throws ReferenceError, not just `undefined`, so this
@@ -51,20 +80,9 @@ const PATCHED_KEYS = [
 // with (unlike `navigator`/`requestAnimationFrame`, verified against .vendors/react-native —
 // see the header comment above), so patching this is safe.
 //
-// `get()` returns a TRUTHY stand-in, and that is the whole reason `set_custom_element_data` can be
-// made lossless. Its condition (attributes.js:245-265) is a ternary, not a fallback:
-//
-//   setters_cache.has(nodeName) || !customElements || customElements.get(nodeName)
-//     ? get_setters(node).includes(prop)     <- a real setter decides; the value passes through
-//     : value && typeof value === 'object'   <- a HEURISTIC: an object is set as a property and
-//                                               every scalar is handed on as String(value)
-//
-// Returning `undefined` — which it did until 2026-09-07 — selects the heuristic, so
-// `<text-input multiline={false}>` committed the STRING "false" and an object-valued prop with no
-// prototype setter was assigned to a plain JS property and silently lost. Anything truthy steers
-// it to `get_setters`, which reaches `ShimElement.prototype`'s accessors (see
-// `svelte-shim-element-global-must-be-an-ancestor.md` for why that walk terminates where it does).
-// One reader in the whole client runtime, so nothing else is affected.
+// `get()` returns a TRUTHY stand-in — the whole reason `set_custom_element_data` stays lossless.
+// Falsy selects attributes.js's HEURISTIC path instead of `get_setters`: it stringifies scalars
+// and drops any object-valued prop with no prototype setter.
 const FAKE_CUSTOM_ELEMENT_REGISTRY = {
     get: () => ShimElement,
 };
@@ -93,6 +111,8 @@ export function patchGlobals() {
         document: g.document,
         customElements: g.customElements,
         HTMLMediaElement: g.HTMLMediaElement,
+        getComputedStyle: g.getComputedStyle,
+        CustomEvent: g.CustomEvent,
     };
     g.Node = ShimNode;
     // ShimElementBase, NOT ShimElement: `get_setters` stops AT `Element.prototype`, so pointing this
@@ -109,6 +129,8 @@ export function patchGlobals() {
     g.document = getShimDocument();
     g.customElements = FAKE_CUSTOM_ELEMENT_REGISTRY;
     g.HTMLMediaElement = FakeHTMLMediaElement;
+    g.getComputedStyle = getComputedStyleGlobal;
+    g.CustomEvent = FakeCustomEvent;
     dlog('svelte dom-shim: patchGlobals installed');
 }
 export function restoreGlobals() {

package/build/index.js

@@ -4,11 +4,9 @@
 // All Fabric clone-on-write lives in the engine, shared cross-adapter. App code names only
 // @symbiote-native/svelte.
 //
-// Full component parity with React/Vue/Angular landed 2026-08-11 (svelte-adapter-dom-shim
-// skill §15): every `core/components` render function has a fixed tree shape, so no
-// `descriptorToSvelte` bridge was ever needed — each component below is hand-authored Svelte
-// markup mirroring its render-*.ts, reusing only the pure state/render logic. See skill §17/§18
-// for the one open async-exception repro and the honest cross-cutting gap list.
+// Full component parity with React/Vue/Angular (svelte-adapter-dom-shim skill §15): every
+// `core/components` render function has a fixed tree shape, so no `descriptorToSvelte` bridge is
+// needed — each component below is hand-authored Svelte markup mirroring its render-*.ts.
 // Bare side-effect import, deliberately NOT a re-export and deliberately not beside one of the
 // same specifier: it registers the press behavior with the engine's host-behavior registry. Any
 // other shape is dropped by Metro's inlineRequires in a release build — see register.ts.
@@ -25,9 +23,8 @@ export { KeyboardAvoidingView, Modal, VirtualizedList, FlatList, VirtualizedSect
 // threaded through this barrel (parity fix, see React's index.ts lines 55-58, 89, 245-250).
 export { setImageSourceResolver } from '@symbiote-native/components';
 // Pure, framework-agnostic runtime modules — same re-export every other adapter does per
-// CLAUDE.md's <runtime_modules_layering>. PanResponder was missing here (present on
-// React/Vue's own barrels) until 2026-08-12 — a pure engine re-export, no framework glue, so
-// adding it is a one-line parity fix, not new adapter work.
+// CLAUDE.md's <runtime_modules_layering>. A pure engine re-export with no framework glue, so
+// adding one is a one-line parity fix, not new adapter work.
 export { Platform, StyleSheet, PlatformColor, DynamicColorIOS, processColor, setNativeViewConfigSource, setColorProcessor, setDeviceEventSource, PixelRatio, PanResponder, dlog, isDebug, } from '@symbiote-native/engine';
 // The two namespaces left behind by primitives that became tags, here rather than in the component
 // block above for one reason: they carry no view. `Image` gets an adapter file only because it

package/build/modules/animated/index.js

@@ -9,10 +9,9 @@
 // between the value graph and the node's Fabric tag, and both of those were already engine-side.
 //
 // Those three were aliases of the wrappers, and the wrappers are gone — a primitive is a tag now,
-// which is not a value `<Animated.X>` can call. `Animated.ScrollView` left the same way on
-// 2026-09-10: `bindAnimatedEvent` (node.ts, from `setEventListener`) attaches a native-driven event
-// on ANY host node, which was the one job a scroll wrapper still looked like it had. The whole API
-// is `<scroll-view style={{ opacity: v }} p={{ onScroll: Animated.event(…) }}>`.
+// which is not a value `<Animated.X>` can call. `Animated.ScrollView` left the same way:
+// `bindAnimatedEvent` (node.ts) attaches a native-driven event on ANY host node.
+// The whole API is `<scroll-view style={{ opacity: v }} p={{ onScroll: Animated.event(…) }}>`.
 //
 // The two below REMAIN because the LIST family is tier 3: a render prop decides their output shape
 // in JS, so there is no tag for `<Animated.X>` to be an alias of.

package/build/preprocessor/collapse-text-whitespace.js

@@ -1,11 +1,8 @@
 // svelte-adapter-dom-shim skill §16: Svelte trims only the leading/trailing whitespace of a
 // fragment's own children - never whitespace INSIDE a single Text node, and never a
-// whitespace-only Text node BETWEEN two siblings. Vue's compiler (and every browser) collapses
-// both; Svelte doesn't. Confirmed against the real compiler (2026-08-17): a Text node authored
-// as `Hello world, this is a\n  long sentence.` compiles verbatim into
-// `$.text('Hello world, this is a\n  long sentence.')` - the newline and indent ship into the
-// native text content and render as a forced line break plus stray leading spaces on device.
-// Reproduced live on an iOS simulator before this file existed; fixed with it registered.
+// whitespace-only Text node BETWEEN two siblings. Vue's compiler (and every browser) collapse both.
+// A Text node authored as `Hello world, this is a\n  long sentence.` compiles verbatim, so the
+// newline and indent ship into native text as a forced line break plus stray leading spaces.
 //
 // Two hazards:
 //   1. Wrapped sentence - a Text node with real content plus an embedded whitespace run

package/build/preprocessor/forbid-web-only-constructs.js

@@ -1,4 +1,4 @@
-// §7 of svelte-adapter-dom-shim (DECIDED 2026-08-11): the constructs that compile cleanly and
+// §7 of svelte-adapter-dom-shim: the constructs that compile cleanly and
 // then silently do nothing under the DOM shim. Everything else in the original §4 table is
 // already closed by "app code can't reach it" or "the TS/Svelte compiler already errors on it for
 // free" (see the skill for the full reachability table). This preprocessor is the guard for what

package/build/preprocessor/scoped-styles.js

@@ -127,13 +127,11 @@ export function scopedStyles() {
 // ---------------------------------------------------------------------------------------------
 // The <style> block, located WITHOUT parsing it.
 //
-// This is svelte's own tag regex (src/compiler/preprocess/index.js), which is what its official
-// `preprocess()` style hook uses to hand a block's content to a preprocessor unparsed — and the
-// reason `svelte-preprocess` can compile SCSS at all. Reading `parse().css` instead, as this file
-// did until 2026-08-20, validates the block as CSS whatever `lang` says: `<style lang="scss">$pad:
-// 7px;</style>` threw `css_expected_identifier` before the language table above was ever
-// consulted, so only SCSS that is already valid CSS (nesting) survived. A `<!-- -->` comment is an
-// alternative of the pattern purely so a commented-out block is skipped rather than matched.
+// This is svelte's own tag regex (src/compiler/preprocess/index.js): what its official
+// `preprocess()` style hook uses to hand a block's content unparsed, the reason `svelte-preprocess`
+// can compile SCSS at all — `parse().css` would validate it as CSS whatever `lang` says.
+// A `<!-- -->` comment is an alternative of the pattern purely so a commented-out block is
+// skipped rather than matched.
 const STYLE_TAG_PATTERN = /<!--[^]*?-->|<style((?:\s+[^=>'"/\s]+=(?:"[^"]*"|'[^']*'|[^>\s]+)|\s+[^=>'"/\s]+)*\s*)(?:\/>|>([\S\s]*?)<\/style>)/g;
 const LANG_ATTRIBUTE_PATTERN = /\blang\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+))/;
 function findStyleBlock(content) {

package/build/render.js

@@ -1,7 +1,7 @@
 // Mount a Svelte app onto a Fabric surface. The native host hands us a rootTag; we create a
 // surface for it, install the DOM shim, and let stock compiled Svelte output drive it while
-// believing it is talking to the real DOM. Decided during Svelte adapter planning
-// (2026-08-11, svelte-adapter-dom-shim skill §10): single root per process, so
+// believing it is talking to the real DOM.
+// Single root per process (svelte-adapter-dom-shim skill §10), so
 // patchGlobals()/restoreGlobals() need no ref-counting.
 import { mount as svelteMount, unmount as svelteUnmount, } from 'svelte';
 import { createSurface, disposeRoot, dlog, reportUncaughtError, } from '@symbiote-native/engine';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@symbiote-native/svelte",
-  "version": "3.0.3",
+  "version": "3.0.5",
   "description": "SymbioteNative's Svelte adapter — a DOM shim over stock compiled Svelte output driving real native iOS/Android views through the same engine as every other adapter.",
   "keywords": [
     "react-native",
@@ -73,22 +73,22 @@
   },
   "dependencies": {
     "typescript": "~6.0.0",
-    "@symbiote-native/components": "3.1.1",
-    "@symbiote-native/css-parser": "0.5.1"
+    "@symbiote-native/components": "3.1.3",
+    "@symbiote-native/css-parser": "0.5.2"
   },
   "peerDependencies": {
     "svelte": ">=5.56.0",
     "react-native": ">=0.86",
-    "@symbiote-native/engine": "^1.3.0"
+    "@symbiote-native/engine": "^1.4.0"
   },
   "devDependencies": {
     "@vue/runtime-core": "^3.5.13",
     "react": "19.2.3",
     "svelte": "^5.56.0",
-    "@symbiote-native/engine": "1.3.0",
-    "@symbiote-native/react": "3.0.3",
-    "@symbiote-native/test-utils": "0.4.3",
-    "@symbiote-native/vue": "3.0.3"
+    "@symbiote-native/engine": "1.4.0",
+    "@symbiote-native/test-utils": "0.4.5",
+    "@symbiote-native/react": "3.1.0",
+    "@symbiote-native/vue": "3.1.0"
   },
   "scripts": {
     "typecheck": "tsc --build",