@askrjs/askr 0.3.0 → 0.4.0

package/dist/data-runtime-C1bFAlba.js

@@ -0,0 +1,242 @@
+import { r as currentAppRuntime } from "./hooks-BimKStr4.js";
+import { n as getActiveRenderContext } from "./render-context-DGHnEveC.js";
+//#region src/data/invalidation-listeners.ts
+const invalidationListeners = /* @__PURE__ */ new Set();
+const activeInvalidationPrefixes = [];
+const MAX_INVALIDATION_CASCADE_DEPTH = 100;
+function addInvalidationListener(listener) {
+	invalidationListeners.add(listener);
+	return () => {
+		invalidationListeners.delete(listener);
+	};
+}
+/**
+* Whether any listener is registered. Listeners come only from the testing
+* entry (`createInvalidationRecorder()`), so production invalidations check
+* this and skip dispatch and cascade bookkeeping entirely.
+*/
+function hasInvalidationListeners() {
+	return invalidationListeners.size > 0;
+}
+function emitInvalidation(event) {
+	if (activeInvalidationPrefixes.includes(event.prefix)) throw new Error(`[Askr] Cyclic invalidation cascade detected for prefix ${JSON.stringify(event.prefix)}.`);
+	if (activeInvalidationPrefixes.length >= MAX_INVALIDATION_CASCADE_DEPTH) throw new Error(`[Askr] Invalidation cascade exceeded ${MAX_INVALIDATION_CASCADE_DEPTH} nested events at prefix ${JSON.stringify(event.prefix)}.`);
+	activeInvalidationPrefixes.push(event.prefix);
+	try {
+		for (const listener of invalidationListeners) listener(event);
+	} finally {
+		activeInvalidationPrefixes.pop();
+	}
+}
+//#endregion
+//#region src/data/collection-invalidation.ts
+const owners = /* @__PURE__ */ new WeakMap();
+function registerCollectionCell(cell, owner) {
+	let registrations = owners.get(cell);
+	if (!registrations) {
+		registrations = /* @__PURE__ */ new Set();
+		owners.set(cell, registrations);
+	}
+	registrations.add(owner);
+}
+function unregisterCollectionCell(cell, owner) {
+	const registrations = owners.get(cell);
+	registrations?.delete(owner);
+	if (registrations?.size === 0) owners.delete(cell);
+}
+/** A shared query uses the smallest cap among its live collection readers. */
+function invalidateCollectionCell(cell) {
+	const registrations = owners.get(cell);
+	if (!registrations?.size) return false;
+	let selected;
+	for (const owner of registrations) if (!selected || owner.invalidationConcurrency < selected.invalidationConcurrency) selected = owner;
+	selected.invalidateCell(cell);
+	return true;
+}
+//#endregion
+//#region src/data/data-runtime.ts
+const dataRuntimeStates = /* @__PURE__ */ new WeakMap();
+const dataRuntimeByQueryCache = /* @__PURE__ */ new WeakMap();
+function createDataRuntimeState(queryCache, queryData) {
+	return {
+		queryCache,
+		queryData,
+		unreadPrefetches: /* @__PURE__ */ new Map(),
+		prefetches: /* @__PURE__ */ new Map(),
+		querySlotsByGeneration: /* @__PURE__ */ new WeakMap(),
+		mutationSlotsByGeneration: /* @__PURE__ */ new WeakMap(),
+		queryCleanupRegistered: /* @__PURE__ */ new WeakSet(),
+		mutationCleanupRegistered: /* @__PURE__ */ new WeakSet(),
+		queryTestOverrides: /* @__PURE__ */ new Map(),
+		mutationTestOverrides: /* @__PURE__ */ new Map()
+	};
+}
+/** Create a new, isolated {@link DataRuntime} with its own query/mutation caches. */
+function createDataRuntime(options = {}) {
+	const runtime = Object.freeze({
+		queryCache: options.queryCache ?? /* @__PURE__ */ new Map(),
+		queryData: options.queryData ?? /* @__PURE__ */ new Map()
+	});
+	dataRuntimeStates.set(runtime, createDataRuntimeState(runtime.queryCache, runtime.queryData));
+	dataRuntimeByQueryCache.set(runtime.queryCache, runtime);
+	return runtime;
+}
+const defaultDataRuntime = createDataRuntime();
+/** Get the process-wide default {@link DataRuntime} used when none is provided explicitly. */
+function getDefaultDataRuntime() {
+	return defaultDataRuntime;
+}
+function getDataRuntimeState(runtime) {
+	const state = dataRuntimeStates.get(runtime);
+	if (!state) throw new Error("[Askr] data runtime was not created by createDataRuntime().");
+	return state;
+}
+function isDataRuntime(value) {
+	return typeof value === "object" && value !== null && dataRuntimeStates.has(value);
+}
+function getDataRuntimeForQueryCache(queryCache) {
+	let runtime = dataRuntimeByQueryCache.get(queryCache);
+	if (!runtime) {
+		runtime = createDataRuntime({ queryCache });
+		dataRuntimeByQueryCache.set(queryCache, runtime);
+	}
+	return runtime;
+}
+function getActiveDataRuntime() {
+	const ctx = getActiveRenderContext();
+	if (isDataRuntime(ctx?.dataRuntime)) return ctx.dataRuntime;
+	if (ctx?.queryCache) return getDataRuntimeForQueryCache(ctx.queryCache);
+	const appRuntime = currentAppRuntime();
+	if (appRuntime?.dataRuntime) return appRuntime.dataRuntime;
+	return defaultDataRuntime;
+}
+function getActiveDataRuntimeState() {
+	return getDataRuntimeState(getActiveDataRuntime());
+}
+function resolveDataRuntimeState(runtime) {
+	return runtime ? getDataRuntimeState(runtime) : getActiveDataRuntimeState();
+}
+/** State for a runtime from createDataRuntime(); undefined for hand-built ones. */
+function findDataRuntimeState(runtime) {
+	return dataRuntimeStates.get(runtime);
+}
+/**
+* Read hydrated or prefetched data for a new query cell. Client readers
+* consume it: the cell owns the value from then on, so keeping the entry would
+* revive it as fresh after the cell is gone.
+*/
+function readQueryData(runtimeState, key, consume) {
+	const value = runtimeState.queryData.get(key);
+	if (consume) {
+		runtimeState.queryData.delete(key);
+		runtimeState.unreadPrefetches.delete(key);
+	}
+	return value;
+}
+/**
+* Store browser-prefetched data. Unread entries are capped: the oldest one is
+* evicted once more than {@link PREFETCHED_QUERY_DATA_LIMIT} are waiting.
+* Entries replaced or removed through `queryData` directly are no longer
+* tracked and are never evicted by the cap.
+*/
+function writePrefetchedQueryData(runtimeState, key, value) {
+	const { queryData, unreadPrefetches } = runtimeState;
+	queryData.set(key, value);
+	unreadPrefetches.delete(key);
+	unreadPrefetches.set(key, value);
+	for (const [oldestKey, oldestValue] of unreadPrefetches) {
+		if (unreadPrefetches.size <= 50) return;
+		unreadPrefetches.delete(oldestKey);
+		if (queryData.get(oldestKey) === oldestValue) queryData.delete(oldestKey);
+	}
+}
+/** Run `fn` for every entry even when some throw; rethrow the failures. */
+function drain(entries, fn) {
+	const errors = [];
+	for (const entry of Array.from(entries)) try {
+		fn(entry);
+	} catch (error) {
+		errors.push(error);
+	}
+	if (errors.length === 1) throw errors[0];
+	if (errors.length > 1) throw new AggregateError(errors, "Data cleanup failed");
+}
+function getQuerySlotStore(runtimeState, instance) {
+	const generation = instance;
+	let store = runtimeState.querySlotsByGeneration.get(generation);
+	if (!store) {
+		store = /* @__PURE__ */ new Map();
+		runtimeState.querySlotsByGeneration.set(generation, store);
+	}
+	return store;
+}
+function getMutationSlotStore(runtimeState, instance) {
+	const generation = instance;
+	let store = runtimeState.mutationSlotsByGeneration.get(generation);
+	if (!store) {
+		store = /* @__PURE__ */ new Map();
+		runtimeState.mutationSlotsByGeneration.set(generation, store);
+	}
+	return store;
+}
+function ensureQueryCleanup(runtimeState, instance) {
+	const generation = instance;
+	if (runtimeState.queryCleanupRegistered.has(generation)) return;
+	runtimeState.queryCleanupRegistered.add(generation);
+	const slots = getQuerySlotStore(runtimeState, instance);
+	instance.onCleanup(() => {
+		try {
+			drain(slots, ([hookIndex, slot]) => slot.cell.detach(generation, hookIndex));
+		} finally {
+			slots.clear();
+			runtimeState.querySlotsByGeneration.delete(generation);
+			runtimeState.queryCleanupRegistered.delete(generation);
+		}
+	});
+}
+function ensureMutationCleanup(runtimeState, instance) {
+	const generation = instance;
+	if (runtimeState.mutationCleanupRegistered.has(generation)) return;
+	runtimeState.mutationCleanupRegistered.add(generation);
+	const slots = getMutationSlotStore(runtimeState, instance);
+	instance.onCleanup(() => {
+		try {
+			drain(slots.values(), (slot) => slot.cell.abort());
+		} finally {
+			slots.clear();
+			runtimeState.mutationSlotsByGeneration.delete(generation);
+			runtimeState.mutationCleanupRegistered.delete(generation);
+		}
+	});
+}
+/**
+* Whether `key` falls under the invalidation `prefix`, matching whole
+* `:`-delimited segments: `user:1` covers `user:1` and `user:1:posts` but not
+* `user:10`. A prefix that already ends in `:` (every `queryScope()` prefix
+* does) covers everything below it, and the empty prefix covers every key.
+*/
+function matchesInvalidationPrefix(key, prefix) {
+	return key.startsWith(prefix) && (key.length === prefix.length || prefix.length === 0 || prefix.endsWith(":") || key[prefix.length] === ":");
+}
+function invalidateQueriesForRuntime(runtimeState, prefix, markPendingWrite) {
+	if (hasInvalidationListeners()) emitInvalidation({
+		prefix,
+		markPendingWrite
+	});
+	for (const [key, prefetch] of runtimeState.prefetches) if (matchesInvalidationPrefix(key, prefix)) {
+		prefetch.invalidated = true;
+		runtimeState.prefetches.delete(key);
+	}
+	for (const key of runtimeState.queryData.keys()) if (matchesInvalidationPrefix(key, prefix)) {
+		runtimeState.queryData.delete(key);
+		runtimeState.unreadPrefetches.delete(key);
+	}
+	const cache = runtimeState.queryCache;
+	for (const [key, query] of cache) {
+		if (!matchesInvalidationPrefix(key, prefix)) continue;
+		if (markPendingWrite) query.markPendingWrite();
+		if (!invalidateCollectionCell(query)) query.invalidate();
+	}
+}
+//#endregion
+export { getDefaultDataRuntime as a, invalidateQueriesForRuntime as c, writePrefetchedQueryData as d, invalidateCollectionCell as f, addInvalidationListener as h, findDataRuntimeState as i, readQueryData as l, unregisterCollectionCell as m, ensureMutationCleanup as n, getMutationSlotStore as o, registerCollectionCell as p, ensureQueryCleanup as r, getQuerySlotStore as s, createDataRuntime as t, resolveDataRuntimeState as u };

package/dist/{deferred-CbgNhf67.js → deferred-bEEHHvic.js}

@@ -1,10 +1,9 @@
-import { d as getCurrentAppRenderRuntime, f as getCurrentComponentInstance } from "./scope-Cq_iYbTR.js";
-import { i as getExecutionModel } from "./manifest-D1P3UNWV.js";
-import { n as getActiveRenderContext, r as getCurrentRenderData } from "./render-context-B7ohlh6t.js";
-import { t as resource } from "./resource-18-sFRl9.js";
-import { S as isDeferred, b as DEFERRED_BOUNDARY, g as guardHydratedRouteData, l as createRouteHandler } from "./resolution-3DskUkjG.js";
-import { C as getCurrentInheritedMeta, D as getCurrentPageScope, E as getCurrentPageChain, H as computeRank, I as insertRecordSorted, O as getCurrentPathPrefix, P as hasActivePageScope, R as pushRegistrationScope, S as getCurrentInheritedAuthRequirements, T as getCurrentLayoutChain, U as normalizeRouteSegmentName, W as parseSegments, g as assertRouteRegistrationUnlocked, h as addRouteToStores, j as getDefaultRouteBasePath, k as getCurrentScopeKind, w as getCurrentInheritedPolicies } from "./route-matching-CUzZ31gT.js";
-import { allOf } from "@askrjs/auth";
+import { i as currentComponent, r as currentAppRuntime } from "./hooks-BimKStr4.js";
+import { c as registerDeferredBoundary, n as getActiveRenderContext, r as getCurrentRenderData } from "./render-context-DGHnEveC.js";
+import { d as DEFERRED_BOUNDARY, p as isDeferred } from "./query-registry-WMCN0BJL.js";
+import { B as getCurrentPathPrefix, F as getCurrentInheritedMeta, G as getRouteRecords, I as getCurrentInheritedPolicies, J as insertRecordSorted, K as hasActivePageScope, L as getCurrentLayoutChain, O as addRouteToStores, P as getCurrentInheritedAuthRequirements, R as getCurrentPageChain, U as getDefaultRouteBasePath, V as getCurrentScopeKind, X as pushRegistrationScope, dt as routeMatchKey, k as assertRouteRegistrationUnlocked, lt as normalizeRouteSegmentName, pt as guardHydratedRouteData, st as computeRank, tt as createRouteHandler, ut as parseSegments, z as getCurrentPageScope } from "./resolution-Cx82-xjW.js";
+import { i as getExecutionModel } from "./manifest-CW9gyNBY.js";
+import { t as resource } from "./resource-CLjB7RBQ.js";
 //#region src/router/access.ts
 function compileNodePolicies(node) {
 	return node.policies ? [...node.policies] : [];
@@ -43,7 +42,11 @@ function normalizeAbsoluteRoutePath(path) {
 }
 function joinRoutePaths(prefix, path) {
 	const normalizedPrefix = normalizeAbsoluteRoutePath(prefix || "/");
-	const normalizedPath = path.replace(/^\/+|\/+$/g, "");
+	let start = 0;
+	let end = path.length;
+	while (start < end && path[start] === "/") start++;
+	while (end > start && path[end - 1] === "/") end--;
+	const normalizedPath = path.slice(start, end);
 	if (!normalizedPath) return normalizedPrefix;
 	return normalizedPrefix === "/" ? `/${normalizedPath}` : `${normalizedPrefix}/${normalizedPath}`;
 }
@@ -98,12 +101,13 @@ function normalizeRouteOptions(options) {
 	const dehydrate = options.dehydrate;
 	const preload = options.preload;
 	const policies = compileNodePolicies(options);
-	if (!loader && !dehydrate && !preload && !options.entries && policies.length === 0 && !options.title && !options.namespace && !options.search && !options.meta && !options.actions && options.auth === void 0) return;
+	if (!loader && !dehydrate && !preload && !options.entries && !options.invalidationKeys && policies.length === 0 && !options.title && !options.namespace && !options.search && !options.meta && !options.actions && options.auth === void 0) return;
 	return {
 		...loader ? { loader } : {},
 		...dehydrate ? { dehydrate } : {},
 		...preload ? { preload } : {},
 		...options.entries ? { entries: options.entries } : {},
+		...options.invalidationKeys ? { invalidationKeys: options.invalidationKeys } : {},
 		...options.auth !== void 0 ? { auth: options.auth } : {},
 		...policies.length > 0 ? { policies } : {},
 		...options.title ? { title: options.title } : {},
@@ -113,18 +117,37 @@ function normalizeRouteOptions(options) {
 		...options.actions ? { actions: options.actions } : {}
 	};
 }
+function assertRouteNotDuplicated(path, segments, fallbackPrefix) {
+	const key = routeMatchKey(segments, fallbackPrefix);
+	const existing = getRouteRecords().find((record) => routeMatchKey(record.segments, record.fallbackPrefix) === key);
+	if (existing) {
+		const hint = existing.path === path ? " To generate several pages from one route template, declare it once and return each page's params from entries()." : "";
+		throw new Error(`Duplicate route path "${path}": it matches the same URLs as "${existing.path}", which is already registered.${hint}`);
+	}
+}
+const authAllowed = Object.freeze({ allowed: true });
+function requireAll(requirements) {
+	return async (context) => {
+		for (const requirement of requirements) {
+			const decision = await requirement(context);
+			if (!decision.allowed) return decision;
+		}
+		return authAllowed;
+	};
+}
 function registerRouteAtResolvedPath(path, Component, options, metadata) {
 	validateRoutePath(path);
+	const segments = parseSegments(path);
+	assertRouteNotDuplicated(path, segments, metadata?.fallbackPrefix);
 	const chain = getCurrentLayoutChain();
 	const pageChain = getCurrentPageChain();
-	const segments = parseSegments(path);
 	const rank = computeRank(segments);
 	const isFallback = metadata?.isFallback ?? path === "/*";
 	const comp = Component;
 	const normalizedOptions = normalizeRouteOptions(options);
 	const policies = [...getCurrentInheritedPolicies(), ...normalizedOptions?.policies ?? []];
 	const authRequirements = [...getCurrentInheritedAuthRequirements(), ...normalizedOptions?.auth ? [normalizedOptions.auth] : []];
-	const auth = authRequirements.length === 0 ? void 0 : authRequirements.length === 1 ? authRequirements[0] : allOf(...authRequirements);
+	const auth = authRequirements.length === 0 ? void 0 : authRequirements.length === 1 ? authRequirements[0] : requireAll(authRequirements);
 	const metaChain = [...getCurrentInheritedMeta(), ...normalizedOptions?.meta ? [normalizedOptions.meta] : []];
 	const handler = createRouteHandler(comp, pageChain, chain);
 	const renderHandler = createRouteHandler(comp, pageChain, chain, true);
@@ -192,9 +215,9 @@ function fallback(Component) {
 }
 function route(path, Component, options) {
 	if (typeof path === "undefined") throw new Error("route() is only for route registration. Use currentRoute() inside components.");
-	if (getExecutionModel() === "islands") throw new Error("Routes are not supported with islands. Use createSPA (client) or createSSR (server) instead.");
-	const currentInst = getCurrentComponentInstance();
-	if (currentInst && currentInst.ssr) throw new Error("route() cannot be called during SSR rendering. Register routes at module load time instead.");
+	if (getExecutionModel() === "islands") throw new Error("Routes are not supported with islands. Use createSPA or hydrateSPA with a route registry instead.");
+	const currentInst = currentComponent();
+	if (currentInst && currentInst.server) throw new Error("route() cannot be called during SSR rendering. Register routes at module load time instead.");
 	assertRouteRegistrationUnlocked();
 	if (typeof Component !== "function") throw new Error("route(path, Component) requires a component function as the second argument. Passing JSX elements or VNodes directly is not supported.");
 	if (options?.search && options.search.kind !== "object") throw new Error("route search must be an object schema.");
@@ -249,7 +272,7 @@ async function resolveDeferredValues(input, signal) {
 function routeData() {
 	const envelope = getCurrentRenderData();
 	if (envelope) return guardHydratedRouteData(envelope.route, envelope.framework);
-	const runtime = getCurrentAppRenderRuntime();
+	const runtime = currentAppRuntime();
 	if (!runtime?.hasRoute) throw new Error("routeData() can only be read while rendering a route with loader data.");
 	return guardHydratedRouteData(runtime.route, runtime.framework);
 }
@@ -258,13 +281,12 @@ function rejectedChild(props, error) {
 }
 /** Render a {@link Deferred} value's fulfilled state, a pending placeholder, or a rejected fallback. */
 function Resolve(props) {
+	const renderContext = getActiveRenderContext();
+	const result = renderContext ? null : resource(() => props.value.state === "pending" ? props.value.promise : null, [props.value]);
 	if (props.value.state === "fulfilled") return props.children(props.value.value);
 	if (props.value.state === "rejected") return rejectedChild(props, props.value.error);
-	const renderContext = getActiveRenderContext();
 	if (renderContext) {
-		const id = `d:${renderContext.deferredBoundaries.length}`;
-		renderContext.deferredBoundaries.push({
-			id,
+		const id = registerDeferredBoundary(renderContext, {
 			promise: props.value.promise,
 			fulfilled: (value) => props.children(value),
 			rejected: (error) => rejectedChild(props, error)
@@ -277,7 +299,7 @@ function Resolve(props) {
 			}
 		};
 	}
-	const result = resource(() => props.value.promise, [props.value]);
+	if (!result) return props.pending ?? null;
 	if (result.error) return rejectedChild(props, result.error);
 	if (result.pending || result.value === null) return props.pending ?? null;
 	return props.children(result.value);

package/dist/domains/actions.d.ts

@@ -1,7 +1,6 @@
 import { JSXElementType, JSXElement, Props } from '../elements.js';
 import '../jsx-globals.js';
-import { AuthContext, AuthRequirement } from '@askrjs/auth';
-import { InferSchema, ObjectSchema } from '@askrjs/schema';
+import { InferSchema, ObjectSchema } from '../peer-types.js';
 import { StateTuple, state } from './state.js';
 import { RenderableChild } from './context.js';
 import { on } from './lifecycle.js';
@@ -50,7 +49,13 @@ interface ActionStatus<TResult = unknown> {
   readonly error?: unknown;
 }
 
-/** Returns a command handle, rather than a hook. */
+/**
+ * Bind an action descriptor to the calling component and return its
+ * `{ state, submit }` handle. `action()` allocates its status with `state()`,
+ * so it follows the same rule: call it during component render, at the top
+ * level and in the same order on every render. `submit()` itself may be
+ * called from event handlers or other async work.
+ */
 declare function action<
   TInput extends Record<string, unknown>,
   TResult = unknown,

package/dist/domains/component.d.ts

@@ -1,84 +1,4 @@
-import { JSXElementType, JSXElement, Props } from '../elements.js';
 import '../jsx-globals.js';
-import { AuthContext, AuthRequirement } from '@askrjs/auth';
-import { InferSchema, ObjectSchema } from '@askrjs/schema';
-import { State, state } from './state.js';
-import { ComponentFunction, ContextFrame, OwnedChildScope } from './context.js';
-import { DataRuntime } from './data.js';
-import { RouteAuthOptions, RouteRegistry } from './routing.js';
-
-interface AppRenderRuntime {
-  framework: Readonly<Record<string, unknown>>;
-  route: unknown;
-  hasRoute: boolean;
-  dataRuntime?: DataRuntime;
-  routeRegistry?: RouteRegistry;
-  routeAuth?: RouteAuthOptions;
-}
-
-interface ComponentInstance {
-  id: string;
-  fn: ComponentFunction;
-  props: Props;
-  target: Element | null;
-  parentInstance: ComponentInstance | null;
-  portalScope: object | null;
-  mounted: boolean;
-  abortController: AbortController | null;
-  ssr?: boolean;
-  cleanupStrict?: boolean;
-  /** @internal Private resource-ownership identity for the active mount. */
-  _ownershipGeneration: object;
-  stateValues?: State<unknown>[];
-  evaluationGeneration: number;
-  notifyUpdate: (() => void) | null;
-  _pendingFlushTask?: () => void;
-  _pendingRunTask?: () => void;
-  _enqueueRun?: () => void;
-  stateIndexCheck: number;
-  expectedStateIndices?: number[];
-  firstRenderComplete: boolean;
-  mountOperations?: Array<
-    () => void | (() => void) | PromiseLike<void | (() => void)>
-  >;
-  commitOperations?: Array<
-    () => void | (() => void) | PromiseLike<void | (() => void)>
-  >;
-  cleanupFns?: Array<() => void>;
-  lifecycleSlots?: unknown[];
-  lifecycleGeneration: number;
-  hasPendingUpdate: boolean;
-  ownerFrame: ContextFrame | null;
-  isRoot?: boolean;
-  _rootComponentFn?: ComponentFunction;
-  /** @internal Browser-owned hydration and route state for this app root. */
-  _appRenderRuntime?: AppRenderRuntime;
-  /** @internal CSP nonce retained across browser route navigation. */
-  _cspNonce?: string;
-  _vnodeOwner?: object;
-  _vnodeParent?: ComponentInstance | null;
-  _vnodeParentGeneration?: object;
-  _vnodeKey?: string | number;
-  _vnodePosition?: number;
-  _wrapperDepth?: number;
-  _currentRenderToken?: number;
-  lastRenderToken?: number;
-  _pendingReadSources?: Set<ReadableSource<unknown>>;
-  _pendingReadSourceVersions?: Map<ReadableSource<unknown>, number>;
-  _lastReadSources?: Set<ReadableSource<unknown>>;
-  devWarningsEmitted?: Set<string>;
-  _placeholder?: Comment;
-  _ownedChildScopes?: Set<OwnedChildScope>;
-  errorBoundaryState?: {
-    error: unknown | null;
-    resetKey: unknown;
-    notified: boolean;
-  };
-  /** @internal Logical error ancestry for content materialized by a portal host. */
-  _portalErrorParent?: ComponentInstance | null;
-  /** @internal Ownership identity paired with `_portalErrorParent`. */
-  _portalErrorParentGeneration?: object;
-}
 
 /**
  * Get the abort signal for the current component.
@@ -90,30 +10,4 @@ interface ComponentInstance {
  */
 declare function getSignal(): AbortSignal;
 
-interface DerivedSubscriber {
-  _markDirty(): void;
-  _pendingDependencySources?: Set<ReadableSource<unknown>>;
-}
-
-interface ReadableSource<T = unknown> {
-  (): T;
-  _hasBeenRead?: boolean;
-  _hasEverBeenRead?: boolean;
-  _unusedStateDiagnosticEligible?: boolean;
-  _readers?: Map<
-    ComponentInstance,
-    {
-      token: number;
-      generation: object;
-    }
-  >;
-  _derivedSubscribers?: Set<DerivedSubscriber>;
-  _version?: number;
-}
-export {
-  AppRenderRuntime,
-  ComponentInstance,
-  getSignal,
-  DerivedSubscriber,
-  ReadableSource,
-};
+export { getSignal };

package/dist/domains/context.d.ts

@@ -1,9 +1,6 @@
 import { JSXElementType, JSXElement, Props } from '../elements.js';
 import '../jsx-globals.js';
-import { AuthContext, AuthRequirement } from '@askrjs/auth';
-import { InferSchema, ObjectSchema } from '@askrjs/schema';
 import { SSRContext } from './server.js';
-import { ControlBoundaryState } from './control.js';
 
 interface DOMElement {
   type: JSXElementType;
@@ -11,7 +8,6 @@ interface DOMElement {
   children?: VNode[];
   key?: string | number | null;
   [Symbol.iterator]?: never;
-  _controlState?: ControlBoundaryState;
 }
 
 type VNode = DOMElement | string | number | boolean | null | undefined;
@@ -41,21 +37,12 @@ interface Scope<T> {
   readonly defaultValue: T;
 }
 
-interface ContextFrame {
-  parent: ContextFrame | null;
-  values: Map<ContextKey, unknown> | null;
-}
-
 /** Create a new lexical {@link Scope} with `defaultValue`, readable via {@link readScope}. */
 declare function defineScope<T>(defaultValue: T): Scope<T>;
 
 /** Read the current value of a {@link Scope} during component render or an async resource. */
 declare function readScope<T>(context: Scope<T>): T;
 
-type OwnedChildScope = {
-  key: string | number;
-  dispose(): void;
-};
 export {
   DOMElement,
   VNode,
@@ -66,8 +53,6 @@ export {
   Renderable,
   ContextScopeChildren,
   Scope,
-  ContextFrame,
   defineScope,
   readScope,
-  OwnedChildScope,
 };