@nativele/ts-dom 0.4.0 → 0.4.6

package/dist/index.d.mts

@@ -176,7 +176,15 @@ export declare function event<T = void>(opts?: {
 type DetailOf<D> = D extends EventDecl<infer T> ? T : never;
 type EmitArgs<D> = [DetailOf<D>] extends [void] ? [detail?: undefined] : [detail: DetailOf<D>];
 /** The data passed to render(): state, props and derived values merged. */
-type View<D, R> = Readonly<D> & Readonly<R>;
+/**
+ * Read-only all the way down: arrays, objects, Maps and Sets inside it cannot be changed through it.
+ * State, props and derived values are typed this way, so changing an object in place instead of passing a new one is a tsc error.
+ */
+type DeepReadonly<T> = T extends ((...args: never[]) => unknown) ? T : T extends Node | Date | RegExp | Promise<unknown> ? T : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, DeepReadonly<V>> : T extends ReadonlySet<infer V> ? ReadonlySet<DeepReadonly<V>> : T extends readonly unknown[] ? { readonly [K in keyof T]: DeepReadonly<T[K]>; } : T extends object ? IsPlainObject<T> extends true ? { readonly [K in keyof T]: DeepReadonly<T[K]>; } : T : T;
+type IsPlainObject<T> = { [K in keyof T]: T[K]; } extends T ? true : false;
+/** Props as the element exposes them: the parent assigns them, but cannot change the objects inside through them. */
+type PropAccessors<P> = { -readonly [K in keyof P]: DeepReadonly<P[K]>; };
+type View<D, R> = DeepReadonly<D> & DeepReadonly<R>;
 interface DataOptions<St extends object, P extends object, R, E extends Record<string, EventDecl<unknown>>> extends ComponentOptions {
   /** Data owned by the component and changed only through set(). Fields named like a {{ hole }} or data-if in the HTML bind automatically. */
   state?: St;
@@ -190,7 +198,7 @@ interface DataOptions<St extends object, P extends object, R, E extends Record<s
    * Derived values: computed from state and props, usable directly by {{ holes }}, data-if and render().
    * Recomputed after every data change (there is no dependency tracking).
    */
-  derive?: { [K in keyof R]: (s: Readonly<St & P>) => R[K]; };
+  derive?: { [K in keyof R]: (s: DeepReadonly<St & P>) => R[K]; };
   /** The events this component emits. */
   emits?: E;
 }
@@ -246,14 +254,14 @@ interface ComponentInstance<S extends Schema> extends HTMLElement {
 /** Members added when the `state` / `props` / `derive` / `emits` options are used. */
 interface StatefulInstance<S extends Schema, St extends object, P extends object, R, E extends Record<string, EventDecl<unknown>>> extends ComponentInstance<S> {
   /** The component's own data (read-only). Use set() to change it. */
-  readonly state: Readonly<St>;
+  readonly state: DeepReadonly<St>;
   /** Data provided by the parent (read-only). Do not assign it inside the component; use emit() to notify the parent. */
-  readonly props: Readonly<P>;
+  readonly props: DeepReadonly<P>;
   /**
    * The only way to change state: shallow-merges the patch, and does nothing when no field actually changed.
    * When something changed it synchronously updates the same-named {{ holes }} and data-if, then calls render(). It cannot change props.
    */
-  set(patch: Partial<St> | ((s: Readonly<St>) => Partial<St>)): void;
+  set(patch: Partial<DeepReadonly<St>> | ((s: DeepReadonly<St>) => Partial<DeepReadonly<St>>)): void;
   /** Coalesce several set() calls and prop changes: the view is updated and render() is called once, after fn returns. */
   batch(fn: () => void): void;
   /**
@@ -284,7 +292,7 @@ export declare function Component<S extends Schema>(tpl: Template<S>, opts?: Com
  * `reservedPropNames` (a prop shares a name with HTMLElement or a ts-dom member), `nativeEventNames` (emits shares a name with a native event).
  * (The check lives in the return type, not in the parameter: in the parameter it prevents TypeScript from inferring the type of derive.)
  */
-export declare function Component<S extends Schema, St extends object = Record<never, never>, P extends object = Record<never, never>, R = Record<never, never>, E extends Record<string, EventDecl<unknown>> = Record<never, never>>(tpl: Template<S>, opts: DataOptions<St, P, R, E>): IsClean<Problems<S, St, P, R, E>> extends true ? new () => StatefulInstance<S, St, P, R, E> & P : Problems<S, St, P, R, E>;
+export declare function Component<S extends Schema, St extends object = Record<never, never>, P extends object = Record<never, never>, R = Record<never, never>, E extends Record<string, EventDecl<unknown>> = Record<never, never>>(tpl: Template<S>, opts: DataOptions<St, P, R, E>): IsClean<Problems<S, St, P, R, E>> extends true ? new () => StatefulInstance<S, St, P, R, E> & PropAccessors<P> : Problems<S, St, P, R, E>;
 type CheckHandlers<I> = I extends {
   readonly "~events"?: infer E;
 } ? [Exclude<NonNullable<E>, keyof I>] extends [never] ? unknown : {
@@ -295,4 +303,4 @@ type CheckHandlers<I> = I extends {
  * component as a public method, otherwise tsc reports an error that lists the missing names (`missingHandlers`).
  */
 export declare function define<C extends abstract new (...args: never[]) => HTMLElement>(name: string, ctor: C & CheckHandlers<InstanceType<C>>): void;
-export type { ComponentInstance, ComponentOptions, DataOptions, El, EmitEvent, EventDecl, EventHit, ItemContext, ListItem, ListSchema, ReadableStore, ReplaceOptions, Schema, StatefulInstance, Store, Template, TemplateInstance, TextOf, TextValue, Update, View };
+export type { ComponentInstance, ComponentOptions, DataOptions, DeepReadonly, El, EmitEvent, EventDecl, EventHit, ItemContext, ListItem, ListSchema, PropAccessors, ReadableStore, ReplaceOptions, Schema, StatefulInstance, Store, Template, TemplateInstance, TextOf, TextValue, Update, View };

package/dist/index.mjs

@@ -228,7 +228,7 @@ var List = class {
 		if (!this.binding) throw new Error("[list-not-bound] this list has no data-key and data-prop, so its items cannot be assigned. Fix: add them to the <template data-each>, e.g. data-key=\"id\" data-prop=\"item\", or call replace().");
 		if (!Array.isArray(items)) throw new Error(`[invalid-items] items must be an array of objects, but got ${items === null ? "null" : typeof items}. Fix: assign an array, for example items = view.todos ?? [].`);
 		if (items.length) this.#checkProp();
-		this.replace(items, this.#keyOf, this.#assign, { skipUnchanged: true });
+		this.#reconcile(items, this.#keyOf, this.#assign, true, true);
 	}
 	#checkProp() {
 		const prop = this.binding?.prop;
@@ -263,7 +263,7 @@ var List = class {
 		return this.#items.get(key);
 	}
 	#create(key) {
-		const el = this.proto.cloneNode(true);
+		const el = this.binding ? document.importNode(this.proto, true) : this.proto.cloneNode(true);
 		const holder = document.createDocumentFragment();
 		holder.append(el);
 		const conds = mountConds(holder);
@@ -324,6 +324,10 @@ var List = class {
 	}
 	/** Keyed reconciliation: remove extra items, create missing ones, reorder, and call update() for every item. */
 	replace(items, key, update, opts = {}) {
+		this.#reconcile(items, key, update, opts.skipUnchanged === true, false);
+	}
+	/** `updateFirst`: a new item is updated before it is inserted, so an item component is connected with its prop already set. */
+	#reconcile(items, key, update, skipUnchanged, updateFirst) {
 		const next = /* @__PURE__ */ new Set();
 		for (const it of items) {
 			const k = key(it);
@@ -340,13 +344,14 @@ var List = class {
 			if (!entry) {
 				entry = this.#create(k);
 				this.#items.set(k, entry);
+				if (updateFirst) this.#run(entry, k, it, update);
 			}
 			if (entry.el.nextSibling !== after || entry.el.parentNode !== parent) {
 				if (entry.el.parentNode === parent && parent?.moveBefore) parent.moveBefore(entry.el, after);
 				else parent?.insertBefore(entry.el, after);
 			}
 			after = entry.el;
-			this.#run(entry, k, it, update, opts.skipUnchanged);
+			this.#run(entry, k, it, update, skipUnchanged);
 		}
 	}
 };

package/dist/{lint-CqWk4U5P.mjs → lint-CP_i4VPA.mjs}

@@ -1,4 +1,4 @@
-import { a as analyze, d as listHtml, f as scanDefines } from "./a11y-Bn9pDvWV.mjs";
+import { a as analyze, f as listHtml, h as scanDefines } from "./a11y-wWL9rie7.mjs";
 import { readFileSync } from "node:fs";
 import { basename, dirname, relative } from "node:path";
 // src/lib/lint.ts
@@ -43,7 +43,8 @@ function componentClasses(code, htmlSpec) {
 		const bodyEnd = matchClose(code, bodyStart, "{", "}");
 		if (bodyEnd > 0) out.push({
 			call: code.slice(call, callEnd + 1),
-			body: code.slice(bodyStart, bodyEnd + 1)
+			body: code.slice(bodyStart, bodyEnd + 1),
+			end: bodyEnd
 		});
 	}
 	return out;

package/dist/oxlint-plugin.d.mts

@@ -4,6 +4,13 @@ interface ImportNode {
     value: string;
   };
 }
+interface Fixer {
+  insertTextBeforeRange(range: [number, number], text: string): unknown;
+}
+interface Suggestion {
+  desc: string;
+  fix(fixer: Fixer): unknown;
+}
 interface Context {
   options?: [{
     ignore?: string[];
@@ -15,6 +22,7 @@ interface Context {
   report(d: {
     message: string;
     node: unknown;
+    suggest?: Suggestion[];
   }): void;
 }
 declare const _default: {
@@ -22,7 +30,7 @@ declare const _default: {
     name: string;
   };
   rules: {
-    /** The HTML declares markup that this file never uses. Always on when enabled; reported as errors. */
+    /** The HTML declares markup that this file never uses. Reported as errors. */
     "unused-markup": {
       meta: {
         type: "suggestion";
@@ -41,6 +49,7 @@ declare const _default: {
           };
           additionalProperties: boolean;
         }[];
+        hasSuggestions: boolean;
       };
       create(context: Context): {
         ImportDeclaration(node: ImportNode): void;
@@ -65,6 +74,7 @@ declare const _default: {
           };
           additionalProperties: boolean;
         }[];
+        hasSuggestions: boolean;
       };
       create(context: Context): {
         ImportDeclaration(node: ImportNode): void;
@@ -89,6 +99,7 @@ declare const _default: {
           };
           additionalProperties: boolean;
         }[];
+        hasSuggestions: boolean;
       };
       create(context: Context): {
         ImportDeclaration(node: ImportNode): void;

package/dist/oxlint-plugin.mjs

@@ -1,5 +1,5 @@
-import { n as checkA11y } from "./a11y-Bn9pDvWV.mjs";
-import { a as dataFlow, i as contractsFor, l as templateCode, r as componentClasses, u as unusedMarkup } from "./lint-CqWk4U5P.mjs";
+import { n as checkA11y, t as A11Y_RULES } from "./a11y-wWL9rie7.mjs";
+import { a as dataFlow, i as contractsFor, l as templateCode, n as UNUSED_MARKUP_RULES, r as componentClasses, t as DATA_FLOW_RULES, u as unusedMarkup } from "./lint-CP_i4VPA.mjs";
 import { readFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 // src/lib/oxlint-plugin.ts
@@ -14,46 +14,86 @@ const ignoreSchema = [{
 /** Child component contracts, scanned once per process from the working directory. */
 let contracts = null;
 const getContracts = () => contracts ??= contractsFor([process.cwd()]);
+const cache = /* @__PURE__ */ new Map();
+function groupDiagnostics(group, html, code, spec, filename) {
+	const key = `${group}\0${filename}\0${spec}`;
+	const hit = cache.get(key);
+	if (hit && hit.code === code && hit.html === html) return hit.diags;
+	const diags = group === "unused-markup" ? unusedMarkup(html, templateCode(code, spec)) : group === "a11y" ? checkA11y(html) : dataFlow(html, componentClasses(code, spec), [], getContracts());
+	cache.set(key, {
+		code,
+		html,
+		diags
+	});
+	return diags;
+}
+function readTemplate(filename, spec) {
+	try {
+		return readFileSync(resolve(dirname(filename), spec.slice(0, -3)), "utf8");
+	} catch {
+		return null;
+	}
+}
+/** A missing handler can be added to the class that uses the template: offered as a suggestion, since the method body is the developer's to write. */
+function suggestionsFor(d, code, spec) {
+	if (d.rule !== "missing-handler") return void 0;
+	const name = /="([^"]+)"/.exec(d.message)?.[1];
+	const target = componentClasses(code, spec)[0];
+	if (!name || !target) return void 0;
+	return [{
+		desc: `Add a method ${name}() to the component class`,
+		fix: (fixer) => fixer.insertTextBeforeRange([target.end, target.end], `\n  ${name}(_e: Event): void {}\n`)
+	}];
+}
 /**
-* Build an oxlint rule that runs `check` on every `import x from "./name.html.js"` and reports the findings
+* Build an oxlint rule that checks every `import x from "./name.html.js"` and reports the findings
 * on the import line (an oxlint plugin can only report inside the file being linted).
 * The message starts with the HTML location, the rule id and what to do: `./x.html.js:3:5 [unused-ref] ...`.
+* `only` limits the rule to one rule id of the group; without it the rule reports the whole group, minus `ignore`.
 */
-function templateRule(description, check) {
+function templateRule(group, description, only) {
 	return {
 		meta: {
 			type: "suggestion",
 			docs: { description },
-			schema: ignoreSchema
+			schema: only ? [] : ignoreSchema,
+			hasSuggestions: true
 		},
 		create(context) {
 			return { ImportDeclaration(node) {
 				const spec = node.source.value;
 				if (!spec.endsWith(".html.js")) return;
-				let html;
-				try {
-					html = readFileSync(resolve(dirname(context.filename), spec.slice(0, -3)), "utf8");
-				} catch {
-					return;
+				const html = readTemplate(context.filename, spec);
+				if (html === null) return;
+				const code = context.sourceCode.text;
+				const ignore = context.options?.[0]?.ignore ?? [];
+				for (const d of groupDiagnostics(group, html, code, spec, context.filename)) {
+					if (only ? d.rule !== only : ignore.includes(d.rule)) continue;
+					const suggest = suggestionsFor(d, code, spec);
+					context.report({
+						message: `${spec}:${d.line}:${d.col} [${d.rule}] ${d.message}`,
+						node,
+						...suggest ? { suggest } : {}
+					});
 				}
-				for (const d of check(html, context, spec)) context.report({
-					message: `${spec}:${d.line}:${d.col} [${d.rule}] ${d.message}`,
-					node
-				});
 			} };
 		}
 	};
 }
-const ignored = (c) => c.options?.[0]?.ignore ?? [];
+const perRule = (group, rules) => Object.fromEntries(Object.entries(rules).map(([id, description]) => [id, templateRule(group, description, id)]));
+const { "no-importer": _noImporter, ...unusedMarkupRules } = UNUSED_MARKUP_RULES;
 var oxlint_plugin_default = {
 	meta: { name: "ts-dom" },
 	rules: {
-		/** The HTML declares markup that this file never uses. Always on when enabled; reported as errors. */
-		"unused-markup": templateRule("Markup declared in the HTML (data-ref, data-if, data-each, {{ }}, data-on-*) must be used by the component class", (html, c, spec) => unusedMarkup(html, templateCode(c.sourceCode.text, spec)).filter((d) => !ignored(c).includes(d.rule))),
+		/** The HTML declares markup that this file never uses. Reported as errors. */
+		"unused-markup": templateRule("unused-markup", "Markup declared in the HTML (data-ref, data-if, data-each, {{ }}, data-on-*) must be used by the component class"),
 		/** ARIA and basic accessibility problems in the template. Off by default. */
-		a11y: templateRule("Check the template for ARIA and basic accessibility problems", (html, c) => checkA11y(html, ignored(c))),
+		a11y: templateRule("a11y", "Check the template for ARIA and basic accessibility problems"),
 		/** Data flow suggestions and child component contract checks. Off by default. */
-		"data-flow": templateRule("Keep props flowing down and events flowing up one level at a time, and check child component attributes and events", (html, c, spec) => dataFlow(html, componentClasses(c.sourceCode.text, spec), ignored(c), getContracts()))
+		"data-flow": templateRule("data-flow", "Keep props flowing down and events flowing up one level at a time, and check child component attributes and events"),
+		...perRule("unused-markup", unusedMarkupRules),
+		...perRule("data-flow", DATA_FLOW_RULES),
+		...perRule("a11y", Object.fromEntries(Object.entries(A11Y_RULES).map(([k, v]) => [k, v.split(". Fix:")[0]])))
 	}
 };
 export { oxlint_plugin_default as default };

package/dist/vite-plugin.mjs

@@ -1,4 +1,4 @@
-import { c as generateFile, d as listHtml, f as scanDefines, i as CodegenError, l as isFullPage, n as checkA11y, o as formatDiagnostics, s as generateAll, u as isSelected } from "./a11y-Bn9pDvWV.mjs";
+import { c as generateAll, d as isSelected, f as listHtml, h as scanDefines, i as CodegenError, l as generateFile, n as checkA11y, s as formatDiagnostics, u as isFullPage } from "./a11y-wWL9rie7.mjs";
 import { existsSync, readFileSync, unlinkSync } from "node:fs";
 import { resolve, sep } from "node:path";
 // src/lib/vite-plugin.ts

package/llms.txt

@@ -1,8 +1,8 @@
 # Nativele
 
-> A TypeScript-driven, HTML-first UI library. Bind HTML templates to TypeScript custom elements. HTML describes structure and where data goes; TypeScript owns state and behavior; the DOM is the only view. Fully typed by tsc, no virtual DOM, no bundler required.
+> A TypeScript-driven, HTML-first UI library built for type safety and AI agents. Bind HTML templates to TypeScript custom elements. HTML describes structure and where data goes; TypeScript owns state and behavior; the DOM is the only view. Fully typed by tsc, no virtual DOM, no bundler required.
 
-Workflow: write `x.html` + `x.ts`, run `npx ts-dom gen` (writes `x.html.ts`), then `npx tsc`. Import a template as `import tpl from "./x.html.js"` (note the `.js`). Lint with `npx ts-dom lint` (add `--a11y`). `npx ts-dom rules` lists every rule id. Every diagnostic is `file:line:col severity [rule-id] message` and ends with a `Fix:` hint: read the hint and apply it.
+Workflow: write `x.html` + `x.ts`, run `npx ts-dom check` (regenerates `x.html.ts`, runs tsc and lint, points errors at the template). Import a template as `import tpl from "./x.html.js"` (note the `.js`). Lint with `npx ts-dom lint` (add `--a11y`). `npx ts-dom rules` lists every rule id. Every diagnostic is `file:line:col severity [rule-id] message` and ends with a `Fix:` hint: read the hint and apply it.
 
 ## Template syntax (HTML only names things; no expressions)
 - `{{ name }}`: text hole, a single identifier only. NOT `{{ a.b }}` / `{{ a + 1 }}`. Not allowed in attributes.
@@ -38,6 +38,7 @@ define("my-counter", MyCounter);
 Rules the compiler enforces: every `{{ hole }}` / `data-if` name must exist in state, props or derive (error `missingStateKeys`); state/props/derive names must be unique (`conflictingKeys`); a prop must not be named like an HTMLElement/ts-dom member such as `title`, `hidden`, `render` (`reservedPropNames`); emitted event names must not be native events (`nativeEventNames`); every `data-on-*` method must exist as a public method (`missingHandlers`, reported by `define()`).
 
 ## Data flow (one direction)
+- `state`, `props`, `render`'s `view` and `derive` arguments are `DeepReadonly`: changing an object or array inside them is a tsc error. Replace with new objects (`s.items.map((i) => (i.id === id ? { ...i, done: true } : i))`). Annotate with read-only types (`readonly Item[]`, `DeepReadonly<State>`).
 - State: changed only by its owner with `this.set(patch | s => patch)`; no change => no render. `this.batch(fn)` merges several updates. Rendering is synchronous.
 - Props go DOWN: the parent sets them with an attribute or a property (`this.refs.child.value = v.x`, typed). A component never assigns its own props; to ask for a change it `emit`s an event.
 - Events go UP: `emit` does not bubble; the parent handles it with `data-on-<event>` on the child tag, casting with `EmitEvent<Child, "event-name">`.
@@ -68,12 +69,19 @@ define("my-counter", MyCounter);
 `const view = tpl.instantiate()` returns `{ root: DocumentFragment, rootElement, refs, lists, text, show }` typed like a component (`rootElement` exists in the type only when the template has exactly one top-level element, `<style>` excluded), for pieces created in code. No host: `data-on-*` is inert (use `refs.x.addEventListener`) and `<slot>` is not projected.
 
 ## Lists
+- Rule: an item with anything of its own (state, events, a nested list) is a component filled with `items =`; an item of a few texts and `data-if` is plain elements filled with `replace()`.
+- Subscribe in `connected()`, never in the constructor: without `moveBefore` a moved item is disconnected (its `bind`/`on`/`onCleanup` released) and connected again. Data every item needs goes in a `createStore` the item binds.
+- Full example (add, remove, sort, toggle, child emit): `examples/readme/task-board.ts` and `task-row.ts` in the repository.
 - Items that are components: `<template data-each="todos" data-key="id" data-prop="todo"><todo-row></todo-row></template>`, then `this.lists.todos.items = view.todos` (inside `render`, guarded by `changed.has("todos")`). Keeps the element of each key, creates and removes the rest, sets the `todo` prop of each changed item; `hit.key` in handlers. The item component declares `todo` in its `props`; `tsc` checks the items against that prop type and the `data-key` field; an item component defined in a scanned folder must be exported and listed in `ts-dom-tags.ts` (run `ts-dom gen`), otherwise the assignment is a type error that names the problem.
 - Items that are plain elements: `<template data-each="x">` with `this.lists.x.replace(items, keyFn, (item, { text, show }) => ...)`.
 - `data-each` is never nested: a list inside an item is the item component's own `data-each`.
 
 ## Rules for agents
-- Never edit `x.html.ts` or `ts-dom-tags.ts` (generated). After any `.html` change run `npx ts-dom gen && npx tsc` and fix every type error instead of casting it away. Until `gen` has run, `tsc` only reports that `./x.html.js` is missing.
+- `npx ts-dom rules --explain=<id>` (or `rules --json`) explains any rule id from a diagnostic: why it exists, a wrong example and the fix.
+- Markup well-formedness is a formatter's job: `oxfmt --check` reports misnested tags that the library's parser would silently repair. Generate with `--whitespace=collapse` when a formatter is used.
+- If checks behave oddly (no types, a template not found), run `npx ts-dom doctor --json` first: it reports tsconfig, import path, runtime, generated file and plugin problems with a `Fix:` each.
+- `npx ts-dom gen --check` (writes nothing, exit 1) tells whether the generated files are stale before you trust `tsc` errors.
+- Never edit `x.html.ts` or `ts-dom-tags.ts` (generated). After any `.html` or component change run `npx ts-dom check --json`: it regenerates, runs tsc, maps template contract errors to the template line/col (`missing-binding`, `missing-handler`, item rules), and runs lint. Fix every issue by its `Fix:` hint; never cast a type error away.
 - No expressions in HTML; computed values go in `derive`. Change state only with `this.set()`. Lists, attributes and focus go in `render(view, changed)`; check `changed.has("items")` before rebuilding a list.
 - Props go down (parent sets them), events go up (`emit`, handled with `data-on-<event>` on the child tag). `data-each` cannot be nested: make the inner list its own component.
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nativele/ts-dom",
-  "version": "0.4.0",
-  "description": "A TypeScript-driven, HTML-first UI library. Bind HTML to TypeScript: HTML describes the structure, TypeScript owns behavior and state, and the DOM is the single source of truth. Fully typed, no virtual DOM, no bundler required.",
+  "version": "0.4.6",
+  "description": "A TypeScript-driven, HTML-first UI library built for type safety and AI agents: HTML describes the structure, TypeScript owns behavior and state, the native DOM renders it. No virtual DOM, no template expressions, no bundler required.",
   "keywords": [
     "html",
     "typescript",
@@ -68,7 +68,8 @@
     "test:browser": "vp test run browser/",
     "verify:pack": "vp pack --publint --attw",
     "smoke": "bash scripts/consumer-smoke.sh",
-    "smoke:no-bundler": "bash scripts/no-bundler-smoke.sh"
+    "smoke:no-bundler": "bash scripts/no-bundler-smoke.sh",
+    "bench": "node scripts/bench.ts"
   },
   "dependencies": {
     "parse5": "^8.1.0"