@firsthandjs/dom 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Firsthand contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,29 @@
+# @firsthandjs/dom
+
+DOM parts, components, portals and keyed lists — and a re-export of
+`@firsthandjs/core`, so applications have one import site.
+
+**Documentation:** [guide](https://github.com/firsthandjs/firsthand/blob/main/docs/guide/03-components.md) · [API reference](https://github.com/firsthandjs/firsthand/blob/main/docs/reference/dom.md) · [all docs](https://github.com/firsthandjs/firsthand/blob/main/docs/README.md)
+
+```tsx
+import { component, render, signal } from '@firsthandjs/dom';
+
+const Counter = component(() => {
+  const count = signal(0);
+  return <button onClick={() => count.value++}>{count.value}</button>;
+});
+
+render(() => <Counter />);
+```
+
+Pair it with [`@firsthandjs/compiler`](../compiler) at build time: static markup
+becomes a cloned `<template>` and every dynamic expression becomes a specialised
+DOM part.
+
+`@firsthandjs/dom/internal` is the compiler/runtime protocol. It is public on
+purpose — compiled output is code you could have written by hand — but it is not
+covered by semantic versioning in the same way the main entry point is.
+
+Full documentation: the [repository README](../../README.md).
+
+MIT licensed.

package/dist/adapter.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Element types this framework does not own.
+ *
+ * A component from another framework is a function, and TSX is happy to write
+ * it as an element. Firsthand cannot run it — there is nothing here that knows
+ * what a React element is, and putting that knowledge in this package would
+ * make every application pay for a framework it may not use.
+ *
+ * So this is a seam and nothing else: one slot for an adapter, one cache, and
+ * an error that names the fix. `@firsthandjs/react/auto` fills the slot; anything
+ * else can fill it the same way. No name in this file mentions React.
+ */
+import type { Component } from './component.js';
+/** Turns a foreign component into a Firsthand one. Called once per target. */
+export type ComponentAdapter = (target: (props: never) => unknown) => Component<never>;
+/**
+ * Installs the adapter used for element types that are not Firsthand components.
+ *
+ * Call it once, at startup. `null` removes it again, which is what a test does
+ * between cases.
+ */
+export declare function setComponentAdapter(next: ComponentAdapter | null): void;
+/** Thrown for an element type this framework cannot run. */
+export declare class FirsthandComponentError extends Error {
+    constructor(name: string);
+}
+/** Resolves a foreign element type, or says why it cannot be resolved. */
+export declare function adapt(target: object): Component<never>;
+//# sourceMappingURL=adapter.d.ts.map

package/dist/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEhD,8EAA8E;AAC9E,MAAM,MAAM,gBAAgB,GAAG,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,KAAK,SAAS,CAAC,KAAK,CAAC,CAAC;AAcvF;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,gBAAgB,GAAG,IAAI,GAAG,IAAI,CAKvE;AAED,4DAA4D;AAC5D,qBAAa,uBAAwB,SAAQ,KAAK;gBACpC,IAAI,EAAE,MAAM;CAQzB;AAED,0EAA0E;AAC1E,wBAAgB,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,KAAK,CAAC,CAYtD"}

package/dist/attributes.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Specialised setters for the attribute-shaped parts of a template.
+ *
+ * Each kind has its own function rather than one generic `setAttribute(node,
+ * name, value)` dispatcher, because the compiler already knows which kind it
+ * emitted (ADR-0009). Nothing here inspects a value to decide what it is,
+ * except where the public contract genuinely allows several shapes (`class`
+ * and `style`).
+ */
+export declare function setAttribute(node: Element, name: string, value: unknown): void;
+export declare function setAttributeNS(node: Element, ns: string, name: string, value: unknown): void;
+/** Writes a DOM property, which is what keeps object props out of strings. */
+export declare function setProperty(node: Element, name: string, value: unknown): void;
+/** A boolean DOM property such as `disabled` or `checked`. */
+export declare function setBoolean(node: Element, name: string, value: unknown): void;
+/** `class` as a string, replacing whatever was there. */
+export declare function setClass(node: Element, value: unknown): void;
+/**
+ * `class` as a record of `{ name: enabled }`, toggling only what changed.
+ *
+ * `previous` is the record from the last run; the caller keeps it, so nothing
+ * is allocated here.
+ */
+export declare function setClassList(node: Element, value: Record<string, unknown>, previous: Record<string, unknown> | undefined): void;
+/** `style` as a string. */
+export declare function setStyle(node: ElementCSSInlineStyle, value: unknown): void;
+/**
+ * `style` as an object, diffed per property.
+ *
+ * Rewriting `cssText` would discard properties set elsewhere and force a full
+ * re-parse of the declaration; setting only what changed does not.
+ */
+export declare function setStyleObject(node: ElementCSSInlineStyle, value: Record<string, string | number | null | undefined>, previous: Record<string, string | number | null | undefined> | undefined): void;
+//# sourceMappingURL=attributes.d.ts.map

package/dist/attributes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attributes.d.ts","sourceRoot":"","sources":["../src/attributes.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAQH,wBAAgB,YAAY,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAM9E;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAM5F;AAED,8EAA8E;AAC9E,wBAAgB,WAAW,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAE7E;AAED,8DAA8D;AAC9D,wBAAgB,UAAU,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAE5E;AAED,yDAAyD;AACzD,wBAAgB,QAAQ,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAM5D;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,OAAO,EACb,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,GAC5C,IAAI,CAeN;AAED,2BAA2B;AAC3B,wBAAgB,QAAQ,CAAC,IAAI,EAAE,qBAAqB,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAM1E;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,qBAAqB,EAC3B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,EACzD,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,GAAG,SAAS,GACvE,IAAI,CAmBN"}

package/dist/chunk-6OTA5OKE.js

@@ -0,0 +1 @@
+var k=null,C=new WeakMap;function $n(n){k=n,C=new WeakMap}var x=class extends Error{constructor(t){super(`${t} is not a Firsthand component. If it is a React component, import '@firsthandjs/react/auto' once at startup to render React components directly, or wrap it with fromReact(). Otherwise, declare it with component().`),this.name="FirsthandComponentError"}};function $(n){let t=C.get(n);if(t!==void 0)return t;if(k===null){let o=typeof n=="function"&&n.name!==""?n.name:"The value";throw new x(o)}let e=k(n);return C.set(n,e),e}import{bind as rn,getOwner as j,onCleanup as sn,runWithOwner as ln}from"@firsthandjs/core";var dn=3;function L(n){return typeof n.nodeType=="number"}var H=Symbol("firsthand.part");function jn(n){return{[H]:!0,anchor:document.createTextNode(""),thunk:n,owner:j()}}function D(n){return H in n}function M(n,t,e=null){if(typeof t!="function"){p(n,e,null,t);return}let o=null;rn(()=>{let r=t();if(typeof r=="function"){o=w(o),M(n,r,e);return}o=p(n,e,o,r)}),sn(()=>{o=w(o)})}function p(n,t,e,o){let r=typeof o;if(o==null||r==="boolean")return w(e);if(r==="string"||r==="number"){let i=String(o);return e!==null&&!Array.isArray(e)&&e.nodeType===dn?(e.data=i,e):v(n,t,e,document.createTextNode(i))}if(r==="function")return p(n,t,e,o());if(Array.isArray(o)){let i=[],s=[];if(W(o,i,s),i.length===0)return w(e);un(n,t,e===null?[]:Array.isArray(e)?e:[e],i);for(let d=0;d<s.length;d++){let l=s[d];ln(l.owner??j(),()=>{M(n,l.thunk,l.anchor)})}return i}return D(o)?p(n,t,e,[o]):L(o)?v(n,t,e,o):p(n,t,e,String(o))}function W(n,t,e){for(let o=0;o<n.length;o++){let r=n[o];if(typeof r=="object"&&r!==null&&D(r)){t.push(r.anchor),e.push(r);continue}for(;typeof r=="function";)r=r();r==null||typeof r=="boolean"||(Array.isArray(r)?W(r,t,e):typeof r=="object"&&L(r)?t.push(r):t.push(document.createTextNode(String(r))))}}function T(n){let t=n.parentNode;t!==null&&t.removeChild(n)}function w(n){if(n!==null)if(Array.isArray(n))for(let t=0;t<n.length;t++)T(n[t]);else T(n);return null}function v(n,t,e,o){return e===o?o:e!==null&&!Array.isArray(e)?(n.replaceChild(o,e),o):(w(e),n.insertBefore(o,t),o)}function un(n,t,e,o){let r=0,i=0,s=e.length-1,d=o.length-1;for(;r<=s&&i<=d&&e[r]===o[i];)r++,i++;for(;r<=s&&i<=d&&e[s]===o[d];)s--,d--;let l=d+1<o.length?o[d+1]:t;if(r>s){for(let u=i;u<=d;u++)n.insertBefore(o[u],l);return}if(i>d){for(let u=r;u<=s;u++)n.removeChild(e[u]);return}let c=new Map;for(let u=r;u<=s;u++)c.set(e[u],u);let a=d-i+1,f=new Int32Array(a).fill(-1);for(let u=0;u<a;u++){let g=o[i+u],O=c.get(g);O!==void 0&&(f[u]=O,c.delete(g))}for(let u of c.keys())n.removeChild(u);let m=cn(f),b=m.length-1,S=l;for(let u=a-1;u>=0;u--){let g=o[i+u];b>=0&&m[b]===u?b--:n.insertBefore(g,S),S=g}}function cn(n){let t=n.length,e=new Int32Array(t).fill(-1),o=[];for(let s=0;s<t;s++){let d=n[s];if(d===-1)continue;let l=0,c=o.length;for(;l<c;){let a=l+c>>1;n[o[a]]<d?l=a+1:c=a}l>0&&(e[s]=o[l-1]),o[l]=s}let r=[],i=o.length>0?o[o.length-1]:-1;for(;i!==-1;)r.push(i),i=e[i];return r.reverse()}import{signal as an,createOwner as I,disposeOwner as fn,getOwner as F,handleError as V,setOwner as h,untrack as _}from"@firsthandjs/core";var z=Symbol.for("firsthand.component"),pn=0,B="firsthand";function Vn(n){B=n}function _n(n,t,e,o){let i=Object.assign(s=>mn(i,s),{[z]:!0,setup:n,options:t,id:e??`c${String(++pn)}`,tag:void 0});return Object.defineProperty(i,"name",{configurable:!0,value:o??(n.name===""?"Component":n.name)}),e===void 0&&(`${i.name}`,void 0),(t?.tag!==void 0||t?.shadow===!0)&&wn(i,typeof t.tag=="string"?t.tag:void 0),i}function zn(n){return typeof n=="function"&&z in n}function mn(n,t){if(Object.freeze(t),n.setup===void 0)return $(n)(t);if(n.tag!==void 0)return bn(n,t);let e=I(F()),o=h(e);try{let r=_(()=>n.setup(t));return h(o),r}catch(r){return h(o),V(r,e),null}}function gn(n){let t=n.name.replace(/([a-z0-9])([A-Z])/g,"$1-$2").replace(/[^a-zA-Z0-9-]/g,"-").toLowerCase();return`${B}-${t}`}function wn(n,t){let e=n;if(e.tag!==void 0)return e.tag;let o=t??gn(e);return customElements.get(o)!==void 0&&(o=`${o}-${e.id.replace(/[^a-zA-Z0-9]/g,"").toLowerCase()}`),e.tag=o,customElements.define(o,hn(e)),o}function hn(n){let t=n.options?.shadow===!0,e=n.options?.attributes,o=e!==void 0?Object.keys(e):[];return class extends HTMLElement{static observedAttributes=o;constructor(){super(),this.$owner=null,this.$props=null,this.$attrs=null,this.$standalone=!1}connectedCallback(){this.$owner===null&&(this.$props===null&&(this.$standalone=!0,this.$attrs={},this.$props=yn(this,e,this.$attrs)),K(this,n,t))}disconnectedCallback(){!this.$standalone||this.$owner===null||(fn(this.$owner),this.$owner=null)}attributeChangedCallback(i,s,d){let l=this.$attrs?.[i];l!==void 0&&(l.value=e[i]?.(d))}}}function yn(n,t,e){let o={};if(t!==void 0)for(let r in t){let i=an(t[r](n.getAttribute(r)));e[r]=i,Object.defineProperty(o,r,{enumerable:!0,get:()=>i.value})}return Object.freeze(o)}function K(n,t,e){let o=I(F());n.$owner=o;let r=h(o);try{let i=e?n.attachShadow({mode:"open"}):n,s=_(()=>t.setup(n.$props));p(i,null,null,s)}catch(i){V(i,o)}finally{h(r)}}function bn(n,t){let e=document.createElement(n.tag);return e.$props=t,e.$owner===null&&K(e,n,n.options?.shadow===!0),e}import{batch as kn,createOwner as q,disposeOwner as Cn,getOwner as xn,setOwner as E,signal as Z,untrack as Y}from"@firsthandjs/core";function Gn(n,t,e){let o=q(xn()),r=new Map;return()=>{let i=n(),s=new Map,d=[];return kn(()=>{for(let l=0;l<i.length;l++){let c=i[l],a=Y(()=>t(c,l));if(s.has(a)){`${String(a)}`;continue}let f=r.get(a);f===void 0?f=En(o,c,l,e):(r.delete(a),f.item.value=c,f.index.value=l),s.set(a,f);for(let m=0;m<f.nodes.length;m++)d.push(f.nodes[m])}for(let l of r.values())Cn(l.owner)}),r=s,d}}function En(n,t,e,o){let r=q(n),i=Z(t),s=Z(e),d=E(r),l;try{l=Y(()=>o(i,s)),E(d)}catch(a){throw E(d),a}let c=[];return G(l,c),{owner:r,item:i,index:s,nodes:c}}function G(n,t){if(!(n==null||typeof n=="boolean")){if(Array.isArray(n)){for(let e=0;e<n.length;e++)G(n[e],t);return}if(typeof n=="object"&&typeof n.nodeType=="number"){t.push(n);return}t.push(document.createTextNode(String(n)))}}var Rn=new Set(["click","dblclick","contextmenu","input","beforeinput","change","keydown","keyup","keypress","pointerdown","pointerup","pointermove","mousedown","mouseup","mouseover","mouseout","submit","focusin","focusout","touchstart","touchend"]),X=new Set;function R(n){return`$firsthand$${n}`}function Nn(n){let t=R(n.type),e=n.composedPath(),o=null;Object.defineProperty(n,"currentTarget",{configurable:!0,get:()=>o});for(let r=0;r<e.length;r++){let i=e[r],s=i[t];if(s!==void 0&&(o=i,s.call(i,n),n.cancelBubble)||i===document)break}o=null}function y(n,t,e,o){if(o!==void 0||!Rn.has(t)){n.addEventListener(t,e,o===!0?void 0:o);return}n[R(t)]=e,X.has(t)||(X.add(t),document.addEventListener(t,Nn))}function Jn(n,t){n[R(t)]=void 0}var An={class:"className",for:"htmlFor"};function A(n,t,e){e==null||e===!1?n.removeAttribute(t):n.setAttribute(t,e===!0?"":String(e))}function Un(n,t,e,o){o==null||o===!1?n.removeAttributeNS(t,e):n.setAttributeNS(t,e,o===!0?"":String(o))}function P(n,t,e){n[An[t]??t]=e}function ne(n,t,e){n[t]=!!e}function Q(n,t){t==null?n.removeAttribute("class"):n.className=String(t)}function U(n,t,e){let o=n.classList;if(e!==void 0)for(let r in e)r in t||o.remove(r);for(let r in t){let i=!!t[r];(e===void 0||!!e[r]!==i)&&o.toggle(r,i)}}function nn(n,t){t==null?n.style.cssText="":n.style.cssText=String(t)}function en(n,t,e){let o=n.style;if(e!==void 0)for(let r in e)r in t||o.removeProperty(N(r));for(let r in t){let i=t[r];(e===void 0||e[r]!==i)&&(i==null?o.removeProperty(N(r)):o.setProperty(N(r),String(i)))}}var Pn=/[A-Z]/g,J=new Map;function N(n){let t=J.get(n);return t===void 0&&(t=n.startsWith("--")?n:n.replace(Pn,e=>`-${e.toLowerCase()}`),J.set(n,t)),t}function Sn(n,t,e){if(t==="class"||t==="className"){e!==null&&typeof e=="object"?U(n,e,on(n,"class",e)):Q(n,e);return}if(t==="style"){e!==null&&typeof e=="object"?en(n,e,on(n,"style",e)):nn(n,e);return}if(t==="ref"){e(n);return}if(t.startsWith("prop:")){P(n,t.slice(5),e);return}if(t.startsWith("attr:")){A(n,t.slice(5),e);return}if(t.startsWith("on")&&t.length>2&&/[A-Z:]/.test(t[2])){On(n,t,e);return}if(t in n&&typeof e!="string"){P(n,t,e);return}A(n,t,e)}function On(n,t,e){let o=t.slice(2).split(":"),r=o[0]==="",i=r?o[1]:o[0].toLowerCase(),s=o[r?2:1];s===void 0?y(n,i,e):s==="native"?y(n,i,e,!0):y(n,i,e,{[s]:!0})}function re(n,t){for(let e in t)e!=="children"&&Sn(n,e,t[e])}function ie(...n){let t={};for(let e=0;e<n.length;e++){let o=n[e];for(let r of Object.keys(o))Object.defineProperty(t,r,{enumerable:!0,configurable:!0,get:()=>o[r]})}return t}function se(n,t){let e={};for(let o of Object.keys(n))t.includes(o)||Object.defineProperty(e,o,{enumerable:!0,get:()=>n[o]});return Object.freeze(e)}var tn=new WeakMap;function on(n,t,e){let o=tn.get(n);o===void 0&&(o={},tn.set(n,o));let r=o[t];return o[t]=e,r}export{$n as a,x as b,jn as c,M as d,p as e,un as f,z as g,Vn as h,_n as i,zn as j,mn as k,wn as l,Gn as m,y as n,Jn as o,A as p,Un as q,P as r,ne as s,Q as t,U as u,nn as v,en as w,Sn as x,re as y,ie as z,se as A};

package/dist/component.d.ts

@@ -0,0 +1,99 @@
+import type { ReadonlyProps } from '@firsthandjs/core';
+import { type DynamicChild } from './insert.js';
+/** Marks a value as a Firsthand component; used by the JSX runtime and compiler. */
+export declare const COMPONENT: unique symbol;
+export interface ComponentOptions {
+    /** Attach a shadow root to the element host. Implies `tag` (ADR-0007). */
+    shadow?: boolean;
+    /** Host this component in a real custom element (ADR-0003). */
+    tag?: true | string;
+    /** Explicit attribute codecs for vanilla-HTML consumers of the element. */
+    attributes?: Readonly<Record<string, AttributeCodec>>;
+}
+/** Converts an attribute string to a prop value. `null` means "absent". */
+export type AttributeCodec = (raw: string | null) => unknown;
+/**
+ * Anything a component or a dynamic expression may produce.
+ *
+ * `JSX.Element` is an alias of this, so TSX and the runtime agree on what a
+ * view is instead of one of them describing the other loosely.
+ *
+ * `DynamicChild` is in the union because a deferred child position is a real
+ * thing a view can be: it is what the compiler emits for a dynamic child of a
+ * fragment, and what a component returns when it renders something that has to
+ * be bound after it is placed — a route outlet, for instance.
+ */
+export type View = Node | string | number | boolean | null | undefined | DynamicChild | readonly View[];
+/**
+ * Props as a *caller* may write them.
+ *
+ * An optional prop accepts an explicit `undefined`. Under
+ * `exactOptionalPropertyTypes` it otherwise would not, and `count={maybe}`
+ * — where `maybe` is `number | undefined` — would be an error although
+ * "absent" and "undefined" mean exactly the same thing to the component that
+ * receives it. Required props are untouched.
+ */
+export type PropsArgument<P> = {
+    [K in keyof P]: undefined extends P[K] ? P[K] | undefined : P[K];
+};
+export interface Component<P> {
+    /**
+     * Creates an instance.
+     *
+     * This is a real call: `<Counter initial={1} />` compiles to
+     * `createComponent(Counter, ...)`, and calling `Counter({ initial: 1 })`
+     * does the same thing. The signature is also what makes a component a valid
+     * TSX element type without any JSX-namespace special-casing.
+     */
+    (props: PropsArgument<P>): View;
+    readonly [COMPONENT]: true;
+    readonly setup: (props: ReadonlyProps<P>) => View;
+    readonly options: ComponentOptions | undefined;
+    /** Stable build id from the compiler; never `Function.name` (ADR-0004). */
+    readonly id: string;
+    /** Original identifier, for devtools and error messages. */
+    readonly name: string;
+    /** Registered custom element name, once `defineElement` has run. */
+    tag: string | undefined;
+}
+/**
+ * Sets the prefix for custom element names. Call once, at startup.
+ *
+ * `setElementPrefix('acme')` makes `UserCard` register as `<acme-user-card>`.
+ * The prefix is the only thing an application has to say about element names:
+ * the rest is derived from the binding the component was assigned to.
+ */
+export declare function setElementPrefix(value: string): void;
+/**
+ * Declares a component.
+ *
+ * The setup function runs exactly once per instance. The component's identity
+ * is the binding you assign it to — there is no name string to repeat, and no
+ * reliance on `Function.name`, which minifiers rewrite (ADR-0004).
+ */
+export declare function component<P>(setup: (props: ReadonlyProps<P>) => View, options?: ComponentOptions, id?: string, name?: string): Component<P>;
+export declare function isComponent(value: unknown): value is Component<never>;
+/**
+ * Instantiates a component.
+ *
+ * `props` arrives exactly as the caller built it: object references are
+ * preserved, nothing is serialised or copied, and dynamic props are accessor
+ * properties so that reading them subscribes to whatever the parent read
+ * (ADR-0005). The object itself is frozen, so top-level props have no writable
+ * slots; the values it points at are the caller's own and are never touched.
+ *
+ * Setup runs untracked: a component created inside a conditional part must not
+ * subscribe that part to everything its setup happens to read.
+ */
+export declare function createComponent<P>(target: Component<P>, props: P): View;
+/** `UserCard` -> `acme-user-card`, using the prefix `setElementPrefix` holds. */
+export declare function tagNameFor(target: Component<unknown>): string;
+/**
+ * Registers a component as a real custom element.
+ *
+ * This is the opt-in half of ADR-0003: components are hostless by default
+ * because an upgraded custom element costs a constructor call, an upgrade
+ * reaction and an extra node per instance.
+ */
+export declare function defineElement(target: Component<never>, tag?: string): string;
+//# sourceMappingURL=component.d.ts.map

package/dist/component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component.d.ts","sourceRoot":"","sources":["../src/component.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAGvD,OAAO,EAAc,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AAE5D,oFAAoF;AACpF,eAAO,MAAM,SAAS,EAAE,OAAO,MAA0C,CAAC;AAE1E,MAAM,WAAW,gBAAgB;IAC/B,0EAA0E;IAC1E,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,+DAA+D;IAC/D,GAAG,CAAC,EAAE,IAAI,GAAG,MAAM,CAAC;IACpB,2EAA2E;IAC3E,UAAU,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,CAAC;CACvD;AAED,2EAA2E;AAC3E,MAAM,MAAM,cAAc,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,KAAK,OAAO,CAAC;AAE7D;;;;;;;;;;GAUG;AACH,MAAM,MAAM,IAAI,GACd,IAAI,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,GAAG,YAAY,GAAG,SAAS,IAAI,EAAE,CAAC;AAEvF;;;;;;;;GAQG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI;KAC5B,CAAC,IAAI,MAAM,CAAC,GAAG,SAAS,SAAS,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,SAAS,GAAG,CAAC,CAAC,CAAC,CAAC;CACjE,CAAC;AAEF,MAAM,WAAW,SAAS,CAAC,CAAC;IAC1B;;;;;;;OAOG;IACH,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAChC,QAAQ,CAAC,CAAC,SAAS,CAAC,EAAE,IAAI,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;IAClD,QAAQ,CAAC,OAAO,EAAE,gBAAgB,GAAG,SAAS,CAAC;IAC/C,2EAA2E;IAC3E,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,4DAA4D;IAC5D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,oEAAoE;IACpE,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;CACzB;AAKD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAEpD;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACzB,KAAK,EAAE,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,IAAI,EACxC,OAAO,CAAC,EAAE,gBAAgB,EAC1B,EAAE,CAAC,EAAE,MAAM,EACX,IAAI,CAAC,EAAE,MAAM,GACZ,SAAS,CAAC,CAAC,CAAC,CAgCd;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,SAAS,CAAC,KAAK,CAAC,CAErE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CA4BvE;AAcD,iFAAiF;AACjF,wBAAgB,UAAU,CAAC,MAAM,EAAE,SAAS,CAAC,OAAO,CAAC,GAAG,MAAM,CAM7D;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,SAAS,CAAC,KAAK,CAAC,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAc5E"}

package/dist/dev.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Development-only diagnostics.
+ *
+ * There is deliberately no `if (DEV)` guard at any call site: the production
+ * build aliases this module to `dev.prod.ts`, whose functions have empty bodies
+ * and are removed by the minifier. That keeps the production bundle free of
+ * diagnostics without creating branches that can never be taken in tests — see
+ * ARCHITECTURE section 8, item 6.
+ */
+export declare function devWarn(message: string): void;
+/** Warns at most once for a given key, so a repeated mistake is not spam. */
+export declare function devWarnOnce(key: string, message: string): void;
+//# sourceMappingURL=dev.d.ts.map

package/dist/dev.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../src/dev.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,wBAAgB,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAE7C;AAID,6EAA6E;AAC7E,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAK9D"}

package/dist/dev.prod.d.ts

@@ -0,0 +1,4 @@
+/** Production stub for `dev.ts`. Aliased in by the build; see `dev.ts`. */
+export declare function devWarn(_message: string): void;
+export declare function devWarnOnce(_key: string, _message: string): void;
+//# sourceMappingURL=dev.prod.d.ts.map

package/dist/dev.prod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev.prod.d.ts","sourceRoot":"","sources":["../src/dev.prod.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAE3E,wBAAgB,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAE9C;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAEhE"}

package/dist/events.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Native events with delegation (ADR-0012).
+ *
+ * There is no synthetic event: handlers receive the browser's own `Event`.
+ * For the bubbling types below, one real listener per type is installed on the
+ * document and dispatch walks the real `composedPath()`, so mounting 100 000
+ * rows registers zero listeners.
+ */
+/**
+ * Attaches an event handler.
+ *
+ * `options` forces a direct listener: capture, once and passive cannot be
+ * expressed through delegation, and forcing one is also the documented escape
+ * hatch when a handler must run before a listener attached further up.
+ */
+export declare function on(node: Element, type: string, handler: (event: Event) => void, options?: AddEventListenerOptions | true): void;
+/** Removes a delegated handler. Direct listeners die with their node. */
+export declare function off(node: Element, type: string): void;
+/** Test-only: forgets which document listeners were installed. */
+export declare function resetDelegation(): void;
+//# sourceMappingURL=events.d.ts.map

package/dist/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../src/events.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAkEH;;;;;;GAMG;AACH,wBAAgB,EAAE,CAChB,IAAI,EAAE,OAAO,EACb,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,EAC/B,OAAO,CAAC,EAAE,uBAAuB,GAAG,IAAI,GACvC,IAAI,CAUN;AAED,yEAAyE;AACzE,wBAAgB,GAAG,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAIrD;AAED,kEAAkE;AAClE,wBAAgB,eAAe,IAAI,IAAI,CAKtC"}

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * `@firsthandjs/dom` — DOM parts, components, portals and keyed lists.
+ *
+ * Re-exports the reactive core so that applications have one import site.
+ */
+export { component, defineElement, setElementPrefix, createComponent } from './component.js';
+export { setComponentAdapter, FirsthandComponentError } from './adapter.js';
+export type { ComponentAdapter } from './adapter.js';
+export type { Component, ComponentOptions, AttributeCodec, View } from './component.js';
+export { render } from './render.js';
+export { portal } from './portal.js';
+export { list } from './list.js';
+export { on, off } from './events.js';
+export { mergeProps } from './props.js';
+export { signal, computed, effect, batch, untrack, onCleanup, createRoot, catchError, runWithOwner, createContext, provide, useContext, FirsthandContextError, FirsthandCycleError, FirsthandReadonlyError, } from '@firsthandjs/core';
+export type { CellOptions, Context, DeepReadonly, Dispose, ReadonlyCell, ReadonlyProps, Signal, } from '@firsthandjs/core';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAC7F,OAAO,EAAE,mBAAmB,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AAC5E,YAAY,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACrD,YAAY,EAAE,SAAS,EAAE,gBAAgB,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AACxF,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,EAAE,EAAE,GAAG,EAAE,MAAM,aAAa,CAAC;AACtC,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAExC,OAAO,EACL,MAAM,EACN,QAAQ,EACR,MAAM,EACN,KAAK,EACL,OAAO,EACP,SAAS,EACT,UAAU,EACV,UAAU,EACV,YAAY,EACZ,aAAa,EACb,OAAO,EACP,UAAU,EACV,qBAAqB,EACrB,mBAAmB,EACnB,sBAAsB,GACvB,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EACV,WAAW,EACX,OAAO,EACP,YAAY,EACZ,OAAO,EACP,YAAY,EACZ,aAAa,EACb,MAAM,GACP,MAAM,mBAAmB,CAAC"}

package/dist/index.js

@@ -0,0 +1 @@
+import{a as d,b as i,e as p,h as s,i as m,k as f,l as a,m as c,n as u,o as C,z as x}from"./chunk-6OTA5OKE.js";import{createRoot as y,onCleanup as h,untrack as N}from"@firsthandjs/core";function g(e,r=document.body){let o;return y(t=>{o=t;let n=null;n=p(r,null,null,N(e)),h(()=>{p(r,null,n,null)})}),o}import{onCleanup as E}from"@firsthandjs/core";function b(e,r){let o=[];l(e,o);for(let t=0;t<o.length;t++)r.appendChild(o[t]);return E(()=>{for(let t=0;t<o.length;t++){let n=o[t];n.parentNode?.removeChild(n)}}),null}function l(e,r){if(!(e==null||typeof e=="boolean")){if(Array.isArray(e)){for(let o=0;o<e.length;o++)l(e[o],r);return}if(typeof e=="object"&&typeof e.nodeType=="number"){r.push(e);return}r.push(document.createTextNode(String(e)))}}import{signal as z,computed as B,effect as G,batch as H,untrack as I,onCleanup as J,createRoot as K,catchError as L,runWithOwner as M,createContext as Q,provide as U,useContext as X,FirsthandContextError as Y,FirsthandCycleError as Z,FirsthandReadonlyError as _}from"@firsthandjs/core";export{i as FirsthandComponentError,Y as FirsthandContextError,Z as FirsthandCycleError,_ as FirsthandReadonlyError,H as batch,L as catchError,m as component,B as computed,f as createComponent,Q as createContext,K as createRoot,a as defineElement,G as effect,c as list,x as mergeProps,C as off,u as on,J as onCleanup,b as portal,U as provide,g as render,M as runWithOwner,d as setComponentAdapter,s as setElementPrefix,z as signal,I as untrack,X as useContext};

package/dist/insert.d.ts

@@ -0,0 +1,59 @@
+import { type Owner } from '@firsthandjs/core';
+/** What a child part currently owns in the DOM. */
+export type ChildSlot = Node | Node[] | null;
+declare const PART: unique symbol;
+/**
+ * A dynamic child inside an array, carrying the scope it was written in.
+ *
+ * A fragment has no element of its own, so its children cannot be bound when
+ * they are created: there is no parent to insert into yet. Deferring the whole
+ * child to insertion time would evaluate it under whoever performs the
+ * insertion — the wrong scope, which loses context and disposal, and which does
+ * not make it reactive at all.
+ *
+ * So a fragment's dynamic child is emitted as one of these: an anchor that
+ * takes its place in the array, plus the expression and the owner it belongs
+ * to. Once the array is in the DOM, each one is bound through `insert` under
+ * its own owner, exactly as a child of a real element would be.
+ */
+export interface DynamicChild {
+    readonly [PART]: true;
+    readonly anchor: Text;
+    readonly thunk: () => unknown;
+    readonly owner: Owner | null;
+}
+/** Marks a dynamic child of a fragment. Emitted by the compiler. */
+export declare function part(thunk: () => unknown): DynamicChild;
+/**
+ * Binds a dynamic child position.
+ *
+ * `value` is a thunk when the compiler could not prove the expression constant.
+ * The thunk is evaluated once inside a tracking scope; if it read nothing
+ * reactive, no effect is retained (ADR-0009).
+ */
+export declare function insert(parent: Node, value: unknown, marker?: Node | null): void;
+/** Applies one value to a child slot and returns the slot's new contents. */
+export declare function applyChild(parent: Node, marker: Node | null, current: ChildSlot, value: unknown): ChildSlot;
+/**
+ * Reconciles two node lists in place, by node identity.
+ *
+ * Keyed lists reuse their rows' DOM nodes across reorders, so identity is
+ * exactly the right key here: a row that survived is the same node, and only
+ * nodes that genuinely moved are touched.
+ *
+ * The algorithm is a common-prefix/suffix trim, then a longest-increasing-
+ * subsequence over the surviving nodes, moving only the ones outside it — the
+ * provably minimal number of `insertBefore` calls.
+ *
+ * This is the outcome of the comparison ADR-0010 required, not an assumption:
+ * three candidates were measured over ten operations at two sizes, with the
+ * order rotated per repetition and correctness asserted on every run. LIS came
+ * out ahead overall (1.02 against 1.17 for the two-ended scan and 1.49 for the
+ * naive baseline) and decisively where moves are few and far apart — a swap at
+ * 10 000 rows costs it 2 moves instead of 9 997. It loses one case: a full
+ * reverse, where the subsequence is length 1 and the analysis buys nothing.
+ * That trade is published in `benchmarks/results/reconcilers.json`.
+ */
+export declare function reconcile(parent: Node, marker: Node | null, a: Node[], b: Node[]): void;
+export {};
+//# sourceMappingURL=insert.d.ts.map

package/dist/insert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"insert.d.ts","sourceRoot":"","sources":["../src/insert.ts"],"names":[],"mappings":"AAAA,OAAO,EAA2C,KAAK,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAExF,mDAAmD;AACnD,MAAM,MAAM,SAAS,GAAG,IAAI,GAAG,IAAI,EAAE,GAAG,IAAI,CAAC;AAQ7C,QAAA,MAAM,IAAI,EAAE,OAAO,MAAiC,CAAC;AAErD;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,OAAO,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CAC9B;AAED,oEAAoE;AACpE,wBAAgB,IAAI,CAAC,KAAK,EAAE,MAAM,OAAO,GAAG,YAAY,CAEvD;AAMD;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,GAAE,IAAI,GAAG,IAAW,GAAG,IAAI,CA4BrF;AAED,6EAA6E;AAC7E,wBAAgB,UAAU,CACxB,MAAM,EAAE,IAAI,EACZ,MAAM,EAAE,IAAI,GAAG,IAAI,EACnB,OAAO,EAAE,SAAS,EAClB,KAAK,EAAE,OAAO,GACb,SAAS,CAqDX;AAmED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,GAAG,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,GAAG,IAAI,CAqEvF"}

package/dist/internal.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The compiler/runtime protocol (ARCHITECTURE section 1.1).
+ *
+ * The compiler has no privileged access to runtime internals: it emits calls
+ * against exactly this surface, which is also importable by hand. That is what
+ * makes "no benchmark-only runtime" an enforceable property rather than a
+ * promise — the benchmark, the examples and the tests all go through here.
+ *
+ * Breaking changes to this surface bump `PROTOCOL_VERSION`, and the compiler
+ * emits a version assertion so a mismatched pair fails loudly at build time.
+ */
+export declare const PROTOCOL_VERSION = 1;
+export { template, path } from './template.js';
+export { insert, applyChild, reconcile, part } from './insert.js';
+export type { DynamicChild, ChildSlot } from './insert.js';
+export { setAttribute, setAttributeNS, setProperty, setBoolean, setClass, setClassList, setStyle, setStyleObject, } from './attributes.js';
+export { on, off } from './events.js';
+export { applyProp, spread, mergeProps, rest } from './props.js';
+export { bind } from '@firsthandjs/core';
+export { list } from './list.js';
+export { createComponent, isComponent, COMPONENT } from './component.js';
+//# sourceMappingURL=internal.d.ts.map

package/dist/internal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../src/internal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,eAAO,MAAM,gBAAgB,IAAI,CAAC;AAElC,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAClE,YAAY,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC3D,OAAO,EACL,YAAY,EACZ,cAAc,EACd,WAAW,EACX,UAAU,EACV,QAAQ,EACR,YAAY,EACZ,QAAQ,EACR,cAAc,GACf,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,EAAE,EAAE,GAAG,EAAE,MAAM,aAAa,CAAC;AACtC,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AACjE,OAAO,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AACzC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,eAAe,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/internal.js

@@ -0,0 +1 @@
+import{A as L,c as l,d as s,e as i,f as a,g as m,j as d,k as f,m as c,n as u,o as x,p as N,q as y,r as C,s as h,t as b,u as O,v as S,w as P,x as T,y as g,z as E}from"./chunk-6OTA5OKE.js";function j(r,o=!1){let e;return()=>{if(e===void 0){let t=document.createElement("template");t.innerHTML=r,e=o?t.content:t.content.firstChild}return e.cloneNode(!0)}}function A(r,...o){let e=r;for(let t=0;t<o.length;t++){let n=e.firstChild;for(let p=o[t];p>0;p--)n=n.nextSibling;e=n}return e}import{bind as k}from"@firsthandjs/core";var M=1;export{m as COMPONENT,M as PROTOCOL_VERSION,i as applyChild,T as applyProp,k as bind,f as createComponent,s as insert,d as isComponent,c as list,E as mergeProps,x as off,u as on,l as part,A as path,a as reconcile,L as rest,N as setAttribute,y as setAttributeNS,h as setBoolean,b as setClass,O as setClassList,C as setProperty,S as setStyle,P as setStyleObject,g as spread,j as template};

package/dist/list.d.ts

@@ -0,0 +1,18 @@
+import { type ReadonlyCell } from '@firsthandjs/core';
+/**
+ * A keyed list part.
+ *
+ * `list()` is called while the template is being built, so it captures the
+ * component's owner. Rows are created under a dedicated child of that owner and
+ * therefore survive the list's own re-evaluation — unlike everything created
+ * directly inside the enclosing effect, which is cleared on each run.
+ *
+ * A row that keeps its key keeps its DOM nodes, its owner and its component
+ * state across reorders; only its `item` and `index` cells are updated, so a
+ * reorder touches exactly the parts that read the index and nothing else.
+ *
+ * The returned thunk produces the row nodes in order; `insert` reconciles them
+ * by node identity (see `insert.ts` and ADR-0010).
+ */
+export declare function list<T>(each: () => readonly T[], keyOf: (item: T, index: number) => unknown, render: (item: ReadonlyCell<T>, index: ReadonlyCell<number>) => unknown): () => Node[];
+//# sourceMappingURL=list.d.ts.map

package/dist/list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../src/list.ts"],"names":[],"mappings":"AAAA,OAAO,EASL,KAAK,YAAY,EAElB,MAAM,mBAAmB,CAAC;AAU3B;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,IAAI,CAAC,CAAC,EACpB,IAAI,EAAE,MAAM,SAAS,CAAC,EAAE,EACxB,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,EAC1C,MAAM,EAAE,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,YAAY,CAAC,MAAM,CAAC,KAAK,OAAO,GACtE,MAAM,IAAI,EAAE,CAuCd"}

package/dist/portal.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Renders `view` into `target`, keeping its logical owner where it was written.
+ *
+ * `view` is an ordinary expression, so it has already been created under the
+ * current scope by the time `portal` sees it. Context, disposal, reactive
+ * dependencies, event handling and error ownership all follow the owner tree
+ * (ADR-0008), so moving the nodes changes nothing but their physical position.
+ *
+ * The call contributes nothing at its own position in the tree.
+ */
+export declare function portal(view: unknown, target: ParentNode): null;
+//# sourceMappingURL=portal.d.ts.map

package/dist/portal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"portal.d.ts","sourceRoot":"","sources":["../src/portal.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,GAAG,IAAI,CAa9D"}

package/dist/props.d.ts

@@ -0,0 +1,38 @@
+/**
+ * The generic property applier.
+ *
+ * The compiler emits specialised setters wherever it knows the kind of a part,
+ * so this function is only reached by `class`/`style` (which genuinely accept
+ * several shapes), by spread attributes, and by the runtime JSX path. It is
+ * deliberately not on any hot path the compiler controls.
+ */
+export declare function applyProp(node: Element, name: string, value: unknown): void;
+/**
+ * `onClick`, `onClick:capture`, and `on:sl-change` for a literal event name.
+ *
+ * The camel-case form lowercases, which is right for every DOM event and
+ * wrong for the ones component libraries invent: Shoelace dispatches
+ * `sl-change`, Vaadin `value-changed`, and no casing of an identifier
+ * produces a hyphen. `on:` takes what follows verbatim, so those work without
+ * a ref and an `addEventListener` by hand.
+ */
+export declare function applyEvent(node: Element, name: string, value: unknown): void;
+/** Applies a spread of props to an element. */
+export declare function spread(node: Element, props: Record<string, unknown>): void;
+/**
+ * Merges prop sources without flattening their accessors.
+ *
+ * `{...a} {...b}` must not snapshot: every key becomes a getter that delegates
+ * to the source, so a reactive prop stays reactive through a spread.
+ */
+export declare function mergeProps(...sources: Record<string, unknown>[]): Record<string, unknown>;
+/**
+ * The remaining props, as live reads.
+ *
+ * `component(({ a, ...rest }) => ...)` compiles to a call to this. The result
+ * delegates every key back to the original props object, so a prop that
+ * changes is still seen through `rest` — copying the values instead would
+ * reintroduce exactly the snapshot the rewrite exists to remove.
+ */
+export declare function rest(props: Record<string, unknown>, omit: readonly string[]): Record<string, unknown>;
+//# sourceMappingURL=props.d.ts.map

package/dist/props.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"props.d.ts","sourceRoot":"","sources":["../src/props.ts"],"names":[],"mappings":"AAUA;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CA0C3E;AAED;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAa5E;AAED,+CAA+C;AAC/C,wBAAgB,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAM1E;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,GAAG,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAazF;AAED;;;;;;;GAOG;AACH,wBAAgB,IAAI,CAClB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,IAAI,EAAE,SAAS,MAAM,EAAE,GACtB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAWzB"}

package/dist/render.d.ts

@@ -0,0 +1,13 @@
+import { type Dispose } from '@firsthandjs/core';
+import type { View } from './component.js';
+/**
+ * Mounts a view and returns its disposer.
+ *
+ * The container defaults to `document.body`, so an application needs no
+ * element lookup and no cast to start. Everything the view creates belongs to
+ * this root, so `dispose()` unsubscribes every effect, runs every cleanup and
+ * removes exactly the nodes that were inserted — not the container's other
+ * children.
+ */
+export declare function render(view: () => View, container?: ParentNode): Dispose;
+//# sourceMappingURL=render.d.ts.map

package/dist/render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../src/render.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkC,KAAK,OAAO,EAAE,MAAM,mBAAmB,CAAC;AACjF,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAG3C;;;;;;;;GAQG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,IAAI,EAAE,SAAS,GAAE,UAA0B,GAAG,OAAO,CAWvF"}

package/dist/template.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Static markup is parsed once into a `<template>` and cloned per instance
+ * (ADR-0009). The compiler emits one `template()` call per distinct markup
+ * shape at module scope; parsing is deferred to the first instance, so a module
+ * that is imported but never rendered costs nothing.
+ */
+export type TemplateFactory = () => Node;
+export declare function template(html: string, isFragment?: boolean): TemplateFactory;
+/**
+ * Descends to a node by a compile-time-known chain of child indices.
+ *
+ * This is how dynamic positions are located: no `querySelector`, no marker
+ * attributes, no scanning. The compiler knows the shape of the template, so it
+ * emits the path.
+ */
+export declare function path(root: Node, ...indices: readonly number[]): Node;
+//# sourceMappingURL=template.d.ts.map

package/dist/template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template.d.ts","sourceRoot":"","sources":["../src/template.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,MAAM,eAAe,GAAG,MAAM,IAAI,CAAC;AAEzC,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,UAAQ,GAAG,eAAe,CAU1E;AAED;;;;;;GAMG;AACH,wBAAgB,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,CAUpE"}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@firsthandjs/dom",
+  "version": "0.1.0",
+  "description": "DOM parts, templates, components, portals and keyed lists for Firsthand.",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./internal": {
+      "types": "./dist/internal.d.ts",
+      "default": "./dist/internal.js"
+    }
+  },
+  "types": "./dist/index.d.ts",
+  "main": "./dist/index.js",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@firsthandjs/core": "0.1.0"
+  },
+  "engines": {
+    "node": ">=20.11.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/firsthandjs/firsthand.git",
+    "directory": "packages/dom"
+  },
+  "bugs": {
+    "url": "https://github.com/firsthandjs/firsthand/issues"
+  },
+  "homepage": "https://github.com/firsthandjs/firsthand#readme",
+  "keywords": [
+    "reactive",
+    "signals",
+    "fine-grained",
+    "web-components",
+    "ui",
+    "framework",
+    "jsx",
+    "no-virtual-dom"
+  ]
+}