@johannc-dev/zyrk 0.0.0-stage → 0.2.1

package/dist/contracts.d.ts

@@ -0,0 +1,312 @@
+/**
+ * Schemas of what the service sends and accepts over HTTP and the event
+ * stream. The guest types live in `@johannc-dev/zyrk` (no Effect there).
+ */
+import { Effect, Result, Schema, type SchemaAST } from "effect";
+import { DecodeError, Failure } from "./errors.js";
+export { Failure } from "./errors.js";
+export { MAX_BUNDLE_BYTES } from "./limits.js";
+export declare const Json: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+export type Json = typeof Json.Type;
+export declare const Name: Schema.String;
+export declare const Address: Schema.String;
+export declare const Trigger: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"trade">;
+    readonly mint: Schema.optionalKey<Schema.String>;
+    readonly wallet: Schema.optionalKey<Schema.String>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"volume">;
+    readonly thresholdRaw: Schema.String;
+    readonly mint: Schema.optionalKey<Schema.String>;
+    readonly quote: Schema.optionalKey<Schema.String>;
+    readonly windowMs: Schema.optionalKey<Schema.Number>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"priceVariation">;
+    readonly mint: Schema.optionalKey<Schema.String>;
+    readonly mode: Schema.Literals<readonly ["rise", "fall", "both"]>;
+    readonly factor: Schema.Number;
+    readonly durationMs: Schema.Number;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"interval">;
+    readonly everyMs: Schema.Number;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"poolEvent">;
+    readonly mint: Schema.optionalKey<Schema.String>;
+    readonly events: Schema.optionalKey<Schema.$Array<Schema.String>>;
+}>]>;
+export type Trigger = typeof Trigger.Type;
+export declare const Subscription: Schema.Struct<{
+    readonly function: Schema.String;
+    readonly trigger: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"trade">;
+        readonly mint: Schema.optionalKey<Schema.String>;
+        readonly wallet: Schema.optionalKey<Schema.String>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"volume">;
+        readonly thresholdRaw: Schema.String;
+        readonly mint: Schema.optionalKey<Schema.String>;
+        readonly quote: Schema.optionalKey<Schema.String>;
+        readonly windowMs: Schema.optionalKey<Schema.Number>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"priceVariation">;
+        readonly mint: Schema.optionalKey<Schema.String>;
+        readonly mode: Schema.Literals<readonly ["rise", "fall", "both"]>;
+        readonly factor: Schema.Number;
+        readonly durationMs: Schema.Number;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"interval">;
+        readonly everyMs: Schema.Number;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"poolEvent">;
+        readonly mint: Schema.optionalKey<Schema.String>;
+        readonly events: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    }>]>;
+    readonly recovery: Schema.Literals<readonly ["latest", "replay"]>;
+    readonly maxReplayEvents: Schema.withDecodingDefaultKey<Schema.Number, never>;
+}>;
+export type Subscription = typeof Subscription.Type;
+/**
+ * Measured usage of an execution. Every field is optional so that a field
+ * added or renamed by the service does not break older clients.
+ */
+export declare const Usage: Schema.Struct<{
+    readonly cpuMs: Schema.optionalKey<Schema.Number>;
+    readonly wallMs: Schema.optionalKey<Schema.Number>;
+    readonly readBytes: Schema.optionalKey<Schema.Number>;
+    readonly readCalls: Schema.optionalKey<Schema.Number>;
+    /** CPU time spent serving history reads (not in `cpuMs`). */
+    readonly readMs: Schema.optionalKey<Schema.Number>;
+    readonly hostOps: Schema.optionalKey<Schema.Number>;
+    readonly outputBytes: Schema.optionalKey<Schema.Number>;
+    readonly peakHeapBytes: Schema.optionalKey<Schema.Number>;
+    /** User storage (`ctx.storage`), counted by the service. */
+    readonly storageReadBytes: Schema.optionalKey<Schema.Number>;
+    readonly storageWriteBytes: Schema.optionalKey<Schema.Number>;
+    readonly storageCalls: Schema.optionalKey<Schema.Number>;
+    readonly storageMs: Schema.optionalKey<Schema.Number>;
+}>;
+export type Usage = typeof Usage.Type;
+/** Every status an execution record can have. */
+export declare const JobStatus: Schema.Literals<readonly ["queued", "running", "succeeded", "failed", "cancelled", "expired", "acknowledged", "continued"]>;
+export type JobStatus = typeof JobStatus.Type;
+/** `GET /v1/functions/executions/{id}`. */
+export declare const Job: Schema.Union<readonly [Schema.Struct<{
+    readonly status: Schema.Literals<readonly ["continued"]>;
+    readonly nextExecutionId: Schema.String;
+    readonly id: Schema.String;
+    readonly program: Schema.String;
+    readonly version: Schema.String;
+    readonly workflow: Schema.String;
+    readonly function: Schema.String;
+    readonly createdAt: Schema.Number;
+    readonly attempt: Schema.Number;
+    readonly depth: Schema.optionalKey<Schema.Number>;
+    readonly onComplete: Schema.optionalKey<Schema.String>;
+    readonly parent: Schema.optionalKey<Schema.String>;
+    readonly subscription: Schema.optionalKey<Schema.String>;
+    readonly usage: Schema.optionalKey<Schema.Struct<{
+        readonly cpuMs: Schema.optionalKey<Schema.Number>;
+        readonly wallMs: Schema.optionalKey<Schema.Number>;
+        readonly readBytes: Schema.optionalKey<Schema.Number>;
+        readonly readCalls: Schema.optionalKey<Schema.Number>;
+        /** CPU time spent serving history reads (not in `cpuMs`). */
+        readonly readMs: Schema.optionalKey<Schema.Number>;
+        readonly hostOps: Schema.optionalKey<Schema.Number>;
+        readonly outputBytes: Schema.optionalKey<Schema.Number>;
+        readonly peakHeapBytes: Schema.optionalKey<Schema.Number>;
+        /** User storage (`ctx.storage`), counted by the service. */
+        readonly storageReadBytes: Schema.optionalKey<Schema.Number>;
+        readonly storageWriteBytes: Schema.optionalKey<Schema.Number>;
+        readonly storageCalls: Schema.optionalKey<Schema.Number>;
+        readonly storageMs: Schema.optionalKey<Schema.Number>;
+    }>>;
+    readonly logs: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+}>, Schema.Struct<{
+    readonly status: Schema.Literals<readonly ["queued", "running"]>;
+    readonly id: Schema.String;
+    readonly program: Schema.String;
+    readonly version: Schema.String;
+    readonly workflow: Schema.String;
+    readonly function: Schema.String;
+    readonly createdAt: Schema.Number;
+    readonly attempt: Schema.Number;
+    readonly depth: Schema.optionalKey<Schema.Number>;
+    readonly onComplete: Schema.optionalKey<Schema.String>;
+    readonly parent: Schema.optionalKey<Schema.String>;
+    readonly subscription: Schema.optionalKey<Schema.String>;
+    readonly usage: Schema.optionalKey<Schema.Struct<{
+        readonly cpuMs: Schema.optionalKey<Schema.Number>;
+        readonly wallMs: Schema.optionalKey<Schema.Number>;
+        readonly readBytes: Schema.optionalKey<Schema.Number>;
+        readonly readCalls: Schema.optionalKey<Schema.Number>;
+        /** CPU time spent serving history reads (not in `cpuMs`). */
+        readonly readMs: Schema.optionalKey<Schema.Number>;
+        readonly hostOps: Schema.optionalKey<Schema.Number>;
+        readonly outputBytes: Schema.optionalKey<Schema.Number>;
+        readonly peakHeapBytes: Schema.optionalKey<Schema.Number>;
+        /** User storage (`ctx.storage`), counted by the service. */
+        readonly storageReadBytes: Schema.optionalKey<Schema.Number>;
+        readonly storageWriteBytes: Schema.optionalKey<Schema.Number>;
+        readonly storageCalls: Schema.optionalKey<Schema.Number>;
+        readonly storageMs: Schema.optionalKey<Schema.Number>;
+    }>>;
+    readonly logs: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+}>, Schema.Struct<{
+    readonly status: Schema.Literals<readonly ["succeeded"]>;
+    readonly result: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly id: Schema.String;
+    readonly program: Schema.String;
+    readonly version: Schema.String;
+    readonly workflow: Schema.String;
+    readonly function: Schema.String;
+    readonly createdAt: Schema.Number;
+    readonly attempt: Schema.Number;
+    readonly depth: Schema.optionalKey<Schema.Number>;
+    readonly onComplete: Schema.optionalKey<Schema.String>;
+    readonly parent: Schema.optionalKey<Schema.String>;
+    readonly subscription: Schema.optionalKey<Schema.String>;
+    readonly usage: Schema.optionalKey<Schema.Struct<{
+        readonly cpuMs: Schema.optionalKey<Schema.Number>;
+        readonly wallMs: Schema.optionalKey<Schema.Number>;
+        readonly readBytes: Schema.optionalKey<Schema.Number>;
+        readonly readCalls: Schema.optionalKey<Schema.Number>;
+        /** CPU time spent serving history reads (not in `cpuMs`). */
+        readonly readMs: Schema.optionalKey<Schema.Number>;
+        readonly hostOps: Schema.optionalKey<Schema.Number>;
+        readonly outputBytes: Schema.optionalKey<Schema.Number>;
+        readonly peakHeapBytes: Schema.optionalKey<Schema.Number>;
+        /** User storage (`ctx.storage`), counted by the service. */
+        readonly storageReadBytes: Schema.optionalKey<Schema.Number>;
+        readonly storageWriteBytes: Schema.optionalKey<Schema.Number>;
+        readonly storageCalls: Schema.optionalKey<Schema.Number>;
+        readonly storageMs: Schema.optionalKey<Schema.Number>;
+    }>>;
+    readonly logs: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+}>, Schema.Struct<{
+    readonly status: Schema.Literals<readonly ["failed"]>;
+    readonly error: Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["program", "limit", "infrastructure", "permission"]>;
+        readonly code: Schema.String;
+        readonly message: Schema.String;
+    }>;
+    readonly id: Schema.String;
+    readonly program: Schema.String;
+    readonly version: Schema.String;
+    readonly workflow: Schema.String;
+    readonly function: Schema.String;
+    readonly createdAt: Schema.Number;
+    readonly attempt: Schema.Number;
+    readonly depth: Schema.optionalKey<Schema.Number>;
+    readonly onComplete: Schema.optionalKey<Schema.String>;
+    readonly parent: Schema.optionalKey<Schema.String>;
+    readonly subscription: Schema.optionalKey<Schema.String>;
+    readonly usage: Schema.optionalKey<Schema.Struct<{
+        readonly cpuMs: Schema.optionalKey<Schema.Number>;
+        readonly wallMs: Schema.optionalKey<Schema.Number>;
+        readonly readBytes: Schema.optionalKey<Schema.Number>;
+        readonly readCalls: Schema.optionalKey<Schema.Number>;
+        /** CPU time spent serving history reads (not in `cpuMs`). */
+        readonly readMs: Schema.optionalKey<Schema.Number>;
+        readonly hostOps: Schema.optionalKey<Schema.Number>;
+        readonly outputBytes: Schema.optionalKey<Schema.Number>;
+        readonly peakHeapBytes: Schema.optionalKey<Schema.Number>;
+        /** User storage (`ctx.storage`), counted by the service. */
+        readonly storageReadBytes: Schema.optionalKey<Schema.Number>;
+        readonly storageWriteBytes: Schema.optionalKey<Schema.Number>;
+        readonly storageCalls: Schema.optionalKey<Schema.Number>;
+        readonly storageMs: Schema.optionalKey<Schema.Number>;
+    }>>;
+    readonly logs: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+}>, Schema.Struct<{
+    readonly status: Schema.Literals<readonly ["cancelled", "expired", "acknowledged"]>;
+    readonly id: Schema.String;
+    readonly program: Schema.String;
+    readonly version: Schema.String;
+    readonly workflow: Schema.String;
+    readonly function: Schema.String;
+    readonly createdAt: Schema.Number;
+    readonly attempt: Schema.Number;
+    readonly depth: Schema.optionalKey<Schema.Number>;
+    readonly onComplete: Schema.optionalKey<Schema.String>;
+    readonly parent: Schema.optionalKey<Schema.String>;
+    readonly subscription: Schema.optionalKey<Schema.String>;
+    readonly usage: Schema.optionalKey<Schema.Struct<{
+        readonly cpuMs: Schema.optionalKey<Schema.Number>;
+        readonly wallMs: Schema.optionalKey<Schema.Number>;
+        readonly readBytes: Schema.optionalKey<Schema.Number>;
+        readonly readCalls: Schema.optionalKey<Schema.Number>;
+        /** CPU time spent serving history reads (not in `cpuMs`). */
+        readonly readMs: Schema.optionalKey<Schema.Number>;
+        readonly hostOps: Schema.optionalKey<Schema.Number>;
+        readonly outputBytes: Schema.optionalKey<Schema.Number>;
+        readonly peakHeapBytes: Schema.optionalKey<Schema.Number>;
+        /** User storage (`ctx.storage`), counted by the service. */
+        readonly storageReadBytes: Schema.optionalKey<Schema.Number>;
+        readonly storageWriteBytes: Schema.optionalKey<Schema.Number>;
+        readonly storageCalls: Schema.optionalKey<Schema.Number>;
+        readonly storageMs: Schema.optionalKey<Schema.Number>;
+    }>>;
+    readonly logs: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+}>]>;
+export type Job = typeof Job.Type;
+/** Same shape as the guest's `JobResult` (`ctx.jobs.wait/result`). */
+export type JobResult = {
+    readonly id: string;
+    readonly status: "queued" | "running";
+} | {
+    readonly id: string;
+    readonly status: "succeeded";
+    readonly result: Json;
+} | {
+    readonly id: string;
+    readonly status: "failed";
+    readonly error: Failure;
+} | {
+    readonly id: string;
+    readonly status: "cancelled" | "expired" | "acknowledged";
+};
+/** `POST /v1/functions/programs/{name}/invoke` (202). */
+export declare const Started: Schema.Struct<{
+    readonly id: Schema.String;
+}>;
+/** `GET /v1/functions/programs`. */
+export declare const ProgramSummary: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly version: Schema.String;
+    readonly stateVersion: Schema.Number;
+    readonly paused: Schema.Boolean;
+}>;
+export type ProgramSummary = typeof ProgramSummary.Type;
+/** A schema that decodes without Effect services, so decoding is synchronous. */
+export type Decodable = Schema.Top & {
+    readonly DecodingServices: never;
+};
+export declare const NonNegativeInt: Schema.Number;
+/** Decodes `unknown` with `options`, mapping the schema error through `onError`. */
+export declare const decodeWith: <S extends Decodable, E>(schema: S, options: SchemaAST.ParseOptions | undefined, onError: (message: string) => E) => (input: unknown) => Result.Result<S["Type"], E>;
+/** A stream event kind: every job status transition, plus guest `ctx.emit`. */
+export declare const ExecutionEventKind: Schema.Literals<readonly ["queued", "running", "succeeded", "failed", "cancelled", "expired", "acknowledged", "continued", "emitted"]>;
+export type ExecutionEventKind = typeof ExecutionEventKind.Type;
+export declare const ExecutionEvent: Schema.Struct<{
+    readonly seq: Schema.Number;
+    readonly executionId: Schema.String;
+    readonly workflow: Schema.String;
+    readonly program: Schema.String;
+    readonly function: Schema.String;
+    readonly version: Schema.String;
+    readonly attempt: Schema.Number;
+    readonly createdAt: Schema.Number;
+    readonly kind: Schema.Literals<readonly ["queued", "running", "succeeded", "failed", "cancelled", "expired", "acknowledged", "continued", "emitted"]>;
+    readonly data: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>;
+export type ExecutionEvent = typeof ExecutionEvent.Type;
+/** Events between `resumeAfter` and `headSeq` were dropped by the server. */
+export declare const Gap: Schema.Struct<{
+    readonly resumeAfter: Schema.Number;
+    readonly headSeq: Schema.Number;
+}>;
+export type Gap = typeof Gap.Type;
+/** Decodes service data; unknown keys are stripped. */
+export declare const decode: <S extends Decodable>(schema: S, what: string) => (input: unknown) => Effect.Effect<S["Type"], DecodeError>;
+/** The guest-facing view of an execution record (continuations not followed). */
+export declare const toJobResult: (job: Job) => JobResult;

package/dist/contracts.js

@@ -0,0 +1,154 @@
+import { Effect, Result, Schema } from "effect";
+import { DecodeError, Failure } from "./errors.js";
+export { Failure } from "./errors.js";
+export { MAX_BUNDLE_BYTES } from "./limits.js";
+export const Json = Schema.Json;
+export const Name = Schema.String.check(Schema.isPattern(/^[A-Za-z][A-Za-z0-9_-]{0,63}$/)).annotate({ identifier: "Name" });
+export const Address = Schema.String.check(Schema.isPattern(/^[1-9A-HJ-NP-Za-km-z]{32,44}$/)).annotate({ identifier: "Address" });
+const IntBetween = (min, max) => Schema.Number.check(Schema.isInt(), Schema.isBetween({ minimum: min, maximum: max }));
+const PriceFactor = Schema.Number.check(Schema.isBetween({ minimum: 1.01, maximum: 11 }), Schema.makeFilter((n) => Math.abs(n * 10_000 - Math.round(n * 10_000)) < 1e-6, { description: "at most four decimals" }));
+export const Trigger = Schema.Union([
+    Schema.Struct({
+        kind: Schema.Literal("trade"),
+        mint: Schema.optionalKey(Address),
+        wallet: Schema.optionalKey(Address),
+    }),
+    Schema.Struct({
+        kind: Schema.Literal("volume"),
+        thresholdRaw: Schema.String.check(Schema.isPattern(/^[1-9][0-9]{0,19}$/)),
+        mint: Schema.optionalKey(Address),
+        quote: Schema.optionalKey(Address),
+        windowMs: Schema.optionalKey(IntBetween(1000, 3600000)),
+    }),
+    Schema.Struct({
+        kind: Schema.Literal("priceVariation"),
+        mint: Schema.optionalKey(Address),
+        mode: Schema.Literals(["rise", "fall", "both"]),
+        factor: PriceFactor,
+        durationMs: IntBetween(15000, 3600000),
+    }),
+    Schema.Struct({
+        kind: Schema.Literal("interval"),
+        everyMs: IntBetween(1000, 86400000),
+    }),
+    Schema.Struct({
+        kind: Schema.Literal("poolEvent"),
+        mint: Schema.optionalKey(Address),
+        events: Schema.optionalKey(Schema.Array(Schema.String)),
+    }),
+]);
+export const Subscription = Schema.Struct({
+    function: Name,
+    trigger: Trigger,
+    recovery: Schema.Literals(["latest", "replay"]),
+    maxReplayEvents: IntBetween(1, 10000).pipe(Schema.withDecodingDefaultKey(Effect.succeed(1000))),
+});
+export const Usage = Schema.Struct({
+    cpuMs: Schema.optionalKey(Schema.Number),
+    wallMs: Schema.optionalKey(Schema.Number),
+    readBytes: Schema.optionalKey(Schema.Number),
+    readCalls: Schema.optionalKey(Schema.Number),
+    readMs: Schema.optionalKey(Schema.Number),
+    hostOps: Schema.optionalKey(Schema.Number),
+    outputBytes: Schema.optionalKey(Schema.Number),
+    peakHeapBytes: Schema.optionalKey(Schema.Number),
+    storageReadBytes: Schema.optionalKey(Schema.Number),
+    storageWriteBytes: Schema.optionalKey(Schema.Number),
+    storageCalls: Schema.optionalKey(Schema.Number),
+    storageMs: Schema.optionalKey(Schema.Number),
+});
+export const JobStatus = Schema.Literals([
+    "queued",
+    "running",
+    "succeeded",
+    "failed",
+    "cancelled",
+    "expired",
+    "acknowledged",
+    "continued",
+]);
+const common = {
+    id: Schema.String,
+    program: Schema.String,
+    version: Schema.String,
+    workflow: Schema.String,
+    function: Schema.String,
+    createdAt: Schema.Number,
+    attempt: Schema.Number,
+    depth: Schema.optionalKey(Schema.Number),
+    onComplete: Schema.optionalKey(Schema.String),
+    parent: Schema.optionalKey(Schema.String),
+    subscription: Schema.optionalKey(Schema.String),
+    usage: Schema.optionalKey(Usage),
+    logs: Schema.optionalKey(Schema.Array(Json)),
+};
+export const Job = Schema.Union([
+    Schema.Struct({
+        ...common,
+        status: JobStatus.pick(["continued"]),
+        nextExecutionId: Schema.String,
+    }),
+    Schema.Struct({ ...common, status: JobStatus.pick(["queued", "running"]) }),
+    Schema.Struct({
+        ...common,
+        status: JobStatus.pick(["succeeded"]),
+        result: Json,
+    }),
+    Schema.Struct({
+        ...common,
+        status: JobStatus.pick(["failed"]),
+        error: Failure,
+    }),
+    Schema.Struct({
+        ...common,
+        status: JobStatus.pick(["cancelled", "expired", "acknowledged"]),
+    }),
+]);
+export const Started = Schema.Struct({ id: Schema.String });
+export const ProgramSummary = Schema.Struct({
+    name: Schema.String,
+    version: Schema.String,
+    stateVersion: Schema.Number,
+    paused: Schema.Boolean,
+});
+export const NonNegativeInt = Schema.Number.check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(0));
+export const decodeWith = (schema, options, onError) => {
+    const parse = Schema.decodeUnknownResult(schema);
+    return (input) => Result.mapError(parse(input, options), (error) => onError(error.message));
+};
+export const ExecutionEventKind = Schema.Literals([
+    ...JobStatus.literals,
+    "emitted",
+]);
+export const ExecutionEvent = Schema.Struct({
+    seq: NonNegativeInt,
+    executionId: Schema.String,
+    workflow: Schema.String,
+    program: Schema.String,
+    function: Schema.String,
+    version: Schema.String,
+    attempt: Schema.Number,
+    createdAt: Schema.Number,
+    kind: ExecutionEventKind,
+    data: Json,
+});
+export const Gap = Schema.Struct({
+    resumeAfter: Schema.Number,
+    headSeq: Schema.Number,
+});
+export const decode = (schema, what) => {
+    const parse = decodeWith(schema, { errors: "all" }, (message) => new DecodeError({ what, message }));
+    return (input) => Effect.suspend(() => Effect.fromResult(parse(input)));
+};
+export const toJobResult = (job) => {
+    switch (job.status) {
+        case "succeeded":
+            return { id: job.id, status: job.status, result: job.result };
+        case "failed":
+            return { id: job.id, status: job.status, error: job.error };
+        case "continued":
+            return { id: job.id, status: "running" };
+        default:
+            return { id: job.id, status: job.status };
+    }
+};

package/dist/errors.d.ts

@@ -0,0 +1,99 @@
+import { Schema } from "effect";
+/** Why an execution failed, as reported by the service. */
+export declare const FailureKind: Schema.Literals<readonly ["program", "limit", "infrastructure", "permission"]>;
+export type FailureKind = typeof FailureKind.Type;
+export declare const Failure: Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["program", "limit", "infrastructure", "permission"]>;
+    readonly code: Schema.String;
+    readonly message: Schema.String;
+}>;
+export type Failure = typeof Failure.Type;
+/** The message of a thrown value: `Error#message`, else its string form. */
+export declare const messageOf: (cause: unknown) => string;
+declare const ConfigError_base: Schema.Class<ConfigError, Schema.TaggedStruct<"ConfigError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The CLI or client is missing configuration (URL, API key, arguments). */
+export declare class ConfigError extends ConfigError_base {
+}
+declare const NetworkError_base: Schema.Class<NetworkError, Schema.TaggedStruct<"NetworkError", {
+    readonly url: Schema.String;
+    readonly message: Schema.String;
+    readonly cause: Schema.Unknown;
+    readonly reason: Schema.optional<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The service could not be reached (DNS, TLS, connection reset, abort), or
+ * it ended a live stream. `reason` is set by the stream:
+ * - `functions_disabled`: Functions access was removed from the account;
+ * - `channel_closed`: the server closed the stream (subscribe again with
+ *   `afterSeq`);
+ * - the server's reason of a refused join (e.g. `functions_unavailable`).
+ */
+export declare class NetworkError extends NetworkError_base {
+}
+declare const ApiError_base: Schema.Class<ApiError, Schema.TaggedStruct<"ApiError", {
+    readonly status: Schema.Number;
+    /** Stable machine code, e.g. `program_not_found`, `sdk_version_unsupported`. */
+    readonly code: Schema.String;
+    readonly message: Schema.String;
+    readonly failure: Schema.optional<Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["program", "limit", "infrastructure", "permission"]>;
+        readonly code: Schema.String;
+        readonly message: Schema.String;
+    }>>;
+    readonly body: Schema.Unknown;
+}>, import("effect/Cause").YieldableError>;
+/** The service answered with a non-2xx status. */
+export declare class ApiError extends ApiError_base {
+}
+declare const DecodeError_base: Schema.Class<DecodeError, Schema.TaggedStruct<"DecodeError", {
+    readonly what: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** A response or event did not match the expected contract. */
+export declare class DecodeError extends DecodeError_base {
+}
+declare const ExecutionFailed_base: Schema.Class<ExecutionFailed, Schema.TaggedStruct<"ExecutionFailed", {
+    readonly executionId: Schema.String;
+    readonly failure: Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["program", "limit", "infrastructure", "permission"]>;
+        readonly code: Schema.String;
+        readonly message: Schema.String;
+    }>;
+}>, import("effect/Cause").YieldableError>;
+/** The execution finished with a failure raised by the program or the runtime. */
+export declare class ExecutionFailed extends ExecutionFailed_base {
+    get message(): string;
+}
+declare const ExecutionEnded_base: Schema.Class<ExecutionEnded, Schema.TaggedStruct<"ExecutionEnded", {
+    readonly executionId: Schema.String;
+    readonly status: Schema.Literals<readonly ["cancelled", "expired", "acknowledged"]>;
+}>, import("effect/Cause").YieldableError>;
+/** The execution ended without a result (cancelled, expired, acknowledged). */
+export declare class ExecutionEnded extends ExecutionEnded_base {
+    get message(): string;
+}
+declare const WaitTimeout_base: Schema.Class<WaitTimeout, Schema.TaggedStruct<"WaitTimeout", {
+    readonly executionId: Schema.String;
+    readonly timeoutMs: Schema.Number;
+}>, import("effect/Cause").YieldableError>;
+/** `wait` gave up after `timeoutMs`; the execution keeps running. */
+export declare class WaitTimeout extends WaitTimeout_base {
+    get message(): string;
+}
+declare const BuildError_base: Schema.Class<BuildError, Schema.TaggedStruct<"BuildError", {
+    readonly stage: Schema.Literals<readonly ["v1_api", "forbidden_import", "forbidden_global", "typecheck", "bundle", "size", "write"]>;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Building the program failed. `stage` is stable:
+ * - `v1_api`: the program uses the removed 0.1 API (`ctx.data.query/pages`);
+ * - `forbidden_import`: a Node module (`fs`, `net`, `node:*`…);
+ * - `forbidden_global`: `fetch` or another network API in the program's code;
+ * - `typecheck`, `bundle`, `size` (over 1 MiB), `write`.
+ */
+export declare class BuildError extends BuildError_base {
+}
+export type ClientError = ConfigError | NetworkError | ApiError | DecodeError | ExecutionFailed | ExecutionEnded | WaitTimeout;
+export {};

package/dist/errors.js

@@ -0,0 +1,63 @@
+import { Schema } from "effect";
+export const FailureKind = Schema.Literals([
+    "program",
+    "limit",
+    "infrastructure",
+    "permission",
+]);
+export const Failure = Schema.Struct({
+    kind: FailureKind,
+    code: Schema.String.check(Schema.isMaxLength(128)),
+    message: Schema.String.check(Schema.isMaxLength(2048)),
+});
+export const messageOf = (cause) => cause instanceof Error ? cause.message : String(cause);
+export class ConfigError extends Schema.TaggedError()("ConfigError", { message: Schema.String }) {
+}
+export class NetworkError extends Schema.TaggedError()("NetworkError", {
+    url: Schema.String,
+    message: Schema.String,
+    cause: Schema.Unknown,
+    reason: Schema.optional(Schema.String),
+}) {
+}
+export class ApiError extends Schema.TaggedError()("ApiError", {
+    status: Schema.Number,
+    code: Schema.String,
+    message: Schema.String,
+    failure: Schema.optional(Failure),
+    body: Schema.Unknown,
+}) {
+}
+export class DecodeError extends Schema.TaggedError()("DecodeError", { what: Schema.String, message: Schema.String }) {
+}
+export class ExecutionFailed extends Schema.TaggedError()("ExecutionFailed", { executionId: Schema.String, failure: Failure }) {
+    get message() {
+        return `Execution ${this.executionId} failed (${this.failure.kind}/${this.failure.code}): ${this.failure.message}`;
+    }
+}
+export class ExecutionEnded extends Schema.TaggedError()("ExecutionEnded", {
+    executionId: Schema.String,
+    status: Schema.Literals(["cancelled", "expired", "acknowledged"]),
+}) {
+    get message() {
+        return `Execution ${this.executionId} ended without result: ${this.status}`;
+    }
+}
+export class WaitTimeout extends Schema.TaggedError()("WaitTimeout", { executionId: Schema.String, timeoutMs: Schema.Number }) {
+    get message() {
+        return `Execution ${this.executionId} not finished after ${this.timeoutMs} ms`;
+    }
+}
+export class BuildError extends Schema.TaggedError()("BuildError", {
+    stage: Schema.Literals([
+        "v1_api",
+        "forbidden_import",
+        "forbidden_global",
+        "typecheck",
+        "bundle",
+        "size",
+        "write",
+    ]),
+    message: Schema.String,
+}) {
+}