Client API

Generated public TypeScript reference for @relkit/client.

Common APIs

• createClient

For configuration and examples, read generated clients, streaming, jobs.

For a complete workflow, follow connect react.

Frontend usage

Connect a React frontend shows the client side of this capability.

Public imports

• @relkit/client — 11 exports
• @relkit/client/server — 1 exports
• @relkit/client/server/tanstack-query — 4 exports
• @relkit/client/tanstack-query — 2 exports
• @relkit/client/react — 117 exports
• @relkit/client/jobs — 60 exports
• @relkit/client/build/next — 1 exports
• @relkit/client/build/vite — 2 exports

All exported APIs

Names link to their complete contracts. Re-exports share their original contract; legacy exports keep their separate identity. Examples link to the API’s inline sample, a maintained repository usage, or the shared module walkthrough.

manifest.ts

readPublicFingerprint

Reads the generated manifest fingerprint and rejects malformed generated output.

Signature

declare const readPublicFingerprint: (root?: string) => string;

Source

next.ts

withRelkit

Adds the generated public fingerprint and linked-workspace root to Next configuration.

Signature

declare const withRelkit: (config?: NextConfig, options?: { readonly root?: string }) => NextConfig;

Source

next.types.ts

The Next configuration shape accepted and returned by the client build adapter.

NextConfig (type alias)

The Next configuration shape accepted and returned by the client build adapter.

Signature

type NextConfig = Readonly<Record<string, unknown>> & {
  readonly env?: Readonly<Record<string, string | undefined>>;
  readonly turbopack?: Readonly<Record<string, unknown>> & { readonly root?: string };
};

Source

vite.ts

RelkitVitePlugin

Signature

declare const RelkitVitePlugin: RelkitVitePlugin;

Source

relkit

Creates the Vite adapter that defines the generated client fingerprint.

Signature

declare const relkit: (options?: { readonly root?: string }) => RelkitVitePlugin;

Source

vite.types.ts

The minimal Vite plugin contract defining the generated client fingerprint.

RelkitVitePlugin (interface)

The minimal Vite plugin contract defining the generated client fingerprint.

Signature

export interface RelkitVitePlugin {
  readonly name: "relkit";
  config(): {
    readonly define: Readonly<Record<string, string>>;
  };
}

Source

client-owner.ts

acquireClientOwner

Acquires one synchronous Layer context and an independently closable fiber scope.

Signature

declare const acquireClientOwner: <Service, Shape>(
  layer: Layer.Layer<Service>,
  key: Context.Key<Service, Shape>,
) => ClientOwner<Shape>;

Source

client-owner.types.ts

ClientOwner (interface)

Once-acquired domain context with independent asynchronous lifetime ownership.

Signature

export interface ClientOwner<Shape> {
  /** Stable service identity; invoking it does not acquire another Layer. */
  readonly service: Shape;
  /** Runs one child owned by this context and joins its scoped finalizers.
   * @typeParam A - Successful operation result.
   * @typeParam E - Original typed failure, preserved at the Promise boundary.
   * @param effect - Lazy resource-owning service workflow.
   * @returns The original result or rejection after child cleanup. */
  readonly run: <A, E>(effect: Effect.Effect<A, E>) => Promise<A>;
  /** Interrupts active children and joins acquired-resource finalizers once.
   * @returns The same settlement Promise on concurrent or repeated closure. */
  readonly close: () => Promise<void>;
}

Source

client-runtime.ts

runClient

Runs fully provided client work at a Promise adapter, retaining original failures.

Signature

declare const runClient: <A, E>(effect: Effect.Effect<A, E>, signal?: AbortSignal) => Promise<A>;

Source

runClientSync

Runs a fully provided synchronous state decision at its compatibility edge.

Signature

declare const runClientSync: <A, E>(effect: Effect.Effect<A, E>) => A;

Source

index.ts

Exposes transport clients and the generated contract augmentation authority. Install @relkit/client for HTTP/WebSocket clients; React and TanStack peers are needed only by their explicit integration entrypoints.

ClientHeaders

Signature

declare const ClientHeaders: ClientHeaders;

Source

ClientHeadersInit

Signature

declare const ClientHeadersInit: ClientHeadersInit;

Source

CreateAutoClientOptions

Signature

declare const CreateAutoClientOptions: CreateAutoClientOptions;

Source

CreateClientOptions

Signature

declare const CreateClientOptions: CreateClientOptions;

Source

CreateWebSocketClientOptions

Signature

declare const CreateWebSocketClientOptions: CreateWebSocketClientOptions;

Source

DefaultContract (type alias)

Contract inferred from the preserved public registry augmentation.

Signature

type DefaultContract = DefaultContractRegistry extends {
  readonly contract: infer Contract extends RouterContract;
}
  ? Contract
  : RouterContract;

Source

DefaultContractRegistry (interface)

Original augmentation authority; generated applications extend this exact module.

Signature

export interface DefaultContractRegistry {}

Source

ORPCError

Signature

declare const ORPCError: typeof ORPCError;

Source

createAutoClient

Signature

declare const createAutoClient: <Contract extends RouterContract = RouterContract>(
  options: CreateAutoClientOptions,
) => RouterContractClient<Contract>;

Source

createClient

Signature

declare const createClient: <Contract extends RouterContract = RouterContract>(
  options: CreateClientOptions,
) => RouterContractClient<Contract>;

Source

createWebSocketClient

Signature

declare const createWebSocketClient: <Contract extends RouterContract = RouterContract>(
  options: CreateWebSocketClientOptions,
) => RouterContractClient<Contract>;

Source

index.types.ts

Native header inputs accepted without copying mutable Headers at construction.

ClientHeaders (type alias)

Static headers or a provider evaluated for each future request.

Signature

type ClientHeaders = ClientHeadersInit | (() => ClientHeadersInit | Promise<ClientHeadersInit>);

Source

ClientHeadersInit (type alias)

Native header inputs accepted without copying mutable Headers at construction.

Signature

type ClientHeadersInit =
  Headers | Readonly<Record<string, string>> | readonly (readonly [string, string])[];

Source

CreateAutoClientOptions (interface)

Combined transport options; fallback applies only to WebSocket establishment failure.

Signature

export interface CreateAutoClientOptions
  extends CreateClientOptions, CreateWebSocketClientOptions {}

Source

CreateClientOptions (interface)

HTTP client configuration preserving browser credentials and caller transport overrides.

Signature

export interface CreateClientOptions {
  /** Application HTTP origin and optional base path. */
  readonly baseUrl: string;
  /** Request-time headers, including asynchronous providers. */
  readonly headers?: ClientHeaders;
  /** Browser fetch credentials policy; the live adapter supplies the existing default. */
  readonly credentials?: RequestInit["credentials"];
  /** Borrowed fetch implementation used for all HTTP requests. */
  readonly fetch?: typeof globalThis.fetch;
}

Source

CreateWebSocketClientOptions (interface)

WebSocket configuration whose establishment timeout leaves accepted streams independent.

Signature

export interface CreateWebSocketClientOptions {
  /** Application origin converted to its corresponding WebSocket protocol. */
  readonly baseUrl: string;
  /** Maximum time allowed for initial connection establishment. */
  readonly establishmentTimeoutMs?: number;
  /** Headers retained with the existing WebSocket transport contract. */
  readonly headers?: ClientHeaders;
  /** Borrowed WebSocket constructor, or the browser implementation when omitted. */
  readonly websocket?: typeof WebSocket;
}

Source

content.service.ts

JobContent (class)

Named job content lifetime and bounded continuity contract.

Signature

declare class JobContent

Source

JobContentLive

Provides named-content acquisition with scoped native pulls and bounded continuity.

See

• packages/client/tests/compatibility/jobs-watch.test.ts for continuity assertions.

Signature

declare const JobContentLive: Layer.Layer<JobContent, never, never>;

Source

content.types.ts

JobContentService (interface)

Named stream acquisition, continuity and memory-bound ownership.

Signature

export interface JobContentService {
  /** Acquires named content and transfers native cleanup to the returned iterator.
   * @param client - Borrowed generated job transport.
   * @param job - Declared job key.
   * @param options - Existing stream identity, cursor, cancellation and bounds.
   * @returns Lazy acquisition of bounded frames or the original native failure. */
  readonly open: (
    client: unknown,
    job: string,
    options: JobStreamOptions,
  ) => Effect.Effect<AsyncIterable<NamedStreamFrame<JsonValue>>, unknown>;
}

Source

contracts.types.ts

JobCancelInput (type alias)

Cancellation request with caller-owned operation identity.

Signature

type JobCancelInput = {
  readonly runId: string;
  readonly operationId: OperationId | string;
  readonly reason?: string;
  readonly expectedIdentity?: ExpectedClientIdentity;
};

Source

JobClientField (type alias)

Client-visible run projection fields.

Signature

type JobClientField = "status" | "input" | "progress" | "output" | "error";

Source

JobGetInput (type alias)

Authoritative run lookup and expected application identity.

Signature

type JobGetInput = {
  readonly runId: string;
  readonly expectedIdentity?: ExpectedClientIdentity;
};

Source

JobListInput (type alias)

Job-specific listing filters and expected application identity.

Signature

type JobListInput = {
  readonly query?: JobListQuery;
  readonly expectedIdentity?: ExpectedClientIdentity;
};

Source

JobListQuery (type alias)

Filters accepted by a generated job-specific list; ownership is server-derived.

Signature

type JobListQuery = Omit<RunListQuery, "jobId" | "service">;

Source

JobProcedureContract (interface)

Generated finite procedure shape preserving input, output and failure inference.

Signature

export interface JobProcedureContract<Input, Output, Failure = Error> {
  readonly input: Input;
  readonly output: Output;
  readonly error: Failure;
  readonly operation: "query" | "mutation";
  readonly stream: false;
}

Source

JobRetryInput (type alias)

Retry request with caller-owned operation identity.

Signature

type JobRetryInput = {
  readonly runId: string;
  readonly operationId: OperationId | string;
  readonly expectedIdentity?: ExpectedClientIdentity;
};

Source

JobStreamInput (type alias)

Named content observation cursor and expected application identity.

Signature

type JobStreamInput<StreamName extends string = string> = {
  readonly runId: string;
  readonly name: StreamName;
  readonly after?: string;
  readonly expectedIdentity?: ExpectedClientIdentity;
};

Source

JobStreamProcedureContract (interface)

Generated stream procedure shape preserving item and failure inference.

Signature

export interface JobStreamProcedureContract<Input, Item, Failure = Error> {
  readonly input: Input;
  readonly output: AsyncIterable<Item>;
  readonly item: Item;
  readonly error: Failure;
  readonly operation: "query" | "mutation";
  readonly stream: true;
}

Source

JobTriggerInput (type alias)

Job trigger request and expected application identity.

Signature

type JobTriggerInput<Input> = {
  readonly input: Input;
  readonly options?: JobTriggerOptions;
  readonly expectedIdentity?: ExpectedClientIdentity;
};

Source

JobTriggerOptions (interface)

Browser-safe options accepted by a generated job trigger.

Signature

export interface JobTriggerOptions {
  readonly operationId?: OperationId | string;
  readonly idempotencyKey?: string;
  readonly delay?: string;
  readonly at?: string;
  readonly tags?: readonly string[];
  readonly correlationId?: string;
}

Source

JobWatchInput (type alias)

Run observation cursor and expected application identity.

Signature

type JobWatchInput = {
  readonly runId: string;
  readonly after?: string;
  readonly expectedIdentity?: ExpectedClientIdentity;
};

Source

controller-state.ts

stateFromFeedEvent

Projects observation status or frames into the existing external-store state.

Signature

declare const stateFromFeedEvent: <Run>(
  current: JobWatchState<Run>,
  event: FeedEvent<Run>,
  source: JobWatchOptions["source"],
) => JobWatchState<Run>;

Source

controller-support.ts

freeze

Deep-freezes external-store state without cloning its identity.

Signature

declare const freeze: <T>(value: T) => T;

Source

notify

Isolates one external-store callback from observation ownership.

Signature

declare const notify: <Run>(listener: JobWatchListener<Run>, state: JobWatchState<Run>) => void;

Source

reconnectAfterTeardown

Waits for interrupted setup and cleanup before admitting the next connection.

Signature

declare const reconnectAfterTeardown: (
  previous: Promise<void> | undefined,
  teardown: Promise<void> | undefined,
  start: () => Promise<void>,
) => Promise<void>;

Source

resumedOptions

Adds the retained snapshot cursor to the existing observation options.

Signature

declare const resumedOptions: <Run>(
  options: JobWatchOptions,
  state: JobWatchState<Run>,
) => JobWatchOptions;

Source

controller.service.ts

JobControllers (class)

Creates passive external-store views over scoped physical observation services.

Signature

declare class JobControllers

Source

JobControllersLive

Acquires the controller factory once without opening native requests.

Example

import { Layer, ManagedRuntime } from "effect";
import { runExecutionSync } from "@relkit/contracts/operation";
import { JobControllers, JobControllersLive } from "./controller.service.js";
import { JobFeedRegistryLive } from "./feed-registry.service.js";
export async function observeJob(client: unknown): Promise<void> {
  const owner = ManagedRuntime.make(JobControllersLive.pipe(Layer.provide(JobFeedRegistryLive)));
  try {
    const factory = runExecutionSync(owner, JobControllers);
    const view = factory.view(client, "job", { runId: "run" });
    try {
      await view.connect();
    } finally {
      await view.dispose();
    }
  } finally {
    await owner.dispose();
  }
}

Signature

declare const JobControllersLive: Layer.Layer<JobControllers, never, JobFeedRegistry>;

Source

controller.service.types.ts

JobControllerFactory (interface)

Once-acquired state factory sharing only complete-key physical observations.

Signature

export interface JobControllerFactory {
  readonly view: (client: unknown, name: string, options: JobWatchOptions) => JobControllerView;
}

Source

JobControllerView (interface)

Passive external-store state; asynchronous native work belongs to the feed service.

Signature

export interface JobControllerView {
  readonly snapshot: () => JobWatchState<unknown>;
  readonly subscribe: (listener: JobWatchListener<unknown>) => () => void;
  readonly assertLive: () => void;
  readonly isDisconnected: () => boolean;
  readonly connect: () => Promise<void>;
  readonly disconnect: () => Promise<void>;
  readonly dispose: () => Promise<void>;
  readonly refetch: () => Promise<void>;
}

Source

controller.ts

JobRunWatchController (class)

Passive synchronous external-store facade over scoped physical feed services.

Signature

declare class JobRunWatchController<Run> {
  constructor(client: unknown, name: string, options: JobWatchOptions);
}

Source

getSnapshot (method)

Signature

declare const getSnapshot: () => JobWatchState<Run>;

Source

subscribe (method)

Borrows controller state publication without acquiring native work.

Signature

declare const subscribe: (listener: JobWatchListener<Run>) => () => void;

Source

connect (method)

Signature

declare const connect: () => Promise<void>;

Source

disconnect (method)

Signature

declare const disconnect: () => Promise<void>;

Source

dispose (method)

Signature

declare const dispose: () => Promise<void>;

Source

refetch (method)

Signature

declare const refetch: () => Promise<void>;

Source

watchJobRun

Creates an idle, independently disposable external-store watch owner.

Signature

declare const watchJobRun: <Name extends string>(
  client: unknown,
  name: Name,
  options: JobWatchOptions,
) => JobWatchController<JobRunFor<Name>>;

Source

feed-registry.service.ts

JobFeedRegistry (class)

Reference-counted native observation ownership, independent of controller state.

Signature

declare class JobFeedRegistry

Source

JobFeedRegistryLive

Provides reference-counted feed sharing within complete security/protocol keys.

Example

import { Effect, ManagedRuntime } from "effect";
import { runExecutionSync } from "@relkit/contracts/operation";
import { JobFeedRegistry, JobFeedRegistryLive } from "./feed-registry.service.js";
export async function borrowJobFeed(client: unknown): Promise<void> {
  const owner = ManagedRuntime.make(JobFeedRegistryLive);
  try {
    const registry = runExecutionSync(owner, JobFeedRegistry);
    const borrow = await owner.runPromise(registry.borrow(client, "job", { runId: "run" }));
    try {
      await borrow.feed.addLease("view", () => undefined);
    } finally {
      await Effect.runPromise(borrow.release);
    }
  } finally {
    await owner.dispose();
  }
}

See

• tests/jobs/registry.test.ts for checked scoped native cleanup.

Signature

declare const JobFeedRegistryLive: Layer.Layer<JobFeedRegistry, never, never>;

Source

feed-registry.types.ts

JobFeedRegistryService (interface)

Reference-counted observation registry, with complete request authority.

Signature

export interface JobFeedRegistryService {
  /** Registers a passive external-store view without another Layer acquisition. */
  readonly borrowView: (client: unknown, name: string, options: JobWatchOptions) => WatchFeedBorrow;
  readonly borrow: (
    client: unknown,
    name: string,
    options: JobWatchOptions,
  ) => Effect.Effect<WatchFeedBorrow>;
}

Source

WatchFeedBorrow (interface)

One independently closable reference to a shared feed.

Signature

export interface WatchFeedBorrow {
  readonly feed: SharedWatchFeed<unknown>;
  /** Excludes a final retiring group before native callbacks can reconnect. */
  readonly retire: Effect.Effect<void>;
  readonly release: Effect.Effect<void>;
  /** Passive view retirement; this boundary never awaits native work. */
  readonly retireView: () => void;
  /** Joins the shared native borrow after passive view retirement. */
  readonly releaseView: () => Promise<void>;
}

Source

WatchFeedGroup (interface)

One native RcMap borrow shared by independently retired passive view leases.

Signature

export interface WatchFeedGroup {
  readonly feed: SharedWatchFeed<unknown>;
  readonly scope: Scope.Closeable;
  readonly references: Ref.Ref<number>;
}

Source

index.ts

“./contracts.types.js” (namespace export)

Re-exports all named exports from the “./contracts.types.js” module.

Signature

export * from "./contracts.types.js";

Source

JobCancelInputFor

Signature

declare const JobCancelInputFor: JobCancelInputFor<Name>;

Source

JobCancelName

Signature

declare const JobCancelName: never;

Source

JobCancelOutputFor

Signature

declare const JobCancelOutputFor: JobCancelOutputFor<Name>;

Source

JobClientOperation

Signature

declare const JobClientOperation: JobClientOperation;

Source

JobContract

Signature

declare const JobContract: JobContract<
  Name,
  JobId,
  Input,
  Output,
  Failure,
  Progress,
  Streams,
  Operations,
  Fields
>;

Source

JobErrorEnvelope

Signature

declare const JobErrorEnvelope: JobErrorEnvelope;

Source

JobFailureFor

Signature

declare const JobFailureFor: JobFailureFor<Name>;

Source

JobFor

Signature

declare const JobFor: JobFor<Name>;

Source

JobProcedureSelector

Signature

declare const JobProcedureSelector: JobProcedureSelector<Name>;

Source

JobRegistry

Signature

declare const JobRegistry: JobRegistry;

Source

JobRetryInputFor

Signature

declare const JobRetryInputFor: JobRetryInputFor<Name>;

Source

JobRetryName

Signature

declare const JobRetryName: never;

Source

JobRetryOutputFor

Signature

declare const JobRetryOutputFor: JobRetryOutputFor<Name>;

Source

JobRunFor

Signature

declare const JobRunFor: JobRunFor<Name>;

Source

JobRunSelector

Signature

declare const JobRunSelector: JobRunSelector<Name>;

Source

JobRunStatus

Signature

declare const JobRunStatus: JobRunStatus;

Source

JobRunWatchController

Signature

declare const JobRunWatchController: typeof JobRunWatchController;

Source

JobSelector

Signature

declare const JobSelector: never;

Source

JobSnapshotFor

Signature

declare const JobSnapshotFor: JobSnapshotFor<Input, Output, Progress, Failure, Fields>;

Source

JobStreamGapError

Signature

declare const JobStreamGapError: typeof JobStreamGapError;

Source

JobStreamOptions

Signature

declare const JobStreamOptions: JobStreamOptions;

Source

JobStreamOverflowError

Signature

declare const JobStreamOverflowError: typeof JobStreamOverflowError;

Source

JobTriggerInputFor

Signature

declare const JobTriggerInputFor: JobTriggerInputFor<Name>;

Source

JobTriggerName

Signature

declare const JobTriggerName: never;

Source

JobTriggerOutputFor

Signature

declare const JobTriggerOutputFor: JobTriggerOutputFor<Name>;

Source

JobTriggerSelector

Signature

declare const JobTriggerSelector: JobTriggerSelector<Name>;

Source

JobWatchAbortedError

Signature

declare const JobWatchAbortedError: typeof JobWatchAbortedError;

Source

JobWatchController

Signature

declare const JobWatchController: JobWatchController<Run>;

Source

JobWatchDisposedError

Signature

declare const JobWatchDisposedError: typeof JobWatchDisposedError;

Source

JobWatchFrame

Signature

declare const JobWatchFrame: JobWatchFrame<Run>;

Source

JobWatchFrameFor

Signature

declare const JobWatchFrameFor: JobWatchFrameFor<Name>;

Source

JobWatchListener

Signature

declare const JobWatchListener: JobWatchListener<Run>;

Source

JobWatchName

Signature

declare const JobWatchName: never;

Source

JobWatchOptions

Signature

declare const JobWatchOptions: JobWatchOptions;

Source

JobWatchReadTimeoutError

Signature

declare const JobWatchReadTimeoutError: typeof JobWatchReadTimeoutError;

Source

JobWatchState

Signature

declare const JobWatchState: JobWatchState<Run>;

Source

JobWatchUnavailableError

Signature

declare const JobWatchUnavailableError: typeof JobWatchUnavailableError;

Source

NamedStreamFrame

Signature

declare const NamedStreamFrame: NamedStreamFrame<Item>;

Source

RunCancellationReceipt

Signature

declare const RunCancellationReceipt: RunCancellationReceipt;

Source

RunHandle

Signature

declare const RunHandle: RunHandle;

Source

RunListQuery

Signature

declare const RunListQuery: RunListQuery;

Source

RunPage

Signature

declare const RunPage: RunPage<Run>;

Source

RunRetryReceipt

Signature

declare const RunRetryReceipt: RunRetryReceipt;

Source

RunSnapshot

Signature

declare const RunSnapshot: RunSnapshot<Input, Output, Progress, Failure>;

Source

RunWatchFrame

Signature

declare const RunWatchFrame: RunWatchFrame<Run>;

Source

SelectedJobField

Signature

declare const SelectedJobField: SelectedJobField<Fields, Field>;

Source

watchJobRun

Signature

declare const watchJobRun: <Name extends string>(
  client: unknown,
  name: Name,
  options: JobWatchOptions,
) => JobWatchController<JobRunFor<Name>>;

Source

watchJobStream

Signature

declare const watchJobStream: <Item extends JsonValue = JsonValue>(
  client: unknown,
  job: string,
  options: JobStreamOptions,
) => Promise<AsyncIterable<NamedStreamFrame<Item>>>;

Source

job-registry-derived.ts

“./job-registry-derived.types.js” (namespace export)

Re-exports all named exports from the “./job-registry-derived.types.js” module.

Signature

export * from "./job-registry-derived.types.js";

Source

job-registry-derived.types.ts

JobCancelInputFor (type alias)

Infers the exact cancellation request or its dynamic fallback.

Signature

type JobCancelInputFor<Name extends string> = Name extends JobSelector
  ? JobFor<Name> extends { readonly runs: infer Runs }
    ? Runs extends { readonly cancel: infer Cancel }
      ? Cancel extends { readonly input: infer Input }
        ? Input
        : never
      : never
    : never
  : JobCancelInput;

Source

JobCancelName (type alias)

Names of jobs exposing cancellation receipts.

Signature

type JobCancelName = JobRunName<"cancel">;

Source

JobCancelOutputFor (type alias)

Infers the declared cancellation receipt or its standard fallback.

Signature

type JobCancelOutputFor<Name extends string> = Name extends JobSelector
  ? JobFor<Name> extends { readonly runs: infer Runs }
    ? Runs extends { readonly cancel: infer Cancel }
      ? Cancel extends { readonly output: infer Output }
        ? Output
        : RunCancellationReceipt
      : RunCancellationReceipt
    : RunCancellationReceipt
  : RunCancellationReceipt;

Source

JobFailureFor (type alias)

Infers declared job failures while preserving the standard error envelope fallback.

Signature

type JobFailureFor<Name extends string> = Name extends JobSelector
  ? JobFor<Name> extends { readonly trigger: infer Trigger }
    ? Trigger extends { readonly error: infer Failure }
      ? Failure
      : JobErrorEnvelope
    : JobErrorEnvelope
  : JobErrorEnvelope;

Source

JobRetryInputFor (type alias)

Infers the exact retry request or its dynamic fallback.

Signature

type JobRetryInputFor<Name extends string> = Name extends JobSelector
  ? JobFor<Name> extends { readonly runs: infer Runs }
    ? Runs extends { readonly retry: infer Retry }
      ? Retry extends { readonly input: infer Input }
        ? Input
        : never
      : never
    : never
  : JobRetryInput;

Source

JobRetryName (type alias)

Names of jobs exposing retry receipts.

Signature

type JobRetryName = JobRunName<"retry">;

Source

JobRetryOutputFor (type alias)

Infers the declared retry receipt or its standard fallback.

Signature

type JobRetryOutputFor<Name extends string> = Name extends JobSelector
  ? JobFor<Name> extends { readonly runs: infer Runs }
    ? Runs extends { readonly retry: infer Retry }
      ? Retry extends { readonly output: infer Output }
        ? Output
        : RunRetryReceipt
      : RunRetryReceipt
    : RunRetryReceipt
  : RunRetryReceipt;

Source

JobRunFor (type alias)

Infers authoritative run payloads from get or watch contracts.

Signature

type JobRunFor<Name extends string> = Name extends JobSelector
  ? JobFor<Name> extends { readonly runs: infer Runs }
    ? Runs extends { readonly get: infer Get }
      ? Get extends { readonly output: infer Output }
        ? Output
        : RunSnapshot
      : Runs extends { readonly watch: infer Watch }
        ? Watch extends { readonly output: AsyncIterable<infer Frame> }
          ? Frame extends { readonly run: infer Run }
            ? Run
            : RunSnapshot
          : RunSnapshot
        : RunSnapshot
    : RunSnapshot
  : RunSnapshot;

Source

JobRunName (type alias)

Names of jobs exposing the selected run operation.

Signature

type JobRunName<Operation extends JobRunOperation> = {
  [Name in JobSelector]: JobFor<Name> extends { readonly runs: infer Runs }
    ? Operation extends keyof Runs
      ? Name
      : never
    : never;
}[JobSelector];

Source

JobTriggerInputFor (type alias)

Infers the declared trigger input while preserving the dynamic fallback.

Signature

type JobTriggerInputFor<Name extends string> = Name extends JobSelector
  ? JobFor<Name> extends { readonly trigger: infer Trigger }
    ? Trigger extends { readonly input: infer Input }
      ? Input
      : never
    : never
  : unknown;

Source

JobTriggerName (type alias)

Names of jobs exposing a declared trigger procedure.

Signature

type JobTriggerName = {
  [Name in JobSelector]: JobFor<Name> extends { readonly trigger: unknown } ? Name : never;
}[JobSelector];

Source

JobTriggerOutputFor (type alias)

Infers the declared trigger receipt while preserving RunHandle fallback.

Signature

type JobTriggerOutputFor<Name extends string> = Name extends JobSelector
  ? JobFor<Name> extends { readonly trigger: infer Trigger }
    ? Trigger extends { readonly output: infer Output }
      ? Output
      : never
    : never
  : RunHandle;

Source

JobWatchFrameFor (type alias)

Wraps the inferred authoritative run payload in its native watch frame.

Signature

type JobWatchFrameFor<Name extends string> = RunWatchFrame<JobRunFor<Name>>;

Source

JobWatchName (type alias)

Names of jobs exposing native run observation.

Signature

type JobWatchName = JobRunName<"watch">;

Source

job-registry-types.ts

Augmentable registry of application-declared job contracts.

“./job-registry.types.js” (namespace export)

Re-exports all named exports from the “./job-registry.types.js” module.

Signature

export * from "./job-registry.types.js";

Source

JobRegistry (interface)

Augmentable registry of application-declared job contracts.

Signature

export interface JobRegistry {}

Source

job-registry.types.ts

JobContract (type alias)

Generated job declaration retaining operation availability and selective field inference.

Signature

type JobContract<
  Name extends string = string,
  JobId extends string = string,
  Input = unknown,
  Output = unknown,
  Failure = JobErrorEnvelope,
  Progress = unknown,
  Streams extends Readonly<Record<string, unknown>> = Readonly<Record<string, unknown>>,
  Operations extends readonly JobClientOperation[] = readonly JobClientOperation[],
  Fields extends readonly JobClientField[] = readonly [],
> = {
  readonly name: Name;
  readonly jobId: JobId;
} & TriggerMember<Input, Failure, Operations> &
  RunMembers<Input, Output, Progress, Failure, Streams, Operations, Fields>;

Source

JobFor (type alias)

Looks up one declared job contract without widening its members.

Signature

type JobFor<Name extends JobSelector> = JobRegistry[Name];

Source

JobProcedureSelector (type alias)

Union of exact procedure selectors exposed by one declared job.

Signature

type JobProcedureSelector<Name extends JobSelector = JobSelector> =
  JobTriggerSelector<Name> | JobRunSelector<Name>;

Source

JobRunSelector (type alias)

Produces exact selectors for the declared run operations.

Signature

type JobRunSelector<Name extends JobSelector> =
  JobFor<Name> extends { readonly runs: infer Runs }
    ? {
        [
          Operation in "get" | "list" | "watch" | "stream" | "cancel" | "retry"
        ]: Runs extends Record<Operation, unknown>
          ? Runs[Operation] extends never
            ? never
            : `${Name}.runs.${Operation}`
          : never;
      }["get" | "list" | "watch" | "stream" | "cancel" | "retry"]
    : never;

Source

JobSelector (type alias)

String keys of the application-declared job registry.

Signature

type JobSelector = Extract<keyof JobRegistry, string>;

Source

JobSnapshotFor (type alias)

Projects run payload fields according to the declared client visibility contract.

Signature

type JobSnapshotFor<
  Input,
  Output,
  Progress,
  Failure,
  Fields extends readonly JobClientField[],
> = RunSnapshot<
  SelectedJobField<Fields, "input"> extends true ? Input : never,
  SelectedJobField<Fields, "output"> extends true ? Output : never,
  SelectedJobField<Fields, "progress"> extends true ? Progress : never,
  SelectedJobField<Fields, "error"> extends true ? Failure : never
>;

Source

JobTriggerSelector (type alias)

Produces the exact trigger selector only for trigger-capable jobs.

Signature

type JobTriggerSelector<Name extends JobSelector> =
  JobFor<Name> extends { readonly trigger: unknown } ? `${Name}.trigger` : never;

Source

SelectedJobField (type alias)

Tests whether a projection field belongs to the declared visible field set.

Signature

type SelectedJobField<
  Fields extends readonly JobClientField[],
  Field extends JobClientField,
> = Field extends Fields[number] ? true : false;

Source

observation.service.ts

JobObservation (class)

Cohesive native/polling observation workflow, replaceable at the feed owner.

Signature

declare class JobObservation

Source

JobObservationLive

Acquires the live observation workflow; native dependencies are supplied by each feed.

See

• tests/jobs/quality.test.ts for checked observation, recovery and interruption cases.

Signature

declare const JobObservationLive: Layer.Layer<JobObservation, never, never>;

Source

observation.types.ts

JobObservationService (interface)

Live/test contract for one independently cancellable shared observation lifetime.

Signature

export interface JobObservationService {
  /** Observes one physical feed until confirmed completion or retirement.
   * @typeParam Run - Application-declared run payload.
   * @param feed - Native dependency and authoritative observation state.
   * @param generation - Active worker generation rejecting stale callbacks.
   * @returns A lazy observed and interruptible workflow preserving native failures. */
  readonly consume: <Run>(
    feed: WatchFeedLoop<Run>,
    generation: number,
  ) => Effect.Effect<void, unknown>;
}

Source

read-timeout.ts

readWatchNext

Bounds one native iterator pull using the caller’s cancellation authority.

Signature

declare const readWatchNext: (
  iterator: AsyncIterator<unknown>,
  signal: AbortSignal,
  timeoutMs?: number,
) => Promise<IteratorResult<unknown>>;

Source

timedCall

Races one native boundary call against cancellation and the existing bounded read deadline.

Signature

declare const timedCall: <T>(
  signal: AbortSignal,
  timeoutMs: number,
  operation: (signal: AbortSignal) => Promise<T> | T,
) => Promise<T>;

Source

reconcile-boundary.ts

asWatchFrame

Checks the existing selective watch-frame envelope and retains original fields.

Signature

declare const asWatchFrame: (value: unknown) => RunWatchFrame;

Source

isProcedureNotFound

Recognizes the existing missing-procedure envelope used for safe read fallback.

Signature

declare const isProcedureNotFound: (value: unknown) => boolean;

Source

isRunSnapshot

Checks the existing selective run-snapshot authority without stricter payload validation.

Signature

declare const isRunSnapshot: (value: unknown) => value is RunSnapshot;

Source

optionalJobProcedure

Resolves an optional generated procedure while preserving unrelated lookup defects.

Signature

declare const optionalJobProcedure: (
  root: unknown,
  name: string,
  operation: string,
) => Procedure | undefined;

Source

ownJobProcedure

Finds a concrete job procedure while avoiding synthesized proxy properties.

Signature

declare const ownJobProcedure: (
  root: unknown,
  name: string,
  operation: string,
) => Procedure | undefined;

Source

resolveJobProcedure

Resolves a generated job procedure or preserves the existing missing-procedure error.

Signature

declare const resolveJobProcedure: (root: unknown, name: string, operation: string) => Procedure;

Source

throwIfAborted

Preserves the public watch-aborted failure at a native compatibility edge.

Signature

declare const throwIfAborted: (signal: AbortSignal) => void;

Source

toAsyncIterator

Checks and transfers a native iterable or iterator without cloning its payloads.

Signature

declare const toAsyncIterator: (value: unknown) => AsyncIterator<unknown>;

Source

reconcile-support.ts

closeIterator

Bounds a native iterator’s return without changing an existing public failure.

Signature

declare const closeIterator: (iterator: AsyncIterator<unknown>) => Promise<void>;

Source

newEpoch

Creates the existing local epoch used for synthesized authoritative snapshots.

Signature

declare const newEpoch: () => string;

Source

reconcile.ts

WatchRequest

Signature

declare const WatchRequest: WatchRequest;

Source

authoritativeFrame

Reads authoritative run state, falling back to watch only for a missing get procedure.

Signature

declare const authoritativeFrame: (
  client: unknown,
  name: string,
  options: JobWatchOptions,
  signal: AbortSignal,
) => Promise<RunWatchFrame | undefined>;

Source