@askrjs/askr 0.3.0 → 0.4.0

package/dist/domains/control.d.ts

@@ -1,226 +1,21 @@
-import { JSXElementType, JSXElement, Props } from '../elements.js';
+import { JSXElement, Props } from '../elements.js';
 import '../jsx-globals.js';
-import { AuthContext, AuthRequirement } from '@askrjs/auth';
-import { InferSchema, ObjectSchema } from '@askrjs/schema';
 import { state, selector } from './state.js';
-import { VNode, RenderableChild, ContextFrame } from './context.js';
-import { ComponentInstance, ReadableSource } from './component.js';
-import {
-  DOMRange,
-  ChildScope,
-  ChildScopeOwnership,
-  ChildScopeTransactionSnapshot,
-} from './renderer.js';
+import { VNode, RenderableChild } from './context.js';
 import { on } from './lifecycle.js';
 
-type ForItemSignal<T> = ReadableSource<T> &
-  (() => T) & {
-    peek(): T;
-    set(newValue: T, notifyReaders?: boolean): void;
-  };
+/** A list, or a getter returning one (`null`/`undefined` render nothing). */
+type ForEachSource<T> = ForEachGetter<T> | ForEachList<T>;
 
-type ForItemPropertySignal = ReadableSource<unknown> &
-  (() => unknown) & {
-    peek(): unknown;
-    set(newValue: unknown, notifyReaders?: boolean): void;
-  };
+type ForEachGetter<T> = () => readonly T[] | null | undefined;
 
-type ForIndexSignal = ReadableSource<number> &
-  (() => number) & {
-    peek(): number;
-    set(
-      newValue: number | ((prev: number) => number),
-      notifyReaders?: boolean
-    ): void;
-  };
+/** A list that is not also callable: a `state()` getter is both. */
+type ForEachList<T> = readonly T[] & { readonly call?: never };
 
-interface ReactiveForItemState<T> {
-  currentItem: T;
-  itemSignal: ForItemSignal<T> | null;
-  propertySignals: Map<PropertyKey, ForItemPropertySignal> | null;
-  coalescedProperties: PropertyKey | PropertyKey[] | null;
-  coalescedProperty2: PropertyKey | null;
-  wholeItemRead: boolean;
-  proxy: T;
-}
-
-interface ForItemInstance<T> {
-  key: string | number;
-  item: T;
-  reactiveItem: T;
-  reactiveItemState: ReactiveForItemState<T> | null;
-  indexSignal: ForIndexSignal;
-  scope: ChildScope;
-}
-
-interface FineGrainedEffectHandle<T> {
-  cleanup(): void;
-  updateCompute(nextCompute: () => T): void;
-  flush(): void;
-}
-
-type ForEachSource<T> = readonly T[] | (() => readonly T[]);
-
-type ForKeySelector<T> = (item: T, index: number) => string | number;
-
-type ForRenderItem<T> = (item: T, index: () => number) => VNode;
-
-type ForCommitStrategy =
-  | 'APPEND'
-  | 'INSERT_ONE'
-  | 'REMOVE_ONE'
-  | 'TRUNCATE'
-  | 'NO_REORDER'
-  | 'SWAP'
-  | 'FULL_KEYED';
-
-interface ForState<T> {
-  kind: 'for';
-  _contextFrame: ContextFrame | null;
-  _contextFrameChanged: boolean;
-  currentItems: readonly T[];
-  _committedItems: readonly T[];
-  eachSource: ForEachSource<T>;
-  fallback: VNode | null;
-  fallbackScope: ChildScope | null;
-  items: Map<string | number, ForItemInstance<T>>;
-  orderedKeys: Array<string | number>;
-  orderedItems: ForItemInstance<T>[];
-  orderedVNodes: VNode[];
-  byFn: ForKeySelector<T>;
-  renderFn: ForRenderItem<T>;
-  parentInstance: ComponentInstance | null;
-  lastCommitStrategy: ForCommitStrategy;
-  lastRemovedNodes: Node[];
-  lastRemovedRanges: DOMRange[];
-  pendingDirtyIndices: number[] | null;
-  pendingSwapIndices: [number, number] | null;
-  pendingMoveOnly: boolean;
-  pendingInsertedIndex: number | null;
-  pendingRemovedKey: string | number | null;
-  pendingAppendStart: number | null;
-  _hasResolvedItemDom: boolean;
-  _needsSourceReconcile: boolean;
-  _sourceEffect: FineGrainedEffectHandle<readonly T[]> | null;
-  _suspendSourceCommit: boolean;
-  _enqueueBoundaryCommit?: (() => void) | null;
-  _hasPendingBoundaryCommit?: boolean;
-  devKeyKinds?: Map<string | number, 'number' | 'string'>;
-  _transaction?: ForTransaction<T> | null;
-  _scopeOwnership: ChildScopeOwnership;
-}
-
-interface ForItemTransactionSnapshot<T> {
-  item: T;
-  itemSignalExists: boolean;
-  itemSignalValue: T | undefined;
-  itemSignalHasBeenRead: boolean;
-  indexValue: number;
-  indexHasBeenRead: boolean;
-  propertySignalStore: Map<PropertyKey, ForItemPropertySignal> | null;
-  propertySignals: Map<
-    PropertyKey,
-    {
-      signal: ForItemPropertySignal;
-      value: unknown;
-      hasBeenRead: boolean;
-    }
-  > | null;
-  scope: ChildScopeTransactionSnapshot;
-}
-
-interface ForTransaction<T> {
-  collectionSnapshotMode: 'copy' | 'reset-empty' | 'preserve-clear' | 'reuse';
-  currentItems: readonly T[];
-  items: Map<string | number, ForItemInstance<T>>;
-  orderedKeys: Array<string | number>;
-  orderedItems: ForItemInstance<T>[];
-  orderedVNodes: VNode[];
-  fallbackScope: ChildScope | null;
-  lastCommitStrategy: ForCommitStrategy;
-  lastRemovedNodes: Node[];
-  lastRemovedRanges: DOMRange[];
-  pendingDirtyIndices: number[] | null;
-  pendingSwapIndices: [number, number] | null;
-  pendingMoveOnly: boolean;
-  pendingInsertedIndex: number | null;
-  pendingRemovedKey: string | number | null;
-  pendingAppendStart: number | null;
-  hasResolvedItemDom: boolean;
-  needsSourceReconcile: boolean;
-  devKeyKinds?: Map<string | number, 'number' | 'string'>;
-  itemSnapshots: Map<ForItemInstance<T>, ForItemTransactionSnapshot<T>> | null;
-  unreadIndexSnapshots: Map<ForIndexSignal, number> | null;
-  fallbackScopeSnapshot: ChildScopeTransactionSnapshot | null;
-  removedScopes: ChildScope[] | null;
-  removedScopeNodes: Node[] | null;
-  removeAllItems: boolean;
-  signalEffects: Map<
-    ReadableSource<unknown>,
-    {
-      parentInstance: ComponentInstance | null;
-      notify: boolean;
-      skipInstance: ComponentInstance | null;
-      skipOwnedBy: ComponentInstance | null;
-    }
-  > | null;
-  shouldClearDomUpdateState: boolean;
-}
-
-interface MatchBranch {
-  key: string | number;
-  render: () => VNode;
-  when: unknown;
-}
-
-interface BranchControlStateBase {
-  _contextFrame: ContextFrame | null;
-  activeKey: string | number | null;
-  activeScope: ChildScope | null;
-  activeVNodes: VNode[];
-  lastRemovedNodes: Node[];
-  lastRemovedRanges: DOMRange[];
-  parentInstance: ComponentInstance | null;
-  _enqueueBoundaryCommit?: (() => void) | null;
-  _hasPendingBoundaryCommit?: boolean;
-  _transaction?: ControlTransaction | null;
-}
-
-interface ShowState extends BranchControlStateBase {
-  kind: 'show';
-  fallbackScope: ChildScope | null;
-  renderFallback: (() => VNode) | null;
-  renderTruthy: ((value: unknown) => VNode) | (() => VNode);
-  selectedValue: unknown;
-  truthyScope: ChildScope | null;
-}
-
-interface CaseState extends BranchControlStateBase {
-  kind: 'case';
-  fallback: (() => VNode) | null;
-  matches: MatchBranch[];
-}
-
-type ControlBoundaryState = ForState<unknown> | ShowState | CaseState;
-
-type BranchStateSnapshot = {
-  activeKey: string | number | null;
-  activeScope: ChildScope | null;
-  activeVNodes: VNode[];
-  lastRemovedNodes: Node[];
-  lastRemovedRanges: DOMRange[];
-  scopeSnapshots: Map<ChildScope, ChildScopeTransactionSnapshot>;
-  fallbackScope?: ChildScope | null;
-  truthyScope?: ChildScope | null;
-};
-
-interface ControlTransaction {
-  state: ShowState | CaseState;
-  snapshot: BranchStateSnapshot;
-  removedScopes: ChildScope[];
-  shouldClearDomUpdateState: boolean;
-  registered: boolean;
-}
+/** How rows are identified: by a key function, or by position. */
+type ForKeying<T, K extends string | number> =
+  | { by: (item: T, index: number) => K; byIndex?: never }
+  | { by?: never; byIndex: true };
 
 type BoundaryChild = RenderableChild;
 
@@ -228,32 +23,42 @@ type ForBaseProps<T> = {
   each: ForEachSource<T>;
   fallback?: BoundaryChild;
   /**
-   * Row renderer. Parent reactive reads must use `selector()` or thunk props;
-   * closure-captured values are snapshotted when the row is created or
-   * reconciled; changing the parent source does not rerun an existing row.
+   * Row renderer. Existing rows rerun with the latest callback when the parent
+   * rerenders, and a reactive read in the callback subscribes that row. Prefer
+   * `selector()` or thunk props so only the affected rows or props update.
    */
   children: (item: T, index: () => number) => VNode;
 };
 
-type KeyedForProps<T, K extends string | number> = ForBaseProps<T> & {
-  by: (item: T, index: number) => K;
-  byIndex?: never;
-};
+type KeyedForProps<T, K extends string | number> = ForBaseProps<T> &
+  Extract<ForKeying<T, K>, { byIndex?: never }>;
 
-type IndexedForProps<T> = ForBaseProps<T> & {
-  by?: never;
-  byIndex: true;
-};
+type IndexedForProps<T> = ForBaseProps<T> &
+  Extract<ForKeying<T, string | number>, { byIndex: true }>;
 
 /** Props for {@link For}. */
 type ForProps<T, K extends string | number = string | number> =
   | KeyedForProps<T, K>
   | IndexedForProps<T>;
 
+/**
+ * {@link ForProps} with a getter `each`. A `state()` getter is also an array
+ * (`[getter, setter]`), so `For` tries this form first and reads it as a getter.
+ */
+type ForGetterProps<T, K extends string | number = string | number> = Omit<
+  ForBaseProps<T>,
+  'each'
+> & { each: ForEachGetter<T> } & ForKeying<T, K>;
+
 /** Render a keyed or indexed list, reconciling items by key instead of position. */
-declare const For: <T, K extends string | number = string | number>(
-  props: ForProps<T, K>
-) => JSXElement;
+declare const For: {
+  <T, K extends string | number = string | number>(
+    props: ForGetterProps<T, K>
+  ): JSXElement;
+  <T, K extends string | number = string | number>(
+    props: ForProps<T, K>
+  ): JSXElement;
+};
 
 type ShowSource<T> = T | (() => T);
 
@@ -290,26 +95,8 @@ declare function Match(_props: MatchProps): null;
 /** Render the first matching {@link Match} child (by `when`), or `fallback` if none match. */
 declare const Case: (props: CaseProps) => JSXElement;
 export {
-  ForItemSignal,
-  ForItemPropertySignal,
-  ForIndexSignal,
-  ReactiveForItemState,
-  ForItemInstance,
-  FineGrainedEffectHandle,
   ForEachSource,
-  ForKeySelector,
-  ForRenderItem,
-  ForCommitStrategy,
-  ForState,
-  ForItemTransactionSnapshot,
-  ForTransaction,
-  MatchBranch,
-  BranchControlStateBase,
-  ShowState,
-  CaseState,
-  ControlBoundaryState,
-  BranchStateSnapshot,
-  ControlTransaction,
+  ForGetterProps,
   BoundaryChild,
   ForBaseProps,
   KeyedForProps,

package/dist/domains/data.d.ts

@@ -1,7 +1,5 @@
 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 } from './state.js';
 import { CoreTelemetry } from './telemetry.js';
 import { on } from './lifecycle.js';
@@ -17,25 +15,20 @@ type QueryStaleReason = 'aborted' | 'error' | 'inconsistent';
 interface DataRuntime {
   readonly queryCache: Map<string, unknown>;
   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>;
 }
 
 /** Options for {@link createDataRuntime}. */
 interface DataRuntimeOptions {
   queryCache?: Map<string, unknown>;
   queryData?: Map<string, unknown>;
-  queryTestOverrides?: Map<string, unknown>;
-  mutationTestOverrides?: Map<string, unknown>;
 }
 
 /** Reusable query definition for {@link defineQuery}: key, fetcher, and freshness checks. */
 interface QueryDefinition<TInput, TResult extends {}> {
   readonly key: (input: TInput) => string;
   readonly fetch: (
-    context: TInput & {
+    input: TInput,
+    context: {
       signal: AbortSignal;
     }
   ) => Promise<TResult>;
@@ -279,6 +272,8 @@ type QueryOptions<T> = {
   runtime?: DataRuntime;
   initialData?: T;
   skipInitialFetch?: boolean;
+  /** Cache lifetime in milliseconds. Defaults to 0 after component unmount and five minutes for ownerless client queries. */
+  gcTime?: number;
 };
 
 /** Options for {@link createMutation}. */
@@ -291,6 +286,15 @@ type MutationOptions<TInput, TResult> = {
       signal: AbortSignal;
     }
   ) => Promise<TResult>;
+  /** Apply a synchronous optimistic change. Return a rollback for failure or abort. */
+  optimistic?: (
+    input: TInput,
+    ctx: { signal: AbortSignal }
+  ) => void | (() => void);
+  /**
+   * Query prefixes to invalidate after success, matched by `:`-delimited
+   * segment the same way as {@link invalidate}.
+   */
   affects?: (input: TInput, result: TResult) => string[];
   afterSuccess?: 'invalidate';
   runtime?: DataRuntime;
@@ -324,15 +328,25 @@ declare function createDataRuntime(options?: DataRuntimeOptions): DataRuntime;
 /** Get the process-wide default {@link DataRuntime} used when none is provided explicitly. */
 declare function getDefaultDataRuntime(): DataRuntime;
 
-/** Mark all cached queries whose key starts with `prefix` as stale, triggering a refresh. */
+/**
+ * Mark all cached queries under `prefix` as stale, triggering a refresh.
+ * Matching is by `:`-delimited segment: a key matches when it equals `prefix`,
+ * when `prefix` ends in `:`, or when the key continues `prefix` at a `:`
+ * (`'user:1'` matches `user:1:posts` but not `user:10`). Only `:` is a
+ * segment boundary; the empty prefix matches every key.
+ */
 declare function invalidate(prefix: string, options?: InvalidateOptions): void;
 
-/** Create a {@link QueryScope} that namespaces keys and invalidations under `namespace`. */
-declare function queryScope(namespace: string): QueryScope;
+/** Create a {@link QueryScope} that namespaces keys and can bind invalidations to a runtime. */
+declare function queryScope(
+  namespace: string,
+  options?: Pick<InvalidateOptions, 'runtime'>
+): QueryScope;
 
 /**
  * Periodically invalidate queries matching `prefix` on a fixed interval,
  * optionally gated by active route, document visibility, or window focus.
+ * `prefix` matches key segments the same way as {@link invalidate}.
  */
 declare function invalidateOnInterval(
   prefix: string,
@@ -401,7 +415,11 @@ declare function prefetchQuery<TInput, TResult extends {}>(
   input: TInput
 ): Promise<boolean>;
 
-/** Extract a runtime's cached query data into a JSON-serializable snapshot, dropping non-serializable values. */
+/**
+ * Extract a runtime's cached query data into a JSON-serializable snapshot.
+ * Throws a `TypeError` naming the key and path of any value that would not
+ * survive JSON transport unchanged (for example a `Date`, `Map`, or bigint).
+ */
 declare function dehydrateDataRuntime(
   runtime: DataRuntime
 ): Record<string, unknown>;

package/dist/domains/diagnostics.d.ts

@@ -1,8 +1,7 @@
 import { JSXElementType, JSXElement, Props } from '../elements.js';
 import '../jsx-globals.js';
-import { AuthContext, AuthRequirement } from '@askrjs/auth';
-import { InferSchema, ObjectSchema } from '@askrjs/schema';
 
+/** Options for {@link configureRenderDiagnostics}. */
 interface RenderDiagnosticsOptions {
   /** Emit one warning per component instance when a render exceeds the threshold. */
   slowRenderWarnings?: boolean;

package/dist/domains/lifecycle.d.ts

@@ -1,8 +1,5 @@
 import { JSXElementType, JSXElement, Props } from '../elements.js';
 import '../jsx-globals.js';
-import { AuthContext, AuthRequirement } from '@askrjs/auth';
-import { InferSchema, ObjectSchema } from '@askrjs/schema';
-import { ReadableSource } from './component.js';
 
 /** A gating condition for lifecycle primitives like {@link timer}; `true` means active. */
 type ActivityPredicate = () => boolean;
@@ -49,7 +46,7 @@ declare function task(
 ): void;
 
 /** A callable reactive source accepted by {@link watch}. */
-type WatchSource<T> = ReadableSource<T>;
+type WatchSource<T> = () => T;
 
 /** Values inferred from an ordered tuple of {@link WatchSource} accessors. */
 type WatchValues<TSources extends readonly WatchSource<unknown>[]> = {
@@ -77,7 +74,7 @@ declare function watch<TValue>(
 
 /** Observe an ordered tuple of readable sources after commit and whenever an entry changes. */
 declare function watch<const TSources extends readonly WatchSource<unknown>[]>(
-  sources: TSources,
+  sources: TSources extends WatchSource<unknown> ? never : TSources,
   callback: WatchCallback<WatchValues<TSources>>
 ): void;
 

package/dist/domains/refs.d.ts

@@ -1,7 +1,5 @@
 import { JSXElementType, JSXElement, Props } from '../elements.js';
 import '../jsx-globals.js';
-import { AuthContext, AuthRequirement } from '@askrjs/auth';
-import { InferSchema, ObjectSchema } from '@askrjs/schema';
 
 /**
  * Creates a stable holder for an intrinsic element ref.

package/dist/domains/routing.d.ts

@@ -1,7 +1,11 @@
 import { JSXElementType, JSXElement, Props } from '../elements.js';
 import '../jsx-globals.js';
-import { AuthContext, AuthRequirement } from '@askrjs/auth';
-import { InferSchema, ObjectSchema } from '@askrjs/schema';
+import {
+  AuthContext,
+  AuthRequirement,
+  InferSchema,
+  ObjectSchema,
+} from '../peer-types.js';
 import { state, selector } from './state.js';
 import { RenderableChild } from './context.js';
 import { QueryPrefetchContext } from './data.js';
@@ -133,13 +137,34 @@ type RouteAuthResolver = (
 
 /** Auth configuration shared across a route registry or a single route. */
 interface RouteAuthOptions {
-  resolve: RouteAuthResolver;
+  /**
+   * Resolve the identity for a request. When omitted, requests are anonymous
+   * unless the caller supplies an identity (for example `authContext` on the
+   * server, or an opted-in hydration snapshot for the initial client route).
+   */
+  resolve?: RouteAuthResolver;
+  /**
+   * Opt in to sending a minimal identity snapshot to the browser for
+   * hydration. Called on the server with the identity that authorized the
+   * page. `authenticated`, `principal`, `tenant`, and `scopes` of the result
+   * are serialized verbatim into the page, so return only what the client
+   * needs; the session is never sent. The client uses the snapshot to resolve
+   * the initial route and, without `resolve`, as its identity for
+   * navigations. Nothing crosses without this hook.
+   */
+  dehydrate?: (context: AuthContext) => Omit<AuthContext, 'session'>;
   loginPath?:
     | string
-    | ((context: RouteContext) => string | PromiseLike<string>);
+    | RouteDestination
+    | ((
+        context: RouteContext
+      ) => string | RouteDestination | PromiseLike<string | RouteDestination>);
   authenticatedRedirectTo?:
     | string
-    | ((context: RouteContext) => string | PromiseLike<string>);
+    | RouteDestination
+    | ((
+        context: RouteContext
+      ) => string | RouteDestination | PromiseLike<string | RouteDestination>);
 }
 
 interface CommonAccessOptions {
@@ -246,14 +271,24 @@ interface RouteRef<
   readonly __search?: TSearch;
 }
 
-type RouteRefSearch<TSchema extends ObjectSchema<RouteSearch> | undefined> =
-  TSchema extends ObjectSchema<RouteSearch>
+type RouteRefSearch<TSchema extends ObjectSchema<RouteSearch> | undefined> = [
+  TSchema,
+] extends [undefined]
+  ? RouteSearch
+  : TSchema extends ObjectSchema<RouteSearch>
     ? InferSchema<TSchema>
     : RouteSearch;
 
-/** A resolved navigation target with a computed `href`, produced by {@link to}. */
+declare const routeDestinationBrand: unique symbol;
+
+/**
+ * A typed navigation target with a computed public `href`, produced by
+ * {@link to}. Branded so that only `to()` creates one: its `href` already
+ * includes the registry `basePath` and is never prefixed again.
+ */
 interface RouteDestination {
   readonly href: string;
+  readonly [routeDestinationBrand]: true;
 }
 
 /** Options accepted by the `page()` route-declaration helper. */

package/dist/domains/scheduler.d.ts

@@ -1,79 +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 { task } from './lifecycle.js';
-
-/**
- * Serialized update scheduler — safer design (no inline execution, explicit flush)
- *
- * Key ideas:
- * - Never execute a task inline from `enqueue`.
- * - `flush()` is explicit and non-reentrant.
- * - `runWithSyncProgress()` allows enqueues temporarily but does not run tasks
- *   inline; it runs `fn` and then does an explicit `flush()`.
- * - `waitForFlush()` is race-free with a monotonic `flushVersion`.
- */
-type Task = () => void;
-
-type SchedulerLane = 'derived' | 'component' | 'reactive' | 'post';
-
-type SchedulerBulkCommitProbe = () => boolean;
-
-declare class Scheduler {
-  private bulkCommitProbe;
-  private lanes;
-  private running;
-  private inHandler;
-  private depth;
-  private executionDepth;
-  private flushVersion;
-  private kickScheduled;
-  private allowSyncProgress;
-  private waiters;
-  private taskCount;
-  setBulkCommitProbe(probe: SchedulerBulkCommitProbe): void;
-  private isBulkCommitActive;
-  private hasPendingTasks;
-  private getPendingTaskCount;
-  private compactLane;
-  private scheduleFlushKick;
-  enqueue(task: Task): void;
-  enqueueInLane(lane: SchedulerLane, task: Task): void;
-  flush(): void;
-  runWithSyncProgress<T>(fn: () => T): T;
-  waitForFlush(targetVersion?: number, timeoutMs?: number): Promise<void>;
-  getState(): {
-    queueLength: number;
-    running: boolean;
-    depth: number;
-    executionDepth: number;
-    taskCount: number;
-    flushVersion: number;
-    laneQueues: {
-      derived: number;
-      component: number;
-      reactive: number;
-      post: number;
-    };
-    inHandler: boolean;
-    allowSyncProgress: boolean;
-  };
-  getFlushVersion(): number;
-  flushIfQueued(): void;
-  runInHandlerScope<T>(fn: () => T, flushMode?: 'defer' | 'sync'): T;
-  setInHandler(v: boolean): void;
-  isInHandler(): boolean;
-  isExecuting(): boolean;
-  clearPendingSyncTasks(): number;
-  private resolveWaiters;
-}
 
 declare function scheduleEventHandler(handler: EventListener): EventListener;
-export {
-  Task,
-  SchedulerLane,
-  SchedulerBulkCommitProbe,
-  Scheduler,
-  scheduleEventHandler,
-};
+export { scheduleEventHandler };

package/dist/domains/server.d.ts

@@ -1,7 +1,5 @@
 import { JSXElementType, JSXElement, Props } from '../elements.js';
 import '../jsx-globals.js';
-import { AuthContext, AuthRequirement } from '@askrjs/auth';
-import { InferSchema, ObjectSchema } from '@askrjs/schema';
 import { RenderableChild, Scope } from './context.js';
 
 /**
@@ -83,12 +81,17 @@ interface SSRPortalHostRegistration {
 interface SSRPortalSlot {
   hasValue: boolean;
   value: RenderableChild | undefined;
+  writers: Map<
+    unknown,
+    { owner: unknown; value: RenderableChild | undefined; order: number }
+  >;
   hosts: SSRPortalHostRegistration[];
 }
 
 interface SSRPortalState {
   slots: Map<object, SSRPortalSlot>;
   nextHostId: number;
+  nextWriteOrder: number;
 }
 
 /** Register request-local CSS produced during SSR without importing the SSR renderer in clients. */

package/dist/domains/state.d.ts

@@ -1,8 +1,5 @@
 import { JSXElementType, JSXElement, Props } from '../elements.js';
 import '../jsx-globals.js';
-import { AuthContext, AuthRequirement } from '@askrjs/auth';
-import { InferSchema, ObjectSchema } from '@askrjs/schema';
-import { ReadableSource } from './component.js';
 import { capture } from './lifecycle.js';
 import { For } from './control.js';
 
@@ -13,7 +10,7 @@ import { For } from './control.js';
  * count();           // read: 0
  * count.set(1);      // write: triggers re-render
  */
-interface State<T> extends ReadableSource<T> {
+interface State<T> {
   (): T;
   set(...args: StateSetterArgs<T>): void;
   [Symbol.iterator](): IterableIterator<StateTuple<T>[number]>;
@@ -72,7 +69,7 @@ type SnapshotSourceBrand = {
 };
 
 /** A reactive derived value produced by {@link derive}; call it to read the current result. */
-interface Derived<T> extends ReadableSource<T> {
+interface Derived<T> {
   (): T;
 }