@askrjs/askr 0.0.88 → 0.0.89

package/dist/testing/index.js

@@ -1,7 +1,9 @@
 import { r as flushRuntimeScheduler } from "../access-Dpfoi4cA.js";
-import { l as addInvalidationListener, t as createDataRuntime } from "../data-runtime-CnVeSvJz.js";
+import { u as recordReadableRead } from "../readable-B5NtV7V0.js";
+import { l as addInvalidationListener, t as createDataRuntime } from "../data-runtime-SC6zzAwh.js";
+import { a as notifySource, i as normalizeAsyncDataError, r as createReadableSource } from "../data-BmZC1kDn.js";
 import { r as computeRouteActivityMatches } from "../route-matching-DqULzZtC.js";
-import { a as cleanupApp, r as createSPA, t as createIsland } from "../boot-BVHzYQz8.js";
+import { a as cleanupApp, r as createSPA, t as createIsland } from "../boot-CrbszDjZ.js";
 //#region src/testing/render.ts
 const renderStates = /* @__PURE__ */ new WeakMap();
 const eventConstructorNames = {
@@ -169,6 +171,7 @@ async function renderRoute(options) {
 			root: container,
 			registry: options.registry,
 			auth: options.auth,
+			dataRuntime: options.dataRuntime,
 			cleanupStrict: options.cleanupStrict
 		});
 		flush();
@@ -218,6 +221,150 @@ function createQueryTestRegistry() {
 		}
 	};
 }
+/** Create a keyed mutation fixture registry for a test render runtime. */
+function createMutationTestRegistry() {
+	const runtime = createDataRuntime();
+	return {
+		runtime,
+		set(key, mutation) {
+			if (typeof key !== "string" || key.length === 0) throw new TypeError("@askrjs/askr/testing mutation registry keys must be non-empty strings.");
+			const previous = runtime.mutationTestOverrides.get(key);
+			if (previous && previous !== mutation) previous.reset();
+			runtime.mutationTestOverrides.set(key, mutation);
+		},
+		delete(key) {
+			runtime.mutationTestOverrides.get(key)?.reset();
+			runtime.mutationTestOverrides.delete(key);
+		},
+		clear() {
+			for (const mutation of runtime.mutationTestOverrides.values()) mutation.reset();
+			runtime.mutationTestOverrides.clear();
+		}
+	};
+}
+var MutableMutationFixture = class {
+	constructor(initial = {}) {
+		this.source = createReadableSource();
+		this.receivedInputs = [];
+		this.active = null;
+		const hasResult = Object.prototype.hasOwnProperty.call(initial, "result");
+		if (initial.pending && (initial.error != null || hasResult)) throw new TypeError("@askrjs/askr/testing mutation fixtures cannot be pending and settled.");
+		if (initial.error != null && hasResult) throw new TypeError("@askrjs/askr/testing mutation fixtures cannot have both error and result.");
+		this.state = initial.pending ? {
+			status: "pending",
+			error: null,
+			result: null
+		} : initial.error != null ? {
+			status: "error",
+			error: initial.error,
+			result: null
+		} : hasResult ? {
+			status: "success",
+			error: null,
+			result: initial.result
+		} : {
+			status: "idle",
+			error: null,
+			result: null
+		};
+	}
+	get status() {
+		recordReadableRead(this.source);
+		return this.state.status;
+	}
+	get pending() {
+		recordReadableRead(this.source);
+		return this.state.status === "pending";
+	}
+	get error() {
+		recordReadableRead(this.source);
+		return this.state.error;
+	}
+	get result() {
+		recordReadableRead(this.source);
+		return this.state.result;
+	}
+	get inputs() {
+		return this.receivedInputs;
+	}
+	execute(input) {
+		this.abort();
+		this.receivedInputs.push(input);
+		this.setPending();
+		return new Promise((resolve, reject) => {
+			this.active = {
+				resolve,
+				reject
+			};
+		});
+	}
+	setPending() {
+		this.setState({
+			status: "pending",
+			error: null,
+			result: null
+		});
+	}
+	succeed(result) {
+		const active = this.active;
+		this.active = null;
+		this.setState({
+			status: "success",
+			error: null,
+			result
+		});
+		active?.resolve(result);
+	}
+	fail(error) {
+		const normalized = normalizeAsyncDataError(error, "Unknown mutation fixture error");
+		const active = this.active;
+		this.active = null;
+		this.setState({
+			status: "error",
+			error: normalized,
+			result: null
+		});
+		active?.reject(normalized);
+	}
+	abort() {
+		const active = this.active;
+		this.active = null;
+		this.setState({
+			status: "idle",
+			error: null,
+			result: null
+		});
+		if (active) {
+			const error = /* @__PURE__ */ new Error("Mutation fixture aborted.");
+			error.name = "AbortError";
+			active.reject(error);
+		}
+	}
+	reset() {
+		this.abort();
+	}
+	setState(state) {
+		this.state = state;
+		notifySource(this.source);
+	}
+};
+function createMutationFixture(initial = {}) {
+	return new MutableMutationFixture(initial);
+}
+const mutationState = Object.assign(createMutationFixture, {
+	idle() {
+		return createMutationFixture();
+	},
+	pending() {
+		return createMutationFixture({ pending: true });
+	},
+	success(result) {
+		return createMutationFixture({ result });
+	},
+	error(error) {
+		return createMutationFixture({ error });
+	}
+});
 function normalizeRefresh(options) {
 	return async () => {
 		await options?.refresh?.();
@@ -380,4 +527,4 @@ function getRouteWarnings(options) {
 	});
 }
 //#endregion
-export { cleanup, click, createInvalidationRecorder, createQueryTestRegistry, dispatch, flush, getRouteWarnings, matchRoute, mockQuery, mount, queryState, render, renderRoute, submit, type };
+export { cleanup, click, createInvalidationRecorder, createMutationTestRegistry, createQueryTestRegistry, dispatch, flush, getRouteWarnings, matchRoute, mockQuery, mount, mutationState, queryState, render, renderRoute, submit, type };

package/dist/{index-SGxMZLAc.d.ts → types-iAmDSV6o.d.ts}

@@ -6,11 +6,14 @@ interface DataRuntime {
   readonly queryData: Map<string, unknown>;
   /** Test-only query overrides keyed by the canonical query key. */
   readonly queryTestOverrides: Map<string, unknown>;
+  /** Test-only mutation overrides keyed by the canonical mutation key. */
+  readonly mutationTestOverrides: Map<string, unknown>;
 }
 interface DataRuntimeOptions {
   queryCache?: Map<string, unknown>;
   queryData?: Map<string, unknown>;
   queryTestOverrides?: Map<string, unknown>;
+  mutationTestOverrides?: Map<string, unknown>;
 }
 interface QueryDefinition<TInput, TResult extends {}> {
   readonly key: (input: TInput) => string;
@@ -163,6 +166,8 @@ type QueryOptions<T> = {
   skipInitialFetch?: boolean;
 };
 type MutationOptions<TInput, TResult> = {
+  /** Stable identity used by runtime-scoped mutation test overrides. */
+  key?: string;
   action: (input: TInput, ctx: {
     signal: AbortSignal;
   }) => Promise<TResult>;
@@ -171,66 +176,4 @@ type MutationOptions<TInput, TResult> = {
   runtime?: DataRuntime;
 };
 //#endregion
-//#region src/common/telemetry.d.ts
-interface TelemetryFields {
-  requestId?: string;
-  traceId?: string;
-  route?: string;
-  action?: string;
-  operation?: string;
-  status?: number;
-  durationMs?: number;
-}
-type TelemetrySpan = <T>(fields: TelemetryFields, work: () => T) => T;
-/**
- * Structural subset implemented by `createTelemetry()` from `@askrjs/otel`.
- * Core does not install an OpenTelemetry SDK, backend, or exporter.
- */
-interface CoreTelemetry {
-  routeMatch?: TelemetrySpan;
-  loader?: TelemetrySpan;
-  queryPrefetch?: TelemetrySpan;
-  ssrRender?: TelemetrySpan;
-}
-//#endregion
-//#region src/data/mutation-cell.d.ts
-declare function createMutation<TInput, TResult>(options: MutationOptions<TInput, TResult>): Mutation<TInput, TResult>;
-//#endregion
-//#region src/data/query-cell.d.ts
-declare function createQuery<T extends {}>(options: QueryOptions<T>): Query<T>;
-declare function createQuery<TInput, TResult extends {}>(definition: QueryDefinition<TInput, TResult>, input: TInput, options?: Omit<QueryOptions<TResult>, 'key' | 'fetch'>): Query<TResult>;
-//#endregion
-//#region src/data/data-runtime.d.ts
-declare function createDataRuntime(options?: DataRuntimeOptions): DataRuntime;
-declare function getDefaultDataRuntime(): DataRuntime;
-//#endregion
-//#region src/data/invalidation.d.ts
-declare function invalidate(prefix: string, options?: InvalidateOptions): void;
-declare function queryScope(namespace: string): QueryScope;
-declare function invalidateOnInterval(prefix: string, options: InvalidateOnIntervalOptions): void;
-//#endregion
-//#region src/data/query-registry.d.ts
-interface ServerQueryRegistry {
-  readonly entries: readonly ServerQueryEntry<unknown, {}>[];
-  get<TInput, TResult extends {}>(query: QueryDefinition<TInput, TResult>): ServerQueryHandler<TInput, TResult> | undefined;
-}
-interface ServerQueryEntry<TInput, TResult extends {}> {
-  readonly query: QueryDefinition<TInput, TResult>;
-  readonly handler: ServerQueryHandler<TInput, TResult>;
-}
-declare function serveQuery<TInput, TResult extends {}>(query: QueryDefinition<TInput, TResult>, handler: ServerQueryHandler<TInput, TResult>): ServerQueryEntry<TInput, TResult>;
-declare function defineServerQueries(...entries: readonly ServerQueryEntry<any, any>[]): ServerQueryRegistry;
-declare function defineQuery<TInput, TResult extends {}>(definition: QueryDefinition<TInput, TResult>): QueryDefinition<TInput, TResult>;
-declare function createQueryPrefetchContext(options?: {
-  runtime?: DataRuntime;
-  registry?: ServerQueryRegistry;
-  request?: Request;
-  signal?: AbortSignal;
-  mode?: 'ssr' | 'spa';
-  telemetry?: CoreTelemetry;
-}): QueryPrefetchContext;
-declare function prefetchQuery<TInput, TResult extends {}>(context: QueryPrefetchContext, query: QueryDefinition<TInput, TResult>, input: TInput): Promise<boolean>;
-declare function dehydrateDataRuntime(runtime: DataRuntime): Record<string, unknown>;
-declare function hydrateDataRuntime(runtime: DataRuntime, data: unknown): void;
-//#endregion
-export { ServerQueryHandler as A, Query as C, QueryPrefetchContext as D, QueryKeyPart as E, QueryScope as O, Mutation as S, QueryDefinition as T, CoreTelemetry as _, defineServerQueries as a, InvalidateOnIntervalOptions as b, prefetchQuery as c, invalidateOnInterval as d, queryScope as f, createMutation as g, createQuery as h, defineQuery as i, QueryStaleReason as k, serveQuery as l, getDefaultDataRuntime as m, ServerQueryRegistry as n, dehydrateDataRuntime as o, createDataRuntime as p, createQueryPrefetchContext as r, hydrateDataRuntime as s, ServerQueryEntry as t, invalidate as u, DataRuntime as v, QueryConsistency as w, InvalidateOptions as x, DataRuntimeOptions as y };
+export { Mutation as a, QueryConsistency as c, QueryOptions as d, QueryPrefetchContext as f, ServerQueryHandler as h, InvalidateOptions as i, QueryDefinition as l, QueryStaleReason as m, DataRuntimeOptions as n, MutationOptions as o, QueryScope as p, InvalidateOnIntervalOptions as r, Query as s, DataRuntime as t, QueryKeyPart as u };

package/dist/{verify-hydration-Bd1kGLmH.js → verify-hydration-AdrYLDxd.js}

@@ -1,6 +1,6 @@
 import { m as withHydrationVerificationRender } from "./render-context-D0Hoj9dW.js";
 import { t as SSR_RENDER_DATA_ATTR } from "./ssr-DSHd_Q9K.js";
-import { a as renderResolvedToStringSync } from "./ssr-D3hUAWyQ.js";
+import { a as renderResolvedToStringSync } from "./ssr-DXGtDJd7.js";
 //#region src/ssr/verify-hydration.ts
 function normalizeHydrationHtml(html) {
 	const template = document.createElement("template");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askrjs/askr",
-  "version": "0.0.88",
+  "version": "0.0.89",
   "description": "Actor-backed deterministic UI framework",
   "keywords": [
     "askr",
@@ -152,7 +152,7 @@
     "@askrjs/schema": ">=0.0.5 <0.1.0"
   },
   "devDependencies": {
-    "@types/node": "^26.1.2",
+    "@types/node": "^26.2.0",
     "@typescript/native": "npm:typescript@^7.0.2",
     "@vitest/browser-playwright": "4.1.10",
     "cross-env": "^10.1.0",