@fabrika/app 0.3.2 → 0.4.0

package/src/react/provider.tsx

@@ -0,0 +1,165 @@
+// `FabrikaProvider`: the page's clients, the cache of their answers, and the caller document of the SPA mount. The
+// hooks take a procedure of a client as the typed name of a call; the provider runs it on the client it holds for
+// that mount, so a test hands in a client over the test kit and the page's own module-level client stays as it is.
+
+import { createContext, type ReactNode, useContext, useState } from 'react'
+import { z } from 'zod/v4'
+import { type PageCaller, parsePageCaller } from '../client/caller'
+import { type ClientNode, clientNodeOf } from '../client/contract'
+import { RpcError, type RpcFetch } from '../client/transport'
+import { joinPath, PAGE_CALLER_FILE } from '../contract/defaults'
+import { type FabrikaError, toFabrikaError } from './errors'
+import { QueryStore, type StoreTarget } from './store'
+
+export type CallerState =
+	| { readonly status: 'loading' }
+	| { readonly status: 'ready'; readonly caller: PageCaller }
+	| { readonly status: 'error'; readonly error: FabrikaError }
+
+/** The caller document, read once per provider when a view first asks for it. */
+export class CallerSource {
+	state: CallerState = { status: 'loading' }
+	#started = false
+	readonly #listeners = new Set<() => void>()
+
+	constructor(private readonly url: string, private readonly fetch: RpcFetch) {}
+
+	subscribe(listener: () => void): () => void {
+		this.#listeners.add(listener)
+		if (!this.#started) {
+			this.#started = true
+			void this.#load()
+		}
+		return () => this.#listeners.delete(listener)
+	}
+
+	async #load(): Promise<void> {
+		this.state = await this.#read()
+		for (const listener of [...this.#listeners]) listener()
+	}
+
+	async #read(): Promise<CallerState> {
+		try {
+			const response = await this.fetch(this.url, { credentials: 'same-origin' })
+			if (!response.ok) {
+				return {
+					status: 'error',
+					error: toFabrikaError(new RpcError({ type: 'caller', message: `HTTP ${response.status}`, httpStatus: response.status })),
+				}
+			}
+			return { status: 'ready', caller: parsePageCaller(await response.json()) }
+		} catch (error) {
+			return { status: 'error', error: toFabrikaError(error) }
+		}
+	}
+}
+
+export interface Fabrika {
+	readonly store: QueryStore
+	readonly caller: CallerSource
+	/** The call of `procedure` on the provider's client of its mount. */
+	target(procedure: unknown, hook: string): ResolvedProcedure
+}
+
+export interface ResolvedProcedure extends StoreTarget {
+	readonly node: ClientNode
+}
+
+const FabrikaContext = createContext<Fabrika | null>(null)
+
+/** The `{ path, code, message }` issues of a refused input, as the application answers them. */
+function issuesOf(error: z.core.$ZodError): readonly { readonly path: string; readonly code: string; readonly message: string }[] {
+	return error.issues.map((issue) => ({ path: issue.path.map(String).join('.'), code: issue.code, message: issue.message }))
+}
+
+/** Checks the input with the procedure's own schema first: a refused input is the application's 400, unsent. */
+function validated(node: ClientNode, input: unknown): unknown {
+	const schema = node.procedure?.input ?? null
+	if (schema === null) return input
+	const parsed = z.safeParse(schema, input ?? {})
+	if (parsed.success) return input
+	const issues = issuesOf(parsed.error)
+	const first = issues[0]
+	throw new RpcError({
+		type: 'validation',
+		message: first === undefined ? 'Invalid input' : `${first.path || 'input'}: ${first.message}`,
+		issues,
+		httpStatus: 400,
+	})
+}
+
+function idOf(node: ClientNode): string {
+	return node.path === '' ? node.mount : `${node.mount}.${node.path}`
+}
+
+function procedureAt(client: object, path: string): unknown {
+	let value: unknown = client
+	for (const segment of path.split('.')) {
+		value = typeof value === 'object' && value !== null ? Reflect.get(value, segment) : undefined
+	}
+	return value
+}
+
+function fabrika(clients: readonly object[], spa: string, fetch: RpcFetch): Fabrika {
+	const byMount = new Map<string, object>()
+	for (const client of clients) {
+		const node = clientNodeOf(client)
+		if (node === null || node.path !== '') throw new Error('FabrikaProvider takes the clients createClient made')
+		if (byMount.has(node.mount)) throw new Error(`FabrikaProvider holds two clients of mount '${node.mount}'`)
+		byMount.set(node.mount, client)
+	}
+	return {
+		store: new QueryStore(toFabrikaError),
+		caller: new CallerSource(joinPath(spa, PAGE_CALLER_FILE), fetch),
+		target(procedure, hook) {
+			const node = clientNodeOf(procedure)
+			if (node?.procedure == null) throw new Error(`${hook} takes a procedure of a client createClient made`)
+			const client = byMount.get(node.mount)
+			if (client === undefined) throw new Error(`${hook}: the FabrikaProvider holds no client of mount '${node.mount}'`)
+			const call = procedureAt(client, node.path)
+			if (typeof call !== 'function') throw new Error(`${hook}: '${idOf(node)}' is not a procedure of the provider's client`)
+			return {
+				id: idOf(node),
+				node,
+				run: async (input) => {
+					const answer: unknown = await Reflect.apply(call, undefined, [validated(node, input)])
+					return answer
+				},
+			}
+		},
+	}
+}
+
+export interface FabrikaProviderProps {
+	/** The clients of the mounts the page calls, as `createClient` made them; read at the first render. */
+	readonly clients: readonly object[]
+	/** The prefix of the SPA mount the page is served from: the caller document is `<spa>/__fabrika-me.json`. */
+	readonly spa?: string
+	/** What the caller document is fetched with; the global `fetch` by default (a test passes the kit's). */
+	readonly fetch?: RpcFetch
+	readonly children?: ReactNode
+}
+
+export function FabrikaProvider({ clients, spa = '/', fetch: fetchCaller, children }: FabrikaProviderProps): ReactNode {
+	const [value] = useState(() => fabrika(clients, spa, fetchCaller ?? ((input, init) => fetch(input, init))))
+	return <FabrikaContext.Provider value={value}>{children}</FabrikaContext.Provider>
+}
+
+export function useFabrika(hook: string): Fabrika {
+	const value = useContext(FabrikaContext)
+	if (value === null) throw new Error(`${hook} is used outside a FabrikaProvider`)
+	return value
+}
+
+/** The prefix a mutation invalidates by default: the group it lies in (`api.deals` for `api.deals.create`). */
+export function parentOf(node: ClientNode): string {
+	const segments = node.path.split('.')
+	return segments.length <= 1 ? node.mount : `${node.mount}.${segments.slice(0, -1).join('.')}`
+}
+
+/** The prefix of a procedure or a group, for `invalidate`. */
+export function prefixOf(target: unknown): string {
+	const node = clientNodeOf(target)
+	if (node === null) throw new Error('invalidate takes a procedure or a group of a client createClient made')
+	return idOf(node)
+}

package/src/react/store.ts

@@ -0,0 +1,215 @@
+// The provider's cache, without React: one entry per procedure and input (and one per paged list), each with the
+// pages it holds, a snapshot the hooks subscribe to, and a sequence number so a slower, older answer never overwrites
+// a newer one. `invalidate` refetches the entries a view shows and drops the others.
+
+import type { FabrikaError } from './errors'
+
+/** A procedure as the store calls it: its id (`<mount>.<path>`) and the call of the provider's client. */
+export interface StoreTarget {
+	readonly id: string
+	readonly run: (input: unknown) => Promise<unknown>
+}
+
+export type QueryStatus = 'loading' | 'success' | 'error'
+
+export interface QuerySnapshot {
+	readonly status: QueryStatus
+	readonly data: unknown
+	readonly error: FabrikaError | null
+	/** A request of this entry is in flight: the first load, a refetch or the next page. */
+	readonly fetching: boolean
+}
+
+export interface PagesSnapshot {
+	readonly status: QueryStatus
+	readonly items: readonly unknown[]
+	readonly next: string | null
+	readonly error: FabrikaError | null
+	readonly fetching: boolean
+	readonly loadingMore: boolean
+}
+
+/** One page of a cursor list, as every list procedure of the paved road answers it. */
+export interface Page {
+	readonly items: readonly unknown[]
+	readonly next: string | null
+}
+
+type Listener = () => void
+
+/** JSON with sorted keys, so two inputs that are the same value are the same key. */
+export function stableKey(value: unknown): string {
+	return JSON.stringify(value, (_key, field: unknown) => {
+		if (typeof field !== 'object' || field === null || Array.isArray(field)) return field
+		return Object.fromEntries(Object.entries(field).sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0)))
+	}) ?? 'null'
+}
+
+/** `<mount>.<path>` lies under `prefix` when it is the prefix itself or one of its descendants. */
+export function under(id: string, prefix: string): boolean {
+	return id === prefix || id.startsWith(`${prefix}.`)
+}
+
+abstract class Entry<S> {
+	snapshot: S
+	protected sequence = 0
+	readonly #listeners = new Set<Listener>()
+
+	constructor(readonly target: StoreTarget, readonly input: unknown, initial: S) {
+		this.snapshot = initial
+	}
+
+	get watched(): boolean {
+		return this.#listeners.size > 0
+	}
+
+	subscribe(listener: Listener): () => void {
+		this.#listeners.add(listener)
+		return () => this.#listeners.delete(listener)
+	}
+
+	protected publish(snapshot: S): void {
+		this.snapshot = snapshot
+		for (const listener of [...this.#listeners]) listener()
+	}
+
+	abstract load(): Promise<void>
+}
+
+export class QueryEntry extends Entry<QuerySnapshot> {
+	constructor(target: StoreTarget, input: unknown, private readonly mapError: (error: unknown) => FabrikaError) {
+		super(target, input, { status: 'loading', data: undefined, error: null, fetching: false })
+	}
+
+	async load(): Promise<void> {
+		const sequence = ++this.sequence
+		this.publish({ ...this.snapshot, fetching: true })
+		try {
+			const data = await this.target.run(this.input)
+			if (sequence !== this.sequence) return
+			this.publish({ status: 'success', data, error: null, fetching: false })
+		} catch (error) {
+			if (sequence !== this.sequence) return
+			this.publish({ ...this.snapshot, status: 'error', error: this.mapError(error), fetching: false })
+		}
+	}
+}
+
+/** `null` when the answer is no page: a hook over a procedure that does not page reports it instead of looping. */
+function pageOf(value: unknown): Page | null {
+	if (typeof value !== 'object' || value === null) return null
+	const items: unknown = Reflect.get(value, 'items')
+	const next: unknown = Reflect.get(value, 'next')
+	return Array.isArray(items) && (typeof next === 'string' || next === null) ? { items, next } : null
+}
+
+const NOT_A_PAGE: FabrikaError = { kind: 'other', message: 'the procedure answered no { items, next } page', status: 0 }
+
+export class PagesEntry extends Entry<PagesSnapshot> {
+	/** How many pages the view has asked for; a refetch loads as many again. `Infinity` follows every cursor. */
+	#pages: number
+
+	constructor(target: StoreTarget, input: unknown, pages: number, private readonly mapError: (error: unknown) => FabrikaError) {
+		super(target, input, { status: 'loading', items: [], next: null, error: null, fetching: false, loadingMore: false })
+		this.#pages = pages
+	}
+
+	#request(after: string | null): Promise<unknown> {
+		const input = typeof this.input === 'object' && this.input !== null ? this.input : {}
+		return this.target.run(after === null ? input : { ...input, after })
+	}
+
+	/** Loads the first `#pages` pages again, from the first cursor. */
+	async load(): Promise<void> {
+		const sequence = ++this.sequence
+		this.publish({ ...this.snapshot, fetching: true })
+		try {
+			const items: unknown[] = []
+			let next: string | null = null
+			let loaded = 0
+			do {
+				const page = pageOf(await this.#request(next))
+				if (sequence !== this.sequence) return
+				if (page === null) {
+					this.#refuse(NOT_A_PAGE)
+					return
+				}
+				items.push(...page.items)
+				next = page.next
+				loaded++
+			} while (next !== null && loaded < this.#pages)
+			this.publish({ status: 'success', items, next, error: null, fetching: false, loadingMore: false })
+		} catch (error) {
+			if (sequence !== this.sequence) return
+			this.#refuse(this.mapError(error))
+		}
+	}
+
+	#refuse(error: FabrikaError): void {
+		this.publish({ ...this.snapshot, status: 'error', error, fetching: false, loadingMore: false })
+	}
+
+	/** Appends the next page; nothing while a request is in flight or when the list has no more. */
+	async loadMore(): Promise<void> {
+		const after = this.snapshot.next
+		if (after === null || this.snapshot.fetching) return
+		const sequence = ++this.sequence
+		this.publish({ ...this.snapshot, fetching: true, loadingMore: true })
+		try {
+			const page = pageOf(await this.#request(after))
+			if (sequence !== this.sequence) return
+			if (page === null) {
+				this.#refuse(NOT_A_PAGE)
+				return
+			}
+			this.#pages++
+			this.publish({
+				status: 'success',
+				items: [...this.snapshot.items, ...page.items],
+				next: page.next,
+				error: null,
+				fetching: false,
+				loadingMore: false,
+			})
+		} catch (error) {
+			if (sequence !== this.sequence) return
+			// The loaded rows stay; the next `loadMore` asks for the same cursor again.
+			this.publish({ ...this.snapshot, status: 'error', error: this.mapError(error), fetching: false, loadingMore: false })
+		}
+	}
+}
+
+export class QueryStore {
+	readonly #entries = new Map<string, QueryEntry | PagesEntry>()
+
+	constructor(private readonly mapError: (error: unknown) => FabrikaError) {}
+
+	query(target: StoreTarget, input: unknown): QueryEntry {
+		const key = `query\u0000${target.id}\u0000${stableKey(input)}`
+		const found = this.#entries.get(key)
+		if (found instanceof QueryEntry) return found
+		const entry = new QueryEntry(target, input, this.mapError)
+		this.#entries.set(key, entry)
+		return entry
+	}
+
+	pages(target: StoreTarget, input: unknown, pages: number): PagesEntry {
+		const key = `pages\u0000${target.id}\u0000${stableKey(input)}\u0000${pages}`
+		const found = this.#entries.get(key)
+		if (found instanceof PagesEntry) return found
+		const entry = new PagesEntry(target, input, pages, this.mapError)
+		this.#entries.set(key, entry)
+		return entry
+	}
+
+	/** Refetches every entry under one of `prefixes` that a view shows, and forgets the rest, so their next view loads. */
+	async invalidate(prefixes: readonly string[]): Promise<void> {
+		const loads: Promise<void>[] = []
+		for (const [key, entry] of this.#entries) {
+			if (!prefixes.some((prefix) => under(entry.target.id, prefix))) continue
+			if (entry.watched) loads.push(entry.load())
+			else this.#entries.delete(key)
+		}
+		await Promise.all(loads)
+	}
+}

package/src/react/types.ts

@@ -0,0 +1,40 @@
+// The types the hooks read off a client procedure: its input as the caller writes it, and its answer as the output
+// schema parses it.
+
+import type { z } from 'zod/v4'
+import type { Schema } from '../contract/define'
+
+/** A query or mutation of a client that `createClient` built. */
+export type ClientProcedure = ((input: never) => Promise<unknown>) & { readonly output: Schema }
+
+/** A group of a client tree (`api.deals`), or the client itself: every procedure under it. */
+export interface ClientGroup {
+	readonly [name: string]: unknown
+}
+
+/** What `invalidate` takes: one procedure, or a group for every procedure under it. */
+export type InvalidateTarget = ClientProcedure | ClientGroup
+
+/** The input as the caller writes it; `undefined` admitted for a procedure that takes none. */
+export type ProcedureInput<F extends ClientProcedure> = F extends (input: infer I) => Promise<unknown> ? I : never
+
+/** A procedure by its input `I` and output schema `O`: what the hooks take, so both are inferred from the call. */
+export type TypedProcedure<I, O extends Schema> = ((input: I) => Promise<unknown>) & { readonly output: O }
+
+/** An input argument that may be left out when the procedure takes no input. */
+export type InputArgument<I> = undefined extends I ? I | void : I
+
+/** The answer, as the procedure's output schema parses it. */
+export type ProcedureResult<F extends ClientProcedure> = z.output<F['output']>
+
+/** The answer of a cursor list: `{ items, next }`. */
+export interface PageAnswer<Item> {
+	readonly items: readonly Item[]
+	readonly next: string | null
+}
+
+/** A procedure that pages: input `after`, answer `{ items, next }`. */
+export type PagedProcedure<I, Item> = ((input: I) => Promise<unknown>) & { readonly output: z.core.$ZodType<PageAnswer<Item>> }
+
+/** The input of a paged procedure without its cursor: the hook sends `after` itself. */
+export type PageInput<I> = undefined extends I ? Omit<NonNullable<I>, 'after'> | void : Omit<I, 'after'>

package/src/rpc/dispatcher.ts

@@ -114,9 +114,9 @@ async function dispatchOne(router: AnyRouter, ctx: unknown, call: SingleCall): P
 }
 
 /**
- * Dispatch an RPC POST. The `ctx` is already built (and decorated by middleware,
- * e.g. `ctx.auth`) by the server before this is called. Handles a single call
- * `{ method, input }` or a `{ batch: [...] }`.
+ * Dispatch an RPC POST. The `ctx` is already built (with its `ctx.auth`, for example)
+ * by the server before this is called. One request is one call,
+ * `{ method, input }`.
  */
 export async function dispatchRpcRequest(args: { router: AnyRouter; ctx: unknown; request: Request }): Promise<Response> {
 	let rawBody: unknown
@@ -126,25 +126,10 @@ export async function dispatchRpcRequest(args: { router: AnyRouter; ctx: unknown
 		return jsonResponse({ error: { type: 'validation', message: 'Invalid JSON body' } }, 400)
 	}
 
-	if (isRecord(rawBody) && Array.isArray(rawBody['batch'])) {
-		const results: SingleResult[] = []
-		for (const call of rawBody['batch']) {
-			results.push((await dispatchOne(args.router, args.ctx, normalizeCall(call))).body)
-		}
-		return jsonResponse({ batch: results }, 200)
-	}
-
 	if (!isRecord(rawBody) || typeof rawBody['method'] !== 'string') {
-		return jsonResponse({ error: { type: 'validation', message: 'Body must be { method, input } or { batch: [...] }' } }, 400)
+		return jsonResponse({ error: { type: 'validation', message: 'Body must be { method, input }' } }, 400)
 	}
 
 	const single = await dispatchOne(args.router, args.ctx, { method: rawBody['method'], input: rawBody['input'] })
 	return jsonResponse(single.body, single.status)
 }
-
-function normalizeCall(call: unknown): SingleCall {
-	if (isRecord(call) && typeof call['method'] === 'string') {
-		return { method: call['method'], input: call['input'] }
-	}
-	return { method: '', input: undefined }
-}

package/src/service/define.ts

@@ -0,0 +1,121 @@
+// A service contract: the endpoint table of one of the installation's own services (ADR-0012, ADR-0022 "Installation
+// entries"). Plain data over `@fabrika/auth-core` only, so a table module stays dependency-light.
+
+import {
+	APP_ENVIRONMENT_SEPARATOR,
+	type BodyAdmission,
+	compileEndpointTable,
+	EndpointTableError,
+	type InstallationCaller,
+	type InstallationEndpointMethod,
+	type InstallationEndpointRow,
+	type InstallationEndpointTable,
+	OAUTH_CALLER,
+} from '@fabrika/auth-core'
+
+/** A row as the builder writes it; the record key of `endpoints` becomes its id. */
+export type ServiceEndpointSpec = InstallationEndpointRow extends infer Row ? Row extends InstallationEndpointRow ? Omit<Row, 'id'> : never : never
+
+/** One installation service's table, with the row ids as a type so its handlers can be checked against them. */
+export interface ServiceArtifact<Id extends string = string> extends InstallationEndpointTable {
+	/** The service's IAM app id; never `<app>@<env>`. */
+	readonly id: string
+	readonly endpoints: readonly (InstallationEndpointRow & { readonly id: Id })[]
+}
+
+export interface ServiceEndpointOptions {
+	readonly callers: readonly [InstallationCaller, ...InstallationCaller[]]
+	/** The request body the row admits; omitted admits none. */
+	readonly admission?: BodyAdmission
+	/** The scopes an OAuth resource token must carry; required exactly when `callers` holds `oauth`. */
+	readonly scopes?: readonly string[]
+}
+
+export interface ServiceContractBuilder {
+	/** A liveness endpoint: anonymous, and served without `X-Fabrika-Endpoint`. */
+	health(method: InstallationEndpointMethod, path: string): ServiceEndpointSpec
+	/** An endpoint the service authenticates itself; the proxy reads no credential and keeps `Authorization`. */
+	protocol(method: InstallationEndpointMethod, path: string): ServiceEndpointSpec
+	/** A credentialed endpoint: a listed caller kind, and no permission (`authenticated`). */
+	service(method: InstallationEndpointMethod, path: string, options: ServiceEndpointOptions): ServiceEndpointSpec
+}
+
+export interface ServiceContractDeclaration<Id extends string> {
+	/** `null` is a row this composition does not serve: the table has no row there, and its handler is never called. */
+	readonly endpoints: Readonly<Record<Id, ServiceEndpointSpec | null>>
+	/** Literal prefixes a path under which reaches only a row declared under it. */
+	readonly reservedPrefixes: readonly string[]
+}
+
+export class ServiceContractError extends Error {
+	override readonly name = 'ServiceContractError'
+	readonly problems: readonly string[]
+
+	constructor(problems: readonly string[]) {
+		super(`the service contract is invalid:\n- ${problems.join('\n- ')}`)
+		this.problems = problems
+	}
+}
+
+const builder: ServiceContractBuilder = {
+	health: (method, path) => anonymous('health', method, path),
+	protocol: (method, path) => anonymous('protocol', method, path),
+	service: (method, path, options) => ({
+		kind: 'service',
+		method,
+		path,
+		callers: options.callers,
+		requirement: { kind: 'authenticated' },
+		admission: options.admission ?? null,
+		oauth: options.scopes === undefined ? null : { scopes: options.scopes },
+	}),
+}
+
+function anonymous(kind: 'health' | 'protocol', method: InstallationEndpointMethod, path: string): ServiceEndpointSpec {
+	return { kind, method, path, callers: [], requirement: null, admission: null, oauth: null }
+}
+
+/**
+ * Declare one installation service's endpoint table. Validated here, once: an id that is an application environment,
+ * an `oauth` caller without its scopes (or scopes without it), and every table the matcher would refuse.
+ */
+export function defineServiceContract<const Id extends string>(
+	id: string,
+	declare: (s: ServiceContractBuilder) => ServiceContractDeclaration<Id>,
+): ServiceArtifact<Id> {
+	const declaration = declare(builder)
+	const endpoints = servedEntries(declaration.endpoints).map(([rowId, spec]) => ({ ...spec, id: rowId }))
+	const problems: string[] = []
+	if (id === '' || id.includes(APP_ENVIRONMENT_SEPARATOR)) {
+		problems.push(`'${id}' is no installation service id: it must be non-empty and hold no '${APP_ENVIRONMENT_SEPARATOR}'`)
+	}
+	for (const row of endpoints) {
+		const admitsOAuth = row.callers.some((caller) => caller === OAUTH_CALLER)
+		if (admitsOAuth !== (row.oauth !== null)) {
+			problems.push(`'${row.id}' must declare scopes exactly when it admits the caller '${OAUTH_CALLER}'`)
+		}
+		if (row.oauth !== null && row.oauth.scopes.length === 0) {
+			problems.push(`'${row.id}' admits '${OAUTH_CALLER}' with no scope`)
+		}
+	}
+	const table = { endpoints, reservedPrefixes: [...declaration.reservedPrefixes] }
+	try {
+		compileEndpointTable(table)
+	} catch (error) {
+		if (!(error instanceof EndpointTableError)) throw error
+		problems.push(...error.problems)
+	}
+	if (problems.length > 0) {
+		throw new ServiceContractError(problems)
+	}
+	return { id, ...table }
+}
+
+function servedEntries<Id extends string, Value>(record: Readonly<Record<Id, Value | null>>): [Id, Value][] {
+	const entries: [Id, Value][] = []
+	for (const key in record) {
+		const value = record[key]
+		if (Object.hasOwn(record, key) && value !== null) entries.push([key, value])
+	}
+	return entries
+}

package/src/service/index.ts

@@ -0,0 +1,21 @@
+// @fabrika/app/service — the installation's own services only (IAM, Control, Operations). An application serves its
+// contract through `serve`; `@fabrika/check` refuses this import in one.
+
+export { dispatchRpcRequest } from '../rpc/dispatcher.js'
+export {
+	defineServiceContract,
+	type ServiceArtifact,
+	type ServiceContractBuilder,
+	type ServiceContractDeclaration,
+	ServiceContractError,
+	type ServiceEndpointOptions,
+	type ServiceEndpointSpec,
+} from './define.js'
+export {
+	serveService,
+	type ServeServiceOptions,
+	type ServiceHandler,
+	type ServiceHandlers,
+	ServiceHandlersError,
+	type ServiceRequest,
+} from './serve.js'