@opetope/react 0.14.0 → 0.16.0

package/dist/integration.d.ts

@@ -1,6 +1,2 @@
 export { ContributionBoundary } from './contribution-isolation.js';
 export type { ContributionBoundaryProps, ContributionErrorContent, ContributionFailure, } from './contribution-isolation.js';
-export { FeatureBoundary, FeatureBoundaryError, useFeatureRetry } from './feature-boundary.js';
-export type { FeatureBoundaryProps } from './feature-boundary.js';
-export { useFeature } from './feature-demand.js';
-export type { FeatureDemandLease, FeatureDemandResult, FeatureDemandSource, FeatureDemandState, } from './feature-demand.js';

package/dist/integration.js

@@ -1,2 +1,2 @@
-import{a as M}from"./contribution-isolation-Bzfbt4iM.js";import{jsx as C}from"react/jsx-runtime";import{useCallback as f,useSyncExternalStore as E,useMemo as h,useEffect as x,useState as S,createContext as B,useContext as g}from"react";const y=()=>{};function b(e){const r=f(t=>e.subscribe(t),[e]),u=f(()=>e.getState(),[e]),d=E(r,u,u),n=h(()=>({current:null,source:e}),[e]);x(()=>{const t=e.acquire();return t.settled.catch(y),()=>{t.release().catch(y)}},[e]);const o=f(()=>{if(n.current!==null)return n.current.settled;let t=()=>{};const s={lease:null,settled:new Promise(p=>{t=p})},c=()=>{n.current===s&&(n.current=null),t()};n.current=s;let i;try{i=n.source.acquire()}catch{return c(),s.settled}return s.lease=i,i.settled.catch(y).finally(c),i.release().catch(y),s.settled},[n]);return h(()=>Object.freeze({retry:o,state:d}),[o,d])}const F=B(void 0);class v extends Error{code;name="FeatureBoundaryError";constructor(r,u){super(u),this.code=r}}function w(){const e=g(F);if(e===void 0)throw new v("missing","Feature error hooks may only be used by the error subtree of a FeatureBoundary.");return e}function q(){return w().retry}function j({children:e,demand:r,error:u,fallback:d}){const{retry:n,state:o}=b(r),[t,s]=S(),c=f(()=>{const a={},m=()=>s(l=>(l==null?void 0:l.attempt)===a?void 0:l);s({attempt:a,demand:r});try{n().finally(m)}catch(l){throw m(),l}},[r,n]),i=h(()=>({retry:c}),[c]),p=(t==null?void 0:t.demand)===r;if(x(()=>{s(a=>a===void 0||a.demand===r&&o.instance===null?a:void 0)},[r,o.instance]),o.instance!==null)return typeof e=="function"?e(o.instance):e;if(o.error!==null&&!p){const a=typeof u=="function"?u({error:o.error,retry:c}):u;return C(F,{value:i,children:a})}return d}export{M as ContributionBoundary,j as FeatureBoundary,v as FeatureBoundaryError,b as useFeature,q as useFeatureRetry};
+import{C as n}from"./contribution-isolation-Ig70xFiC.js";export{n as ContributionBoundary};
 //# sourceMappingURL=integration.js.map

package/dist/integration.js.map

@@ -1 +1 @@
-{"version":3,"file":"integration.js","sources":["../src/feature-demand.ts","../src/feature-boundary.tsx"],"sourcesContent":["import { useCallback, useEffect, useMemo, useSyncExternalStore } from 'react';\n\ninterface FeatureDemandLease {\n  readonly release: () => Promise<void>;\n  readonly settled: Promise<void>;\n}\n\ninterface FeatureDemandState<Ready> {\n  readonly error: unknown | null;\n  readonly instance: Ready | null;\n}\n\ninterface FeatureDemandSource<Ready> {\n  acquire(): FeatureDemandLease;\n  getState(): FeatureDemandState<Ready>;\n  subscribe(listener: () => void): () => void;\n}\n\ninterface FeatureDemandResult<Ready> {\n  /** Resolves when the attempt it started has settled, in success and in failure alike (D198). */\n  readonly retry: () => Promise<void>;\n  readonly state: FeatureDemandState<Ready>;\n}\n\nconst ignoreFailure = (): void => undefined;\n\nfunction useFeature<Ready>(source: FeatureDemandSource<Ready>): FeatureDemandResult<Ready> {\n  const subscribe = useCallback((listener: () => void) => source.subscribe(listener), [source]);\n  const getSnapshot = useCallback(() => source.getState(), [source]);\n  const state = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);\n  const retrying = useMemo<{\n    current: { lease: FeatureDemandLease | null; readonly settled: Promise<void> } | null;\n    readonly source: FeatureDemandSource<Ready>;\n  }>(() => ({ current: null, source }), [source]);\n\n  useEffect(() => {\n    const demand = source.acquire();\n    void demand.settled.catch(ignoreFailure);\n\n    return () => void demand.release().catch(ignoreFailure);\n  }, [source]);\n\n  const retry = useCallback((): Promise<void> => {\n    // Single-flight per source: a second call joins the attempt already running instead of starting another.\n    if (retrying.current !== null) return retrying.current.settled;\n\n    // D198: `acquire` runs foreign code, and a host that answers it synchronously may call `retry` again. The\n    // attempt is reserved with its own promise before that call, so the reentrant caller joins this attempt\n    // instead of taking a second lease of its own.\n    let settle = (): void => undefined;\n    const attempt = {\n      lease: null as FeatureDemandLease | null,\n      settled: new Promise<void>(resolve => {\n        settle = resolve;\n      }),\n    };\n    const finish = (): void => {\n      if (retrying.current === attempt) retrying.current = null;\n\n      settle();\n    };\n    retrying.current = attempt;\n\n    let lease: FeatureDemandLease;\n\n    try {\n      lease = retrying.source.acquire();\n    } catch {\n      // D198: `retry` answers with the promise of the attempt it started, and an acquisition that refused is an\n      // attempt that is over. The refusal belongs to the state the source publishes, which is where the caller\n      // reads it; throwing it back here would leave every caller of `retry` waiting for an attempt that ended.\n      finish();\n\n      return attempt.settled;\n    }\n\n    attempt.lease = lease;\n    void lease.settled.catch(ignoreFailure).finally(finish);\n    void lease.release().catch(ignoreFailure);\n\n    return attempt.settled;\n  }, [retrying]);\n\n  return useMemo(() => Object.freeze({ retry, state }), [retry, state]);\n}\n\nexport { useFeature };\nexport type { FeatureDemandLease, FeatureDemandResult, FeatureDemandSource, FeatureDemandState };\n","import { createContext, useCallback, useContext, useEffect, useMemo, useState } from 'react';\nimport type { ReactNode } from 'react';\n\nimport { useFeature } from './feature-demand';\nimport type { FeatureDemandSource } from './feature-demand';\n\n/**\n * D177: a branch may be a node or a render callback. The callback receives what only the boundary knows — the ready\n * instance, or the failure with the retry that belongs to this demand — so a ready consumer needs no second\n * `useFeature` and no second lease. A function is never a `ReactNode`, so the two forms cannot be confused.\n */\ntype FeatureBoundaryChildren<Ready> = ((instance: Ready) => ReactNode) | ReactNode;\ntype FeatureBoundaryErrorContent =\n  | ((context: { readonly error: unknown; readonly retry: () => void }) => ReactNode)\n  | ReactNode;\n\n/** The boundary keeps the feature open while it is mounted; its UI enters the host through slots (D85). */\ntype FeatureBoundaryProps<Ready = unknown> = {\n  readonly children: FeatureBoundaryChildren<Ready>;\n  readonly demand: FeatureDemandSource<Ready>;\n  readonly error: FeatureBoundaryErrorContent;\n  readonly fallback: ReactNode;\n};\n\n/** Only `retry` is read: the error itself belongs to the `error` subtree a host already renders (D142). */\ntype FeatureBoundaryErrorContext = {\n  readonly retry: () => void;\n};\n\n/** D198: the error is hidden for the life of the attempt that was started, not until the error object changes. */\ntype SuppressedError = {\n  readonly attempt: object;\n  readonly demand: object;\n};\n\nconst ErrorContext = createContext<FeatureBoundaryErrorContext | undefined>(undefined);\n\n/** One class per subject with the state in `code` (D69): the boundary is its own subject, not a feature failure. */\nclass FeatureBoundaryError extends Error {\n  override readonly name = 'FeatureBoundaryError';\n\n  constructor(\n    readonly code: 'missing',\n    message: string,\n  ) {\n    super(message);\n  }\n}\n\nfunction useBoundaryErrorContext(): FeatureBoundaryErrorContext {\n  const context = useContext(ErrorContext);\n\n  if (context === undefined) {\n    throw new FeatureBoundaryError(\n      'missing',\n      'Feature error hooks may only be used by the error subtree of a FeatureBoundary.',\n    );\n  }\n\n  return context;\n}\n\nfunction useFeatureRetry(): () => void {\n  return useBoundaryErrorContext().retry;\n}\n\nfunction FeatureBoundary<Ready>({ children, demand, error, fallback }: FeatureBoundaryProps<Ready>): ReactNode {\n  const { retry: requestRetry, state } = useFeature(demand);\n  const [suppressed, setSuppressed] = useState<SuppressedError>();\n  const retry = useCallback(() => {\n    const attempt = {};\n    // The attempt is over: whatever it ended with, including the very same error object, is the answer to show.\n    const reveal = (): void => setSuppressed(current => (current?.attempt === attempt ? undefined : current));\n    setSuppressed({ attempt, demand });\n\n    try {\n      void requestRetry().finally(reveal);\n    } catch (error) {\n      // A retry that refuses synchronously has no promise to settle, and an error hidden by it would never be\n      // shown again: the suppression is lifted here before the refusal goes back to whoever asked (D198).\n      reveal();\n\n      throw error;\n    }\n  }, [demand, requestRetry]);\n  const errorContext = useMemo(() => ({ retry }), [retry]);\n  const errorIsSuppressed = suppressed?.demand === demand;\n\n  useEffect(() => {\n    // A suppression outlives neither its source nor a ready feature: only the attempt of this demand may hide it.\n    setSuppressed(current =>\n      current === undefined || (current.demand === demand && state.instance === null) ? current : undefined,\n    );\n  }, [demand, state.instance]);\n\n  // Only the branch that is shown runs its callback: an abandoned branch renders nothing and computes nothing.\n  if (state.instance !== null) return typeof children === 'function' ? children(state.instance) : children;\n\n  if (state.error !== null && !errorIsSuppressed) {\n    const content = typeof error === 'function' ? error({ error: state.error, retry }) : error;\n\n    return <ErrorContext value={errorContext}>{content}</ErrorContext>;\n  }\n\n  return fallback;\n}\n\nexport { FeatureBoundary, FeatureBoundaryError, useFeatureRetry };\nexport type { FeatureBoundaryProps };\n"],"names":["ignoreFailure","useFeature","source","subscribe","useCallback","listener","getSnapshot","state","useSyncExternalStore","retrying","useMemo","useEffect","demand","retry","settle","attempt","resolve","finish","lease","ErrorContext","createContext","FeatureBoundaryError","code","message","useBoundaryErrorContext","context","useContext","useFeatureRetry","FeatureBoundary","children","error","fallback","requestRetry","suppressed","setSuppressed","useState","reveal","current","errorContext","errorIsSuppressed","content","_jsx"],"mappings":"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"}
+{"version":3,"file":"integration.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/model-hook.d.ts

@@ -1,18 +1,19 @@
 import type { Command, ModelOf, PaginatedResource, Resource } from '@opetope/core';
 import type { CommandHook } from './command-hook.js';
 import type { AnyModel } from './model-binding.js';
-import type { SelectionContext, SelectionShape } from './model-selection-snapshot.js';
+import type { SelectionContext } from './model-selection-snapshot.js';
 import type { PaginatedResourceHook, ResourceHook, ResourceKey } from './resource-command.js';
+import type { RefusedSelection, SelectorModel } from './selector-sources.js';
 /**
  * D359: a field whose value is a Resource answers the hook `useResource` answers, and the mount leases it exactly as
  * `useResource` does. `read(resource.state)` is unchanged — it hands out the state and leases nothing — so naming one
  * Resource both ways registers it twice: the subscription and the lease are independent.
  */
-type SelectedValue<Value> = Value extends Command<infer Input, infer Output> ? CommandHook<Input, Output> : Value extends PaginatedResource<infer Data, infer Key extends ResourceKey, infer Cursor extends ResourceKey, 'consumers' | 'owner'> ? PaginatedResourceHook<Data, Key, Cursor> : Value extends Resource<infer Data, infer Key extends ResourceKey, 'consumers' | 'owner'> ? ResourceHook<Data, Key> : Value;
+type SelectedValue<Value> = Value extends Command<infer Input, infer Output> ? CommandHook<Input, Output> : Value extends PaginatedResource<infer Data, infer Key extends ResourceKey, infer Cursor extends ResourceKey, 'consumers' | 'model'> ? PaginatedResourceHook<Data, Key, Cursor> : Value extends Resource<infer Data, infer Key extends ResourceKey, 'consumers' | 'model'> ? ResourceHook<Data, Key> : Value;
 type ModelSelection<Selected> = {
     readonly [Key in keyof Selected]: SelectedValue<Selected[Key]>;
 };
-/** D205: resolve only a granted model, explicitly read data, and reuse the ordinary per-key command consumers. */
+/** Read a granted model; a selection reads sources through `read` and binds Command or Resource fields. */
 declare function useModel<Declaration extends AnyModel>(declaration: Declaration): ModelOf<Declaration>;
-declare function useModel<Declaration extends AnyModel, const Selected extends object>(declaration: Declaration, select: (model: ModelOf<Declaration>, context: SelectionContext) => Selected & SelectionShape<Selected>): ModelSelection<Selected>;
+declare function useModel<Declaration extends AnyModel, const Selected extends object = RefusedSelection>(declaration: Declaration, select: (model: SelectorModel<ModelOf<Declaration>>, context: SelectionContext) => Selected): ModelSelection<Selected>;
 export { useModel };

package/dist/model-selection-snapshot.d.ts

@@ -2,17 +2,16 @@ import type { Readable, ResourceView } from '@opetope/core';
 import type { ResourceDemand } from '@opetope/core/internal';
 import type { AnyCommand } from './model-binding.js';
 import type { AnyResource } from './resource-command.js';
-type SelectionValue<Source> = Source extends ResourceView<infer Value> ? Value : Source extends Readable<infer Value> ? Value : never;
+type SelectionValue<Candidate> = Candidate extends ResourceView<infer Value> ? Value : Candidate extends Readable<infer Value> ? Value : never;
 interface SelectionRead {
-    <Source extends Readable<unknown> | ResourceView<unknown>>(source: Source): SelectionValue<Source>;
-    <Source extends Readable<unknown> | ResourceView<unknown>, Selected>(source: Source, select: (value: SelectionValue<Source>) => Selected): Selected;
+    <Candidate extends Readable<unknown> | ResourceView<unknown>>(source: Candidate): SelectionValue<Candidate>;
+    <Candidate extends Readable<unknown> | ResourceView<unknown>, Selected>(source: Candidate, select: (value: SelectionValue<Candidate>) => Selected): Selected;
 }
+/** The tracked reader passed to a `useModel` selector. Reading a view records demand for commit. */
 type SelectionContext = Readonly<{
+    /** Read a source for this selection, tracking it so the selection updates when it changes. */
     read: SelectionRead;
 }>;
-type NonSelectionRecord = readonly unknown[] | ((...arguments_: never[]) => unknown) | (abstract new (...arguments_: never[]) => unknown) | Date | PromiseLike<unknown> | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown> | RegExp | WeakMap<object, unknown> | WeakSet<object>;
-/** A named interface needs no open index signature; container and callable results are not field selections. */
-type SelectionShape<Selected extends object> = Selected extends NonSelectionRecord ? never : Selected;
 type SelectionRecord = Readonly<Record<PropertyKey, unknown>>;
 /**
  * D359: the Resource a field selected, and what this selection read from it — its state, and the state of its
@@ -61,4 +60,4 @@ declare function createSelectionMemory(): SelectionMemory;
  */
 declare function createSelectionSnapshot<Model>(model: Model, selectRef: SelectionReaderRef<Model>, memory: SelectionMemory): () => SelectionSnapshot;
 export { createSelectionMemory, createSelectionSnapshot, emptySelectionSnapshot };
-export type { ModelSelector, SelectedResource, SelectionContext, SelectionMemory, SelectionShape, SelectionSnapshot };
+export type { ModelSelector, SelectedResource, SelectionContext, SelectionMemory, SelectionSnapshot };

package/dist/readable-hooks.d.ts

@@ -1,10 +1,7 @@
-import type { Readable } from '@opetope/core';
-import type { EqualityOption } from '@opetope/core/internal';
+import type { Readable, Resource, ResourceKey, ResourceView } from '@opetope/core';
+type SourceValue<Source> = Source extends ResourceView<infer Value> ? Value : Source extends Readable<infer Value> ? Value : never;
 /**
- * D279: the source and the selection are positional; `equals` is the one modifier, spelled as in Core — including
- * D348's rule for where the comparator is read, so a named non-generic one compiles here as it does in `derive`.
+ * Subscribe to a Readable or lease a ResourceView for this committed mount.
  */
-export declare function useSelector<Value, Selected>(readable: Readable<Value>, select: (value: NoInfer<Value>) => Selected, options?: {
-    readonly equals?: EqualityOption<NoInfer<Selected>>;
-}): Selected;
-export declare function useReadable<Value>(readable: Readable<Value>): Value;
+export declare function useReadable<Source extends Readable<unknown> | Resource<unknown, ResourceKey, 'consumers' | 'model'> | ResourceView<unknown>>(source: Source extends Readable<unknown> | ResourceView<unknown> ? Source : 'read resource.state, or select the Resource in useModel'): SourceValue<Source>;
+export {};

package/dist/requires-models.d.ts

@@ -2,16 +2,13 @@ import type { FunctionComponent } from 'react';
 import type { ModelIdentity } from '@opetope/core/internal';
 type AnyModel = ModelIdentity;
 /**
- * The marker a component uses to state which UI models of its contribution it reads. `slot` checks by type that the
- * contribution grants every model of this list — it may grant more, because the mount serves its whole instance.
- *
- * The runtime authority is the mount frame, not this marker: `useModel` resolves against what the mount was given
- * and refuses anything else. The lint rule `opetope/require-declared-models` checks visible contribution sites and
- * each reader of a per-mount model within the same module. Imported implementations and dynamic declaration lists
- * remain unknown to this syntactic check (D85, D158, D250).
+ * The marker a component uses to state which UI models of its contribution it reads.
  */
 type ComponentRequiringModels<Props, Models extends readonly AnyModel[]> = FunctionComponent<Props> & {
     readonly requires: Models;
 };
+/**
+ * Declares the UI models a component reads and returns the same component marked with them, so `slot` can check by type that the contribution grants each one.
+ */
 declare function requiresModels<const Models extends readonly AnyModel[]>(models: Models): <Props>(component: FunctionComponent<Props>) => ComponentRequiringModels<Props, Models>;
 export { requiresModels };

package/dist/resource-command.d.ts

@@ -1,21 +1,14 @@
-/**
- * D359: the verbs of a Resource, dressed as the commands a button already knows, and the recognition that answers
- * «is this selected field a Resource». A consumer keeps a status — `inFlight` until the operation settles, the
- * settled `outcome` — while the Resource stays owned by the model that declared it: cancelling this wait cancels the
- * wait and not the load.
- */
 import type { PaginationOutcome, PaginationState, Resource, ResourceOperationOutcome, ResourcePagination, ResourceState } from '@opetope/core';
 import type { ResourceKey } from '@opetope/core/internal';
-import type { CommandHook } from './command-hook.js';
-import type { CommandInvoker } from './command-hook-controller.js';
+import type { ResourceVerbHook } from './resource-verb-hook.js';
 /**
  * D439: the widest Resource, and the name says so. `Resource<never, ResourceKey>` said the opposite in both
  * arguments — `never` is the narrowest `Data` a reader can be handed and a named `Key` *requires* `state.key`, so
  * hardly any member of the family fitted it. Nothing was refused, because every value reaches this name through a
  * cast, which is exactly why the name could drift. `ResourceKeyField<never>` requires no field, so
- * `Resource<unknown, never, 'consumers' | 'owner'>` is the one form every Resource satisfies — keyed or not, paginated or not.
+ * `Resource<unknown, never, 'consumers' | 'model'>` is the one form every Resource satisfies — keyed or not, paginated or not.
  */
-type AnyResource = Resource<unknown, never, 'consumers' | 'owner'>;
+type AnyResource = Resource<unknown, never, 'consumers' | 'model'>;
 /**
  * D349, D359: a Resource is a structural contract a host may implement with an ordinary object, so the question the
  * type of a selected field asked is answered by the runtime that owns it — the registry of the materializations it
@@ -24,37 +17,43 @@ type AnyResource = Resource<unknown, never, 'consumers' | 'owner'>;
  * throws.
  */
 declare function isResource(value: unknown): boolean;
-/** D356: the nested capability, with `loadNext` as a command and the projected pagination state beside it. */
+/**
+ * The nested capability — the projected pagination state and a stable `loadNext`.
+ */
 type ResourcePaginationHook<Cursor extends ResourceKey> = Readonly<{
-    loadNext: CommandHook<void, PaginationOutcome<Cursor>>;
+    loadNext: (options?: {
+        readonly retry?: boolean;
+    }) => Promise<PaginationOutcome<Cursor>>;
     state: PaginationState<Cursor>;
 }>;
 /**
- * D359: what `useResource` answers, and what a field of a `useModel` selection whose value is a Resource answers.
- * The verbs never reject (a Resource answers an outcome), so the ordinary path of `outcome` is
- * `{ kind: 'ok', value }`; `failed` stays in the type because the controller turns a synchronous throw of an
- * invoker into it, and the wrapper below carries its own test that it never throws synchronously.
+ * What `useResource` answers, and what a field of a `useModel` selection whose value is a Resource answers.
  */
 type ResourceHook<Data, Key extends ResourceKey = never> = Readonly<{
-    /** Present when the declaration carried `pagination`; `undefined` for every other Resource. */
+    /**
+     * Present when the Resource was paginated (`ctx.resource.paginate`); `undefined` for every other Resource.
+     */
     pagination: ResourcePaginationHook<ResourceKey> | undefined;
-    refresh: CommandHook<void, ResourceOperationOutcome>;
-    reset: CommandHook<void, ResourceOperationOutcome>;
-    retry: CommandHook<void, ResourceOperationOutcome>;
+    refresh: ResourceVerbHook;
+    reset: ResourceVerbHook;
+    retry: ResourceVerbHook;
     state: ResourceState<Data, Key>;
 }>;
 type PaginatedResourceHook<Data, Key extends ResourceKey, Cursor extends ResourceKey> = Omit<ResourceHook<Data, Key>, 'pagination'> & Readonly<{
     pagination: ResourcePaginationHook<Cursor>;
 }>;
 type ResourceInvokers = Readonly<{
-    loadNext: CommandInvoker;
-    refresh: CommandInvoker;
-    reset: CommandInvoker;
-    retry: CommandInvoker;
+    /** D486: not a command — the stable function `pagination.loadNext` is, one per Resource identity. */
+    loadNext: (options?: {
+        readonly retry?: boolean;
+    }) => Promise<unknown>;
+    refresh: () => Promise<ResourceOperationOutcome>;
+    reset: () => Promise<ResourceOperationOutcome>;
+    retry: () => Promise<ResourceOperationOutcome>;
 }>;
-declare function paginationOf(resource: AnyResource): ResourcePagination<ResourceKey, 'consumers' | 'owner'> | undefined;
+declare function paginationOf(resource: AnyResource): ResourcePagination<ResourceKey, 'consumers' | 'model'> | undefined;
 /**
- * One set per Resource identity. `selectEntry` and `useCommandSlot` both pick their controller by the identity of the
+ * One set per Resource identity. Selected and standalone hooks both pick their controller by the identity of the
  * invoker, so a set rebuilt on every render would reset `inFlight`, drop `outcome` and change `run` — which is why it
  * is memoised against the Resource itself and never assembled during a render.
  */

package/dist/resource-hook.d.ts

@@ -1,11 +1,7 @@
 import type { PaginatedResource, Resource } from '@opetope/core';
 import type { ResourceKey } from '@opetope/core/internal';
 import type { PaginatedResourceHook, ResourceHook } from './resource-command.js';
-/**
- * D359: the state of a Resource, the lease that keeps it open for as long as this component is mounted, and its verbs
- * as commands. The number of React hooks here does not depend on the Resource: a declaration without `pagination`
- * subscribes to a constant source and keeps a `loadNext` that answers `skipped`.
- */
-declare function useResource<Data, Key extends ResourceKey, Cursor extends ResourceKey>(resource: PaginatedResource<Data, Key, Cursor, 'consumers' | 'owner'>): PaginatedResourceHook<Data, Key, Cursor>;
-declare function useResource<Data, Key extends ResourceKey>(resource: Resource<Data, Key, 'consumers' | 'owner'>): ResourceHook<Data, Key>;
+/** Lease a Resource for this committed component and read its state and optional pagination. */
+declare function useResource<Data, Key extends ResourceKey, Cursor extends ResourceKey>(resource: PaginatedResource<Data, Key, Cursor, 'consumers' | 'model'>): PaginatedResourceHook<Data, Key, Cursor>;
+declare function useResource<Data, Key extends ResourceKey>(resource: Resource<Data, Key, 'consumers' | 'model'>): ResourceHook<Data, Key>;
 export { useResource };

package/dist/resource-verb-hook.d.ts

@@ -0,0 +1,28 @@
+import type { ResourceOperationOutcome } from '@opetope/core';
+/** A Resource verb answers its own outcome; only its consumer owns this wait and status. */
+type ResourceVerbHook = Readonly<{
+    inFlight: boolean;
+    outcome: ResourceOperationOutcome | undefined;
+    run: () => Promise<ResourceOperationOutcome>;
+}>;
+type VerbNotification = (inFlight: boolean, outcome?: ResourceOperationOutcome) => void;
+/**
+ * Only Resource verbs use this controller. A detached consumer settles its own waits without cancelling the
+ * materialization's work. The linked waiters add no retained collection to a Resource hook that never runs a verb.
+ */
+declare class ResourceVerbController {
+    private readonly start;
+    private inFlight;
+    private notify;
+    private pending;
+    readonly run: () => Promise<ResourceOperationOutcome>;
+    constructor(start: () => Promise<ResourceOperationOutcome>);
+    attach(notify: VerbNotification): () => void;
+    synchronize(): void;
+    private unlink;
+    private finish;
+    private fail;
+}
+declare function useResourceVerbStatus(slot: ResourceVerbController): ResourceVerbHook;
+export { ResourceVerbController, useResourceVerbStatus };
+export type { ResourceVerbHook };

package/dist/scenario-diagnostics.d.ts

@@ -1,6 +1,8 @@
 import type { RuntimeGraphSnapshot } from '@opetope/runtime/internal';
 import type { ScenarioOwnership } from './scenario-types.js';
-/** D206: the failure carries the producer's same data-only graph/activity facts, without product payloads. */
+/**
+ * The failure carries the producer's same data-only graph/activity facts, without product payloads.
+ */
 declare class ScenarioTimeoutError extends Error {
     readonly label: string;
     readonly timeoutMs: number;

package/dist/scenario-mount.d.ts

@@ -2,13 +2,14 @@ import type { ScenarioHostMount } from './scenario-types.js';
 /** A reservation exists before the host callback, so reentrant close also owns a mount returned later. */
 declare class ScenarioMountLease<Mounted extends ScenarioHostMount> {
     private readonly released;
+    private readonly act;
     get closed(): boolean;
     private available;
     private completion;
     private handle;
     private reject;
     private resolve;
-    constructor(released: (failed: boolean, error?: unknown) => void);
+    constructor(released: (failed: boolean, error?: unknown) => void, act: ((callback: () => unknown) => PromiseLike<unknown>) | undefined);
     readonly close: () => Promise<void>;
     provide(handle: Mounted | undefined): void;
     private finish;

package/dist/scenario-slot.d.ts

@@ -1,18 +1,15 @@
 import type { FC } from 'react';
-import type { Command } from '@opetope/core';
 import type { ModelFixture } from './contribution-frame.js';
 import type { SlotComponentProperties, SlotContribution, SlotProperties, SlotTarget } from './slot.js';
 /**
- * Two forms, as `renderRoot` had (D19): without `contribution` the harness mounts what the target published, with it
- * the harness mounts one fixture contribution so a component test needs no generation.
+ * Two forms, as `renderRoot` had: without `contribution` the harness mounts what the target published.
  */
 type SlotTestFixture<Props extends SlotProperties> = {
     readonly contribution?: SlotContribution<Props>;
     readonly models?: readonly ModelFixture[];
     readonly props?: SlotComponentProperties<Props>;
     /**
-     * Where a contained mount failure is reported (D256). A component test has no feature to report to, so without it
-     * the failure is detached and the assertion has nothing to read.
+     * Where a contained mount failure is reported.
      */
     readonly reporter?: (error: unknown) => void;
 };
@@ -20,15 +17,6 @@ interface SlotTestHarness<Props extends SlotProperties> {
     readonly Slot: FC;
     readonly updateProps: (props: SlotComponentProperties<Props>) => void;
 }
-/**
- * A command a fixture publishes: the test writes the body, the harness gives it the identity a model requires. The
- * Command itself is the core fixture (D300); what this word adds, and what keeps it in the React package, is the
- * contribution binding a mount reads (D285).
- */
-declare function command<Input = void, Output = void>(run: (context: {
-    readonly input: Input;
-    readonly signal: AbortSignal;
-}) => Output | PromiseLike<Output>): Command<Input, Output>;
 /**
  * Mounts the contributions of one slot the way a host does, with optional model fixtures for a component test. D19 and D85: the same
  * ContributionMount is shared by component tests and the application scenario harness (D206).
@@ -36,6 +24,9 @@ declare function command<Input = void, Output = void>(run: (context: {
 declare function createSlotHarness<Props extends SlotProperties>(target: SlotTarget<Props>, fixture?: SlotTestFixture<Props>): SlotTestHarness<Props> & {
     readonly close: () => void;
 };
+/**
+ * Mounts one slot contribution under the React test harness.
+ */
 declare function renderSlot<Props extends SlotProperties>(target: SlotTarget<Props>, fixture?: SlotTestFixture<Props>): SlotTestHarness<Props>;
-export { command, createSlotHarness, renderSlot };
+export { createSlotHarness, renderSlot };
 export type { SlotTestFixture, SlotTestHarness };

package/dist/scenario-types.d.ts

@@ -1,25 +1,50 @@
 import type { FC } from 'react';
-import type { Application, ApplicationConditionBinding } from '@opetope/runtime';
-import type { OpenApplicationOptions, RuntimeGraphSnapshot } from '@opetope/runtime/internal';
+import type { Readable, ResourceView } from '@opetope/core';
+import type { Application, ApplicationConditionBinding, ApplicationImportBinding, ErrorReporter } from '@opetope/runtime';
+import type { ApplicationBindingOptions, OpenApplicationOptions, RuntimeGraphSnapshot } from '@opetope/runtime/internal';
 import type { SlotComponentProperties, SlotProperties, SlotTarget } from './slot.js';
 type ScenarioFeatures = Application extends Application<infer Features> ? Features : never;
 interface ScenarioHostMount {
     unmount(): PromiseLike<void> | void;
 }
-/** The test owns its renderer; the package has no dependency on a DOM renderer or a test runner. */
+/**
+ * The test owns its renderer; the package has no dependency on a DOM renderer or a test runner.
+ */
 interface ScenarioHost<Mounted extends ScenarioHostMount> {
     mount(Component: FC): Mounted;
 }
-type ScenarioOptions<Features extends ScenarioFeatures, Mounted extends ScenarioHostMount, Bindings extends readonly ApplicationConditionBinding[] = readonly ApplicationConditionBinding[]> = OpenApplicationOptions<Features, Bindings> & {
+type ScenarioOptions<Features extends ScenarioFeatures, Mounted extends ScenarioHostMount, Bindings extends readonly ApplicationConditionBinding[] = readonly ApplicationConditionBinding[], Imports extends readonly ApplicationImportBinding[] = readonly ApplicationImportBinding[], Choice extends ErrorReporter | 'collect' = ErrorReporter | 'collect'> = Omit<OpenApplicationOptions<Features, Bindings, Imports>, 'reporter' | 'conditions' | 'imports'> & ApplicationBindingOptions<Features, Bindings, Imports> & {
+    /** Where the application's failures go: a function, or `'collect'` for a readonly `reported` list. */
+    readonly reporter: Choice;
+} & {
+    /**
+     * The renderer's `act`: mount, props, unmount, close and every delivery to a mounted tree run inside it.
+     */
+    readonly act?: (callback: () => unknown) => PromiseLike<unknown>;
+    /**
+     * Records of physical activity an observation keeps, an integer from 1 to 10000.
+     * @default 256
+     */
     readonly activityCapacity?: number;
+    /**
+     * Snapshots `history()` keeps, an integer from 1 to 10000.
+     * @default 64
+     */
     readonly historyCapacity?: number;
+    /** The test-owned renderer: `mount(Component)` answers a handle with `unmount()`. */
     readonly host: ScenarioHost<Mounted>;
+    /** Deadline of readiness and of every wait without its own; the `configureTesting` default otherwise. */
     readonly timeoutMs?: number;
 };
 interface ScenarioWaitOptions {
+    /** Names the wait in its `ScenarioTimeoutError`. */
     readonly label?: string;
-    /** Polls a predicate that also reads external UI state; inspection notifications always wake it immediately. */
+    /**
+     * Polls a predicate that also reads external UI state; inspection notifications always wake it immediately.
+     * @default 10
+     */
     readonly pollIntervalMs?: number;
+    /** Deadline of this wait; the scenario's `timeoutMs`, then the `configureTesting` default otherwise. */
     readonly timeoutMs?: number;
 }
 interface ScenarioMount<Props extends SlotProperties, Mounted extends ScenarioHostMount> {
@@ -38,20 +63,52 @@ type ScenarioOwnership = Readonly<{
     features: 'unknown' | number;
     reasons: readonly string[];
     resources: 'unknown' | number;
-    /** This is not a GC leak assertion and does not claim coverage of arbitrary host or UI resources. */
+    /**
+     * This is not a GC leak assertion and does not claim coverage of arbitrary host or UI resources.
+     */
     scope: 'registered-runtime';
     status: 'complete' | 'unknown';
 }>;
-interface Scenario<Mounted extends ScenarioHostMount> {
+type ScenarioAnswer<Value> = Exclude<Value, false | null | undefined>;
+type ScenarioWaitSource<Value> = Readable<Value> | ResourceView<Value>;
+/**
+ * A source whose every value answers needs a decision.
+ */
+type ScenarioNullableAnswer<Value> = unknown extends Value ? unknown : [Extract<Value, false | null | undefined>] extends [never] ? {
+    readonly 'waitFor(source) requires accept when every source value is an answer': true;
+} : unknown;
+/**
+ * A read answers now or not at all.
+ */
+type ScenarioSyncOnly<Value> = 0 extends 1 & Value ? unknown : [Extract<Value, PromiseLike<unknown>>] extends [never] ? unknown : {
+    readonly 'waitFor reads synchronously and a promise would answer its first attempt: await the read inside eventually': never;
+};
+/**
+ * Without a decision, the function and the source share one signature, so the refusal of either half is the one
+ * printed. The name stands in the first line: spelled out, the snapshot type would fill it before the refusal.
+ */
+type ScenarioReadWithoutAccept<Value> = (((snapshot: RuntimeGraphSnapshot) => Value) & ScenarioSyncOnly<Value>) | (ScenarioWaitSource<Value> & ScenarioNullableAnswer<Value> & ScenarioSyncOnly<Value>);
+interface ScenarioBase<Mounted extends ScenarioHostMount> {
     close(): Promise<void>;
     getSnapshot(): RuntimeGraphSnapshot;
     history(): readonly RuntimeGraphSnapshot[];
     mount<Props extends SlotProperties>(target: SlotTarget<Props>, ...arguments_: ScenarioMountArguments<Props>): ScenarioMount<Props, Mounted>;
-    /** Wakes predicates after an external fixture changes; it publishes no runtime event. */
+    /**
+     * Wakes predicates after an external fixture changes; it publishes no runtime event.
+     */
     notify(): void;
     ownership(): ScenarioOwnership;
-    /** A deadline does not close the application: a test can inspect a loading body and then release its fixture. */
+    /**
+     * A deadline does not close the application: a test can inspect a loading body and then release its fixture.
+     */
     readonly ready: Promise<void>;
-    waitFor(predicate: (snapshot: RuntimeGraphSnapshot) => boolean, options?: ScenarioWaitOptions): Promise<void>;
+    waitFor<Value>(read: ScenarioReadWithoutAccept<Value>, options?: ScenarioWaitOptions): Promise<ScenarioAnswer<Value>>;
+    waitFor<Value, Narrowed extends Value>(source: ScenarioWaitSource<Value> & ScenarioSyncOnly<Value>, accept: (value: Value) => value is Narrowed, options?: ScenarioWaitOptions): Promise<Narrowed>;
+    waitFor<Value>(source: ScenarioWaitSource<Value> & ScenarioSyncOnly<Value>, accept: (value: Value) => boolean, options?: ScenarioWaitOptions): Promise<Value>;
+    waitFor<Value, Narrowed extends Value>(read: ((snapshot: RuntimeGraphSnapshot) => Value) & ScenarioSyncOnly<Value>, accept: (value: Value) => value is Narrowed, options?: ScenarioWaitOptions): Promise<Narrowed>;
+    waitFor<Value>(read: ((snapshot: RuntimeGraphSnapshot) => Value) & ScenarioSyncOnly<Value>, accept: (value: Value) => boolean, options?: ScenarioWaitOptions): Promise<Value>;
 }
-export type { Scenario, ScenarioFeatures, ScenarioHost, ScenarioHostMount, ScenarioMount, ScenarioOptions, ScenarioOwnership, ScenarioWaitOptions, };
+type Scenario<Mounted extends ScenarioHostMount, Choice extends ErrorReporter | 'collect' = ErrorReporter> = ScenarioBase<Mounted> & (Choice extends 'collect' ? Readonly<{
+    reported: readonly unknown[];
+}> : {});
+export type { Scenario, ScenarioFeatures, ScenarioHost, ScenarioHostMount, ScenarioMount, ScenarioOptions, ScenarioOwnership, ScenarioReadWithoutAccept, ScenarioWaitOptions, };

package/dist/scenario-wait.d.ts

@@ -6,6 +6,13 @@ interface ScenarioWaitSource {
     readonly history: () => readonly RuntimeGraphSnapshot[];
     readonly timeoutMs: number;
 }
+type ScenarioWaitRead = {
+    readonly kind: 'source';
+    readonly read: () => unknown;
+} | {
+    readonly kind: 'graph';
+    readonly read: (snapshot: RuntimeGraphSnapshot) => unknown;
+};
 declare class ScenarioWaiters {
     private readonly source;
     private readonly listeners;
@@ -14,7 +21,7 @@ declare class ScenarioWaiters {
     cancel(): void;
     deadline<Value>(result: PromiseLike<Value>, label: string, timeoutMs?: number): Promise<Value>;
     readonly notify: () => void;
-    waitFor(predicate: (snapshot: RuntimeGraphSnapshot) => boolean, options: ScenarioWaitOptions): Promise<void>;
+    waitFor(request: ScenarioWaitRead, accept: ((value: unknown) => boolean) | undefined, options: ScenarioWaitOptions): Promise<unknown>;
     private timeout;
 }
 export { positiveDuration, ScenarioWaiters };

package/dist/scenario.d.ts

@@ -1,5 +1,7 @@
-import type { Application, ApplicationConditionBinding } from '@opetope/runtime';
+import type { Application, ApplicationConditionBinding, ApplicationImportBinding, ErrorReporter } from '@opetope/runtime';
 import type { Scenario, ScenarioFeatures, ScenarioHostMount, ScenarioOptions } from './scenario-types.js';
-/** D206: one real application, its existing inspection session and renderer-owned Slot ingress. */
-declare function createScenario<const Features extends ScenarioFeatures, Mounted extends ScenarioHostMount, const Bindings extends readonly ApplicationConditionBinding[] = readonly []>(application: Application<Features>, options: ScenarioOptions<NoInfer<Features>, Mounted, Bindings>): Scenario<Mounted>;
+/**
+ * One real application, its existing inspection session and renderer-owned Slot ingress.
+ */
+declare function createScenario<const Features extends ScenarioFeatures, Mounted extends ScenarioHostMount, const Bindings extends readonly ApplicationConditionBinding[] = readonly [], const Imports extends readonly ApplicationImportBinding[] = readonly [], const Choice extends ErrorReporter | 'collect' = ErrorReporter>(application: Application<Features>, options: ScenarioOptions<NoInfer<Features>, Mounted, Bindings, Imports, Choice>): Scenario<Mounted, Choice>;
 export { createScenario };

package/dist/selection-hooks.d.ts

@@ -1,17 +1,19 @@
 import type { Command } from '@opetope/core';
 import type { CommandHook } from './command-hook.js';
 import type { SelectedResource } from './model-selection-snapshot.js';
+import type { ResourceInvokers } from './resource-command.js';
+import type { ResourceVerbHook } from './resource-verb-hook.js';
 type CommandSelection = Readonly<Record<string, Command<never, unknown>>>;
 type ResourceSelection = ReadonlyMap<PropertyKey, SelectedResource>;
 /** D359: what one selected Resource answers — its three verbs, its state, and the pagination capability if it has one. */
 type SelectedResourceHook = Readonly<{
     pagination: Readonly<{
-        loadNext: CommandHook<never, unknown>;
+        loadNext: ResourceInvokers['loadNext'];
         state: unknown;
     }> | undefined;
-    refresh: CommandHook<never, unknown>;
-    reset: CommandHook<never, unknown>;
-    retry: CommandHook<never, unknown>;
+    refresh: ResourceVerbHook;
+    reset: ResourceVerbHook;
+    retry: ResourceVerbHook;
     state: unknown;
 }>;
 type SelectionHooks = Readonly<Record<PropertyKey, CommandHook<never, unknown> | SelectedResourceHook>>;

package/dist/selector-sources.d.ts

@@ -0,0 +1,64 @@
+import type { Readable, ResourceView } from '@opetope/core';
+import type { State } from '@opetope/core/internal';
+/**
+ * D476: the refusals of a selector. Each is the instruction, as D401 writes a refusal; a string literal behind an alias
+ * prints as the literal, so the sentence reaches the message. A string and not a record, because a `this` of a record
+ * type reaches TS7 as a missing property that prints the sentence twice and never says `this`.
+ */
+type SnapshotRefusal = 'getSnapshot() in a selector never updates: use read(source)';
+type SubscribeRefusal = 'a selector subscribes to a source through read(source)';
+type LeaseRefusal = 'select the Resource as a field, or read(view), and the component leases it';
+type StateWriteRefusal = 'a selector reads; write in a command';
+/**
+ * D476: what a selector sees in place of a `Readable` field. It is still a `Readable` — `this` is not compared where
+ * the target signature declares none — so `derive`, `selectByKey` and a selector annotated with the model keep taking
+ * it, while a direct read refuses its receiver: `read` is the one read in a selector that subscribes the component to
+ * what it read, and `getSnapshot()` there answers the first value forever. An alias of an object type and not an
+ * interface, so a declaration file that meets it prints its structure instead of refusing an unexported name.
+ */
+type Source<Value> = {
+    getSnapshot(this: SnapshotRefusal): Value;
+    subscribe(this: SubscribeRefusal, listener: () => void): () => void;
+};
+type Guarded<Member, Refusal> = Member extends (...arguments_: infer Arguments) => infer Result ? (this: Refusal, ...arguments_: Arguments) => Result : Member;
+/** D476, D519: the members a selector may not call on a source, each with its refusal. */
+type ReadRefusals = {
+    readonly acquire: LeaseRefusal;
+    readonly getSnapshot: SnapshotRefusal;
+    readonly subscribe: SubscribeRefusal;
+};
+type GuardedMembers = ReadRefusals & {
+    readonly close: StateWriteRefusal;
+    readonly set: StateWriteRefusal;
+    readonly update: StateWriteRefusal;
+};
+/**
+ * D476: a source with more members than `Readable` — a Resource, a view, a collection, a pagination capability — keeps
+ * every one of them, and only the reads and the lease refuse a direct call. `observe()`, `state` and the members of a
+ * collection answer sources of the same kind. What `read` hands back is a value and is not guarded, and neither is
+ * what a factory field answers: a factory keeps its own signature, generic and overloaded ones included. D519: the
+ * writes of a `State` refuse too. The six refusals are one lookup and not a chain of six conditionals, which costs
+ * the `selectors` workload 141 instantiations less for the same refusals.
+ */
+type InSelector<Field> = {
+    readonly [Key in keyof Field]: Key extends keyof GuardedMembers ? Key extends keyof ReadRefusals ? Guarded<Field[Key], ReadRefusals[Key]> : Field extends State<infer _Value> ? Guarded<Field[Key], StateWriteRefusal> : FieldInSelector<Field[Key]> : Key extends 'observe' ? Field[Key] extends () => infer Observed ? () => FieldInSelector<Observed> : Field[Key] : FieldInSelector<Field[Key]>;
+};
+type FieldInSelector<Member> = Member extends Readable<infer Value> ? [Exclude<keyof Member, keyof Readable<Value>>] extends [never] ? Source<Value> : InSelector<Member> : Member extends ResourceView<unknown> | Readonly<{
+    state: Readable<unknown>;
+}> ? InSelector<Member> : Member;
+/**
+ * The model a selector receives.
+ */
+type SelectorModel<Model> = {
+    readonly [Key in keyof Model]: FieldInSelector<Model[Key]>;
+};
+/**
+ * D476: what a refused call answers. TypeScript resolves a refused call again without its selector, so the selection
+ * type is not inferred there: destructuring stays silent, and a field that is used says the selection was refused.
+ */
+type RefusedSelection = {
+    readonly [Field in PropertyKey]: {
+        readonly 'this selection is refused: fix the error its selector reports': never;
+    };
+};
+export type { RefusedSelection, SelectorModel };