foldkit 0.146.0 → 0.148.0

package/dist/hydrationMarker.d.ts

@@ -0,0 +1,10 @@
+/** Attribute stamped on the server-rendered application root. Its presence
+ *  tells a booting runtime to hydrate instead of rendering fresh, and its
+ *  value is the runtime id used for HMR model preservation. */
+export declare const FOLDKIT_APP_ATTRIBUTE = "data-foldkit-app";
+/** Attribute on the JSON script tag carrying the Schema-encoded flags the
+ *  server rendered with. A hydrating runtime decodes this payload instead of
+ *  running the client `flags` Effect, so both sides call `init` with the
+ *  same value. */
+export declare const FOLDKIT_FLAGS_ATTRIBUTE = "data-foldkit-flags";
+//# sourceMappingURL=hydrationMarker.d.ts.map

package/dist/hydrationMarker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hydrationMarker.d.ts","sourceRoot":"","sources":["../src/hydrationMarker.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAC/D,eAAO,MAAM,qBAAqB,qBAAqB,CAAA;AAEvD;;;kBAGkB;AAClB,eAAO,MAAM,uBAAuB,uBAAuB,CAAA"}

package/dist/hydrationMarker.js

@@ -0,0 +1,9 @@
+/** Attribute stamped on the server-rendered application root. Its presence
+ *  tells a booting runtime to hydrate instead of rendering fresh, and its
+ *  value is the runtime id used for HMR model preservation. */
+export const FOLDKIT_APP_ATTRIBUTE = 'data-foldkit-app';
+/** Attribute on the JSON script tag carrying the Schema-encoded flags the
+ *  server rendered with. A hydrating runtime decodes this payload instead of
+ *  running the client `flags` Effect, so both sides call `init` with the
+ *  same value. */
+export const FOLDKIT_FLAGS_ATTRIBUTE = 'data-foldkit-flags';

package/dist/hydrationMarkers.d.ts

@@ -0,0 +1,15 @@
+export declare const HYDRATION_KEY_ATTRIBUTE = "data-foldkit-key";
+export declare const HYDRATION_IDENTITY_ATTRIBUTE = "data-foldkit-identity";
+/** The marker value for a vnode key, or `undefined` for a key type the
+ *  hydration handoff does not support (a symbol, which the server refuses to
+ *  render and hydration therefore never adopts).
+ *
+ * @internal
+ */
+export declare const hydrationKeyMarker: (key: PropertyKey) => string | undefined;
+/** The marker value for a compiler-assigned view identity.
+ *
+ * @internal
+ */
+export declare const hydrationIdentityMarker: (identity: string) => string;
+//# sourceMappingURL=hydrationMarkers.d.ts.map

package/dist/hydrationMarkers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hydrationMarkers.d.ts","sourceRoot":"","sources":["../src/hydrationMarkers.ts"],"names":[],"mappings":"AAsBA,eAAO,MAAM,uBAAuB,qBAAqB,CAAA;AACzD,eAAO,MAAM,4BAA4B,0BAA0B,CAAA;AAkCnE;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,GAAI,KAAK,WAAW,KAAG,MAAM,GAAG,SAQ9D,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,uBAAuB,GAAI,UAAU,MAAM,KAAG,MAClC,CAAA"}

package/dist/hydrationMarkers.js

@@ -0,0 +1,70 @@
+// Hydration markers the serializer stamps onto a keyed or identity-bearing
+// element, and hydration reads then strips. The server HTML does not otherwise
+// encode a vnode's `key` or `identity`, so a reordered or stale keyed list would
+// be adopted positionally: the client's first row would take over the DOM node
+// (and the user state on it) of a different logical row. Serializing the markers
+// lets hydration verify it is adopting the same logical entity by key and
+// identity, not just by tag and position, and rebuild when it is not.
+//
+// A marker carries a digest of the key, never the key itself. Application keys
+// are database ids, account identifiers, and email addresses the view otherwise
+// never renders, and a compiler identity spells out a source path and function
+// name; neither belongs in public HTML. A digest is a one-way comparison token:
+// it is enough for hydration, which only ever asks whether two markers are
+// equal, and it does not read back to the value it was computed from. It is not
+// a secret, since a reader who guesses a candidate key can hash it and compare,
+// so it is sized to make an accidental collision between two distinct keys
+// vanishingly unlikely rather than to withstand a guessing attack.
+//
+// Markers are part of the hydration handoff, so they are emitted only for a
+// hydratable render. Non-hydratable output carries no key or identity channel
+// at all.
+export const HYDRATION_KEY_ATTRIBUTE = 'data-foldkit-key';
+export const HYDRATION_IDENTITY_ATTRIBUTE = 'data-foldkit-identity';
+// FNV-1a, run as two 32-bit lanes from different offset bases and concatenated
+// to 64 bits. The lanes are plain integer arithmetic over the string's code
+// units, so the server and the browser compute the same digest for the same
+// input with no platform dependency and no async crypto API.
+const FNV_PRIME = 16777619;
+const FNV_OFFSET_BASIS = 2166136261;
+const SECOND_LANE_OFFSET_BASIS = 1099511628;
+const digest = (value) => {
+    let lowLane = FNV_OFFSET_BASIS;
+    let highLane = SECOND_LANE_OFFSET_BASIS;
+    for (let index = 0; index < value.length; index += 1) {
+        const codeUnit = value.charCodeAt(index);
+        const lowByte = codeUnit & 0xff;
+        const highByte = codeUnit >>> 8;
+        lowLane = Math.imul(lowLane ^ lowByte, FNV_PRIME);
+        lowLane = Math.imul(lowLane ^ highByte, FNV_PRIME);
+        highLane = Math.imul(highLane ^ highByte, FNV_PRIME);
+        highLane = Math.imul(highLane ^ lowByte, FNV_PRIME);
+    }
+    return ((lowLane >>> 0).toString(16).padStart(8, '0') +
+        (highLane >>> 0).toString(16).padStart(8, '0'));
+};
+// Each digest is taken over a type-tagged string, which keeps the supported key
+// types apart. The runtime compares keys with `===`, so the number 1 and the
+// string '1' are different keys and must digest differently; untagged, both
+// would reach the digest as "1" and a server-rendered numeric key would adopt a
+// client string key's node, and the state on it.
+/** The marker value for a vnode key, or `undefined` for a key type the
+ *  hydration handoff does not support (a symbol, which the server refuses to
+ *  render and hydration therefore never adopts).
+ *
+ * @internal
+ */
+export const hydrationKeyMarker = (key) => {
+    if (typeof key === 'string') {
+        return digest(`s:${key}`);
+    }
+    if (typeof key === 'number') {
+        return digest(`n:${key}`);
+    }
+    return undefined;
+};
+/** The marker value for a compiler-assigned view identity.
+ *
+ * @internal
+ */
+export const hydrationIdentityMarker = (identity) => digest(`i:${identity}`);

package/dist/nativeInnerHtml.d.ts

@@ -0,0 +1,13 @@
+/** Reads the platform's `Element.innerHTML`, bypassing a same-named property
+ *  an autonomous custom element defines.
+ *
+ * @internal
+ */
+export declare const readNativeInnerHtml: (element: Element) => string;
+/** Writes the platform's `Element.innerHTML`, bypassing a same-named property
+ *  an autonomous custom element defines.
+ *
+ * @internal
+ */
+export declare const writeNativeInnerHtml: (element: Element, value: string) => void;
+//# sourceMappingURL=nativeInnerHtml.d.ts.map

package/dist/nativeInnerHtml.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nativeInnerHtml.d.ts","sourceRoot":"","sources":["../src/nativeInnerHtml.ts"],"names":[],"mappings":"AAeA;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,GAAI,SAAS,OAAO,KAAG,MAGtD,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,GAAI,SAAS,OAAO,EAAE,OAAO,MAAM,KAAG,IAEtE,CAAA"}

package/dist/nativeInnerHtml.js

@@ -0,0 +1,30 @@
+const innerHtmlDescriptor = (element) => {
+    const elementConstructor = element.ownerDocument.defaultView?.Element ?? globalThis.Element;
+    const prototype = elementConstructor.prototype;
+    let current = prototype;
+    while (current !== null) {
+        const descriptor = Object.getOwnPropertyDescriptor(current, 'innerHTML');
+        if (descriptor?.get !== undefined && descriptor.set !== undefined) {
+            return descriptor;
+        }
+        current = Object.getPrototypeOf(current);
+    }
+    throw new Error('[foldkit] The browser does not expose Element.innerHTML.');
+};
+/** Reads the platform's `Element.innerHTML`, bypassing a same-named property
+ *  an autonomous custom element defines.
+ *
+ * @internal
+ */
+export const readNativeInnerHtml = (element) => {
+    const value = innerHtmlDescriptor(element).get?.call(element);
+    return typeof value === 'string' ? value : '';
+};
+/** Writes the platform's `Element.innerHTML`, bypassing a same-named property
+ *  an autonomous custom element defines.
+ *
+ * @internal
+ */
+export const writeNativeInnerHtml = (element, value) => {
+    innerHtmlDescriptor(element).set?.call(element, value);
+};

package/dist/propertyProvenance.d.ts

@@ -0,0 +1,33 @@
+/** Records `value` as markup `h.InnerHTML` wrote. The value itself is the mark,
+ *  so a later generic write to `innerHTML` no longer matches and the markup it
+ *  wrote is never treated as trusted.
+ *
+ * @internal
+ */
+export declare const markTrustedInnerHtml: (props: Record<string, unknown>, value: string) => void;
+/** Records `name` as a property a builder wrote without claiming it is markup:
+ *  an internal `Prop`, which is also what a `CustomElement.define` property
+ *  factory produces.
+ *
+ * @internal
+ */
+export declare const markClientOnlyProperty: (props: Record<string, unknown>, name: string) => void;
+/** Drops the client-only mark from `name`, for a typed attribute builder
+ *  overwriting a property a generic write left behind.
+ *
+ * @internal
+ */
+export declare const unmarkClientOnlyProperty: (props: Record<string, unknown>, name: string) => void;
+/** Whether `props.innerHTML` is the markup `h.InnerHTML` wrote, rather than an
+ *  arbitrary property that happens to carry that name.
+ *
+ * @internal
+ */
+export declare const hasTrustedInnerHtml: (props: Readonly<Record<string, unknown>> | undefined) => boolean;
+/** Whether `name` is a client-only DOM property rather than the HTML attribute
+ *  it is named after.
+ *
+ * @internal
+ */
+export declare const isClientOnlyProperty: (props: Readonly<Record<string, unknown>> | undefined, name: string) => boolean;
+//# sourceMappingURL=propertyProvenance.d.ts.map

package/dist/propertyProvenance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"propertyProvenance.d.ts","sourceRoot":"","sources":["../src/propertyProvenance.ts"],"names":[],"mappings":"AAgCA;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,GAC/B,OAAO,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,OAAO,MAAM,KACZ,IAIF,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,GACjC,OAAO,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,MAAM,MAAM,KACX,IAOF,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,GACnC,OAAO,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,MAAM,MAAM,KACX,IAEF,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,GAC9B,OAAO,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,SAAS,KACnD,OASF,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,GAC/B,OAAO,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,SAAS,EACpD,MAAM,MAAM,KACX,OAKF,CAAA"}

package/dist/propertyProvenance.js

@@ -0,0 +1,78 @@
+// What the server serializer may assume about an entry in a vnode's
+// `data.props`. A DOM property name alone does not say what the property means:
+// `innerHTML` is markup the view author intends to be parsed when `h.InnerHTML`
+// wrote it and an arbitrary client-only value when anything else did, and `id`
+// on a custom element is a reflected HTML attribute when `h.Id` wrote it and a
+// component-private value when `CustomElement.define` did.
+//
+// Both marks belong to the last write, not to the props bag, which is what stops
+// a value the serializer trusts from standing in for one written after it. The
+// serializer always emits the value that is in `props`, and the marks always
+// describe the builder that put it there.
+//
+// The marks live under symbol keys, so `Object.keys` never surfaces them, the
+// props module never applies them to the DOM, the attribute serializer never
+// emits them, and no string-keyed property can forge them. Object spread copies
+// own enumerable symbol keys, so a copied props bag keeps its marks.
+const TRUSTED_INNER_HTML = Symbol('foldkit/trusted-inner-html');
+const CLIENT_ONLY_PROPERTIES = Symbol('foldkit/client-only-properties');
+const markedProps = (props) => 
+/* eslint-disable-next-line @typescript-eslint/consistent-type-assertions */
+props;
+/** Records `value` as markup `h.InnerHTML` wrote. The value itself is the mark,
+ *  so a later generic write to `innerHTML` no longer matches and the markup it
+ *  wrote is never treated as trusted.
+ *
+ * @internal
+ */
+export const markTrustedInnerHtml = (props, value) => {
+    const marked = markedProps(props);
+    marked[TRUSTED_INNER_HTML] = value;
+    marked[CLIENT_ONLY_PROPERTIES]?.delete('innerHTML');
+};
+/** Records `name` as a property a builder wrote without claiming it is markup:
+ *  an internal `Prop`, which is also what a `CustomElement.define` property
+ *  factory produces.
+ *
+ * @internal
+ */
+export const markClientOnlyProperty = (props, name) => {
+    const marked = markedProps(props);
+    const names = (marked[CLIENT_ONLY_PROPERTIES] ??= new Set());
+    names.add(name);
+    if (name === 'innerHTML') {
+        Reflect.deleteProperty(marked, TRUSTED_INNER_HTML);
+    }
+};
+/** Drops the client-only mark from `name`, for a typed attribute builder
+ *  overwriting a property a generic write left behind.
+ *
+ * @internal
+ */
+export const unmarkClientOnlyProperty = (props, name) => {
+    markedProps(props)[CLIENT_ONLY_PROPERTIES]?.delete(name);
+};
+/** Whether `props.innerHTML` is the markup `h.InnerHTML` wrote, rather than an
+ *  arbitrary property that happens to carry that name.
+ *
+ * @internal
+ */
+export const hasTrustedInnerHtml = (props) => {
+    if (props === undefined) {
+        return false;
+    }
+    const marked = markedProps(props);
+    const innerHtml = marked['innerHTML'];
+    return (typeof innerHtml === 'string' && marked[TRUSTED_INNER_HTML] === innerHtml);
+};
+/** Whether `name` is a client-only DOM property rather than the HTML attribute
+ *  it is named after.
+ *
+ * @internal
+ */
+export const isClientOnlyProperty = (props, name) => {
+    if (props === undefined) {
+        return false;
+    }
+    return markedProps(props)[CLIENT_ONLY_PROPERTIES]?.has(name) === true;
+};

package/dist/propsModule.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"propsModule.d.ts","sourceRoot":"","sources":["../src/propsModule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AA0DjD,eAAO,MAAM,WAAW,EAAE,MAIzB,CAAA"}
+{"version":3,"file":"propsModule.d.ts","sourceRoot":"","sources":["../src/propsModule.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AA0NjD,eAAO,MAAM,WAAW,EAAE,MAIzB,CAAA"}

package/dist/propsModule.js

@@ -1,8 +1,64 @@
+import { clearControlledDefault, restoreControlledStateFromRawAttribute, } from './controlledDomState.js';
+import { GLOBAL_ATTRIBUTE_PROPERTIES, HTML_NAMESPACE, htmlAttributeValue, reflectedAttributeName, } from './domReflection.js';
+import { writeNativeInnerHtml } from './nativeInnerHtml.js';
+import { hasTrustedInnerHtml, isClientOnlyProperty, } from './propertyProvenance.js';
 import { VNodeDataMask } from './snabbdom/vnode.js';
-/** A custom props module that extends snabbdom's built-in propsModule with
- *  proper cleanup of removed properties.
+const writeProperty = (element, name, value) => {
+    if (name === '__proto__') {
+        Object.defineProperty(element, name, {
+            configurable: true,
+            enumerable: true,
+            value,
+            writable: true,
+        });
+    }
+    else {
+        if (!Reflect.set(element, name, value)) {
+            throw new TypeError(`[foldkit] Cannot assign DOM property ${name}.`);
+        }
+    }
+};
+const isAutonomousCustomElement = (element) => (element.namespaceURI === null || element.namespaceURI === HTML_NAMESPACE) &&
+    element.localName.includes('-');
+const isNativeCustomElementAttribute = (element, properties, name) => isAutonomousCustomElement(element) &&
+    GLOBAL_ATTRIBUTE_PROPERTIES.has(name) &&
+    !isClientOnlyProperty(properties, name);
+const writeAttribute = (element, name, value) => {
+    const attributeName = reflectedAttributeName(name);
+    if (attributeName === undefined) {
+        return;
+    }
+    if (name === 'draggable') {
+        element.setAttribute(attributeName, String(value));
+    }
+    else if (value === true) {
+        element.setAttribute(attributeName, '');
+    }
+    else if (value === false) {
+        element.removeAttribute(attributeName);
+    }
+    else {
+        element.setAttribute(attributeName, String(value));
+    }
+};
+const resetProperty = (element, name, value) => {
+    if (name === '__proto__') {
+        Reflect.deleteProperty(element, name);
+    }
+    else if (typeof value === 'boolean') {
+        writeProperty(element, name, false);
+    }
+    else if (typeof value === 'string') {
+        writeProperty(element, name, '');
+    }
+    else if (typeof value === 'number') {
+        writeProperty(element, name, 0);
+    }
+};
+/** A props module that extends Snabbdom's built-in module with cleanup of
+ *  removed properties and explicit controlled-state ownership transitions.
  *
- *  Snabbdom's propsModule only iterates over _new_ props — it never resets
+ *  Snabbdom's propsModule only iterates over new props. It never resets
  *  old props that disappeared between renders. This means `elm.disabled = true`
  *  persists even after `Disabled(true)` is removed from the attribute array.
  *  Since a disabled button swallows click events at the browser level, an
@@ -10,7 +66,10 @@ import { VNodeDataMask } from './snabbdom/vnode.js';
  *
  *  This module adds a second loop (mirroring what snabbdom's attributesModule
  *  already does) that resets removed props to type-appropriate defaults:
- *  booleans → false, strings → '', numbers → 0. */
+ *  booleans become false, strings become empty, and numbers become zero. For
+ *  reflected form and media state it also keeps the parsed default state in
+ *  step with the controlled value, then restores raw-attribute ownership when
+ *  the typed property leaves. */
 function updateProps(oldVnode, vnode) {
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const elm = vnode.elm;
@@ -26,25 +85,100 @@ function updateProps(oldVnode, vnode) {
     }
     oldProps = oldProps ?? {};
     props = props ?? {};
-    for (const key in props) {
+    if (elm instanceof Element) {
+        for (const key of Object.keys(oldProps)) {
+            if (key === 'innerHTML' &&
+                Object.hasOwn(props, key) &&
+                hasTrustedInnerHtml(oldProps) !== hasTrustedInnerHtml(props)) {
+                if (hasTrustedInnerHtml(oldProps)) {
+                    writeNativeInnerHtml(elm, '');
+                }
+                else {
+                    resetProperty(elm, key, oldProps[key]);
+                }
+            }
+            if (Object.hasOwn(props, key) &&
+                !isClientOnlyProperty(oldProps, key) &&
+                isClientOnlyProperty(props, key)) {
+                clearControlledDefault(elm, key);
+                if (isNativeCustomElementAttribute(elm, oldProps, key)) {
+                    const attributeName = reflectedAttributeName(key);
+                    if (attributeName !== undefined) {
+                        elm.removeAttribute(attributeName);
+                    }
+                }
+            }
+            else if (Object.hasOwn(props, key) &&
+                isClientOnlyProperty(oldProps, key) &&
+                !isClientOnlyProperty(props, key) &&
+                isNativeCustomElementAttribute(elm, props, key)) {
+                resetProperty(elm, key, oldProps[key]);
+            }
+        }
+    }
+    for (const key of Object.keys(props)) {
         const cur = props[key];
         const old = oldProps[key];
-        if (old !== cur && (key !== 'value' || elm[key] !== cur)) {
-            elm[key] = cur;
+        const isOwnershipChanged = isClientOnlyProperty(oldProps, key) !== isClientOnlyProperty(props, key);
+        if ((old !== cur || isOwnershipChanged) &&
+            (key !== 'value' || elm[key] !== cur)) {
+            if (key === 'innerHTML' &&
+                elm instanceof Element &&
+                hasTrustedInnerHtml(props)) {
+                writeNativeInnerHtml(elm, String(cur));
+            }
+            else if (elm instanceof Element &&
+                isNativeCustomElementAttribute(elm, props, key)) {
+                writeAttribute(elm, key, cur);
+            }
+            else {
+                writeProperty(elm, key, cur);
+            }
         }
     }
-    for (const key in oldProps) {
-        if (!(key in props)) {
+    for (const key of Object.keys(oldProps)) {
+        if (!Object.hasOwn(props, key)) {
             const old = oldProps[key];
-            if (typeof old === 'boolean') {
-                elm[key] = false;
+            if (key === 'innerHTML' &&
+                elm instanceof Element &&
+                hasTrustedInnerHtml(oldProps)) {
+                writeNativeInnerHtml(elm, '');
+                continue;
+            }
+            if (elm instanceof Element &&
+                isNativeCustomElementAttribute(elm, oldProps, key)) {
+                const attributeName = reflectedAttributeName(key);
+                if (attributeName !== undefined) {
+                    elm.removeAttribute(attributeName);
+                }
+                continue;
+            }
+            if (elm instanceof Element &&
+                key === 'value' &&
+                (elm.localName === 'select' ||
+                    elm.localName === 'textarea' ||
+                    elm.localName === 'output')) {
+                if (!Object.hasOwn(props, 'innerHTML')) {
+                    clearControlledDefault(elm, key);
+                }
+                continue;
             }
-            else if (typeof old === 'string') {
-                elm[key] = '';
+            const attributeName = reflectedAttributeName(key);
+            if (attributeName !== undefined &&
+                !isClientOnlyProperty(oldProps, key) &&
+                elm instanceof Element) {
+                if (htmlAttributeValue(vnode.data?.attrs, attributeName) !== undefined) {
+                    restoreControlledStateFromRawAttribute(elm, key);
+                    continue;
+                }
+                clearControlledDefault(elm, key);
+                elm.removeAttribute(attributeName);
+                continue;
             }
-            else if (typeof old === 'number') {
-                elm[key] = 0;
+            if (elm instanceof Element) {
+                clearControlledDefault(elm, key);
             }
+            resetProperty(elm, key, old);
         }
     }
 }

package/dist/runtime/public.d.ts

@@ -1,4 +1,4 @@
-export { SlowPhase, defaultSlowCallback, embed, makeApplication, makeElement, run, } from './runtime.js';
-export type { RoutingConfig, CrashConfig, CrashContext, ElementCrashConfig, RoutingApplicationConfigWithFlags, RoutingApplicationConfig, ApplicationConfigWithFlags, ApplicationConfig, ElementConfigWithFlags, ElementConfig, ApplicationInit, RoutingApplicationInit, ElementInit, EmbedHandle, InboundPortHandle, InboundPortHandles, OutboundPortHandle, OutboundPortHandles, PortHandles, MakeRuntimeReturn, Visibility, SlowConfig, SlowContext, SlowPatchContext, SlowSubscriptionDependenciesContext, SlowThresholdOverrides, SlowUpdateContext, SlowViewContext, DevToolsConfig, DevToolsMode, DevToolsModeConfig, DevToolsPosition, } from './runtime.js';
+export { SlowPhase, defaultSlowCallback, embed, hydrate, makeApplication, makeElement, run, } from './runtime.js';
+export type { RoutingConfig, CrashConfig, CrashContext, ElementCrashConfig, RoutingApplicationConfigWithFlags, RoutingApplicationConfig, ApplicationConfigWithFlags, ApplicationConfig, ElementConfigWithFlags, ElementConfig, ApplicationInit, RoutingApplicationInit, ElementInit, EmbedHandle, HydrateOptions, InboundPortHandle, InboundPortHandles, OutboundPortHandle, OutboundPortHandles, PortHandles, MakeRuntimeReturn, RunOptions, Visibility, SlowConfig, SlowContext, SlowPatchContext, SlowSubscriptionDependenciesContext, SlowThresholdOverrides, SlowUpdateContext, SlowViewContext, DevToolsConfig, DevToolsMode, DevToolsModeConfig, DevToolsPosition, } from './runtime.js';
 export type { ViewTransitionConfig, ViewTransitionContext, ViewTransitionDecision, } from './viewTransition.js';
 //# sourceMappingURL=public.d.ts.map

package/dist/runtime/public.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"public.d.ts","sourceRoot":"","sources":["../../src/runtime/public.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EACT,mBAAmB,EACnB,KAAK,EACL,eAAe,EACf,WAAW,EACX,GAAG,GACJ,MAAM,cAAc,CAAA;AAErB,YAAY,EACV,aAAa,EACb,WAAW,EACX,YAAY,EACZ,kBAAkB,EAClB,iCAAiC,EACjC,wBAAwB,EACxB,0BAA0B,EAC1B,iBAAiB,EACjB,sBAAsB,EACtB,aAAa,EACb,eAAe,EACf,sBAAsB,EACtB,WAAW,EACX,WAAW,EACX,iBAAiB,EACjB,kBAAkB,EAClB,kBAAkB,EAClB,mBAAmB,EACnB,WAAW,EACX,iBAAiB,EACjB,UAAU,EACV,UAAU,EACV,WAAW,EACX,gBAAgB,EAChB,mCAAmC,EACnC,sBAAsB,EACtB,iBAAiB,EACjB,eAAe,EACf,cAAc,EACd,YAAY,EACZ,kBAAkB,EAClB,gBAAgB,GACjB,MAAM,cAAc,CAAA;AAErB,YAAY,EACV,oBAAoB,EACpB,qBAAqB,EACrB,sBAAsB,GACvB,MAAM,qBAAqB,CAAA"}
+{"version":3,"file":"public.d.ts","sourceRoot":"","sources":["../../src/runtime/public.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EACT,mBAAmB,EACnB,KAAK,EACL,OAAO,EACP,eAAe,EACf,WAAW,EACX,GAAG,GACJ,MAAM,cAAc,CAAA;AAErB,YAAY,EACV,aAAa,EACb,WAAW,EACX,YAAY,EACZ,kBAAkB,EAClB,iCAAiC,EACjC,wBAAwB,EACxB,0BAA0B,EAC1B,iBAAiB,EACjB,sBAAsB,EACtB,aAAa,EACb,eAAe,EACf,sBAAsB,EACtB,WAAW,EACX,WAAW,EACX,cAAc,EACd,iBAAiB,EACjB,kBAAkB,EAClB,kBAAkB,EAClB,mBAAmB,EACnB,WAAW,EACX,iBAAiB,EACjB,UAAU,EACV,UAAU,EACV,UAAU,EACV,WAAW,EACX,gBAAgB,EAChB,mCAAmC,EACnC,sBAAsB,EACtB,iBAAiB,EACjB,eAAe,EACf,cAAc,EACd,YAAY,EACZ,kBAAkB,EAClB,gBAAgB,GACjB,MAAM,cAAc,CAAA;AAErB,YAAY,EACV,oBAAoB,EACpB,qBAAqB,EACrB,sBAAsB,GACvB,MAAM,qBAAqB,CAAA"}

package/dist/runtime/public.js

@@ -1 +1 @@
-export { SlowPhase, defaultSlowCallback, embed, makeApplication, makeElement, run, } from './runtime.js';
+export { SlowPhase, defaultSlowCallback, embed, hydrate, makeApplication, makeElement, run, } from './runtime.js';