@mindees/core 0.1.0

package/LICENSE

@@ -0,0 +1,31 @@
+# License
+
+MindeesNative is dual-licensed under either of:
+
+- **Apache License, Version 2.0** ([LICENSE-APACHE](./LICENSE-APACHE) or
+  <https://www.apache.org/licenses/LICENSE-2.0>)
+- **MIT license** ([LICENSE-MIT](./LICENSE-MIT) or
+  <https://opensource.org/licenses/MIT>)
+
+at your option.
+
+This `MIT OR Apache-2.0` dual-license is the same model used by the Rust
+ecosystem and many modern open-source projects. It gives downstream users
+maximum flexibility: the MIT option is short and permissive, while the Apache
+option adds an explicit patent grant.
+
+## SPDX identifier
+
+```
+SPDX-License-Identifier: MIT OR Apache-2.0
+```
+
+## Contribution
+
+Unless you explicitly state otherwise, any contribution intentionally
+submitted for inclusion in the work by you, as defined in the Apache-2.0
+license, shall be dual-licensed as above, without any additional terms or
+conditions.
+
+Contributions are accepted under the **Developer Certificate of Origin (DCO)**.
+See [CONTRIBUTING.md](./CONTRIBUTING.md) for details on signing off your commits.

package/README.md

@@ -0,0 +1,119 @@
+# @mindees/core
+
+The reactive runtime foundation of MindeesNative — a fast, fine-grained
+**signals** library (the same reactivity model behind SolidJS and modern
+frameworks), written in strict TypeScript.
+
+> **Status: 🧪 Experimental (Phases 1–2).** Implemented and thoroughly tested:
+> the **reactivity** layer (`signal`, `computed`/`memo`, `effect`, `batch`,
+> `untrack`, `createRoot`, `onCleanup`), the **component model** (element tree +
+> selector-based, re-render-isolated context), the **priority scheduler**, and a
+> **thread-pool** abstraction (Web Worker backend + inline fallback). APIs may
+> still change before `1.0`.
+
+## Install
+
+> ⚠️ **Not published to npm yet.** `@mindees/core` is pre-1.0 and not on the npm
+> registry. The command below is what you'll use **once it's published** (Phase
+> 12). For now, work with it from the monorepo via the
+> [contributor quick-start](../../README.md#-quickstart-contributors):
+> `corepack enable && pnpm install && pnpm verify`.
+
+```bash
+# coming soon (not yet published):
+pnpm add @mindees/core
+```
+
+## Quick start
+
+```ts
+import { signal, computed, effect, batch } from '@mindees/core'
+
+const count = signal(0)
+const doubled = computed(() => count() * 2)
+
+effect(() => {
+  console.log(`count=${count()} doubled=${doubled()}`)
+}) // logs immediately, then on every change
+
+count.set(1)             // re-runs the effect
+count.update((n) => n + 1)
+
+batch(() => {            // coalesce multiple writes into one effect run
+  count.set(10)
+  count.set(20)
+})
+```
+
+## Why signals?
+
+Signals give you **fine-grained reactivity**: only the computations that actually
+depend on a changed value re-run — no virtual-DOM diffing, no manual
+`useMemo`/`useCallback`, no whole-component re-renders. The engine is:
+
+- **Glitch-free** — a diamond dependency recomputes its consumer exactly once;
+  no observer ever sees an inconsistent intermediate state.
+- **Lazy & cached** — `computed` values recompute only when read *and* a
+  dependency changed; an equal recomputation stops propagation.
+- **Leak-free** — disposing an owner unlinks every subscription (verified by an
+  adversarial disposal test suite).
+- **Synchronous & deterministic** — predictable effect ordering, batched writes.
+
+## API
+
+| Export | Kind | Description |
+| --- | --- | --- |
+| `signal(value, opts?)` | fn | Writable reactive value: `()` read · `.set` · `.update` · `.peek`. |
+| `computed(fn, opts?)` / `memo` | fn | Lazy, cached derived value. |
+| `effect(fn)` | fn | Re-runs on dependency change; returns a disposer; supports `onCleanup`. |
+| `batch(fn)` | fn | Coalesce writes; effects run once at the end. |
+| `untrack(fn)` | fn | Read without subscribing. |
+| `createRoot(fn)` | fn | Non-tracked owner scope with manual `dispose`. |
+| `onCleanup(fn)` | fn | Register teardown for the current scope. |
+| `getOwner` / `runWithOwner` | fn | Inspect / re-enter an ownership scope. |
+| `Signal`, `Memo`, `Accessor`, `EqualsFn`, `Owner`, … | type | Fully-typed public surface. |
+| `NotImplementedError` / `notImplemented` | err | Honest markers for unbuilt research tracks. |
+
+Custom equality is supported everywhere (`{ equals: (a, b) => … }`, or
+`equals: false` to always notify).
+
+## Component model, scheduler & threading (Phase 2)
+
+```ts
+import {
+  createContext, createProvider, createElement,
+  createScheduler, createInlineThreadPool,
+} from '@mindees/core'
+
+// Selector-based context with re-render isolation: a consumer only re-runs
+// when its SELECTED slice changes, not on every context update.
+const Session = createContext({ user: { name: 'Ada' }, unread: 0 })
+const session = createProvider(Session)
+const name = session.select((s) => s.user.name) // memo; isolated from `unread`
+
+// Two-lane priority scheduler (sync vs normal), microtask-batched,
+// with cancellable + dedup-by-key tasks.
+const scheduler = createScheduler()
+scheduler.schedule(() => paint(), { priority: 'sync', key: 'frame' })
+
+// Thread-pool abstraction. The inline fallback runs jobs synchronously;
+// createWorkerPool({ createWorker }) runs them on real Web Workers (see API below).
+const pool = createInlineThreadPool()
+await pool.run((n) => fib(n), 40)
+```
+
+| Export | Kind | Description |
+| --- | --- | --- |
+| `createElement` / `Fragment` / `isElement` | fn | Renderer-agnostic element tree. |
+| `createContext` / `createProvider` | fn | Selector-based, **re-render-isolated** context. |
+| `renderComponent` | fn | Run a component in a disposable owner scope. |
+| `createScheduler` / `Scheduler` | fn | Two-lane priority scheduler (cancellable, dedupable). |
+| `createWorkerPool` / `createInlineThreadPool` | fn | `ThreadPool` backends (web + fallback). |
+| `createNativeThreadPool` | fn | 🔬 research track — throws `NotImplementedError`. |
+
+> Native multi-threading is a **research track** (honest `NotImplementedError`);
+> the Web Worker and inline backends work today.
+
+## License
+
+`MIT OR Apache-2.0`

package/dist/component/component.d.ts

@@ -0,0 +1,112 @@
+//#region src/component/component.d.ts
+/**
+ * MindeesNative component model — a minimal, renderer-agnostic element tree plus
+ * **selector-based, re-render-isolated context**.
+ *
+ * The element tree (`createElement` / `Fragment`) is a plain data structure: a
+ * component is a function of `props` returning elements. It carries no rendering
+ * logic itself — the Helix renderer (Phase 3) turns this tree into host nodes.
+ *
+ * The context system is the important primitive: a `createContext` value is read
+ * through a **selector**, and a consumer only re-runs when its *selected slice*
+ * actually changes — not on every context update. This is the re-render
+ * isolation the Quantum Router (Phase 6) builds on. It is implemented on the
+ * Phase 1 signals, so selection participates in normal reactivity.
+ *
+ * @module
+ */
+/** A component: a function from props to a renderable node. */
+type Component<P = Record<string, unknown>> = (props: P) => MindeesNode;
+/**
+ * Anything that can appear in the tree.
+ *
+ * Includes an **accessor** form `() => MindeesNode`: a function child (or
+ * function prop value) is a *reactive region* — the renderer subscribes to it
+ * and patches exactly that region when its signals change (the fine-grained
+ * update model, à la SolidJS). Static trees never need it; reactive UIs do.
+ */
+type MindeesNode = MindeesElement | string | number | boolean | null | undefined | (() => MindeesNode) | MindeesNode[];
+/** The tag of an element: a host string (e.g. `"view"`) or a component function. */
+type ElementType = string | Component<never>;
+/** A virtual element: a tag, its props, and its children. */
+interface MindeesElement {
+  readonly $$typeof: typeof ELEMENT_TYPE;
+  readonly type: ElementType;
+  readonly props: Readonly<Record<string, unknown>>;
+  readonly children: readonly MindeesNode[];
+  readonly key: string | number | null;
+}
+/** Brand so a renderer can reliably distinguish elements from plain objects. */
+declare const ELEMENT_TYPE: unique symbol;
+/** Marker tag for a fragment (children with no wrapper host node). */
+declare const Fragment: unique symbol;
+interface PropsWithKey {
+  key?: string | number | null;
+  children?: MindeesNode;
+}
+/**
+ * Create a virtual element. `type` is a host-component string or a component
+ * function; `Fragment` groups children without a wrapper.
+ *
+ * @example
+ * createElement('view', { id: 'root' }, createElement('text', null, 'hi'))
+ */
+declare function createElement(type: ElementType | typeof Fragment, props?: (Record<string, unknown> & PropsWithKey) | null, ...children: MindeesNode[]): MindeesElement;
+/** Type guard: is `value` a MindeesElement? */
+declare function isElement(value: unknown): value is MindeesElement;
+/** Equality used by context selectors. Defaults to `Object.is`. */
+type SelectorEquals<S> = (a: S, b: S) => boolean;
+/** A context handle created by {@link createContext}. */
+interface Context<T> {
+  /** Provide a value to a subtree (conceptually); returns a scoped reader set. */
+  readonly id: symbol;
+  /** The default value used when no provider is present. */
+  readonly defaultValue: T;
+}
+/**
+ * A live provider instance: holds the current value and lets consumers subscribe
+ * to a derived slice with re-render isolation.
+ */
+interface ContextProvider<T> {
+  /** Replace the provided value (notifies only consumers whose slice changed). */
+  set(value: T): void;
+  /** Read the current value without subscribing. */
+  peek(): T;
+  /**
+   * Subscribe to a selected slice. The returned accessor is a memo that only
+   * changes — and thus only re-runs its observers — when `selector(value)`
+   * changes under `equals` (default `Object.is`).
+   */
+  select<S>(selector: (value: T) => S, equals?: SelectorEquals<S>): () => S;
+}
+/** Create a context with a default value. */
+declare function createContext<T>(defaultValue: T): Context<T>;
+/**
+ * Create a provider instance for `context`. Built on a signal, so selected
+ * slices are memos: a consumer that selects `c => c.user.name` does not re-run
+ * when an unrelated field changes.
+ *
+ * @example
+ * const Theme = createContext({ mode: 'light', accent: 'blue' })
+ * const p = createProvider(Theme, { mode: 'light', accent: 'blue' })
+ * const mode = p.select((t) => t.mode) // only re-runs when `mode` changes
+ */
+declare function createProvider<T>(context: Context<T>, initial?: T): ContextProvider<T>;
+/**
+ * Invoke a component within a reactive ownership scope, so every effect, memo,
+ * and `onCleanup` it registers is torn down together when `dispose` is called.
+ * Returns the produced node and that disposer.
+ *
+ * Built on the Phase 1 {@link createRoot}, so disposal reuses the same
+ * leak-free teardown the reactivity tests cover. This is a renderer building
+ * block; it does not touch any host.
+ */
+declare function renderComponent<P>(component: Component<P>, props: P): {
+  node: MindeesNode;
+  dispose: () => void;
+};
+/** Whether code is currently running inside a reactive ownership scope. */
+declare function hasOwner(): boolean;
+//#endregion
+export { Component, Context, ContextProvider, ELEMENT_TYPE, ElementType, Fragment, MindeesElement, MindeesNode, SelectorEquals, createContext, createElement, createProvider, hasOwner, isElement, renderComponent };
+//# sourceMappingURL=component.d.ts.map

package/dist/component/component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component.d.ts","names":[],"sources":["../../src/component/component.ts"],"mappings":";;AAwBA;;;;;;;;;;;;;;AAA8E;AAU9E;AAAA,KAVY,SAAA,KAAc,MAAA,sBAA4B,KAAA,EAAO,CAAA,KAAM,WAAA;;;;;;;;;KAUvD,WAAA,GACR,cAAA,yDAMO,WAAA,IACP,WAAA;;KAGQ,WAAA,YAAuB,SAAS;AAA5C;AAAA,UAGiB,cAAA;EAAA,SACN,QAAA,SAAiB,YAAA;EAAA,SACjB,IAAA,EAAM,WAAA;EAAA,SACN,KAAA,EAAO,QAAA,CAAS,MAAA;EAAA,SAChB,QAAA,WAAmB,WAAA;EAAA,SACnB,GAAA;AAAA;;cAIE,YAAA;;cAGA,QAAA;AAAA,UAEH,YAAA;EACR,GAAA;EACA,QAAA,GAAW,WAAW;AAAA;;;;;;;;iBAUR,aAAA,CACd,IAAA,EAAM,WAAA,UAAqB,QAAA,EAC3B,KAAA,IAAS,MAAA,oBAA0B,YAAA,aAChC,QAAA,EAAU,WAAA,KACZ,cAAA;;iBAea,SAAA,CAAU,KAAA,YAAiB,KAAA,IAAS,cAAc;AAxCpD;AAAA,KAqDF,cAAA,OAAqB,CAAA,EAAG,CAAA,EAAG,CAAA,EAAG,CAAC;;UAG1B,OAAA;EApDuD;EAAA,SAsD7D,EAAA;EAnDE;EAAA,SAqDF,YAAA,EAAc,CAAC;AAAA;;AArD2C;AAAA;;UA4DpD,eAAA;EAxDO;EA0DtB,GAAA,CAAI,KAAA,EAAO,CAAA;EA1DX;EA4DA,IAAA,IAAQ,CAAA;EA5Dc;AAAA;AAUxB;;;EAwDE,MAAA,IAAU,QAAA,GAAW,KAAA,EAAO,CAAA,KAAM,CAAA,EAAG,MAAA,GAAS,cAAA,CAAe,CAAA,UAAW,CAAA;AAAA;;iBAI1D,aAAA,IAAiB,YAAA,EAAc,CAAA,GAAI,OAAA,CAAQ,CAAA;;;;;;;;;;;iBAc3C,cAAA,IAAkB,OAAA,EAAS,OAAA,CAAQ,CAAA,GAAI,OAAA,GAAU,CAAA,GAAI,eAAA,CAAgB,CAAA;;;;AAtEpE;AAejB;;;;;iBAmFgB,eAAA,IACd,SAAA,EAAW,SAAA,CAAU,CAAA,GACrB,KAAA,EAAO,CAAA;EACJ,IAAA,EAAM,WAAA;EAAa,OAAA;AAAA;AAzExB;AAAA,iBA8FgB,QAAA"}

package/dist/component/component.js

@@ -0,0 +1,107 @@
+import { computed, createRoot, getOwner, signal } from "../reactive/reactive.js";
+//#region src/component/component.ts
+/**
+* MindeesNative component model — a minimal, renderer-agnostic element tree plus
+* **selector-based, re-render-isolated context**.
+*
+* The element tree (`createElement` / `Fragment`) is a plain data structure: a
+* component is a function of `props` returning elements. It carries no rendering
+* logic itself — the Helix renderer (Phase 3) turns this tree into host nodes.
+*
+* The context system is the important primitive: a `createContext` value is read
+* through a **selector**, and a consumer only re-runs when its *selected slice*
+* actually changes — not on every context update. This is the re-render
+* isolation the Quantum Router (Phase 6) builds on. It is implemented on the
+* Phase 1 signals, so selection participates in normal reactivity.
+*
+* @module
+*/
+/** Brand so a renderer can reliably distinguish elements from plain objects. */
+const ELEMENT_TYPE = Symbol.for("mindees.element");
+/** Marker tag for a fragment (children with no wrapper host node). */
+const Fragment = Symbol.for("mindees.fragment");
+/**
+* Create a virtual element. `type` is a host-component string or a component
+* function; `Fragment` groups children without a wrapper.
+*
+* @example
+* createElement('view', { id: 'root' }, createElement('text', null, 'hi'))
+*/
+function createElement(type, props, ...children) {
+	const { key = null, children: propsChildren, ...rest } = props ?? {};
+	const resolved = children.length > 0 ? children : propsChildren !== void 0 ? [propsChildren] : [];
+	return {
+		$$typeof: ELEMENT_TYPE,
+		type,
+		props: Object.freeze({ ...rest }),
+		children: Object.freeze(resolved),
+		key
+	};
+}
+/** Type guard: is `value` a MindeesElement? */
+function isElement(value) {
+	return typeof value === "object" && value !== null && value.$$typeof === ELEMENT_TYPE;
+}
+/** Create a context with a default value. */
+function createContext(defaultValue) {
+	return {
+		id: Symbol("mindees.context"),
+		defaultValue
+	};
+}
+/**
+* Create a provider instance for `context`. Built on a signal, so selected
+* slices are memos: a consumer that selects `c => c.user.name` does not re-run
+* when an unrelated field changes.
+*
+* @example
+* const Theme = createContext({ mode: 'light', accent: 'blue' })
+* const p = createProvider(Theme, { mode: 'light', accent: 'blue' })
+* const mode = p.select((t) => t.mode) // only re-runs when `mode` changes
+*/
+function createProvider(context, initial) {
+	const source = signal(initial ?? context.defaultValue, { equals: false });
+	return {
+		set: (value) => {
+			source.set(value);
+		},
+		peek: () => source.peek(),
+		select(selector, equals = Object.is) {
+			return computed(() => selector(source()), { equals });
+		}
+	};
+}
+/**
+* Invoke a component within a reactive ownership scope, so every effect, memo,
+* and `onCleanup` it registers is torn down together when `dispose` is called.
+* Returns the produced node and that disposer.
+*
+* Built on the Phase 1 {@link createRoot}, so disposal reuses the same
+* leak-free teardown the reactivity tests cover. This is a renderer building
+* block; it does not touch any host.
+*/
+function renderComponent(component, props) {
+	let node;
+	let dispose;
+	try {
+		createRoot((d) => {
+			dispose = d;
+			node = component(props);
+		});
+	} catch (error) {
+		dispose?.();
+		throw error;
+	}
+	return {
+		node,
+		dispose
+	};
+}
+/** Whether code is currently running inside a reactive ownership scope. */
+function hasOwner() {
+	return getOwner() !== null;
+}
+//#endregion
+export { ELEMENT_TYPE, Fragment, createContext, createElement, createProvider, hasOwner, isElement, renderComponent };
+
+//# sourceMappingURL=component.js.map

package/dist/component/component.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"component.js","names":[],"sources":["../../src/component/component.ts"],"sourcesContent":["/**\n * MindeesNative component model — a minimal, renderer-agnostic element tree plus\n * **selector-based, re-render-isolated context**.\n *\n * The element tree (`createElement` / `Fragment`) is a plain data structure: a\n * component is a function of `props` returning elements. It carries no rendering\n * logic itself — the Helix renderer (Phase 3) turns this tree into host nodes.\n *\n * The context system is the important primitive: a `createContext` value is read\n * through a **selector**, and a consumer only re-runs when its *selected slice*\n * actually changes — not on every context update. This is the re-render\n * isolation the Quantum Router (Phase 6) builds on. It is implemented on the\n * Phase 1 signals, so selection participates in normal reactivity.\n *\n * @module\n */\n\nimport { computed, createRoot, getOwner, signal } from '../reactive'\n\n// ---------------------------------------------------------------------------\n// Element tree\n// ---------------------------------------------------------------------------\n\n/** A component: a function from props to a renderable node. */\nexport type Component<P = Record<string, unknown>> = (props: P) => MindeesNode\n\n/**\n * Anything that can appear in the tree.\n *\n * Includes an **accessor** form `() => MindeesNode`: a function child (or\n * function prop value) is a *reactive region* — the renderer subscribes to it\n * and patches exactly that region when its signals change (the fine-grained\n * update model, à la SolidJS). Static trees never need it; reactive UIs do.\n */\nexport type MindeesNode =\n  | MindeesElement\n  | string\n  | number\n  | boolean\n  | null\n  | undefined\n  | (() => MindeesNode)\n  | MindeesNode[]\n\n/** The tag of an element: a host string (e.g. `\"view\"`) or a component function. */\nexport type ElementType = string | Component<never>\n\n/** A virtual element: a tag, its props, and its children. */\nexport interface MindeesElement {\n  readonly $$typeof: typeof ELEMENT_TYPE\n  readonly type: ElementType\n  readonly props: Readonly<Record<string, unknown>>\n  readonly children: readonly MindeesNode[]\n  readonly key: string | number | null\n}\n\n/** Brand so a renderer can reliably distinguish elements from plain objects. */\nexport const ELEMENT_TYPE: unique symbol = Symbol.for('mindees.element')\n\n/** Marker tag for a fragment (children with no wrapper host node). */\nexport const Fragment: unique symbol = Symbol.for('mindees.fragment')\n\ninterface PropsWithKey {\n  key?: string | number | null\n  children?: MindeesNode\n}\n\n/**\n * Create a virtual element. `type` is a host-component string or a component\n * function; `Fragment` groups children without a wrapper.\n *\n * @example\n * createElement('view', { id: 'root' }, createElement('text', null, 'hi'))\n */\nexport function createElement(\n  type: ElementType | typeof Fragment,\n  props?: (Record<string, unknown> & PropsWithKey) | null,\n  ...children: MindeesNode[]\n): MindeesElement {\n  const { key = null, children: propsChildren, ...rest } = props ?? {}\n  // Children passed as args win over a `children` prop; otherwise fall back to it.\n  const resolved: MindeesNode[] =\n    children.length > 0 ? children : propsChildren !== undefined ? [propsChildren] : []\n  return {\n    $$typeof: ELEMENT_TYPE,\n    type: type as ElementType,\n    props: Object.freeze({ ...rest }),\n    children: Object.freeze(resolved),\n    key,\n  }\n}\n\n/** Type guard: is `value` a MindeesElement? */\nexport function isElement(value: unknown): value is MindeesElement {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    (value as { $$typeof?: unknown }).$$typeof === ELEMENT_TYPE\n  )\n}\n\n// ---------------------------------------------------------------------------\n// Selector-based, re-render-isolated context\n// ---------------------------------------------------------------------------\n\n/** Equality used by context selectors. Defaults to `Object.is`. */\nexport type SelectorEquals<S> = (a: S, b: S) => boolean\n\n/** A context handle created by {@link createContext}. */\nexport interface Context<T> {\n  /** Provide a value to a subtree (conceptually); returns a scoped reader set. */\n  readonly id: symbol\n  /** The default value used when no provider is present. */\n  readonly defaultValue: T\n}\n\n/**\n * A live provider instance: holds the current value and lets consumers subscribe\n * to a derived slice with re-render isolation.\n */\nexport interface ContextProvider<T> {\n  /** Replace the provided value (notifies only consumers whose slice changed). */\n  set(value: T): void\n  /** Read the current value without subscribing. */\n  peek(): T\n  /**\n   * Subscribe to a selected slice. The returned accessor is a memo that only\n   * changes — and thus only re-runs its observers — when `selector(value)`\n   * changes under `equals` (default `Object.is`).\n   */\n  select<S>(selector: (value: T) => S, equals?: SelectorEquals<S>): () => S\n}\n\n/** Create a context with a default value. */\nexport function createContext<T>(defaultValue: T): Context<T> {\n  return { id: Symbol('mindees.context'), defaultValue }\n}\n\n/**\n * Create a provider instance for `context`. Built on a signal, so selected\n * slices are memos: a consumer that selects `c => c.user.name` does not re-run\n * when an unrelated field changes.\n *\n * @example\n * const Theme = createContext({ mode: 'light', accent: 'blue' })\n * const p = createProvider(Theme, { mode: 'light', accent: 'blue' })\n * const mode = p.select((t) => t.mode) // only re-runs when `mode` changes\n */\nexport function createProvider<T>(context: Context<T>, initial?: T): ContextProvider<T> {\n  // equals:false at the root — every set() re-evaluates selectors, but each\n  // selector memo applies its own equality to isolate re-renders.\n  const source = signal<T>(initial ?? context.defaultValue, { equals: false })\n  return {\n    set: (value: T) => {\n      source.set(value)\n    },\n    peek: () => source.peek(),\n    select<S>(selector: (value: T) => S, equals: SelectorEquals<S> = Object.is): () => S {\n      return computed(() => selector(source()), { equals })\n    },\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Rendering a component subtree under an owner (so it can be disposed)\n// ---------------------------------------------------------------------------\n\n/**\n * Invoke a component within a reactive ownership scope, so every effect, memo,\n * and `onCleanup` it registers is torn down together when `dispose` is called.\n * Returns the produced node and that disposer.\n *\n * Built on the Phase 1 {@link createRoot}, so disposal reuses the same\n * leak-free teardown the reactivity tests cover. This is a renderer building\n * block; it does not touch any host.\n */\nexport function renderComponent<P>(\n  component: Component<P>,\n  props: P,\n): { node: MindeesNode; dispose: () => void } {\n  let node!: MindeesNode\n  // Capture the disposer eagerly: createRoot hands it to the callback synchronously\n  // *before* the component runs, so if the component throws mid-render we can still\n  // tear down anything it registered before the throw (effects, subscriptions,\n  // timers). Without this, createRoot re-throws without disposing and the caller\n  // never receives a disposer — the partial scope would leak forever.\n  let dispose!: () => void\n  try {\n    createRoot((d) => {\n      dispose = d\n      node = component(props)\n    })\n  } catch (error) {\n    dispose?.()\n    throw error\n  }\n  return { node, dispose }\n}\n\n/** Whether code is currently running inside a reactive ownership scope. */\nexport function hasOwner(): boolean {\n  return getOwner() !== null\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAyDA,MAAa,eAA8B,OAAO,IAAI,iBAAiB;;AAGvE,MAAa,WAA0B,OAAO,IAAI,kBAAkB;;;;;;;;AAcpE,SAAgB,cACd,MACA,OACA,GAAG,UACa;CAChB,MAAM,EAAE,MAAM,MAAM,UAAU,eAAe,GAAG,SAAS,SAAS,CAAC;CAEnE,MAAM,WACJ,SAAS,SAAS,IAAI,WAAW,kBAAkB,KAAA,IAAY,CAAC,aAAa,IAAI,CAAC;CACpF,OAAO;EACL,UAAU;EACJ;EACN,OAAO,OAAO,OAAO,EAAE,GAAG,KAAK,CAAC;EAChC,UAAU,OAAO,OAAO,QAAQ;EAChC;CACF;AACF;;AAGA,SAAgB,UAAU,OAAyC;CACjE,OACE,OAAO,UAAU,YACjB,UAAU,QACT,MAAiC,aAAa;AAEnD;;AAmCA,SAAgB,cAAiB,cAA6B;CAC5D,OAAO;EAAE,IAAI,OAAO,iBAAiB;EAAG;CAAa;AACvD;;;;;;;;;;;AAYA,SAAgB,eAAkB,SAAqB,SAAiC;CAGtF,MAAM,SAAS,OAAU,WAAW,QAAQ,cAAc,EAAE,QAAQ,MAAM,CAAC;CAC3E,OAAO;EACL,MAAM,UAAa;GACjB,OAAO,IAAI,KAAK;EAClB;EACA,YAAY,OAAO,KAAK;EACxB,OAAU,UAA2B,SAA4B,OAAO,IAAa;GACnF,OAAO,eAAe,SAAS,OAAO,CAAC,GAAG,EAAE,OAAO,CAAC;EACtD;CACF;AACF;;;;;;;;;;AAeA,SAAgB,gBACd,WACA,OAC4C;CAC5C,IAAI;CAMJ,IAAI;CACJ,IAAI;EACF,YAAY,MAAM;GAChB,UAAU;GACV,OAAO,UAAU,KAAK;EACxB,CAAC;CACH,SAAS,OAAO;EACd,UAAU;EACV,MAAM;CACR;CACA,OAAO;EAAE;EAAM;CAAQ;AACzB;;AAGA,SAAgB,WAAoB;CAClC,OAAO,SAAS,MAAM;AACxB"}

package/dist/errors.d.ts

@@ -0,0 +1,23 @@
+//#region src/errors.d.ts
+/**
+ * Thrown by APIs that are declared but not yet implemented (a "research track").
+ *
+ * Per the MindeesNative Working-Code Doctrine, a not-yet-built capability must
+ * fail loudly and honestly rather than silently returning a fake value. This
+ * error type makes that failure explicit, typed, and traceable to an RFC.
+ */
+declare class NotImplementedError extends Error {
+  readonly name = "NotImplementedError";
+  /** Stable, machine-readable error code. */
+  readonly code: "ERR_MINDEES_NOT_IMPLEMENTED";
+  /** The capability that is not implemented yet. */
+  readonly feature: string;
+  /** Optional reference to the tracking RFC (e.g. `"RFC-0007"`). */
+  readonly rfc?: string;
+  constructor(feature: string, options?: {
+    readonly rfc?: string;
+  });
+}
+//#endregion
+export { NotImplementedError };
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","names":[],"sources":["../src/errors.ts"],"mappings":";;AAOA;;;;;;cAAa,mBAAA,SAA4B,KAAK;EAAA,SAC1B,IAAA;EAST;EAAA,SANA,IAAA;EAQG;EAAA,SALH,OAAA;EAKoB;EAAA,SAFpB,GAAA;cAEG,OAAA,UAAiB,OAAA;IAAA,SAAqB,GAAA;EAAA;AAAA"}

package/dist/errors.js

@@ -0,0 +1,28 @@
+//#region src/errors.ts
+/**
+* Thrown by APIs that are declared but not yet implemented (a "research track").
+*
+* Per the MindeesNative Working-Code Doctrine, a not-yet-built capability must
+* fail loudly and honestly rather than silently returning a fake value. This
+* error type makes that failure explicit, typed, and traceable to an RFC.
+*/
+var NotImplementedError = class extends Error {
+	name = "NotImplementedError";
+	/** Stable, machine-readable error code. */
+	code = "ERR_MINDEES_NOT_IMPLEMENTED";
+	/** The capability that is not implemented yet. */
+	feature;
+	/** Optional reference to the tracking RFC (e.g. `"RFC-0007"`). */
+	rfc;
+	constructor(feature, options) {
+		const rfc = options?.rfc;
+		super(`${feature} is not implemented yet (research track).${rfc ? ` See ${rfc}.` : ""}`);
+		this.feature = feature;
+		if (rfc !== void 0) this.rfc = rfc;
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+};
+//#endregion
+export { NotImplementedError };
+
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","names":[],"sources":["../src/errors.ts"],"sourcesContent":["/**\n * Thrown by APIs that are declared but not yet implemented (a \"research track\").\n *\n * Per the MindeesNative Working-Code Doctrine, a not-yet-built capability must\n * fail loudly and honestly rather than silently returning a fake value. This\n * error type makes that failure explicit, typed, and traceable to an RFC.\n */\nexport class NotImplementedError extends Error {\n  override readonly name = 'NotImplementedError'\n\n  /** Stable, machine-readable error code. */\n  readonly code = 'ERR_MINDEES_NOT_IMPLEMENTED' as const\n\n  /** The capability that is not implemented yet. */\n  readonly feature: string\n\n  /** Optional reference to the tracking RFC (e.g. `\"RFC-0007\"`). */\n  readonly rfc?: string\n\n  constructor(feature: string, options?: { readonly rfc?: string }) {\n    const rfc = options?.rfc\n    super(`${feature} is not implemented yet (research track).${rfc ? ` See ${rfc}.` : ''}`)\n    this.feature = feature\n    if (rfc !== undefined) {\n      this.rfc = rfc\n    }\n    // Preserve the prototype chain so `instanceof` works reliably.\n    Object.setPrototypeOf(this, new.target.prototype)\n  }\n}\n"],"mappings":";;;;;;;;AAOA,IAAa,sBAAb,cAAyC,MAAM;CAC7C,OAAyB;;CAGzB,OAAgB;;CAGhB;;CAGA;CAEA,YAAY,SAAiB,SAAqC;EAChE,MAAM,MAAM,SAAS;EACrB,MAAM,GAAG,QAAQ,2CAA2C,MAAM,QAAQ,IAAI,KAAK,IAAI;EACvF,KAAK,UAAU;EACf,IAAI,QAAQ,KAAA,GACV,KAAK,MAAM;EAGb,OAAO,eAAe,MAAM,IAAI,OAAO,SAAS;CAClD;AACF"}

package/dist/index.d.ts

@@ -0,0 +1,31 @@
+import { Maturity, PackageInfo } from "./types.js";
+import { Component, Context, ContextProvider, ELEMENT_TYPE, ElementType, Fragment, MindeesElement, MindeesNode, SelectorEquals, createContext, createElement, createProvider, hasOwner, isElement, renderComponent } from "./component/component.js";
+import { NotImplementedError } from "./errors.js";
+import { notImplemented } from "./not-implemented.js";
+import { Accessor, ComputedOptions, EqualsFn, Memo, Owner, Signal, SignalOptions, batch, computed, createRoot, effect, getOwner, memo, onCleanup, runWithOwner, signal, untrack } from "./reactive/reactive.js";
+import { Priority, ScheduleOptions, ScheduledTask, Scheduler, SchedulerOptions, Task, createScheduler } from "./scheduler/scheduler.js";
+import { ThreadPool, WorkerLike, WorkerPoolOptions, createInlineThreadPool, createNativeThreadPool, createWorkerPool } from "./threading/thread-pool.js";
+
+//#region src/index.d.ts
+/** The npm package name. */
+declare const name = "@mindees/core";
+/** The package version. All `@mindees/*` packages share one locked version line. */
+declare const VERSION = "0.1.0";
+/**
+ * Current maturity of this package. See the repository `STATUS.md`.
+ *
+ * The reactivity layer (signals/computed/effect/batch), the component model with
+ * selector-isolated context, the priority scheduler, and the thread-pool
+ * abstraction (Web Worker + inline) are all implemented and tested. Native
+ * multi-threading remains a research track (throws `NotImplementedError`).
+ */
+declare const maturity: Maturity;
+/**
+ * Static identity + maturity metadata for this package. Frozen so the
+ * self-reported identity tooling introspects cannot be mutated at runtime,
+ * matching the `readonly` fields of {@link PackageInfo}.
+ */
+declare const info: PackageInfo;
+//#endregion
+export { type Accessor, type Component, type ComputedOptions, type Context, type ContextProvider, ELEMENT_TYPE, type ElementType, type EqualsFn, Fragment, type Maturity, type Memo, type MindeesElement, type MindeesNode, NotImplementedError, type Owner, type PackageInfo, type Priority, type ScheduleOptions, type ScheduledTask, Scheduler, type SchedulerOptions, type SelectorEquals, type Signal, type SignalOptions, type Task, type ThreadPool, VERSION, type WorkerLike, type WorkerPoolOptions, batch, computed, createContext, createElement, createInlineThreadPool, createNativeThreadPool, createProvider, createRoot, createScheduler, createWorkerPool, effect, getOwner, hasOwner, info, isElement, maturity, memo, name, notImplemented, onCleanup, renderComponent, runWithOwner, signal, untrack };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;;;;;AAgGA;AAAA,cApBa,IAAA;;cAGA,OAAA;AAiBuE;;;;;;;;AAAA,cAPvE,QAAA,EAAU,QAAyB;;;;;;cAOnC,IAAA,EAAM,WAAiE"}

package/dist/index.js

@@ -0,0 +1,34 @@
+import { batch, computed, createRoot, effect, getOwner, memo, onCleanup, runWithOwner, signal, untrack } from "./reactive/reactive.js";
+import { ELEMENT_TYPE, Fragment, createContext, createElement, createProvider, hasOwner, isElement, renderComponent } from "./component/component.js";
+import { NotImplementedError } from "./errors.js";
+import { notImplemented } from "./not-implemented.js";
+import { Scheduler, createScheduler } from "./scheduler/scheduler.js";
+import { createInlineThreadPool, createNativeThreadPool, createWorkerPool } from "./threading/thread-pool.js";
+//#region src/index.ts
+/** The npm package name. */
+const name = "@mindees/core";
+/** The package version. All `@mindees/*` packages share one locked version line. */
+const VERSION = "0.1.0";
+/**
+* Current maturity of this package. See the repository `STATUS.md`.
+*
+* The reactivity layer (signals/computed/effect/batch), the component model with
+* selector-isolated context, the priority scheduler, and the thread-pool
+* abstraction (Web Worker + inline) are all implemented and tested. Native
+* multi-threading remains a research track (throws `NotImplementedError`).
+*/
+const maturity = "experimental";
+/**
+* Static identity + maturity metadata for this package. Frozen so the
+* self-reported identity tooling introspects cannot be mutated at runtime,
+* matching the `readonly` fields of {@link PackageInfo}.
+*/
+const info = Object.freeze({
+	name,
+	version: VERSION,
+	maturity
+});
+//#endregion
+export { ELEMENT_TYPE, Fragment, NotImplementedError, Scheduler, VERSION, batch, computed, createContext, createElement, createInlineThreadPool, createNativeThreadPool, createProvider, createRoot, createScheduler, createWorkerPool, effect, getOwner, hasOwner, info, isElement, maturity, memo, name, notImplemented, onCleanup, renderComponent, runWithOwner, signal, untrack };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/index.ts"],"sourcesContent":["import type { Maturity, PackageInfo } from './types'\n\n/**\n * Component model: a renderer-agnostic element tree plus selector-based,\n * re-render-isolated context. (Phase 2)\n */\nexport {\n  type Component,\n  type Context,\n  type ContextProvider,\n  createContext,\n  createElement,\n  createProvider,\n  ELEMENT_TYPE,\n  type ElementType,\n  Fragment,\n  hasOwner,\n  isElement,\n  type MindeesElement,\n  type MindeesNode,\n  renderComponent,\n  type SelectorEquals,\n} from './component'\nexport { NotImplementedError } from './errors'\nexport { notImplemented } from './not-implemented'\n/**\n * Fine-grained reactivity: signals, computed values, effects, batching, and\n * disposal scopes. This is the reactive core of MindeesNative.\n */\nexport {\n  type Accessor,\n  batch,\n  type ComputedOptions,\n  computed,\n  createRoot,\n  type EqualsFn,\n  effect,\n  getOwner,\n  type Memo,\n  memo,\n  type Owner,\n  onCleanup,\n  runWithOwner,\n  type Signal,\n  type SignalOptions,\n  signal,\n  untrack,\n} from './reactive'\n/**\n * Priority scheduler: two-lane (sync/normal), microtask-batched, with\n * cancellable and dedupable tasks. (Phase 2)\n */\nexport {\n  createScheduler,\n  type Priority,\n  type ScheduledTask,\n  type ScheduleOptions,\n  Scheduler,\n  type SchedulerOptions,\n  type Task,\n} from './scheduler'\n/**\n * Threading abstraction: a {@link ThreadPool} contract with a working Web Worker\n * backend and an inline fallback. Native multi-threading is a research track. (Phase 2)\n */\nexport {\n  createInlineThreadPool,\n  createNativeThreadPool,\n  createWorkerPool,\n  type ThreadPool,\n  type WorkerLike,\n  type WorkerPoolOptions,\n} from './threading'\nexport type { Maturity, PackageInfo } from './types'\n\n/** The npm package name. */\nexport const name = '@mindees/core'\n\n/** The package version. All `@mindees/*` packages share one locked version line. */\nexport const VERSION = '0.1.0'\n\n/**\n * Current maturity of this package. See the repository `STATUS.md`.\n *\n * The reactivity layer (signals/computed/effect/batch), the component model with\n * selector-isolated context, the priority scheduler, and the thread-pool\n * abstraction (Web Worker + inline) are all implemented and tested. Native\n * multi-threading remains a research track (throws `NotImplementedError`).\n */\nexport const maturity: Maturity = 'experimental'\n\n/**\n * Static identity + maturity metadata for this package. Frozen so the\n * self-reported identity tooling introspects cannot be mutated at runtime,\n * matching the `readonly` fields of {@link PackageInfo}.\n */\nexport const info: PackageInfo = Object.freeze({ name, version: VERSION, maturity })\n"],"mappings":";;;;;;;;AA4EA,MAAa,OAAO;;AAGpB,MAAa,UAAU;;;;;;;;;AAUvB,MAAa,WAAqB;;;;;;AAOlC,MAAa,OAAoB,OAAO,OAAO;CAAE;CAAM,SAAS;CAAS;AAAS,CAAC"}

package/dist/not-implemented.d.ts

@@ -0,0 +1,16 @@
+//#region src/not-implemented.d.ts
+/**
+ * Throw a {@link NotImplementedError} for a not-yet-built capability.
+ *
+ * The `never` return type documents at the type level that this function never
+ * returns normally, so call sites type-check without bogus fallbacks.
+ *
+ * @param feature - Human-readable name of the unimplemented capability.
+ * @param options - Optional metadata, e.g. the tracking RFC.
+ */
+declare function notImplemented(feature: string, options?: {
+  readonly rfc?: string;
+}): never;
+//#endregion
+export { notImplemented };
+//# sourceMappingURL=not-implemented.d.ts.map

package/dist/not-implemented.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"not-implemented.d.ts","names":[],"sources":["../src/not-implemented.ts"],"mappings":";;AAWA;;;;;;;;iBAAgB,cAAA,CAAe,OAAA,UAAiB,OAAA;EAAA,SAAqB,GAAA;AAAA"}

package/dist/not-implemented.js

@@ -0,0 +1,18 @@
+import { NotImplementedError } from "./errors.js";
+//#region src/not-implemented.ts
+/**
+* Throw a {@link NotImplementedError} for a not-yet-built capability.
+*
+* The `never` return type documents at the type level that this function never
+* returns normally, so call sites type-check without bogus fallbacks.
+*
+* @param feature - Human-readable name of the unimplemented capability.
+* @param options - Optional metadata, e.g. the tracking RFC.
+*/
+function notImplemented(feature, options) {
+	throw new NotImplementedError(feature, options);
+}
+//#endregion
+export { notImplemented };
+
+//# sourceMappingURL=not-implemented.js.map

package/dist/not-implemented.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"not-implemented.js","names":[],"sources":["../src/not-implemented.ts"],"sourcesContent":["import { NotImplementedError } from './errors'\n\n/**\n * Throw a {@link NotImplementedError} for a not-yet-built capability.\n *\n * The `never` return type documents at the type level that this function never\n * returns normally, so call sites type-check without bogus fallbacks.\n *\n * @param feature - Human-readable name of the unimplemented capability.\n * @param options - Optional metadata, e.g. the tracking RFC.\n */\nexport function notImplemented(feature: string, options?: { readonly rfc?: string }): never {\n  throw new NotImplementedError(feature, options)\n}\n"],"mappings":";;;;;;;;;;;AAWA,SAAgB,eAAe,SAAiB,SAA4C;CAC1F,MAAM,IAAI,oBAAoB,SAAS,OAAO;AAChD"}