@askrjs/askr 0.0.52 → 0.0.54

package/README.md

@@ -24,9 +24,13 @@ createIsland({ root: document.body, component: Counter });
 ### Runtime
 
 `@askrjs/askr` exports the core runtime primitives: `state()`, `derive()`,
-`selector()`, `defineContext()`, `readContext()`, `getSignal()`, and the JSX
+`selector()`, `defineScope()`, `readScope()`, `getSignal()`, and the JSX
 runtime exports.
 
+Public APIs prefer functions and closures over classes. Lexical ownership uses
+`defineScope()` and `readScope()`; there are no compatibility aliases for the
+clean-break vocabulary.
+
 App startup, routing, async resources, data helpers, and error boundaries live
 on their own subpaths.
 

package/dist/{runtime/scheduler.js → access-Bg4RJNC8.js}

@@ -1,7 +1,93 @@
-import { isDevelopmentEnvironment } from "../common/env.js";
-import { assertSchedulingPrecondition, invariant } from "../common/invariant.js";
-import { logger } from "../common/logger.js";
-import { recordSchedulerFlushTaskCount } from "./perf-metrics.js";
+//#region src/common/env.ts
+function normalizeEnv(source) {
+	if (!source) return {};
+	const normalized = {};
+	for (const [key, value] of Object.entries(source)) if (typeof value === "string") normalized[key] = value;
+	else if (typeof value === "boolean" || typeof value === "number") normalized[key] = String(value);
+	return normalized;
+}
+function getBuildTimeEnv() {
+	const metaEnv = import.meta.env;
+	const normalized = normalizeEnv(metaEnv);
+	if (normalized.NODE_ENV == null && metaEnv) {
+		if (typeof metaEnv.MODE === "string" && metaEnv.MODE.length > 0) normalized.NODE_ENV = metaEnv.MODE;
+		else if (metaEnv.PROD === true || metaEnv.PROD === "true") normalized.NODE_ENV = "production";
+		else if (metaEnv.DEV === true || metaEnv.DEV === "true") normalized.NODE_ENV = "development";
+	}
+	return normalized;
+}
+function resolveNodeEnv(processNodeEnv, buildNodeEnv) {
+	if (buildNodeEnv === "production") return "production";
+	if (processNodeEnv != null) return processNodeEnv;
+	if (buildNodeEnv === "development") return "development";
+	return buildNodeEnv === "test" ? void 0 : buildNodeEnv;
+}
+function getRuntimeEnv() {
+	const processEnv = globalThis.process?.env ?? {};
+	const buildTimeEnv = getBuildTimeEnv();
+	return {
+		...processEnv,
+		...buildTimeEnv,
+		NODE_ENV: resolveNodeEnv(processEnv.NODE_ENV, buildTimeEnv.NODE_ENV)
+	};
+}
+function isProductionEnvironment() {
+	return getRuntimeEnv().NODE_ENV === "production";
+}
+function isDevelopmentEnvironment() {
+	return !isProductionEnvironment();
+}
+//#endregion
+//#region src/common/invariant.ts
+/**
+* Invariant assertions shared by production runtime code.
+*/
+function invariant(condition, message, context) {
+	if (!condition) {
+		const contextStr = context ? "\n" + JSON.stringify(context, null, 2) : "";
+		throw new Error(`[Askr Invariant] ${message}${contextStr}`);
+	}
+}
+function assertSchedulingPrecondition(condition, violationMessage) {
+	invariant(condition, `[Scheduler Precondition] ${violationMessage}`);
+}
+//#endregion
+//#region src/common/logger.ts
+/**
+* Shared logger interface for runtime and tooling code.
+*
+* Debug, info, and warn stay silent in production. Errors always log.
+*/
+function callConsole(method, args) {
+	const c = typeof console !== "undefined" ? console : void 0;
+	if (!c) return;
+	const fn = c[method];
+	if (typeof fn === "function") try {
+		fn.apply(console, args);
+	} catch {}
+}
+const logger = {
+	debug: (...args) => {
+		if (isProductionEnvironment()) return;
+		callConsole("debug", args);
+	},
+	info: (...args) => {
+		if (isProductionEnvironment()) return;
+		callConsole("info", args);
+	},
+	warn: (...args) => {
+		if (isProductionEnvironment()) return;
+		callConsole("warn", args);
+	},
+	error: (...args) => {
+		callConsole("error", args);
+	}
+};
+//#endregion
+//#region src/runtime/perf-metrics.ts
+const incrementPerfMetric = () => {};
+const addPerfDuration = () => {};
+//#endregion
 //#region src/runtime/scheduler.ts
 /**
 * Serialized update scheduler — safer design (no inline execution, explicit flush)
@@ -166,7 +252,6 @@ var Scheduler = class {
 			}
 			this.flushVersion++;
 			this.resolveWaiters();
-			recordSchedulerFlushTaskCount(executedTaskCount);
 		}
 		if (failures.length === 1) throw failures[0];
 		if (failures.length > 1) throw new AggregateError(failures, "Scheduler task failures");
@@ -197,14 +282,12 @@ var Scheduler = class {
 		if (this.flushVersion >= target) return Promise.resolve();
 		return new Promise((resolve, reject) => {
 			const timer = setTimeout(() => {
-				const ns = globalThis.__ASKR__ || {};
 				const diag = {
 					flushVersion: this.flushVersion,
 					queueLen: this.getPendingTaskCount(),
 					running: this.running,
 					inHandler: this.inHandler,
-					bulk: this.isBulkCommitActive(),
-					namespace: ns
+					bulk: this.isBulkCommitActive()
 				};
 				reject(/* @__PURE__ */ new Error(`waitForFlush timeout ${timeoutMs}ms: ${JSON.stringify(diag)}`));
 			}, timeoutMs);
@@ -313,4 +396,94 @@ function scheduleEventHandler(handler) {
 	};
 }
 //#endregion
-export { Scheduler, globalScheduler, scheduleEventHandler };
+//#region src/runtime/runtime.ts
+function createMissingRendererHost() {
+	const missing = (method) => {
+		throw new Error(`[Askr] renderer host is not configured; cannot call ${method}().`);
+	};
+	return {
+		evaluate() {
+			missing("evaluate");
+		},
+		cleanupInstancesUnder() {
+			missing("cleanupInstancesUnder");
+		},
+		teardownNodeSubtree() {
+			missing("teardownNodeSubtree");
+		},
+		populateKeyMapForElement() {},
+		getKeyMapForElement() {},
+		isKeyedReorderFastPathEligible() {
+			return {
+				useFastPath: false,
+				totalKeyed: 0,
+				totalChildren: 0,
+				currentKeyCount: 0,
+				moveCount: 0,
+				lisLen: 0,
+				hasPropChanges: false,
+				isWholeKeyedList: false
+			};
+		},
+		markReactivePropsDirtySource() {}
+	};
+}
+var AskrRuntime = class {
+	constructor(options = {}) {
+		this.scheduler = options.scheduler ?? globalScheduler;
+		this.rendererHost = options.renderer ?? createMissingRendererHost();
+	}
+	get renderer() {
+		return this.rendererHost;
+	}
+	configureRenderer(renderer) {
+		this.rendererHost = renderer;
+	}
+};
+const defaultRuntime = new AskrRuntime({ scheduler: globalScheduler });
+function createRuntime(options = {}) {
+	return new AskrRuntime(options);
+}
+function getDefaultRuntime() {
+	return defaultRuntime;
+}
+function configureRuntimeRenderer(renderer, runtime = defaultRuntime) {
+	runtime.configureRenderer(renderer);
+}
+//#endregion
+//#region src/runtime/access.ts
+function getRuntimeScheduler() {
+	return getDefaultRuntime().scheduler;
+}
+function getDefaultRuntimeInstance() {
+	return getDefaultRuntime();
+}
+function getRuntimeRenderer() {
+	return getDefaultRuntime().renderer;
+}
+function enqueueRuntimeTask(task) {
+	getRuntimeScheduler().enqueue(task);
+}
+function enqueueRuntimeLane(lane, task) {
+	getRuntimeScheduler().enqueueInLane(lane, task);
+}
+function runRuntimeHandlerScope(fn, flushMode = "defer") {
+	return getRuntimeScheduler().runInHandlerScope(fn, flushMode);
+}
+function runRuntimeWithSyncProgress(fn) {
+	return getRuntimeScheduler().runWithSyncProgress(fn);
+}
+function getRuntimeFlushVersion() {
+	return getRuntimeScheduler().getFlushVersion();
+}
+function flushRuntimeScheduler() {
+	getRuntimeScheduler().flush();
+}
+function setRuntimeBulkCommitProbe(probe) {
+	getRuntimeScheduler().setBulkCommitProbe(probe);
+}
+function markRuntimeReactivePropsDirtySource(source) {
+	getRuntimeRenderer().markReactivePropsDirtySource(source);
+}
+//#endregion
+export { incrementPerfMetric as _, getRuntimeFlushVersion as a, isDevelopmentEnvironment as b, runRuntimeHandlerScope as c, AskrRuntime as d, configureRuntimeRenderer as f, addPerfDuration as g, scheduleEventHandler as h, getDefaultRuntimeInstance as i, runRuntimeWithSyncProgress as l, getDefaultRuntime as m, enqueueRuntimeTask as n, getRuntimeRenderer as o, createRuntime as p, flushRuntimeScheduler as r, markRuntimeReactivePropsDirtySource as s, enqueueRuntimeLane as t, setRuntimeBulkCommitProbe as u, logger as v, isProductionEnvironment as x, getRuntimeEnv as y };

package/dist/actions/index.d.ts

@@ -0,0 +1,2 @@
+import { a as action, i as ActionValidationError, n as ActionForm, o as defineAction, r as ActionStatus, t as ActionDescriptor } from "../index-C8iW3xCt.js";
+export { ActionDescriptor, ActionForm, ActionStatus, ActionValidationError, action, defineAction };

package/dist/actions/index.js

@@ -0,0 +1,103 @@
+import { d as getCurrentAppRenderRuntime } from "../component-scope-CC3cojX9.js";
+import { r as getCurrentRenderData } from "../render-context-Clw3rFiO.js";
+import { t as state } from "../state-DPl8lffD.js";
+import { jsx, jsxs } from "../jsx-runtime.js";
+import { c as resolveDataRuntimeState, s as invalidateQueriesForRuntime } from "../data-runtime-SJ1BSUvk.js";
+//#region src/actions/runtime.ts
+const emptyFramework = Object.freeze({});
+/** @internal Read Askr-owned state from the current application root. */
+function readActionFramework() {
+	return getCurrentAppRenderRuntime()?.framework ?? emptyFramework;
+}
+//#endregion
+//#region src/actions/index.tsx
+function csrfToken() {
+	const value = getCurrentRenderData()?.framework.csrf ?? readActionFramework().csrf;
+	return typeof value === "string" ? value : void 0;
+}
+function defineAction(options) {
+	if (!options.id) throw new Error("defineAction requires a stable id.");
+	if (options.input.kind !== "object") throw new Error("defineAction input must be an object schema.");
+	return Object.freeze({
+		id: options.id,
+		input: options.input,
+		invalidates: Object.freeze([...options.invalidates ?? []])
+	});
+}
+/** A native form bound to a declared action; it is not a synthetic event API. */
+function ActionForm({ action, children, ...props }) {
+	const token = csrfToken();
+	return /* @__PURE__ */ jsxs("form", {
+		...props,
+		method: "post",
+		children: [
+			/* @__PURE__ */ jsx("input", {
+				type: "hidden",
+				name: "_askr_action",
+				value: action.id
+			}),
+			token ? /* @__PURE__ */ jsx("input", {
+				type: "hidden",
+				name: "_csrf",
+				value: token
+			}) : null,
+			children
+		]
+	});
+}
+function validationError(value, actionId) {
+	if (!value || typeof value !== "object") return void 0;
+	const replay = value;
+	if (replay.kind !== "invalid" || replay.action !== actionId) return void 0;
+	if (!replay.values || !Array.isArray(replay.issues) || !replay.fieldErrors) return void 0;
+	return replay;
+}
+function initialStatus(actionId) {
+	const replay = validationError(getCurrentRenderData()?.framework.action ?? readActionFramework().action, actionId);
+	return replay ? {
+		pending: false,
+		error: replay
+	} : { pending: false };
+}
+/** Returns a command handle, rather than a hook. */
+function action(descriptor) {
+	const token = csrfToken();
+	const runtime = resolveDataRuntimeState();
+	const value = state(initialStatus(descriptor.id));
+	const setValue = value.set;
+	return {
+		state: value,
+		async submit(input) {
+			setValue({ pending: true });
+			try {
+				const response = await fetch(location.href, {
+					method: "POST",
+					headers: {
+						"content-type": "application/json",
+						accept: "application/vnd.askr.action+json;v=1",
+						"x-askr-action": descriptor.id,
+						...token ? { "x-askr-csrf-token": token } : {}
+					},
+					body: JSON.stringify(input)
+				});
+				const envelope = await response.json();
+				if (!response.ok) throw envelope.error ?? validationError(envelope, descriptor.id) ?? /* @__PURE__ */ new Error(`Action failed (${response.status}).`);
+				const invalidates = Array.isArray(envelope.invalidates) ? envelope.invalidates.filter((prefix) => typeof prefix === "string") : descriptor.invalidates;
+				for (const prefix of invalidates) invalidateQueriesForRuntime(runtime, prefix, true);
+				setValue({
+					pending: false,
+					result: envelope.result
+				});
+				return envelope.result;
+			} catch (error) {
+				setValue({
+					pending: false,
+					error
+				});
+				throw error;
+			}
+		}
+	};
+}
+//#endregion
+export { ActionForm, action, defineAction };

package/dist/{common/attr-names.js → attr-names-CjhzmHOn.js}

@@ -12,4 +12,4 @@ function getPublicAttributeName(propName) {
 	return PUBLIC_ATTRIBUTE_NAME_MAP[propName] ?? propName;
 }
 //#endregion
-export { getPublicAttributeName };
+export { getPublicAttributeName as t };

package/dist/benchmark.d.ts

@@ -1,5 +1,9 @@
-import { BenchmarkRowData } from "./bench/components/benchmark-row.js";
-
+//#region src/bench/components/benchmark-row.d.ts
+interface BenchmarkRowData {
+  id: number;
+  label: string;
+}
+//#endregion
 //#region src/bench/benchmark-entry.d.ts
 type RowData = BenchmarkRowData;
 interface BenchmarkMetadata {

package/dist/benchmark.js

@@ -1,18 +1,70 @@
-import { flushRuntimeScheduler } from "./runtime/access.js";
-import { state } from "./runtime/state.js";
-import { selector } from "./runtime/selector.js";
-import "./runtime/index.js";
-import { jsx } from "./jsx-runtime.js";
-import { installRendererBridge } from "./renderer/index.js";
-import "./jsx-runtime2.js";
-import { createIsland } from "./boot/index.js";
-import { BenchmarkTable } from "./bench/components/benchmark-table.js";
+import { r as flushRuntimeScheduler } from "./access-Bg4RJNC8.js";
+import { t as installRendererBridge } from "./renderer-DrLRAD5y.js";
+import { t as state } from "./state-DPl8lffD.js";
+import { t as selector } from "./selector-DafVYzV4.js";
+import { jsx, jsxs } from "./jsx-runtime.js";
+import { i as For } from "./control-mXROCjL3.js";
+import { t as createIsland } from "./boot-2ZR3MtO0.js";
+//#region src/bench/components/benchmark-row.tsx
+function BenchmarkRow({ item, isSelected, onSelect, onRemove }) {
+	return /* @__PURE__ */ jsxs("tr", {
+		class: () => isSelected(item.id) ? "danger" : "",
+		children: [
+			/* @__PURE__ */ jsx("td", {
+				class: "col-md-1",
+				children: () => item.id
+			}, "id"),
+			/* @__PURE__ */ jsx("td", {
+				class: "col-md-4",
+				children: /* @__PURE__ */ jsx("a", {
+					onClick: (event) => {
+						event.preventDefault();
+						onSelect(item.id);
+					},
+					children: () => item.label
+				})
+			}, "label"),
+			/* @__PURE__ */ jsx("td", {
+				class: "col-md-1",
+				children: /* @__PURE__ */ jsx("a", {
+					onClick: (event) => {
+						event.preventDefault();
+						onRemove(item.id);
+					},
+					children: /* @__PURE__ */ jsx("span", {
+						class: "glyphicon glyphicon-remove",
+						"aria-hidden": "true"
+					})
+				})
+			}, "remove"),
+			/* @__PURE__ */ jsx("td", { class: "col-md-6" }, "spacer")
+		]
+	});
+}
+//#endregion
+//#region src/bench/components/benchmark-table.tsx
+function BenchmarkTable({ rows, isSelected, onSelect, onRemove }) {
+	return /* @__PURE__ */ jsx("table", {
+		class: "table table-hover table-striped test-data",
+		children: /* @__PURE__ */ jsx("tbody", { children: /* @__PURE__ */ jsx(For, {
+			each: () => rows(),
+			by: (item) => item.id,
+			children: (item) => /* @__PURE__ */ jsx(BenchmarkRow, {
+				item,
+				isSelected,
+				onSelect,
+				onRemove
+			})
+		}) })
+	});
+}
+//#endregion
 //#region src/bench/benchmark-entry.tsx
 installRendererBridge();
 const benchmarkMetadata = {
 	packageName: "@askrjs/askr",
-	packageVersion: "0.0.52",
-	buildLabel: "0.0.52-local"
+	packageVersion: "0.0.54",
+	buildLabel: "0.0.54-local"
 };
 function getBenchmarkMetadata() {
 	return { ...benchmarkMetadata };

package/dist/boot/index.d.ts

@@ -1,6 +1,65 @@
-import { HydrateSPAConfig, IslandConfig, IslandsConfig, SPAConfig } from "./types.js";
-import { cleanupApp, hasApp } from "./root-lifecycle.js";
+import { s as ComponentFunction } from "../control-BI4RMD2z.js";
+import { v as DataRuntime } from "../index-Bki2rqcr.js";
+import { P as RouteRegistry, m as RouteAuthOptions, p as Route, x as RouteManifest } from "../router-DCfwLBr-.js";
+import { d as ScrollRestorationOptions } from "../navigate-BVDCzOuB.js";
 
+//#region src/boot/types.d.ts
+type IslandConfig = {
+  root: Element | string;
+  component: ComponentFunction;
+  cleanupStrict?: boolean;
+  routes?: never;
+};
+type IslandsConfig = {
+  islands: IslandConfig[];
+};
+type BootRouteSource = {
+  registry: RouteRegistry;
+  manifest?: RouteManifest;
+  routes?: Route[];
+} | {
+  manifest: RouteManifest;
+  registry?: RouteRegistry;
+  routes?: Route[];
+} | {
+  manifest?: RouteManifest;
+  registry?: RouteRegistry;
+  routes: Route[];
+};
+type SPAConfig = BootRouteSource & {
+  root: Element | string;
+  /**
+   * Preferred: pass a route registry built via `createRouteRegistry(() => { ... })`.
+   * ```ts
+   * import { createRouteRegistry } from '@askrjs/askr/router';
+   * const registry = createRouteRegistry(() => { ... });
+   * await createSPA({ root: '#app', registry });
+   * ```
+   */
+  auth?: RouteAuthOptions;
+  scrollRestoration?: boolean | ScrollRestorationOptions;
+  cleanupStrict?: boolean;
+  component?: never;
+};
+type HydrateSPAConfig = BootRouteSource & {
+  root: Element | string;
+  dataRuntime?: DataRuntime; /** Preferred route input - see `SPAConfig`. */
+  auth?: RouteAuthOptions;
+  scrollRestoration?: boolean | ScrollRestorationOptions;
+  cleanupStrict?: boolean;
+  hydrate?: {
+    verifyMarkup?: boolean;
+    deferUntilIdle?: boolean;
+    deferBelowFold?: boolean;
+    foldThreshold?: number;
+    skipSelectors?: string[];
+  };
+};
+//#endregion
+//#region src/boot/root-lifecycle.d.ts
+declare function cleanupApp(root: Element | string): void;
+declare function hasApp(root: Element | string): boolean;
+//#endregion
 //#region src/boot/index.d.ts
 /**
  * createIsland: Enhances existing DOM (no router, mounts once)