@swirls/looms 0.0.1

package/dist/approval/module.d.ts

@@ -0,0 +1,342 @@
+export declare function approval(): import("@swirls/looms/core").RuntimeModule<"approval", import("@swirls/looms/core").EventCatalog<"approval", {
+    requested: import("effect/Schema").Struct<{
+        readonly approvalId: import("effect/Schema").String;
+        readonly title: import("effect/Schema").String;
+        readonly description: import("effect/Schema").optional<import("effect/Schema").String>;
+        readonly actions: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly id: import("effect/Schema").String;
+            readonly label: import("effect/Schema").String;
+            readonly outcome: import("effect/Schema").Union<readonly [import("effect/Schema").Literal<"approve">, import("effect/Schema").Literal<"reject">]>;
+        }>>;
+        readonly schema: import("effect/Schema").optional<import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>;
+    }>;
+    decided: import("effect/Schema").Struct<{
+        readonly approvalId: import("effect/Schema").String;
+        readonly actionId: import("effect/Schema").String;
+        readonly outcome: import("effect/Schema").Union<readonly [import("effect/Schema").Literal<"approve">, import("effect/Schema").Literal<"reject">]>;
+        readonly payload: import("effect/Schema").optional<import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>;
+    }>;
+    timed_out: import("effect/Schema").Struct<{
+        readonly approvalId: import("effect/Schema").String;
+    }>;
+}>, {
+    request: import("@swirls/looms/core").EffectDefinition<{
+        readonly approvalId: string;
+        readonly title: string;
+        readonly description?: string | undefined;
+        readonly actions: readonly {
+            readonly id: string;
+            readonly label: string;
+            readonly outcome: "approve" | "reject";
+        }[];
+        readonly schema?: import("effect/Schema").Json | undefined;
+    }, never, (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "approval.decided";
+        readonly payload: {
+            readonly approvalId: string;
+            readonly actionId: string;
+            readonly outcome: "approve" | "reject";
+            readonly payload?: import("effect/Schema").Json | undefined;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "approval.requested";
+        readonly payload: {
+            readonly approvalId: string;
+            readonly title: string;
+            readonly description?: string | undefined;
+            readonly actions: readonly {
+                readonly id: string;
+                readonly label: string;
+                readonly outcome: "approve" | "reject";
+            }[];
+            readonly schema?: import("effect/Schema").Json | undefined;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "approval.timed_out";
+        readonly payload: {
+            readonly approvalId: string;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.effect.failed";
+        readonly payload: {
+            readonly effectId: string;
+            readonly error: string;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.run.completed";
+        readonly payload: {
+            readonly output: import("effect/Schema").Json;
+            readonly error: string | null;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.run.started";
+        readonly payload: {
+            readonly rootThreadId?: string | undefined;
+            readonly kind: string;
+            readonly definitionName: string;
+            readonly input: import("effect/Schema").Json;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.signal.received";
+        readonly payload: {
+            readonly signalType: string;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.snapshot.taken";
+        readonly payload: {
+            readonly seq: number;
+            readonly stateHash: string;
+            readonly state?: import("effect/Schema").Json | undefined;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.thread.cancelled";
+        readonly payload: {
+            readonly threadId: string;
+            readonly reason?: string | undefined;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.thread.completed";
+        readonly payload: {
+            readonly threadId: string;
+            readonly output: import("effect/Schema").Json;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.thread.failed";
+        readonly payload: {
+            readonly threadId: string;
+            readonly error: string;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.thread.started";
+        readonly payload: {
+            readonly threadId: string;
+            readonly kind: string;
+            readonly definitionName: string;
+            readonly input: import("effect/Schema").Json;
+            readonly parentThreadId: string | null;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.timer.fired";
+        readonly payload: {
+            readonly timerId: string;
+            readonly waitId: string;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.timer.set";
+        readonly payload: {
+            readonly timerId: string;
+            readonly waitId: string;
+            readonly wakeAt: number;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.wait.registered";
+        readonly payload: {
+            readonly waitId: string;
+            readonly threadId?: string | undefined;
+            readonly on: {
+                readonly type: string | readonly string[];
+                readonly match?: import("effect/Schema").Json | undefined;
+            } | {
+                readonly timerAt: number;
+            };
+            readonly tag?: import("effect/Schema").Json | undefined;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.wait.satisfied";
+        readonly payload: {
+            readonly waitId: string;
+            readonly tag?: import("effect/Schema").Json | undefined;
+            readonly event: {
+                readonly id: string;
+                readonly type: string;
+                readonly payload: import("effect/Schema").Json;
+            };
+        };
+    })>;
+}, {}, {
+    pendingApprovals: import("@swirls/looms/core").ProjectionDefinition<{
+        readonly items: {
+            readonly approvalId: string;
+            readonly title: string;
+            readonly description?: string | undefined;
+            readonly status: "approved" | "pending" | "rejected" | "timed_out";
+            readonly threadId: string | null;
+        }[];
+    } | {
+        items: ({
+            readonly approvalId: string;
+            readonly title: string;
+            readonly description?: string | undefined;
+            readonly status: "approved" | "pending" | "rejected" | "timed_out";
+            readonly threadId: string | null;
+        } | {
+            approvalId: string;
+            title: string;
+            description?: string | undefined;
+            threadId: string | null;
+            status: string;
+        })[];
+    }>;
+}, any> & {
+    readonly effects: {
+        request: import("@swirls/looms/core").EffectDefinition<{
+            readonly approvalId: string;
+            readonly title: string;
+            readonly description?: string | undefined;
+            readonly actions: readonly {
+                readonly id: string;
+                readonly label: string;
+                readonly outcome: "approve" | "reject";
+            }[];
+            readonly schema?: import("effect/Schema").Json | undefined;
+        }, never, (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "approval.decided";
+            readonly payload: {
+                readonly approvalId: string;
+                readonly actionId: string;
+                readonly outcome: "approve" | "reject";
+                readonly payload?: import("effect/Schema").Json | undefined;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "approval.requested";
+            readonly payload: {
+                readonly approvalId: string;
+                readonly title: string;
+                readonly description?: string | undefined;
+                readonly actions: readonly {
+                    readonly id: string;
+                    readonly label: string;
+                    readonly outcome: "approve" | "reject";
+                }[];
+                readonly schema?: import("effect/Schema").Json | undefined;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "approval.timed_out";
+            readonly payload: {
+                readonly approvalId: string;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.effect.failed";
+            readonly payload: {
+                readonly effectId: string;
+                readonly error: string;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.run.completed";
+            readonly payload: {
+                readonly output: import("effect/Schema").Json;
+                readonly error: string | null;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.run.started";
+            readonly payload: {
+                readonly rootThreadId?: string | undefined;
+                readonly kind: string;
+                readonly definitionName: string;
+                readonly input: import("effect/Schema").Json;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.signal.received";
+            readonly payload: {
+                readonly signalType: string;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.snapshot.taken";
+            readonly payload: {
+                readonly seq: number;
+                readonly stateHash: string;
+                readonly state?: import("effect/Schema").Json | undefined;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.thread.cancelled";
+            readonly payload: {
+                readonly threadId: string;
+                readonly reason?: string | undefined;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.thread.completed";
+            readonly payload: {
+                readonly threadId: string;
+                readonly output: import("effect/Schema").Json;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.thread.failed";
+            readonly payload: {
+                readonly threadId: string;
+                readonly error: string;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.thread.started";
+            readonly payload: {
+                readonly threadId: string;
+                readonly kind: string;
+                readonly definitionName: string;
+                readonly input: import("effect/Schema").Json;
+                readonly parentThreadId: string | null;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.timer.fired";
+            readonly payload: {
+                readonly timerId: string;
+                readonly waitId: string;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.timer.set";
+            readonly payload: {
+                readonly timerId: string;
+                readonly waitId: string;
+                readonly wakeAt: number;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.wait.registered";
+            readonly payload: {
+                readonly waitId: string;
+                readonly threadId?: string | undefined;
+                readonly on: {
+                    readonly type: string | readonly string[];
+                    readonly match?: import("effect/Schema").Json | undefined;
+                } | {
+                    readonly timerAt: number;
+                };
+                readonly tag?: import("effect/Schema").Json | undefined;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.wait.satisfied";
+            readonly payload: {
+                readonly waitId: string;
+                readonly tag?: import("effect/Schema").Json | undefined;
+                readonly event: {
+                    readonly id: string;
+                    readonly type: string;
+                    readonly payload: import("effect/Schema").Json;
+                };
+            };
+        })>;
+    };
+    readonly threads: {};
+    readonly projections: {
+        pendingApprovals: import("@swirls/looms/core").ProjectionDefinition<{
+            readonly items: {
+                readonly approvalId: string;
+                readonly title: string;
+                readonly description?: string | undefined;
+                readonly status: "approved" | "pending" | "rejected" | "timed_out";
+                readonly threadId: string | null;
+            }[];
+        } | {
+            items: ({
+                readonly approvalId: string;
+                readonly title: string;
+                readonly description?: string | undefined;
+                readonly status: "approved" | "pending" | "rejected" | "timed_out";
+                readonly threadId: string | null;
+            } | {
+                approvalId: string;
+                title: string;
+                description?: string | undefined;
+                threadId: string | null;
+                status: string;
+            })[];
+        }>;
+    };
+};

package/dist/approval/module.js

@@ -0,0 +1,10 @@
+import { defineModule } from '@swirls/looms/core';
+import { requestApprovalEffect } from './effects.js';
+import { pendingApprovals } from './projections.js';
+import { approvalModule } from './scope.js';
+export function approval() {
+    return defineModule(approvalModule, () => ({
+        effects: { request: requestApprovalEffect },
+        projections: { pendingApprovals },
+    }));
+}

package/dist/approval/projections.d.ts

@@ -0,0 +1,42 @@
+import { Schema } from 'effect';
+export declare const PendingApprovalSchema: Schema.Struct<{
+    readonly approvalId: Schema.String;
+    readonly title: Schema.String;
+    readonly description: Schema.optional<Schema.String>;
+    readonly status: Schema.Union<readonly [Schema.Literal<"pending">, Schema.Literal<"approved">, Schema.Literal<"rejected">, Schema.Literal<"timed_out">]>;
+    readonly threadId: Schema.NullOr<Schema.String>;
+}>;
+export type PendingApproval = Schema.Schema.Type<typeof PendingApprovalSchema>;
+export declare const PendingApprovalsSchema: Schema.Struct<{
+    readonly items: Schema.mutable<Schema.$Array<Schema.Struct<{
+        readonly approvalId: Schema.String;
+        readonly title: Schema.String;
+        readonly description: Schema.optional<Schema.String>;
+        readonly status: Schema.Union<readonly [Schema.Literal<"pending">, Schema.Literal<"approved">, Schema.Literal<"rejected">, Schema.Literal<"timed_out">]>;
+        readonly threadId: Schema.NullOr<Schema.String>;
+    }>>>;
+}>;
+export type PendingApprovalsState = Schema.Schema.Type<typeof PendingApprovalsSchema>;
+export declare const pendingApprovals: import("@swirls/looms/core").ProjectionDefinition<{
+    readonly items: {
+        readonly approvalId: string;
+        readonly title: string;
+        readonly description?: string | undefined;
+        readonly status: "approved" | "pending" | "rejected" | "timed_out";
+        readonly threadId: string | null;
+    }[];
+} | {
+    items: ({
+        readonly approvalId: string;
+        readonly title: string;
+        readonly description?: string | undefined;
+        readonly status: "approved" | "pending" | "rejected" | "timed_out";
+        readonly threadId: string | null;
+    } | {
+        approvalId: string;
+        title: string;
+        description?: string | undefined;
+        threadId: string | null;
+        status: string;
+    })[];
+}>;

package/dist/approval/projections.js

@@ -0,0 +1,57 @@
+import { Schema } from 'effect';
+import { approvalModule } from './scope.js';
+export const PendingApprovalSchema = Schema.Struct({
+    approvalId: Schema.String,
+    title: Schema.String,
+    description: Schema.optional(Schema.String),
+    status: Schema.Union([
+        Schema.Literal('pending'),
+        Schema.Literal('approved'),
+        Schema.Literal('rejected'),
+        Schema.Literal('timed_out'),
+    ]),
+    threadId: Schema.NullOr(Schema.String),
+});
+export const PendingApprovalsSchema = Schema.Struct({
+    items: Schema.mutable(Schema.Array(PendingApprovalSchema)),
+});
+export const pendingApprovals = approvalModule.projection({
+    name: 'pendingApprovals',
+    shape: PendingApprovalsSchema,
+    initialState: { items: [] },
+    reduce(state, event) {
+        switch (event.type) {
+            case 'approval.requested': {
+                const { approvalId, title, description } = event.payload;
+                const threadId = event.threadId ?? null;
+                return {
+                    items: [
+                        ...state.items.filter((item) => item.approvalId !== approvalId),
+                        {
+                            approvalId,
+                            title: title || 'Approval',
+                            description: description || undefined,
+                            status: 'pending',
+                            threadId,
+                        },
+                    ],
+                };
+            }
+            case 'approval.decided': {
+                const { approvalId, outcome } = event.payload;
+                const status = outcome === 'reject' ? 'rejected' : 'approved';
+                return {
+                    items: state.items.map((item) => item.approvalId === approvalId ? { ...item, status } : item),
+                };
+            }
+            case 'approval.timed_out': {
+                const { approvalId } = event.payload;
+                return {
+                    items: state.items.map((item) => item.approvalId === approvalId ? { ...item, status: 'timed_out' } : item),
+                };
+            }
+            default:
+                return state;
+        }
+    },
+});

package/dist/approval/scope.d.ts

@@ -0,0 +1,45 @@
+import { type EventOf } from '@swirls/looms/core';
+export declare const approvalModule: import("@swirls/looms/core").ModuleScope<"approval", import("@swirls/looms/core").ScopeUniverse<import("@swirls/looms/core").EventCatalog<"approval", {
+    requested: import("effect/Schema").Struct<{
+        readonly approvalId: import("effect/Schema").String;
+        readonly title: import("effect/Schema").String;
+        readonly description: import("effect/Schema").optional<import("effect/Schema").String>;
+        readonly actions: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly id: import("effect/Schema").String;
+            readonly label: import("effect/Schema").String;
+            readonly outcome: import("effect/Schema").Union<readonly [import("effect/Schema").Literal<"approve">, import("effect/Schema").Literal<"reject">]>;
+        }>>;
+        readonly schema: import("effect/Schema").optional<import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>;
+    }>;
+    decided: import("effect/Schema").Struct<{
+        readonly approvalId: import("effect/Schema").String;
+        readonly actionId: import("effect/Schema").String;
+        readonly outcome: import("effect/Schema").Union<readonly [import("effect/Schema").Literal<"approve">, import("effect/Schema").Literal<"reject">]>;
+        readonly payload: import("effect/Schema").optional<import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>;
+    }>;
+    timed_out: import("effect/Schema").Struct<{
+        readonly approvalId: import("effect/Schema").String;
+    }>;
+}>, undefined>, import("@swirls/looms/core").EventCatalog<"approval", {
+    requested: import("effect/Schema").Struct<{
+        readonly approvalId: import("effect/Schema").String;
+        readonly title: import("effect/Schema").String;
+        readonly description: import("effect/Schema").optional<import("effect/Schema").String>;
+        readonly actions: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly id: import("effect/Schema").String;
+            readonly label: import("effect/Schema").String;
+            readonly outcome: import("effect/Schema").Union<readonly [import("effect/Schema").Literal<"approve">, import("effect/Schema").Literal<"reject">]>;
+        }>>;
+        readonly schema: import("effect/Schema").optional<import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>;
+    }>;
+    decided: import("effect/Schema").Struct<{
+        readonly approvalId: import("effect/Schema").String;
+        readonly actionId: import("effect/Schema").String;
+        readonly outcome: import("effect/Schema").Union<readonly [import("effect/Schema").Literal<"approve">, import("effect/Schema").Literal<"reject">]>;
+        readonly payload: import("effect/Schema").optional<import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>;
+    }>;
+    timed_out: import("effect/Schema").Struct<{
+        readonly approvalId: import("effect/Schema").String;
+    }>;
+}>, undefined>;
+export type ApprovalEvent = EventOf<typeof approvalModule>;

package/dist/approval/scope.js

@@ -0,0 +1,7 @@
+import { createModuleScope } from '@swirls/looms/core';
+import { approvalCatalog } from './events.js';
+export const approvalModule = createModuleScope({
+    namespace: 'approval',
+    protocolVersion: '1.0.0',
+    events: approvalCatalog,
+});

package/dist/approval/signals.d.ts

@@ -0,0 +1,19 @@
+import { type EventInput, type JsonValue, type RuntimeEffect } from '@swirls/looms/core';
+import type { ApprovalAction } from './events';
+export declare function gate(args: {
+    title: string;
+    description?: string;
+    approvalId?: string;
+    actions?: ApprovalAction[];
+    schema?: JsonValue;
+}): RuntimeEffect[];
+export type ApprovalChoice = 'approve' | 'reject' | {
+    actionId: string;
+    outcome: 'approve' | 'reject';
+    payload?: JsonValue;
+};
+/**
+ * Build the `approval.decided` event that resolves a pending gate.
+ * Send it with `looms.signal(runId, [decision(approvalId, 'approve')])`.
+ */
+export declare function decision(approvalId: string, choice: ApprovalChoice): EventInput;

package/dist/approval/signals.js

@@ -0,0 +1,34 @@
+import { createWaitId, invoke, isJsonString, wait, } from '@swirls/looms/core';
+import { requestApprovalEffect } from './effects.js';
+import { approvalModule } from './scope.js';
+export function gate(args) {
+    const approvalId = args.approvalId ?? createWaitId('approval');
+    const actions = args.actions ?? [
+        { id: 'approve', label: 'Approve', outcome: 'approve' },
+        { id: 'reject', label: 'Reject', outcome: 'reject' },
+    ];
+    return [
+        invoke(requestApprovalEffect, {
+            approvalId,
+            title: args.title,
+            description: args.description,
+            actions,
+            schema: args.schema,
+        }, `request_${approvalId}`),
+        wait({
+            waitId: createWaitId(approvalId, 'decision'),
+            on: { type: 'approval.decided', match: { approvalId } },
+            tag: { approvalId },
+        }),
+    ];
+}
+/**
+ * Build the `approval.decided` event that resolves a pending gate.
+ * Send it with `looms.signal(runId, [decision(approvalId, 'approve')])`.
+ */
+export function decision(approvalId, choice) {
+    const decided = isJsonString(choice)
+        ? { approvalId, actionId: choice, outcome: choice }
+        : { approvalId, actionId: choice.actionId, outcome: choice.outcome, payload: choice.payload };
+    return approvalModule.input('decided', decided);
+}

package/dist/cli/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};

package/dist/cli/cli.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env bun
+import { BunRuntime, BunServices } from '@effect/platform-bun';
+import { Effect } from 'effect';
+import { Command } from 'effect/unstable/cli';
+import { looms, VERSION } from './commands.js';
+looms.pipe(Command.run({ version: VERSION }), Effect.provide(BunServices.layer), BunRuntime.runMain);

package/dist/cli/commands.d.ts

@@ -0,0 +1,13 @@
+import { Effect, FileSystem, Layer, Path, Stdio, Terminal } from 'effect';
+import { CliError, Command } from 'effect/unstable/cli';
+import { ChildProcessSpawner } from 'effect/unstable/process';
+declare const VERSION = "0.0.1";
+export declare const looms: Command.Command<"looms", {
+    readonly url: string;
+}, {
+    readonly url: string;
+}, CliError.UserError, never>;
+export declare const cliTestLayer: Layer.Layer<ChildProcessSpawner.ChildProcessSpawner | FileSystem.FileSystem | Path.Path | Stdio.Stdio | Terminal.Terminal, never, never>;
+/** Run the CLI with an explicit argv (for tests and programmatic use). */
+export declare const runCli: (argv: ReadonlyArray<string>) => Effect.Effect<void, CliError.CliError, Command.Environment>;
+export { VERSION };