@almadar/core 10.129.0 → 11.0.1

package/dist/{bus-CcbB__oo.d.ts → bus-C0hFDNFR.d.ts}

@@ -1,10 +1,9 @@
 import { z } from 'zod';
-import { b as EventPayloadValue, E as EventPayload, L as LogMeta, R as RuntimeValue, S as SExpr, J as JsonValue } from './expression-D0Fs0riG.js';
-import { F as FieldValue, d as EntityRow, f as ServiceParams, b as OrbitalId, T as TraitId, c as EventId, P as PatternConfig, A as AnyPatternConfig } from './effect-CiEVLsZz.js';
-import { R as RepaintReason, S as ServerEffectResult, H as HopObservation, a as RawUserClaims } from './effect-result-Bebwu9yT.js';
-import { O as OrbitalSchema } from './schema-T5RT5s6H.js';
-import { P as PayloadField } from './orbital-CkFdDS9f.js';
-import { J as JsonSchema } from './types-DGwrltUF.js';
+import { E as EventPayloadValue, c as EventPayload, L as LogMeta, R as RuntimeValue, a as JsonObject, J as JsonValue } from './expression-DirYKz-f.js';
+import { c as EntityRow, i as FieldValue, j as ServiceParams, O as OrbitalId, T as TraitId, b as EventId } from './effect-DZaXwSAz.js';
+import { V as Viewer, H as HostAskCompletion, a as EventResponse, E as EventRequest } from './effect-result-1HpXgeBc.js';
+import { P as PayloadField } from './trait-sRjIivFq.js';
+import { J as JsonSchema } from './types-C6_yPMpn.js';
 
 /**
  * Service Contract Types
@@ -140,7 +139,7 @@ interface StoreFilter<T> {
     value: FieldValue | undefined;
 }
 /** One page of rows from a store: filters, then search, then sort, then the page. */
-interface RowPageRequest<T> {
+type RowPageRequest<T> = {
     /** 1-indexed. */
     page: number;
     pageSize: number;
@@ -150,12 +149,12 @@ interface RowPageRequest<T> {
     searchFields?: readonly string[];
     sortBy?: string;
     sortOrder?: "asc" | "desc";
-}
-interface RowPage<T> {
+};
+type RowPage<T> = {
     rows: T[];
     /** Rows matching the filters and search, across all pages. */
     total: number;
-}
+};
 /** The comparison members of `StoreFilterOp`. */
 type RowCompareOp = Extract<StoreFilterOp, "==" | "!=" | "<" | "<=" | ">" | ">=">;
 /**
@@ -200,25 +199,25 @@ type RowPredicate = {
     value: boolean;
 };
 /** One sort key. Missing and null values sort last in both directions; ties break by `id` ascending. A query with no `order` is ordered by `createdAt` ascending, then `id` (EXEC-FETCH-1). */
-interface RowOrder {
+type RowOrder = {
     field: string;
     direction: "asc" | "desc";
-}
+};
 /**
  * A vector-similarity query: up to `k` rows ordered by descending cosine similarity of `field` to `vector`
  * (EXEC-FETCH-2). A row whose field is absent, null or of zero norm is skipped; a stored vector that is not a
  * `[number]` of the query's length, a zero-norm query or a non-positive `k` fails.
  */
-interface RowNearest {
+type RowNearest = {
     field: string;
     vector: number[];
     k: number;
-}
+};
 /**
  * A pushed-down query: rows matching `policy` AND `filter`, ordered, then windowed. `policy` is the
  * entity's `@read` predicate already specialised to the viewer; `filter` is the call-site filter.
  */
-interface RowQuery {
+type RowQuery = {
     policy?: RowPredicate;
     filter?: RowPredicate;
     /** Absent = `createdAt` ascending, then `id` ascending (EXEC-FETCH-1). */
@@ -230,7 +229,7 @@ interface RowQuery {
     total?: RowTotalMode;
     /** The nearest `k` rows among those `policy` and `filter` admit. Excludes `order`, `offset` and `limit`; `total` is the count returned. */
     nearest?: RowNearest;
-}
+};
 /** The answer to a `RowQuery`: the window, and `total` = every match before the window. */
 type RowQueryPage = RowPage<EntityRow>;
 /** Value kinds a store can compare, in `compare`/`member`/`hasElement` operands. */
@@ -238,14 +237,14 @@ type RowValueKind = "string" | "number" | "boolean" | "date" | "null";
 /** Every operator a `RowPredicate` leaf can carry. */
 type RowOperator = RowCompareOp | "member" | "hasElement" | "contains";
 /** The value kinds one operator accepts on a store; an operator not listed accepts every kind. */
-interface OperatorValueKinds {
+type OperatorValueKinds = {
     operator: RowOperator;
     valueKinds: RowValueKind[];
-}
+};
 /** Whether `total` counts every match (`exact`, the default) or the store may skip the count (`none`). */
 type RowTotalMode = "exact" | "none";
 /** What an adapter's `queryPage` honours for one entity type. */
-interface QueryCapabilities {
+type QueryCapabilities = {
     leaves: ("compare" | "member" | "hasElement" | "contains" | "isNull")[];
     combinators: ("all" | "any" | "not")[];
     compareOps: RowCompareOp[];
@@ -265,12 +264,12 @@ interface QueryCapabilities {
     idsOnly?: boolean;
     /** `nearest` is pushed down: the store ranks by cosine similarity itself (EXEC-FETCH-2). */
     nearest?: boolean;
-}
+};
 /** The answer to a `queryIds`: the window's ids in order, and `total` as in `RowQueryPage`. */
-interface RowIdPage {
+type RowIdPage = {
     ids: string[];
     total: number;
-}
+};
 /**
  * One write. `create` fails (`duplicate-id`) when its id is taken. `upsert` creates the row or replaces it
  * whole by id (`created` / `updated`), keeping the existing `createdAt`. `update` changes an existing row only
@@ -336,12 +335,12 @@ type RowWriteOutcome = {
  * not attempted and have no outcome (a run of plain `persist` effects).
  */
 type RowWriteFailureMode = "atomic" | "stop";
-interface RowWriteBatch {
+type RowWriteBatch = {
     ops: RowWriteOp[];
     onFailure: RowWriteFailureMode;
-}
+};
 /** What an adapter's `writeWhere`/`writeBatch` honours for one entity type. */
-interface WriteCapabilities {
+type WriteCapabilities = {
     /** The guard predicates the store can test; a `Pick` of the query capabilities. */
     guards: Pick<QueryCapabilities, "leaves" | "combinators" | "compareOps">;
     /** `writeWhere` tests the guard and the existence of the row in one step. */
@@ -356,7 +355,7 @@ interface WriteCapabilities {
     rekey?: boolean;
     /** The store commits rows the kernel decided (`commitRows`) and holds no write semantics (EXEC-STORE-5). */
     commitRows?: boolean;
-}
+};
 /** What a compare-and-commit does to one row the kernel read. */
 type RowCommitWrite = {
     kind: "keep";
@@ -367,12 +366,12 @@ type RowCommitWrite = {
     kind: "delete";
 };
 /** One row of a compare-and-commit: the version the kernel read (`null` when absent) and what it writes (EXEC-STORE-5). */
-interface RowCommit {
+type RowCommit = {
     entityType: string;
     id: string;
     expected: EntityRow | null;
     write: RowCommitWrite;
-}
+};
 /**
  * Storage contract for CRUD operations on entity rows. The runtime's effect
  * handlers and every database backend (`@almadar/db`) speak this interface.
@@ -475,12 +474,12 @@ declare function createLazyService<T>(factory: () => T): LazyService<T>;
  * A fetched page by reference: `ids` = the window in order, `total` = matches before the window at
  * dispatch time, `query` = what produced it (its predicates, incl. the @read policy, re-count `total`; order and window are ignored).
  */
-interface RowSetRef {
+type RowSetRef = {
     entityType: string;
     ids: string[];
     total: number;
     query: RowQuery;
-}
+};
 declare const RowSetRefSchema: z.ZodType<RowSetRef>;
 /** Tag property of a `RowSetMarker`; `$`-prefixed so it never collides with a pattern prop key. */
 declare const ROW_SET_MARKER: "$rowSet";
@@ -493,65 +492,195 @@ declare function rowSetMarker(ref: RowSetRef): RowSetMarker;
 declare function isRowSetMarker(value: RuntimeValue): value is RowSetMarker;
 
 /**
- * Declared inputs — the events a client outside the program (an API
- * caller, an agent acting as the user, an MCP client) may send a trait. Authored
- * as `listens { EVENT -> input { … } }`, lowered onto the trait's own
- * `stateMachine.events[]` entry as `input: true`. The one owner of that list:
- * hosts gate their input channel with it, and clients build their tool lists
- * from it. Mirrors `orbital-core/src/runtime/external_inputs.rs`.
+ * Authenticated user context — what `@user.x` resolves against.
+ *
+ * The canonical shape for the `user` binding root, shared by both execution
+ * paths: the JS interpreter resolves `@user.id` through
+ * `EvaluationContext.user`, and the compiled shell emits `user?.id` against the
+ * `UserContext` its `@app/shared` re-exports from here.
+ *
+ * `id` is the field the behavior library reads for ownership scoping and `role`
+ * the field it reads for capability gating. Auth providers that name the subject
+ * `uid` must normalize at their boundary — {@link normalizeUserContext} does that.
  *
  * @packageDocumentation
  */
 
 /**
- * An event written with `listens` addressing (`EVENT`, `Trait.EVENT`,
- * `Orbital.Trait.EVENT`) as a value. A service contract param of this type is
- * checked by `orb validate` against the program's declared external inputs.
+ * What a host's auth provider has resolved the viewer to be — from session
+ * resolution only, never from an interactive sign-in action: `pending` until
+ * the session is known; `anonymous` / `authenticated` once it is; `failed`
+ * when connecting or resolving the session failed; `unavailable` when the host
+ * has no sign-in configured. An `access: authenticated` page mounts only on
+ * `authenticated`.
  */
-type EventAddress = string;
-interface ExternalInput {
-    orbital: string;
-    trait: string;
-    event: string;
-    payloadSchema: PayloadField[];
-    description?: string;
-    synonyms?: string;
-    tier?: string;
-}
-declare function externalInputsOf(schema: OrbitalSchema): ExternalInput[];
+type ViewerAuthority = 'pending' | 'anonymous' | 'authenticated' | 'failed' | 'unavailable';
 /**
- * The entities a `call-service` provider acting as the caller may read: every
- * persisted entity, once, in schema order. Rows stay filtered by each entity's
- * `@read` policy at read time. Mirrors the compiled host's `ENTITY_READS`
- * (`orbital-shell-typescript` `orbital_route.rs`).
+ * The `@user` binding: a {@link Viewer} held flat. Its named fields are the viewer's; each claim is a key holding its
+ * JSON value, readable as `@user.<claim>`. The Rust twin of the conversion is `orbital_core_base::viewer`
+ * (`Viewer::from_user` / `Viewer::to_user`).
  */
-declare function readableEntitiesOf(schema: OrbitalSchema): string[];
-declare function findExternalInput(schema: OrbitalSchema, orbital: string, trait: string, event: string): ExternalInput | undefined;
+type UserContext = Omit<Viewer, 'claims'> & {
+    [key: string]: FieldValue;
+};
+/** Zod twin of the generated {@link Viewer}: the record a `.lolo` program names as `Viewer`. */
+declare const ViewerSchema: z.ZodType<Viewer>;
 /**
- * The declared input a `listens`-addressed event names, resolved from the
- * calling trait's position: `EVENT` is that trait's own, `Trait.EVENT` a trait
- * of its orbital, `Orbital.Trait.EVENT` any orbital. Mirrors the L2 rule in
- * `orbital-compiler` `config_type.rs` `EventRefIndex::check`.
+ * The identity of an unauthenticated viewer. A resolvable object rather than
+ * `undefined` so a role predicate evaluates to a definite `false` instead of
+ * comparing against nothing.
  */
-declare function findInputByAddress(inputs: readonly ExternalInput[], address: string, caller: {
-    orbital: string;
-    trait: string;
-}): ExternalInput | undefined;
-/** A declared payload as the JSON Schema of one object — what a tool-calling model fills. */
-declare function payloadSchemaToJsonSchema(fields: readonly PayloadField[]): JsonSchema;
-/** One way a value misses its declared payload. */
-interface PayloadIssue {
-    readonly path: string;
-    readonly reason: 'missing' | 'unknown' | 'wrong-type' | 'not-one-of';
-    readonly expected?: string;
+declare const ANONYMOUS_USER: UserContext;
+/** Provider-shaped identity claims, before normalization. */
+type RawUserClaims = {
+    id?: string;
+    uid?: string;
+    email?: string | null;
+    name?: string | null;
+    displayName?: string | null;
+    /** Absent or `null` when the token carries none, as the kernel's `Viewer.role` (`Option`). */
+    role?: string | null;
+    permissions?: string[] | null;
+} & {
+    [key: string]: FieldValue;
+};
+/** Zod twin of `RawUserClaims` — the wire shape of `EventRequest.user`. */
+declare const RawUserClaimsSchema: z.ZodType<RawUserClaims>;
+/**
+ * Normalize provider claims into a {@link UserContext}.
+ *
+ * Firebase (and most OIDC providers) name the subject `uid` and the display name
+ * `displayName`, while every `.lolo` behavior reads `@user.id` / `@user.name`.
+ * Without this normalization `@user.id` is `undefined` against a fully
+ * authenticated request and every ownership filter silently matches no rows.
+ * `uid` is preserved so `@user.uid` keeps working.
+ *
+ * Returns `undefined` for absent or subject-less claims so callers can
+ * distinguish "no auth ran" from "anonymous"; use {@link ANONYMOUS_USER} where a
+ * definite identity is required.
+ */
+declare function normalizeUserContext(claims: RawUserClaims | null | undefined): UserContext | undefined;
+/**
+ * Turn a row of an app's `[identity]` entity into a viewer.
+ *
+ * There is no separate persona shape: an identity row IS the persona
+ * (`Almadar_LOLO_Identity.md` §4.3), so this only guards the one field the
+ * behavior library requires — a non-empty string `id` — and passes every other
+ * declared field through as a `@user.<field>` claim. Rows without a usable id
+ * yield `undefined` rather than a persona nobody can own rows as.
+ */
+declare function personaFromIdentityRow(row: Record<string, FieldValue | undefined>): UserContext | undefined;
+/** Look a persona up in a roster by id, or by role when no id matches. */
+declare function findPersonaInRoster(roster: readonly UserContext[], idOrRole: string): UserContext | undefined;
+/**
+ * Resolve a persona spec — a bare id/role (`Person Id 3`, `moderator`) or a full
+ * JSON `UserContext` — into a viewer. This is the `ALMADAR_PERSONA` contract,
+ * shared by every host that presents an app as somebody.
+ *
+ * The roster is the app's OWN declared personas — the seeded rows of its
+ * `[identity]` entity (`Almadar_LOLO_Identity.md` §4.3) — supplied by the host
+ * that has them in hand (the runtime's live store on the interpreter path, the
+ * schema-derived seed rows on the compiled path). There is no global roster:
+ * an app without an `[identity]` entity resolves only JSON-form specs.
+ *
+ * Throws on anything unresolvable rather than returning `undefined`: "no persona"
+ * and "persona silently ignored" look identical on screen, so a bad spec must
+ * fail at boot instead of rendering as nobody.
+ */
+declare function resolvePersonaSpec(spec: string, roster: readonly UserContext[]): UserContext;
+
+declare const ExternalInputSchema: z.ZodObject<{
+    orbital: z.ZodString;
+    trait: z.ZodString;
+    event: z.ZodString;
+    payloadSchema: z.ZodArray<z.ZodType<PayloadField, unknown, z.core.$ZodTypeInternals<PayloadField, unknown>>>;
+    description: z.ZodOptional<z.ZodString>;
+    synonyms: z.ZodOptional<z.ZodString>;
+    tier: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** A declared input: what an outside client may send which trait. */
+type ExternalInput = z.infer<typeof ExternalInputSchema>;
+/** One declared handler: the trait and event a hook name is delivered to, and the event that answers. */
+declare const InboundRouteSchema: z.ZodObject<{
+    name: z.ZodString;
+    orbital: z.ZodString;
+    trait: z.ZodString;
+    event: z.ZodString;
+    answer: z.ZodString;
+    verifies: z.ZodOptional<z.ZodObject<{
+        header: z.ZodString;
+        credential: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type InboundRoute = z.infer<typeof InboundRouteSchema>;
+/** What a host carries of one request: its headers and its body text exactly as received. */
+interface InboundDelivery {
+    headers: Readonly<Record<string, string | undefined>>;
+    rawBody: string;
 }
+/** The HTTP answer the host writes: the status and the JSON text of the body. */
+declare const InboundAnswerSchema: z.ZodObject<{
+    status: z.ZodNumber;
+    body: z.ZodString;
+    stderr: z.ZodOptional<z.ZodString>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+type InboundAnswer = z.infer<typeof InboundAnswerSchema>;
+/** The kernel's answer to "which handler does this hook name": the route, or the answer to write for a hook it does not serve. */
+declare const InboundFoundSchema: z.ZodUnion<readonly [z.ZodObject<{
+    route: z.ZodObject<{
+        name: z.ZodString;
+        orbital: z.ZodString;
+        trait: z.ZodString;
+        event: z.ZodString;
+        answer: z.ZodString;
+        verifies: z.ZodOptional<z.ZodObject<{
+            header: z.ZodString;
+            credential: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    answer: z.ZodObject<{
+        status: z.ZodNumber;
+        body: z.ZodString;
+        stderr: z.ZodOptional<z.ZodString>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>;
+}, z.core.$strip>]>;
+/** An inbound hook event named on a client-facing route: the trait that handles it and the refusal message. */
+declare const InboundOnlySchema: z.ZodNullable<z.ZodObject<{
+    trait: z.ZodString;
+    message: z.ZodString;
+}, z.core.$strip>>;
+/** A list of names (the readable entities). */
+declare const NameListSchema: z.ZodArray<z.ZodString>;
+/** A name, or null when the program has none (the `[identity]` entity, the owner of an entity). */
+declare const OptionalNameSchema: z.ZodNullable<z.ZodString>;
+/** One way a value misses its declared payload (the kernel's `payloadIssues`). */
+declare const PayloadIssueSchema: z.ZodObject<{
+    path: z.ZodString;
+    reason: z.ZodEnum<{
+        unknown: "unknown";
+        missing: "missing";
+        "wrong-type": "wrong-type";
+        "not-one-of": "not-one-of";
+    }>;
+    expected: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type PayloadIssue = z.infer<typeof PayloadIssueSchema>;
+/** The JSON Schema of a declared payload (the kernel's `payloadSchemaToJsonSchema`). */
+declare const PayloadJsonSchemaSchema: z.ZodType<JsonSchema>;
+
 /**
- * Check a value against a declared payload: required fields, primitive and container types,
- * closed value sets, declared object shapes (closed) at any depth. An object field without
- * declared properties stays open; a type with no JSON shape (`node`, an entity name) is not
- * checked beyond its container.
+ * Bus Event Types (framework concept)
+ *
+ * Canonical event shape for Almadar's cross-package event bus. Hoisted into
+ * `@almadar/core` so `@almadar/ui`, `@almadar/runtime`, and generated code
+ * all agree on the same structure. Replaces the previously divergent
+ * `KFlowEvent` (ui) and `RuntimeEvent` (runtime) definitions.
+ *
+ * @packageDocumentation
  */
-declare function payloadIssues(fields: readonly PayloadField[], value: EventPayloadValue): PayloadIssue[];
 
 /**
  * Declared event key. A trait's event names (INIT, SAVE, CLOSE,
@@ -641,7 +770,7 @@ type EventListen<P> = string & {
  * `transition` and `tick` are optional runtime-internal details; most
  * consumers only care about `orbital` and `trait`.
  */
-interface BusEventSource {
+type BusEventSource = {
     orbital?: string;
     /** V4 dual-carry id sibling of `orbital` — stable across an orbital rename. */
     orbitalId?: OrbitalId;
@@ -680,7 +809,7 @@ interface BusEventSource {
     dispatched?: boolean;
     /**
      * The client that originated the dispatch whose effects emitted this
-     * event (from `OrbitalEventRequest.clientId`); absent for headless
+     * event (from `EventRequest.clientId`); absent for headless
      * dispatches (ticks, circuit-router probes, walkers). The server-side
      * listens fan-out skips client-originated cascade emits — under dual
      * execution the originating client relays every cascade hop through the
@@ -701,20 +830,23 @@ interface BusEventSource {
      * host (`setLiveBroadcastSink`) also fans out to every other connected client.
      */
     persistSuccess?: boolean;
-}
+    /**
+     * The row of the emitting trait's entity that made the emit, when the trait's rows are addressed by a `per`
+     * listener. A listener with a `per` clause evaluates its own key; one without ignores this.
+     */
+    instanceKey?: string;
+};
 /** The delivery a transition is processing: `@event`, and one element of `@prevEvents` (Runtime Spec Clause 5.5). */
-interface DeliveryRecord {
+type DeliveryRecord = {
     event: string;
     payload?: EventPayload;
     source: BusEventSource;
-}
+};
 /** A trait's log so far in a dispatch that began elsewhere (`@prevEvents` / `@prevStates`), carried on the request. */
-interface DispatchLog {
+type DispatchLog = {
     prevEvents: DeliveryRecord[];
     prevStates: string[];
-}
-/** The evaluator value of a delivery record: `source` carries exactly the ten `BusEventSource` fields that are set. */
-declare function deliveryRecordValue(record: DeliveryRecord): EventPayload;
+};
 /** Zod twin of `BusEventSource`. */
 declare const BusEventSourceSchema: z.ZodType<BusEventSource, object>;
 /** Zod twin of `DeliveryRecord`. */
@@ -728,7 +860,7 @@ declare const DispatchLogSchema: z.ZodType<DispatchLog, object>;
  * `event.source?.orbital === 'X' && event.source?.trait === 'Y'` without
  * parsing a delimiter.
  */
-interface BusEvent {
+type BusEvent = {
     /** Event type identifier (e.g., 'CartItemLoaded', 'TASK_COMPLETED') */
     type: EventKey;
     /** Optional structured payload */
@@ -737,7 +869,7 @@ interface BusEvent {
     timestamp: number;
     /** Optional origin info for filtering */
     source?: BusEventSource;
-}
+};
 /** Bus event listener callback. */
 type BusEventListener = (event: BusEvent) => void;
 /** Returned by `on()` / `once()` to detach a listener. */
@@ -749,15 +881,15 @@ type Unsubscribe = () => void;
  * generated compiled-path `EmittedEvent` (orbital-shell-typescript's
  * `shared/types.ts`) so the two execution paths agree on one shape.
  */
-interface EmittedEvent {
+type EmittedEvent = {
     event: string;
     payload?: EventPayload;
     source?: BusEventSource;
-}
+};
 /** Zod twin of `EmittedEvent`. Third type param `object`, see `BusEventSourceSchema`. */
 declare const EmittedEventSchema: z.ZodType<EmittedEvent, object>;
 /**
- * Client-side effect tuple shipped in `OrbitalEventResponse.clientEffects`.
+ * Client-side effect tuple shipped in `EventResponse.clientEffectsByTrait`.
  * Restricted to the effect kinds the client knows how to apply to the
  * UI: render-ui (slot mutation, including the `toast` slot that carries
  * what used to be the separate notify effect) and navigate (route change).
@@ -774,138 +906,56 @@ declare const EmittedEventSchema: z.ZodType<EmittedEvent, object>;
  * `(render-ui slot ...)` SExpr without re-validating against the registry —
  * registry validation lives in `orbital validate` / `lolo` parse, not here.
  */
-type ClientRenderUITuple = ['render-ui', string, PatternConfig | null];
+type ClientRenderUITuple = ['render-ui', string, JsonObject | null];
 type ClientNavigateTuple = ['navigate', string] | ['navigate', string, Record<string, string> | null] | ['navigate', string, Record<string, string> | null, {
     crumb?: string;
 }];
 type ClientNavigateBackTuple = ['navigate-back'];
-type ClientEffectTuple = ClientRenderUITuple | ClientNavigateTuple | ClientNavigateBackTuple;
+/** A `runsOn: client` host-port effect (`auth/sign-out`, `audio/*`) the client host answers; its arguments are resolved. */
+type ClientHostAskTuple = ['host-ask', string, JsonValue[]] | ['host-ask', string, JsonValue[], HostAskCompletion];
+
+type ClientEffectTuple = ClientRenderUITuple | ClientNavigateTuple | ClientNavigateBackTuple | ClientHostAskTuple;
 /** Zod twin of `ClientRenderUITuple`. */
-declare const ClientRenderUITupleSchema: z.ZodTuple<[z.ZodLiteral<"render-ui">, z.ZodString, z.ZodType<AnyPatternConfig | null, unknown, z.core.$ZodTypeInternals<AnyPatternConfig | null, unknown>>], null>;
+declare const ClientRenderUITupleSchema: z.ZodTuple<[z.ZodLiteral<"render-ui">, z.ZodString, z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>], null>;
 /** Zod twin of `ClientNavigateTuple` — one variant per fixed arity (2/3/4), unioned. */
 declare const ClientNavigateTupleSchema: z.ZodUnion<readonly [z.ZodTuple<[z.ZodLiteral<"navigate">, z.ZodString], null>, z.ZodTuple<[z.ZodLiteral<"navigate">, z.ZodString, z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>], null>, z.ZodTuple<[z.ZodLiteral<"navigate">, z.ZodString, z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>, z.ZodObject<{
     crumb: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>], null>]>;
 /** Zod twin of `ClientNavigateBackTuple`. */
 declare const ClientNavigateBackTupleSchema: z.ZodTuple<[z.ZodLiteral<"navigate-back">], null>;
+/** Zod twin of `ClientHostAskTuple`. */
+declare const HostAskCompletionSchema: z.ZodObject<{
+    trait: z.ZodString;
+    entityId: z.ZodOptional<z.ZodString>;
+    key: z.ZodOptional<z.ZodString>;
+    success: z.ZodOptional<z.ZodString>;
+    failure: z.ZodOptional<z.ZodString>;
+    onMessage: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+declare const ClientHostAskTupleSchema: z.ZodUnion<readonly [z.ZodTuple<[z.ZodLiteral<"host-ask">, z.ZodString, z.ZodArray<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>], null>, z.ZodTuple<[z.ZodLiteral<"host-ask">, z.ZodString, z.ZodArray<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>, z.ZodObject<{
+    trait: z.ZodString;
+    entityId: z.ZodOptional<z.ZodString>;
+    key: z.ZodOptional<z.ZodString>;
+    success: z.ZodOptional<z.ZodString>;
+    failure: z.ZodOptional<z.ZodString>;
+    onMessage: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>], null>]>;
 /** Zod twin of `ClientEffectTuple`. */
 declare const ClientEffectTupleSchema: z.ZodType<ClientEffectTuple>;
-/**
- * Client → server event dispatch request. The single upstream owner of
- * this shape — both the JS interpreter (`@almadar/runtime`'s
- * `OrbitalEventRequest`) and the compiled path's generated `EventRequest`
- * (orbital-shell-typescript's `shared/types.ts`, mirrored 1:1 in
- * `orbital-core`) carry the same fields, so the two execution paths cannot
- * drift.
- */
-interface OrbitalEventRequest {
-    event: string;
-    /**
-     * V4 dual-carry id sibling of `event` — the fired event's id, when known
-     * (e.g. threaded from a `listens[].triggersId`). Optional; absent means
-     * the state machine dispatches by name only (legacy).
-     */
-    eventId?: EventId;
-    payload?: EventPayload;
-    entityId?: string;
-    /**
-     * Scoped-listen delivery: dispatch to THIS trait only. A listens-matched
-     * trigger is addressed to the listening trait; without this, a trigger
-     * renamed to INIT broadcast orbital-wide and re-ran every trait's
-     * initializer (R-SCOPED-LISTEN-INIT-RENAME-FREEZE re-fire cascade).
-     */
-    targetTrait?: string;
-    /** Provider claims for `@user` bindings, normalized by `normalizeUserContext`. */
-    user?: RawUserClaims;
-    /** Per-tab client identity (UUID) — excludes this request's origin from live-broadcast delivery. */
-    clientId?: string;
-    /**
-     * The viewer's locale (one of the program's declared `locales`): servers
-     * evaluate `i18n/t` and `@locale` with it. Absent means the program's first
-     * declared locale.
-     */
-    locale?: string;
-    /**
-     * Broadcast-class marker (T6, docs/Almadar_Tick_Loop.md §3a): the name of
-     * the tick that emitted this event. Tick-stamped dispatches are
-     * latest-state broadcasts — the client fires them without awaiting the
-     * response, and the server relays them to OTHER tabs coalesced
-     * (newest-per-key) at a snapshot rate instead of 1:1.
-     */
-    tick?: string;
-    /** Emitting trait for a tick-stamped dispatch — builds the relay's BusEventSource (sourceless emits are dropped client-side). */
-    sourceTrait?: string;
-    /**
-     * Run one firing of a tick at the data authority: the trait's tick named `tick` runs its
-     * effects there, as `event` + `targetTrait` runs a transition. A browser-run tick sends one
-     * for its data effects on browser-stored entities (a tick has no event to replay under);
-     * `event` is the tick's synthetic key `$TICK_<tick>`. Owner ruling 2026-10-12 (drift D-1).
-     */
-    runTick?: {
-        trait: string;
-        tick: string;
-    };
-    /**
-     * Stateless addressing: the traits this dispatch runs against, each with
-     * the scope it dispatches `from` (a single-element array is the common
-     * case; a listens fan-out that crosses traits carries more than one). The
-     * compiled server is stateless-per-trait too (`handlers.rs:510-532` seeds
-     * state from `currentState`) — this generalizes that mechanism instead of
-     * the retired single `currentState`/`fields` pair. `event` is the event
-     * that trait fired on in a cascade (the seed's own is `event` above); where
-     * the leg runs follows it.
-     */
-    traits?: Array<{
-        trait: string;
-        from: string;
-        event?: string;
-    }>;
-    /**
-     * The dispatching traits' current `@entity` frames (declared defaults <
-     * fetched row < `[shared]` frame), keyed by trait name. The server layers
-     * each row over the one it resolves via `resolveEntityView` so guards and
-     * effects read the same values the client does.
-     */
-    entityByTrait?: Record<string, EntityRow>;
-    /** The orbital/behavior name this dispatch targets, for stateless multi-orbital addressing. */
-    behavior?: string;
-    /** `@event` for the target when this request continues a dispatch that began on the client; absent = a direct dispatch. */
-    delivery?: DeliveryRecord;
-    /** The target trait's log so far in that dispatch; absent = empty. */
-    dispatchLog?: DispatchLog;
-    /**
-     * A mount batch: one request mounts several traits of the orbital, each
-     * running its OWN lifecycle event, in list order, with the shared
-     * `payload`. `traits`/`entityByTrait` keep their stateless-addressing
-     * meaning; `event` carries the first seed's event.
-     */
-    mount?: MountSeed[];
-    /** Where this leg runs, set by the kernel (EXEC-DIST-6): `browser` for browser-stored rows only, else `server`. */
-    residence?: 'browser' | 'server';
-}
 /** The lifecycle events a trait runs when it enters a page (the first it handles). */
-/**
- * Host-level UI events: handled by the app host, never by a trait, so a
- * component inside a trait scope emits them bare (`UI:NAVIGATE`), not
- * qualified to its trait. `NAVIGATE` moves the router; `SIGN_OUT` ends the
- * viewer's session.
- */
-declare const SYSTEM_UI_EVENTS: readonly ["NAVIGATE", "SIGN_OUT"];
-type SystemUiEvent = (typeof SYSTEM_UI_EVENTS)[number];
-declare function isSystemUiEvent(event: string): event is SystemUiEvent;
 declare const LIFECYCLE_EVENTS: readonly ["INIT", "LOAD", "$MOUNT"];
 /** Wire-only event a client sends when a trait leaves the page; the server stops counting it as mounted. */
 declare const UNMOUNT_EVENT = "$UNMOUNT";
 /** An event key without its `UI:` bus prefix. */
 declare function normalizeEventKey(eventKey: string): string;
-/** The event a tick firing carries on the wire (`OrbitalEventRequest.event` of a `runTick` leg). */
+/** The event a tick firing carries on the wire (`EventRequest.event` of a `runTick` leg). */
 declare function tickEventKey(tickName: string): string;
 type LifecycleEvent = (typeof LIFECYCLE_EVENTS)[number];
 /** One trait of a mount batch and the lifecycle event it runs. */
-interface MountSeed {
+type MountSeed = {
     trait: string;
     event: LifecycleEvent;
-}
+};
 declare const MountSeedSchema: z.ZodObject<{
     trait: z.ZodString;
     event: z.ZodEnum<{
@@ -914,23 +964,19 @@ declare const MountSeedSchema: z.ZodObject<{
         $MOUNT: "$MOUNT";
     }>;
 }, z.core.$strip>;
-/** Structured reason one trait (or the whole dispatch) did not transition. */
-type TransitionRejectionCode = 'no-matching-transition' | 'guard-rejected' | 'no-dispatchable-traits' | 'not-an-external-input' | 'inbound-only-event'
-/** An effect of the trait's transition threw; its later effects did not run. */
- | 'effect-failed';
 /**
  * A request on the outside-client input channel (`POST /:orbital/inputs`): an
  * API caller, an agent acting as the user, an MCP client. Only an event the
  * target trait declares as an external input (`listens { EVENT -> external { … } }`)
  * is dispatched; anything else is refused with `not-an-external-input`.
  */
-interface ExternalInputRequest {
+type ExternalInputRequest = {
     targetTrait: string;
     event: string;
     payload?: EventPayload;
     user?: RawUserClaims;
     entityId?: string;
-}
+};
 type EventStreamItem = {
     type: 'event';
     data: EmittedEvent;
@@ -941,7 +987,7 @@ type EventStreamItem = {
     timestamp: number;
 } | {
     type: 'complete';
-    data: OrbitalEventResponse;
+    data: EventResponse;
     timestamp: number;
 } | {
     type: 'error';
@@ -960,7 +1006,7 @@ declare const EventStreamItemSchema: z.ZodUnion<readonly [z.ZodObject<{
     timestamp: z.ZodNumber;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"complete">;
-    data: z.ZodLazy<z.ZodType<OrbitalEventResponse, object, z.core.$ZodTypeInternals<OrbitalEventResponse, object>>>;
+    data: z.ZodCustom<EventResponse, EventResponse>;
     timestamp: z.ZodNumber;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"error">;
@@ -972,7 +1018,7 @@ declare const EventStreamItemSchema: z.ZodUnion<readonly [z.ZodObject<{
 /** How a host answered a `program/dispatch` event request: the response, or the route's failure code and status. */
 type DispatchRequestOutcome = {
     ok: true;
-    response: OrbitalEventResponse;
+    response: EventResponse;
     streamItems?: EventStreamItem[];
 } | {
     ok: false;
@@ -997,15 +1043,16 @@ interface ServiceHostPorts {
     inputs(): ExternalInput[];
     /** The entities `read` serves: every persisted entity of the program (`readableEntitiesOf`). */
     readableEntities(): string[];
-    dispatchInput(orbital: string, request: Omit<ExternalInputRequest, 'user'>): Promise<OrbitalEventResponse>;
+    dispatchInput(orbital: string, request: Omit<ExternalInputRequest, 'user'>): Promise<EventResponse>;
     read(entity: string): Promise<EntityRow[]>;
     /**
      * A `program/dispatch` event request (owner, 2026-10-21): dispatch `request` on `orbital` as the HTTP events
-     * route does (`input: true` admits only a declared external input, as the inputs route). `request.user` is the
-     * dispatch's viewer when the call names one. A host that does not serve event requests leaves it out.
+     * route does (`input: true` admits only a declared external input, as the inputs route). `request` is what the kernel
+     * parsed (`EventRequest::from_dispatch`); its `user` is the dispatch's viewer when the call names one.
+     * A host that does not serve event requests leaves it out.
      */
     supportsDispatchStream?: true;
-    dispatchRequest?(orbital: string, request: OrbitalEventRequest, input: boolean, stream?: boolean): Promise<DispatchRequestOutcome>;
+    dispatchRequest?(orbital: string, request: EventRequest, input: boolean, stream?: boolean): Promise<DispatchRequestOutcome>;
     /** A `program/dispatch { inbound }` delivery through the inbound route, credential check and answer path. */
     deliverInbound?(name: string, delivery: {
         headers: Readonly<Record<string, string>>;
@@ -1016,6 +1063,8 @@ interface ServiceHostPorts {
     }>;
     /** The host's last `steps` traced dispatch steps, oldest first; a host that keeps no trace leaves it out. */
     trace?(steps: number): JsonValue[];
+    /** A `program/resolve-rows` ask: `reference` resolved for the identity bound to `clientId`'s session (none: the anonymous viewer), `@read` applied by the kernel's one resolver. */
+    resolveRows?(reference: RowSetRef, clientId: string | undefined): Promise<RowQueryPage>;
     /**
      * Deliver one message of the running call to the caller's tab, live, as the
      * call site's `emit.onMessage` event source-stamped to the caller. A no-op
@@ -1023,139 +1072,6 @@ interface ServiceHostPorts {
      */
     message(payload: EventPayload): void;
 }
-/**
- * Why a dispatched trait (or the whole request) did not transition —
- * G-RUNTIME-023. `statesDeclaringEvent` lists the states whose transition
- * table DOES declare the event, which makes a stale client-supplied `from`
- * self-explanatory in a stateless response.
- */
-interface TransitionRejection {
-    code: TransitionRejectionCode;
-    trait?: string;
-    from?: string;
-    event?: string;
-    statesDeclaringEvent?: string[];
-    transition?: string;
-    guard?: unknown;
-    /** `effect-failed`: the thrown error's message. */
-    error?: string;
-}
-/** How one authored effect of an executed hop ran. */
-type HopEffectStatus = 'executed' | 'failed' | 'skipped';
-/** One authored effect of a hop: its operator head, its arguments as authored, and how it ran. */
-interface HopEffect {
-    type: string;
-    args: SExpr[];
-    status: HopEffectStatus;
-    error?: string;
-}
-/**
- * One executed hop of a dispatch (the seed's, a same-trait cascade step's, a listener delivery's), in
- * dispatch order: what a `TransitionObserver` hears. `guardResult` is `true` when the fired arm's guard
- * held and absent for an unguarded arm.
- */
-interface TransitionHop {
-    trait: string;
-    from: string;
-    to: string;
-    event: string;
-    /** The arm that fired, by its position among the state's arms for the event. */
-    firedArm?: number;
-    guardResult?: boolean;
-    effects: HopEffect[];
-    /** The payload and `@entity` before and after the hop, when a verifier asked the kernel to record them. */
-    observed?: HopObservation;
-}
-/**
- * One client effect paired with the trait that produced it and, when the
- * producer knows it, the transition that fired: that transition's own event
- * key (for a listens delivery, the triggered event, not the source emit) and
- * the state it fired from. A client stamps render provenance from these.
- */
-interface ClientEffectByTrait {
-    traitName: string;
-    effect: ClientEffectTuple;
-    event?: string;
-    fromState?: string;
-    /** The payload an embedded `@callsitePayload` child was composed with — sticky, so a later repaint of the child resolves its captures the same way. */
-    callsitePayload?: EventPayload;
-    /** Set when the paint is a repaint a renderer must act on beyond the content: the rows a reference in it points at changed (EXEC-RENDER-3). */
-    repaint?: RepaintReason;
-}
-/**
- * Server → client event dispatch response. Mirrors the compiled path's
- * generated `EventResponse` (orbital-shell-typescript's `shared/types.ts`,
- * mirrored 1:1 in `orbital-core`'s `effects/response.rs`) — canonical = the
- * TS runtime's `OrbitalEventResponse` (`@almadar/runtime`'s
- * `OrbitalServerRuntime.ts`).
- */
-interface OrbitalEventResponse {
-    success: boolean;
-    transitioned: boolean;
-    /** Whole-orbital state snapshot, keyed by trait name. */
-    states: Record<string, string>;
-    /**
-     * Events emitted during processing, in declaration order. ALWAYS present
-     * (`[]` when none) — the compiled Hono path used to omit this field on a
-     * no-cascade response, which forced every consumer to optional-chain a
-     * field that is really always there.
-     *
-     * Each entry carries a `source: BusEventSource` so the client-side
-     * ServerBridge can re-broadcast on the qualified `UI:Orbital.Trait.EVENT`
-     * bus key. Without source the re-broadcast skips the entry and downstream
-     * listeners (e.g. ContactBrowse waiting for ContactLoaded after a fetch)
-     * never fire — the dashboard-layout that ContactLoaded renders disappears.
-     */
-    emittedEvents: EmittedEvent[];
-    /** Fetched/queried entity collections this response carries, keyed by entity name. */
-    data?: Record<string, EntityRow[]>;
-    /** Fetched pages delivered by reference (`deliver: ids`), keyed by entity name. */
-    dataRefs?: Record<string, RowSetRef>;
-    /**
-     * `@entity` fields this transition's server-side `set` effects wrote,
-     * post-effect, keyed by trait name — the response-side twin of the
-     * request's `entityByTrait`. The client merges them over its own effect
-     * results (server wins).
-     */
-    entityByTrait?: Record<string, EntityRow>;
-    /** Client-side effects to execute (render-ui, navigate). */
-    clientEffects?: ClientEffectTuple[];
-    /**
-     * Same effects as `clientEffects`, paired with the producing trait name.
-     * Consumers that need per-trait attribution (e.g. `<TraitFrame>` resolving
-     * `@trait.X` bindings) read from this field; legacy consumers ignore it
-     * and continue with the flat `clientEffects` array unchanged.
-     *
-     * Same length and ordering as `clientEffects`; entries are 1:1 by index.
-     */
-    clientEffectsByTrait?: ClientEffectByTrait[];
-    /** Results from server-side effects (persist, call-service, set). */
-    effectResults?: ServerEffectResult[];
-    /** Guard that failed, addressed as `"<Trait>.<event>"`, for debugging. */
-    guardFailed?: string;
-    /**
-     * Structured per-trait / per-request rejection reasons (G-RUNTIME-023) —
-     * present only when nothing transitioned. Supersedes the `guardFailed`
-     * string (kept for backcompat) with a machine-readable shape.
-     */
-    rejections?: TransitionRejection[];
-    /**
-     * Names of traits DROPPED from a stateless cascade because the cross-trait
-     * worklist hit its safety-valve cap (G-RUNTIME-027) — the response's
-     * states/effects/entity rows are INCOMPLETE for these traits. Absent when
-     * the whole worklist ran. Surfaced so the truncation is observable
-     * (previously the tail of any page over ~20 traits silently never
-     * executed).
-     */
-    cascadeTruncated?: string[];
-    /** Every executed hop of the dispatch, in order (the server role's trace); absent when none ran. */
-    transitions?: TransitionHop[];
-    error?: string;
-}
-/** Zod twin of `OrbitalEventRequest`. Third type param `object`, see `BusEventSourceSchema`. */
-declare const OrbitalEventRequestSchema: z.ZodType<OrbitalEventRequest, object>;
-/** Zod twin of `OrbitalEventResponse`. Third type param `object`, see `BusEventSourceSchema`. */
-declare const OrbitalEventResponseSchema: z.ZodType<OrbitalEventResponse, object>;
 /**
  * Where circuit state lives between events (`docs/Almadar_Runtime_Stateless_Stateful_PLAN.md` §1a):
  * `'stateless'` = the client carries it on every request, `'stateful'` = the server holds it.
@@ -1193,14 +1109,6 @@ interface LiveBroadcastItem {
 }
 /** Zod twin of `LiveBroadcastItem`. Third type param `object`, see `BusEventSourceSchema`. */
 declare const LiveBroadcastItemSchema: z.ZodType<LiveBroadcastItem, object>;
-/** @deprecated use {@link OrbitalEventRequest}. Kept until every referrer migrates (Program A wave A8). */
-type EventDispatchRequest = OrbitalEventRequest;
-/** @deprecated use {@link OrbitalEventRequestSchema}. */
-declare const EventDispatchRequestSchema: z.ZodType<OrbitalEventRequest, object, z.core.$ZodTypeInternals<OrbitalEventRequest, object>>;
-/** @deprecated use {@link OrbitalEventResponse}. Kept until every referrer migrates (Program A wave A8). */
-type EventDispatchResponse = OrbitalEventResponse;
-/** @deprecated use {@link OrbitalEventResponseSchema}. */
-declare const EventDispatchResponseSchema: z.ZodType<OrbitalEventResponse, object, z.core.$ZodTypeInternals<OrbitalEventResponse, object>>;
 
-export { EventStreamItemSchema as A, LIFECYCLE_EVENTS as J, LiveBroadcastItemSchema as N, MountSeedSchema as Q, OrbitalEventRequestSchema as S, OrbitalEventResponseSchema as T, OrbitalRegisterResponseSchema as V, ROW_SET_MARKER as _, createLazyService as aB, createTypedEventBus as aC, deliveryRecordValue as aD, externalInputsOf as aE, findExternalInput as aF, findInputByAddress as aG, isRowSetMarker as aH, isSystemUiEvent as aI, normalizeEventKey as aJ, payloadIssues as aK, payloadSchemaToJsonSchema as aL, readableEntitiesOf as aM, rowSetMarker as aN, tickEventKey as aO, RowSetRefSchema as ac, SYSTEM_UI_EVENTS as aj, ServerTopologySchema as al, UNMOUNT_EVENT as ay, BusEventSourceSchema as e, ClientEffectTupleSchema as g, ClientNavigateBackTupleSchema as i, ClientNavigateTupleSchema as k, ClientRenderUITupleSchema as m, DeliveryRecordSchema as n, DispatchLogSchema as p, EmittedEventSchema as r, EventDispatchRequestSchema as u, EventDispatchResponseSchema as w };
-export type { RowCommit as $, BusEvent as B, ClientEffectTuple as C, DeliveryRecord as D, EventStreamItem as E, ExternalInput as F, ExternalInputRequest as G, HopEffect as H, HopEffectStatus as I, LazyService as K, LiveBroadcastItem as L, LifecycleEvent as M, OrbitalEventRequest as O, MountSeed as P, OperatorValueKinds as R, OrbitalRegisterResponse as U, PayloadIssue as W, PersistActionName as X, PersistenceAdapter as Y, QueryCapabilities as Z, OrbitalEventResponse as a, RowCommitWrite as a0, RowCompareOp as a1, RowIdPage as a2, RowOperator as a3, RowOrder as a4, RowPage as a5, RowPageRequest as a6, RowPredicate as a7, RowQuery as a8, RowQueryPage as a9, WriteCapabilities as aA, RowSetMarker as aa, RowSetRef as ab, RowTotalMode as ad, RowValueKind as ae, RowWriteBatch as af, RowWriteFailureMode as ag, RowWriteOp as ah, RowWriteOutcome as ai, ServerTopology as ak, ServiceAction as am, ServiceActionName as an, ServiceContract as ao, ServiceEvents as ap, ServiceHostPorts as aq, StoreContract as ar, StoreFilter as as, StoreFilterOp as at, SystemUiEvent as au, TransitionHop as av, TransitionRejection as aw, TransitionRejectionCode as ax, Unsubscribe as az, EmittedEvent as b, BusEventListener as c, BusEventSource as d, ClientEffectByTrait as f, ClientNavigateBackTuple as h, ClientNavigateTuple as j, ClientRenderUITuple as l, DispatchLog as o, DispatchRequestOutcome as q, EventAddress as s, EventDispatchRequest as t, EventDispatchResponse as v, EventEmit as x, EventKey as y, EventListen as z };
+export { PayloadJsonSchemaSchema as $, ANONYMOUS_USER as A, InboundFoundSchema as G, HostAskCompletionSchema as H, InboundOnlySchema as J, InboundRouteSchema as M, LIFECYCLE_EVENTS as N, LiveBroadcastItemSchema as Q, MountSeedSchema as S, NameListSchema as T, OptionalNameSchema as W, OrbitalRegisterResponseSchema as Y, PayloadIssueSchema as _, ROW_SET_MARKER as a3, RawUserClaimsSchema as a5, UNMOUNT_EVENT as aA, ViewerSchema as aD, createLazyService as aF, createTypedEventBus as aG, findPersonaInRoster as aH, isRowSetMarker as aI, normalizeEventKey as aJ, normalizeUserContext as aK, personaFromIdentityRow as aL, resolvePersonaSpec as aM, rowSetMarker as aN, tickEventKey as aO, RowSetRefSchema as aj, ServerTopologySchema as ar, BusEventSourceSchema as d, ClientEffectTupleSchema as e, ClientHostAskTupleSchema as g, ClientNavigateBackTupleSchema as i, ClientNavigateTupleSchema as k, ClientRenderUITupleSchema as m, DeliveryRecordSchema as n, DispatchLogSchema as p, EmittedEventSchema as r, EventStreamItemSchema as v, ExternalInputSchema as y, InboundAnswerSchema as z };
+export type { BusEvent as B, ClientEffectTuple as C, DeliveryRecord as D, EventStreamItem as E, InboundDelivery as F, InboundAnswer as I, InboundRoute as K, LiveBroadcastItem as L, LazyService as O, LifecycleEvent as P, MountSeed as R, UserContext as U, OperatorValueKinds as V, OrbitalRegisterResponse as X, PayloadIssue as Z, EmittedEvent as a, PersistActionName as a0, PersistenceAdapter as a1, QueryCapabilities as a2, RawUserClaims as a4, RowCommit as a6, RowCommitWrite as a7, RowCompareOp as a8, RowIdPage as a9, Unsubscribe as aB, ViewerAuthority as aC, WriteCapabilities as aE, RowOperator as aa, RowOrder as ab, RowPage as ac, RowPageRequest as ad, RowPredicate as ae, RowQuery as af, RowQueryPage as ag, RowSetMarker as ah, RowSetRef as ai, RowTotalMode as ak, RowValueKind as al, RowWriteBatch as am, RowWriteFailureMode as an, RowWriteOp as ao, RowWriteOutcome as ap, ServerTopology as aq, ServiceAction as as, ServiceActionName as at, ServiceContract as au, ServiceEvents as av, ServiceHostPorts as aw, StoreContract as ax, StoreFilter as ay, StoreFilterOp as az, BusEventListener as b, BusEventSource as c, ClientHostAskTuple as f, ClientNavigateBackTuple as h, ClientNavigateTuple as j, ClientRenderUITuple as l, DispatchLog as o, DispatchRequestOutcome as q, EventEmit as s, EventKey as t, EventListen as u, ExternalInput as w, ExternalInputRequest as x };