@rikalabs/akter-cli 0.0.0-stage → 0.1.0-alpha.4

package/dist/main.js

@@ -0,0 +1,3280 @@
+#!/usr/bin/env node
+
+// src/main.ts
+import { Context as Context2, Effect as Effect23, Layer as Layer5, Stdio as Stdio2 } from "effect";
+import { FetchHttpClient } from "effect/http";
+
+// src/cli.ts
+import { Effect as Effect22, Runtime as Runtime2, Schema as Schema29 } from "effect";
+import { CliError, Command as Command19 } from "effect/cli";
+// package.json
+var version = "0.1.0-alpha.4";
+
+// src/commands/adopt/run.ts
+import {
+  adoptionStatus,
+  adoptionWriters,
+  backfillAdoption,
+  enforceAdoption,
+  formatAdoptionPlan,
+  formatAdoptionStatus,
+  formatBackfill,
+  formatEnforce,
+  formatObservedWriter,
+  observeAdoption,
+  planAdoption,
+  releaseAdoption
+} from "@rikalabs/akter/runtime";
+import { Clock, Console as Console3, Effect as Effect3, Layer as Layer2, Option } from "effect";
+import { Argument, Command as Command2, Flag as Flag2 } from "effect/cli";
+import { Database as Database2 } from "@rikalabs/akter/runtime";
+
+// src/failure.ts
+import { Console, Effect, Runtime, Schema } from "effect";
+
+class UsageError extends Schema.TaggedError()("UsageError", {
+  message: Schema.String
+}) {
+}
+
+class CommandFailed extends Schema.TaggedError()("CommandFailed", {
+  exitCode: Schema.Int,
+  reason: Schema.String
+}) {
+  [Runtime.errorReported] = false;
+  get [Runtime.errorExitCode]() {
+    return this.exitCode;
+  }
+}
+var fail = (failure) => Console.error(failure.message).pipe(Effect.andThen(Effect.fail(CommandFailed.make({ exitCode: failure.exitCode ?? 2, reason: failure.reason }))));
+
+// src/platform.ts
+import { createServer } from "node:http";
+var platform = typeof Bun === "undefined" ? await import("@effect/platform-node").then((node) => ({
+  crypto: node.NodeCrypto.layer,
+  services: node.NodeServices.layer,
+  runMain: node.NodeRuntime.runMain,
+  httpServer: (options) => node.NodeHttpServer.layer(createServer, { port: options.port, host: options.hostname })
+})) : await import("@effect/platform-bun").then((bun) => ({
+  crypto: bun.BunCrypto.layer,
+  services: bun.BunServices.layer,
+  runMain: bun.BunRuntime.runMain,
+  httpServer: (options) => bun.BunHttpServer.layer(options)
+}));
+var PlatformCrypto = { layer: platform.crypto };
+var PlatformServices = { layer: platform.services };
+var PlatformRuntime = { runMain: platform.runMain };
+var PlatformHttpServer = { layer: platform.httpServer };
+
+// src/commands/workflows/check.ts
+import { Database, checkWorkflows, formatIncompatibility } from "@rikalabs/akter/runtime";
+import { Console as Console2, Effect as Effect2, Layer, Schema as Schema2 } from "effect";
+import { Command, Flag } from "effect/cli";
+import { pathToFileURL } from "node:url";
+var entryFlags = {
+  entry: Flag.File("entry", { mustExist: true }).pipe(Flag.withDescription("The entry module; it exports an `actors` array of actor definitions")),
+  databaseUrl: Flag.Redacted("database-url").pipe(Flag.withDescription("The application's Postgres URL")),
+  json: Flag.Boolean("json").pipe(Flag.withDefault(false), Flag.withDescription("Print the report as JSON"))
+};
+var entryCommand = ({
+  options,
+  reading,
+  run
+}) => Effect2.gen(function* () {
+  const module = yield* loadEntry(options.entry);
+  const actors = yield* actorsOf({ module, entry: options.entry });
+  const services = yield* Layer.build(Database.postgres({ url: options.databaseUrl }).pipe(Layer.provideMerge(PlatformCrypto.layer)));
+  const { output, exitCode } = yield* run(actors).pipe(Effect2.provideContext(services));
+  yield* Console2.log(output);
+  if (exitCode !== 0)
+    return yield* CommandFailed.make({ exitCode, reason: "Refused" });
+}).pipe(Effect2.scoped, Effect2.catchTags({
+  SqlError: (error) => fail({ reason: error._tag, message: `Cannot read ${reading}: ${error.message}` }),
+  UsageError: (error) => fail({ reason: error._tag, message: error.message })
+}));
+var Entry = Schema2.Struct({
+  actors: Schema2.Array(Schema2.Struct({ name: Schema2.String, api: Schema2.Record(Schema2.String, Schema2.Unknown) }))
+});
+var decodeEntry = Schema2.decodeUnknownEffect(Entry);
+var AnySchema = Schema2.declare(Schema2.isSchema);
+var WorkflowDefinition = Schema2.Struct({
+  kind: Schema2.Literal("workflow"),
+  tag: Schema2.String,
+  payload: AnySchema,
+  success: AnySchema,
+  error: AnySchema,
+  versions: Schema2.Record(Schema2.String, Schema2.Struct({ current: Schema2.Finite, min: Schema2.Finite })),
+  registry: Schema2.Struct({
+    steps: Schema2.declare((u) => u instanceof Map)
+  })
+});
+var isWorkflowDefinition = Schema2.is(WorkflowDefinition);
+var isWorkflowKind = Schema2.is(Schema2.Struct({ kind: Schema2.Literal("workflow") }));
+var loadEntry = (entry) => Effect2.tryPromise({
+  try: () => import(pathToFileURL(entry).href),
+  catch: (cause) => UsageError.make({
+    message: `Cannot load ${entry}: ${cause instanceof Error ? cause.message : String(cause)}`
+  })
+});
+var actorsOf = ({ module, entry }) => decodeEntry(module).pipe(Effect2.mapError(() => UsageError.make({ message: `${entry} must export an \`actors\` array of actor definitions` })), Effect2.flatMap(({ actors }) => {
+  for (const actor of actors)
+    for (const [name, member] of Object.entries(actor.api))
+      if (isWorkflowKind(member) && !isWorkflowDefinition(member))
+        return Effect2.fail(UsageError.make({
+          message: `${entry}: ${actor.name}.${name} is not an Actor.workflow definition`
+        }));
+  return Effect2.succeed(actors);
+}));
+var report = ({
+  incompatibilities,
+  json
+}) => ({
+  incompatibilities,
+  output: json ? JSON.stringify({ compatible: incompatibilities.length === 0, incompatibilities }, null, 2) : incompatibilities.length === 0 ? "Workflows are compatible with every open execution" : [
+    ...incompatibilities.map(formatIncompatibility),
+    `${incompatibilities.length} incompatibilit${incompatibilities.length === 1 ? "y" : "ies"}; deploy refused (exit 1)`
+  ].join(`
+`),
+  exitCode: incompatibilities.length === 0 ? 0 : 1
+});
+var check = ({
+  actors,
+  json
+}) => checkWorkflows(actors).pipe(Effect2.map((incompatibilities) => report({ incompatibilities, json })));
+var checkCommand = Command.make("check", entryFlags, (options) => entryCommand({
+  options,
+  reading: "workflow state",
+  run: (actors) => check({ actors, json: options.json })
+})).pipe(Command.withDescription("Compare the entry's workflows with every open execution, read-only; exit 1 when a deploy would be refused"));
+
+// src/commands/adopt/run.ts
+var UNITS = { m: 60000, h: 3600000, d: 86400000 };
+var WINDOW = /^([1-9][0-9]*)([mhd])$/;
+var parseWindow = (text) => {
+  const match = WINDOW.exec(text);
+  return match === null ? Option.none() : Option.some(Number(match[1]) * UNITS[match[2]]);
+};
+var printJson = (value) => JSON.stringify(value, null, 2);
+var adopt = ({
+  options,
+  actors
+}) => Effect3.gen(function* () {
+  if (options.command === "status") {
+    const statuses = yield* adoptionStatus;
+    return {
+      output: options.json ? printJson({ tables: statuses }) : statuses.length === 0 ? "No table is adopted" : statuses.map(formatAdoptionStatus).join(`
+`),
+      exitCode: 0
+    };
+  }
+  if (options.command === "enforce") {
+    const enforced = yield* enforceAdoption(actors, {
+      only: options.table,
+      writerRole: options.writerRole,
+      allowedRoles: options.allow,
+      quietMs: options.quietMs,
+      nowMs: yield* Clock.currentTimeMillis
+    });
+    return {
+      output: options.json ? printJson({ enforced }) : enforced.map(formatEnforce).join(`
+`),
+      exitCode: 0
+    };
+  }
+  if (options.command === "release") {
+    const released = yield* releaseAdoption(actors, { only: options.table });
+    return {
+      output: options.json ? printJson({ observing: released }) : released.map((table) => `${table} is observing again`).join(`
+`),
+      exitCode: 0
+    };
+  }
+  if (options.command === "plan") {
+    const plans = yield* planAdoption(actors, options.table);
+    return {
+      output: options.json ? printJson({ tables: plans }) : plans.map(formatAdoptionPlan).join(`
+
+`),
+      exitCode: plans.some((plan) => plan.problems.length > 0) ? 1 : 0
+    };
+  }
+  if (options.command === "backfill") {
+    const results = yield* backfillAdoption(actors, {
+      only: options.table,
+      batch: options.batch
+    });
+    return {
+      output: options.json ? printJson({ tables: results }) : results.map(formatBackfill).join(`
+`),
+      exitCode: 0
+    };
+  }
+  if (options.report) {
+    const writers = yield* adoptionWriters(actors, {
+      only: options.table,
+      sinceMs: options.sinceMs,
+      clear: options.clear
+    });
+    return {
+      output: options.json ? printJson({ writers }) : writers.length === 0 ? "No write was recorded" : writers.map(formatObservedWriter).join(`
+`),
+      exitCode: 0
+    };
+  }
+  const observed = yield* observeAdoption(actors, options.table);
+  return {
+    output: options.json ? printJson({ observing: observed }) : observed.map((table) => `${table} is observing`).join(`
+`),
+    exitCode: 0
+  };
+}).pipe(Effect3.catchTag("AdoptionRefused", (refused) => Effect3.succeed({ output: refused.message, exitCode: 1 })));
+var run = (options) => Effect3.gen(function* () {
+  const actors = options.entry === undefined ? [] : yield* actorsOf({ module: yield* loadEntry(options.entry), entry: options.entry });
+  const services = yield* Layer2.build(Database2.postgres({ url: options.databaseUrl }).pipe(Layer2.provideMerge(PlatformCrypto.layer)));
+  const { output, exitCode } = yield* adopt({ options, actors }).pipe(Effect3.provideContext(services));
+  yield* Console3.log(output);
+  if (exitCode !== 0)
+    return yield* CommandFailed.make({ exitCode, reason: "Refused" });
+}).pipe(Effect3.scoped, Effect3.catchTags({
+  SqlError: (error) => fail({
+    reason: error._tag,
+    message: `Cannot read adoption state (is the database migrated to 0024_adoption?): ${error.message}`
+  }),
+  UsageError: (error) => fail({ reason: error._tag, message: error.message })
+}));
+var defaults = {
+  entry: undefined,
+  table: undefined,
+  report: false,
+  clear: false,
+  sinceMs: undefined,
+  batch: undefined,
+  writerRole: undefined,
+  allow: [],
+  quietMs: undefined
+};
+var table = (verb) => Argument.String("table").pipe(Argument.withDescription(`The adopted table to ${verb}`));
+var planCommand = Command2.make("plan", {
+  ...entryFlags,
+  table: Flag2.String("table").pipe(Flag2.optional, Flag2.withDescription("Plan only this adopted table"))
+}, (options) => run({
+  ...defaults,
+  ...options,
+  command: "plan",
+  table: Option.getOrUndefined(options.table)
+})).pipe(Command2.withDescription("Plan adopting the entry's existing tables, with the SQL each needs; exit 1 while a table has a problem"));
+var observeCommand = Command2.make("observe", {
+  ...entryFlags,
+  table: table("observe"),
+  report: Flag2.Boolean("report").pipe(Flag2.withDefault(false), Flag2.withDescription("Report the writes recorded so far instead of starting to observe")),
+  since: Flag2.String("since").pipe(Flag2.filterMap(parseWindow, () => "a window such as 30m, 12h, or 7d"), Flag2.optional, Flag2.withDescription("With --report, only writes within this window, such as 7d")),
+  clear: Flag2.Boolean("clear").pipe(Flag2.withDefault(false), Flag2.withDescription("With --report, clear the reported writes"))
+}, (options) => Effect3.gen(function* () {
+  if ((Option.isSome(options.since) || options.clear) && !options.report)
+    return yield* fail({
+      reason: "UsageError",
+      message: "--since and --clear belong to observe --report"
+    });
+  const nowMs = yield* Clock.currentTimeMillis;
+  return yield* run({
+    ...defaults,
+    ...options,
+    command: "observe",
+    sinceMs: Option.getOrUndefined(Option.map(options.since, (window) => nowMs - window))
+  });
+})).pipe(Command2.withDescription("Record which writers still write an adopted table, or report them with --report"));
+var backfillCommand = Command2.make("backfill", {
+  ...entryFlags,
+  table: table("backfill"),
+  batch: Flag2.Int("batch").pipe(Flag2.filter((batch) => batch >= 1, () => "a positive integer"), Flag2.optional, Flag2.withDescription("Rows per pass (default 1000)"))
+}, (options) => run({
+  ...defaults,
+  ...options,
+  command: "backfill",
+  batch: Option.getOrUndefined(options.batch)
+})).pipe(Command2.withDescription("Fill routing_key on an observed table's rows, in batches"));
+var enforceCommand = Command2.make("enforce", {
+  ...entryFlags,
+  table: table("enforce"),
+  writerRole: Flag2.String("writer-role").pipe(Flag2.withDescription("The database role the runtime writes the table as")),
+  allow: Flag2.String("allow").pipe(Flag2.atLeast(0), Flag2.withDescription("Another role still allowed to write the table; repeat for several")),
+  quiet: Flag2.String("quiet").pipe(Flag2.filterMap(parseWindow, () => "a window such as 30m, 12h, or 7d"), Flag2.optional, Flag2.withDescription("How long no legacy write may have been recorded before enforcing, such as 7d"))
+}, (options) => run({
+  ...defaults,
+  ...options,
+  command: "enforce",
+  quietMs: Option.getOrUndefined(options.quiet)
+})).pipe(Command2.withDescription("Enforce an adopted table: only the runtime's writer role and --allow roles may write it"));
+var releaseCommand = Command2.make("release", {
+  ...entryFlags,
+  table: table("release"),
+  to: Flag2.Literals("to", ["observe"]).pipe(Flag2.withDescription("The mode to return the table to; only observe"))
+}, (options) => run({ ...defaults, ...options, command: "release" })).pipe(Command2.withDescription("Return an enforced table to observing"));
+var statusCommand = Command2.make("status", { databaseUrl: entryFlags.databaseUrl, json: entryFlags.json }, (options) => run({ ...defaults, ...options, command: "status" })).pipe(Command2.withDescription("Show each adopted table's mode and the rows left to backfill"));
+
+// src/commands/dead-letters/repair.ts
+import { Argument as Argument3, Command as Command3, Flag as Flag4 } from "effect/cli";
+
+// src/commands/operator/request.ts
+import { Config, Console as Console4, Effect as Effect4, Option as Option2, Redacted, Schema as Schema3 } from "effect";
+import { Argument as Argument2, Flag as Flag3 } from "effect/cli";
+import { HttpClient, HttpClientRequest } from "effect/http";
+var TOKEN_ENV = "AKTER_OPERATOR_TOKEN";
+
+class RunnerUnreachable extends Schema3.TaggedError()("RunnerUnreachable", { url: Schema3.String, message: Schema3.String }) {
+}
+
+class OperatorRefused extends Schema3.TaggedError()("OperatorRefused", {
+  status: Schema3.Finite,
+  body: Schema3.String
+}) {
+}
+var urls = Flag3.String("url").pipe(Flag3.atLeast(1), Flag3.map((values) => values.map((value) => value.replace(/\/+$/, ""))), Flag3.withDescription("A runner's base URL; repeat to name several, a single-actor command uses the first"));
+var tenant = Flag3.String("tenant").pipe(Flag3.withDescription("The tenant the request acts in"));
+var operatorFlags = {
+  urls,
+  tokenEnv: Flag3.String("token-env").pipe(Flag3.withDefault(TOKEN_ENV), Flag3.withDescription(`The environment variable holding the operator bearer token (default ${TOKEN_ENV})`)),
+  json: Flag3.Boolean("json").pipe(Flag3.withDefault(false), Flag3.withDescription("Print the runner's answer as JSON"))
+};
+var splitActor = (value) => {
+  const slash = value.indexOf("/");
+  return slash <= 0 || slash === value.length - 1 ? Option2.none() : Option2.some({ actorType: value.slice(0, slash), actorId: value.slice(slash + 1) });
+};
+var notAnActor = () => "an actor named as <Type>/<id>";
+var actorArgument = Argument2.String("actor").pipe(Argument2.filterMap(splitActor, notAnActor), Argument2.withDescription("The actor, as <Type>/<id>"));
+var actorFlag = (flag) => Flag3.String(flag.name).pipe(Flag3.filterMap(splitActor, notAnActor), Flag3.withDescription(flag.description));
+var reason = Flag3.String("reason").pipe(Flag3.filter((value) => value.length > 0 && value.length <= 500, () => "a reason of 1 to 500 characters"), Flag3.withDescription("Why, recorded in the operator audit log (up to 500 characters)"));
+var operatorToken = (name) => Effect4.map(Config.option(Config.Redacted(name)), (token) => Option2.match(token, { onNone: () => {
+  return;
+}, onSome: (value) => Redacted.value(value) }));
+var encodeJson = (answer) => Schema3.encodeEffect(Schema3.fromJsonString(Schema3.Json))(answer).pipe(Effect4.orDie);
+var operatorCommand = ({
+  options,
+  request,
+  format
+}) => Effect4.gen(function* () {
+  const token = yield* operatorToken(options.tokenEnv);
+  const answer = yield* request({ options, token });
+  yield* Console4.log(options.json ? yield* encodeJson(answer) : yield* format(answer));
+}).pipe(Effect4.catchTags({
+  RunnerUnreachable: (error) => fail({ reason: error._tag, message: `Cannot reach ${error.url}: ${error.message}` }),
+  OperatorRefused: (error) => fail({
+    reason: error._tag,
+    message: `Refused (${error.status}): ${error.body}`,
+    exitCode: 1
+  }),
+  ConfigError: (error) => fail({ reason: error._tag, message: `Cannot read the operator token: ${error.message}` }),
+  SchemaError: (error) => fail({ reason: error._tag, message: `Unexpected answer: ${error.message}` }),
+  PlatformError: (error) => fail({ reason: error._tag, message: `Cannot write the file: ${error.message}` })
+}));
+var decodeJson = Schema3.decodeUnknownEffect(Schema3.fromJsonString(Schema3.Json));
+var operatorRequest = Effect4.fnUntraced(function* ({
+  url,
+  path,
+  token,
+  body
+}) {
+  const client = yield* HttpClient.HttpClient;
+  const base = body === undefined ? HttpClientRequest.get(`${url}${path}`) : HttpClientRequest.post(`${url}${path}`);
+  const request = (body === undefined ? base : HttpClientRequest.bodyJsonUnsafe(base, body)).pipe(token === undefined ? (same) => same : HttpClientRequest.bearerToken(token));
+  const response = yield* client.execute(request).pipe(Effect4.mapError((error) => RunnerUnreachable.make({ url, message: error.message })));
+  const text = yield* response.text.pipe(Effect4.mapError((error) => RunnerUnreachable.make({ url, message: error.message })));
+  if (response.status >= 400)
+    return yield* OperatorRefused.make({ status: response.status, body: text });
+  return yield* decodeJson(text).pipe(Effect4.mapError(() => RunnerUnreachable.make({ url, message: "the answer is not JSON" })));
+});
+
+// src/commands/dead-letters/repair.ts
+var flags = {
+  jobId: Argument3.String("jobId").pipe(Argument3.withDescription("The dead-lettered job's id")),
+  actor: actorFlag({
+    name: "actor",
+    description: "The actor that enqueued the job, as <Type>/<id>"
+  }),
+  tenant,
+  reason,
+  ...operatorFlags
+};
+var repair = ({
+  options,
+  token
+}) => operatorRequest({
+  url: options.urls[0],
+  path: `/operator/dead-letters/${encodeURIComponent(options.jobId)}/${options.action}`,
+  token,
+  body: options.action === "retry" ? {
+    tenant: options.tenant,
+    actorType: options.actor.actorType,
+    actorId: options.actor.actorId,
+    reason: options.reason,
+    providerChecked: options.providerChecked
+  } : {
+    tenant: options.tenant,
+    actorType: options.actor.actorType,
+    actorId: options.actor.actorId,
+    reason: options.reason
+  }
+});
+var retryCommand = Command3.make("retry", {
+  ...flags,
+  providerChecked: Flag4.Boolean("provider-checked").pipe(Flag4.withDefault(false), Flag4.withDescription("Confirm the provider never applied an ambiguous attempt, so running it again is safe"))
+}, (options) => operatorCommand({
+  options: { ...options, action: "retry" },
+  request: repair,
+  format: encodeJson
+})).pipe(Command3.withDescription("Run a dead-lettered job again"));
+var discardCommand = Command3.make("discard", flags, (options) => operatorCommand({
+  options: { ...options, action: "discard", providerChecked: false },
+  request: repair,
+  format: encodeJson
+})).pipe(Command3.withDescription("Settle a dead-lettered job without running it"));
+
+// src/commands/defects/list.ts
+import { DefectRecords } from "@rikalabs/akter/runtime";
+import { Clock as Clock2, Console as Console5, DateTime, Duration, Effect as Effect5, Option as Option3, Schema as Schema4 } from "effect";
+import { Command as Command4, Flag as Flag5 } from "effect/cli";
+var units = { s: "seconds", m: "minutes", h: "hours", d: "days" };
+var parseSince = (value) => {
+  const compact = /^(\d+)([smhd])$/.exec(value);
+  return Duration.fromInput(compact === null ? value : `${compact[1]} ${units[compact[2]]}`);
+};
+var decodeDefects = Schema4.decodeUnknownEffect(DefectRecords);
+var flags2 = {
+  ...operatorFlags,
+  tenant: Flag5.String("tenant").pipe(Flag5.withDefault("*"), Flag5.withDescription("The tenant to read, or * for every tenant the operator's grant covers (default *)")),
+  actor: Flag5.String("actor").pipe(Flag5.optional, Flag5.withDescription("Only defects of this actor type")),
+  since: Flag5.String("since").pipe(Flag5.filterMap(parseSince, () => 'a duration such as 1h, 30m, 2d, 45s or "90 minutes"'), Flag5.optional, Flag5.withDescription("Only defects this recent: 1h, 30m, 2d, 45s, or any duration")),
+  limit: Flag5.Int("limit").pipe(Flag5.filter((limit) => limit >= 1 && limit <= 1000, () => "an integer from 1 to 1000"), Flag5.optional, Flag5.withDescription("At most this many of the newest defects, 1 to 1000"))
+};
+var listDefects = Effect5.fnUntraced(function* (options, token) {
+  const read = (url) => {
+    const query = new URLSearchParams({ tenant: options.tenant });
+    if (options.actor !== undefined)
+      query.set("actor", options.actor);
+    if (options.sinceMs !== undefined)
+      query.set("sinceMs", String(Math.floor(options.sinceMs)));
+    if (options.limit !== undefined)
+      query.set("limit", String(options.limit));
+    return operatorRequest({ url, path: `/operator/defects?${query}`, token }).pipe(Effect5.flatMap(decodeDefects));
+  };
+  const each = yield* Effect5.forEach(options.urls, read, { concurrency: "unbounded" });
+  const merged = each.flat().toSorted((a, b) => a.atMs - b.atMs);
+  return options.limit === undefined ? merged : merged.slice(-options.limit);
+});
+var formatDefects = ({
+  defects,
+  json
+}) => {
+  if (json)
+    return JSON.stringify(defects, null, 2);
+  if (defects.length === 0)
+    return "No defects.";
+  return defects.map((defect) => [
+    DateTime.formatIso(DateTime.makeUnsafe(defect.atMs)),
+    `${defect.actorType}/${defect.actorId}`,
+    `${defect.command} ${defect.commandId}`,
+    `tenant=${defect.tenant}`,
+    `trace=${defect.traceId}`,
+    defect.cause.split(`
+`)[0] ?? ""
+  ].join("  ")).join(`
+`);
+};
+var listCommand = Command4.make("list", flags2, (options) => Effect5.gen(function* () {
+  const nowMs = yield* Clock2.currentTimeMillis;
+  const token = yield* operatorToken(options.tokenEnv);
+  const defects = yield* listDefects({
+    urls: options.urls,
+    tenant: options.tenant,
+    actor: Option3.getOrUndefined(options.actor),
+    sinceMs: Option3.getOrUndefined(Option3.map(options.since, (since) => nowMs - Duration.toMillis(since))),
+    limit: Option3.getOrUndefined(options.limit)
+  }, token);
+  yield* Console5.log(formatDefects({ defects, json: options.json }));
+}).pipe(Effect5.catchTags({
+  RunnerUnreachable: (error) => fail({
+    reason: error._tag,
+    message: `Cannot read defects from ${error.url}: ${error.message}`
+  }),
+  OperatorRefused: (error) => fail({
+    reason: error._tag,
+    message: `Refused (${error.status}): ${error.body}`,
+    exitCode: 1
+  }),
+  SchemaError: (error) => fail({ reason: error._tag, message: `Unexpected answer: ${error.message}` }),
+  ConfigError: (error) => fail({ reason: error._tag, message: `Cannot read the operator token: ${error.message}` })
+}))).pipe(Command4.withDescription("List recent defects from each runner named; each keeps only its own recent defect spans"));
+
+// src/commands/dev/run.ts
+import { User } from "@rikalabs/akter";
+import { Auth, Database as Database3, Inspector } from "@rikalabs/akter/runtime";
+import { Console as Console6, Effect as Effect7, Layer as Layer3, Option as Option4, Schema as Schema5 } from "effect";
+import { Command as Command5, Flag as Flag6 } from "effect/cli";
+import { HttpRouter as HttpRouter2, HttpServer } from "effect/http";
+
+// src/commands/dev/inspector/page.ts
+import { Effect as Effect6, FileSystem } from "effect";
+import { HttpRouter, HttpServerResponse } from "effect/http";
+import { fileURLToPath } from "node:url";
+var STYLES = `
+:root {
+  color-scheme: light dark;
+  --bg: #f6f7f9; --panel: #ffffff; --ink: #16181d; --muted: #6b7280; --line: #e3e6ea;
+  --accent: #3b5bdb; --good: #2b8a3e; --bad: #c92a2a; --warn: #b7791f; --info: #1c7ed6;
+  --code: #f1f3f5;
+}
+@media (prefers-color-scheme: dark) {
+  :root {
+    --bg: #0f1115; --panel: #171a21; --ink: #e8eaed; --muted: #9aa0a6; --line: #2a2f39;
+    --accent: #7c95ff; --good: #51cf66; --bad: #ff6b6b; --warn: #fcc419; --info: #4dabf7;
+    --code: #1f232b;
+  }
+}
+* { box-sizing: border-box; }
+body { margin: 0; font: 14px/1.45 ui-sans-serif, system-ui, -apple-system, "Segoe UI", sans-serif; background: var(--bg); color: var(--ink); }
+a { color: var(--accent); text-decoration: none; }
+a:hover { text-decoration: underline; }
+code, .mono, pre { font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; font-size: 12.5px; }
+header.top { display: flex; align-items: center; gap: 16px; padding: 12px 24px; background: var(--panel); border-bottom: 1px solid var(--line); position: sticky; top: 0; z-index: 1; }
+header.top .brand { font-weight: 650; letter-spacing: -0.01em; }
+header.top .brand small { color: var(--muted); font-weight: 400; margin-left: 6px; }
+header.top .spacer { flex: 1; }
+header.top label, header.top .updated { color: var(--muted); font-size: 12.5px; }
+header.top button { font: inherit; padding: 4px 10px; border: 1px solid var(--line); border-radius: 6px; background: var(--panel); color: var(--ink); cursor: pointer; }
+.layout { display: grid; grid-template-columns: 200px 1fr; min-height: calc(100vh - 53px); }
+nav.sections { padding: 16px 12px; border-right: 1px solid var(--line); display: flex; flex-direction: column; gap: 2px; }
+nav.sections a { padding: 7px 10px; border-radius: 6px; color: var(--ink); }
+nav.sections a.active { background: color-mix(in srgb, var(--accent) 14%, transparent); color: var(--accent); font-weight: 600; }
+nav.sections .note { margin-top: 16px; padding: 0 10px; color: var(--muted); font-size: 12px; }
+main { padding: 20px 24px 48px; min-width: 0; }
+.tiles { display: grid; grid-template-columns: repeat(auto-fill, minmax(120px, 1fr)); gap: 10px; margin-bottom: 18px; }
+.tile { background: var(--panel); border: 1px solid var(--line); border-radius: 10px; padding: 10px 12px; display: flex; flex-direction: column; color: var(--ink); }
+.tile strong { font-size: 20px; font-variant-numeric: tabular-nums; }
+.tile span { color: var(--muted); font-size: 12px; }
+.tile.alert { border-color: var(--bad); }
+.tile.alert strong { color: var(--bad); }
+.stack { display: flex; flex-direction: column; gap: 16px; }
+.card { background: var(--panel); border: 1px solid var(--line); border-radius: 10px; padding: 16px 18px; overflow-x: auto; }
+.card.error { border-color: var(--bad); }
+.card h2 { margin: 0 0 12px; font-size: 15px; display: flex; align-items: center; gap: 8px; }
+.card h2 .count { color: var(--muted); font-weight: 500; font-size: 12.5px; background: var(--code); border-radius: 999px; padding: 1px 8px; }
+.hero h1 { margin: 2px 0 10px; font-size: 20px; font-family: ui-monospace, SFMono-Regular, Menlo, monospace; }
+.crumbs { margin: 0; color: var(--muted); font-size: 12.5px; }
+.facts { display: flex; gap: 6px; flex-wrap: wrap; }
+.hint { color: var(--muted); margin: -4px 0 10px; font-size: 12.5px; }
+.empty { color: var(--muted); margin: 4px 0; }
+.muted { color: var(--muted); }
+table { width: 100%; border-collapse: collapse; }
+th { text-align: left; font-weight: 600; color: var(--muted); font-size: 12px; text-transform: uppercase; letter-spacing: 0.03em; padding: 6px 10px; border-bottom: 1px solid var(--line); white-space: nowrap; }
+td { padding: 8px 10px; border-bottom: 1px solid var(--line); vertical-align: top; }
+tr:last-child td { border-bottom: 0; }
+td.num { font-variant-numeric: tabular-nums; text-align: right; }
+td.cause { max-width: 420px; word-break: break-word; }
+td.cause pre.trace { margin: 6px 0 0; font-size: 11.5px; color: var(--muted); white-space: pre-wrap; max-height: 220px; overflow: auto; }
+td pre.json { min-width: 200px; }
+td .due time { white-space: nowrap; }
+.small { font-size: 11.5px; color: var(--muted); word-break: break-all; }
+.badge { display: inline-block; max-width: 280px; overflow: hidden; text-overflow: ellipsis; vertical-align: middle; padding: 1px 8px; border-radius: 999px; font-size: 12px; font-weight: 550; background: var(--code); color: var(--ink); white-space: nowrap; }
+.badge.good { background: color-mix(in srgb, var(--good) 16%, transparent); color: var(--good); }
+.badge.bad { background: color-mix(in srgb, var(--bad) 16%, transparent); color: var(--bad); }
+.badge.warn { background: color-mix(in srgb, var(--warn) 18%, transparent); color: var(--warn); }
+.badge.info { background: color-mix(in srgb, var(--info) 16%, transparent); color: var(--info); }
+.chip { display: inline-block; padding: 2px 9px; margin: 0 4px 4px 0; border: 1px solid var(--line); border-radius: 999px; font-size: 12px; color: var(--ink); background: var(--panel); cursor: pointer; font-family: inherit; }
+.chip.active { border-color: var(--accent); color: var(--accent); }
+.filters { margin-bottom: 10px; }
+pre.json { margin: 0; padding: 8px 10px; background: var(--code); border-radius: 6px; max-height: 260px; overflow: auto; white-space: pre-wrap; word-break: break-word; }
+details summary { cursor: pointer; color: var(--accent); font-size: 12.5px; }
+.due small { color: var(--muted); }
+.due.overdue small { color: var(--warn); }
+.state { display: grid; grid-template-columns: repeat(auto-fill, minmax(260px, 1fr)); gap: 12px; }
+.state-entry h3 { margin: 0 0 6px; font-size: 13px; }
+ol.timeline { list-style: none; margin: 0; padding: 0 0 0 14px; border-left: 2px solid var(--line); display: flex; flex-direction: column; gap: 10px; }
+li.event { position: relative; }
+li.event::before { content: ""; position: absolute; left: -20px; top: 6px; width: 10px; height: 10px; border-radius: 50%; background: var(--accent); }
+li.event.flash pre.json { outline: 2px solid var(--accent); }
+.event-head { display: flex; gap: 10px; align-items: baseline; margin-bottom: 4px; flex-wrap: wrap; }
+.event-head .seq { font-weight: 650; font-variant-numeric: tabular-nums; }
+article.workflow { border: 1px solid var(--line); border-radius: 8px; padding: 12px 14px; margin-bottom: 12px; overflow-x: auto; }
+article.workflow header { display: flex; gap: 8px; align-items: center; flex-wrap: wrap; }
+article.workflow h3 { margin: 0; font-size: 14px; }
+article.workflow h4 { margin: 12px 0 6px; font-size: 12px; text-transform: uppercase; letter-spacing: 0.03em; color: var(--muted); }
+article.workflow dl { display: grid; grid-template-columns: max-content 1fr; gap: 2px 12px; margin: 10px 0 0; }
+article.workflow dt { color: var(--muted); }
+article.workflow dd { margin: 0; }
+.split { display: grid; grid-template-columns: 1fr 1fr; gap: 12px; }
+@media (max-width: 800px) { .layout { grid-template-columns: 1fr; } nav.sections { flex-direction: row; flex-wrap: wrap; border-right: 0; border-bottom: 1px solid var(--line); } .split { grid-template-columns: 1fr; } }
+`;
+var SECTIONS = [
+  ["#/actors", "/actor", "Actors"],
+  ["#/outbox", "/outbox", "Outbox and timers"],
+  ["#/jobs", "/jobs", "Jobs"],
+  ["#/dead-letters", "/dead-letters", "Dead letters"],
+  ["#/workflows", "/workflows", "Workflows"]
+];
+var escape = (text) => text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+var page = ({
+  api,
+  script
+}) => `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>akter dev inspector</title>
+<style>${STYLES}</style>
+</head>
+<body data-api="${escape(api)}">
+<header class="top">
+  <span class="brand">akter dev<small>inspector</small></span>
+  <span class="badge info">tenant <strong id="tenant">…</strong></span>
+  <span class="badge">read-only</span>
+  <span class="spacer"></span>
+  <span class="updated" id="updated"></span>
+  <label><input type="checkbox" id="live"> live</label>
+  <button type="button" id="refresh">Refresh</button>
+</header>
+<div class="layout">
+  <nav class="sections">
+    ${SECTIONS.map(([href, section, label]) => `<a href="${href}" data-section="${section}">${label}</a>`).join(`
+    `)}
+    <p class="note">Reads the durable inspection views. Nothing here writes.</p>
+  </nav>
+  <main>
+    <div id="tiles"></div>
+    <div id="app"><p class="empty">Loading…</p></div>
+  </main>
+</div>
+<script type="module" src="${escape(script)}"></script>
+</body>
+</html>`;
+var bundle = Effect6.gen(function* () {
+  const fs = yield* FileSystem.FileSystem;
+  return yield* fs.readFileString(fileURLToPath(new URL(import.meta.url.endsWith(".ts") ? "../../../../.cache/inspector-client.js" : "./inspector-client.js", import.meta.url)));
+});
+var pageRoutes = (path) => HttpRouter.use(Effect6.fnUntraced(function* (router) {
+  const script = yield* bundle;
+  const html = page({ api: `${path}/api`, script: `${path}/client.js` });
+  yield* router.add("GET", path, () => Effect6.succeed(HttpServerResponse.text(html, {
+    contentType: "text/html; charset=utf-8",
+    headers: { "cache-control": "no-store" }
+  })));
+  yield* router.add("GET", `${path}/client.js`, () => Effect6.succeed(HttpServerResponse.text(script, {
+    contentType: "text/javascript; charset=utf-8",
+    headers: { "cache-control": "no-store" }
+  })));
+}));
+
+// src/commands/dev/run.ts
+var flags3 = {
+  entry: Flag6.File("entry", { mustExist: true }).pipe(Flag6.withDescription("The entry module; it exports `app`, a Layer of its routes")),
+  databaseUrl: Flag6.Redacted("database-url").pipe(Flag6.optional, Flag6.withDescription("Run on this Postgres instead of PGlite")),
+  dataDir: Flag6.Directory("data-dir").pipe(Flag6.optional, Flag6.withDescription("Where PGlite keeps its files (default in memory)")),
+  port: Flag6.Int("port").pipe(Flag6.filter((port) => port >= 0 && port <= 65535, () => "an integer 0-65535"), Flag6.withDefault(3000), Flag6.withDescription("The port to listen on; 0 picks a free one (default 3000)")),
+  hostname: Flag6.String("hostname").pipe(Flag6.withDefault("127.0.0.1"), Flag6.withDescription("The address to listen on (default 127.0.0.1)")),
+  tenant: Flag6.String("tenant").pipe(Flag6.withDefault("default"), Flag6.withDescription("The one tenant the inspector reads (default default)"))
+};
+var isDevApp = (value) => Layer3.isLayer(value);
+var Entry2 = Schema5.Struct({ app: Schema5.declare(isDevApp) });
+var decodeEntry2 = Schema5.decodeUnknownEffect(Entry2);
+var appOf = ({ module, entry }) => decodeEntry2(module).pipe(Effect7.map(({ app }) => app), Effect7.mapError(() => UsageError.make({
+  message: `${entry} must export \`app\`: a Layer of its routes that needs only the database`
+})));
+var INSPECTOR_PATH = "/_akter/inspector";
+var localOperator = (tenant) => Auth.make(() => Effect7.succeed({ tenant, caller: User.make({ subject: "durable-dev" }) }));
+var devRoutes = ({ app, tenant }) => Layer3.mergeAll(app, Inspector.serve({ auth: localOperator(tenant), basePath: `${INSPECTOR_PATH}/api` }), pageRoutes(INSPECTOR_PATH));
+var devCommand = Command5.make("dev", flags3, (options) => Effect7.gen(function* () {
+  if (Option4.isSome(options.databaseUrl) && Option4.isSome(options.dataDir))
+    return yield* UsageError.make({
+      message: "--data-dir is for PGlite; drop it or --database-url"
+    });
+  const module = yield* loadEntry(options.entry);
+  const app = yield* appOf({ module, entry: options.entry });
+  const database = Option4.match(options.databaseUrl, {
+    onNone: () => Database3.pglite(Option4.match(options.dataDir, { onNone: () => ({}), onSome: (dataDir) => ({ dataDir }) })),
+    onSome: (url) => Database3.postgres({ url })
+  });
+  const storage = Option4.isSome(options.databaseUrl) ? "Postgres" : `PGlite (${Option4.getOrElse(options.dataDir, () => "in memory")})`;
+  const banner = Layer3.effectDiscard(HttpServer.addressFormattedWith((origin) => Console6.log([
+    `akter dev: ${options.entry} on ${storage}`,
+    `  app        ${origin}`,
+    `  inspector  ${origin}${INSPECTOR_PATH} (tenant ${options.tenant})`
+  ].join(`
+`))));
+  return banner.pipe(Layer3.provideMerge(HttpRouter2.serve(devRoutes({ app, tenant: options.tenant }), { disableListenLog: true })), Layer3.provide(PlatformHttpServer.layer({ port: options.port, hostname: options.hostname })), Layer3.provide(database), Layer3.provide(PlatformCrypto.layer));
+}).pipe(Effect7.flatMap(Layer3.launch), Effect7.catchTag("UsageError", (error) => fail({ reason: error._tag, message: error.message })))).pipe(Command5.withDescription("Run the entry's app locally with a read-only inspector at /_akter/inspector"));
+
+// src/commands/export/run.ts
+import { Seed, SeedJson } from "@rikalabs/akter/runtime";
+import { Effect as Effect8, FileSystem as FileSystem2, Schema as Schema6 } from "effect";
+import { Command as Command6, Flag as Flag7 } from "effect/cli";
+var flags4 = {
+  actor: actorArgument,
+  tenant,
+  output: Flag7.File("output").pipe(Flag7.withDescription("The seed file to create; an existing file is never replaced")),
+  ...operatorFlags
+};
+var ExportAnswer = Schema6.Struct({
+  output: Schema6.String,
+  actor: Schema6.String,
+  state: Schema6.Finite,
+  intents: Schema6.Finite,
+  jobs: Schema6.Finite,
+  omitted: Schema6.Struct({
+    receipts: Schema6.Finite,
+    events: Schema6.Finite,
+    workflows: Schema6.Finite,
+    deadLetters: Schema6.Finite,
+    tableRows: Schema6.Finite,
+    blobs: Schema6.Finite
+  })
+});
+var exportSeed = Effect8.fnUntraced(function* ({
+  options,
+  token
+}) {
+  const answer = yield* operatorRequest({
+    url: options.urls[0],
+    path: `/operator/actors/${encodeURIComponent(options.actor.actorType)}/${encodeURIComponent(options.actor.actorId)}/export?${new URLSearchParams({ tenant: options.tenant })}`,
+    token
+  });
+  const seed = yield* Schema6.decodeUnknownEffect(Seed)(answer);
+  const fs = yield* FileSystem2.FileSystem;
+  yield* fs.writeFileString(options.output, `${yield* Schema6.encodeEffect(SeedJson)(seed).pipe(Effect8.orDie)}
+`, { flag: "wx", mode: 384 });
+  return {
+    output: options.output,
+    actor: `${seed.actor.type}/${seed.actor.id}`,
+    state: Object.keys(seed.state).length,
+    intents: seed.intents.length,
+    jobs: seed.jobs.length,
+    omitted: seed.omitted
+  };
+});
+var formatExport = (answer) => Effect8.map(Schema6.decodeUnknownEffect(ExportAnswer)(answer), (exported) => [
+  `Exported ${exported.actor} to ${exported.output}`,
+  `carries ${exported.state} state keys, ${exported.intents} pending intents, ${exported.jobs} pending jobs`,
+  `omits ${exported.omitted.receipts} receipts, ${exported.omitted.events} events, ${exported.omitted.workflows} workflows, ${exported.omitted.deadLetters} dead letters, ${exported.omitted.tableRows} owned-table rows, ${exported.omitted.blobs} blob entries`
+].join(`
+`));
+var exportCommand = Command6.make("export", flags4, (options) => operatorCommand({ options, request: exportSeed, format: formatExport })).pipe(Command6.withDescription("Write one actor's state and pending intents and jobs to a new seed file, through the first runner named"));
+
+// src/commands/fleet/run.ts
+import { Database as Database4, rebuildFleetView, setupFleet } from "@rikalabs/akter/runtime";
+import { Console as Console7, Effect as Effect9, Layer as Layer4, Predicate } from "effect";
+import { Argument as Argument4, Command as Command7, Flag as Flag8 } from "effect/cli";
+var isView = (value) => Predicate.hasProperty(value, "definitionHash") && Predicate.hasProperty(value, "groupColumns") && Predicate.hasProperty(value, "table");
+var viewsOf = ({ module, entry }) => {
+  const fleet = module.fleet;
+  return Array.isArray(fleet) && fleet.length > 0 && fleet.every(isView) ? Effect9.succeed(fleet) : Effect9.fail(UsageError.make({ message: `${entry} must export a \`fleet\` array of Fleet.view values` }));
+};
+var setup = (views) => setupFleet(views).pipe(Effect9.map((result) => [
+  `Full replica identity and publication durable_fleet: ${result.sources.join(", ")}`,
+  `Replication slot durable_fleet: ${result.slot}`
+].join(`
+`)));
+var rebuild = (view) => rebuildFleetView(view).pipe(Effect9.map((found) => found ? { output: `${view} is building; the maintainer rebuilds it from its source`, exitCode: 0 } : { output: `No fleet view ${view} is registered on this database`, exitCode: 1 }));
+var onDatabase = (databaseUrl, run) => Effect9.gen(function* () {
+  const services = yield* Layer4.build(Database4.postgres({ url: databaseUrl }).pipe(Layer4.provideMerge(PlatformCrypto.layer)));
+  const { output, exitCode } = yield* run.pipe(Effect9.provideContext(services));
+  yield* Console7.log(output);
+  if (exitCode !== 0)
+    return yield* CommandFailed.make({ exitCode, reason: "Refused" });
+}).pipe(Effect9.scoped);
+var databaseUrl = Flag8.Redacted("database-url").pipe(Flag8.withDescription("The application's Postgres URL"));
+var setupCommand = Command7.make("setup", {
+  entry: Flag8.File("entry", { mustExist: true }).pipe(Flag8.withDescription("The entry module; it exports a `fleet` array of Fleet.view values")),
+  databaseUrl
+}, (options) => Effect9.gen(function* () {
+  const views = yield* viewsOf({
+    module: yield* loadEntry(options.entry),
+    entry: options.entry
+  });
+  return yield* onDatabase(options.databaseUrl, setup(views).pipe(Effect9.map((output) => ({ output, exitCode: 0 }))));
+}).pipe(Effect9.catchTags({
+  SqlError: (error) => fail({ reason: error._tag, message: `Cannot set up fleet views: ${error.message}` }),
+  FleetSetupRefused: (error) => fail({ reason: error._tag, message: error.message }),
+  UsageError: (error) => fail({ reason: error._tag, message: error.message })
+}))).pipe(Command7.withDescription("Give the entry's fleet view sources full replica identity, publish them, and create the logical slot; needs wal_level=logical"));
+var rebuildCommand = Command7.make("rebuild", {
+  view: Argument4.String("view").pipe(Argument4.withDescription("The fleet view to rebuild")),
+  databaseUrl
+}, (options) => onDatabase(options.databaseUrl, rebuild(options.view)).pipe(Effect9.catchTags({
+  SqlError: (error) => fail({ reason: error._tag, message: `Cannot rebuild ${options.view}: ${error.message}` })
+}))).pipe(Command7.withDescription("Rebuild a fleet view from its source, clearing its error; exit 1 when no runtime registered it"));
+
+// src/commands/inspect/show.ts
+import { Inspection } from "@rikalabs/akter/client";
+import { Effect as Effect10, Schema as Schema7, Struct } from "effect";
+import { Command as Command8, Flag as Flag9 } from "effect/cli";
+var flags5 = {
+  actor: actorArgument,
+  tenant,
+  limit: Flag9.Int("receipts").pipe(Flag9.filter((count) => count >= 1 && count <= 1000, () => "an integer from 1 to 1000"), Flag9.withDefault(20), Flag9.withDescription("How many of the newest receipts to show, 1 to 1000 (default 20)")),
+  ...operatorFlags
+};
+var ActorPage = Schema7.Struct({
+  actor: Inspection.ActorRow.mapFields(Struct.pick(["actorType", "actorId", "generation", "lastEventSequence"])),
+  state: Schema7.Array(Inspection.ActorDetail.fields.state.value.mapFields(Struct.pick(["key", "value"]))),
+  receipts: Schema7.Array(Inspection.OperatorActorDetail.fields.receipts.value.mapFields(Struct.pick(["commandId", "command", "outcomeTag", "outcome"]))),
+  deadLetters: Schema7.Array(Inspection.DeadLetterRow.mapFields(Struct.pick(["jobId", "job", "attempts", "ambiguous", "cause"]))),
+  totals: Inspection.ActorDetail.fields.totals
+});
+var decodeActorPage = Schema7.decodeUnknownEffect(ActorPage);
+var shown = (value) => value === undefined ? "(outcome needs receipts.read)" : value === null ? "null" : ("json" in value) ? JSON.stringify(value.json) : `(undecodable: ${value.undecodable})`;
+var formatActor = (page) => [
+  `${page.actor.actorType}/${page.actor.actorId}  generation ${page.actor.generation}  events through ${page.actor.lastEventSequence}`,
+  `totals  receipts ${page.totals.receipts}  events ${page.totals.events}  outbox ${page.totals.outbox}  jobs ${page.totals.jobs}  dead letters ${page.totals.deadLetters}  workflows ${page.totals.workflows}`,
+  "state",
+  ...page.state.map(({ key, value }) => `  ${key} = ${shown(value)}`),
+  "receipts (newest first)",
+  ...page.receipts.map((receipt) => `  ${receipt.command} ${receipt.commandId}  ${receipt.outcomeTag ?? "?"}  ${shown(receipt.outcome)}`),
+  ...page.deadLetters.length === 0 ? [] : [
+    "dead letters",
+    ...page.deadLetters.map((letter) => `  ${letter.jobId}  ${letter.job}  attempts ${letter.attempts}${letter.ambiguous ? "  ambiguous" : ""}  ${letter.cause.split(`
+`)[0] ?? ""}`)
+  ]
+].join(`
+`);
+var inspect = ({
+  options,
+  token
+}) => operatorRequest({
+  url: options.urls[0],
+  path: `/operator/actors/${encodeURIComponent(options.actor.actorType)}/${encodeURIComponent(options.actor.actorId)}?${new URLSearchParams({ tenant: options.tenant, limit: String(options.limit) })}`,
+  token
+});
+var formatInspection = (answer) => Effect10.map(decodeActorPage(answer), formatActor);
+var inspectCommand = Command8.make("inspect", flags5, (options) => operatorCommand({ options, request: inspect, format: formatInspection })).pipe(Command8.withDescription("Read one actor's state, newest receipts, and dead letters through the first runner named"));
+
+// src/commands/payloads/run.ts
+import { checkPayloads, clearPayloads, formatPayloadProblem } from "@rikalabs/akter/runtime";
+import { Effect as Effect11 } from "effect";
+import { Command as Command9 } from "effect/cli";
+var checkReport = ({
+  problems,
+  json
+}) => ({
+  output: json ? JSON.stringify({ compatible: problems.length === 0, problems }, null, 2) : problems.length === 0 ? "Every stored event and job payload version decodes" : [
+    ...problems.map(formatPayloadProblem),
+    `${problems.length} problem${problems.length === 1 ? "" : "s"}; deploy refused (exit 1)`
+  ].join(`
+`),
+  exitCode: problems.length === 0 ? 0 : 1
+});
+var reasons = {
+  cleared: "cleared",
+  writer: "not cleared: a runtime wrote it within its writer window and command timeout",
+  stored: "not cleared: events of this version are still stored"
+};
+var clearReport = ({
+  results,
+  json
+}) => ({
+  output: json ? JSON.stringify({ results }, null, 2) : results.length === 0 ? "No superseded event version is past its retention horizon" : results.map((result) => `${result.actorType}/${result.tag}  version ${result.version}  ${reasons[result.outcome]}`).join(`
+`),
+  exitCode: results.every((result) => result.outcome === "cleared") ? 0 : 1
+});
+var payloads = ({
+  command,
+  actors,
+  json
+}) => command === "check" ? checkPayloads(actors).pipe(Effect11.map((problems) => checkReport({ problems, json }))) : clearPayloads(actors).pipe(Effect11.map((results) => clearReport({ results, json })));
+var checkCommand2 = Command9.make("check", entryFlags, (options) => entryCommand({
+  options,
+  reading: "payload versions",
+  run: (actors) => payloads({ command: "check", actors, json: options.json })
+})).pipe(Command9.withDescription("Check that every stored event and job payload version still decodes, read-only; exit 1 when a deploy would be refused"));
+var clearCommand = Command9.make("clear", entryFlags, (options) => entryCommand({
+  options,
+  reading: "payload versions",
+  run: (actors) => payloads({ command: "clear", actors, json: options.json })
+})).pipe(Command9.withDescription("Mark superseded event versions past their retention horizon cleared; exit 1 when one stays uncleared"));
+
+// src/commands/receipts/show.ts
+import { Command as Command10, Argument as Argument5 } from "effect/cli";
+var flags6 = {
+  actor: actorArgument,
+  commandId: Argument5.String("commandId").pipe(Argument5.withDescription("The command id whose stored outcome to show")),
+  tenant,
+  ...operatorFlags
+};
+var showReceipt = ({
+  options,
+  token
+}) => operatorRequest({
+  url: options.urls[0],
+  path: `/operator/receipts/${encodeURIComponent(options.actor.actorType)}/${encodeURIComponent(options.actor.actorId)}/${encodeURIComponent(options.commandId)}?${new URLSearchParams({ tenant: options.tenant })}`,
+  token
+});
+var showCommand = Command10.make("show", flags6, (options) => operatorCommand({ options, request: showReceipt, format: encodeJson })).pipe(Command10.withDescription("Print one receipt's stored outcome as JSON; the runner never runs the command to answer"));
+
+// src/commands/subscriptions/list.ts
+import { Effect as Effect12, Option as Option5, Schema as Schema8 } from "effect";
+import { Command as Command11, Flag as Flag10 } from "effect/cli";
+var count = (name, maximum, description) => Flag10.Int(name).pipe(Flag10.filter((value) => value >= 1 && value <= maximum, () => `an integer from 1 to ${maximum}`), Flag10.optional, Flag10.withDescription(description));
+var flags7 = {
+  lagging: Flag10.Boolean("lagging").pipe(Flag10.withDescription("List the rows whose deliveries keep failing; the only listing, so required")),
+  tenant,
+  minAttempts: count("min-attempts", 1e6, "Only rows with at least this many failed attempts"),
+  limit: count("limit", 1000, "At most this many rows, 1 to 1000"),
+  ...operatorFlags
+};
+var list = ({
+  options,
+  token
+}) => {
+  const params = new URLSearchParams({ tenant: options.tenant });
+  if (Option5.isSome(options.minAttempts))
+    params.set("minAttempts", String(options.minAttempts.value));
+  if (Option5.isSome(options.limit))
+    params.set("limit", String(options.limit.value));
+  return operatorRequest({
+    url: options.urls[0],
+    path: `/operator/subscriptions/lagging?${params}`,
+    token
+  });
+};
+var Row = Schema8.Struct({
+  sourceType: Schema8.String,
+  sourceId: Schema8.String,
+  subscriberType: Schema8.String,
+  subscription: Schema8.String,
+  subscriberId: Schema8.String,
+  delivered: Schema8.String,
+  head: Schema8.String,
+  lag: Schema8.String,
+  attempts: Schema8.Finite,
+  lastError: Schema8.String
+});
+var decodeRows = Schema8.decodeUnknownEffect(Schema8.Array(Row));
+var formatLagging = (answer) => Effect12.map(decodeRows(answer), (rows) => rows.length === 0 ? "no lagging subscriptions" : rows.flatMap((row) => [
+  `${row.sourceType}/${row.sourceId} -> ${row.subscriberType}.${row.subscription}/${row.subscriberId}  delivered ${row.delivered} of ${row.head}  lag ${row.lag}  attempts ${row.attempts}`,
+  `  ${row.lastError.split(`
+`)[0] ?? ""}`
+]).join(`
+`));
+var listCommand2 = Command11.make("list", flags7, (options) => operatorCommand({ options, request: list, format: formatLagging })).pipe(Command11.withDescription("List subscription rows whose deliveries keep failing, with their lag and last error"));
+
+// src/commands/subscriptions/skip.ts
+import { Command as Command12, Flag as Flag11 } from "effect/cli";
+var flags8 = {
+  source: actorFlag({
+    name: "source",
+    description: "The source actor whose events the row delivers, as <Type>/<id>"
+  }),
+  subscriber: actorFlag({
+    name: "subscriber",
+    description: "The subscribing actor, as <Type>/<id>"
+  }),
+  subscription: Flag11.String("subscription").pipe(Flag11.filter((name) => name.length > 0, () => "a subscription name"), Flag11.withDescription("The subscription's name on the subscriber")),
+  through: Flag11.String("through").pipe(Flag11.filter((cursor) => /^[1-9][0-9]{0,17}$/.test(cursor), () => "a positive event cursor"), Flag11.withDescription("Skip every event up to and including this source event cursor")),
+  tenant,
+  reason,
+  ...operatorFlags
+};
+var skip = ({
+  options,
+  token
+}) => operatorRequest({
+  url: options.urls[0],
+  path: "/operator/subscriptions/skip",
+  token,
+  body: {
+    tenant: options.tenant,
+    sourceType: options.source.actorType,
+    sourceId: options.source.actorId,
+    subscriberType: options.subscriber.actorType,
+    subscription: options.subscription,
+    subscriberId: options.subscriber.actorId,
+    through: options.through,
+    reason: options.reason
+  }
+});
+var skipCommand = Command12.make("skip", flags8, (options) => operatorCommand({ options, request: skip, format: encodeJson })).pipe(Command12.withDescription("Skip a stuck subscription row's events through a cursor; the runner audits the skip"));
+
+// ../../packages/cloud-api/src/errors.ts
+import { Schema as Schema9 } from "effect";
+
+class Unauthorized extends Schema9.TaggedError()("Unauthorized", {
+  code: Schema9.Literals(["missing_credentials", "invalid_credentials", "expired"]),
+  message: Schema9.String
+}, { httpApiStatus: 401 }) {
+}
+
+class Forbidden extends Schema9.TaggedError()("Forbidden", { message: Schema9.String }, { httpApiStatus: 403 }) {
+}
+var NotFoundResource = Schema9.Literals([
+  "actor",
+  "actor-type",
+  "api-key",
+  "command",
+  "cursor",
+  "deployment",
+  "domain",
+  "environment",
+  "invitation",
+  "live deployment",
+  "member",
+  "organization",
+  "project",
+  "source"
+]);
+
+class NotFound extends Schema9.TaggedError()("NotFound", { resource: NotFoundResource, id: Schema9.String }, { httpApiStatus: 404 }) {
+}
+
+class Conflict extends Schema9.TaggedError()("Conflict", { message: Schema9.String }, { httpApiStatus: 409 }) {
+}
+
+class NotImplemented extends Schema9.TaggedError()("NotImplemented", { operation: Schema9.String }, { httpApiStatus: 501 }) {
+}
+var UnavailableReason = Schema9.Literals(["unknownPlan"]);
+
+class Unavailable extends Schema9.TaggedError()("Unavailable", {
+  message: Schema9.String,
+  retryAfterSeconds: Schema9.Int.check(Schema9.isGreaterThanOrEqualTo(1)),
+  reason: Schema9.optionalKey(UnavailableReason)
+}, { httpApiStatus: 503 }) {
+}
+
+class PayloadTooLarge extends Schema9.TaggedError()("PayloadTooLarge", { limitBytes: Schema9.Int }, { httpApiStatus: 413 }) {
+}
+var ReadErrors = [Forbidden, NotFound, NotImplemented, Unavailable];
+var WriteErrors = [Forbidden, NotFound, Conflict, NotImplemented, Unavailable];
+var SelfErrors = [Forbidden, NotImplemented];
+// ../../packages/cloud-api/src/auth.ts
+import { Context, Schema as Schema11 } from "effect";
+import { HttpApiMiddleware, HttpApiSecurity } from "effect/http-api";
+
+// ../../packages/cloud-api/src/primitives.ts
+import { Schema as Schema10 } from "effect";
+var identifier = Schema10.String.pipe(Schema10.check(Schema10.isMinLength(1), Schema10.isMaxLength(128)));
+var UserId = identifier.pipe(Schema10.brand("UserId"));
+var OrganizationId = identifier.pipe(Schema10.brand("OrganizationId"));
+var MemberId = identifier.pipe(Schema10.brand("MemberId"));
+var InvitationId = identifier.pipe(Schema10.brand("InvitationId"));
+var ApiKeyId = identifier.pipe(Schema10.brand("ApiKeyId"));
+var ProjectId = identifier.pipe(Schema10.brand("ProjectId"));
+var DeploymentId = identifier.pipe(Schema10.brand("DeploymentId"));
+var DomainId = identifier.pipe(Schema10.brand("DomainId"));
+var DeadLetterId = identifier.pipe(Schema10.brand("DeadLetterId"));
+var InvoiceId = identifier.pipe(Schema10.brand("InvoiceId"));
+var EnvironmentId = identifier.pipe(Schema10.brand("EnvironmentId"));
+var Slug = Schema10.String.pipe(Schema10.check(Schema10.isPattern(/^[a-z0-9](?:[a-z0-9-]{0,38}[a-z0-9])?$/)), Schema10.brand("Slug"));
+var Name = Schema10.String.pipe(Schema10.check(Schema10.isPattern(/^\S(?:.{0,98}\S)?$/)), Schema10.brand("Name"));
+var Email = Schema10.String.pipe(Schema10.check(Schema10.isPattern(/^[^\s@]+@[^\s@]+\.[^\s@]+$/), Schema10.isMaxLength(254)), Schema10.brand("Email"));
+var NonNegativeInt = Schema10.Int.pipe(Schema10.check(Schema10.isGreaterThanOrEqualTo(0)));
+var NonNegative = Schema10.Finite.pipe(Schema10.check(Schema10.isGreaterThanOrEqualTo(0)));
+var Timestamp = Schema10.DateTimeUtc;
+var CalendarDay = Schema10.String.pipe(Schema10.check(Schema10.isPattern(/^\d{4}-\d{2}-\d{2}$/)));
+var BillingPeriod = Schema10.String.pipe(Schema10.check(Schema10.isPattern(/^\d{4}-(?:0[1-9]|1[0-2])$/)));
+var Role = Schema10.Literals(["owner", "admin", "member", "viewer"]);
+var InviteRole = Schema10.Literals(["admin", "member", "viewer"]);
+var EnvironmentName = Schema10.Literals(["production", "staging", "dev"]);
+var RegionId = Schema10.Literals(["us-east-1", "us-west-2"]);
+var CommitSha = Schema10.String.pipe(Schema10.check(Schema10.isPattern(/^[0-9a-f]{7,40}$/)));
+var ActorAddress = Schema10.String.pipe(Schema10.check(Schema10.isMinLength(3), Schema10.isMaxLength(1024), Schema10.isPattern(/^[^/]+\/.+$/)));
+var ActorReference = Schema10.Struct({
+  kind: Schema10.Literals(["user", "api-key"]),
+  id: Schema10.String,
+  name: Schema10.NullOr(Schema10.String)
+});
+var SeriesPoint = Schema10.Struct({ at: Timestamp, value: Schema10.Finite });
+var pageQuery = {
+  limit: Schema10.optional(Schema10.Int.pipe(Schema10.check(Schema10.isBetween({ minimum: 1, maximum: 100 })))),
+  cursor: Schema10.optional(Schema10.String)
+};
+var Page = (item) => Schema10.Struct({ items: Schema10.Array(item), nextCursor: Schema10.NullOr(Schema10.String) });
+
+// ../../packages/cloud-api/src/auth.ts
+var sessionCookieName = "better-auth.session_token";
+var secureSessionCookieName = "__Secure-better-auth.session_token";
+var apiKeyHeaderName = "x-api-key";
+var SessionIdentity = Schema11.TaggedStruct("session", {
+  userId: UserId,
+  sessionId: Schema11.String,
+  activeOrganizationId: Schema11.NullOr(OrganizationId)
+});
+var ApiKeyIdentity = Schema11.TaggedStruct("api-key", {
+  keyId: ApiKeyId,
+  organizationId: OrganizationId,
+  permission: Schema11.Literals(["read", "write", "admin"])
+});
+var Identity = Schema11.Union([SessionIdentity, ApiKeyIdentity]);
+
+class CurrentIdentity extends Context.Service()("@akter/cloud-api/auth/CurrentIdentity") {
+}
+
+class Authentication extends HttpApiMiddleware.Service()("@akter/cloud-api/Authentication", {
+  security: {
+    session: HttpApiSecurity.apiKey({ key: sessionCookieName, in: "cookie" }),
+    secureSession: HttpApiSecurity.apiKey({ key: secureSessionCookieName, in: "cookie" }),
+    apiKey: HttpApiSecurity.apiKey({ key: apiKeyHeaderName, in: "header" }),
+    bearer: HttpApiSecurity.bearer
+  },
+  error: [Unauthorized, Forbidden, Unavailable]
+}) {
+}
+// ../../packages/cloud-api/src/identity.ts
+import { Schema as Schema12 } from "effect";
+var PlanId = Schema12.Literals(["free", "pro", "team", "enterprise"]);
+var UnboundPlan = Schema12.TaggedStruct("unbound", {});
+var KnownPlan = Schema12.TaggedStruct("known", { id: PlanId });
+var UnknownPlan = Schema12.TaggedStruct("unknown", { id: Schema12.String });
+var OrganizationPlan = Schema12.Union([UnboundPlan, KnownPlan, UnknownPlan]);
+var User2 = Schema12.Struct({
+  id: UserId,
+  name: Schema12.String,
+  email: Email,
+  emailVerified: Schema12.Boolean,
+  image: Schema12.NullOr(Schema12.String)
+});
+var Organization = Schema12.Struct({
+  id: OrganizationId,
+  name: Schema12.String,
+  slug: Slug,
+  plan: OrganizationPlan,
+  createdAt: Timestamp
+});
+var OrganizationMembership = Schema12.Struct({
+  organization: Organization,
+  role: Role
+});
+var Me = Schema12.Struct({
+  user: Schema12.NullOr(User2),
+  identityKind: Schema12.Literals(["session", "api-key"]),
+  activeOrganizationId: Schema12.NullOr(OrganizationId),
+  organizations: Schema12.Array(OrganizationMembership)
+});
+var UpdateProfile = Schema12.Struct({
+  name: Schema12.optional(Name),
+  image: Schema12.optional(Schema12.NullOr(Schema12.String))
+});
+var DeleteAccount = Schema12.Struct({ confirmation: Email });
+var PersonalDataExport = Schema12.Struct({
+  userId: UserId,
+  exportedAt: Timestamp,
+  tables: Schema12.Record(Schema12.String, Schema12.Array(Schema12.Json))
+});
+var OrganizationDeletion = Schema12.Struct({
+  organizationId: OrganizationId,
+  phase: Schema12.Literals(["billing", "runners", "databases", "records", "completed"]),
+  blocked: Schema12.Boolean
+});
+var SetActiveOrganization = Schema12.Struct({ organizationId: OrganizationId });
+var CreateOrganization = Schema12.Struct({ name: Name, slug: Slug });
+var UpdateOrganization = Schema12.Struct({
+  name: Schema12.optional(Name),
+  slug: Schema12.optional(Slug)
+});
+var MemberUser = Schema12.Struct({
+  id: UserId,
+  name: Schema12.String,
+  email: Email,
+  image: Schema12.NullOr(Schema12.String)
+});
+var Member = Schema12.Struct({
+  id: MemberId,
+  user: MemberUser,
+  role: Role,
+  createdAt: Timestamp,
+  lastActiveAt: Schema12.NullOr(Timestamp)
+});
+var UpdateMemberRole = Schema12.Struct({ role: Role });
+var InvitationStatus = Schema12.Literals([
+  "pending",
+  "accepted",
+  "declined",
+  "canceled",
+  "expired"
+]);
+var Invitation = Schema12.Struct({
+  id: InvitationId,
+  organizationId: OrganizationId,
+  email: Email,
+  role: InviteRole,
+  status: InvitationStatus,
+  invitedBy: Schema12.Struct({ id: UserId, name: Schema12.String }),
+  createdAt: Timestamp,
+  expiresAt: Timestamp
+});
+var CreateInvitation = Schema12.Struct({ email: Email, role: InviteRole });
+var InvitationPreview = Schema12.Struct({
+  id: InvitationId,
+  email: Email,
+  role: InviteRole,
+  status: InvitationStatus,
+  expiresAt: Timestamp,
+  inviterName: Schema12.String,
+  organization: Schema12.Struct({
+    id: OrganizationId,
+    name: Schema12.String,
+    slug: Slug,
+    plan: OrganizationPlan,
+    memberCount: NonNegativeInt
+  })
+});
+var ApiKeyPermission = Schema12.Literals(["read", "write", "admin"]);
+var ApiKey = Schema12.Struct({
+  id: ApiKeyId,
+  organizationId: OrganizationId,
+  name: Schema12.String,
+  prefix: Schema12.String,
+  lastFour: Schema12.String,
+  permission: ApiKeyPermission,
+  projectId: Schema12.NullOr(ProjectId),
+  createdAt: Timestamp,
+  createdBy: ActorReference,
+  lastUsedAt: Schema12.NullOr(Timestamp),
+  expiresAt: Schema12.NullOr(Timestamp),
+  revokedAt: Schema12.NullOr(Timestamp)
+});
+var CreateApiKey = Schema12.Struct({
+  name: Name,
+  permission: ApiKeyPermission,
+  projectId: Schema12.optional(ProjectId),
+  expiresAt: Schema12.optional(Timestamp)
+});
+var CreatedApiKey = Schema12.Struct({
+  key: ApiKey,
+  secret: Schema12.String
+});
+var Theme = Schema12.Literals(["light", "dark", "system"]);
+var Preferences = Schema12.Struct({
+  defaultEnvironment: EnvironmentName,
+  openActorLinksInNewTab: Schema12.Boolean,
+  timeZone: Schema12.String,
+  pauseLiveTailOnScroll: Schema12.Boolean,
+  showReplayedCommands: Schema12.Boolean,
+  theme: Theme
+});
+var UpdatePreferences = Schema12.Struct({
+  defaultEnvironment: Schema12.optional(EnvironmentName),
+  openActorLinksInNewTab: Schema12.optional(Schema12.Boolean),
+  timeZone: Schema12.optional(Schema12.String),
+  pauseLiveTailOnScroll: Schema12.optional(Schema12.Boolean),
+  showReplayedCommands: Schema12.optional(Schema12.Boolean),
+  theme: Schema12.optional(Theme)
+});
+var NotificationEvent = Schema12.Literals([
+  "deploy_failed",
+  "dead_letter",
+  "spend_threshold"
+]);
+var NotificationPreference = Schema12.Struct({
+  event: NotificationEvent,
+  email: Schema12.Boolean,
+  slack: Schema12.Boolean
+});
+var NotificationSettings = Schema12.Struct({
+  preferences: Schema12.Array(NotificationPreference)
+});
+var PinnedActor = Schema12.Struct({
+  projectId: ProjectId,
+  environment: EnvironmentName,
+  address: Schema12.String,
+  status: Schema12.Literals(["awake", "idle", "unknown"]),
+  lastActivityAt: Schema12.NullOr(Timestamp)
+});
+var PinActor = Schema12.Struct({
+  projectId: ProjectId,
+  environment: EnvironmentName,
+  address: Schema12.String
+});
+// ../../packages/cloud-api/src/projects.ts
+import { Schema as Schema13 } from "effect";
+var ProjectStatus = Schema13.Literals(["empty", "live", "deploying", "failed"]);
+var Region = Schema13.Struct({ id: RegionId, city: Schema13.String });
+var Project = Schema13.Struct({
+  id: ProjectId,
+  organizationId: OrganizationId,
+  name: Schema13.String,
+  slug: Slug,
+  status: ProjectStatus,
+  homeRegion: RegionId,
+  createdAt: Timestamp
+});
+var CreateProject = Schema13.Struct({ name: Name, slug: Slug, homeRegion: RegionId });
+var UpdateProject = Schema13.Struct({
+  name: Schema13.optional(Name),
+  slug: Schema13.optional(Slug)
+});
+var Environment = Schema13.Struct({
+  name: EnvironmentName,
+  projectId: ProjectId,
+  currentDeploymentId: Schema13.NullOr(DeploymentId),
+  database: Schema13.optionalKey(Schema13.Struct({
+    source: Schema13.Literal("customer"),
+    state: Schema13.Literals(["missing", "reachable", "unreachable"]),
+    latency: Schema13.NullOr(NonNegative),
+    latencyWarning: Schema13.Boolean,
+    runnerCap: Schema13.NullOr(Schema13.Int)
+  }))
+});
+var CreateEnvironment = Schema13.Struct({ name: EnvironmentName });
+var EnvVariable = Schema13.Struct({
+  name: Schema13.String,
+  usedBy: Schema13.Array(Schema13.String),
+  updatedAt: Timestamp,
+  updatedBy: Schema13.NullOr(ActorReference)
+});
+var EnvVariableName = Schema13.String.pipe(Schema13.check(Schema13.isPattern(/^[A-Za-z_][A-Za-z0-9_]{0,255}$/)));
+var SetEnvVariable = Schema13.Struct({
+  value: Schema13.String.pipe(Schema13.check(Schema13.isMaxLength(65536)))
+});
+var ImportEnvVariables = Schema13.Struct({
+  content: Schema13.String.pipe(Schema13.check(Schema13.isMaxLength(1048576)))
+});
+var ImportEnvVariablesResult = Schema13.Struct({
+  created: Schema13.Array(Schema13.String),
+  updated: Schema13.Array(Schema13.String)
+});
+var DomainStatus = Schema13.Literals(["pending", "verifying", "active"]);
+var DnsRecord = Schema13.Struct({
+  type: Schema13.Literals(["A", "AAAA", "CNAME", "TXT"]),
+  name: Schema13.String,
+  value: Schema13.String
+});
+var Hostname = Schema13.String.pipe(Schema13.check(Schema13.isMaxLength(253), Schema13.isPattern(/^(?=.{1,253}$)(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]{2,63}$/)));
+var Domain = Schema13.Struct({
+  id: DomainId,
+  hostname: Hostname,
+  environment: EnvironmentName,
+  status: DomainStatus,
+  dnsRecords: Schema13.Array(DnsRecord),
+  createdAt: Timestamp
+});
+var AddDomain = Schema13.Struct({ hostname: Hostname, environment: EnvironmentName });
+var OwnedTable = Schema13.Struct({
+  name: Schema13.String,
+  actor: Schema13.String,
+  rows: NonNegativeInt,
+  sizeBytes: NonNegativeInt,
+  region: RegionId
+});
+var ProjectRegion = Schema13.Struct({
+  region: Region,
+  home: Schema13.Boolean,
+  tenantCount: NonNegativeInt,
+  database: Schema13.Struct({ version: Schema13.String, sizeBytes: NonNegativeInt }),
+  storage: Schema13.Struct({ usedBytes: NonNegativeInt, limitBytes: NonNegativeInt }),
+  cpuPercent: NonNegative,
+  connections: Schema13.Struct({ used: NonNegativeInt, limit: NonNegativeInt }),
+  runners: NonNegativeInt,
+  largestTables: Schema13.Array(OwnedTable)
+});
+var AddRegion = Schema13.Struct({ region: RegionId });
+var SetHomeRegion = Schema13.Struct({ region: RegionId });
+var ProjectEndpoints = Schema13.Struct({
+  httpBaseUrl: Schema13.String,
+  webSocketUrl: Schema13.String,
+  openApiPath: Schema13.String,
+  mcpPath: Schema13.String
+});
+var IntegrationKind = Schema13.Literals([
+  "github",
+  "slack",
+  "datadog",
+  "opentelemetry",
+  "pagerduty"
+]);
+var Integration = Schema13.Struct({
+  kind: IntegrationKind,
+  status: Schema13.Literals(["connected", "disconnected", "error"]),
+  label: Schema13.NullOr(Schema13.String),
+  connectedAt: Schema13.NullOr(Timestamp)
+});
+var ConnectIntegration = Schema13.Struct({
+  settings: Schema13.optional(Schema13.Record(Schema13.String, Schema13.String))
+});
+var IntegrationConnection = Schema13.Struct({
+  redirectUrl: Schema13.NullOr(Schema13.String),
+  integration: Integration
+});
+// ../../packages/cloud-api/src/deployments.ts
+import { Schema as Schema14 } from "effect";
+var DeploymentStatus = Schema14.Literals([
+  "in-progress",
+  "live",
+  "drained",
+  "rolled-back",
+  "failed"
+]);
+var RolloutStepName = Schema14.Literals([
+  "build",
+  "migrate",
+  "start-runners",
+  "drain-previous"
+]);
+var RolloutStep = Schema14.Struct({
+  name: RolloutStepName,
+  status: Schema14.Literals(["pending", "running", "succeeded", "failed", "skipped"]),
+  durationMs: Schema14.NullOr(NonNegativeInt),
+  detail: Schema14.NullOr(Schema14.String)
+});
+var DeploymentRunner = Schema14.Struct({
+  id: Schema14.String,
+  region: RegionId,
+  actorCount: Schema14.NullOr(NonNegativeInt),
+  cpuPercent: Schema14.NullOr(NonNegative),
+  health: Schema14.Literals(["healthy", "unhealthy", "starting", "draining"])
+});
+var DeploymentAuthor = Schema14.Struct({
+  name: Schema14.String,
+  image: Schema14.NullOr(Schema14.String)
+});
+var DeploymentSummary = Schema14.Struct({
+  id: DeploymentId,
+  projectId: ProjectId,
+  environment: EnvironmentName,
+  environmentHost: Schema14.optional(Schema14.String),
+  commitSha: CommitSha,
+  message: Schema14.String,
+  author: DeploymentAuthor,
+  regions: Schema14.Array(RegionId),
+  runnerCount: NonNegativeInt,
+  durationMs: Schema14.NullOr(NonNegativeInt),
+  status: DeploymentStatus,
+  rolledBackFrom: Schema14.NullOr(DeploymentId),
+  createdAt: Timestamp
+});
+var DeploymentDetail = Schema14.Struct({
+  ...DeploymentSummary.fields,
+  steps: Schema14.Array(RolloutStep),
+  runners: Schema14.Array(DeploymentRunner)
+});
+var SourceDigest = Schema14.String.pipe(Schema14.check(Schema14.isPattern(/^sha256:[a-f0-9]{64}$/u)));
+var MAX_SOURCE_BYTES = 64 * 1024 * 1024;
+var SourceArchive = Schema14.Struct({
+  digest: SourceDigest,
+  sizeBytes: NonNegativeInt
+});
+var SOURCE_ENTRY = "src/app.ts";
+var DeploymentSource = Schema14.Struct({
+  digest: SourceDigest,
+  dockerfile: Schema14.optionalKey(Schema14.Never.annotate({
+    message: `source.dockerfile is not accepted: the platform builds every source from ${SOURCE_ENTRY}`
+  }))
+});
+var CreateDeployment = Schema14.Struct({
+  environment: EnvironmentName,
+  commitSha: CommitSha,
+  message: Schema14.optional(Schema14.String),
+  regions: Schema14.optional(Schema14.Array(RegionId)),
+  source: Schema14.optional(DeploymentSource)
+});
+var ImageDigest = Schema14.String.pipe(Schema14.check(Schema14.isPattern(/^(?:[^\s@]+@)?sha256:[a-f0-9]{64}$/u)));
+var RecordBuild = Schema14.Struct({
+  image: ImageDigest,
+  commitSha: CommitSha,
+  environmentSnapshot: Schema14.Record(Schema14.String, Schema14.String).check(Schema14.makeFilter((snapshot) => Object.keys(snapshot).every((key) => /^[A-Za-z_][A-Za-z0-9_]{0,254}$/u.test(key)) || "Environment variable names must be valid identifiers"))
+});
+var FailBuild = Schema14.Struct({
+  reason: Schema14.String.check(Schema14.isMinLength(1), Schema14.isMaxLength(4096))
+});
+var BuildLogLine = Schema14.Struct({
+  index: NonNegativeInt,
+  at: Timestamp,
+  stream: Schema14.Literals(["stdout", "stderr"]),
+  text: Schema14.String
+});
+var BuildLog = Schema14.Struct({
+  lines: Schema14.Array(BuildLogLine),
+  complete: Schema14.Boolean
+});
+// ../../packages/cloud-api/src/runtime.ts
+import * as Framework from "@rikalabs/akter/client";
+import { Schema as Schema15, Struct as Struct2 } from "effect";
+var SidebarCounts = Schema15.Struct({
+  actorTypes: NonNegativeInt,
+  openDeadLetters: NonNegativeInt
+});
+var Overview = Schema15.Struct({
+  commands: Schema15.NullOr(Schema15.Struct({
+    perSecond: NonNegative,
+    series24h: Schema15.Array(SeriesPoint),
+    p50Ms: Schema15.NullOr(NonNegative),
+    p99Ms: Schema15.NullOr(NonNegative)
+  })),
+  actors: Schema15.Struct({ awake: Schema15.NullOr(NonNegativeInt), total: NonNegativeInt }),
+  jobs: Schema15.Struct({ inFlight: NonNegativeInt, donePerHour: Schema15.NullOr(NonNegativeInt) }),
+  deadLettersByJobType: Schema15.Array(Schema15.Struct({ jobName: Schema15.String, count: NonNegativeInt })),
+  throughput: Schema15.NullOr(Schema15.Array(SeriesPoint)),
+  p99: Schema15.NullOr(Schema15.Array(SeriesPoint)),
+  health: Schema15.Struct({
+    runners: Schema15.NullOr(Schema15.Struct({ healthy: NonNegativeInt, total: NonNegativeInt })),
+    databaseCpuPercent: Schema15.NullOr(NonNegative),
+    maxMailbox: Schema15.NullOr(Schema15.Struct({ depth: NonNegativeInt, actor: Schema15.NullOr(ActorAddress) })),
+    parkedSockets: Schema15.NullOr(NonNegativeInt),
+    outboxLagP99Ms: Schema15.NullOr(NonNegative),
+    lastDeployAt: Schema15.NullOr(Timestamp)
+  }),
+  recentDeployments: Schema15.NullOr(Schema15.Array(DeploymentSummary))
+});
+var ActorTypeSummary = Schema15.Struct({
+  name: Schema15.String,
+  commands: Schema15.NullOr(Schema15.Array(Schema15.String)),
+  instances: NonNegativeInt,
+  awake: Schema15.NullOr(NonNegativeInt),
+  commandsPerSecond: Schema15.NullOr(NonNegative),
+  p99Ms: Schema15.NullOr(NonNegative),
+  maxMailbox: Schema15.NullOr(NonNegativeInt)
+});
+var SeriesWindow = Schema15.Literals(["1h", "24h", "7d"]);
+var CommandVolume = Schema15.Struct({
+  command: Schema15.String,
+  count: NonNegativeInt,
+  perSecond: NonNegative
+});
+var ActorTypeActivity = Schema15.Struct({
+  window: SeriesWindow,
+  since: Timestamp,
+  series: Schema15.Array(SeriesPoint),
+  commands: Schema15.Array(CommandVolume)
+});
+var LatencyBucket = Schema15.Struct({
+  upToMs: Schema15.NullOr(NonNegative),
+  count: NonNegativeInt
+});
+var TurnLatency = Schema15.Struct({
+  window: SeriesWindow,
+  since: Timestamp,
+  buckets: Schema15.Array(LatencyBucket),
+  p50Ms: Schema15.NullOr(NonNegative),
+  p95Ms: Schema15.NullOr(NonNegative),
+  p99Ms: Schema15.NullOr(NonNegative)
+});
+var ActorInstance = Schema15.Struct({
+  key: Schema15.String,
+  status: Schema15.NullOr(Schema15.Literals(["awake", "idle"])),
+  lastCommand: Schema15.NullOr(Schema15.String),
+  lastActivityAt: Schema15.NullOr(Timestamp),
+  generation: NonNegativeInt
+});
+var OwnedTableRows = Schema15.Struct({
+  table: Schema15.String,
+  columns: Schema15.Array(Schema15.String),
+  rows: Schema15.Array(Schema15.Array(Schema15.Json))
+});
+var CommandCaller = Schema15.Struct({
+  kind: Schema15.Literals(["user", "anonymous", "system"]),
+  subject: Schema15.NullOr(Schema15.String),
+  source: Schema15.NullOr(Schema15.String)
+});
+var Receipt = Schema15.Struct({
+  commandId: Schema15.String,
+  command: Schema15.String,
+  result: Schema15.NullOr(Schema15.String),
+  caller: Schema15.NullOr(CommandCaller),
+  at: Schema15.NullOr(Timestamp),
+  expiresAt: Timestamp,
+  replayed: Schema15.Boolean
+});
+var ActorEvent = Schema15.Struct({
+  name: Schema15.String,
+  cursor: Schema15.String,
+  emittedAt: Timestamp,
+  subscribers: Schema15.NullOr(NonNegativeInt)
+});
+var JobStatus = Schema15.Literals(["queued", "running", "retrying", "done", "dead"]);
+var ActorJob = Schema15.Struct({
+  name: Schema15.String,
+  id: Schema15.String,
+  attempts: NonNegativeInt,
+  status: JobStatus
+});
+var ActorTimelineEntry = Schema15.Struct({
+  at: Timestamp,
+  kind: Schema15.Literals(["command", "event", "job"]),
+  label: Schema15.String,
+  detail: Schema15.NullOr(Schema15.String),
+  caller: Schema15.NullOr(CommandCaller)
+});
+var ActorInspector = Schema15.Struct({
+  address: ActorAddress,
+  state: Schema15.Json,
+  turn: Schema15.NullOr(NonNegativeInt),
+  tables: Schema15.NullOr(Schema15.Array(OwnedTableRows)),
+  receipts: Schema15.Array(Receipt),
+  events: Schema15.Array(ActorEvent),
+  jobs: Schema15.Array(ActorJob),
+  connections: Schema15.Struct({
+    sockets: Schema15.NullOr(NonNegativeInt),
+    feedCursor: Schema15.NullOr(Schema15.String)
+  }),
+  properties: Schema15.Struct({
+    status: Schema15.NullOr(Schema15.Literals(["awake", "idle"])),
+    type: Schema15.String,
+    generation: NonNegativeInt,
+    runner: Schema15.NullOr(Schema15.String),
+    region: Schema15.NullOr(Schema15.String),
+    tenant: Schema15.String,
+    mailboxDepth: Schema15.NullOr(NonNegativeInt)
+  }),
+  timeline: Schema15.NullOr(Schema15.Array(ActorTimelineEntry))
+});
+var CommandOutcome = Schema15.Literals(["ok", "error", "replayed"]);
+var CommandLogEntry = Schema15.Struct({
+  commandId: Schema15.String,
+  at: Schema15.NullOr(Timestamp),
+  durationMs: Schema15.NullOr(NonNegative),
+  address: ActorAddress,
+  command: Schema15.String,
+  caller: Schema15.NullOr(CommandCaller),
+  payloadPreview: Schema15.NullOr(Schema15.String),
+  outcome: CommandOutcome,
+  errorTag: Schema15.NullOr(Schema15.String)
+});
+var commandName = Schema15.String.pipe(Schema15.check(Schema15.isMinLength(1), Schema15.isMaxLength(128)));
+var SendCommand = Schema15.Struct({
+  address: ActorAddress,
+  command: commandName,
+  payload: Schema15.Json,
+  commandId: Schema15.optional(commandName)
+});
+var CommandSent = Schema15.Struct({
+  commandId: Schema15.String,
+  result: Schema15.Json,
+  replayed: Schema15.Boolean
+});
+
+class CommandExpired extends Schema15.TaggedError()("CommandExpired", { commandId: Schema15.String }, { httpApiStatus: 410 }) {
+}
+
+class CommandStreamGap extends Schema15.TaggedError()("CommandStreamGap", {}) {
+}
+
+class RunnerDefect extends Schema15.TaggedError()("RunnerDefect", {}, { httpApiStatus: 502 }) {
+}
+
+class CommandRefused extends Schema15.TaggedError()("CommandRefused", {
+  commandId: Schema15.String,
+  reasonTag: Schema15.String,
+  reason: Framework.ActorError.fields.reason
+}, { httpApiStatus: 422 }) {
+}
+
+class CommandFailed2 extends Schema15.TaggedError()("CommandFailed", {
+  commandId: Schema15.String,
+  errorTag: Schema15.String,
+  error: Schema15.Json,
+  replayed: Schema15.Boolean
+}, { httpApiStatus: 422 }) {
+}
+
+class QuotaExceeded2 extends Schema15.TaggedError()("QuotaExceeded", Struct2.omit(Framework.QuotaExceeded.fields, ["_tag"]), { httpApiStatus: 429 }) {
+}
+
+class QuotaUnbound extends Schema15.TaggedError()("QuotaUnbound", {
+  deployment: Schema15.String,
+  tenant: Schema15.String,
+  reason: Schema15.Literals(["tenant", "account", "plan"])
+}, { httpApiStatus: 402 }) {
+}
+var QuotaErrors = [QuotaExceeded2, QuotaUnbound];
+var JobTypeStats = Schema15.Struct({
+  jobName: Schema15.String,
+  done: Schema15.NullOr(NonNegativeInt),
+  retried: NonNegativeInt,
+  dead: NonNegativeInt,
+  p99Ms: Schema15.NullOr(NonNegative)
+});
+var JobsSummary = Schema15.Struct({
+  queued: NonNegativeInt,
+  running: Schema15.NullOr(NonNegativeInt),
+  retrying: NonNegativeInt,
+  dead: NonNegativeInt,
+  byType: Schema15.Array(JobTypeStats),
+  throughput: Schema15.NullOr(Schema15.Array(SeriesPoint))
+});
+var DeadLetter = Schema15.Struct({
+  id: DeadLetterId,
+  jobName: Schema15.String,
+  jobId: Schema15.String,
+  actor: ActorAddress,
+  attempts: NonNegativeInt,
+  lastError: Schema15.String,
+  since: Timestamp
+});
+var Workflow = Schema15.Struct({
+  id: Schema15.String,
+  name: Schema15.String,
+  actor: ActorAddress,
+  step: Schema15.NullOr(Schema15.Struct({
+    index: Schema15.Int.pipe(Schema15.check(Schema15.isGreaterThanOrEqualTo(1))),
+    total: Schema15.NullOr(Schema15.Int.pipe(Schema15.check(Schema15.isGreaterThanOrEqualTo(1)))),
+    name: Schema15.String
+  }).pipe(Schema15.check(Schema15.makeFilter((step) => step.total === null || step.index <= step.total || "step.index must not exceed step.total")))),
+  waitingFor: Schema15.NullOr(Schema15.Struct({ kind: Schema15.Literals(["event", "timer"]), name: Schema15.String })),
+  startedAt: Timestamp,
+  status: Schema15.NullOr(Schema15.Literals(["running", "waiting", "completed", "failed"]))
+});
+var TimersSummary = Schema15.Struct({
+  pending: NonNegativeInt,
+  nextFireAt: Schema15.NullOr(Timestamp)
+});
+var Schedule = Schema15.Struct({
+  name: Schema15.String,
+  actorPattern: Schema15.String,
+  cron: Schema15.String,
+  lastRun: Schema15.NullOr(Schema15.Struct({
+    at: Timestamp,
+    outcome: Schema15.Literals(["ok", "error"]),
+    durationMs: Schema15.NullOr(NonNegative)
+  })),
+  nextRunAt: Schema15.NullOr(Timestamp)
+});
+var ConnectionsSummary = Schema15.Struct({
+  open: NonNegativeInt,
+  parked: Schema15.NullOr(NonNegativeInt),
+  sseStreams: NonNegativeInt,
+  feedSubscribers: NonNegativeInt,
+  replayGaps: Schema15.NullOr(NonNegativeInt),
+  openVersusParked: Schema15.NullOr(Schema15.Array(Schema15.Struct({ at: Timestamp, open: NonNegativeInt, parked: NonNegativeInt }))),
+  byActorType: Schema15.Array(Schema15.Struct({
+    actorType: Schema15.String,
+    open: NonNegativeInt,
+    parked: Schema15.NullOr(NonNegativeInt),
+    sse: NonNegativeInt
+  }))
+});
+var SearchResult = Schema15.Struct({
+  kind: Schema15.Literals(["actor-type", "actor", "deployment"]),
+  id: Schema15.String,
+  title: Schema15.String,
+  subtitle: Schema15.NullOr(Schema15.String)
+});
+// ../../packages/cloud-api/src/billing.ts
+import { Schema as Schema16 } from "effect";
+var Plan = Schema16.TaggedStruct("known", {
+  id: PlanId,
+  name: Schema16.String,
+  basePriceCents: NonNegativeInt,
+  currency: Schema16.Literal("usd"),
+  renewsAt: Schema16.NullOr(Timestamp),
+  monthToDateEstimateCents: NonNegativeInt,
+  provisional: Schema16.optionalKey(Schema16.Boolean),
+  subscribedId: Schema16.optionalKey(PlanId),
+  paymentStatus: Schema16.optionalKey(Schema16.Literals(["free", "active", "past_due", "unpaid", "canceled", "incomplete"]))
+});
+var CardPaymentMethod = Schema16.TaggedStruct("card", {
+  brand: Schema16.String,
+  lastFour: Schema16.String,
+  expiryMonth: Schema16.Int.pipe(Schema16.check(Schema16.isBetween({ minimum: 1, maximum: 12 }))),
+  expiryYear: NonNegativeInt
+});
+var LinkPaymentMethod = Schema16.TaggedStruct("link", {
+  email: Schema16.NullOr(Schema16.String)
+});
+var PaymentMethod = Schema16.Union([CardPaymentMethod, LinkPaymentMethod]);
+var SpendLimit = Schema16.Struct({
+  limitCents: Schema16.NullOr(NonNegativeInt),
+  currentSpendCents: NonNegativeInt
+});
+var capFields = {
+  limit: Schema16.NullOr(NonNegative),
+  used: NonNegative,
+  atCap: Schema16.Boolean,
+  refusing: Schema16.Boolean,
+  reason: Schema16.optionalKey(Schema16.Literal("unbound"))
+};
+var CapState = Schema16.Struct({
+  cap: Schema16.Literals(["spend", "connections", "compute"]),
+  ...capFields
+});
+var BillingSummary = Schema16.Struct({
+  plan: Schema16.Union([Plan, UnboundPlan]),
+  paymentMethod: Schema16.NullOr(PaymentMethod),
+  billingEmail: Schema16.NullOr(Email),
+  spendLimit: SpendLimit,
+  caps: Schema16.optionalKey(Schema16.Array(CapState))
+});
+var SetSpendLimit = Schema16.Struct({ limitCents: Schema16.NullOr(NonNegativeInt) });
+var Invoice = Schema16.Struct({
+  id: InvoiceId,
+  number: Schema16.String,
+  periodStart: Timestamp,
+  periodEnd: Timestamp,
+  amountCents: NonNegativeInt,
+  currency: Schema16.Literal("usd"),
+  status: Schema16.Literals(["draft", "open", "paid", "void", "uncollectible"]),
+  pdfUrl: Schema16.NullOr(Schema16.String)
+});
+var StartCheckout = Schema16.Struct({ plan: Schema16.Literals(["pro", "team", "enterprise"]) });
+var PlanChange = Schema16.Struct({
+  requestId: Schema16.String,
+  status: Schema16.Literals(["pending", "completed", "failed"])
+});
+var HostedSession = Schema16.Struct({ url: Schema16.String });
+var machineSizeFields = {
+  cpuKind: Schema16.Literals(["shared", "performance"]),
+  cpus: Schema16.Int.check(Schema16.isGreaterThanOrEqualTo(1)),
+  memoryMb: Schema16.Int.check(Schema16.isGreaterThanOrEqualTo(1))
+};
+var PlanFeature = Schema16.Literals([
+  "compute-overage",
+  "compute-cap",
+  "byo-database",
+  "checkout"
+]);
+var CatalogPlan = Schema16.Struct({
+  id: PlanId,
+  name: Schema16.String,
+  basePriceCents: NonNegativeInt,
+  currency: Schema16.Literal("usd"),
+  allowances: Schema16.Struct({
+    computeUnitHours: NonNegative,
+    computeUnitHourCap: Schema16.NullOr(NonNegative),
+    concurrentConnections: NonNegativeInt
+  }),
+  overage: Schema16.Struct({
+    computeCentsPerUnitHour: NonNegative
+  }),
+  features: Schema16.Array(PlanFeature),
+  provisional: Schema16.Boolean
+});
+var ComputeSize = Schema16.Struct({
+  ...machineSizeFields,
+  unitsPerHour: Schema16.Finite.check(Schema16.isGreaterThan(0))
+});
+var PlanCatalog = Schema16.Struct({
+  plans: Schema16.Array(CatalogPlan),
+  computeSizes: Schema16.Array(ComputeSize),
+  provisional: Schema16.Boolean
+});
+var UsageMeterName = Schema16.Literal("runnerHours");
+var UsageMeter = Schema16.Struct({
+  meter: UsageMeterName,
+  used: NonNegative,
+  included: NonNegative,
+  overage: NonNegative,
+  overageCostCents: NonNegative
+});
+var UsagePricing = Schema16.Struct({
+  computeCentsPerUnitHour: NonNegative,
+  provisional: Schema16.optionalKey(Schema16.Boolean)
+});
+var ComputeUsage = Schema16.Struct({
+  environmentId: EnvironmentId,
+  ...machineSizeFields,
+  machineHours: NonNegative,
+  computeUnitHours: NonNegative
+});
+var Usage = Schema16.Struct({
+  period: BillingPeriod,
+  meters: Schema16.Array(UsageMeter),
+  caps: Schema16.Array(CapState),
+  byProject: Schema16.Array(Schema16.Struct({
+    projectId: ProjectId,
+    name: Schema16.String,
+    computeUnitHours: NonNegative,
+    compute: Schema16.Array(ComputeUsage),
+    estimatedCostCents: NonNegative
+  })),
+  pricing: UsagePricing
+});
+var AuditEntry = Schema16.Struct({
+  id: Schema16.String,
+  at: Timestamp,
+  actor: ActorReference,
+  action: Schema16.String,
+  target: Schema16.Struct({
+    type: Schema16.String,
+    id: Schema16.NullOr(Schema16.String),
+    name: Schema16.NullOr(Schema16.String)
+  }),
+  ipAddress: Schema16.NullOr(Schema16.String)
+});
+// ../../packages/cloud-api/src/contract.ts
+import { HttpApi, OpenApi as OpenApi3 } from "effect/http-api";
+
+// ../../packages/cloud-api/src/groups/account.ts
+import { Schema as Schema17 } from "effect";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
+var organizationParams = { organizationId: OrganizationId };
+
+class AccountGroup extends HttpApiGroup.make("account").add(HttpApiEndpoint.get("me", "/me", { success: Me, error: SelfErrors }), HttpApiEndpoint.get("exportData", "/me/export", {
+  success: PersonalDataExport,
+  error: SelfErrors
+}), HttpApiEndpoint.delete("deleteAccount", "/me", {
+  payload: DeleteAccount,
+  error: WriteErrors
+}), HttpApiEndpoint.patch("updateProfile", "/me", {
+  payload: UpdateProfile,
+  success: User2,
+  error: SelfErrors
+}), HttpApiEndpoint.put("setActiveOrganization", "/me/active-organization", {
+  payload: SetActiveOrganization,
+  success: OrganizationMembership,
+  error: WriteErrors
+}), HttpApiEndpoint.get("getPreferences", "/me/preferences", {
+  success: Preferences,
+  error: SelfErrors
+}), HttpApiEndpoint.patch("updatePreferences", "/me/preferences", {
+  payload: UpdatePreferences,
+  success: Preferences,
+  error: SelfErrors
+}), HttpApiEndpoint.get("getNotifications", "/me/notifications", {
+  success: NotificationSettings,
+  error: SelfErrors
+}), HttpApiEndpoint.put("setNotifications", "/me/notifications", {
+  payload: NotificationSettings,
+  success: NotificationSettings,
+  error: SelfErrors
+}), HttpApiEndpoint.get("listPinnedActors", "/me/pinned-actors", {
+  query: { projectId: ProjectId, environment: EnvironmentName },
+  success: Schema17.Array(PinnedActor),
+  error: ReadErrors
+}), HttpApiEndpoint.post("pinActor", "/me/pinned-actors", {
+  payload: PinActor,
+  success: PinnedActor,
+  error: WriteErrors
+}), HttpApiEndpoint.delete("unpinActor", "/me/pinned-actors", {
+  query: { projectId: ProjectId, environment: EnvironmentName, address: Schema17.String },
+  error: WriteErrors
+})) {
+}
+
+class OrganizationsGroup extends HttpApiGroup.make("organizations").add(HttpApiEndpoint.get("list", "/organizations", {
+  success: Schema17.Array(OrganizationMembership),
+  error: SelfErrors
+}), HttpApiEndpoint.post("create", "/organizations", {
+  payload: CreateOrganization,
+  success: OrganizationMembership,
+  error: WriteErrors
+}), HttpApiEndpoint.get("get", "/organizations/:organizationId", {
+  params: organizationParams,
+  success: OrganizationMembership,
+  error: ReadErrors
+}), HttpApiEndpoint.patch("update", "/organizations/:organizationId", {
+  params: organizationParams,
+  payload: UpdateOrganization,
+  success: Organization,
+  error: WriteErrors
+}), HttpApiEndpoint.delete("delete", "/organizations/:organizationId", {
+  params: organizationParams,
+  error: WriteErrors
+}), HttpApiEndpoint.get("getDeletion", "/organizations/:organizationId/deletion", {
+  params: organizationParams,
+  success: OrganizationDeletion,
+  error: ReadErrors
+})) {
+}
+
+class MembersGroup extends HttpApiGroup.make("members").add(HttpApiEndpoint.get("list", "/organizations/:organizationId/members", {
+  params: organizationParams,
+  success: Schema17.Array(Member),
+  error: ReadErrors
+}), HttpApiEndpoint.patch("updateRole", "/organizations/:organizationId/members/:memberId", {
+  params: { ...organizationParams, memberId: MemberId },
+  payload: UpdateMemberRole,
+  success: Member,
+  error: WriteErrors
+}), HttpApiEndpoint.delete("remove", "/organizations/:organizationId/members/:memberId", {
+  params: { ...organizationParams, memberId: MemberId },
+  error: WriteErrors
+})) {
+}
+
+class InvitationsGroup extends HttpApiGroup.make("invitations").add(HttpApiEndpoint.get("list", "/organizations/:organizationId/invitations", {
+  params: organizationParams,
+  success: Schema17.Array(Invitation),
+  error: ReadErrors
+}), HttpApiEndpoint.post("create", "/organizations/:organizationId/invitations", {
+  params: organizationParams,
+  payload: CreateInvitation,
+  success: Invitation,
+  error: WriteErrors
+}), HttpApiEndpoint.post("resend", "/organizations/:organizationId/invitations/:invitationId/resend", {
+  params: { ...organizationParams, invitationId: InvitationId },
+  success: Invitation,
+  error: WriteErrors
+}), HttpApiEndpoint.delete("cancel", "/organizations/:organizationId/invitations/:invitationId", {
+  params: { ...organizationParams, invitationId: InvitationId },
+  error: WriteErrors
+}), HttpApiEndpoint.get("preview", "/invitations/:invitationId", {
+  params: { invitationId: InvitationId },
+  success: InvitationPreview,
+  error: ReadErrors
+}), HttpApiEndpoint.post("accept", "/invitations/:invitationId/accept", {
+  params: { invitationId: InvitationId },
+  success: OrganizationMembership,
+  error: WriteErrors
+}), HttpApiEndpoint.post("decline", "/invitations/:invitationId/decline", {
+  params: { invitationId: InvitationId },
+  error: WriteErrors
+})) {
+}
+
+class ApiKeysGroup extends HttpApiGroup.make("apiKeys").add(HttpApiEndpoint.get("list", "/organizations/:organizationId/api-keys", {
+  params: organizationParams,
+  query: { projectId: Schema17.optional(ProjectId) },
+  success: Schema17.Array(ApiKey),
+  error: ReadErrors
+}), HttpApiEndpoint.post("create", "/organizations/:organizationId/api-keys", {
+  params: organizationParams,
+  payload: CreateApiKey,
+  success: CreatedApiKey,
+  error: WriteErrors
+}), HttpApiEndpoint.delete("revoke", "/organizations/:organizationId/api-keys/:keyId", {
+  params: { ...organizationParams, keyId: ApiKeyId },
+  error: WriteErrors
+})) {
+}
+
+// ../../packages/cloud-api/src/groups/billing.ts
+import { Schema as Schema18 } from "effect";
+import { HttpApiEndpoint as HttpApiEndpoint2, HttpApiGroup as HttpApiGroup2 } from "effect/http-api";
+var organizationParams2 = { organizationId: OrganizationId };
+
+class BillingGroup extends HttpApiGroup2.make("billing").add(HttpApiEndpoint2.get("listPlans", "/billing/plans", {
+  success: PlanCatalog,
+  error: SelfErrors
+}), HttpApiEndpoint2.get("get", "/organizations/:organizationId/billing", {
+  params: organizationParams2,
+  success: BillingSummary,
+  error: ReadErrors
+}), HttpApiEndpoint2.get("listInvoices", "/organizations/:organizationId/billing/invoices", {
+  params: organizationParams2,
+  success: Schema18.Array(Invoice),
+  error: ReadErrors
+}), HttpApiEndpoint2.put("setSpendLimit", "/organizations/:organizationId/billing/spend-limit", {
+  params: organizationParams2,
+  payload: SetSpendLimit,
+  success: SpendLimit,
+  error: WriteErrors
+}), HttpApiEndpoint2.post("startCheckout", "/organizations/:organizationId/billing/checkout", {
+  params: organizationParams2,
+  payload: StartCheckout,
+  success: HostedSession,
+  error: WriteErrors
+}), HttpApiEndpoint2.post("changePlan", "/organizations/:organizationId/billing/plan", {
+  params: organizationParams2,
+  payload: StartCheckout,
+  success: PlanChange,
+  error: WriteErrors
+}), HttpApiEndpoint2.post("openPortal", "/organizations/:organizationId/billing/portal", {
+  params: organizationParams2,
+  success: HostedSession,
+  error: WriteErrors
+})) {
+}
+
+class UsageGroup extends HttpApiGroup2.make("usage").add(HttpApiEndpoint2.get("get", "/organizations/:organizationId/usage", {
+  params: organizationParams2,
+  query: { period: Schema18.optional(BillingPeriod) },
+  success: Usage,
+  error: ReadErrors
+})) {
+}
+
+class AuditGroup extends HttpApiGroup2.make("audit").add(HttpApiEndpoint2.get("list", "/organizations/:organizationId/audit-log", {
+  params: organizationParams2,
+  query: {
+    ...pageQuery,
+    action: Schema18.optional(Schema18.String),
+    actorId: Schema18.optional(Schema18.String)
+  },
+  success: Page(AuditEntry),
+  error: ReadErrors
+})) {
+}
+
+// ../../packages/cloud-api/src/groups/deployments.ts
+import { Schema as Schema20 } from "effect";
+import { HttpApiEndpoint as HttpApiEndpoint3, HttpApiGroup as HttpApiGroup3, HttpApiSchema, OpenApi } from "effect/http-api";
+
+// ../../packages/cloud-api/src/logs.ts
+import { Schema as Schema19 } from "effect";
+var MAX_LOG_LINES = 200;
+var MAX_LOG_TEXT_BYTES = 4096;
+var MAX_LOG_WINDOW_SECONDS = 3600;
+var MAX_LOG_WAIT_SECONDS = 20;
+var LogCursor = Schema19.String.check(Schema19.isMinLength(1), Schema19.isMaxLength(2048));
+var LogLimit = Schema19.Int.check(Schema19.isBetween({ minimum: 1, maximum: MAX_LOG_LINES }));
+var LogWait = Schema19.Int.check(Schema19.isBetween({ minimum: 0, maximum: MAX_LOG_WAIT_SECONDS }));
+var logQuery = {
+  since: Schema19.optional(Timestamp),
+  limit: Schema19.optional(LogLimit),
+  cursor: Schema19.optional(LogCursor),
+  wait: Schema19.optional(LogWait)
+};
+var RunnerLogLine = Schema19.Struct({
+  id: Schema19.String.check(Schema19.isMinLength(1), Schema19.isMaxLength(512)),
+  deploymentId: DeploymentId,
+  runnerId: Schema19.String.check(Schema19.isMinLength(1), Schema19.isMaxLength(256)),
+  at: Timestamp,
+  stream: Schema19.Literals(["stdout", "stderr", "unknown"]),
+  text: Schema19.String.check(Schema19.makeFilter((text) => new TextEncoder().encode(text).byteLength <= MAX_LOG_TEXT_BYTES || "Log text exceeds the byte limit")),
+  clipped: Schema19.Boolean
+});
+var RunnerLogPage = Schema19.Struct({
+  lines: Schema19.Array(RunnerLogLine).check(Schema19.isMaxLength(MAX_LOG_LINES)),
+  cursor: LogCursor,
+  more: Schema19.Boolean
+});
+
+// ../../packages/cloud-api/src/groups/deployments.ts
+var projectParams = { projectId: ProjectId };
+var deploymentParams = { ...projectParams, deploymentId: DeploymentId };
+
+class DeploymentsGroup extends HttpApiGroup3.make("deployments").add(HttpApiEndpoint3.get("getEnvironmentLogs", "/projects/:projectId/environments/:environment/logs", {
+  params: { ...projectParams, environment: EnvironmentName },
+  query: logQuery,
+  success: RunnerLogPage,
+  error: ReadErrors
+}).annotate(OpenApi.Description, "Reads recent stdout/stderr from the environment's current deployment. Authorization is checked on every read, including resumed polls, and suspended organizations remain readable. Defaults: since five minutes ago, limit 100, wait 0. The server clamps since to the past hour through now, so network delay and client clock skew do not reject a window boundary; limit is 1–200 and wait is 0–20 seconds. A cursor, at most 2048 characters, resumes the same authorized resource and takes precedence over since. More means another page is immediately available: continue with the cursor and wait 0 until more is false, then follow with wait 20. A current-deployment change switches environment follow to the new deployment and resets its provider position, retaining the original bounded window. Provider retention is recent and best-effort, not an archive. No current deployment returns an empty page. Text is clipped at 4096 UTF-8 bytes; each line's clipped flag reports that independently of more."), HttpApiEndpoint3.get("getLogs", "/projects/:projectId/deployments/:deploymentId/logs", {
+  params: deploymentParams,
+  query: logQuery,
+  success: RunnerLogPage,
+  error: ReadErrors
+}).annotate(OpenApi.Description, "Reads only the authorized deployment's customer runner stdout/stderr, with the same bounds and cursor protocol as environment logs. A deployment from another project or organization is not visible. Runner identifiers come only from the deployment's stored runner records, never from the cursor or caller input."), HttpApiEndpoint3.get("list", "/projects/:projectId/deployments", {
+  params: projectParams,
+  query: {
+    ...pageQuery,
+    environment: Schema20.optional(EnvironmentName),
+    status: Schema20.optional(DeploymentStatus)
+  },
+  success: Page(DeploymentSummary),
+  error: ReadErrors
+}), HttpApiEndpoint3.post("create", "/projects/:projectId/deployments", {
+  params: projectParams,
+  payload: CreateDeployment,
+  success: DeploymentDetail,
+  error: WriteErrors
+}), HttpApiEndpoint3.post("uploadSource", "/projects/:projectId/sources", {
+  params: projectParams,
+  payload: Schema20.Uint8Array.pipe(HttpApiSchema.asUint8Array({ contentType: "application/gzip" })),
+  success: SourceArchive,
+  error: [...WriteErrors, PayloadTooLarge]
+}).annotate(OpenApi.Description, "Stores a gzip-compressed tar of a build context for the project and answers its digest, the SHA-256 of the bytes sent. Sending the same bytes again answers the same digest. A deployment created with `source` naming that digest is built from it by the control plane's builder. Access and the builder are checked before the body is read: a caller without write access answers 403 and a control plane without a builder 501 `NotImplemented`. A body over 64 MiB answers 413 `PayloadTooLarge`, before any byte is read when its `content-length` says so, and as soon as it passes the limit otherwise."), HttpApiEndpoint3.get("get", "/projects/:projectId/deployments/:deploymentId", {
+  params: deploymentParams,
+  success: DeploymentDetail,
+  error: ReadErrors
+}), HttpApiEndpoint3.post("recordBuild", "/projects/:projectId/deployments/:deploymentId/build", {
+  params: deploymentParams,
+  payload: RecordBuild,
+  success: DeploymentDetail,
+  error: WriteErrors
+}), HttpApiEndpoint3.post("failBuild", "/projects/:projectId/deployments/:deploymentId/build-failure", {
+  params: deploymentParams,
+  payload: FailBuild,
+  success: DeploymentDetail,
+  error: WriteErrors
+}), HttpApiEndpoint3.get("getBuildLog", "/projects/:projectId/deployments/:deploymentId/build-log", {
+  params: deploymentParams,
+  query: { after: Schema20.optional(NonNegativeInt) },
+  success: BuildLog,
+  error: ReadErrors
+}), HttpApiEndpoint3.post("rollback", "/projects/:projectId/deployments/:deploymentId/rollback", {
+  params: deploymentParams,
+  success: DeploymentDetail,
+  error: WriteErrors
+}).annotate(OpenApi.Description, "Rolls the environment back to the earlier deployment named by `deploymentId`. That deployment must have reached `live` before (status `live`, `drained` or `rolled-back`) and must not be the one live now; otherwise the answer is 409. The build is not repeated: a new deployment in the same environment redeploys that deployment's image and environment-variable snapshot, its `rolledBackFrom` is `deploymentId`, and its build and migrate steps are `skipped`. The new deployment starts `in-progress` and becomes `live` or `failed`. When it becomes `live`, the deployment that was live ends `rolled-back`; if it fails, that deployment stays `live`. The target keeps its own status. A second rollout in the environment while one is `in-progress` answers 409. The response is the new deployment."), HttpApiEndpoint3.post("redeploy", "/projects/:projectId/deployments/:deploymentId/redeploy", {
+  params: deploymentParams,
+  success: DeploymentDetail,
+  error: WriteErrors
+})) {
+}
+
+// ../../packages/cloud-api/src/groups/projects.ts
+import { Schema as Schema21 } from "effect";
+import { HttpApiEndpoint as HttpApiEndpoint4, HttpApiGroup as HttpApiGroup4 } from "effect/http-api";
+var projectParams2 = { projectId: ProjectId };
+var environmentParams = { ...projectParams2, environment: EnvironmentName };
+
+class ProjectsGroup extends HttpApiGroup4.make("projects").add(HttpApiEndpoint4.get("list", "/organizations/:organizationId/projects", {
+  params: { organizationId: OrganizationId },
+  success: Schema21.Array(Project),
+  error: ReadErrors
+}), HttpApiEndpoint4.post("create", "/organizations/:organizationId/projects", {
+  params: { organizationId: OrganizationId },
+  payload: CreateProject,
+  success: Project,
+  error: WriteErrors
+}), HttpApiEndpoint4.get("get", "/projects/:projectId", {
+  params: projectParams2,
+  success: Project,
+  error: ReadErrors
+}), HttpApiEndpoint4.patch("update", "/projects/:projectId", {
+  params: projectParams2,
+  payload: UpdateProject,
+  success: Project,
+  error: WriteErrors
+}), HttpApiEndpoint4.delete("delete", "/projects/:projectId", {
+  params: projectParams2,
+  error: WriteErrors
+}), HttpApiEndpoint4.get("listEnvironments", "/projects/:projectId/environments", {
+  params: projectParams2,
+  success: Schema21.Array(Environment),
+  error: ReadErrors
+}), HttpApiEndpoint4.post("createEnvironment", "/projects/:projectId/environments", {
+  params: projectParams2,
+  payload: CreateEnvironment,
+  success: Environment,
+  error: WriteErrors
+}), HttpApiEndpoint4.get("getEnvironment", "/projects/:projectId/environments/:environment", {
+  params: environmentParams,
+  success: Environment,
+  error: ReadErrors
+}), HttpApiEndpoint4.delete("deleteEnvironment", "/projects/:projectId/environments/:environment", {
+  params: environmentParams,
+  error: WriteErrors
+}), HttpApiEndpoint4.get("getEndpoints", "/projects/:projectId/environments/:environment/endpoints", {
+  params: environmentParams,
+  success: ProjectEndpoints,
+  error: ReadErrors
+})) {
+}
+
+class EnvironmentVariablesGroup extends HttpApiGroup4.make("environmentVariables").add(HttpApiEndpoint4.get("list", "/projects/:projectId/environments/:environment/variables", {
+  params: environmentParams,
+  success: Schema21.Array(EnvVariable),
+  error: ReadErrors
+}), HttpApiEndpoint4.put("set", "/projects/:projectId/environments/:environment/variables/:name", {
+  params: { ...environmentParams, name: EnvVariableName },
+  payload: SetEnvVariable,
+  success: EnvVariable,
+  error: WriteErrors
+}), HttpApiEndpoint4.delete("delete", "/projects/:projectId/environments/:environment/variables/:name", {
+  params: { ...environmentParams, name: EnvVariableName },
+  error: WriteErrors
+}), HttpApiEndpoint4.post("import", "/projects/:projectId/environments/:environment/variables/import", {
+  params: environmentParams,
+  payload: ImportEnvVariables,
+  success: ImportEnvVariablesResult,
+  error: WriteErrors
+})) {
+}
+
+class DomainsGroup extends HttpApiGroup4.make("domains").add(HttpApiEndpoint4.get("list", "/projects/:projectId/domains", {
+  params: projectParams2,
+  success: Schema21.Array(Domain),
+  error: ReadErrors
+}), HttpApiEndpoint4.post("add", "/projects/:projectId/domains", {
+  params: projectParams2,
+  payload: AddDomain,
+  success: Domain,
+  error: WriteErrors
+}), HttpApiEndpoint4.post("verify", "/projects/:projectId/domains/:domainId/verify", {
+  params: { ...projectParams2, domainId: DomainId },
+  success: Domain,
+  error: WriteErrors
+}), HttpApiEndpoint4.delete("remove", "/projects/:projectId/domains/:domainId", {
+  params: { ...projectParams2, domainId: DomainId },
+  error: WriteErrors
+})) {
+}
+
+class RegionsGroup extends HttpApiGroup4.make("regions").add(HttpApiEndpoint4.get("catalog", "/regions", {
+  success: Schema21.Array(Region),
+  error: ReadErrors
+}), HttpApiEndpoint4.get("list", "/projects/:projectId/environments/:environment/regions", {
+  params: environmentParams,
+  success: Schema21.Array(ProjectRegion),
+  error: ReadErrors
+}), HttpApiEndpoint4.post("add", "/projects/:projectId/regions", {
+  params: projectParams2,
+  payload: AddRegion,
+  success: Region,
+  error: WriteErrors
+}), HttpApiEndpoint4.delete("remove", "/projects/:projectId/regions/:region", {
+  params: { ...projectParams2, region: RegionId },
+  error: WriteErrors
+}), HttpApiEndpoint4.put("setHome", "/projects/:projectId/home-region", {
+  params: projectParams2,
+  payload: SetHomeRegion,
+  success: Project,
+  error: WriteErrors
+})) {
+}
+
+class IntegrationsGroup extends HttpApiGroup4.make("integrations").add(HttpApiEndpoint4.get("list", "/projects/:projectId/integrations", {
+  params: projectParams2,
+  success: Schema21.Array(Integration),
+  error: ReadErrors
+}), HttpApiEndpoint4.post("connect", "/projects/:projectId/integrations/:kind", {
+  params: { ...projectParams2, kind: IntegrationKind },
+  payload: ConnectIntegration,
+  success: IntegrationConnection,
+  error: WriteErrors
+}), HttpApiEndpoint4.delete("disconnect", "/projects/:projectId/integrations/:kind", {
+  params: { ...projectParams2, kind: IntegrationKind },
+  error: WriteErrors
+})) {
+}
+
+// ../../packages/cloud-api/src/groups/runtime.ts
+import { Schema as Schema22 } from "effect";
+import { HttpApiEndpoint as HttpApiEndpoint5, HttpApiGroup as HttpApiGroup5, HttpApiSchema as HttpApiSchema2, OpenApi as OpenApi2 } from "effect/http-api";
+var environmentParams2 = { projectId: ProjectId, environment: EnvironmentName };
+var actorTypeParams = { ...environmentParams2, actorType: Schema22.String };
+var actorParams = { ...actorTypeParams, key: Schema22.String };
+var InspectErrors = [...ReadErrors, RunnerDefect];
+
+class RuntimeGroup extends HttpApiGroup5.make("runtime").add(HttpApiEndpoint5.get("getOverview", "/projects/:projectId/environments/:environment/runtime/overview", {
+  params: environmentParams2,
+  success: Overview,
+  error: InspectErrors
+}), HttpApiEndpoint5.get("getSidebarCounts", "/projects/:projectId/environments/:environment/runtime/sidebar-counts", { params: environmentParams2, success: SidebarCounts, error: InspectErrors }), HttpApiEndpoint5.get("search", "/projects/:projectId/environments/:environment/runtime/search", {
+  params: environmentParams2,
+  query: { q: Schema22.String.pipe(Schema22.check(Schema22.isMinLength(1), Schema22.isMaxLength(256))) },
+  success: Schema22.Array(SearchResult),
+  error: InspectErrors
+}), HttpApiEndpoint5.get("listActorTypes", "/projects/:projectId/environments/:environment/runtime/actor-types", {
+  params: environmentParams2,
+  success: Schema22.Array(ActorTypeSummary),
+  error: InspectErrors
+}), HttpApiEndpoint5.get("getActorType", "/projects/:projectId/environments/:environment/runtime/actor-types/:actorType", { params: actorTypeParams, success: ActorTypeSummary, error: InspectErrors }), HttpApiEndpoint5.get("getActorTypeActivity", "/projects/:projectId/environments/:environment/runtime/actor-types/:actorType/activity", {
+  params: actorTypeParams,
+  query: { window: Schema22.optional(SeriesWindow) },
+  success: ActorTypeActivity,
+  error: InspectErrors
+}).annotate(OpenApi2.Description, "Commands per second over the window (default 24h) and the volume of each command, for one actor type, as the serving runner counted them since `since`. `NotImplemented` while more than one runner serves the environment."), HttpApiEndpoint5.get("getActorTypeLatency", "/projects/:projectId/environments/:environment/runtime/actor-types/:actorType/latency", {
+  params: actorTypeParams,
+  query: { window: Schema22.optional(SeriesWindow) },
+  success: TurnLatency,
+  error: InspectErrors
+}).annotate(OpenApi2.Description, "Turn-latency histogram over the window (default 24h) with p50, p95 and p99, for one actor type, as the serving runner measured them since `since`. `NotImplemented` while more than one runner serves the environment."), HttpApiEndpoint5.get("listActorInstances", "/projects/:projectId/environments/:environment/runtime/actor-types/:actorType/instances", {
+  params: actorTypeParams,
+  query: { ...pageQuery, status: Schema22.optional(Schema22.Literals(["awake", "idle"])) },
+  success: Page(ActorInstance),
+  error: InspectErrors
+}), HttpApiEndpoint5.get("inspectActor", "/projects/:projectId/environments/:environment/runtime/actors/:actorType/:key", { params: actorParams, success: ActorInspector, error: InspectErrors }), HttpApiEndpoint5.get("listActorTables", "/projects/:projectId/environments/:environment/runtime/actors/:actorType/:key/tables", { params: actorParams, success: Schema22.Array(OwnedTableRows), error: ReadErrors }), HttpApiEndpoint5.get("listActorReceipts", "/projects/:projectId/environments/:environment/runtime/actors/:actorType/:key/receipts", { params: actorParams, query: pageQuery, success: Page(Receipt), error: InspectErrors }), HttpApiEndpoint5.get("listActorEvents", "/projects/:projectId/environments/:environment/runtime/actors/:actorType/:key/events", { params: actorParams, success: Schema22.Array(ActorEvent), error: InspectErrors }), HttpApiEndpoint5.get("listActorJobs", "/projects/:projectId/environments/:environment/runtime/actors/:actorType/:key/jobs", { params: actorParams, success: Schema22.Array(ActorJob), error: InspectErrors }), HttpApiEndpoint5.get("listActorTimeline", "/projects/:projectId/environments/:environment/runtime/actors/:actorType/:key/timeline", {
+  params: actorParams,
+  query: pageQuery,
+  success: Page(ActorTimelineEntry),
+  error: InspectErrors
+}), HttpApiEndpoint5.get("listCommands", "/projects/:projectId/environments/:environment/runtime/commands", {
+  params: environmentParams2,
+  query: {
+    ...pageQuery,
+    actorType: Schema22.optional(Schema22.String),
+    outcome: Schema22.optional(CommandOutcome)
+  },
+  success: Page(CommandLogEntry),
+  error: InspectErrors
+}), HttpApiEndpoint5.post("sendCommand", "/projects/:projectId/environments/:environment/runtime/commands", {
+  params: environmentParams2,
+  payload: SendCommand,
+  success: CommandSent,
+  error: [
+    ...WriteErrors,
+    CommandFailed2,
+    CommandRefused,
+    CommandExpired,
+    RunnerDefect,
+    ...QuotaErrors
+  ]
+}).annotate(OpenApi2.Description, "Sends to an actor address, including one not yet created, without requiring an inspector read. Requires project write permission. `commandId` is an optional client idempotency key, not a runner command id. Its scope is organization/project/environment/actor address/command, independent of deployment. The control plane durably assigns a runner-minted id and stores only a canonical payload hash; the same key and JSON input reuse it and replay the receipt with `replayed: true` within the runner's retry window. Different input returns 409 Conflict. After expiry, the key is retained as a tombstone for 30 days and returns 410 `CommandExpired`; reusing it after that starts a new command. Declared actor errors are 422 CommandFailed; admission refusals are typed 4xx, including 422 CommandRefused. Mailbox backpressure remains 503 Unavailable. Remote defects are opaque, non-retryable 502 RunnerDefect errors. The edge's usage refusals keep the framework's tags and payloads: a full Free command quota is a 429 `QuotaExceeded`, a passed spend limit a 402 `SpendLimitExceeded`, a full connection allowance a 429 `ConnectionLimitExceeded` and a Free tenant at its storage cap a 429 `StorageQuotaExceeded`. A command the edge cannot bill, because the tenant has no organization, the organization no billing account, or its plan is not in the pricing configuration, is a 402 `QuotaUnbound` carrying that reason, never a generic 503."), HttpApiEndpoint5.get("streamCommands", "/projects/:projectId/environments/:environment/runtime/commands/stream", {
+  params: environmentParams2,
+  query: {
+    actorType: Schema22.optional(Schema22.String),
+    outcome: Schema22.optional(CommandOutcome)
+  },
+  success: HttpApiSchema2.StreamSse({
+    data: Schema22.toCodecJson(CommandLogEntry),
+    error: CommandStreamGap
+  }),
+  error: InspectErrors
+}).annotate(OpenApi2.Description, "Each command the serving runner commits from now on, filtered by actor type and outcome (`replayed` is always empty, since a replay commits no turn), with a payload preview of at most 256 characters that the runner cut and redacted. The control plane resumes across the runner's credential expiry; the stream fails with `CommandStreamGap` when the runner can no longer resume it without missing commands, and ends when the runner goes away; a client reconnects. `NotImplemented` while more than one runner serves the environment."), HttpApiEndpoint5.get("getJobs", "/projects/:projectId/environments/:environment/runtime/jobs", {
+  params: environmentParams2,
+  success: JobsSummary,
+  error: InspectErrors
+}), HttpApiEndpoint5.get("listDeadLetters", "/projects/:projectId/environments/:environment/runtime/dead-letters", {
+  params: environmentParams2,
+  query: pageQuery,
+  success: Page(DeadLetter),
+  error: InspectErrors
+}), HttpApiEndpoint5.post("retryDeadLetter", "/projects/:projectId/environments/:environment/runtime/dead-letters/:deadLetterId/retry", {
+  params: { ...environmentParams2, deadLetterId: DeadLetterId },
+  error: WriteErrors
+}), HttpApiEndpoint5.post("discardDeadLetter", "/projects/:projectId/environments/:environment/runtime/dead-letters/:deadLetterId/discard", {
+  params: { ...environmentParams2, deadLetterId: DeadLetterId },
+  error: WriteErrors
+}), HttpApiEndpoint5.get("listWorkflows", "/projects/:projectId/environments/:environment/runtime/workflows", {
+  params: environmentParams2,
+  query: {
+    ...pageQuery,
+    status: Schema22.optional(Schema22.Literals(["running", "waiting", "completed", "failed"]))
+  },
+  success: Page(Workflow),
+  error: InspectErrors
+}), HttpApiEndpoint5.get("getTimers", "/projects/:projectId/environments/:environment/runtime/timers", {
+  params: environmentParams2,
+  success: TimersSummary,
+  error: InspectErrors
+}), HttpApiEndpoint5.get("listSchedules", "/projects/:projectId/environments/:environment/runtime/schedules", {
+  params: environmentParams2,
+  success: Schema22.Array(Schedule),
+  error: InspectErrors
+}), HttpApiEndpoint5.get("getConnections", "/projects/:projectId/environments/:environment/runtime/connections", { params: environmentParams2, success: ConnectionsSummary, error: InspectErrors })) {
+}
+
+// ../../packages/cloud-api/src/contract.ts
+class CloudApi extends HttpApi.make("akter-cloud").add(AccountGroup, OrganizationsGroup, MembersGroup, InvitationsGroup, ApiKeysGroup, ProjectsGroup, EnvironmentVariablesGroup, DomainsGroup, RegionsGroup, IntegrationsGroup, DeploymentsGroup, RuntimeGroup, BillingGroup, UsageGroup, AuditGroup).middleware(Authentication).prefix("/api").annotateMerge(OpenApi3.annotations({ title: "Akter Cloud API" })) {
+}
+// src/commands/cloud/deploy.ts
+import { Clock as Clock3, Config as Config3, Console as Console9, Duration as Duration3, Effect as Effect16, Option as Option8, Schema as Schema26, Stream } from "effect";
+import { Command as Command13, Flag as Flag12 } from "effect/cli";
+import { ChildProcess, ChildProcessSpawner } from "effect/process";
+
+// src/commands/cloud/archive.ts
+import { Effect as Effect13, FileSystem as FileSystem3, Option as Option6, Schema as Schema23 } from "effect";
+import { gzipSync } from "node:zlib";
+
+class ContextInvalid extends Schema23.TaggedError()("ContextInvalid", {
+  message: Schema23.String
+}) {
+}
+var compile = (pattern) => {
+  let source = "^";
+  for (let index = 0;index < pattern.length; index++) {
+    const char = pattern[index];
+    if (char === "*" && pattern[index + 1] === "*") {
+      index++;
+      if (pattern[index + 1] === "/")
+        index++;
+      source += index + 1 >= pattern.length ? ".*" : "(.*/)?";
+    } else if (char === "*")
+      source += "[^/]*";
+    else if (char === "?")
+      source += "[^/]";
+    else if (char === "\\" && index + 1 < pattern.length) {
+      index++;
+      source += `\\${pattern[index]}`;
+    } else if (".+()|{}^$".includes(char))
+      source += `\\${char}`;
+    else
+      source += char;
+  }
+  return new RegExp(`${source}$`, "u");
+};
+var ignoreRules = (text) => text.split(/\r?\n/u).map((line) => line.trim()).filter((line) => line !== "" && !line.startsWith("#")).flatMap((line) => {
+  const exception = line.startsWith("!");
+  const body = exception ? line.slice(1) : line;
+  const directory = body.endsWith("/");
+  const trimmed = body.replace(/\/+$/u, "");
+  const pattern = trimmed.replace(/^\//u, "");
+  if (pattern === "")
+    return [];
+  return [
+    {
+      exception,
+      directory,
+      pattern: compile(trimmed.includes("/") ? pattern : `**/${pattern}`)
+    }
+  ];
+});
+var isIgnored = (rules) => (path, directory) => {
+  const segments = path.split("/");
+  return segments.some((_, index) => {
+    const prefix = segments.slice(0, index + 1).join("/");
+    const isDirectory = index < segments.length - 1 || directory;
+    return rules.reduce((ignored, rule) => (!rule.directory || isDirectory) && rule.pattern.test(prefix) ? !rule.exception : ignored, false);
+  });
+};
+var BLOCK = 512;
+var encoder = new TextEncoder;
+var octal = (value, width) => `${value.toString(8).padStart(width - 1, "0")}\x00`;
+var headers = (entry) => {
+  const fits = (value) => encoder.encode(value).byteLength <= 100 && /^[\x20-\x7e]*$/u.test(value);
+  const extended = entry.type !== "x" && (!fits(entry.path) || !fits(entry.target)) ? pax([
+    ["path", entry.path],
+    ["linkpath", entry.target]
+  ].filter(([, value]) => value !== "")) : [];
+  const header = new Uint8Array(BLOCK);
+  const put = (offset, value) => header.set(encoder.encode(value).subarray(0, value.length), offset);
+  put(0, extended.length > 0 ? entry.path.slice(0, 99).replace(/[^\x20-\x7e]/gu, "_") : entry.path);
+  put(100, octal(entry.mode, 8));
+  put(108, octal(0, 8));
+  put(116, octal(0, 8));
+  put(124, octal(entry.size, 12));
+  put(136, octal(0, 12));
+  put(148, "        ");
+  put(156, entry.type);
+  put(157, extended.length > 0 ? "" : entry.target);
+  put(257, "ustar\x00");
+  put(263, "00");
+  put(148, `${header.reduce((sum, byte) => sum + byte, 0).toString(8).padStart(6, "0")}\x00 `);
+  return [...extended, header];
+};
+var pax = (records) => {
+  const body = encoder.encode(records.map(([key, value]) => {
+    const line = ` ${key}=${value}
+`;
+    const size = encoder.encode(line).byteLength;
+    let digits = 1;
+    while (String(size + digits).length !== digits)
+      digits += 1;
+    return `${size + digits}${line}`;
+  }).join(""));
+  return [
+    ...headers({
+      path: "././@PaxHeader",
+      mode: 420,
+      size: body.byteLength,
+      type: "x",
+      target: ""
+    }),
+    padded(body)
+  ];
+};
+var padded = (bytes) => {
+  const block = new Uint8Array(Math.ceil(bytes.byteLength / BLOCK) * BLOCK);
+  block.set(bytes);
+  return block;
+};
+var tar = (entries) => {
+  const blocks = entries.flatMap((entry) => ("target" in entry) ? headers({ path: entry.path, mode: 511, size: 0, type: "2", target: entry.target }) : [
+    ...headers({
+      path: entry.path,
+      mode: entry.mode,
+      size: entry.bytes.byteLength,
+      type: "0",
+      target: ""
+    }),
+    padded(entry.bytes)
+  ]);
+  const bytes = new Uint8Array(blocks.reduce((size, block) => size + block.byteLength, 0) + 2 * BLOCK);
+  let offset = 0;
+  for (const block of blocks) {
+    bytes.set(block, offset);
+    offset += block.byteLength;
+  }
+  return gzipSync(bytes);
+};
+var GIT_DIRECTORY = ignoreRules(".git");
+var packContext = (input) => Effect13.gen(function* () {
+  const fs = yield* FileSystem3.FileSystem;
+  const root = input.context.replace(/[\\/]+$/u, "");
+  let rules = [];
+  for (const candidate of [".akterignore", ".gitignore"])
+    if (yield* fs.exists(`${root}/${candidate}`)) {
+      rules = ignoreRules(yield* fs.readFileString(`${root}/${candidate}`));
+      break;
+    }
+  const ignored = isIgnored([...rules, ...GIT_DIRECTORY]);
+  const entries = [];
+  const walk = (directory) => Effect13.gen(function* () {
+    const names = (yield* fs.readDirectory(directory === "" ? root : `${root}/${directory}`)).toSorted();
+    for (const name of names) {
+      const path = directory === "" ? name : `${directory}/${name}`;
+      const link = yield* Effect13.option(fs.readLink(`${root}/${path}`));
+      if (Option6.isSome(link)) {
+        if (!ignored(path, false))
+          entries.push({ path, target: link.value });
+        continue;
+      }
+      const info = yield* fs.stat(`${root}/${path}`);
+      if (info.type === "Directory") {
+        if (!ignored(path, true))
+          yield* walk(path);
+      } else if (info.type === "File" && !ignored(path, false))
+        entries.push({
+          path,
+          mode: info.mode & 511,
+          bytes: yield* fs.readFile(`${root}/${path}`)
+        });
+    }
+  }).pipe(Effect13.catchTag("PlatformError", (error) => Effect13.fail(ContextInvalid.make({ message: `Cannot read ${root}/${directory}: ${error.message}` }))));
+  yield* walk("");
+  return { archive: tar(entries), files: entries.map((entry) => entry.path) };
+});
+
+// src/commands/cloud/client.ts
+import { Console as Console8, Duration as Duration2, Effect as Effect15, Match, Schema as Schema25 } from "effect";
+import { HttpClient as HttpClient2, HttpClientRequest as HttpClientRequest2 } from "effect/http";
+import { HttpApiClient } from "effect/http-api";
+
+// src/commands/cloud/credentials.ts
+import { homedir } from "node:os";
+import { Config as Config2, Crypto, Effect as Effect14, FileSystem as FileSystem4, Option as Option7, Schema as Schema24 } from "effect";
+var isLoopback = (hostname) => hostname === "localhost" || hostname.endsWith(".localhost") || hostname === "[::1]" || /^127(?:\.\d{1,3}){3}$/u.test(hostname);
+var controlPlaneUrl = (input) => {
+  const url = URL.parse(input);
+  if (url === null || url.username !== "" || url.password !== "" || url.search !== "")
+    return Option7.none();
+  if (url.protocol !== "https:" && !(url.protocol === "http:" && isLoopback(url.hostname)))
+    return Option7.none();
+  return Option7.some(`${url.origin}${url.pathname}`.replace(/\/+$/u, ""));
+};
+var Credentials = Schema24.Struct({
+  apiUrl: Schema24.String.check(Schema24.makeFilter((url) => Option7.isSome(controlPlaneUrl(url)) || "An https URL, or http on a loopback host")),
+  token: Schema24.String,
+  email: Schema24.String
+});
+
+class NotLoggedIn extends Schema24.TaggedError()("NotLoggedIn", {
+  path: Schema24.String
+}) {
+}
+
+class CredentialsExposed extends Schema24.TaggedError()("CredentialsExposed", { path: Schema24.String, mode: Schema24.Int }) {
+}
+
+class CredentialsUnreadable extends Schema24.TaggedError()("CredentialsUnreadable", { path: Schema24.String }) {
+}
+var configDirectory = (location) => {
+  if (location.override !== undefined && location.override !== "")
+    return location.override;
+  if (location.platform === "darwin")
+    return `${location.home}/Library/Application Support/akter`;
+  if (location.platform === "win32")
+    return `${location.appData ?? `${location.home}\\AppData\\Roaming`}\\akter`;
+  return `${location.xdgConfigHome === undefined || location.xdgConfigHome === "" ? `${location.home}/.config` : location.xdgConfigHome}/akter`;
+};
+var optional = (name) => Config2.option(Config2.String(name)).pipe(Effect14.map(Option7.getOrUndefined));
+var credentialsPath = Effect14.gen(function* () {
+  const platform = process.platform;
+  const directory = configDirectory({
+    platform,
+    home: homedir(),
+    override: yield* optional("AKTER_CONFIG_DIR"),
+    xdgConfigHome: yield* optional("XDG_CONFIG_HOME"),
+    appData: yield* optional("APPDATA")
+  });
+  return { directory, file: `${directory}${platform === "win32" ? "\\" : "/"}credentials.json` };
+});
+var encode = Schema24.encodeEffect(Schema24.fromJsonString(Credentials));
+var decode = Schema24.decodeUnknownEffect(Schema24.fromJsonString(Credentials));
+var saveCredentials = (credentials) => Effect14.gen(function* () {
+  const fs = yield* FileSystem4.FileSystem;
+  const { directory, file } = yield* credentialsPath;
+  const suffix = yield* (yield* Crypto.Crypto).randomUUIDv4.pipe(Effect14.orDie);
+  const pending = `${file}.${suffix}.tmp`;
+  yield* fs.makeDirectory(directory, { recursive: true, mode: 448 });
+  yield* fs.chmod(directory, 448);
+  yield* Effect14.gen(function* () {
+    yield* fs.writeFileString(pending, yield* encode(credentials).pipe(Effect14.orDie), {
+      flag: "wx",
+      mode: 384
+    });
+    yield* fs.chmod(pending, 384);
+    yield* fs.rename(pending, file);
+  }).pipe(Effect14.onError(() => fs.remove(pending, { force: true }).pipe(Effect14.ignore)));
+  return file;
+});
+var readCredentials = Effect14.gen(function* () {
+  const fs = yield* FileSystem4.FileSystem;
+  const { file } = yield* credentialsPath;
+  if (!(yield* fs.exists(file)))
+    return yield* NotLoggedIn.make({ path: file });
+  const mode = (yield* fs.stat(file)).mode & 511;
+  const credentials = yield* fs.readFileString(file).pipe(Effect14.flatMap(decode), Effect14.mapError(() => CredentialsUnreadable.make({ path: file })));
+  return { credentials, file, mode };
+});
+var loadCredentials = Effect14.gen(function* () {
+  const { credentials, file, mode } = yield* readCredentials;
+  if (process.platform !== "win32" && (mode & 63) !== 0)
+    return yield* CredentialsExposed.make({ path: file, mode });
+  return credentials;
+});
+var loadCredentialsToRevoke = Effect14.map(readCredentials, (read) => read.credentials);
+var removeCredentials = Effect14.gen(function* () {
+  const fs = yield* FileSystem4.FileSystem;
+  const { file } = yield* credentialsPath;
+  if (!(yield* fs.exists(file)))
+    return false;
+  yield* fs.remove(file);
+  return true;
+});
+
+// src/commands/cloud/client.ts
+var DEFAULT_API_URL = "https://api.akter.dev";
+var cloudClient = (credentials) => HttpApiClient.make(CloudApi, {
+  baseUrl: credentials.apiUrl,
+  transformClient: HttpClient2.mapRequest(HttpClientRequest2.bearerToken(credentials.token))
+});
+var signedIn = Effect15.gen(function* () {
+  const credentials = yield* loadCredentials;
+  return { credentials, client: yield* cloudClient(credentials) };
+});
+var MAX_READ_RETRIES = 5;
+var readRetryDelay = (attempt) => Duration2.seconds(Math.min(2 ** (attempt - 1), 8));
+var isTransient = (error) => Match.value(error).pipe(Match.tag("Unavailable", (unavailable) => unavailable.reason === undefined), Match.tag("HttpClientError", ({ reason }) => Match.value(reason).pipe(Match.tag("TransportError", () => true), Match.tag("StatusCodeError", "DecodeError", "EmptyBodyError", ({ response }) => response.status >= 500), Match.orElse(() => false))), Match.orElse(() => false));
+var retryTransient = (notice) => {
+  let failures = 0;
+  const read = (effect) => effect.pipe(Effect15.tap(() => Effect15.sync(() => {
+    failures = 0;
+  })), Effect15.catchIf((error) => failures < MAX_READ_RETRIES && isTransient(error), () => Effect15.gen(function* () {
+    failures += 1;
+    yield* Console8.error(notice);
+    yield* Effect15.sleep(readRetryDelay(failures));
+    return yield* read(effect);
+  })));
+  return read;
+};
+var octal2 = (mode) => mode.toString(8).padStart(3, "0");
+var describe = Match.type().pipe(Match.tagsExhaustive({
+  NotLoggedIn: () => ({
+    reason: "NotLoggedIn",
+    message: "Not logged in. Run `akter login` first.",
+    exitCode: 2
+  }),
+  CredentialsExposed: (error) => ({
+    reason: "CredentialsExposed",
+    message: `${error.path} can be read by other users (mode ${octal2(error.mode)}). Run \`chmod 600\` on it or \`akter login\` again.`,
+    exitCode: 2
+  }),
+  CredentialsUnreadable: (error) => ({
+    reason: "CredentialsUnreadable",
+    message: `${error.path} does not hold akter credentials. Run \`akter login\` again.`,
+    exitCode: 2
+  }),
+  Unauthorized: () => ({
+    reason: "Unauthorized",
+    message: "Your session has expired or was revoked. Run `akter login` to sign in again.",
+    exitCode: 1
+  }),
+  Forbidden: (error) => ({
+    reason: "Forbidden",
+    message: `Refused: ${error.message}`,
+    exitCode: 1
+  }),
+  NotFound: (error) => ({
+    reason: "NotFound",
+    message: `No ${error.resource} ${error.id} is visible to you.`,
+    exitCode: 1
+  }),
+  Conflict: (error) => ({
+    reason: "Conflict",
+    message: `Refused: ${error.message}`,
+    exitCode: 1
+  }),
+  NotImplemented: (error) => ({
+    reason: "NotImplemented",
+    message: `This control plane does not support ${error.operation}.`,
+    exitCode: 1
+  }),
+  PayloadTooLarge: (error) => ({
+    reason: "PayloadTooLarge",
+    message: `The control plane accepts at most ${error.limitBytes} bytes; exclude more files in .dockerignore.`,
+    exitCode: 1
+  }),
+  Unavailable: () => ({
+    reason: "Unavailable",
+    message: "The control plane is temporarily unavailable. Try again shortly.",
+    exitCode: 1
+  }),
+  HttpClientError: (error) => ({
+    reason: "Unreachable",
+    message: `Cannot reach the control plane: ${error.message}`,
+    exitCode: 2
+  }),
+  SchemaError: (error) => ({
+    reason: "SchemaError",
+    message: `The control plane's answer was not understood: ${error.message}`,
+    exitCode: 2
+  }),
+  PlatformError: (error) => ({
+    reason: "PlatformError",
+    message: `Cannot use the file system: ${error.message}`,
+    exitCode: 2
+  }),
+  ConfigError: (error) => ({
+    reason: "ConfigError",
+    message: `Cannot read the environment: ${error.message}`,
+    exitCode: 2
+  })
+}));
+var reportFailures = (effect) => Effect15.catchIf(effect, (error) => !Schema25.is(CommandFailed)(error), (error) => fail(describe(error)));
+
+// src/commands/cloud/deploy.ts
+class DeploymentFailed extends Schema26.TaggedError()("DeploymentFailed", {
+  deploymentId: Schema26.String,
+  step: Schema26.String,
+  detail: Schema26.String
+}) {
+}
+
+class DeploymentTimedOut extends Schema26.TaggedError()("DeploymentTimedOut", { deploymentId: Schema26.String, seconds: Schema26.Int }) {
+}
+var flags9 = {
+  project: Flag12.String("project").pipe(Flag12.withFallbackConfig(Config3.String("AKTER_PROJECT")), Flag12.withSchema(ProjectId), Flag12.withDescription("The project to deploy to (default AKTER_PROJECT)")),
+  environment: Flag12.Literals("env", EnvironmentName.literals).pipe(Flag12.withDefault("production"), Flag12.withDescription("The environment to deploy to (default production)")),
+  context: Flag12.Directory("context", { mustExist: true }).pipe(Flag12.withDefault("."), Flag12.withDescription(`The app directory to upload, holding ${SOURCE_ENTRY} (default the current directory)`)),
+  commit: Flag12.String("commit").pipe(Flag12.optional, Flag12.withDescription("The commit SHA the deployment is labeled with (default the context's git HEAD)")),
+  message: Flag12.String("message").pipe(Flag12.optional, Flag12.withDescription("The deployment's message (default the commit's subject)")),
+  timeout: Flag12.Int("timeout").pipe(Flag12.withDefault(900), Flag12.withDescription("Seconds to follow the rollout before giving up on it (default 900)"))
+};
+var git = (directory, args) => Effect16.gen(function* () {
+  const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+  const handle = yield* spawner.spawn(ChildProcess.make("git", ["-C", directory, ...args]));
+  const [out] = yield* Effect16.all([handle.stdout.pipe(Stream.decodeText, Stream.mkString), handle.stderr.pipe(Stream.runDrain)], { concurrency: 2 });
+  return Number(yield* handle.exitCode) === 0 ? out.trim() : undefined;
+}).pipe(Effect16.scoped, Effect16.orElseSucceed(() => {
+  return;
+}));
+var label = Effect16.fnUntraced(function* (input) {
+  const head = yield* git(input.context, ["rev-parse", "HEAD"]);
+  const commitSha = input.commit ?? head ?? input.digest.slice("sha256:".length, 47);
+  if (input.message !== undefined)
+    return { commitSha, message: input.message };
+  if (input.commit !== undefined || head === undefined)
+    return { commitSha, message: "" };
+  const subject = (yield* git(input.context, ["log", "-1", "--format=%s"])) ?? "";
+  const dirty = ((yield* git(input.context, ["status", "--porcelain"])) ?? "") !== "";
+  return { commitSha, message: dirty ? `${subject} (with uncommitted changes)` : subject };
+});
+var seconds = (durationMs) => durationMs === null ? "" : ` in ${(durationMs / 1000).toFixed(1)}s`;
+var follow = Effect16.fnUntraced(function* (input) {
+  const params = { projectId: input.projectId, deploymentId: input.deployment.id };
+  const deadline = (yield* Clock3.currentTimeMillis) + input.timeoutSeconds * 1000;
+  const printed = new Map;
+  let detail = input.deployment;
+  let cursor = 0;
+  let following = false;
+  let logComplete = false;
+  const read = retryTransient("The control plane is unavailable; still following the deployment.");
+  const printLog = Effect16.gen(function* () {
+    const log = yield* read(input.client.deployments.getBuildLog({ params, query: { after: cursor } }));
+    const last = log.lines.at(-1);
+    for (const line of log.lines)
+      yield* Console9.log(`    ${line.text}`);
+    if (last !== undefined)
+      cursor = last.index + 1;
+    following = true;
+    logComplete = log.complete;
+  });
+  while (true) {
+    for (const step of detail.steps) {
+      if (step.status === "pending" || printed.get(step.name) === step.status)
+        continue;
+      if (step.name === "build" && step.status === "succeeded" && following && !logComplete)
+        yield* printLog;
+      printed.set(step.name, step.status);
+      yield* Console9.log(`  ${step.name} ${step.status}${step.status === "running" ? "" : seconds(step.durationMs)}`);
+    }
+    if (!logComplete && detail.steps.some((step) => step.name === "build" && step.status === "running"))
+      yield* printLog;
+    if (detail.status === "live")
+      return detail;
+    if (detail.status === "failed") {
+      const failed = detail.steps.find((step) => step.status === "failed");
+      if (failed?.name === "build") {
+        const log = yield* read(input.client.deployments.getBuildLog({ params, query: {} }));
+        for (const line of log.lines.slice(-20))
+          yield* Console9.error(`    ${line.text}`);
+      }
+      return yield* DeploymentFailed.make({
+        deploymentId: detail.id,
+        step: failed?.name ?? "rollout",
+        detail: failed?.detail ?? "no reason was recorded"
+      });
+    }
+    if ((yield* Clock3.currentTimeMillis) >= deadline)
+      return yield* DeploymentTimedOut.make({
+        deploymentId: detail.id,
+        seconds: input.timeoutSeconds
+      });
+    yield* Effect16.sleep(Duration3.seconds(1));
+    detail = yield* read(input.client.deployments.get({ params }));
+  }
+});
+var deployCommand = Command13.make("deploy", flags9, (options) => Effect16.gen(function* () {
+  const { client, credentials } = yield* signedIn;
+  const packed = yield* packContext({ context: options.context });
+  if (!packed.files.includes(SOURCE_ENTRY))
+    return yield* ContextInvalid.make({
+      message: `No ${SOURCE_ENTRY} in ${options.context}, or its .akterignore or .gitignore leaves it out; the platform serves the App that file exports by default`
+    });
+  if (packed.archive.byteLength > MAX_SOURCE_BYTES)
+    return yield* fail({
+      reason: "ContextTooLarge",
+      message: `The app directory is ${packed.archive.byteLength} bytes compressed; the control plane accepts at most ${MAX_SOURCE_BYTES}. Exclude more files in .akterignore.`
+    });
+  yield* Console9.log(`Uploading ${packed.files.length} files (${packed.archive.byteLength} bytes) from ${options.context} to ${credentials.apiUrl}`);
+  const source = yield* client.deployments.uploadSource({
+    params: { projectId: options.project },
+    payload: packed.archive
+  });
+  const { commitSha, message } = yield* label({
+    context: options.context,
+    digest: source.digest,
+    commit: Option8.getOrUndefined(options.commit),
+    message: Option8.getOrUndefined(options.message)
+  });
+  const deployment = yield* client.deployments.create({
+    params: { projectId: options.project },
+    payload: {
+      environment: options.environment,
+      commitSha,
+      message,
+      source: { digest: source.digest }
+    }
+  });
+  yield* Console9.log(`Deployment ${deployment.id} of ${commitSha.slice(0, 7)} to ${options.environment} started`);
+  const live = yield* follow({
+    client,
+    projectId: options.project,
+    deployment,
+    timeoutSeconds: options.timeout
+  });
+  yield* Console9.log(`Deployment ${live.id} is live in ${options.environment}`);
+  const report = yield* retryTransient("The control plane is unavailable; retrying the database report.")(client.projects.getEnvironment({
+    params: { projectId: options.project, environment: options.environment }
+  })).pipe(Effect16.catch(() => Console9.error("Warning: could not read the database report; the deployment is already live.").pipe(Effect16.as(undefined))));
+  if (report === undefined)
+    return;
+  if (report.currentDeploymentId !== live.id)
+    return yield* Console9.error("Warning: the database report is not for this deployment; skipping its diagnostics.");
+  const { database } = report;
+  if (database !== undefined) {
+    if (database.latencyWarning)
+      yield* Console9.error(`Warning: database p50 latency${database.latency === null ? "" : ` (${database.latency} ms)`} exceeds 5 ms from the runner region; deployment is not refused.`);
+    if (database.runnerCap !== null)
+      yield* Console9.log(`Database runner cap: ${database.runnerCap}`);
+  }
+}).pipe(Effect16.catchTags({
+  ContextInvalid: (error) => fail({ reason: "ContextInvalid", message: error.message }),
+  DeploymentFailed: (error) => fail({
+    reason: "DeploymentFailed",
+    message: `Deployment ${error.deploymentId} failed at ${error.step}: ${error.detail}. The previous deployment, if any, is still serving.`,
+    exitCode: 1
+  }),
+  DeploymentTimedOut: (error) => fail({
+    reason: "DeploymentTimedOut",
+    message: `Deployment ${error.deploymentId} was still rolling out after ${error.seconds}s; it continues on the control plane.`,
+    exitCode: 1
+  })
+}), reportFailures)).pipe(Command13.withDescription("Upload the app directory, build and roll it out on Akter Cloud, and follow it until it is live"));
+
+// src/commands/cloud/login.ts
+import { Clock as Clock4, Config as Config4, Console as Console10, Data, Duration as Duration4, Effect as Effect17, Schema as Schema27 } from "effect";
+import { Command as Command14, Flag as Flag13 } from "effect/cli";
+import { HttpClient as HttpClient3, HttpClientRequest as HttpClientRequest3, HttpClientResponse } from "effect/http";
+var CLIENT_ID = "akter-cli";
+var DEVICE_GRANT = "urn:ietf:params:oauth:grant-type:device_code";
+var DeviceCode = Schema27.Struct({
+  device_code: Schema27.String,
+  user_code: Schema27.String,
+  verification_uri: Schema27.String,
+  expires_in: Schema27.Finite,
+  interval: Schema27.Finite
+});
+var DeviceToken = Schema27.Struct({ access_token: Schema27.String });
+var DeviceError = Schema27.Struct({ error: Schema27.String });
+var displayCode = (code) => code.length === 8 ? `${code.slice(0, 4)}-${code.slice(4)}` : code;
+
+class LoginDenied extends Schema27.TaggedError()("LoginDenied", {}) {
+}
+
+class LoginExpired extends Schema27.TaggedError()("LoginExpired", {}) {
+}
+
+class LoginRefused extends Schema27.TaggedError()("LoginRefused", {
+  status: Schema27.Int,
+  error: Schema27.String
+}) {
+}
+var Poll = Data.taggedEnum();
+var flags10 = {
+  apiUrl: Flag13.String("api-url").pipe(Flag13.withFallbackConfig(Config4.String("AKTER_API_URL")), Flag13.withDefault(DEFAULT_API_URL), Flag13.filterMap(controlPlaneUrl, () => "an https URL, or http on a loopback host"), Flag13.withDescription(`The control plane to sign in to (default AKTER_API_URL, then ${DEFAULT_API_URL})`))
+};
+var post = (url, body) => Effect17.flatMap(HttpClient3.HttpClient, (client) => client.execute(HttpClientRequest3.bodyJsonUnsafe(HttpClientRequest3.post(url), body)));
+var refusal = (response) => HttpClientResponse.schemaBodyJson(DeviceError)(response).pipe(Effect17.orElseSucceed(() => ({ error: `HTTP ${response.status}` })));
+var deviceLogin = (apiUrl) => Effect17.gen(function* () {
+  const started = yield* post(`${apiUrl}/auth/device/code`, { client_id: CLIENT_ID });
+  if (started.status !== 200) {
+    const { error } = yield* refusal(started);
+    return yield* LoginRefused.make({ status: started.status, error });
+  }
+  const code = yield* HttpClientResponse.schemaBodyJson(DeviceCode)(started);
+  yield* Console10.log(`To sign in, open ${code.verification_uri}
+and enter the code ${displayCode(code.user_code)}. Waiting for approval…`);
+  const poll = Effect17.gen(function* () {
+    const response = yield* post(`${apiUrl}/auth/device/token`, {
+      grant_type: DEVICE_GRANT,
+      device_code: code.device_code,
+      client_id: CLIENT_ID
+    });
+    if (response.status === 200)
+      return Poll.Granted({
+        token: (yield* HttpClientResponse.schemaBodyJson(DeviceToken)(response)).access_token
+      });
+    const { error } = yield* refusal(response);
+    if (error === "authorization_pending")
+      return Poll.Pending();
+    if (error === "slow_down")
+      return Poll.SlowDown();
+    if (error === "access_denied")
+      return yield* LoginDenied.make({});
+    if (error === "expired_token")
+      return yield* LoginExpired.make({});
+    return yield* LoginRefused.make({ status: response.status, error });
+  });
+  const deadline = (yield* Clock4.currentTimeMillis) + code.expires_in * 1000;
+  let interval = Duration4.seconds(code.interval);
+  while ((yield* Clock4.currentTimeMillis) < deadline) {
+    yield* Effect17.sleep(interval);
+    const answer = yield* poll;
+    if (Poll.$is("Granted")(answer))
+      return answer.token;
+    if (Poll.$is("SlowDown")(answer))
+      interval = Duration4.sum(interval, Duration4.seconds(5));
+  }
+  return yield* LoginExpired.make({});
+});
+var revoke = (apiUrl, token) => HttpClient3.HttpClient.pipe(Effect17.flatMap((client) => client.execute(HttpClientRequest3.post(`${apiUrl}/auth/sign-out`).pipe(HttpClientRequest3.bearerToken(token), HttpClientRequest3.bodyJsonUnsafe({})))), Effect17.ignore);
+var loginCommand = Command14.make("login", flags10, ({ apiUrl }) => Effect17.gen(function* () {
+  const token = yield* deviceLogin(apiUrl);
+  const client = yield* cloudClient({ apiUrl, token, email: "" });
+  const me = yield* client.account.me().pipe(Effect17.tapError(() => revoke(apiUrl, token)));
+  const email = me.user?.email ?? "";
+  const file = yield* saveCredentials({ apiUrl, token, email });
+  yield* Console10.log(`Logged in to ${apiUrl} as ${email}. Credentials saved to ${file}.`);
+}).pipe(Effect17.catchTags({
+  LoginDenied: () => fail({
+    reason: "LoginDenied",
+    message: "The sign-in was denied in the browser. Nothing was saved.",
+    exitCode: 1
+  }),
+  LoginExpired: () => fail({
+    reason: "LoginExpired",
+    message: "The sign-in code expired before it was approved. Run `akter login` again.",
+    exitCode: 1
+  }),
+  LoginRefused: (error) => fail({
+    reason: "LoginRefused",
+    message: `The control plane refused the sign-in: ${error.error} (${error.status})`,
+    exitCode: 1
+  })
+}), reportFailures)).pipe(Command14.withDescription("Sign in to Akter Cloud through the browser and store the session for deploy"));
+
+// src/commands/cloud/logout.ts
+import { Console as Console11, Effect as Effect18, Option as Option9 } from "effect";
+import { Command as Command15 } from "effect/cli";
+import { HttpClient as HttpClient4, HttpClientRequest as HttpClientRequest4 } from "effect/http";
+var logout = Effect18.gen(function* () {
+  const credentials = yield* loadCredentialsToRevoke.pipe(Effect18.asSome, Effect18.catchTag("CredentialsUnreadable", () => Effect18.succeedNone), Effect18.map(Option9.getOrUndefined));
+  const revoked = credentials === undefined ? false : yield* HttpClient4.HttpClient.pipe(Effect18.flatMap((client) => client.execute(HttpClientRequest4.post(`${credentials.apiUrl}/auth/sign-out`).pipe(HttpClientRequest4.bearerToken(credentials.token), HttpClientRequest4.bodyJsonUnsafe({})))), Effect18.map((response) => response.status === 200), Effect18.orElseSucceed(() => false));
+  yield* removeCredentials;
+  return { credentials, revoked };
+});
+var logoutCommand = Command15.make("logout", {}, () => Effect18.gen(function* () {
+  const { credentials, revoked } = yield* logout;
+  if (credentials === undefined)
+    return yield* Console11.log("Removed the stored credentials.");
+  yield* Console11.log(revoked ? `Logged out of ${credentials.apiUrl}.` : `Removed the stored credentials. ${credentials.apiUrl} could not revoke the session, which ends when it expires.`);
+}).pipe(Effect18.catchTag("NotLoggedIn", () => Console11.log("Not logged in.")), reportFailures)).pipe(Command15.withDescription("Sign out of Akter Cloud and delete the stored session"));
+
+// src/commands/cloud/whoami.ts
+import { Console as Console12, Effect as Effect19 } from "effect";
+import { Command as Command16 } from "effect/cli";
+var whoamiCommand = Command16.make("whoami", {}, () => Effect19.gen(function* () {
+  const { credentials, client } = yield* signedIn;
+  const me = yield* client.account.me();
+  yield* Console12.log([
+    `${me.user?.email ?? credentials.email} at ${credentials.apiUrl}`,
+    ...me.organizations.map((membership) => `  ${membership.organization.slug}  ${membership.role}  ${membership.organization.id}`)
+  ].join(`
+`));
+}).pipe(reportFailures)).pipe(Command16.withDescription("Show who the stored Akter Cloud session signs in as"));
+
+// src/commands/cloud/env.ts
+import { Config as Config5, Console as Console13, DateTime as DateTime2, Effect as Effect20, FileSystem as FileSystem5, Option as Option10, Stdio, Stream as Stream2 } from "effect";
+import { Argument as Argument6, Command as Command17, Flag as Flag14 } from "effect/cli";
+var scope = {
+  project: Flag14.String("project").pipe(Flag14.withFallbackConfig(Config5.String("AKTER_PROJECT")), Flag14.withSchema(ProjectId)),
+  environment: Flag14.Literals("env", EnvironmentName.literals).pipe(Flag14.withDefault("production"))
+};
+var name = Argument6.String("name").pipe(Argument6.withSchema(EnvVariableName));
+var input = (path, limit) => Effect20.gen(function* () {
+  const tooLarge = () => fail({
+    reason: "EnvironmentInputTooLarge",
+    message: `Environment input exceeds ${limit} bytes.`,
+    exitCode: 2
+  });
+  if (path !== undefined && path !== "-") {
+    const fs = yield* FileSystem5.FileSystem;
+    const stat = yield* fs.stat(path);
+    if (Number(stat.size) > limit)
+      return yield* tooLarge();
+    const value = yield* fs.readFileString(path);
+    if (new TextEncoder().encode(value).byteLength > limit)
+      return yield* tooLarge();
+    return value;
+  }
+  const stdio = yield* Stdio.Stdio;
+  if (yield* stdio.stdinIsTerminal)
+    return yield* fail({
+      reason: "EnvironmentInputRequired",
+      message: "Pipe the value on stdin or supply --file. Values are never accepted as command arguments.",
+      exitCode: 2
+    });
+  const collected = yield* stdio.stdin.pipe(Stream2.runFoldEffect(() => ({ size: 0, chunks: new Array }), (state, chunk) => {
+    if (state.size + chunk.length > limit)
+      return tooLarge();
+    state.chunks.push(chunk);
+    state.size += chunk.length;
+    return Effect20.succeed(state);
+  }));
+  const bytes = new Uint8Array(collected.size);
+  let offset = 0;
+  for (const chunk of collected.chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return new TextDecoder().decode(bytes);
+});
+var list2 = Command17.make("list", scope, ({ project, environment }) => Effect20.gen(function* () {
+  const { client } = yield* signedIn;
+  const variables = yield* client.environmentVariables.list({
+    params: { projectId: project, environment }
+  });
+  for (const variable of variables)
+    yield* Console13.log(`${variable.name}	${DateTime2.formatIso(variable.updatedAt)}`);
+}).pipe(reportFailures)).pipe(Command17.withDescription("List variable names and update times; values cannot be read back"));
+var set = Command17.make("set", { ...scope, name, file: Flag14.File("file", { mustExist: true }).pipe(Flag14.optional) }, (options) => Effect20.gen(function* () {
+  const { client } = yield* signedIn;
+  const value = yield* input(Option10.getOrUndefined(options.file), 65536);
+  yield* client.environmentVariables.set({
+    params: {
+      projectId: options.project,
+      environment: options.environment,
+      name: options.name
+    },
+    payload: { value }
+  });
+  yield* Console13.log(`Set ${options.name} in ${options.environment}. The value takes effect on the next deployment.`);
+}).pipe(reportFailures)).pipe(Command17.withDescription("Set a write-only value from piped stdin or --file"));
+var unset = Command17.make("unset", { ...scope, name }, ({ project, environment, name }) => Effect20.gen(function* () {
+  const { client } = yield* signedIn;
+  yield* client.environmentVariables.delete({ params: { projectId: project, environment, name } });
+  yield* Console13.log(`Unset ${name} in ${environment}. The change takes effect on the next deployment.`);
+}).pipe(reportFailures)).pipe(Command17.withDescription("Remove an environment variable"));
+var importVariables = Command17.make("import", { ...scope, file: Argument6.String("file").pipe(Argument6.withDefault("-")) }, ({ project, environment, file }) => Effect20.gen(function* () {
+  const { client } = yield* signedIn;
+  const content = yield* input(file, 1048576);
+  const result = yield* client.environmentVariables.import({
+    params: { projectId: project, environment },
+    payload: { content }
+  });
+  yield* Console13.log(`Imported ${result.created.length} new and ${result.updated.length} updated variables in ${environment}.`);
+}).pipe(reportFailures)).pipe(Command17.withDescription("Import a dotenv file atomically; use - or no file for stdin"));
+var envCommand = Command17.make("env").pipe(Command17.withDescription("Manage encrypted, write-only Akter Cloud environment variables"), Command17.withSubcommands([list2, set, unset, importVariables]));
+
+// src/commands/cloud/logs.ts
+import { Config as Config6, Console as Console14, DateTime as DateTime3, Effect as Effect21, Option as Option11, Schema as Schema28 } from "effect";
+import { Command as Command18, Flag as Flag15 } from "effect/cli";
+var colourSequence = new RegExp(`${String.fromCodePoint(27)}\\[[0-?]*[ -/]*[@-~]`, "gu");
+var logsCommand = Command18.make("logs", {
+  project: Flag15.String("project").pipe(Flag15.withFallbackConfig(Config6.String("AKTER_PROJECT")), Flag15.withSchema(ProjectId), Flag15.withDescription("The project (default AKTER_PROJECT)")),
+  environment: Flag15.Literals("env", EnvironmentName.literals).pipe(Flag15.withDefault("production"), Flag15.withDescription("The environment (default production)")),
+  deployment: Flag15.String("deployment").pipe(Flag15.withSchema(DeploymentId), Flag15.optional, Flag15.withDescription("Read a deployment instead of the environment's current deployment")),
+  since: Flag15.Int("since").pipe(Flag15.withSchema(Schema28.Int.check(Schema28.isBetween({ minimum: 1, maximum: MAX_LOG_WINDOW_SECONDS }))), Flag15.withDefault(300), Flag15.withDescription("Seconds of recent output, 1–3600 (default 300)")),
+  limit: Flag15.Int("limit").pipe(Flag15.withSchema(LogLimit), Flag15.withDefault(100), Flag15.withDescription("Maximum lines per response, 1–200 (default 100)")),
+  follow: Flag15.Boolean("follow").pipe(Flag15.withDefault(false), Flag15.withDescription("Resume long polls until interrupted"))
+}, (options) => Effect21.gen(function* () {
+  const { client } = yield* signedIn;
+  const since = DateTime3.subtract(yield* DateTime3.now, { seconds: options.since });
+  let cursor;
+  let more = false;
+  let failures = 0;
+  const retryRead = (error) => Effect21.gen(function* () {
+    if (!options.follow || failures >= MAX_READ_RETRIES)
+      return yield* error;
+    failures += 1;
+    yield* Console14.error("Log read unavailable; reconnecting from the last cursor.");
+    yield* Effect21.sleep(readRetryDelay(failures));
+    return;
+  });
+  while (true) {
+    const query = {
+      since,
+      limit: options.limit,
+      cursor,
+      wait: options.follow && cursor !== undefined && !more ? MAX_LOG_WAIT_SECONDS : 0
+    };
+    const request = Option11.isSome(options.deployment) ? client.deployments.getLogs({
+      params: { projectId: options.project, deploymentId: options.deployment.value },
+      query
+    }) : client.deployments.getEnvironmentLogs({
+      params: { projectId: options.project, environment: options.environment },
+      query
+    });
+    const page = yield* request.pipe(Effect21.catchTags({ HttpClientError: retryRead, Unavailable: retryRead }));
+    if (page === undefined)
+      continue;
+    failures = 0;
+    for (const line of page.lines)
+      yield* Console14.log(`${DateTime3.formatIso(line.at)}	${line.runnerId}	${line.stream}	${line.text.replace(colourSequence, "").replace(/\p{Cc}|[\u061c\u200e\u200f\u2028\u2029\u202a-\u202e\u2066-\u2069]/gu, "�")}${line.clipped ? " …" : ""}`);
+    cursor = page.cursor;
+    more = page.more;
+    if (!options.follow && !more)
+      return;
+    if (page.lines.length === 0 && !more)
+      yield* Effect21.sleep("1 second");
+  }
+}).pipe(reportFailures)).pipe(Command18.withDescription("Read recent customer runner logs, or follow with resumable long polls"));
+
+// src/cli.ts
+var group = (name, description, subcommands) => Command19.make(name).pipe(Command19.withDescription(description), Command19.withSubcommands(subcommands));
+var akter = Command19.make("akter").pipe(Command19.withDescription("Run actors locally, check a deploy against stored data, adopt existing tables, inspect and repair a running deployment, and deploy to Akter Cloud"), Command19.withSubcommands([
+  {
+    group: "Develop and check",
+    commands: [
+      devCommand,
+      group("workflows", "Check workflow changes against open executions", [
+        checkCommand
+      ]),
+      group("payloads", "Check and clear stored event and job payload versions", [
+        checkCommand2,
+        clearCommand
+      ]),
+      group("adopt", "Adopt existing tables: plan, observe legacy writers, backfill, enforce, and check status", [
+        planCommand,
+        observeCommand,
+        backfillCommand,
+        enforceCommand,
+        statusCommand,
+        releaseCommand
+      ]),
+      group("fleet", "Set up fleet views' change feed and rebuild a view from its source", [
+        setupCommand,
+        rebuildCommand
+      ])
+    ]
+  },
+  {
+    group: "Operate a running deployment",
+    commands: [
+      group("defects", "Read recent defects from runners", [listCommand]),
+      inspectCommand,
+      exportCommand,
+      group("receipts", "Read stored command outcomes", [showCommand]),
+      group("dead-letters", "Repair dead-lettered jobs; the runner audits each repair", [
+        retryCommand,
+        discardCommand
+      ]),
+      group("subscriptions", "List and skip stuck subscription rows", [
+        listCommand2,
+        skipCommand
+      ])
+    ]
+  },
+  {
+    group: "Akter Cloud",
+    commands: [
+      loginCommand,
+      logoutCommand,
+      whoamiCommand,
+      deployCommand,
+      envCommand,
+      logsCommand
+    ]
+  }
+]));
+var isShowHelp = Schema29.is(CliError.ShowHelp);
+var run2 = (args) => Command19.runWith(akter, { version })(args).pipe(Effect22.catchIf((error) => CliError.isCliError(error) && Runtime2.getErrorExitCode(error) !== 0, (error) => Effect22.fail(CommandFailed.make({
+  exitCode: 2,
+  reason: isShowHelp(error) ? error.errors[0]?._tag ?? "ShowHelp" : error._tag
+}))));
+
+// src/main.ts
+Effect23.gen(function* () {
+  const services = yield* Layer5.build(Layer5.mergeAll(PlatformServices.layer, FetchHttpClient.layer));
+  const args = yield* Context2.get(services, Stdio2.Stdio).args;
+  return yield* run2(args).pipe(Effect23.provideContext(services));
+}).pipe(Effect23.scoped, PlatformRuntime.runMain);