@symbiote-native/svelte 0.1.0

package/build/descriptor-to-svelte.js

@@ -0,0 +1,104 @@
+// A generic Descriptor -> shim-tree bridge, the Svelte twin of React's descriptorToReact /
+// Vue's descriptorToVue — but SHAPE-STABLE rather than a walker that rebuilds on every call.
+// React/Vue can afford a plain recursive `createElement`/`h()` walk because their OWN
+// reconciler (outside this function) diffs the result against the previous render and reuses
+// DOM nodes by identity; Svelte has no such external reconciler for an externally-built tree,
+// so building fresh nodes on every call would mean recreating (not updating) the underlying
+// Fabric/native view on every reactive change — expensive, and it would break any imperative
+// command / native-owned state (focus, `dispatchViewCommand`) tied to the old node's identity.
+//
+// This works ONLY because every `core/components/src/view/render-*.ts` produces a Descriptor
+// tree of CONSTANT shape across renders (svelte-adapter-dom-shim skill §15) — only prop VALUES
+// vary. So: build each node ONCE (`mountDescriptorChildren`), cache it by tree position, and on
+// every `update()` just re-set `.p`/`.data` on the SAME already-live shim nodes — never
+// removeChild+recreate. See skill §19 for the full design rationale, the wolf-tui precedent
+// this diverges from, and why the naive "rebuild the whole subtree" approach was rejected.
+//
+// A shape change (different type, different child count, text where an element was) throws
+// rather than silently falling back to some best-effort behavior: it means a render-*.ts
+// function's actual output changed shape, which this bridge's whole cost-free model assumes
+// never happens. If this ever fires for real, the render fn genuinely stopped being
+// shape-stable and needs its own fix, not a workaround here.
+import { getShimDocument } from './dom-shim/index.js';
+function shapeChangedMessage(detail) {
+    return (`descriptorToSvelte: Descriptor shape changed between renders (${detail}) — a ` +
+        `render-*.ts fn is expected to produce a CONSTANT tree shape (svelte-adapter-dom-shim ` +
+        `skill §15/§19); only prop values may vary between calls.`);
+}
+function buildChild(child) {
+    const document = getShimDocument();
+    if (typeof child === 'string') {
+        return { kind: 'text', shim: document.createTextNode(child) };
+    }
+    const shim = document.createElement(child.type);
+    shim.p = child.props;
+    const children = child.children.map(grandchild => {
+        const cached = buildChild(grandchild);
+        shim.appendChild(cached.shim);
+        return cached;
+    });
+    return { kind: 'element', shim, children };
+}
+function syncChild(cached, child) {
+    if (typeof child === 'string') {
+        if (cached.kind !== 'text')
+            throw new Error(shapeChangedMessage('text/element'));
+        if (cached.shim.data !== child)
+            cached.shim.data = child;
+        return;
+    }
+    if (cached.kind !== 'element' || cached.shim.tagName !== child.type) {
+        const was = cached.kind === 'element' ? cached.shim.tagName : 'text';
+        throw new Error(shapeChangedMessage(`${was} -> ${child.type}`));
+    }
+    cached.shim.p = child.props;
+    if (cached.children.length !== child.children.length) {
+        throw new Error(shapeChangedMessage('child count'));
+    }
+    cached.children.forEach((c, index) => syncChild(c, child.children[index]));
+}
+// Materializes `descriptor.children` onto an already-live `parent` ONCE, then reuses the same
+// shim nodes by position on every `update()`. `parent` is expected to already be live (has an
+// `engineNode`) — the normal case, since it is reached via a component's own `bind:this`
+// inside an `$effect` that runs after mount, matching every other imperative-command use in
+// this adapter (Switch's snap-back, TextInput's controlled write).
+export function mountDescriptorChildren(parent, children) {
+    const cached = children.map(child => {
+        const built = buildChild(child);
+        parent.appendChild(built.shim);
+        return built;
+    });
+    return {
+        update(next) {
+            if (cached.length !== next.length)
+                throw new Error(shapeChangedMessage('root child count'));
+            cached.forEach((c, index) => syncChild(c, next[index]));
+        },
+    };
+}
+// The uniform wiring every category-1 component repeats: mount `mountDescriptorChildren` once
+// (as soon as the root shim is live) and update() it thereafter — the "call the bridge" half of
+// React's `descriptorToReact(useXLogic(...))` / Vue's `descriptorToVue(...)`. Root tags with an
+// empty `children` array (Switch, TextInput — every prop rides the root's own `p`) still call
+// this, for the SAME reason React still routes them through `descriptorToReact`: one uniform
+// shape for every category-1 component, not two different idioms picked by child count. Usage:
+//
+//   const syncChildren = createDescriptorChildrenSync();
+//   $effect(() => { syncChildren(hostShim, descriptor.children); });
+//
+// `hostShim` and `descriptor.children` are read unconditionally at the top of the effect body —
+// same dependency-tracking discipline as every other $effect in this adapter (skill's TextInput
+// note): a guard placed before the read would drop it from the tracked set on a guarded run.
+export function createDescriptorChildrenSync() {
+    let mounted;
+    return (hostShim, children) => {
+        if (hostShim === null)
+            return;
+        if (mounted === undefined) {
+            mounted = mountDescriptorChildren(hostShim, children);
+        }
+        else {
+            mounted.update(children);
+        }
+    };
+}

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

@@ -0,0 +1,9 @@
+import { type ISymbioteNode } from '@symbiote-native/engine';
+import { ShimNode } from './shim-node';
+export declare class ShimComment extends ShimNode {
+    data: string;
+    constructor(data: string);
+    get nodeName(): string;
+    cloneNode(deep?: boolean): ShimComment;
+    createEngineNode(): ISymbioteNode;
+}

package/build/dom-shim/comment.js

@@ -0,0 +1,24 @@
+// A comment — the anchor path (svelte-adapter-dom-shim skill §3e, §9). Maps to the engine's
+// createAnchor: a real retained node so insert/nextSibling ordering stays correct, but the
+// commit walk skips it (core/engine/src/node.ts's ANCHOR_COMPONENT) — no native view is ever
+// created for it. Unlike text/element, `data` carries no engine-visible meaning; Svelte never
+// reads a comment's content on any mandatory path, only its position in the tree.
+import { createAnchor } from '@symbiote-native/engine';
+import { ShimNode } from './shim-node.js';
+export class ShimComment extends ShimNode {
+    data;
+    constructor(data) {
+        super();
+        this.data = data;
+    }
+    get nodeName() {
+        return '#comment';
+    }
+    cloneNode(deep) {
+        void deep; // DOM signature parity only — a comment node has no children to deep-clone
+        return new ShimComment(this.data);
+    }
+    createEngineNode() {
+        return createAnchor();
+    }
+}

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

@@ -0,0 +1,8 @@
+import type { ISymbioteNode } from '@symbiote-native/engine';
+import { ShimNode } from './shim-node';
+export declare class ShimDocumentFragment extends ShimNode {
+    readonly isDocumentFragment = true;
+    get nodeName(): string;
+    cloneNode(deep?: boolean): ShimDocumentFragment;
+    createEngineNode(): ISymbioteNode;
+}

package/build/dom-shim/document-fragment.js

@@ -0,0 +1,23 @@
+// A document fragment: never itself carries an engine node — inserting a fragment inserts
+// its CHILDREN and leaves it empty (the DOM rule `ShimNode`'s `normalizeInsertable` depends
+// on). Allocated per template build and on every `{#each}`/`{#if}`/`<svelte:boundary>` update
+// (svelte-adapter-dom-shim skill §3e) — must stay cheap.
+import { ShimNode } from './shim-node.js';
+export class ShimDocumentFragment extends ShimNode {
+    isDocumentFragment = true;
+    get nodeName() {
+        return '#document-fragment';
+    }
+    cloneNode(deep) {
+        const clone = new ShimDocumentFragment();
+        if (deep === true) {
+            for (const child of this.children)
+                clone.appendChild(child.cloneNode(true));
+        }
+        return clone;
+    }
+    createEngineNode() {
+        throw new Error('ShimDocumentFragment must never be inserted directly — normalizeInsertable() ' +
+            'should have unwrapped it into its children first');
+    }
+}

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

@@ -0,0 +1,23 @@
+import { ShimElement } from './element';
+import { ShimText } from './text';
+import { ShimComment } from './comment';
+import { ShimDocumentFragment } from './document-fragment';
+export declare class ShimDocument {
+    readonly body: ShimElement;
+    createElement(tag: string, options?: {
+        is?: string;
+    }): ShimElement;
+    createElementNS(namespace: string, tag: string, options?: {
+        is?: string;
+    }): ShimElement;
+    createTextNode(value: string): ShimText;
+    createDocumentFragment(): ShimDocumentFragment;
+    createComment(data: string): ShimComment;
+    importNode(node: ShimElement, deep: boolean): ShimElement;
+    importNode(node: ShimText, deep: boolean): ShimText;
+    importNode(node: ShimComment, deep: boolean): ShimComment;
+    importNode(node: ShimDocumentFragment, deep: boolean): ShimDocumentFragment;
+    getComputedStyle(): Record<string, never>;
+}
+export declare function getShimDocument(): ShimDocument;
+export declare function resetShimDocumentForTests(): void;

package/build/dom-shim/document.js

@@ -0,0 +1,61 @@
+// 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.
+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';
+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
+    // DELEGATED_EVENTS list), but a minimal, unattached node converts any stray read into a
+    // no-op instead of a crash — one line, per §4's "provide a stub anyway" call.
+    body = new ShimElement('symbiote-view');
+    createElement(tag, options) {
+        const element = new ShimElement(tag);
+        if (options?.is !== undefined)
+            element.setAttribute('is', options.is);
+        return element;
+    }
+    createElementNS(namespace, tag, options) {
+        const element = new ShimElement(tag, namespace);
+        if (options?.is !== undefined)
+            element.setAttribute('is', options.is);
+        return element;
+    }
+    createTextNode(value) {
+        return new ShimText(value);
+    }
+    createDocumentFragment() {
+        return new ShimDocumentFragment();
+    }
+    createComment(data) {
+        return new ShimComment(data);
+    }
+    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 {};
+    }
+}
+let singleton;
+export function getShimDocument() {
+    singleton ??= new ShimDocument();
+    return singleton;
+}
+// Exercised only by tests / restoreGlobals bookkeeping — production code always goes through
+// getShimDocument() so the singleton survives a mount/unmount cycle within one process.
+export function resetShimDocumentForTests() {
+    singleton = undefined;
+}
+// Plugs this module into ShimNode's `ownerDocument`/`textContent` (see shim-node.ts's header
+// comment for why the dependency runs this direction and not the reverse).
+registerShimDocumentFactory(getShimDocument);

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

@@ -0,0 +1,22 @@
+import { type ISymbioteNode } from '@symbiote-native/engine';
+import { ShimNode } from './shim-node';
+export type IShimPropBag = Record<string, unknown>;
+export declare class ShimElement extends ShimNode {
+    readonly tagName: string;
+    readonly namespaceURI: string | undefined;
+    private readonly attributes;
+    private readonly domListeners;
+    private lastBag;
+    constructor(tagName: string, namespaceURI?: string);
+    get nodeName(): string;
+    get p(): IShimPropBag;
+    set p(bag: IShimPropBag | undefined);
+    setAttribute(name: string, value: string): void;
+    getAttribute(name: string): string | null;
+    removeAttribute(name: string): void;
+    addEventListener(name: string, handler: (event: unknown) => void): void;
+    removeEventListener(name: string): void;
+    cloneNode(deep?: boolean): ShimElement;
+    createEngineNode(): ISymbioteNode;
+    onMadeLive(): void;
+}

package/build/dom-shim/element.js

@@ -0,0 +1,130 @@
+// The workhorse of the shim. Every Symbiote intrinsic (`symbiote-view`, `symbiote-text`, …)
+// is a hyphenated tag, so Svelte compiles it down the CUSTOM-ELEMENT codegen path (§3g):
+// attributes go through `set_custom_element_data`, which stringifies scalars and hard-excludes
+// `style`. The resolution (§3g(c)) is a single object-bag PROPERTY, not a spread of
+// attributes — an object always satisfies `value && typeof value === 'object'`, so it lands as
+// a real property SET (`node.p = bag`), untouched by stringification. `p`'s setter (below)
+// unpacks the bag into `routeProp`, the same entry point React's flat bag and Vue's patchProp
+// already use.
+//
+// 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, isDebug, routeProp, setEventListener, toPublicInstance, } from '@symbiote-native/engine';
+import { descriptorFor } from '@symbiote-native/components';
+import { normalizeSvelteClass } from '../class-value.js';
+import { ShimNode } from './shim-node.js';
+// Diagnostic-only: a process-wide sequence so every `set p` call across every shim element in a
+// log dump is individually orderable against AnimatedProps reconcile#N / AnimatedView reduced#N
+// / hostShim identity-change#N, to see which one is driving which.
+let globalSetPSeq = 0;
+// `on<Name>` handlers ride inside the prop bag (idiomatic Svelte 5 callback props — see the
+// skill's §3g(c) "most of §5 collapses" note) — they are not addEventListener-style DOM
+// listeners, so they are diffed and routed exactly like any other bag key, through routeProp.
+export class ShimElement extends ShimNode {
+    tagName;
+    namespaceURI;
+    attributes = new Map();
+    domListeners = new Map();
+    lastBag = {};
+    constructor(tagName, namespaceURI) {
+        super();
+        this.tagName = tagName;
+        this.namespaceURI = namespaceURI;
+    }
+    get nodeName() {
+        return this.tagName;
+    }
+    // The single object-bag prop. The literal name is ours to choose (§3g(c)) — the adapter's
+    // own View.svelte/Text.svelte/… emit `<symbiote-view p={bag}>`; app code never sees it.
+    get p() {
+        return this.lastBag;
+    }
+    set p(bag) {
+        const next = normalizeBagClasses(bag ?? {});
+        const prev = this.lastBag;
+        this.lastBag = next;
+        const changedKeys = diffKeys(prev, next);
+        dlog(`ShimElement set-p#${++globalSetPSeq} tag=${this.tagName} live=${this.engineNode !== undefined} ` +
+            `changedKeys=${changedKeys.join(',')}`);
+        if (this.engineNode === undefined)
+            return; // not live yet — onMadeLive() replays `next` in full
+        applyBagDiff(this.engineNode, prev, next);
+        this.surface?.requestCommit();
+    }
+    setAttribute(name, value) {
+        this.attributes.set(name, value);
+    }
+    getAttribute(name) {
+        return this.attributes.get(name) ?? null;
+    }
+    removeAttribute(name) {
+        this.attributes.delete(name);
+    }
+    addEventListener(name, handler) {
+        this.domListeners.set(name, handler);
+        if (this.engineNode !== undefined)
+            setEventListener(this.engineNode, name, handler);
+    }
+    removeEventListener(name) {
+        this.domListeners.delete(name);
+        if (this.engineNode !== undefined)
+            setEventListener(this.engineNode, name, undefined);
+    }
+    cloneNode(deep) {
+        const clone = new ShimElement(this.tagName, this.namespaceURI);
+        for (const [key, value] of this.attributes)
+            clone.attributes.set(key, value);
+        if (deep === true) {
+            for (const child of this.children)
+                clone.appendChild(child.cloneNode(true));
+        }
+        return clone;
+    }
+    // toPublicInstance grafts measure/measureInWindow/measureLayout/setNativeProps/focus/blur
+    // onto the node — the imperative API a `bind:this` host ref hands back, the same augmentation
+    // Vue's renderer applies at its own commit point (renderer/index.ts) and React gets from
+    // getPublicInstance. Mutates in place and returns the SAME node, so this is a safe drop-in for
+    // the previously-bare createElement() call.
+    createEngineNode() {
+        const descriptor = descriptorFor(this.tagName);
+        return toPublicInstance(createElement(descriptor.component, descriptor.isText));
+    }
+    onMadeLive() {
+        const engineNode = this.engineNode;
+        if (engineNode === undefined)
+            return;
+        applyBagDiff(engineNode, {}, this.lastBag);
+        for (const [name, handler] of this.domListeners)
+            setEventListener(engineNode, name, handler);
+    }
+}
+// Both spellings route through the engine's shared class+style merge (routeProp's
+// CLASS_PROP_KEYS), so both get the same clsx normalization here.
+const CLASS_BAG_KEYS = ['class', 'className'];
+// Normalizing BEFORE the bag is stored — rather than at the routeProp call — is deliberate: the
+// diff below then compares two class STRINGS instead of two freshly-allocated object literals, so
+// a component re-rendering with an unchanged `class={{ active: isOn }}` stops marking the node
+// dirty and stops driving a Fabric subtree clone that changes nothing.
+function normalizeBagClasses(bag) {
+    let next = bag;
+    for (const key of CLASS_BAG_KEYS) {
+        if (!(key in next))
+            continue;
+        const normalized = normalizeSvelteClass(next[key]);
+        if (normalized === next[key])
+            continue;
+        if (next === bag)
+            next = { ...bag };
+        next[key] = normalized;
+    }
+    return next;
+}
+function diffKeys(prev, next) {
+    const keys = new Set([...Object.keys(prev), ...Object.keys(next)]);
+    return [...keys].filter(key => prev[key] !== next[key]);
+}
+function applyBagDiff(engineNode, prev, next) {
+    for (const key of diffKeys(prev, next))
+        routeProp(engineNode, key, next[key]);
+}

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

@@ -0,0 +1,5 @@
+export { patchGlobals, restoreGlobals } from './patch-globals';
+export { ShimElement } from './element';
+export { ShimNode } from './shim-node';
+export { ShimText } from './text';
+export { getShimDocument } from './document';

package/build/dom-shim/index.js

@@ -0,0 +1,7 @@
+// Internal barrel — consumed by render.ts and root-element.ts, never by app code (app code
+// never sees a shim class or a `symbiote-*` tag; see the adapter's own index.ts).
+export { patchGlobals, restoreGlobals } from './patch-globals.js';
+export { ShimElement } from './element.js';
+export { ShimNode } from './shim-node.js';
+export { ShimText } from './text.js';
+export { getShimDocument } from './document.js';

package/build/dom-shim/patch-globals.d.ts

@@ -0,0 +1,2 @@
+export declare function patchGlobals(): void;
+export declare function restoreGlobals(): void;

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

@@ -0,0 +1,94 @@
+// Installs the shim as the DOM globals Svelte's `init_operations()` reads at mount time
+// (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.
+//
+// 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
+// just asserted:
+// - `navigator` — RN's own `setUpNavigator.js` sets `global.navigator = {product:
+//   'ReactNative'}` before any app code runs; clobbering it breaks third-party detection
+//   silently. `init_operations()` reads `navigator.userAgent` (undefined on RN, since
+//   setUpNavigator.js sets no such field) but only via `/Firefox/.test(...)`, which coerces
+//   `undefined` to the string `"undefined"` rather than throwing.
+// - `requestAnimationFrame` / `cancelAnimationFrame` — `@symbiote-native/engine`'s own Animated
+//   driver reads these globals at call time; replacing them would silently degrade every
+//   adapter's animations to a 16ms timer, not just Svelte's.
+// - `window` — RN's own `setUpGlobals.js` sets `global.window = global` before any app code
+//   runs; nothing to do. (A bare Node/vitest sandbox does NOT have this — a test exercising
+//   the real mount pipeline needs to replicate it itself; see
+//   mount-pipeline.smoke.test.ts's module-level setup.)
+//
+// `customElements` IS patched, unlike the three above — see its own comment below.
+import { dlog } from '@symbiote-native/engine';
+import { ShimElement } from './element.js';
+import { ShimText } from './text.js';
+import { ShimComment } from './comment.js';
+import { ShimDocumentFragment } from './document-fragment.js';
+import { ShimNode } from './shim-node.js';
+import { getShimDocument } from './document.js';
+const PATCHED_KEYS = [
+    'Node',
+    'Element',
+    'HTMLElement',
+    'SVGElement',
+    'Text',
+    'Comment',
+    'DocumentFragment',
+    'document',
+    'customElements',
+];
+// 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
+// must be a real assigned property, not merely absent. Found only by actually running the
+// pipeline (mount-pipeline.smoke.test.ts); `tsc --build` has no way to catch a missing global
+// a compiled Svelte bundle reads. RN/Hermes has no Custom Elements API of its own to collide
+// with (unlike `navigator`/`requestAnimationFrame`, verified against .vendors/react-native —
+// see the header comment above), so patching this is safe. `get()` always returns `undefined`
+// since we never call `customElements.define()`, which is exactly what steers
+// `set_custom_element_data` down the object-bag "set as property" branch every `p={bag}` prop
+// needs (skill §3g(c)).
+const FAKE_CUSTOM_ELEMENT_REGISTRY = { get: () => undefined };
+let previous;
+export function patchGlobals() {
+    if (previous !== undefined)
+        return; // already installed — single root, idempotent
+    const g = globalThis;
+    previous = {
+        Node: g.Node,
+        Element: g.Element,
+        HTMLElement: g.HTMLElement,
+        SVGElement: g.SVGElement,
+        Text: g.Text,
+        Comment: g.Comment,
+        DocumentFragment: g.DocumentFragment,
+        document: g.document,
+        customElements: g.customElements,
+    };
+    g.Node = ShimNode;
+    g.Element = ShimElement;
+    // Svelte's mandatory paths never distinguish HTMLElement/SVGElement from Element (we have
+    // no `<svg>` primitives), so both alias the same class — real, extensible prototypes either
+    // way, which is all `init_operations()` requires (§3a).
+    g.HTMLElement = ShimElement;
+    g.SVGElement = ShimElement;
+    g.Text = ShimText;
+    g.Comment = ShimComment;
+    g.DocumentFragment = ShimDocumentFragment;
+    g.document = getShimDocument();
+    g.customElements = FAKE_CUSTOM_ELEMENT_REGISTRY;
+    dlog('svelte dom-shim: patchGlobals installed');
+}
+export function restoreGlobals() {
+    if (previous === undefined)
+        return;
+    const g = globalThis;
+    for (const key of PATCHED_KEYS)
+        g[key] = previous[key];
+    previous = undefined;
+    dlog('svelte dom-shim: restoreGlobals');
+}

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

@@ -0,0 +1,30 @@
+import { type ISymbioteNode, type SymbioteSurface } from '@symbiote-native/engine';
+type IDocumentLike = {
+    createTextNode(value: string): ShimNode;
+};
+export declare function registerShimDocumentFactory(factory: () => IDocumentLike): void;
+export declare abstract class ShimNode {
+    parent: ShimNode | null;
+    children: ShimNode[];
+    engineNode: ISymbioteNode | undefined;
+    surface: SymbioteSurface | undefined;
+    readonly isDocumentFragment: boolean;
+    abstract createEngineNode(): ISymbioteNode;
+    onMadeLive(): void;
+    abstract cloneNode(deep?: boolean): ShimNode;
+    get parentNode(): ShimNode | null;
+    get lastChild(): ShimNode | null;
+    get nodeName(): string;
+    get content(): undefined;
+    get ownerDocument(): IDocumentLike;
+    makeLive(surface: SymbioteSurface): ISymbioteNode;
+    append(...nodes: ShimNode[]): void;
+    appendChild<T extends ShimNode>(node: T): T;
+    insertBefore<T extends ShimNode>(node: T, ref: ShimNode | null): T;
+    before(node: ShimNode): void;
+    remove(): void;
+    removeChild<T extends ShimNode>(child: T): T;
+    set textContent(value: string);
+    private insertOne;
+}
+export {};