foldkit-remote 0.3.0 → 0.4.0

package/README.md

@@ -293,6 +293,32 @@ const clientLayer = Remote.clientLayer(rpcClient)
 `RemoteClient` service used by subscriptions and Commands. The transport itself
 is not owned by Remote.
 
+## One list per application with `Data.wiring`
+
+The integration steps above — spread `Remote.messages`, reduce by tag, derive
+`Data.subscriptions`, provide the client — are one value when the application
+uses `foldkit-bundle`:
+
+```ts
+import { Bundle } from 'foldkit-bundle'
+
+const Page = Bundle.parent({ Model, Message })
+const wiring = Page.assemble(
+  Data.wiring({
+    project: Surface.at(ProjectPage, model =>
+      model.route._tag === 'project' ? { projectId: model.route.projectId } : undefined,
+    ),
+  }),
+)
+const update = wiring.update(model => ({ model }))
+```
+
+`Data.wiring` routes Remote's Messages into `Data.reduce`, brings the active
+Surfaces' Subscriptions and the domain's contract, and requires `RemoteClient`
+from the runtime's resources — the same client layer from above. One assembly
+holds at most one Remote domain: every domain claims the same Message tags,
+and the assembly refuses a second claimant at startup, naming both.
+
 ## `RemoteData`: what does the Model know right now?
 
 A Remote Projection never lies by pretending an absent value is present. It
@@ -329,7 +355,13 @@ The states are:
 - **`Ready`** — every selected field is present and decodes.
 - **`Refreshing`** — the current value remains visible while it is being refetched.
 - **`Failed`** — stored server data does not decode against the Selection.
-- **`NotFound`** — the entity is represented by a tombstone.
+- **`NotFound`** — the entity is represented by a tombstone: a live event
+  deleted it, or the server was asked for it by id and answered without it. That
+  id is then known absent, whether it never existed, is gone, or is not this
+  principal's to see. It is not planned again until `Data.refresh` forces it or a
+  write brings it back. The target of a returned ref is not marked this way: a
+  server need not expand a relation that rides on a request, and the planner asks
+  for such a target by id next, which is when its absence is learned.
 
 `Initial` is intentionally different from `Loading`. A Projection belonging to
 no active Surface may remain `Initial` forever. Rendering a spinner for
@@ -384,6 +416,50 @@ An unknown field or a nested Selection for the wrong entity is a type error.
 Recursive relations remain finite because the entity schema stores references
 (`Entity.ref(User)` / `Entity.refTo('Node')`), not recursively inlined schemas.
 
+### Entities declared with `foldkit-entity`
+
+[`foldkit-entity`](../entity/README.md) declares a domain without Remote in it:
+fields, relations as navigation edges, derived members. `Remote.make` registers
+those Entities, and `Data.get`, `Data.live`, and a query's `select` take their
+Selections. Remote compiles both into the descriptor and Selection above, so
+the store, the planner, and the server see nothing new.
+
+```ts
+import { Schema } from 'effect'
+import { Entity, Relation } from 'foldkit-entity'
+import { Remote } from 'foldkit-remote'
+
+const User = Entity.define('User', Schema.Struct({ id: Schema.String, name: Schema.String }))
+const Project = Entity.define('Project', Schema.Struct({ id: Schema.String, name: Schema.String }))
+const Work = Entity.relate({ User, Project }, { Project: { owner: Relation.one(User) } })
+
+const ProjectCard = Entity.select(Work.Project, {
+  name: true,
+  owner: Entity.select(Work.User, { name: true }),
+})
+
+const Data = Remote.make({ model: App.model.remote, entities: [Work.User, Work.Project] })
+const card = Data.get(ProjectCard, 'p1') // Projection<Model, RemoteData<{ name; owner: { name } }>>
+```
+
+- A relation becomes a ref field: `one` a ref, an optional `one` a nullable ref,
+  `many` an array of refs. A derived member becomes a field the server supplies.
+- The Entity needs an `id` field; Remote keys the store by it.
+- Register the Entities of one `Entity.relate` result and select from that same
+  result; `Object.values(Work)` registers them all.
+- `Entity.from(entity)` and `Selection.from(selection)` are the compile steps,
+  for when you need the descriptor itself: `patch` and `ref` in a mutation
+  handler.
+- `Entity.page(selection, window)` in an Entity Selection is Remote's
+  `Selection.connection`: the window travels with the read, and the server
+  answers with a page of refs. One relation of one entity is held whole or as
+  one window at a time, so two views of the same entity should not read the
+  same relation both ways at once.
+
+`Entity.make` with `Entity.ref` keeps working, and both kinds can share one
+domain. Both packages export `Entity`; a module that needs `Entity.from` beside
+`Entity.define` aliases one of them.
+
 Presence is tracked separately from the JavaScript value. These are distinct:
 
 ```text
@@ -552,6 +628,17 @@ Those settlement Messages go through `Data.reduce` like every other Remote fact.
 The request id comes from the Remote Model's sequence, so `update` stays pure.
 Settling is idempotent per `requestId`.
 
+A mutation that deletes says so. The server's outcome carries
+`deleted: [{ entity, id }]`, and settling it tombstones those entities: they read
+`NotFound`, and they leave every connection and relation they were in, so the
+server names no list. Patches apply first, so an entity named both ways is
+deleted; a retry of the same request deletes nothing again.
+
+`Data.mutation(model, requestId)` reads what became of it from the Model:
+`Pending`, `Applied`, `Failed` with the error the server or transport gave, or
+`Unknown` for an id never started here (or settled so long ago it left the
+bounded ledger). A retry reuses its id, and the latest outcome wins.
+
 Optimistic entity patches are **layers over the base store**, not inverse
 patches. If multiple mutations overlap, the visible cache is recomputed as base
 plus the still-pending layers, so settling one does not require trying to undo
@@ -911,6 +998,15 @@ Remote does **not** own:
 - authentication; server-side authorization belongs at the Source boundary;
 - a background scheduler or general-purpose database/query engine.
 
+## How state changes here
+
+Local application state uses `evo` inside `update`, like anywhere else.
+Remote Messages go through `Data.reduce` into the embedded `Remote.Model`
+submodel — Remote owns that reducer, and it is the only writer of the
+cache. Never install cache state with a ref `set`; the requirements,
+staleness, and tombstones only stay coherent when every fact arrives as a
+Remote Message.
+
 ## Limits
 
 - Effect RPC is the wire contract; the application supplies deployment layers.

package/dist/index.d.mts

@@ -1,9 +1,64 @@
 import { Context, Duration, Effect, Layer, Option, Schema, Stream } from "effect";
-import { ActiveSurface, Contract, Invalid, Metadata, ModelRef, Projection, Surface } from "foldkit-surface";
+import * as Domain from "foldkit-entity";
+import { EntryWithoutKeepAlive } from "foldkit/subscription";
+import { ActiveSurface, Contract, Invalid, Metadata, ModelRef, Projection, Surface, Wiring } from "foldkit-surface";
 import { Rpc, RpcGroup } from "effect/unstable/rpc";
 import { KeyValueStore } from "effect/unstable/persistence";
 import { Command } from "foldkit/command";
-import { EntryWithoutKeepAlive } from "foldkit/subscription";
+//#region ../metadata/dist/index.d.mts
+//#region src/index.d.ts
+/** Marks a `Metadata` value. Its entries are private to this module. */
+declare const MetadataTypeId: unique symbol;
+type MetadataTypeId = typeof MetadataTypeId;
+/**
+ * Declarative facts an interpreter attaches to a node it does not own, such as
+ * the server data a Remote selection needs. The carrier holds and combines
+ * them without knowing what they mean; a package reads only the key it owns.
+ *
+ * Opaque: only a key's `of` and `Metadata.combine` make one, so entries cannot
+ * be forged past a key's type or `merge`, and they are frozen.
+ */
+interface Metadata$1 {
+  readonly [MetadataTypeId]: MetadataTypeId;
+}
+/**
+ * An interpreter's typed slot in `Metadata`. Lookup is by the key object, never
+ * its `name`, so two packages cannot collide by choosing the same string.
+ */
+interface MetadataKey<A> {
+  /** For tooling output only. */
+  readonly name: string;
+  /** Normalizes the entries gathered from combined values, e.g. unioning duplicates. */
+  readonly merge: (values: ReadonlyArray<A>) => ReadonlyArray<A>;
+  /** One line per entry for tooling output. */
+  readonly summarize: (value: A) => string;
+  readonly of: (...values: ReadonlyArray<A>) => Metadata$1;
+  readonly get: (metadata: Metadata$1) => ReadonlyArray<A>;
+}
+/** One key's entries as serializable text, named by the key. */
+interface MetadataSummary {
+  readonly name: string;
+  readonly entries: readonly string[];
+}
+declare const Metadata$1: {
+  /**
+   * Declares an interpreter's slot. Call once per package, at module level:
+   * entries are found by the key object, so two copies of a package (a
+   * duplicated install, a reloaded module) do not see each other's entries.
+   */
+  key: <A>(name: string, options: {
+    readonly merge: (values: ReadonlyArray<A>) => ReadonlyArray<A>;
+    readonly summarize: (value: A) => string;
+  }) => MetadataKey<A>;
+  empty: Metadata$1;
+  /** True only for a value this module made; a copy or a hand-built brand is not one. */
+  is: (value: unknown) => value is Metadata$1;
+  /** Gathers every part's entries and runs each key's `merge` over its group. */
+  combine: (parts: ReadonlyArray<Metadata$1>) => Metadata$1;
+  summarize: (metadata: Metadata$1) => readonly MetadataSummary[];
+};
+//#endregion
+//#endregion
 //#region src/connection.d.ts
 export interface EdgeRef {
   readonly entity: string;
@@ -49,6 +104,51 @@ export declare const hasNext: (connection: Connection) => boolean;
 /** A connection with more than one segment has an explicit unknown gap. */
 export declare const isGapped: (connection: Connection) => boolean;
 //#endregion
+//#region src/remoteData.d.ts
+export interface RemoteError {
+  readonly _tag: string;
+  readonly message: string;
+}
+export type RemoteData<A> = {
+  readonly _tag: 'Initial';
+} | {
+  readonly _tag: 'Loading';
+} | {
+  readonly _tag: 'Ready';
+  readonly value: A;
+} | {
+  readonly _tag: 'Refreshing';
+  readonly value: A;
+} | {
+  readonly _tag: 'Failed';
+  readonly error: RemoteError;
+  readonly previous?: A;
+} | {
+  readonly _tag: 'NotFound';
+};
+export declare const remoteErrorSchema: Schema.Struct<{
+  readonly _tag: Schema.String;
+  readonly message: Schema.String;
+}>;
+export declare const remoteDataSchema: <A>(value: Schema.Schema<A>) => Schema.Codec<RemoteData<A>, unknown>;
+export declare const RemoteData: {
+  /**
+   * The `RemoteData` schema for a value schema. Exposed so a `RemoteData` can
+   * be embedded in a hand-written Model schema, not only through `Remote.select`.
+   */
+  schema: <A>(value: Schema.Schema<A>) => Schema.Schema<RemoteData<A>>;
+  /** Exhaustive: omitting a state is a compile error. */
+  match: <A, R>(data: RemoteData<A>, cases: {
+    readonly Initial: () => R;
+    readonly Loading: () => R;
+    readonly Ready: (value: A) => R;
+    readonly Refreshing: (value: A) => R;
+    readonly Failed: (error: RemoteError, previous: Option.Option<A>) => R;
+    readonly NotFound: () => R;
+  }) => R;
+  map: <A, B>(data: RemoteData<A>, f: (value: A) => B) => RemoteData<B>;
+};
+//#endregion
 //#region src/store.d.ts
 export type EntityKey = string;
 export interface EntityEntry {
@@ -128,6 +228,8 @@ export interface MutationState {
   readonly pending: ReadonlySet<string>;
   readonly applied: ReadonlySet<string>;
   readonly failed: ReadonlySet<string>;
+  /** Why each request in `failed` failed, kept exactly as long as `failed` keeps its id. */
+  readonly errors: ReadonlyMap<string, RemoteError>;
   /**
    * How many mutations this model has started. A bound domain takes its next
    * request id from here, so `update` stays pure and the id exists before the
@@ -137,7 +239,21 @@ export interface MutationState {
 }
 export declare const emptyMutationState: MutationState;
 export declare const beginMutation: (state: MutationState, requestId: string) => MutationState;
-export declare const failMutation: (state: MutationState, requestId: string) => MutationState;
+export declare const failMutation: (state: MutationState, requestId: string, error: RemoteError) => MutationState;
+/** What Remote knows of one mutation request, by the id `mutate` returned. */
+export type MutationStatus =
+/** Never started here, or settled so long ago its id has left the window. */
+{
+  readonly _tag: 'Unknown';
+} | {
+  readonly _tag: 'Pending';
+} | {
+  readonly _tag: 'Applied';
+} | {
+  readonly _tag: 'Failed';
+  readonly error: RemoteError;
+};
+export declare const mutationStatus: (state: MutationState, requestId: string) => MutationStatus;
 export interface Reconciled {
   readonly store: EntityStore;
   readonly state: MutationState;
@@ -147,7 +263,10 @@ export interface Reconciled {
  * with the same `requestId` (a retry, or a live event describing the same change)
  * does not re-apply the entities, but still clears `pending`.
  */
-export declare const reconcileMutation: (store: EntityStore, state: MutationState, requestId: string, entities: ReadonlyArray<NormalizedPatch>) => Reconciled;
+export declare const reconcileMutation: (store: EntityStore, state: MutationState, requestId: string, entities: ReadonlyArray<NormalizedPatch>, deleted?: ReadonlyArray<{
+  readonly entity: string;
+  readonly id: string;
+}>) => Reconciled;
 /** A mutation an application declares: its name and input/output codecs. */
 export interface MutationDescriptor<Name extends string, Input, Output> {
   readonly name: Name;
@@ -283,9 +402,9 @@ export declare const Requirement: {
   mergeConnections: typeof mergeConnections;
 };
 /** Remote's entity requirements on a Projection, unioned per entity and id as nodes compose. */
-export declare const RemoteRequirements: import("foldkit-surface").MetadataKey<Requirement>;
+export declare const RemoteRequirements: MetadataKey<Requirement>;
 /** Remote's query connections on a Projection, unioned per connection and window. */
-export declare const RemoteConnections: import("foldkit-surface").MetadataKey<ConnectionRequirement>;
+export declare const RemoteConnections: MetadataKey<ConnectionRequirement>;
 /** The entity requirements a Projection carries. */
 export declare const requirementsOf: (projection: {
   readonly metadata: Metadata;
@@ -381,7 +500,10 @@ export declare const pruneOverlays: (optimistic: OptimisticState, connection: st
  * a later layer re-wins on rebase. Confirmed connection changes are recorded
  * once per request, as overlays the request no longer owns.
  */
-export declare const settleSuccess: (base: EntityStore, optimistic: OptimisticState, state: MutationState, requestId: string, entities: ReadonlyArray<NormalizedPatch>, connections?: ReadonlyArray<ConnectionChange>) => {
+export declare const settleSuccess: (base: EntityStore, optimistic: OptimisticState, state: MutationState, requestId: string, entities: ReadonlyArray<NormalizedPatch>, connections?: ReadonlyArray<ConnectionChange>, deleted?: ReadonlyArray<{
+  readonly entity: string;
+  readonly id: string;
+}>) => {
   readonly store: EntityStore;
   readonly state: MutationState;
   readonly optimistic: OptimisticState;
@@ -672,6 +794,11 @@ export declare const MutationResult: Schema.Struct<{
       readonly key: Schema.String;
     }>;
   }>]>>>;
+  /** Entities the mutation deleted; the client knows them absent from then on. */
+  readonly deleted: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+  }>>>;
 }>;
 export declare const LiveRequirement: Schema.Struct<{
   readonly version: Schema.Number;
@@ -760,6 +887,11 @@ export declare const Mutate: Rpc.Rpc<"FoldkitRemoteMutate", Schema.Struct<{
       readonly key: Schema.String;
     }>;
   }>]>>>;
+  /** Entities the mutation deleted; the client knows them absent from then on. */
+  readonly deleted: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+  }>>>;
 }>, typeof RemoteMutationError, never, never>;
 export declare const Live: Rpc.Rpc<"FoldkitRemoteLive", Schema.Struct<{
   readonly version: Schema.Number;
@@ -924,6 +1056,11 @@ export declare const RemoteRpc: RpcGroup.RpcGroup<Rpc.Rpc<"FoldkitRemoteRead", S
       readonly key: Schema.String;
     }>;
   }>]>>>;
+  /** Entities the mutation deleted; the client knows them absent from then on. */
+  readonly deleted: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+  }>>>;
 }>, typeof RemoteMutationError, never, never> | Rpc.Rpc<"FoldkitRemoteLive", Schema.Struct<{
   readonly version: Schema.Number;
   readonly requirements: Schema.$Array<Schema.Codec<Requirement, Requirement, never, never>>;
@@ -997,51 +1134,6 @@ export declare const RemoteRpc: RpcGroup.RpcGroup<Rpc.Rpc<"FoldkitRemoteRead", S
   }>]>;
 }>, typeof RemoteQueryError, never, never>>;
 //#endregion
-//#region src/remoteData.d.ts
-export interface RemoteError {
-  readonly _tag: string;
-  readonly message: string;
-}
-export type RemoteData<A> = {
-  readonly _tag: 'Initial';
-} | {
-  readonly _tag: 'Loading';
-} | {
-  readonly _tag: 'Ready';
-  readonly value: A;
-} | {
-  readonly _tag: 'Refreshing';
-  readonly value: A;
-} | {
-  readonly _tag: 'Failed';
-  readonly error: RemoteError;
-  readonly previous?: A;
-} | {
-  readonly _tag: 'NotFound';
-};
-export declare const remoteErrorSchema: Schema.Struct<{
-  readonly _tag: Schema.String;
-  readonly message: Schema.String;
-}>;
-export declare const remoteDataSchema: <A>(value: Schema.Schema<A>) => Schema.Codec<RemoteData<A>, unknown>;
-export declare const RemoteData: {
-  /**
-   * The `RemoteData` schema for a value schema. Exposed so a `RemoteData` can
-   * be embedded in a hand-written Model schema, not only through `Remote.select`.
-   */
-  schema: <A>(value: Schema.Schema<A>) => Schema.Schema<RemoteData<A>>;
-  /** Exhaustive: omitting a state is a compile error. */
-  match: <A, R>(data: RemoteData<A>, cases: {
-    readonly Initial: () => R;
-    readonly Loading: () => R;
-    readonly Ready: (value: A) => R;
-    readonly Refreshing: (value: A) => R;
-    readonly Failed: (error: RemoteError, previous: Option.Option<A>) => R;
-    readonly NotFound: () => R;
-  }) => R;
-  map: <A, B>(data: RemoteData<A>, f: (value: A) => B) => RemoteData<B>;
-};
-//#endregion
 //#region src/model.d.ts
 /**
  * The normalized cache as a Foldkit Submodel. `Remote.define` returns a schema
@@ -1124,6 +1216,11 @@ export type RemoteMessage = {
   readonly entities: readonly NormalizedPatch[];
   /** Connection changes the server confirmed; they replace the request's own. */
   readonly connections?: ReadonlyArray<ConnectionChange> | undefined;
+  /** Entities the mutation deleted: tombstoned, which hides them from every connection. */
+  readonly deleted?: ReadonlyArray<{
+    readonly entity: string;
+    readonly id: string;
+  }> | undefined;
 } | {
   readonly _tag: 'MutationFailed';
   readonly requestId: string;
@@ -1218,6 +1315,10 @@ export declare const remoteMessageCases: {
       readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
     }>>;
     connections: Schema.optional<Schema.$Array<Schema.Unknown>>;
+    deleted: Schema.optional<Schema.$Array<Schema.Struct<{
+      readonly entity: Schema.String;
+      readonly id: Schema.String;
+    }>>>;
   };
   MutationFailed: {
     requestId: Schema.String;
@@ -1374,6 +1475,10 @@ export declare const mutateRemote: <Name extends string, Input, Output>(mutation
     };
   }[];
   connections: ConnectionChange[];
+  deleted: readonly {
+    readonly entity: string;
+    readonly id: string;
+  }[];
 }, RemoteMutationError, RemoteClient>;
 //#endregion
 //#region src/relation.d.ts
@@ -1458,6 +1563,11 @@ export declare const pageSchema: (item: AnySchema) => AnySchema;
 /** The requirement a nested selection contributes for its relation's target. */
 export declare const relationOf: (selection: Selection<unknown>) => RelationRequirement;
 export declare const Selection: {
+  /**
+   * The Remote Selection of a `foldkit-entity` Selection: the same members, read
+   * from Remote's store. `true` on a relation reads its refs, as it does here.
+   */
+  from: <Name extends string, S extends Schema.Constraint>(selection: Domain.Selection<Name, unknown, S>) => Selection<S["Type"], Name, "entity">;
   /**
    * The fields to read of `entity`. A nested `Selection` on a relation field
    * reads through the ref (or refs, or page of refs) the field holds into the
@@ -1526,7 +1636,25 @@ export interface RefPage<Name extends string, F extends Schema.Struct.Fields = S
   readonly hasNext: boolean;
   readonly hasPrevious: boolean;
 }
+/** The ref codec a `foldkit-entity` relation becomes: one ref, a nullable ref, or an array of refs. */
+type RelationField<Spec> = Spec extends Domain.RelationSpec<infer Target, infer Cardinality, infer Optional> ? Cardinality extends 'many' ? Schema.$Array<Schema.Codec<EntityRef<Target['name']>, string>> : Optional extends true ? Schema.NullOr<Schema.Codec<EntityRef<Target['name']>, string>> : Schema.Codec<EntityRef<Target['name']>, string> : never;
+/**
+ * The fields Remote stores for a `foldkit-entity` Entity: its own fields, its
+ * derived members (the server supplies them like any field), and each relation
+ * as refs.
+ */
+export type FieldsFrom<E> = E extends Domain.Entity<any, infer Fields, infer Relations, infer Derived> ? Fields & { readonly [K in keyof Derived]: Derived[K]['schema']; } & { readonly [K in keyof Relations]: RelationField<Relations[K]>; } : never;
 declare const Entity$1: {
+  /**
+   * The Remote descriptor of a `foldkit-entity` Entity. Relations declared with
+   * `Entity.relate` become ref fields, so the store, the planner, and the server
+   * treat it as they treat an `Entity.make` descriptor.
+   */
+  from: <E extends Domain.AnyEntity>(entity: E & {
+    readonly fields: {
+      readonly id: unknown;
+    };
+  }) => EntityDescriptor<E["name"], FieldsFrom<E>>;
   make: <const Name extends string, const F extends Schema.Struct.Fields & {
     readonly id: Schema.Schema<unknown>;
   }>(name: Name, schema: Schema.Struct<F>) => EntityDescriptor<Name, F>;
@@ -1640,7 +1768,18 @@ export declare const RemotePolicy: {
 };
 //#endregion
 //#region src/index.d.ts
-type EntityName<D> = D extends EntityDescriptor<infer Name, any> ? Name : never;
+/** What a domain registers: a Remote descriptor, or a `foldkit-entity` Entity (read through `Entity.from`). */
+export type EntityLike = EntityDescriptor<any, any> | Domain.AnyEntity;
+/**
+ * What a read selects: a Remote Selection, or a `foldkit-entity` Selection
+ * (read through `Selection.from`).
+ */
+export type EntitySelection<Value, Name extends string> = Selection<Value, Name, 'entity'> | Domain.Selection<Name, unknown, Schema.Constraint & {
+  readonly Type: Value;
+}>;
+type EntityName<D> = D extends {
+  readonly name: infer Name extends string;
+} ? Name : never;
 type QueryName<D> = D extends QueryDescriptor<infer Name, any, any> ? Name : never;
 type MutationName<D> = D extends MutationDescriptor<infer Name, any, any> ? Name : never;
 /**
@@ -1651,7 +1790,7 @@ type MutationName<D> = D extends MutationDescriptor<infer Name, any, any> ? Name
 export type Registered<Name extends string, Names extends string, Kind extends string> = [Name] extends [Names] ? unknown : Invalid<`${Kind} "${Name}" is not registered with this Remote domain`>;
 /** Nothing when a selection is of the query's entity; otherwise a branded failure naming both. */
 export type SelectsEntity<Entity extends string, Of extends string> = [Entity] extends [Of] ? unknown : Invalid<`the selection is of "${Entity}", but the query lists "${Of}"`>;
-export interface RemoteDescriptor<Entities extends readonly EntityDescriptor<any, any>[] = readonly EntityDescriptor<any, any>[], Queries extends readonly QueryDescriptor<any, any, any>[] = readonly QueryDescriptor<any, any, any>[], Mutations extends readonly MutationDescriptor<any, any, any>[] = readonly MutationDescriptor<any, any, any>[]> {
+export interface RemoteDescriptor<Entities extends readonly EntityLike[] = readonly EntityLike[], Queries extends readonly QueryDescriptor<any, any, any>[] = readonly QueryDescriptor<any, any, any>[], Mutations extends readonly MutationDescriptor<any, any, any>[] = readonly MutationDescriptor<any, any, any>[]> {
   readonly entities: Entities;
   readonly queries: Queries;
   readonly mutations: Mutations;
@@ -1701,6 +1840,8 @@ export type SubscriptionEntries<AppModel, Active> = { readonly [K in keyof Activ
   readonly retain: RemoteEntry<AppModel, any>;
 };
 export interface SubscriptionsOptions extends ObserveOptions, LiveOptions, RetainOptions {}
+/** A Remote domain's wiring for an assembly: it routes Remote's Messages into `reduce`, brings its Subscriptions and contract, and requires `RemoteClient` from the runtime's resources Layer. */
+export type RemoteWiring<AppModel> = Wiring<AppModel, RemoteMessage | RemoteMessageInput, RemoteClient>;
 /** What `RemoteDomain.mutate` hands `update`: the Model with the request started, and the Command that settles it. */
 export interface MutationStarted<AppModel> {
   readonly model: AppModel;
@@ -1715,15 +1856,15 @@ export interface MutationStarted<AppModel> {
  * operations over them. Every method compiles to the `Remote.*` function of the
  * same name, which stays exported for tooling, SSR, and tests.
  */
-export interface RemoteDomain<AppModel, Store extends RemoteModel, Entities extends readonly EntityDescriptor<any, any>[], Queries extends readonly QueryDescriptor<any, any, any>[], Mutations extends readonly MutationDescriptor<any, any, any>[]> extends BoundRemote<AppModel, Store, EntityName<Entities[number]>>, RemoteDescriptor<Entities, Queries, Mutations> {
+export interface RemoteDomain<AppModel, Store extends RemoteModel, Entities extends readonly EntityLike[], Queries extends readonly QueryDescriptor<any, any, any>[], Mutations extends readonly MutationDescriptor<any, any, any>[]> extends BoundRemote<AppModel, Store, EntityName<Entities[number]>>, RemoteDescriptor<Entities, Queries, Mutations> {
   /** `Remote.select`: a Projection reading one entity through a selection of a registered entity. */
-  get<Value, Name extends string>(selection: Selection<Value, Name, 'entity'> & Registered<Name, EntityName<Entities[number]>, 'Entity'>, id: string): Projection<AppModel, RemoteData<Value>>;
+  get<Value, Name extends string>(selection: EntitySelection<Value, Name> & Registered<Name, EntityName<Entities[number]>, 'Entity'>, id: string): Projection<AppModel, RemoteData<Value>>;
   /**
    * `get`, and the projection also subscribes to the entity's changes: its
    * requirements are marked `live`, so `subscriptions` derives a live entry for
    * the Surfaces that read it.
    */
-  live<Value, Name extends string>(selection: Selection<Value, Name, 'entity'> & Registered<Name, EntityName<Entities[number]>, 'Entity'>, id: string): Projection<AppModel, RemoteData<Value>>;
+  live<Value, Name extends string>(selection: EntitySelection<Value, Name> & Registered<Name, EntityName<Entities[number]>, 'Entity'>, id: string): Projection<AppModel, RemoteData<Value>>;
   /**
    * A query connection read as a `Page` of items selected of the query's
    * entity: `Initial` until the page and every item's selected fields are
@@ -1766,8 +1907,21 @@ export interface RemoteDomain<AppModel, Store extends RemoteModel, Entities exte
    * mutation sequence unless `options.requestId` is given.
    */
   mutate<M extends MutationDescriptor<any, any, any>>(model: AppModel, mutation: M & Registered<M['name'], MutationName<Mutations[number]>, 'Mutation'>, input: MutationInput<M>, options?: DomainMutateOptions): MutationStarted<AppModel>;
+  /**
+   * What Remote knows of a mutation `mutate` started, by its request id:
+   * pending, applied, or failed with the error the server or transport gave.
+   */
+  mutation(model: AppModel, requestId: string): MutationStatus;
   /** `updateRemote` on the bound slice: reduces one of Remote's Messages, as `RemoteMessage` or as the application's union constructs it. */
   reduce(model: AppModel, message: RemoteMessage | RemoteMessageInput): AppModel;
+  /**
+   * How this domain joins an assembly: it routes Remote's Messages into
+   * `reduce`, brings its Subscriptions and contract, and requires
+   * `RemoteClient` from the runtime's resources Layer. One assembly holds at
+   * most one Remote wiring: every domain claims the same tags, and routing
+   * takes the first claimant.
+   */
+  wiring: <const Active extends Readonly<Record<string, ActiveSurface<AppModel> | Surface<AppModel, any, any, void>>>>(active: Active, options?: SubscriptionsOptions) => RemoteWiring<AppModel>;
   /** `Remote.inspect` of the bound slice. */
   inspect(model: AppModel): RemoteInspection;
 }
@@ -1789,7 +1943,7 @@ export type QueryWindowOptions = {
 };
 export type QueryOptions<Value, Entity extends string, Of extends string = Entity> = {
   /** What to read of each item: a selection of the query's entity (`Of`). */
-  readonly select: Selection<Value, Entity, 'entity'> & SelectsEntity<Entity, Of>;
+  readonly select: EntitySelection<Value, Entity> & SelectsEntity<Entity, Of>;
 } & QueryWindowOptions;
 /** A query connection read as a `Page` of selected items; `ref` is the connection with its first window. */
 export interface QueryProjection<AppModel, Value, Name extends string, Input> extends Projection<AppModel, RemoteData<Page<Value>>> {
@@ -1899,6 +2053,10 @@ export declare const Remote: {
         readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
       }>>;
       connections: Schema.optional<Schema.$Array<Schema.Unknown>>;
+      deleted: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly entity: Schema.String;
+        readonly id: Schema.String;
+      }>>>;
     };
     MutationFailed: {
       requestId: Schema.String;
@@ -1946,7 +2104,7 @@ export declare const Remote: {
    * in one step; the result carries the application-facing operations. The
    * descriptor alone is `Remote.define`, the binding alone `Remote.at`.
    */
-  make: <AppModel, Store extends RemoteModel, const Entities extends readonly EntityDescriptor<any, any>[], const Queries extends readonly QueryDescriptor<any, any, any>[] = readonly [], const Mutations extends readonly MutationDescriptor<any, any, any>[] = readonly []>(config: {
+  make: <AppModel, Store extends RemoteModel, const Entities extends readonly EntityLike[], const Queries extends readonly QueryDescriptor<any, any, any>[] = readonly [], const Mutations extends readonly MutationDescriptor<any, any, any>[] = readonly []>(config: {
     readonly model: ModelRef<AppModel, Store>;
     readonly entities: Entities;
     readonly queries?: Queries;
@@ -1957,7 +2115,7 @@ export declare const Remote: {
    * mutations, plus the submodel. For a domain reused across applications or
    * bound in a test; `Remote.make` is the one-step form.
    */
-  define: <const Entities extends readonly EntityDescriptor<any, any>[], const Queries extends readonly QueryDescriptor<any, any, any>[] = readonly QueryDescriptor<any, any, any>[], const Mutations extends readonly MutationDescriptor<any, any, any>[] = readonly MutationDescriptor<any, any, any>[]>(config: {
+  define: <const Entities extends readonly EntityLike[], const Queries extends readonly QueryDescriptor<any, any, any>[] = readonly QueryDescriptor<any, any, any>[], const Mutations extends readonly MutationDescriptor<any, any, any>[] = readonly MutationDescriptor<any, any, any>[]>(config: {
     readonly entities: Entities;
     readonly queries?: Queries;
     readonly mutations?: Mutations;
@@ -1967,7 +2125,7 @@ export declare const Remote: {
    * registered entity names are carried on the returned value, so `Remote.select`
    * rejects a selection for an entity this domain never declared.
    */
-  at: <AppModel, Store extends RemoteModel, Entities extends readonly EntityDescriptor<any, any>[], Queries extends readonly QueryDescriptor<any, any, any>[], Mutations extends readonly MutationDescriptor<any, any, any>[]>(definition: RemoteDescriptor<Entities, Queries, Mutations>, store: ModelRef<AppModel, Store>) => BoundRemote<AppModel, Store, EntityName<Entities[number]>>;
+  at: <AppModel, Store extends RemoteModel, Entities extends readonly EntityLike[], Queries extends readonly QueryDescriptor<any, any, any>[], Mutations extends readonly MutationDescriptor<any, any, any>[]>(definition: RemoteDescriptor<Entities, Queries, Mutations>, store: ModelRef<AppModel, Store>) => BoundRemote<AppModel, Store, EntityName<Entities[number]>>;
   /**
    * A Projection node that reads a `RemoteData` value out of the store. The id
    * is supplied by the caller, usually from a Surface's params. The assembled
@@ -1975,7 +2133,7 @@ export declare const Remote: {
    * as `Failed` instead of being asserted into `Value`. A present value with a
    * stale field reads as `Refreshing`: an observer is refetching it.
    */
-  select: <AppModel, Store extends RemoteModel, Names extends string, Value, Name extends string>(bound: BoundRemote<AppModel, Store, Names>, selection: Selection<Value, Name, "entity"> & Registered<Name, Names, "Entity">) => (id: string) => Projection<AppModel, RemoteData<Value>>;
+  select: <AppModel, Store extends RemoteModel, Names extends string, Value, Name extends string>(bound: BoundRemote<AppModel, Store, Names>, given: EntitySelection<Value, Name> & Registered<Name, Names, "Entity">) => (id: string) => Projection<AppModel, RemoteData<Value>>;
   /**
    * The pure plan for a projection against a Model: the requirements its
    * remote store does not satisfy, under `options` (freshness, force). A
@@ -2098,6 +2256,10 @@ export declare const Remote: {
       };
     }[];
     connections: ConnectionChange[];
+    deleted: readonly {
+      readonly entity: string;
+      readonly id: string;
+    }[];
   }, RemoteMutationError, RemoteClient>;
   /**
    * Runs a mutation and reconciles its patches into a `RemoteModel` in one step,