@nkzw/fate 0.1.3 → 1.0.0

package/lib/executor-BqwHdN3n.d.mts

@@ -0,0 +1,468 @@
+import { q as QueryProcedure, t as AnyRecord } from "./types-Dz46PXr3.mjs";
+import { z } from "zod";
+
+//#region src/server/dataView.d.ts
+declare const dataViewFieldsKey: unique symbol;
+declare const dataViewBaseKey: unique symbol;
+declare const dataViewListOptionsKey: unique symbol;
+type ResolverSelect<Context> = AnyRecord | ((options: {
+  args?: AnyRecord;
+  context?: Context;
+}) => AnyRecord | void);
+type Bivariant<Fn extends (...args: Array<any>) => unknown> = {
+  bivariance(...args: Parameters<Fn>): ReturnType<Fn>;
+}['bivariance'];
+type ResolverResolve<Item extends AnyRecord, Result, Context> = Bivariant<(item: Item, context?: Context, args?: AnyRecord) => Promise<Result> | Result>;
+type ResolverAuthorize<Item extends AnyRecord, Context> = Bivariant<(item: Item, context?: Context, args?: AnyRecord) => Promise<boolean> | boolean>;
+type FieldSelection = {
+  kind: 'field';
+  path: string;
+};
+type SQLWrapperLike = {
+  getSQL: () => unknown;
+};
+type CountWhere = AnyRecord | SQLWrapperLike | ((columns: Record<string, any>) => SQLWrapperLike | undefined);
+type CountSelection = {
+  kind: 'count';
+  relation: string;
+  where?: CountWhere;
+};
+type ComputedSelection = CountSelection | FieldSelection;
+type ComputedDeps<Select extends Record<string, ComputedSelection> | undefined> = Select extends Record<string, ComputedSelection> ? { [Key in keyof Select]: Select[Key] extends CountSelection ? number : Select[Key] extends FieldSelection ? unknown : never } : Record<string, unknown>;
+type ComputedResolve<Item extends AnyRecord, Result, Select extends Record<string, ComputedSelection> | undefined, Context> = Bivariant<(item: Item, deps: ComputedDeps<Select>, context?: Context, args?: AnyRecord) => Promise<Result> | Result>;
+/**
+ * Field configuration for selecting and resolving a computed value on the backend.
+ */
+type ResolverField<Item extends AnyRecord, Result, Context> = {
+  authorize?: ResolverAuthorize<Item, Context>;
+  kind: 'resolver';
+  resolve: ResolverResolve<Item, Result, Context>;
+  select?: ResolverSelect<Context>;
+};
+type ComputedField<Item extends AnyRecord, Result, Context, Select extends Record<string, ComputedSelection> | undefined = Record<string, ComputedSelection>> = {
+  authorize?: ResolverAuthorize<Item, Context>;
+  kind: 'computed';
+  resolve: ComputedResolve<Item, Result, Select, Context>;
+  select?: Select;
+};
+type DataField<Item extends AnyRecord> = true | ComputedField<Item, any, any, any> | DataView<AnyRecord> | ResolverField<Item, any, any>;
+/**
+ * Recursively serializes resolver results for transport across the network.
+ */
+type Serializable<T> = T extends Date ? string : T extends Array<infer U> ? Array<Serializable<U>> : T extends object ? { [K in keyof T]: Serializable<T[K]> } : T;
+/**
+ * Server-side mirror of a view definition describing how to select and resolve
+ * fields when fulfilling a client request.
+ */
+type DataView<Item extends AnyRecord> = {
+  fields: Record<string, DataField<Item>>;
+  kind?: 'resolver' | 'list';
+  typeName: string;
+};
+type DataViewInternals<Item extends AnyRecord> = {
+  readonly [dataViewBaseKey]?: DataView<Item>;
+  readonly [dataViewListOptionsKey]?: DataViewListOptions;
+};
+/**
+ * Convenience type for declaring the fields of a server data view.
+ */
+type DataViewConfig<Item extends AnyRecord> = Record<string, DataField<Item>>;
+type DataViewOrderDirection = 'asc' | 'desc';
+type DataViewOrderBy = Record<string, DataViewOrderDirection> | Array<Record<string, DataViewOrderDirection>>;
+type DataViewListOptions = {
+  orderBy?: DataViewOrderBy;
+};
+/**
+ * Declares a server data view that exposes an object's available fields to the client.
+ *
+ * @example
+ * const Post = dataView<PostItem>('Post')({
+ *   id: true,
+ *   title: true,
+ * });
+ */
+declare function dataView<Item extends AnyRecord>(typeName: string): <Fields extends DataViewConfig<Item>>(fields: Fields) => DataView<Item> & {
+  readonly [dataViewFieldsKey]: Fields;
+};
+/**
+ * Marks a data view as a list resolver so the server can respond with
+ * connection information.
+ */
+declare const list: <Item extends AnyRecord>(view: DataView<Item>, options?: DataViewListOptions) => DataView<Item> & DataViewInternals<Item> & {
+  kind: "list";
+};
+/**
+ * Declares a resolver field inside a data view, optionally providing a
+ * selection for any data dependencies.
+ */
+declare function resolver<Item extends AnyRecord, Result = unknown, Context = unknown>(config: {
+  authorize?: ResolverAuthorize<Item, Context>;
+  resolve: ResolverResolve<Item, Result, Context>;
+  select?: ResolverSelect<Context>;
+}): ResolverField<Item, Result, Context>;
+declare const field$1: (path: string) => FieldSelection;
+declare const count: (relation: string, options?: {
+  where?: CountWhere;
+}) => CountSelection;
+declare function computed<Item extends AnyRecord, Result = unknown, Context = unknown, Select extends Record<string, ComputedSelection> | undefined = Record<string, ComputedSelection>>(config: {
+  authorize?: ResolverAuthorize<Item, Context>;
+  resolve: ComputedResolve<Item, Result, Select, Context>;
+  select?: Select;
+}): ComputedField<Item, Result, Context, Select>;
+type NonNullish<T> = Exclude<T, null | undefined>;
+type WithNullish<Original, Value> = null extends Original ? undefined extends Original ? Value | null | undefined : Value | null : undefined extends Original ? Value | undefined : Value;
+type ResolverResult<Field> = Field extends ResolverField<AnyRecord, any, any> ? Field['authorize'] extends ResolverAuthorize<any, any> ? Awaited<ReturnType<Field['resolve']>> | null : Awaited<ReturnType<Field['resolve']>> : never;
+type ComputedResult<Field> = Field extends ComputedField<AnyRecord, any, any, any> ? Field['authorize'] extends ResolverAuthorize<any, any> ? Awaited<ReturnType<Field['resolve']>> | null : Awaited<ReturnType<Field['resolve']>> : never;
+type RelationResult<ItemField, V extends DataView<AnyRecord>> = NonNullish<ItemField> extends Array<unknown> ? WithNullish<ItemField, Array<RawDataViewResult<V>>> : WithNullish<ItemField, RawDataViewResult<V>>;
+type ViewFieldConfig<V extends DataView<AnyRecord>> = V extends {
+  readonly [dataViewFieldsKey]: infer Fields;
+} ? Fields : V['fields'];
+type RawFieldResult<Item extends AnyRecord, Key extends PropertyKey, Field extends DataField<Item>> = Field extends true ? Key extends keyof Item ? Item[Key] : never : Field extends DataView<infer ChildItem> ? Key extends keyof Item ? RelationResult<Item[Key], DataView<ChildItem>> : never : Field extends ComputedField<Item, any, any, any> ? ComputedResult<Field> : Field extends ResolverField<Item, any, any> ? ResolverResult<Field> : never;
+type RawDataViewResult<V extends DataView<AnyRecord>> = V extends DataView<infer Item> ? { [K in keyof ViewFieldConfig<V>]: RawFieldResult<Item, K, ViewFieldConfig<V>[K]> } : never;
+type DataViewResult<V extends DataView<AnyRecord>> = Serializable<RawDataViewResult<V>>;
+type WithTypename<T, Name extends string> = T & {
+  __typename: Name;
+};
+/**
+ * Resolved entity type from a data view for client use.
+ */
+type Entity<TView extends DataView<AnyRecord>, Name extends string, Replacements extends Record<string, unknown> = Record<never, never>> = WithTypename<Omit<DataViewResult<TView>, keyof Replacements> & Replacements, Name>;
+type SelectedViewNode<Context> = {
+  args?: AnyRecord;
+  computeds: Map<string, ComputedField<AnyRecord, any, Context>>;
+  path: string | null;
+  relations: Map<string, SelectedViewNode<Context>>;
+  resolvers: Map<string, ResolverField<AnyRecord, any, Context>>;
+  selectedFields: Set<string>;
+  view: DataView<AnyRecord>;
+};
+type ViewPlanNode<Context = unknown> = SelectedViewNode<Context>;
+type ViewPlan<Item extends AnyRecord = AnyRecord, Context = unknown> = {
+  args?: AnyRecord;
+  ctx?: Context;
+  resolve: (item: Item) => Promise<AnyRecord>;
+  resolveMany: (items: Array<AnyRecord>) => Promise<Array<AnyRecord>>;
+  root: ViewPlanNode<Context>;
+  selectedPaths: ReadonlySet<string>;
+  view: DataView<Item>;
+};
+/**
+ * Builds a resolver that applies a client's selection to a server data view,
+ * filtering fields, running nested resolvers, and shaping Prisma selects.
+ */
+declare function createResolver<Item extends AnyRecord, Context = unknown>({
+  args,
+  ctx,
+  select,
+  view
+}: {
+  args?: AnyRecord;
+  ctx?: Context;
+  select: Iterable<string>;
+  view: DataView<Item>;
+}): {
+  resolve: (item: Item) => Promise<AnyRecord>;
+  resolveMany: (items: Array<AnyRecord>) => Promise<Array<AnyRecord>>;
+  select: {
+    [x: string]: unknown;
+  };
+};
+//#endregion
+//#region src/server/connection.d.ts
+type ConnectionInput = z.infer<typeof connectionInput>;
+type AdditionalInputSchema = z.ZodObject<Record<string, z.ZodTypeAny>>;
+type ConnectionInputWithAdditional<TAdditionalInput extends AdditionalInputSchema | undefined> = ConnectionInput & {
+  args?: ConnectionInput['args'] extends infer A ? A & (TAdditionalInput extends AdditionalInputSchema ? z.infer<TAdditionalInput> : object) : never;
+};
+type ConnectionCursor = string;
+/**
+ * Connection item including the node and opaque cursor.
+ */
+type ConnectionItem<TNode> = {
+  cursor: ConnectionCursor;
+  node: TNode;
+};
+/**
+ * Pagination metadata returned with connection lists.
+ */
+type ConnectionPagination = {
+  hasNext: boolean;
+  hasPrevious: boolean;
+  nextCursor?: ConnectionCursor;
+  previousCursor?: ConnectionCursor;
+};
+/**
+ * Connection payload that mirrors what the client expects for list fields.
+ */
+type ConnectionResult<TNode> = {
+  items: Array<ConnectionItem<TNode>>;
+  pagination: ConnectionPagination;
+};
+type ProcedureLike = {
+  input: (schema: any) => {
+    query: (resolver: (options: any) => unknown) => unknown;
+  };
+};
+type ProcedureContext<TProcedure> = TProcedure extends {
+  input: (schema: any) => {
+    query: (resolver: (options: {
+      ctx: infer TContext;
+    }) => unknown) => unknown;
+  };
+} ? TContext : unknown;
+type ConnectionProcedure<TInput, TOutput> = QueryProcedure<{
+  input: TInput;
+  meta: unknown;
+  output: TOutput;
+}>;
+type QueryFn<TContext, TItem, TInput extends ConnectionInput> = (options: {
+  ctx: TContext;
+  cursor?: ConnectionCursor;
+  direction: 'forward' | 'backward';
+  input: TInput;
+  skip?: number;
+  take: number;
+}) => Promise<Array<TItem>>;
+type MapFn<TContext, TItem, TNode, TInput extends ConnectionInput> = (options: {
+  ctx: TContext;
+  input: TInput;
+  items: Array<TItem>;
+}) => Promise<Array<TNode>> | Array<TNode>;
+/**
+ * Zod schema for connection args (`after`, `before`, `first`, `last`, etc.).
+ */
+declare const connectionArgs: z.ZodOptional<z.ZodType<Record<string, unknown>, unknown, z.core.$ZodTypeInternals<Record<string, unknown>, unknown>>>;
+declare const connectionInput: z.ZodObject<{
+  args: z.ZodOptional<z.ZodType<Record<string, unknown>, unknown, z.core.$ZodTypeInternals<Record<string, unknown>, unknown>>>;
+  select: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * Wraps a tRPC procedure to handle cursor-based pagination with consistent
+ * connection semantics.
+ */
+declare function withConnection<TProcedure extends ProcedureLike>(procedure: TProcedure): <TItem, TNode = TItem, TAdditionalInput extends AdditionalInputSchema | undefined = undefined>(options: {
+  defaultSize?: number;
+  getCursor?: (node: TNode) => ConnectionCursor;
+  input?: TAdditionalInput;
+  map?: MapFn<ProcedureContext<TProcedure>, TItem, TNode, ConnectionInputWithAdditional<TAdditionalInput>>;
+  query: QueryFn<ProcedureContext<TProcedure>, TItem, ConnectionInputWithAdditional<TAdditionalInput>>;
+}) => ConnectionProcedure<ConnectionInputWithAdditional<TAdditionalInput>, ConnectionResult<TNode>>;
+//#endregion
+//#region src/server/source.d.ts
+type OrderDirection = 'asc' | 'desc';
+type SourceOrderField = {
+  direction: OrderDirection;
+  field: string;
+};
+type SourceOrder = Array<SourceOrderField>;
+type SourceReference<Item extends AnyRecord = AnyRecord, Adapter = unknown> = SourceDefinition<Item, Adapter> | (() => SourceDefinition<Item, Adapter>);
+type SourceRelationBase<Item extends AnyRecord = AnyRecord, Adapter = unknown> = {
+  foreignKey: string;
+  localKey: string;
+  source: SourceReference<Item, Adapter>;
+};
+type SourceRelation<Item extends AnyRecord = AnyRecord, Adapter = unknown> = SourceRelationBase<Item, Adapter> & ({
+  kind: 'one';
+  orderBy?: never;
+  through?: never;
+} | {
+  kind: 'many';
+  orderBy?: SourceOrder;
+  through?: never;
+} | {
+  kind: 'manyToMany';
+  orderBy?: SourceOrder;
+  through?: {
+    foreignKey: string;
+    localKey: string;
+  };
+});
+type SourceRelationKeyConfig = {
+  foreignKey: string;
+  localKey: string;
+};
+type SourceRelationConfig = Partial<SourceRelationKeyConfig> & {
+  orderBy?: SourceOrder;
+  through?: {
+    foreignKey: string;
+    localKey: string;
+  };
+};
+type SourceDefinition<Item extends AnyRecord = AnyRecord, Adapter = unknown> = {
+  adapter?: Adapter;
+  id: string;
+  orderBy?: SourceOrder;
+  relations?: Record<string, SourceRelation<AnyRecord, Adapter>>;
+  view: DataView<Item>;
+};
+type SourceConfig<Item extends AnyRecord = AnyRecord, Adapter = unknown> = {
+  adapter?: Adapter;
+  id?: string;
+  orderBy?: SourceOrder;
+  relations?: Record<string, SourceRelationConfig>;
+  view: DataView<Item>;
+};
+type SourcePlanNode<Context = unknown, Adapter = unknown> = ViewPlanNode<Context> & {
+  orderBy: SourceOrder;
+  relations: Map<string, SourcePlanNode<Context, Adapter>>;
+  source: SourceDefinition<AnyRecord, Adapter>;
+};
+type SourcePlan<Item extends AnyRecord = AnyRecord, Context = unknown, Adapter = unknown> = Omit<ViewPlan<Item, Context>, 'root'> & {
+  root: SourcePlanNode<Context, Adapter>;
+  source: SourceDefinition<Item, Adapter>;
+};
+type DataViewModule = Record<string, unknown>;
+declare const hasNestedSelection: (select: Iterable<string>, field: string) => boolean;
+declare const getNestedSelection: (select: Iterable<string>, field: string) => Array<string>;
+declare function createSourcePlan<Item extends AnyRecord, Context = unknown, Adapter = unknown>({
+  args,
+  ctx,
+  select,
+  source
+}: {
+  args?: Record<string, unknown>;
+  ctx?: Context;
+  select: Iterable<string>;
+  source: SourceDefinition<Item, Adapter>;
+}): {
+  root: SourcePlanNode<unknown, Adapter>;
+  source: SourceDefinition<Item, Adapter>;
+  args: AnyRecord | undefined;
+  ctx: Context | undefined;
+  resolve: (item: Item) => Promise<AnyRecord>;
+  resolveMany: (items: Array<AnyRecord>) => Promise<Array<AnyRecord>>;
+  selectedPaths: Set<string>;
+  view: DataView<Item>;
+};
+declare function createNestedSourcePlan<Item extends AnyRecord, Context = unknown, Adapter = unknown>({
+  ctx,
+  field,
+  input,
+  source
+}: {
+  ctx?: Context;
+  field: string;
+  input: {
+    args?: Record<string, unknown>;
+    select: Iterable<string>;
+  };
+  source: SourceDefinition<Item, Adapter>;
+}): {
+  root: SourcePlanNode<unknown, Adapter>;
+  source: SourceDefinition<Item, Adapter>;
+  args: AnyRecord | undefined;
+  ctx: Context | undefined;
+  resolve: (item: Item) => Promise<AnyRecord>;
+  resolveMany: (items: Array<AnyRecord>) => Promise<Array<AnyRecord>>;
+  selectedPaths: Set<string>;
+  view: DataView<Item>;
+};
+//#endregion
+//#region src/server/executor.d.ts
+type SourceConnectionHandler<Context, Extra = unknown, Item extends AnyRecord = AnyRecord> = (options: {
+  ctx: Context;
+  cursor?: string;
+  direction: 'backward' | 'forward';
+  extra?: Extra;
+  plan: SourcePlan<Item, Context>;
+  skip?: number;
+  take: number;
+}) => Promise<Array<Item>>;
+type SourceByIdHandler<Context, Extra = unknown, Item extends AnyRecord = AnyRecord> = (options: {
+  ctx: Context;
+  extra?: Extra;
+  id: string;
+  plan: SourcePlan<Item, Context>;
+}) => Promise<Item | null>;
+type SourceByIdsHandler<Context, Extra = unknown, Item extends AnyRecord = AnyRecord> = (options: {
+  ctx: Context;
+  extra?: Extra;
+  ids: Array<string>;
+  plan: SourcePlan<Item, Context>;
+}) => Promise<Array<Item>>;
+type SourceExecutor<Context, Item extends AnyRecord = AnyRecord, ByIdExtra = unknown, ByIdsExtra = unknown, ConnectionExtra = unknown> = {
+  byId?: SourceByIdHandler<Context, ByIdExtra, Item>;
+  byIds?: SourceByIdsHandler<Context, ByIdsExtra, Item>;
+  connection?: SourceConnectionHandler<Context, ConnectionExtra, Item>;
+};
+type SourceRegistry<Context> = Map<SourceDefinition<AnyRecord, unknown>, SourceExecutor<Context, AnyRecord, any, any, any>>;
+declare const resolveSourceByIds: <Context, Item extends AnyRecord>({
+  ctx,
+  extra,
+  ids,
+  input,
+  registry,
+  source
+}: {
+  ctx: Context;
+  extra?: unknown;
+  ids: Array<string>;
+  input: {
+    args?: Record<string, unknown>;
+    select: Iterable<string>;
+  };
+  registry: SourceRegistry<Context>;
+  source: SourceDefinition<Item, unknown>;
+}) => Promise<AnyRecord[]>;
+declare const resolveSourceById: <Context, Item extends AnyRecord>({
+  ctx,
+  extra,
+  id,
+  input,
+  registry,
+  source
+}: {
+  ctx: Context;
+  extra?: unknown;
+  id: string;
+  input: {
+    args?: Record<string, unknown>;
+    select: Iterable<string>;
+  };
+  registry: SourceRegistry<Context>;
+  source: SourceDefinition<Item, unknown>;
+}) => Promise<AnyRecord | null>;
+declare const resolveSourceConnection: <Context, Item extends AnyRecord>({
+  ctx,
+  cursor,
+  direction,
+  extra,
+  input,
+  registry,
+  skip,
+  source,
+  take
+}: {
+  ctx: Context;
+  cursor?: string;
+  direction: "backward" | "forward";
+  extra?: unknown;
+  input: {
+    args?: Record<string, unknown>;
+    select: Iterable<string>;
+  };
+  registry: SourceRegistry<Context>;
+  skip?: number;
+  source: SourceDefinition<Item, unknown>;
+  take: number;
+}) => Promise<AnyRecord[]>;
+declare const refetchSourceById: <Context, Item extends AnyRecord>({
+  ctx,
+  extra,
+  id,
+  input,
+  registry,
+  source
+}: {
+  ctx: Context;
+  extra?: unknown;
+  id: string;
+  input: {
+    args?: Record<string, unknown>;
+    select: Iterable<string>;
+  };
+  registry: SourceRegistry<Context>;
+  source: SourceDefinition<Item, unknown>;
+}) => Promise<AnyRecord | null>;
+//#endregion
+export { DataViewListOptions as A, dataView as B, connectionArgs as C, CountSelection as D, ComputedSelection as E, FieldSelection as F, list as H, ViewPlan as I, computed as L, DataViewOrderDirection as M, DataViewResult as N, CountWhere as O, Entity as P, count as R, ConnectionResult as S, ComputedField as T, resolver as U, field$1 as V, createSourcePlan as _, resolveSourceConnection as a, ConnectionItem as b, SourceConfig as c, SourceOrderField as d, SourcePlan as f, createNestedSourcePlan as g, SourceRelationConfig as h, resolveSourceByIds as i, DataViewOrderBy as j, DataView as k, SourceDefinition as l, SourceRelation as m, refetchSourceById as n, DataViewModule as o, SourcePlanNode as p, resolveSourceById as r, OrderDirection as s, SourceRegistry as t, SourceOrder as u, getNestedSelection as v, withConnection as w, ConnectionPagination as x, hasNestedSelection as y, createResolver as z };

package/lib/index.d.mts

@@ -1,5 +1,67 @@
-import { A as ViewSelection, B as RequestOptions, C as TypeConfig, D as ViewEntity, E as ViewData, F as isViewTag, G as getSelectionPlan, H as Transport, I as FateMutations, L as mutation, M as ViewTag, N as __FateEntityBrand, O as ViewEntityName, P as __FateSelectionBrand, R as FateClient, S as Snapshot, T as View, U as createTRPCTransport, V as createClient, _ as Pagination, a as Entity, b as RootDefinition, c as FateThenable, d as MutationDefinition, f as MutationEntity, g as NodesItem, h as MutationResult, i as ConnectionTag, j as ViewSnapshot, k as ViewRef, l as ListItem, m as MutationInput, n as ConnectionMetadata, o as EntityId, p as MutationIdentifier, r as ConnectionRef, s as FateRoots, t as AnyRecord, u as Mask, v as Request, w as TypeName, x as Selection, y as RequestResult, z as RequestMode } from "./types-HECWvGpd.mjs";
+import { A as ViewRef, B as RequestMode, C as Snapshot, D as ViewData, E as View, F as __FateSelectionBrand, G as createTRPCTransport, H as createClient, I as isViewTag, J as getSelectionPlan, L as FateMutations, M as ViewSnapshot, N as ViewTag, O as ViewEntity, P as __FateEntityBrand, R as mutation, S as Selection, T as TypeName, U as List, V as RequestOptions, W as Transport, _ as NodesItem, a as Entity, b as RequestResult, c as FateThenable, d as MutationDefinition, f as MutationEntity, g as MutationShape, h as MutationResult, i as ConnectionTag, j as ViewSelection, k as ViewEntityName, l as ListItem, m as MutationInput, n as ConnectionMetadata, o as EntityId, p as MutationIdentifier, r as ConnectionRef, s as FateRoots, t as AnyRecord, u as Mask, v as Pagination, w as TypeConfig, x as RootDefinition, y as Request$1, z as FateClient } from "./types-Dz46PXr3.mjs";
+import { C as liveGlobalConnectionTopic, S as liveEntityTopic, a as FateProtocolRequest, i as FateOperation, n as FateLiveConnectionEvent, o as FateProtocolResponse, r as FateLiveEvent, t as isRecord, u as InferFateAPI, x as liveConnectionTopic } from "./record-ENh92gyb.mjs";
+import { n as getListEntries, t as ListEntry } from "./list-4wRNSVgI.mjs";
 
+//#region src/httpTransport.d.ts
+type TransportMutations = Record<string, MutationShape>;
+type EmptyTransportMutations = Record<never, MutationShape>;
+type FateAPIShape = {
+  mutations?: Record<string, MutationShape>;
+};
+type MutationMapFromAPI<API> = API extends {
+  mutations: infer Mutations;
+} ? Mutations extends TransportMutations ? Mutations : EmptyTransportMutations : EmptyTransportMutations;
+type FetchLike = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+type HeadersFactory = HeadersInit | (() => HeadersInit | Promise<HeadersInit>);
+type EventSourceConstructor = new (url: string, options?: {
+  withCredentials?: boolean;
+}) => {
+  addEventListener(type: string, listener: (event: Event) => void): void;
+  close(): void;
+  removeEventListener(type: string, listener: (event: Event) => void): void;
+};
+type LiveConnectorOptions = {
+  eventSource?: EventSourceConstructor;
+  fetch?: typeof fetch;
+  headers?: HeadersFactory;
+  onError?: (error: Error | Event) => void;
+  retryDelay?: number;
+  withCredentials?: boolean;
+};
+type LiveConnectorClient = {
+  subscribe<Data = unknown>(options: {
+    id: string;
+    lastEventId?: string;
+    onEvent?: (event: VoidLiveClientEvent<Data>) => void;
+    topic: string;
+  }): Promise<() => Promise<void> | void>;
+};
+type LiveConnector = (url: string | URL, options?: LiveConnectorOptions) => LiveConnectorClient;
+type VoidLiveClientEvent<Data = unknown> = {
+  data: Data;
+  eventId?: string;
+  subscriptionId: string;
+  topic: string;
+  type?: string;
+};
+declare function createHTTPTransport<API extends FateAPIShape, Mutations extends TransportMutations = MutationMapFromAPI<API>>({
+  eventSource,
+  fetch: fetchImpl,
+  headers,
+  live,
+  liveRetryMs,
+  liveUrl,
+  url
+}: {
+  eventSource?: EventSourceConstructor;
+  fetch?: FetchLike;
+  headers?: HeadersFactory;
+  live?: boolean | LiveConnector;
+  liveRetryMs?: number;
+  liveUrl?: string | URL;
+  url: string | URL;
+}): Transport<Mutations>;
+//#endregion
 //#region src/root.d.ts
 /**
  * Defines a root query for an entity type, capturing the response shape.
@@ -25,4 +87,4 @@ type SelectionValidation<T extends Entity, S extends Selection<T>> = Exclude<key
  */
 declare function view<T extends Entity>(): <S extends Selection<T>>(select: S & SelectionValidation<T, S>) => View<T, S>;
 //#endregion
-export { type ConnectionMetadata, type ConnectionRef, ConnectionTag, type Entity, type EntityId, FateClient, type FateMutations, type AnyRecord as FateRecord, type FateRoots, type FateThenable, type ListItem, type Mask, type MutationDefinition, type MutationEntity, type MutationIdentifier, type MutationInput, type MutationResult, type NodesItem, type Pagination, type Request, type RequestMode, type RequestOptions, type RequestResult, type Selection, type Snapshot, type Transport, type TypeConfig, type View, type ViewData, type ViewEntity, type ViewEntityName, type ViewRef, type ViewSelection, type ViewSnapshot, type ViewTag, clientRoot, createClient, createTRPCTransport, getSelectionPlan, isViewTag, mutation, toEntityId, view };
+export { type ConnectionMetadata, type ConnectionRef, ConnectionTag, type Entity, type EntityId, FateClient, type FateLiveConnectionEvent, type FateLiveEvent, type FateMutations, type FateOperation, type FateProtocolRequest, type FateProtocolResponse, type AnyRecord as FateRecord, type FateRoots, type FateThenable, type InferFateAPI, type List, type ListEntry, type ListItem, type Mask, type MutationDefinition, type MutationEntity, type MutationIdentifier, type MutationInput, type MutationResult, type NodesItem, type Pagination, type Request$1 as Request, type RequestMode, type RequestOptions, type RequestResult, type Selection, type Snapshot, type Transport, type TypeConfig, type View, type ViewData, type ViewEntity, type ViewEntityName, type ViewRef, type ViewSelection, type ViewSnapshot, type ViewTag, clientRoot, createClient, createHTTPTransport, createTRPCTransport, getListEntries, getSelectionPlan, isRecord, isViewTag, liveConnectionTopic, liveEntityTopic, liveGlobalConnectionTopic, mutation, toEntityId, view };