@sincpro/client-framework 0.6.0 → 1.0.0

package/dist/services/bounded-context.js

@@ -1,261 +0,0 @@
-import { newEntityId } from "../common/ids.js";
-import { contextAt } from "../context/context.js";
-import { bindDependency } from "./execution.js";
-import { composes, isApplicationServiceClass, isFeatureClass, methodsOf, } from "./feature.js";
-import { processContext, processNow, processStore, } from "./process.js";
-import { firstReport } from "./report.js";
-/** Names `project` answers itself: no service is registered under them. */
-const RESERVED = new Set(["name", "context", "with", "scoped"]);
-/** Names a run answers on `this` itself: no dependency is added under them. */
-const ANSWERED = new Set(["context", "feature", "span"]);
-export class UseBoundedContext {
-    name;
-    /** This bounded context's level of the context, saved in the process's store. */
-    context;
-    #dependencies = {};
-    constructor(name) {
-        if (name === "" || name.includes("/"))
-            throw new Error(`"${name}" is not a bounded context's name — it names its spans: "${name}/Issues.close"`);
-        this.name = name;
-        this.context = contextAt(`bounded_context:${name}`, processStore);
-    }
-    /** `value` is what every service of this bounded context finds at `this.<name>`. */
-    addDependency(name, value) {
-        if (ANSWERED.has(name))
-            throw new Error(`${this.name}: a dependency cannot be called "${name}" — every service answers this.${name} itself`);
-        this.#dependencies[name] = value;
-        return this;
-    }
-    /**
-     * The object the bounded context is used through: each service under its name. A dependency
-     * added after this is seen too — the services read them on every call.
-     */
-    register(services) {
-        const classes = new Map();
-        const add = (key, service) => {
-            if (RESERVED.has(key))
-                throw new Error(`${this.name}: no service can be called "${key}" — it is the bounded context's own`);
-            if (classes.has(key))
-                throw new Error(`${this.name}: two services are called "${key}"`);
-            classes.set(key, service);
-        };
-        for (const [key, service] of Object.entries(services.features)) {
-            if (typeof service !== "function" || !isFeatureClass(service))
-                throw new Error(`${this.name}: "${key}" is not a Feature — an ApplicationService goes in applicationServices`);
-            add(key, service);
-        }
-        for (const [key, service] of Object.entries(services.applicationServices ?? {})) {
-            if (typeof service !== "function" || !isApplicationServiceClass(service))
-                throw new Error(`${this.name}: "${key}" is not an ApplicationService — a Feature goes in features`);
-            add(key, service);
-        }
-        const registry = {
-            name: this.name,
-            dependencies: this.#dependencies,
-            classes,
-            features: new Set(Object.keys(services.features)),
-            instances: new Map(),
-            context: this.context,
-        };
-        return assemble({ registry, overrides: {}, scope: {} });
-    }
-}
-function assemble(binding) {
-    const { registry } = binding;
-    const held = {};
-    Object.defineProperties(held, {
-        name: { value: registry.name, enumerable: true },
-        context: { value: registry.context, enumerable: true },
-        with: {
-            value: (dependencies) => assemble({ ...binding, overrides: { ...binding.overrides, ...dependencies } }),
-        },
-        scoped: {
-            value: (values) => assemble({ ...binding, scope: { ...binding.scope, ...values } }),
-        },
-    });
-    // Each service is made and wrapped the first time it is asked for, then kept on this object.
-    for (const key of registry.classes.keys())
-        Object.defineProperty(held, key, {
-            configurable: true,
-            enumerable: true,
-            get() {
-                const service = intercepted(key, binding, undefined);
-                Object.defineProperty(held, key, { value: service, enumerable: true });
-                return service;
-            },
-        });
-    return held;
-}
-function instanceOf(registry, key) {
-    const known = registry.instances.get(key);
-    if (known !== undefined)
-        return known;
-    const Service = registry.classes.get(key);
-    if (Service === undefined)
-        throw new Error(`${registry.name}: no service is called "${key}"`);
-    const made = new Service();
-    registry.instances.set(key, made);
-    return made;
-}
-/**
- * A service as its holder sees it: each public method runs in an execution of its own — a child
- * of `parent` when an ApplicationService runs it. A method is the same function every time it is
- * read, so a screen can keep it (`useService(project.Issues.close)`).
- */
-function intercepted(key, binding, parent) {
-    const target = instanceOf(binding.registry, key);
-    const traced = methodsOf(target);
-    const methods = new Map();
-    return new Proxy(target, {
-        get(held, property) {
-            const value = Reflect.get(held, property, held);
-            if (typeof property !== "string" ||
-                typeof value !== "function" ||
-                !traced.has(property))
-                return value;
-            let method = methods.get(property);
-            if (method === undefined) {
-                const body = value;
-                method = (...args) => run(held, key, property, body, args, binding, parent);
-                methods.set(property, method);
-            }
-            return method;
-        },
-    });
-}
-function dependencyOf(binding, name) {
-    if (Object.hasOwn(binding.overrides, name))
-        return { found: true, value: binding.overrides[name] };
-    if (Object.hasOwn(binding.registry.dependencies, name))
-        return { found: true, value: binding.registry.dependencies[name] };
-    return { found: false, value: undefined };
-}
-/**
- * The run's own view of the instance: its context, its dependencies bound to this execution
- * (each bound the first time it is read), and — for an ApplicationService — its Features as
- * children of this run. Anything else is the instance's.
- */
-function viewOf(target, binding, execution) {
-    const bound = new Map();
-    let features;
-    const isComposer = composes(target);
-    return new Proxy(target, {
-        get(held, property, receiver) {
-            if (property === "context")
-                return execution.context;
-            if (property === "span")
-                return execution.span;
-            if (property === "feature" && isComposer)
-                return (features ??= featuresOf(binding, execution));
-            if (typeof property === "string") {
-                if (bound.has(property))
-                    return bound.get(property);
-                const dependency = dependencyOf(binding, property);
-                if (dependency.found) {
-                    const value = bindDependency(dependency.value, execution);
-                    bound.set(property, value);
-                    return value;
-                }
-            }
-            return Reflect.get(held, property, receiver);
-        },
-        set(held, property, value) {
-            if (ANSWERED.has(String(property)))
-                return false;
-            if (typeof property === "string" && dependencyOf(binding, property).found)
-                return false;
-            // What a method writes on `this` lands on the instance — it is the bounded context's.
-            return Reflect.set(held, property, value);
-        },
-    });
-}
-/** An ApplicationService's `this.feature`: each Feature, asked by name, a child of the run. */
-function featuresOf(binding, execution) {
-    const children = new Map();
-    return new Proxy({}, {
-        get(_, property) {
-            if (typeof property !== "string" || !binding.registry.features.has(property))
-                return undefined;
-            let child = children.get(property);
-            if (child === undefined) {
-                child = intercepted(property, binding, execution);
-                children.set(property, child);
-            }
-            return child;
-        },
-    });
-}
-const NOTHING = {};
-/** What a gesture runs with: the process's context, under it the bounded context's, its scope's. */
-function contextOf(binding) {
-    return {
-        ...processContext.values,
-        ...binding.registry.context.values,
-        ...binding.scope,
-    };
-}
-/** What watches a use case never changes what it answers: a tracer or reporter that throws is ignored. */
-function quietly(work, otherwise) {
-    try {
-        return work();
-    }
-    catch {
-        return otherwise;
-    }
-}
-const NO_SPAN = {
-    traceId: "",
-    spanId: "",
-    sampled: false,
-    set: () => undefined,
-    end: () => undefined,
-};
-function run(target, key, method, body, args, binding, parent) {
-    const settings = processNow();
-    const boundedContext = binding.registry.name;
-    // As sincpro_framework names a use case: the span `context/Name`, the identity `context.Name`.
-    const identity = method === "execute" ? key : `${key}.${method}`;
-    const useCase = `${boundedContext}.${identity}`;
-    const context = parent?.context ?? quietly(() => contextOf(binding), NOTHING);
-    const id = newEntityId();
-    const attributes = {
-        "sincpro.use_case": useCase,
-        "sincpro.layer": composes(target) ? "application_service" : "feature",
-        "sincpro.context": boundedContext,
-        "sincpro.execution_id": id,
-    };
-    const span = quietly(() => settings.tracer.start(`${boundedContext}/${identity}`, {
-        ...(parent === undefined ? {} : { parent: parent.span }),
-        attributes,
-    }), NO_SPAN);
-    const execution = { id, useCase, boundedContext, parent, span, context };
-    const finish = (failed, error) => {
-        const outcome = failed ? quietly(() => settings.outcomeOf(error), "failed") : "ok";
-        quietly(() => span.end(outcome, error), undefined);
-        if (outcome === "failed" && firstReport(error))
-            quietly(() => settings.reporter?.report(error, {
-                useCase,
-                traceId: span.traceId,
-                executionId: id,
-                context,
-            }), undefined);
-    };
-    let answer;
-    try {
-        answer = body.apply(viewOf(target, binding, execution), args);
-    }
-    catch (error) {
-        finish(true, error);
-        throw error;
-    }
-    if (answer instanceof Promise)
-        return answer.then((value) => {
-            finish(false);
-            return value;
-        }, (error) => {
-            finish(true, error);
-            throw error;
-        });
-    finish(false);
-    return answer;
-}

package/dist/services/execution.d.ts

@@ -1,63 +0,0 @@
-import type { Transport } from "../client/transport.js";
-import type { Span } from "../observability/ports.js";
-/**
- * One run of a use case: its span, what it runs with, and who ran it.
- *
- * Context: sincpro_framework keeps the running use case in a context variable; a browser has
- * nothing like it that survives an `await` (AsyncContext is a proposal, Zone.js patches the
- * world), and a global stack mixes the parents of two use cases running at once — which a
- * screen with several windows does all the time. So an execution is a value, handed to what
- * the use case calls: its Features (`this.feature`) and its dependencies (`BIND`).
- */
-export type Execution = {
-    /** UUID v7, as 32 hex: this run. */
-    readonly id: string;
-    /** `<bounded context>.<Service>[.<method>]` — the use case's identity, as the backend names its own. */
-    readonly useCase: string;
-    /** The bounded context the use case belongs to. */
-    readonly boundedContext: string;
-    /** The run that executed this one: an ApplicationService, for its Features. */
-    readonly parent: Execution | undefined;
-    readonly span: Span;
-    /** What it runs with, read once where the gesture started and inherited by every child. */
-    readonly context: Readonly<Record<string, unknown>>;
-};
-/**
- * A dependency that has something to say about the execution it is used in: given that
- * execution, it answers itself bound to it. The transport and every generated client are;
- * any other dependency of a bounded context is handed as it is.
- */
-export declare const BIND: unique symbol;
-export type Bindable<T> = {
-    [BIND]: (execution: Execution) => T;
-};
-/**
- * What every request of an execution carries: its trace (`traceparent`, W3C) and its context
- * (`sincpro-context`, the header sincpro_framework's entrances read, written with `plainCodec`).
- * Nothing when there is no trace and no context that travels.
- */
-export declare function headersOf(execution: Execution): Record<string, string>;
-/**
- * The transport, writing the execution's headers on every call — the caller's own headers of a
- * call still win.
- *
- * Context: the transport's own headers (`restTransport({ headers })`) are the session's — the
- * token, the tenant — the same for every call; these are the use case's, different for two use
- * cases running at once, so they travel per call (`CallOptions`).
- */
-export declare function bindTransport(transport: Transport, execution: Execution): Transport;
-/**
- * A client made over a transport, made again over the transport bound to each execution it is
- * used in. What a generated `clientOf(transport)` answers, so a Feature that calls
- * `this.client.sendIssue(…)` sends that request with its own trace.
- *
- *     export function clientOf(transport: Transport) {
- *       return bindable(transport, (transport) => ({ sendIssue: (body) => transport.send(…) }));
- *     }
- *
- * Context: it takes the function that makes the client, not the client — rebuilding through
- * `clientOf` itself would make TypeScript infer `clientOf` from its own return.
- */
-export declare function bindable<T extends object>(transport: Transport, make: (transport: Transport) => T): T;
-/** A dependency as the execution should see it: bound when it can be, as it is otherwise. */
-export declare function bindDependency<T>(value: T, execution: Execution): T;

package/dist/services/feature.d.ts

@@ -1,85 +0,0 @@
-import type { ContextValues } from "../context/store.js";
-import type { Span } from "../observability/ports.js";
-/**
- * `Feature` and `ApplicationService`: the two kinds of service a bounded context holds, as in
- * sincpro_framework. Each bounded context gives them its dependencies once, in its own base:
- *
- *     // domains/project/infrastructure/bounded_context.ts
- *     export class Feature extends BaseFeature<ProjectDependencies> {}
- *     export class ApplicationService extends BaseApplicationService<ProjectDependencies, ProjectFeatures> {}
- *
- *     // domains/project/services/issues.ts
- *     export class Issues extends Feature {
- *       close(input: dto.CommandCloseIssue) {
- *         this.session.require();                 // each dependency is a property — typed
- *         return this.client.closeIssue(input);
- *       }
- *     }
- *
- *     // domains/project/services/close_and_notify.ts
- *     export class CloseAndNotify extends ApplicationService {
- *       async execute(input: dto.CommandCloseIssue) {
- *         await this.feature.Issues.close(input);   // a child of this run, on the same trace
- *         return this.feature.Notices.tell(input);
- *       }
- *     }
- *
- * Context: a Feature is a facade — the operations of one part of the domain, each a public
- * method; an ApplicationService composes the Features of its own bounded context and never
- * another ApplicationService (sincpro_framework's rule). Neither writes a span nor catches an
- * error to report it: the bounded context runs every public method inside its own execution
- * (`UseBoundedContext`).
- *
- * The dependencies are typed, not declared: `BaseFeature<ProjectDependencies>` types
- * `this.client` and `this.session` from the bounded context's dependency type — sincpro_framework's
- * `DependencyContextType` — and the bounded context hands them in on each run. So a service
- * constructs with nothing, keeps no dependency on `this`, and declares no `#private` field: a run
- * sees the instance through a view of its own (its dependencies bound to its trace), and
- * `#private` refuses views. TypeScript's `private` is the same promise without that.
- */
-declare class FeatureCore {
-}
-declare class ApplicationServiceCore extends FeatureCore {
-}
-/** What every service sees on `this` inside a method. */
-type Within<D extends object, C extends object> = Readonly<D> & {
-    /**
-     * What this run executes with: the process's context, its bounded context's, its scope's —
-     * read once where the gesture started and the same for every Feature it runs.
-     */
-    readonly context: Readonly<Partial<C>>;
-    /** This run's span: a use case says more about what it ran on (`this.span.set({ … })`). */
-    readonly span: Span;
-};
-/** Service classes by the name a bounded context gives them: `{ Issues, Notices }`. */
-export type ServiceClasses = Readonly<Record<string, new () => object>>;
-/**
- * What a service offers to whoever holds it — `project.Issues`, `this.feature.Issues`: its public
- * methods, without its dependencies, its context or its `_` helpers.
- */
-export type ServiceMethods<I, D> = {
-    readonly [M in keyof I as M extends keyof D | "context" | "feature" | "span" | `_${string}` ? never : I[M] extends (...args: never[]) => unknown ? M : never]: I[M];
-};
-/** The services of a set of classes, by their names. */
-export type Services<S extends ServiceClasses, D> = {
-    readonly [K in keyof S]: ServiceMethods<InstanceType<S[K]>, D>;
-};
-type FeatureClass = abstract new <D extends object = Record<never, never>, C extends object = ContextValues>() => FeatureCore & Within<D, C>;
-type ApplicationServiceClass = abstract new <D extends object = Record<never, never>, F extends ServiceClasses = Record<never, never>, C extends object = ContextValues>() => ApplicationServiceCore & Within<D, C> & {
-    /** The Features of this bounded context, each run a child of this one. */
-    readonly feature: Services<F, D>;
-};
-/** The base of a bounded context's Features: `class Feature extends BaseFeature<Deps> {}`. */
-export declare const Feature: FeatureClass;
-/**
- * The base of a bounded context's ApplicationServices:
- * `class ApplicationService extends BaseApplicationService<Deps, typeof features> {}`.
- */
-export declare const ApplicationService: ApplicationServiceClass;
-/** Whether a class is a Feature — and not an ApplicationService. */
-export declare function isFeatureClass(service: new () => object): boolean;
-export declare function isApplicationServiceClass(service: new () => object): boolean;
-/** Whether a service composes Features — an ApplicationService. */
-export declare function composes(service: object): boolean;
-export declare function methodsOf(service: object): ReadonlySet<string>;
-export {};

package/dist/services/feature.js

@@ -1,86 +0,0 @@
-/**
- * `Feature` and `ApplicationService`: the two kinds of service a bounded context holds, as in
- * sincpro_framework. Each bounded context gives them its dependencies once, in its own base:
- *
- *     // domains/project/infrastructure/bounded_context.ts
- *     export class Feature extends BaseFeature<ProjectDependencies> {}
- *     export class ApplicationService extends BaseApplicationService<ProjectDependencies, ProjectFeatures> {}
- *
- *     // domains/project/services/issues.ts
- *     export class Issues extends Feature {
- *       close(input: dto.CommandCloseIssue) {
- *         this.session.require();                 // each dependency is a property — typed
- *         return this.client.closeIssue(input);
- *       }
- *     }
- *
- *     // domains/project/services/close_and_notify.ts
- *     export class CloseAndNotify extends ApplicationService {
- *       async execute(input: dto.CommandCloseIssue) {
- *         await this.feature.Issues.close(input);   // a child of this run, on the same trace
- *         return this.feature.Notices.tell(input);
- *       }
- *     }
- *
- * Context: a Feature is a facade — the operations of one part of the domain, each a public
- * method; an ApplicationService composes the Features of its own bounded context and never
- * another ApplicationService (sincpro_framework's rule). Neither writes a span nor catches an
- * error to report it: the bounded context runs every public method inside its own execution
- * (`UseBoundedContext`).
- *
- * The dependencies are typed, not declared: `BaseFeature<ProjectDependencies>` types
- * `this.client` and `this.session` from the bounded context's dependency type — sincpro_framework's
- * `DependencyContextType` — and the bounded context hands them in on each run. So a service
- * constructs with nothing, keeps no dependency on `this`, and declares no `#private` field: a run
- * sees the instance through a view of its own (its dependencies bound to its trace), and
- * `#private` refuses views. TypeScript's `private` is the same promise without that.
- */
-class FeatureCore {
-}
-class ApplicationServiceCore extends FeatureCore {
-}
-/** The base of a bounded context's Features: `class Feature extends BaseFeature<Deps> {}`. */
-export const Feature = FeatureCore;
-/**
- * The base of a bounded context's ApplicationServices:
- * `class ApplicationService extends BaseApplicationService<Deps, typeof features> {}`.
- */
-export const ApplicationService = ApplicationServiceCore;
-/** Whether a class is a Feature — and not an ApplicationService. */
-export function isFeatureClass(service) {
-    return (service.prototype instanceof FeatureCore &&
-        !(service.prototype instanceof ApplicationServiceCore));
-}
-export function isApplicationServiceClass(service) {
-    return service.prototype instanceof ApplicationServiceCore;
-}
-/** Whether a service composes Features — an ApplicationService. */
-export function composes(service) {
-    return service instanceof ApplicationServiceCore;
-}
-/**
- * The methods a class adds over its base — what is traced — read once per class: every public
- * method of the class and its parents up to `Feature`, but `constructor` and a name that starts
- * with `_`.
- */
-const METHODS = new WeakMap();
-export function methodsOf(service) {
-    const prototype = Object.getPrototypeOf(service);
-    const known = METHODS.get(prototype);
-    if (known !== undefined)
-        return known;
-    const names = new Set();
-    for (let level = prototype; level !== null &&
-        level !== ApplicationServiceCore.prototype &&
-        level !== FeatureCore.prototype &&
-        level !== Object.prototype; level = Object.getPrototypeOf(level))
-        for (const name of Object.getOwnPropertyNames(level)) {
-            const descriptor = Object.getOwnPropertyDescriptor(level, name);
-            if (name !== "constructor" &&
-                !name.startsWith("_") &&
-                typeof descriptor?.value === "function")
-                names.add(name);
-        }
-    METHODS.set(prototype, names);
-    return names;
-}

package/dist/services/process.d.ts

@@ -1,60 +0,0 @@
-import { type Context, type StoreSource } from "../context/context.js";
-import { type ContextStore } from "../context/store.js";
-import { type ErrorReporter, type Outcome, type Tracer } from "../observability/ports.js";
-/**
- * What every bounded context of this process runs with — set once, in `main`, the way
- * sincpro_framework's process is: who traces, who reports, where the context lives.
- *
- *     // entrypoints/main.tsx — the platform's pieces, built from the application's settings
- *     configureProcess({
- *       tracer: browserTracer({ endpoint: settings.otlp, service: "forge-web" }),
- *       reporter: glitchtipReporter({ dsn: settings.glitchtip }),
- *       context: memoryContexts(),
- *     });
- *
- * Context: everything is optional, and nothing breaks without it. A process that never configures
- * runs every use case untraced, unreported, with its context in memory — so a bounded context is
- * usable the moment it is imported, and `main` adds what it watches with. The bounded contexts
- * read the process on every call, never at import: `project` may be defined before `main` runs.
- *
- * It replaces everything at once: what is not given goes back to its default — a test calls it
- * with its own tracer and starts from a clean context.
- */
-export type ProcessOptions = {
-    /** The platform's (OpenTelemetry in a browser, a queue on a phone, memory in a test). */
-    tracer?: Tracer;
-    /** The platform's (GlitchTip, Sentry, memory in a test). Only what nobody expected reaches it. */
-    reporter?: ErrorReporter;
-    /** Where the context lives (`memoryContexts()` by default). */
-    context?: ContextStore;
-    /** How an error ended a use case (`outcomeOf` by default). Only `failed` is reported. */
-    outcomeOf?: (error: unknown) => Outcome;
-};
-/** The process as a use case reads it. Not public: `configureProcess` is the way in. */
-export type Process = {
-    readonly tracer: Tracer;
-    readonly reporter: ErrorReporter | undefined;
-    readonly store: ContextStore;
-    readonly outcomeOf: (error: unknown) => Outcome;
-};
-export declare function configureProcess(options?: ProcessOptions): void;
-/** The process's store as every level of the context reads it — the process's and each bounded context's. */
-export declare const processStore: StoreSource;
-/** What the process runs with now. */
-export declare function processNow(): Process;
-/**
- * The process's level of the context: what every use case of every bounded context runs with —
- * the tenant, the company, the language.
- *
- *     processContext.set({ tenant_id: "acme" });
- */
-export declare const processContext: Context;
-/**
- * How an error ended a use case, by default.
- *
- * Context: the backend reports what nobody expected and only that — a refusal it explained is
- * the business answering, not a fault. Here the same: a `TransportError` the server answered
- * with a 4xx is `refused`; a request the caller stopped waiting for is `aborted`; everything
- * else — a bug, a 5xx, a server nobody could reach — is `failed`, and reported.
- */
-export declare function outcomeOf(error: unknown): Outcome;

package/dist/services/process.js

@@ -1,57 +0,0 @@
-import { TransportError } from "../client/transport.js";
-import { contextAt, } from "../context/context.js";
-import { memoryContexts } from "../context/store.js";
-import { NO_TRACER, } from "../observability/ports.js";
-function settled(options) {
-    return {
-        tracer: options.tracer ?? NO_TRACER,
-        reporter: options.reporter,
-        store: options.context ?? memoryContexts(),
-        outcomeOf: options.outcomeOf ?? outcomeOf,
-    };
-}
-let current = settled({});
-const replacing = new Set();
-export function configureProcess(options = {}) {
-    const before = current.store;
-    current = settled(options);
-    if (current.store !== before)
-        for (const listener of [...replacing])
-            listener();
-}
-/** The process's store as every level of the context reads it — the process's and each bounded context's. */
-export const processStore = {
-    current: () => current.store,
-    replaced(listener) {
-        replacing.add(listener);
-        return () => void replacing.delete(listener);
-    },
-};
-/** What the process runs with now. */
-export function processNow() {
-    return current;
-}
-/**
- * The process's level of the context: what every use case of every bounded context runs with —
- * the tenant, the company, the language.
- *
- *     processContext.set({ tenant_id: "acme" });
- */
-export const processContext = contextAt("process", processStore);
-/**
- * How an error ended a use case, by default.
- *
- * Context: the backend reports what nobody expected and only that — a refusal it explained is
- * the business answering, not a fault. Here the same: a `TransportError` the server answered
- * with a 4xx is `refused`; a request the caller stopped waiting for is `aborted`; everything
- * else — a bug, a 5xx, a server nobody could reach — is `failed`, and reported.
- */
-export function outcomeOf(error) {
-    if (error instanceof TransportError && error.status !== null)
-        return error.status >= 400 && error.status < 500 ? "refused" : "failed";
-    if (error !== null &&
-        typeof error === "object" &&
-        error.name === "AbortError")
-        return "aborted";
-    return "failed";
-}

package/dist/services/screens.d.ts

@@ -1,2 +0,0 @@
-import type { Transport } from "../client/transport.js";
-export declare function screensTransport(transport: Transport, name?: string): Transport;