@relayfx/test 0.3.1 → 0.3.3

package/dist/types/runtime/workspace/workspace-provider-service.d.ts

@@ -1,112 +0,0 @@
-import { Ids, Workspace } from "../../schema/index";
-import { Context, Effect, Layer, Schema } from "effect";
-declare const WorkspaceNotFound_base: Schema.Class<WorkspaceNotFound, Schema.TaggedStruct<"WorkspaceNotFound", {
-    readonly sandbox_ref: Schema.brand<Schema.String, "Relay.WorkspaceRef"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WorkspaceRef">;
-    };
-}>, import("effect/Cause").YieldableError>;
-export declare class WorkspaceNotFound extends WorkspaceNotFound_base {
-}
-declare const WorkspaceUnavailable_base: Schema.Class<WorkspaceUnavailable, Schema.TaggedStruct<"WorkspaceUnavailable", {
-    readonly sandbox_ref: Schema.brand<Schema.String, "Relay.WorkspaceRef"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WorkspaceRef">;
-    };
-    readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class WorkspaceUnavailable extends WorkspaceUnavailable_base {
-}
-declare const WorkspaceCapabilityUnsupported_base: Schema.Class<WorkspaceCapabilityUnsupported, Schema.TaggedStruct<"WorkspaceCapabilityUnsupported", {
-    readonly capability: Schema.Literals<readonly ["suspend", "snapshot", "fork"]>;
-    readonly provider_key: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class WorkspaceCapabilityUnsupported extends WorkspaceCapabilityUnsupported_base {
-}
-declare const WorkspaceProviderError_base: Schema.Class<WorkspaceProviderError, Schema.TaggedStruct<"WorkspaceProviderError", {
-    readonly provider_key: Schema.String;
-    readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class WorkspaceProviderError extends WorkspaceProviderError_base {
-}
-export interface WorkspaceCommandInput {
-    readonly command: string;
-    readonly args?: ReadonlyArray<string>;
-    readonly cwd?: string;
-    readonly input?: string;
-}
-export interface WorkspaceCommandResult {
-    readonly exitCode: number;
-    readonly stdout: string;
-    readonly stderr: string;
-}
-export interface WorkspaceSpec {
-    readonly executionId: Ids.ExecutionId;
-    readonly request?: Workspace.WorkspaceRequest;
-}
-export interface WorkspaceHandle {
-    readonly ref: Ids.WorkspaceRef;
-    readonly providerKey: Workspace.WorkspaceProviderKey;
-    readonly capabilities: Workspace.WorkspaceCapabilities;
-    readonly readFile: (path: string) => Effect.Effect<string, WorkspaceNotFound | WorkspaceProviderError>;
-    readonly writeFile: (path: string, content: string) => Effect.Effect<void, WorkspaceNotFound | WorkspaceProviderError>;
-    readonly exec: (input: WorkspaceCommandInput) => Effect.Effect<WorkspaceCommandResult, WorkspaceProviderError>;
-}
-export interface Interface {
-    readonly providerKey: Workspace.WorkspaceProviderKey;
-    readonly capabilities: Workspace.WorkspaceCapabilities;
-    readonly acquire: (spec: WorkspaceSpec) => Effect.Effect<WorkspaceHandle, WorkspaceProviderError>;
-    readonly resume: (ref: Ids.WorkspaceRef) => Effect.Effect<WorkspaceHandle, WorkspaceNotFound | WorkspaceUnavailable | WorkspaceProviderError>;
-    readonly suspend: (ref: Ids.WorkspaceRef) => Effect.Effect<Ids.WorkspaceRef, WorkspaceNotFound | WorkspaceProviderError>;
-    readonly snapshot: (ref: Ids.WorkspaceRef, name?: string) => Effect.Effect<Ids.SnapshotRef, WorkspaceNotFound | WorkspaceCapabilityUnsupported | WorkspaceProviderError>;
-    readonly fork: (ref: Ids.WorkspaceRef, spec?: Partial<WorkspaceSpec>) => Effect.Effect<Ids.WorkspaceRef, WorkspaceNotFound | WorkspaceCapabilityUnsupported | WorkspaceProviderError>;
-    readonly destroy: (ref: Ids.WorkspaceRef) => Effect.Effect<void, WorkspaceProviderError>;
-}
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/workspace/workspace-provider-service/Service", Interface>;
-export declare class Service extends Service_base {
-}
-export declare const memoryHandle: {
-    (ref: Ids.WorkspaceRef, providerKey: Workspace.WorkspaceProviderKey): WorkspaceHandle;
-    (ref: Ids.WorkspaceRef): WorkspaceHandle;
-    (providerKey: Workspace.WorkspaceProviderKey): (ref: Ids.WorkspaceRef) => WorkspaceHandle;
-};
-export declare const memoryLayer: (providerKey?: Workspace.WorkspaceProviderKey) => Layer.Layer<Service, never, never>;
-export interface DaytonaSandbox {
-    readonly id: string;
-    state?: string;
-    readonly start: (_?: void) => Effect.Effect<void, WorkspaceProviderError>;
-    readonly stop: (_?: void) => Effect.Effect<void, WorkspaceProviderError>;
-    readonly readFile?: (path: string) => Effect.Effect<string, WorkspaceProviderError>;
-    readonly writeFile?: (path: string, content: string) => Effect.Effect<void, WorkspaceProviderError>;
-    readonly exec?: (input: WorkspaceCommandInput) => Effect.Effect<WorkspaceCommandResult, WorkspaceProviderError>;
-    readonly createSnapshot?: (name?: string) => Effect.Effect<string, WorkspaceProviderError>;
-    readonly fork?: () => Effect.Effect<string, WorkspaceProviderError>;
-}
-export interface DaytonaClient {
-    readonly create: (options: Record<string, unknown>) => Effect.Effect<DaytonaSandbox, WorkspaceProviderError>;
-    readonly get: (ref: Ids.WorkspaceRef) => Effect.Effect<DaytonaSandbox, WorkspaceNotFound | WorkspaceProviderError>;
-    readonly delete: (ref: Ids.WorkspaceRef) => Effect.Effect<void, WorkspaceProviderError>;
-}
-export interface DaytonaLayerConfig {
-    readonly providerKey?: Workspace.WorkspaceProviderKey;
-    readonly autoArchiveInterval?: number;
-    readonly client: DaytonaClient;
-}
-export declare const daytonaLayer: (config: DaytonaLayerConfig) => Layer.Layer<Service, never, never>;
-export interface LocalDockerCommand {
-    readonly args: ReadonlyArray<string>;
-    readonly input?: string;
-}
-export interface LocalDockerLayerConfig {
-    readonly providerKey?: Workspace.WorkspaceProviderKey;
-    readonly defaultImage: string;
-    readonly volumePrefix: string;
-    readonly run: (command: LocalDockerCommand) => Effect.Effect<WorkspaceCommandResult, WorkspaceProviderError>;
-}
-export declare const localDockerLayer: (config: LocalDockerLayerConfig) => Layer.Layer<Service, never, never>;
-export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
-export declare const acquire: (spec: WorkspaceSpec) => Effect.Effect<WorkspaceHandle, WorkspaceProviderError, Service>;
-export declare const resume: (ref: string & import("effect/Brand").Brand<"Relay.WorkspaceRef">) => Effect.Effect<WorkspaceHandle, WorkspaceNotFound | WorkspaceProviderError | WorkspaceUnavailable, Service>;
-export declare const suspend: (ref: string & import("effect/Brand").Brand<"Relay.WorkspaceRef">) => Effect.Effect<string & import("effect/Brand").Brand<"Relay.WorkspaceRef">, WorkspaceNotFound | WorkspaceProviderError, Service>;
-export declare const snapshot: (ref: string & import("effect/Brand").Brand<"Relay.WorkspaceRef">, name?: string | undefined) => Effect.Effect<string & import("effect/Brand").Brand<"Relay.SnapshotRef">, WorkspaceCapabilityUnsupported | WorkspaceNotFound | WorkspaceProviderError, Service>;
-export declare const fork: (ref: string & import("effect/Brand").Brand<"Relay.WorkspaceRef">, spec?: Partial<WorkspaceSpec> | undefined) => Effect.Effect<string & import("effect/Brand").Brand<"Relay.WorkspaceRef">, WorkspaceCapabilityUnsupported | WorkspaceNotFound | WorkspaceProviderError, Service>;
-export declare const destroy: (ref: string & import("effect/Brand").Brand<"Relay.WorkspaceRef">) => Effect.Effect<void, WorkspaceProviderError, Service>;
-export {};

package/dist/types/runtime/workspace/workspace-runtime-service.d.ts

@@ -1,21 +0,0 @@
-import { Context, Effect, Layer, Schema } from "effect";
-import type { WorkspaceCommandInput, WorkspaceCommandResult, WorkspaceHandle } from "./workspace-provider-service";
-declare const WorkspaceRuntimeError_base: Schema.Class<WorkspaceRuntimeError, Schema.TaggedStruct<"WorkspaceRuntimeError", {
-    readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class WorkspaceRuntimeError extends WorkspaceRuntimeError_base {
-}
-export interface Interface {
-    readonly readFile: (path: string) => Effect.Effect<string, WorkspaceRuntimeError>;
-    readonly writeFile: (path: string, content: string) => Effect.Effect<void, WorkspaceRuntimeError>;
-    readonly exec: (input: WorkspaceCommandInput) => Effect.Effect<WorkspaceCommandResult, WorkspaceRuntimeError>;
-}
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/workspace/workspace-runtime-service/Service", Interface>;
-export declare class Service extends Service_base {
-}
-export declare const layerFromHandle: (handle: WorkspaceHandle) => Layer.Layer<Service, never, never>;
-export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
-export declare const readFile: (path: string) => Effect.Effect<string, WorkspaceRuntimeError, Service>;
-export declare const writeFile: (path: string, content: string) => Effect.Effect<void, WorkspaceRuntimeError, Service>;
-export declare const exec: (input: WorkspaceCommandInput) => Effect.Effect<WorkspaceCommandResult, WorkspaceRuntimeError, Service>;
-export {};

package/dist/types/schema/address-schema.d.ts

@@ -1,77 +0,0 @@
-import { Schema } from "effect";
-export declare const RouteKind: Schema.Literals<readonly ["local-agent", "local-execution", "remote-relay", "local-adapter", "unavailable", "deferred-retry"]>;
-export type RouteKind = typeof RouteKind.Type;
-export declare const Route: Schema.Struct<{
-    readonly kind: Schema.Literals<readonly ["local-agent", "local-execution", "remote-relay", "local-adapter", "unavailable", "deferred-retry"]>;
-    readonly route_key: Schema.String;
-    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-}>;
-export interface Route extends Schema.Schema.Type<typeof Route> {
-}
-export declare const RouteRecord: Schema.Struct<{
-    readonly id: Schema.brand<Schema.String, "Relay.AddressBookEntryId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressBookEntryId">;
-    };
-    readonly address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
-    };
-    readonly route: Schema.Struct<{
-        readonly kind: Schema.Literals<readonly ["local-agent", "local-execution", "remote-relay", "local-adapter", "unavailable", "deferred-retry"]>;
-        readonly route_key: Schema.String;
-        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-    }>;
-    readonly created_at: Schema.Int;
-    readonly updated_at: Schema.Int;
-}>;
-export interface RouteRecord extends Schema.Schema.Type<typeof RouteRecord> {
-}
-export declare const RegisterRoutePayload: Schema.Struct<{
-    readonly address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
-    };
-    readonly route: Schema.Struct<{
-        readonly kind: Schema.Literals<readonly ["local-agent", "local-execution", "remote-relay", "local-adapter", "unavailable", "deferred-retry"]>;
-        readonly route_key: Schema.String;
-        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-    }>;
-}>;
-export interface RegisterRoutePayload extends Schema.Schema.Type<typeof RegisterRoutePayload> {
-}
-export declare const RouteRegistered: Schema.Struct<{
-    readonly record: Schema.Struct<{
-        readonly id: Schema.brand<Schema.String, "Relay.AddressBookEntryId"> & {
-            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressBookEntryId">;
-        };
-        readonly address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
-            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
-        };
-        readonly route: Schema.Struct<{
-            readonly kind: Schema.Literals<readonly ["local-agent", "local-execution", "remote-relay", "local-adapter", "unavailable", "deferred-retry"]>;
-            readonly route_key: Schema.String;
-            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-        }>;
-        readonly created_at: Schema.Int;
-        readonly updated_at: Schema.Int;
-    }>;
-}>;
-export interface RouteRegistered extends Schema.Schema.Type<typeof RouteRegistered> {
-}
-export declare const RouteList: Schema.Struct<{
-    readonly records: Schema.$Array<Schema.Struct<{
-        readonly id: Schema.brand<Schema.String, "Relay.AddressBookEntryId"> & {
-            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressBookEntryId">;
-        };
-        readonly address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
-            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
-        };
-        readonly route: Schema.Struct<{
-            readonly kind: Schema.Literals<readonly ["local-agent", "local-execution", "remote-relay", "local-adapter", "unavailable", "deferred-retry"]>;
-            readonly route_key: Schema.String;
-            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-        }>;
-        readonly created_at: Schema.Int;
-        readonly updated_at: Schema.Int;
-    }>>;
-}>;
-export interface RouteList extends Schema.Schema.Type<typeof RouteList> {
-}