priiisk 0.1.1

package/dist/chunk-UCN75R46.js

@@ -0,0 +1,1185 @@
+import { createRequire as __priiiskCreateRequire } from "node:module";
+const require = __priiiskCreateRequire(import.meta.url);
+import {
+  CampProtocol,
+  CampSurface,
+  CommandExecutor_exports,
+  Command_exports,
+  PRIIISK_PROTOCOL_VERSION,
+  ProtocolClientKind,
+  RpcClient_exports,
+  RpcSerialization_exports,
+  SurfaceActivity,
+  SurfaceError,
+  SurfaceErrorCode,
+  SurfaceOwnership,
+  SurfacePresence,
+  campProjectPaths,
+  ensureSurfaceHandleClosable,
+  ensureSurfaceHandleProvider,
+  layerNet,
+  makeCampSurfaceName,
+  resolveProjectScopeSync
+} from "./chunk-RJO6Z3SQ.js";
+import {
+  Clock_exports,
+  Config_exports,
+  Context_exports,
+  Data_exports,
+  Deferred_exports,
+  Duration_exports,
+  Effect_exports,
+  Either_exports,
+  FiberRef_exports,
+  Layer_exports,
+  Option_exports,
+  Ref_exports,
+  Schedule_exports,
+  Schema_exports,
+  Stream_exports
+} from "./chunk-KFSFN6L5.js";
+
+// packages/cli/src/doctor/doctorModel.ts
+var DOCTOR_REPORT_SCHEMA_VERSION = 1;
+var DoctorCheckStatus = {
+  pass: "pass",
+  warning: "warning",
+  failure: "failure",
+  skipped: "skipped"
+};
+var DoctorOverallStatus = {
+  healthy: "healthy",
+  degraded: "degraded",
+  failed: "failed"
+};
+var DoctorCheckSchema = Schema_exports.Struct({
+  id: Schema_exports.String.pipe(Schema_exports.minLength(1)),
+  status: Schema_exports.Literal(...Object.values(DoctorCheckStatus)),
+  summary: Schema_exports.String.pipe(Schema_exports.minLength(1)),
+  details: Schema_exports.optional(Schema_exports.Record({ key: Schema_exports.String, value: Schema_exports.Unknown }))
+});
+var DoctorReportSchema = Schema_exports.Struct({
+  schemaVersion: Schema_exports.Literal(DOCTOR_REPORT_SCHEMA_VERSION),
+  overallStatus: Schema_exports.Literal(...Object.values(DoctorOverallStatus)),
+  checkedAt: Schema_exports.Number.pipe(Schema_exports.int(), Schema_exports.nonNegative()),
+  projectHash: Schema_exports.optional(Schema_exports.String.pipe(Schema_exports.minLength(1))),
+  checks: Schema_exports.Array(DoctorCheckSchema)
+});
+var doctorCheck = (id, status, summary, details) => ({
+  id,
+  status,
+  summary,
+  ...details === void 0 ? {} : { details }
+});
+var makeDoctorReport = (checks, checkedAt, projectHash) => ({
+  schemaVersion: DOCTOR_REPORT_SCHEMA_VERSION,
+  overallStatus: checks.some((check) => check.status === DoctorCheckStatus.failure) ? DoctorOverallStatus.failed : checks.some((check) => check.status === DoctorCheckStatus.warning) ? DoctorOverallStatus.degraded : DoctorOverallStatus.healthy,
+  checkedAt,
+  ...projectHash === void 0 ? {} : { projectHash },
+  checks
+});
+var doctorErrorMessage = (cause) => (cause instanceof Error ? cause.message : String(cause)).slice(-2048);
+
+// packages/cli/src/client/campRpcRuntime.ts
+import { existsSync } from "node:fs";
+
+// packages/cli/src/domain/cliErrors.ts
+var CliRpcTimeout = class extends Data_exports.TaggedError("CliRpcTimeout") {
+};
+var CliCampNotRunning = class extends Data_exports.TaggedError("CliCampNotRunning") {
+};
+var CliTurnWaitTimeout = class extends Data_exports.TaggedError("CliTurnWaitTimeout") {
+};
+var CliMessageSourceError = class extends Data_exports.TaggedError("CliMessageSourceError") {
+};
+var CliEquipmentConflict = class extends Data_exports.TaggedError("CliEquipmentConflict") {
+};
+var CliCampLifecycleError = class extends Data_exports.TaggedError("CliCampLifecycleError") {
+};
+var CliGenerationChanged = class extends Data_exports.TaggedError("CliGenerationChanged") {
+};
+var CliStdioRequestInvalid = class extends Data_exports.TaggedError("CliStdioRequestInvalid") {
+};
+var CliStdioCommandCancelled = class extends Data_exports.TaggedError("CliStdioCommandCancelled") {
+};
+var CliStdioStreamFailure = class extends Data_exports.TaggedError("CliStdioStreamFailure") {
+};
+var CliSurfaceSelectionError = class extends Data_exports.TaggedError("CliSurfaceSelectionError") {
+};
+
+// packages/cli/src/client/campRpcConnection.ts
+import { randomUUID } from "node:crypto";
+
+// packages/cli/src/domain/cliVersion.ts
+var PRIIISK_CLI_VERSION = "0.1.1";
+
+// packages/cli/src/client/campRpcConnection.ts
+var PRIIISK_CONTROLLER_ID_ENV = "PRIIISK_CONTROLLER_ID";
+var PRIIISK_CONSUMER_ID_ENV = "PRIIISK_CONSUMER_ID";
+var protocolRetrySchedule = Schedule_exports.exponential("50 millis").pipe(
+  Schedule_exports.intersect(Schedule_exports.recurs(5))
+);
+var trimmedEnvironment = (name) => {
+  const value = process.env[name]?.trim();
+  return value === void 0 || value === "" ? void 0 : value;
+};
+var makeClientContext = (projectHash, consumerId) => {
+  const configured = trimmedEnvironment(PRIIISK_CONTROLLER_ID_ENV);
+  const configuredConsumer = consumerId?.trim();
+  return {
+    protocolVersion: PRIIISK_PROTOCOL_VERSION,
+    clientVersion: PRIIISK_CLI_VERSION,
+    projectHash,
+    controllerId: configured ?? `orchestrator-${projectHash}`,
+    consumerId: configuredConsumer === void 0 || configuredConsumer === "" ? trimmedEnvironment(PRIIISK_CONSUMER_ID_ENV) ?? `cli-${randomUUID()}` : configuredConsumer,
+    clientKind: ProtocolClientKind.orchestrator
+  };
+};
+var makeCampProtocolLayer = (socketPath, options) => Effect_exports.gen(function* () {
+  const retryState = yield* Ref_exports.make({
+    attempt: 0
+  });
+  const retrySchedule = protocolRetrySchedule.pipe(
+    Schedule_exports.tapInput(
+      (cause) => Ref_exports.update(retryState, (current) => ({ ...current, cause }))
+    ),
+    Schedule_exports.onDecision(
+      (_output, decision) => decision._tag === "Done" ? Effect_exports.void : Ref_exports.modify(retryState, (current) => {
+        const next = { attempt: current.attempt + 1, cause: current.cause };
+        return [next, next];
+      }).pipe(
+        Effect_exports.flatMap(
+          ({ attempt, cause }) => Clock_exports.currentTimeMillis.pipe(
+            Effect_exports.flatMap(
+              (now) => options.onRetry?.({
+                operation: options.operation,
+                attempt,
+                nextRetryAt: now + 50 * 2 ** (attempt - 1),
+                message: cause instanceof Error ? cause.message : String(cause)
+              }) ?? Effect_exports.void
+            )
+          )
+        )
+      )
+    )
+  );
+  return RpcClient_exports.layerProtocolSocket({
+    retryTransientErrors: options.retryTransientErrors ?? false,
+    retrySchedule
+  }).pipe(
+    Layer_exports.provide(RpcSerialization_exports.layerNdjson),
+    Layer_exports.provide(layerNet({ path: socketPath }))
+  );
+});
+var makeCampProtocolContext = (socketPath, options) => makeCampProtocolLayer(socketPath, options).pipe(Effect_exports.flatMap(Layer_exports.build));
+var makeCommandFactory = (client, context, operation, acceptedGeneration) => (
+  /*
+   * A one-shot command adopts whatever generation the handshake reports. A
+   * session command must not: the host may have restarted since the client
+   * reconciled, and applying the command under the new epoch would hide it.
+   */
+  (commandId = randomUUID()) => client.Handshake(context).pipe(
+    Effect_exports.flatMap((handshake) => {
+      const bound = { ...context, generation: handshake.generation, commandId };
+      if (acceptedGeneration === void 0) return Effect_exports.succeed(bound);
+      return Ref_exports.get(acceptedGeneration).pipe(
+        Effect_exports.flatMap(
+          (accepted) => accepted === void 0 || accepted === handshake.generation ? Effect_exports.succeed(bound) : Effect_exports.fail(
+            new CliGenerationChanged({
+              operation,
+              code: "session_generation_changed",
+              recoveryAction: "reconcile_snapshot",
+              acceptedGeneration: accepted,
+              currentGeneration: handshake.generation,
+              message: `host generation changed from ${accepted} to ${handshake.generation}; reconcile before sending commands`
+            })
+          )
+        )
+      );
+    })
+  )
+);
+
+// packages/cli/src/client/campRpcRuntime.ts
+var isTransportFailure = (error) => {
+  if (typeof error !== "object" || error === null) return false;
+  const tag = error._tag;
+  return tag === "RpcClientError" || tag === "SocketError" || tag === "SocketGenericError";
+};
+var activeCampRpc = FiberRef_exports.unsafeMake(void 0);
+var SESSION_CONNECT_TIMEOUT_MS = 3e4;
+var releaseCampRpcConnection = FiberRef_exports.get(activeCampRpc).pipe(
+  Effect_exports.flatMap((active) => active?.release ?? Effect_exports.void)
+);
+var withCampRpc = (use, options) => {
+  const scope = resolveProjectScopeSync();
+  const { socketPath } = campProjectPaths(scope);
+  const timeoutMs = options.timeoutMs ?? 5e3;
+  const bounded = (effect) => timeoutMs === "none" ? effect : effect.pipe(
+    Effect_exports.timeoutFail({
+      duration: timeoutMs,
+      onTimeout: () => new CliRpcTimeout({ operation: options.operation, timeoutMs })
+    })
+  );
+  const run = Effect_exports.gen(function* () {
+    if (options.expectRunning !== false && !existsSync(socketPath)) {
+      yield* releaseCampRpcConnection;
+      return yield* Effect_exports.fail(
+        new CliCampNotRunning({
+          operation: options.operation,
+          projectHash: scope.hash,
+          code: "camp_not_running",
+          message: "camp \u043D\u0435 \u0437\u0430\u043F\u0443\u0449\u0435\u043D \u0432 \u044D\u0442\u043E\u043C project scope",
+          recoveryAction: "camp_up"
+        })
+      );
+    }
+    const active = yield* FiberRef_exports.get(activeCampRpc);
+    if (active !== void 0) {
+      const connection = yield* active.connect;
+      const context = makeClientContext(
+        active.projectHash,
+        options.consumerId ?? active.consumerId
+      );
+      return yield* bounded(
+        use({
+          client: connection.client,
+          context,
+          command: makeCommandFactory(
+            connection.client,
+            context,
+            options.operation,
+            active.acceptedGeneration
+          ),
+          socketPath: connection.socketPath
+        }).pipe(
+          Effect_exports.provide(connection.protocol),
+          Effect_exports.tapError(
+            (error) => isTransportFailure(error) ? active.invalidate(connection) : Effect_exports.void
+          )
+        )
+      );
+    }
+    const protocolLayer = yield* makeCampProtocolLayer(socketPath, options);
+    return yield* bounded(
+      Effect_exports.scoped(
+        RpcClient_exports.make(CampProtocol).pipe(
+          Effect_exports.flatMap((client) => {
+            const context = makeClientContext(scope.hash, options.consumerId);
+            return use({
+              client,
+              context,
+              command: makeCommandFactory(client, context, options.operation),
+              socketPath
+            });
+          }),
+          Effect_exports.provide(protocolLayer)
+        )
+      )
+    );
+  });
+  return run;
+};
+var withCampRpcSession = (use, options) => Effect_exports.scoped(
+  Effect_exports.gen(function* () {
+    const sessionScope = yield* Effect_exports.scope;
+    const project = resolveProjectScopeSync();
+    const { socketPath } = campProjectPaths(project);
+    const context = makeClientContext(project.hash, options.consumerId);
+    const acceptedGeneration = yield* Ref_exports.make(void 0);
+    const connectionRef = yield* Ref_exports.make(void 0);
+    const gate = yield* Effect_exports.makeSemaphore(1);
+    const open = Effect_exports.gen(function* () {
+      const ready = yield* Deferred_exports.make();
+      const held = yield* Deferred_exports.make();
+      const holder = Effect_exports.gen(function* () {
+        const protocol = yield* makeCampProtocolContext(socketPath, options);
+        const client = yield* RpcClient_exports.make(CampProtocol).pipe(Effect_exports.provide(protocol));
+        const handshake = yield* client.Handshake(context).pipe(Effect_exports.provide(protocol));
+        const connection = {
+          client,
+          socketPath,
+          protocol,
+          release: Deferred_exports.succeed(held, void 0).pipe(Effect_exports.asVoid)
+        };
+        yield* Ref_exports.update(acceptedGeneration, (current) => current ?? handshake.generation);
+        yield* Ref_exports.set(connectionRef, connection);
+        yield* options.onConnect?.(handshake) ?? Effect_exports.void;
+        yield* Deferred_exports.succeed(ready, connection);
+        yield* Deferred_exports.await(held);
+      });
+      yield* Effect_exports.forkIn(
+        Effect_exports.scoped(holder).pipe(
+          Effect_exports.onError(
+            (cause) => Ref_exports.set(connectionRef, void 0).pipe(
+              Effect_exports.zipRight(Deferred_exports.failCause(ready, cause)),
+              Effect_exports.asVoid
+            )
+          )
+        ),
+        sessionScope
+      );
+      return yield* Deferred_exports.await(ready);
+    });
+    const invalidate = (connection) => gate.withPermits(1)(
+      Ref_exports.get(connectionRef).pipe(
+        Effect_exports.flatMap(
+          (current) => current === connection ? Ref_exports.set(connectionRef, void 0).pipe(Effect_exports.zipRight(connection.release)) : Effect_exports.void
+        )
+      )
+    );
+    const connect = gate.withPermits(1)(
+      Ref_exports.get(connectionRef).pipe(
+        Effect_exports.flatMap((current) => current === void 0 ? open : Effect_exports.succeed(current))
+      )
+    ).pipe(
+      Effect_exports.timeoutFail({
+        duration: SESSION_CONNECT_TIMEOUT_MS,
+        onTimeout: () => new CliRpcTimeout({
+          operation: `${options.operation}.connect`,
+          timeoutMs: SESSION_CONNECT_TIMEOUT_MS
+        })
+      })
+    );
+    const release = gate.withPermits(1)(
+      Ref_exports.get(connectionRef).pipe(
+        Effect_exports.flatMap(
+          (current) => current === void 0 ? Effect_exports.void : Ref_exports.set(connectionRef, void 0).pipe(Effect_exports.zipRight(current.release))
+        )
+      )
+    );
+    return yield* Effect_exports.locally(activeCampRpc, {
+      projectHash: project.hash,
+      consumerId: context.consumerId,
+      acceptedGeneration,
+      connect,
+      invalidate,
+      release
+    })(use({ projectHash: project.hash, socketPath }));
+  })
+);
+var acceptCampGeneration = (generation) => FiberRef_exports.get(activeCampRpc).pipe(
+  Effect_exports.flatMap(
+    (active) => active === void 0 ? Effect_exports.void : Ref_exports.set(active.acceptedGeneration, generation)
+  )
+);
+
+// packages/surface-herdr/src/domain/herdrErrors.ts
+var HerdrUnavailableError = class extends Data_exports.TaggedError("HerdrUnavailableError") {
+};
+var HerdrTimeoutError = class extends Data_exports.TaggedError("HerdrTimeoutError") {
+};
+var HerdrCommandError = class extends Data_exports.TaggedError("HerdrCommandError") {
+};
+var HerdrApiError = class extends Data_exports.TaggedError("HerdrApiError") {
+};
+var HerdrEnvelopeError = class extends Data_exports.TaggedError("HerdrEnvelopeError") {
+};
+var HerdrRollbackError = class extends Data_exports.TaggedError("HerdrRollbackError") {
+};
+
+// packages/surface-herdr/src/commands/herdrOutput.ts
+var ApiErrorEnvelopeSchema = Schema_exports.Struct({
+  error: Schema_exports.Struct({ code: Schema_exports.String, message: Schema_exports.String })
+});
+var isApiErrorEnvelope = Schema_exports.is(ApiErrorEnvelopeSchema);
+var emptyOutputTail = () => ({
+  bytes: new Uint8Array(),
+  truncated: false
+});
+var appendOutputTail = (current, chunk, limit) => {
+  const combined = Buffer.concat([Buffer.from(current.bytes), Buffer.from(chunk)]);
+  const overflowed = combined.length > limit;
+  return {
+    bytes: overflowed ? combined.subarray(combined.length - limit) : combined,
+    truncated: current.truncated || overflowed
+  };
+};
+var redactHerdrOutput = (text, values) => [...new Set(values.filter((value) => value !== ""))].sort((left, right) => right.length - left.length).reduce((current, value) => current.replaceAll(value, "<redacted>"), text);
+var renderOutputTail = (output, redactions) => redactHerdrOutput(Buffer.from(output.bytes).toString("utf8"), redactions);
+var parseJson = (text) => {
+  const trimmed = text.trim();
+  if (trimmed === "") return {};
+  try {
+    return { value: JSON.parse(trimmed) };
+  } catch (cause) {
+    return { cause };
+  }
+};
+var HerdrResponseMode = {
+  emptyOk: "empty-ok",
+  json: "json",
+  raw: "raw"
+};
+var isHerdrRawOutput = (value) => typeof value === "object" && value !== null && "text" in value && typeof value.text === "string" && "truncated" in value && typeof value.truncated === "boolean";
+var decodeHerdrOutput = (captured, responseMode) => {
+  const stdout = parseJson(captured.stdoutTail);
+  const stderr = parseJson(captured.stderrTail);
+  const apiError = isApiErrorEnvelope(stdout.value) ? stdout.value : isApiErrorEnvelope(stderr.value) ? stderr.value : void 0;
+  if (apiError !== void 0) {
+    return Effect_exports.fail(
+      new HerdrApiError({
+        args: captured.args,
+        code: apiError.error.code,
+        message: apiError.error.message
+      })
+    );
+  }
+  if (responseMode === HerdrResponseMode.raw && captured.exitCode === 0) {
+    return Effect_exports.succeed({
+      text: captured.stdoutTail,
+      truncated: captured.stdoutTruncated
+    });
+  }
+  if (responseMode === HerdrResponseMode.emptyOk && captured.exitCode === 0 && stdout.cause === void 0 && stdout.value === void 0) {
+    return Effect_exports.succeed(void 0);
+  }
+  if (captured.exitCode !== 0 || stdout.cause !== void 0 || stdout.value === void 0) {
+    return Effect_exports.fail(
+      new HerdrCommandError({
+        ...captured,
+        cause: stdout.cause
+      })
+    );
+  }
+  return Effect_exports.succeed(stdout.value);
+};
+
+// packages/surface-herdr/src/commands/herdrCli.ts
+var DEFAULT_TIMEOUT_MS = 5e3;
+var DEFAULT_OUTPUT_TAIL_BYTES = 16 * 1024;
+var SPAWN_RETRY = Schedule_exports.exponential(Duration_exports.millis(50)).pipe(
+  Schedule_exports.intersect(Schedule_exports.recurs(2))
+);
+var HerdrCli = class extends Context_exports.Tag("priiisk/SurfaceHerdr/HerdrCli")() {
+};
+var resolveCommandPrefix = (options) => options.commandPrefix === void 0 ? Config_exports.string("PRIIISK_HERDR_BIN").pipe(
+  Config_exports.withDefault("herdr"),
+  Effect_exports.map((executable) => [executable]),
+  Effect_exports.orDie
+) : Effect_exports.succeed(options.commandPrefix);
+var makeHerdrCli = (options = {}) => Effect_exports.gen(function* () {
+  const executor = yield* CommandExecutor_exports.CommandExecutor;
+  const commandPrefix = yield* resolveCommandPrefix(options);
+  const [executable, ...prefixArgs] = commandPrefix;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const outputLimit = options.outputTailBytes ?? DEFAULT_OUTPUT_TAIL_BYTES;
+  const attempt = (args, runOptions) => Effect_exports.gen(function* () {
+    const displayArgs = runOptions.displayArgs ?? args;
+    const redactions = runOptions.redactValues ?? [];
+    const stdoutRef = yield* Ref_exports.make(emptyOutputTail());
+    const stderrRef = yield* Ref_exports.make(emptyOutputTail());
+    const command = Command_exports.make(executable, ...prefixArgs, ...args);
+    const execute = Effect_exports.scoped(
+      Effect_exports.gen(function* () {
+        const running = yield* executor.start(command).pipe(Effect_exports.mapError((cause) => new HerdrUnavailableError({ executable, cause })));
+        const drain = (stream, ref) => Stream_exports.runForEach(
+          stream,
+          (chunk) => Ref_exports.update(ref, (current) => appendOutputTail(current, chunk, outputLimit))
+        );
+        const [, , exitCode2] = yield* Effect_exports.all(
+          [
+            drain(running.stdout, stdoutRef),
+            drain(running.stderr, stderrRef),
+            running.exitCode.pipe(
+              Effect_exports.map(Number),
+              Effect_exports.orElseSucceed(() => null)
+            )
+          ],
+          { concurrency: "unbounded" }
+        ).pipe(
+          Effect_exports.catchAll(
+            (cause) => Effect_exports.all([Ref_exports.get(stdoutRef), Ref_exports.get(stderrRef)]).pipe(
+              Effect_exports.flatMap(
+                ([stdout2, stderr2]) => Effect_exports.fail(
+                  new HerdrCommandError({
+                    args: displayArgs,
+                    exitCode: null,
+                    stdoutTail: renderOutputTail(stdout2, redactions),
+                    stderrTail: renderOutputTail(stderr2, redactions),
+                    stdoutTruncated: stdout2.truncated,
+                    stderrTruncated: stderr2.truncated,
+                    cause
+                  })
+                )
+              )
+            )
+          )
+        );
+        return { exitCode: exitCode2 };
+      })
+    ).pipe(
+      Effect_exports.timeoutFail({
+        duration: Duration_exports.millis(timeoutMs),
+        onTimeout: () => new HerdrTimeoutError({
+          args: displayArgs,
+          timeoutMs,
+          stdoutTail: "",
+          stderrTail: "",
+          stdoutTruncated: false,
+          stderrTruncated: false
+        })
+      })
+    );
+    const { exitCode } = yield* execute.pipe(
+      Effect_exports.catchTag(
+        "HerdrTimeoutError",
+        (error) => Effect_exports.all([Ref_exports.get(stdoutRef), Ref_exports.get(stderrRef)]).pipe(
+          Effect_exports.flatMap(
+            ([stdout2, stderr2]) => Effect_exports.fail(
+              new HerdrTimeoutError({
+                ...error,
+                stdoutTail: renderOutputTail(stdout2, redactions),
+                stderrTail: renderOutputTail(stderr2, redactions),
+                stdoutTruncated: stdout2.truncated,
+                stderrTruncated: stderr2.truncated
+              })
+            )
+          )
+        )
+      )
+    );
+    const stdout = yield* Ref_exports.get(stdoutRef);
+    const stderr = yield* Ref_exports.get(stderrRef);
+    const stdoutTail = renderOutputTail(stdout, redactions);
+    const stderrTail = renderOutputTail(stderr, redactions);
+    return yield* decodeHerdrOutput(
+      {
+        args: displayArgs,
+        exitCode,
+        stdoutTail,
+        stderrTail,
+        stdoutTruncated: stdout.truncated,
+        stderrTruncated: stderr.truncated
+      },
+      runOptions.responseMode ?? HerdrResponseMode.json
+    );
+  });
+  return {
+    run: (args, runOptions = {}) => attempt(args, runOptions).pipe(
+      Effect_exports.retry({
+        schedule: SPAWN_RETRY,
+        while: (error) => error._tag === "HerdrUnavailableError"
+      })
+    )
+  };
+});
+var makeHerdrCliLayer = (options = {}) => Layer_exports.effect(HerdrCli, makeHerdrCli(options));
+var HerdrCliLive = makeHerdrCliLayer();
+
+// packages/surface-herdr/src/commands/herdrCommand.ts
+var HerdrCommand = {
+  paneGet: ["pane", "get"],
+  paneRead: ["pane", "read"],
+  paneReportAgent: ["pane", "report-agent"],
+  paneRun: ["pane", "run"],
+  tabClose: ["tab", "close"],
+  tabCreate: ["tab", "create"],
+  tabFocus: ["tab", "focus"],
+  tabGet: ["tab", "get"],
+  tabList: ["tab", "list"]
+};
+var HerdrFlag = {
+  agent: "--agent",
+  customStatus: "--custom-status",
+  cwd: "--cwd",
+  env: "--env",
+  format: "--format",
+  label: "--label",
+  lines: "--lines",
+  noFocus: "--no-focus",
+  seq: "--seq",
+  source: "--source",
+  state: "--state",
+  workspace: "--workspace"
+};
+var HerdrReadSource = {
+  visible: "visible"
+};
+var HerdrOutputFormat = {
+  text: "text"
+};
+var HerdrApiErrorCode = {
+  paneNotFound: "pane_not_found",
+  tabNotFound: "tab_not_found",
+  workspaceNotFound: "workspace_not_found"
+};
+
+// packages/surface-herdr/src/protocol/herdrEnvelopes.ts
+var HerdrWireField = {
+  result: "result",
+  resultKind: "type"
+};
+var TabSchema = Schema_exports.Struct({
+  tab_id: Schema_exports.String,
+  workspace_id: Schema_exports.String,
+  focused: Schema_exports.Boolean,
+  label: Schema_exports.String
+});
+var PaneSchema = Schema_exports.Struct({
+  pane_id: Schema_exports.String,
+  tab_id: Schema_exports.String,
+  workspace_id: Schema_exports.String
+});
+var TabCreatedEnvelopeSchema = Schema_exports.Struct({
+  result: Schema_exports.Struct({
+    tab: TabSchema,
+    root_pane: PaneSchema
+  })
+});
+var TabInfoEnvelopeSchema = Schema_exports.Struct({
+  result: Schema_exports.Struct({ tab: TabSchema })
+});
+var TabListEnvelopeSchema = Schema_exports.Struct({
+  result: Schema_exports.Struct({ tabs: Schema_exports.Array(TabSchema) })
+});
+var PaneInfoEnvelopeSchema = Schema_exports.Struct({
+  result: Schema_exports.Struct({ pane: PaneSchema })
+});
+var decoders = {
+  paneInfo: Schema_exports.decodeUnknown(PaneInfoEnvelopeSchema),
+  tabCreated: Schema_exports.decodeUnknown(TabCreatedEnvelopeSchema),
+  tabInfo: Schema_exports.decodeUnknown(TabInfoEnvelopeSchema),
+  tabList: Schema_exports.decodeUnknown(TabListEnvelopeSchema)
+};
+var isRecord = (value) => typeof value === "object" && value !== null;
+var readResultKind = (value) => {
+  if (!isRecord(value)) return void 0;
+  const result = value[HerdrWireField.result];
+  if (!isRecord(result)) return void 0;
+  const kind = result[HerdrWireField.resultKind];
+  return typeof kind === "string" ? kind : void 0;
+};
+var ensureResultKind = (value, expectedKind, operation) => readResultKind(value) === expectedKind ? Effect_exports.void : Effect_exports.fail(
+  new HerdrEnvelopeError({
+    operation,
+    expectedKind,
+    cause: `received ${String(readResultKind(value))}`
+  })
+);
+var mapDecodeError = (operation, expectedKind) => (cause) => new HerdrEnvelopeError({ operation, expectedKind, cause });
+var parseTabCreated = (value) => ensureResultKind(value, "tab_created", "herdr.tab.create").pipe(
+  Effect_exports.zipRight(
+    decoders.tabCreated(value).pipe(Effect_exports.mapError(mapDecodeError("herdr.tab.create", "tab_created")))
+  ),
+  Effect_exports.map(({ result }) => ({
+    workspaceId: result.tab.workspace_id,
+    tabId: result.tab.tab_id,
+    paneId: result.root_pane.pane_id
+  }))
+);
+var parseTabInfoFor = (value, operation) => ensureResultKind(value, "tab_info", operation).pipe(
+  Effect_exports.zipRight(
+    decoders.tabInfo(value).pipe(Effect_exports.mapError(mapDecodeError(operation, "tab_info")))
+  ),
+  Effect_exports.map(({ result }) => ({
+    workspaceId: result.tab.workspace_id,
+    tabId: result.tab.tab_id,
+    focused: result.tab.focused,
+    label: result.tab.label
+  }))
+);
+var parseTabInfo = (value) => parseTabInfoFor(value, "herdr.tab.get");
+var parseFocusedTab = (value) => parseTabInfoFor(value, "herdr.tab.focus");
+var parseTabList = (value) => ensureResultKind(value, "tab_list", "herdr.tab.list").pipe(
+  Effect_exports.zipRight(
+    decoders.tabList(value).pipe(Effect_exports.mapError(mapDecodeError("herdr.tab.list", "tab_list")))
+  ),
+  Effect_exports.map(
+    ({ result }) => result.tabs.map((tab) => ({
+      workspaceId: tab.workspace_id,
+      tabId: tab.tab_id,
+      focused: tab.focused,
+      label: tab.label
+    }))
+  )
+);
+var parsePaneInfo = (value) => ensureResultKind(value, "pane_info", "herdr.pane.get").pipe(
+  Effect_exports.zipRight(
+    decoders.paneInfo(value).pipe(Effect_exports.mapError(mapDecodeError("herdr.pane.get", "pane_info")))
+  ),
+  Effect_exports.map(({ result }) => ({
+    workspaceId: result.pane.workspace_id,
+    tabId: result.pane.tab_id,
+    paneId: result.pane.pane_id
+  }))
+);
+var parseOk = (value, operation) => ensureResultKind(value, "ok", operation);
+
+// packages/surface-herdr/src/runtime/herdrFailureMapping.ts
+var surfaceCodeByFailure = {
+  HerdrApiError: SurfaceErrorCode.commandFailed,
+  HerdrCommandError: SurfaceErrorCode.commandFailed,
+  HerdrEnvelopeError: SurfaceErrorCode.responseInvalid,
+  HerdrRollbackError: SurfaceErrorCode.adapterFailure,
+  HerdrTimeoutError: SurfaceErrorCode.timeout,
+  HerdrUnavailableError: SurfaceErrorCode.contextUnavailable
+};
+var diagnosticsByFailure = {
+  HerdrApiError: (error) => ({ args: error.args, apiCode: error.code, message: error.message }),
+  HerdrCommandError: (error) => ({
+    args: error.args,
+    exitCode: error.exitCode,
+    stdoutTail: error.stdoutTail,
+    stderrTail: error.stderrTail,
+    stdoutTruncated: error.stdoutTruncated,
+    stderrTruncated: error.stderrTruncated
+  }),
+  HerdrEnvelopeError: (error) => ({ expectedKind: error.expectedKind }),
+  HerdrRollbackError: (error) => ({
+    primary: error.primary._tag,
+    rollback: error.rollback._tag
+  }),
+  HerdrTimeoutError: (error) => ({
+    args: error.args,
+    timeoutMs: error.timeoutMs,
+    stdoutTail: error.stdoutTail,
+    stderrTail: error.stderrTail,
+    stdoutTruncated: error.stdoutTruncated,
+    stderrTruncated: error.stderrTruncated
+  }),
+  HerdrUnavailableError: (error) => ({ executable: error.executable })
+};
+var mapHerdrFailure = (operation, error) => {
+  const diagnostics = diagnosticsByFailure[error._tag];
+  return new SurfaceError({
+    operation,
+    code: surfaceCodeByFailure[error._tag],
+    details: diagnostics(error),
+    cause: error
+  });
+};
+
+// packages/surface-herdr/src/runtime/herdrContext.ts
+var HerdrEnvironment = {
+  paneId: "HERDR_PANE_ID",
+  tabId: "HERDR_TAB_ID",
+  workspaceId: "HERDR_WORKSPACE_ID"
+};
+var readOptional = (name) => Config_exports.option(Config_exports.string(name));
+var readContextEnvironment = Effect_exports.all({
+  containerRef: readOptional(HerdrEnvironment.workspaceId),
+  viewRef: readOptional(HerdrEnvironment.tabId),
+  executionRef: readOptional(HerdrEnvironment.paneId)
+});
+var detectHerdrContext = (cli) => Effect_exports.gen(function* () {
+  const configured = yield* readContextEnvironment.pipe(
+    Effect_exports.map((values) => ({
+      containerRef: Option_exports.getOrUndefined(values.containerRef),
+      viewRef: Option_exports.getOrUndefined(values.viewRef),
+      executionRef: Option_exports.getOrUndefined(values.executionRef)
+    })),
+    Effect_exports.mapError(
+      (cause) => new SurfaceError({
+        operation: "surface.detectContext",
+        code: SurfaceErrorCode.contextUnavailable,
+        details: { reason: "config_error" },
+        cause
+      })
+    )
+  );
+  const { containerRef, viewRef, executionRef } = configured;
+  if (containerRef === void 0 || viewRef === void 0 || executionRef === void 0) {
+    return yield* Effect_exports.fail(
+      new SurfaceError({
+        operation: "surface.detectContext",
+        code: SurfaceErrorCode.contextUnavailable,
+        details: {
+          missing: Object.entries(configured).filter(([, value]) => value === void 0).map(([name]) => name)
+        }
+      })
+    );
+  }
+  const tab = yield* cli.run([...HerdrCommand.tabGet, viewRef]).pipe(
+    Effect_exports.flatMap(parseTabInfo),
+    Effect_exports.mapError((error) => mapHerdrFailure("surface.detectContext", error))
+  );
+  const pane = yield* cli.run([...HerdrCommand.paneGet, executionRef]).pipe(
+    Effect_exports.flatMap(parsePaneInfo),
+    Effect_exports.mapError((error) => mapHerdrFailure("surface.detectContext", error))
+  );
+  if (tab.workspaceId !== containerRef || pane.workspaceId !== containerRef || pane.tabId !== viewRef) {
+    return yield* Effect_exports.fail(
+      new SurfaceError({
+        operation: "surface.detectContext",
+        code: SurfaceErrorCode.contextUnavailable,
+        details: { reason: "context_mismatch" }
+      })
+    );
+  }
+  return { providerAlias: "herdr", containerRef, viewRef, executionRef };
+});
+
+// packages/surface-herdr/src/runtime/shellQuote.ts
+var ENVIRONMENT_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var quoteShellWord = (value) => `'${value.replaceAll("'", `'"'"'`)}'`;
+var parseHerdrEnvironment = (environment) => {
+  const entries = Object.entries(environment ?? {});
+  const invalidName = entries.find(([name]) => !ENVIRONMENT_NAME.test(name));
+  return invalidName === void 0 ? Effect_exports.succeed(entries) : Effect_exports.fail(
+    new SurfaceError({
+      operation: "surface.launch",
+      code: SurfaceErrorCode.invalidRequest,
+      details: { field: "command.environment", name: invalidName[0] }
+    })
+  );
+};
+var buildHerdrCommandLine = (command) => {
+  if (command.executable === "") {
+    return Effect_exports.fail(
+      new SurfaceError({
+        operation: "surface.launch",
+        code: SurfaceErrorCode.invalidRequest,
+        details: { field: "command.executable" }
+      })
+    );
+  }
+  return Effect_exports.succeed(
+    [command.executable, ...command.arguments ?? []].map(quoteShellWord).join(" ")
+  );
+};
+
+// packages/surface-herdr/src/runtime/herdrLaunch.ts
+var HERDR_SURFACE_ALIAS = "herdr";
+var rollbackExact = (operations, tabId, primary) => operations.closeTab(tabId).pipe(
+  Effect_exports.matchEffect({
+    onFailure: (rollback) => Effect_exports.fail(new HerdrRollbackError({ operation: "surface.launch", primary, rollback })),
+    onSuccess: () => Effect_exports.fail(primary)
+  })
+);
+var rollbackUnknown = (operations, containerRef, previousIds, label, primary) => operations.listTabs(containerRef).pipe(
+  Effect_exports.flatMap((tabs) => {
+    const candidates = tabs.filter((tab) => !previousIds.has(tab.tabId) && tab.label === label);
+    if (candidates.length === 0) return Effect_exports.fail(primary);
+    if (candidates.length === 1) {
+      const candidate = candidates[0];
+      return candidate === void 0 ? Effect_exports.fail(primary) : rollbackExact(operations, candidate.tabId, primary);
+    }
+    return Effect_exports.fail(
+      new HerdrRollbackError({
+        operation: "surface.launch.reconcile",
+        primary,
+        rollback: new HerdrEnvelopeError({
+          operation: "herdr.tab.list",
+          expectedKind: "single_new_tab",
+          cause: { candidateIds: candidates.map((tab) => tab.tabId) }
+        })
+      })
+    );
+  }),
+  Effect_exports.catchAll(
+    (rollback) => rollback === primary ? Effect_exports.fail(primary) : Effect_exports.fail(
+      rollback._tag === "HerdrRollbackError" ? rollback : new HerdrRollbackError({ operation: "surface.launch", primary, rollback })
+    )
+  )
+);
+var launchHerdrSurface = (cli, operations, request) => Effect_exports.gen(function* () {
+  const context = yield* detectHerdrContext(cli);
+  const commandLine = yield* buildHerdrCommandLine(request.command);
+  const environment = yield* parseHerdrEnvironment(request.command.environment);
+  const surfaceName = makeCampSurfaceName(request.project);
+  const mapFailure = (error) => mapHerdrFailure("surface.launch", error);
+  const before = yield* operations.listTabs(context.containerRef).pipe(Effect_exports.mapError(mapFailure));
+  const previousIds = new Set(before.map((tab) => tab.tabId));
+  const created = yield* operations.createTab(context, request.project.cwd, surfaceName, environment).pipe(
+    Effect_exports.catchAll(
+      (primary) => rollbackUnknown(operations, context.containerRef, previousIds, surfaceName, primary)
+    ),
+    Effect_exports.mapError(mapFailure)
+  );
+  if (created.workspaceId !== context.containerRef || created.tabId === context.viewRef || created.paneId === context.executionRef) {
+    const primary = new HerdrEnvelopeError({
+      operation: "herdr.tab.create",
+      expectedKind: "sibling_tab"
+    });
+    return yield* rollbackExact(operations, created.tabId, primary).pipe(
+      Effect_exports.mapError(mapFailure)
+    );
+  }
+  yield* operations.runPane(created.paneId, commandLine, Object.values(request.command.environment ?? {})).pipe(
+    Effect_exports.catchAll((primary) => rollbackExact(operations, created.tabId, primary)),
+    Effect_exports.mapError(mapFailure)
+  );
+  return {
+    providerAlias: HERDR_SURFACE_ALIAS,
+    containerRef: created.workspaceId,
+    viewRef: created.tabId,
+    executionRef: created.paneId,
+    originViewRef: context.viewRef,
+    ownership: SurfaceOwnership.created
+  };
+});
+
+// packages/surface-herdr/src/runtime/herdrOperations.ts
+var statusByActivity = {
+  [SurfaceActivity.blocked]: "blocked",
+  [SurfaceActivity.idle]: "idle",
+  [SurfaceActivity.unknown]: "unknown",
+  [SurfaceActivity.working]: "working"
+};
+var readLines = (options) => Math.max(1, Math.min(options?.maxLines ?? 200, 1e4));
+var makeHerdrOperations = (cli) => {
+  const getTab = (tabId) => cli.run([...HerdrCommand.tabGet, tabId]).pipe(
+    Effect_exports.flatMap(parseTabInfo),
+    Effect_exports.map(Option_exports.some),
+    Effect_exports.catchTag(
+      "HerdrApiError",
+      (error) => error.code === HerdrApiErrorCode.tabNotFound ? Effect_exports.succeed(Option_exports.none()) : Effect_exports.fail(error)
+    )
+  );
+  const getPane = (paneId) => cli.run([...HerdrCommand.paneGet, paneId]).pipe(
+    Effect_exports.flatMap(parsePaneInfo),
+    Effect_exports.map(Option_exports.some),
+    Effect_exports.catchTag(
+      "HerdrApiError",
+      (error) => error.code === HerdrApiErrorCode.paneNotFound ? Effect_exports.succeed(Option_exports.none()) : Effect_exports.fail(error)
+    )
+  );
+  const listTabs = (workspaceId) => cli.run([...HerdrCommand.tabList, HerdrFlag.workspace, workspaceId]).pipe(Effect_exports.flatMap(parseTabList));
+  const createTab = (context, cwd, label, environment) => cli.run(
+    [
+      ...HerdrCommand.tabCreate,
+      HerdrFlag.workspace,
+      context.containerRef,
+      HerdrFlag.cwd,
+      cwd,
+      HerdrFlag.label,
+      label,
+      ...environment.flatMap(([name, value]) => [HerdrFlag.env, `${name}=${value}`]),
+      HerdrFlag.noFocus
+    ],
+    {
+      displayArgs: [
+        ...HerdrCommand.tabCreate,
+        HerdrFlag.workspace,
+        context.containerRef,
+        HerdrFlag.cwd,
+        cwd,
+        HerdrFlag.label,
+        label,
+        ...environment.flatMap(([name]) => [HerdrFlag.env, `${name}=<redacted>`]),
+        HerdrFlag.noFocus
+      ],
+      redactValues: environment.map(([, value]) => value)
+    }
+  ).pipe(Effect_exports.flatMap(parseTabCreated));
+  const runPane = (paneId, commandLine, secretValues) => cli.run([...HerdrCommand.paneRun, paneId, commandLine], {
+    displayArgs: [...HerdrCommand.paneRun, paneId, "<redacted-command>"],
+    redactValues: secretValues,
+    responseMode: HerdrResponseMode.emptyOk
+  }).pipe(Effect_exports.asVoid);
+  const focusTab = (tabId) => cli.run([...HerdrCommand.tabFocus, tabId]).pipe(
+    Effect_exports.flatMap(parseFocusedTab),
+    Effect_exports.filterOrFail(
+      (tab) => tab.tabId === tabId && tab.focused,
+      (tab) => new HerdrEnvelopeError({
+        operation: "herdr.tab.focus",
+        expectedKind: "focused_tab_info",
+        cause: `received tab ${tab.tabId}, focused=${String(tab.focused)}`
+      })
+    ),
+    Effect_exports.asVoid
+  );
+  const readPane = (paneId, options) => cli.run(
+    [
+      ...HerdrCommand.paneRead,
+      paneId,
+      HerdrFlag.source,
+      HerdrReadSource.visible,
+      HerdrFlag.lines,
+      String(readLines(options)),
+      HerdrFlag.format,
+      HerdrOutputFormat.text
+    ],
+    { responseMode: HerdrResponseMode.raw }
+  ).pipe(
+    Effect_exports.flatMap(
+      (value) => isHerdrRawOutput(value) ? Effect_exports.succeed(value) : Effect_exports.fail(
+        new HerdrEnvelopeError({
+          operation: "herdr.pane.read",
+          expectedKind: "raw_text"
+        })
+      )
+    )
+  );
+  const reportPane = (paneId, report) => {
+    const args = [
+      ...HerdrCommand.paneReportAgent,
+      paneId,
+      HerdrFlag.source,
+      "priiisk-surface",
+      HerdrFlag.agent,
+      "camp",
+      HerdrFlag.state,
+      statusByActivity[report.activity],
+      ...report.message === void 0 ? [] : [HerdrFlag.customStatus, report.message.slice(0, 240)],
+      ...report.sequence === void 0 ? [] : [HerdrFlag.seq, String(report.sequence)]
+    ];
+    return cli.run(args, { responseMode: HerdrResponseMode.emptyOk }).pipe(Effect_exports.asVoid);
+  };
+  const closeTab = (tabId) => cli.run([...HerdrCommand.tabClose, tabId]).pipe(
+    Effect_exports.flatMap((value) => parseOk(value, "herdr.tab.close")),
+    Effect_exports.catchTag(
+      "HerdrApiError",
+      (error) => error.code === HerdrApiErrorCode.tabNotFound ? Effect_exports.void : Effect_exports.fail(error)
+    )
+  );
+  return {
+    closeTab,
+    createTab,
+    focusTab,
+    getPane,
+    getTab,
+    listTabs,
+    readPane,
+    reportPane,
+    runPane
+  };
+};
+
+// packages/surface-herdr/src/runtime/herdrCampSurface.ts
+var invalidHandle = (reason) => new SurfaceError({
+  operation: "surface.handle",
+  code: SurfaceErrorCode.invalidHandle,
+  details: { reason }
+});
+var makeHerdrCampSurface = (cli) => {
+  const operations = makeHerdrOperations(cli);
+  const mapFailure = (operation) => (error) => mapHerdrFailure(operation, error);
+  const validateProvider = (handle, operation) => ensureSurfaceHandleProvider(handle, HERDR_SURFACE_ALIAS, operation);
+  const verifyLive = (handle, operation) => validateProvider(handle, operation).pipe(
+    Effect_exports.zipRight(
+      Effect_exports.all({
+        tab: operations.getTab(handle.viewRef),
+        pane: operations.getPane(handle.executionRef)
+      }).pipe(Effect_exports.mapError(mapFailure(operation)))
+    ),
+    Effect_exports.flatMap(({ tab, pane }) => {
+      if (Option_exports.isNone(tab) || Option_exports.isNone(pane)) return Effect_exports.succeed(Option_exports.none());
+      if (tab.value.workspaceId !== handle.containerRef || pane.value.workspaceId !== handle.containerRef || pane.value.tabId !== handle.viewRef) {
+        return Effect_exports.fail(invalidHandle("provider_refs_mismatch"));
+      }
+      return Effect_exports.succeed(Option_exports.some({ tab: tab.value, pane: pane.value }));
+    })
+  );
+  return {
+    detectContext: () => detectHerdrContext(cli),
+    attachCurrent: () => detectHerdrContext(cli).pipe(
+      Effect_exports.map((context) => ({
+        ...context,
+        originViewRef: context.viewRef,
+        ownership: SurfaceOwnership.attached
+      }))
+    ),
+    launch: (request) => launchHerdrSurface(cli, operations, request),
+    inspect: (handle) => verifyLive(handle, "surface.inspect").pipe(
+      Effect_exports.map(
+        (live) => Option_exports.isNone(live) ? { presence: SurfacePresence.missing } : { presence: SurfacePresence.present, focused: live.value.tab.focused }
+      )
+    ),
+    focus: (handle) => verifyLive(handle, "surface.focus").pipe(
+      Effect_exports.filterOrFail(Option_exports.isSome, () => invalidHandle("view_missing")),
+      Effect_exports.zipRight(
+        operations.focusTab(handle.viewRef).pipe(Effect_exports.mapError(mapFailure("surface.focus")))
+      ),
+      Effect_exports.asVoid
+    ),
+    read: (handle, options) => verifyLive(handle, "surface.read").pipe(
+      Effect_exports.filterOrFail(Option_exports.isSome, () => invalidHandle("view_missing")),
+      Effect_exports.zipRight(
+        operations.readPane(handle.executionRef, options).pipe(Effect_exports.mapError(mapFailure("surface.read")))
+      ),
+      Effect_exports.map((read) => ({ text: read.text, truncated: read.truncated }))
+    ),
+    reportStatus: (handle, report) => verifyLive(handle, "surface.reportStatus").pipe(
+      Effect_exports.filterOrFail(Option_exports.isSome, () => invalidHandle("view_missing")),
+      Effect_exports.zipRight(
+        operations.reportPane(handle.executionRef, report).pipe(Effect_exports.mapError(mapFailure("surface.reportStatus")))
+      ),
+      Effect_exports.asVoid
+    ),
+    close: (handle) => validateProvider(handle, "surface.close").pipe(
+      Effect_exports.zipRight(ensureSurfaceHandleClosable(handle)),
+      Effect_exports.zipRight(verifyLive(handle, "surface.close")),
+      Effect_exports.flatMap(
+        (live) => Option_exports.isNone(live) ? Effect_exports.void : operations.closeTab(handle.viewRef).pipe(Effect_exports.mapError(mapFailure("surface.close")))
+      )
+    )
+  };
+};
+var HerdrCampSurfaceLive = Layer_exports.effect(
+  CampSurface,
+  Effect_exports.map(HerdrCli, makeHerdrCampSurface)
+);
+
+// packages/cli/src/surface/surfaceRegistry.ts
+var registrations = [
+  {
+    providerAlias: HERDR_SURFACE_ALIAS,
+    make: makeHerdrCli().pipe(Effect_exports.map(makeHerdrCampSurface))
+  }
+];
+var resolveCampSurface = (providerAlias) => {
+  const registration = registrations.find((candidate) => candidate.providerAlias === providerAlias);
+  return registration === void 0 ? Effect_exports.fail(
+    new CliSurfaceSelectionError({
+      operation: "resolve",
+      providerAlias,
+      message: `surface adapter \u043D\u0435 \u0437\u0430\u0440\u0435\u0433\u0438\u0441\u0442\u0440\u0438\u0440\u043E\u0432\u0430\u043D: ${providerAlias}`
+    })
+  ) : registration.make;
+};
+var detectCampSurface = () => Effect_exports.forEach(
+  registrations,
+  (registration) => registration.make.pipe(
+    Effect_exports.flatMap(
+      (surface) => surface.detectContext().pipe(Effect_exports.as({ registration, surface }))
+    ),
+    Effect_exports.either
+  )
+).pipe(
+  Effect_exports.flatMap((attempts) => {
+    const matches = attempts.filter(Either_exports.isRight).map((attempt) => attempt.right);
+    if (matches.length === 1) {
+      const match = matches[0];
+      return match === void 0 ? Effect_exports.die("surface registry lost its only match") : Effect_exports.succeed(match.surface);
+    }
+    if (matches.length > 1) {
+      return Effect_exports.fail(
+        new CliSurfaceSelectionError({
+          operation: "detect",
+          message: `\u043D\u0430\u0439\u0434\u0435\u043D\u043E \u043D\u0435\u0441\u043A\u043E\u043B\u044C\u043A\u043E surface contexts: ${matches.map(({ registration }) => registration.providerAlias).join(", ")}`
+        })
+      );
+    }
+    return Effect_exports.fail(
+      new CliSurfaceSelectionError({
+        operation: "detect",
+        message: "\u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D \u043F\u043E\u0434\u0434\u0435\u0440\u0436\u0438\u0432\u0430\u0435\u043C\u044B\u0439 surface context",
+        cause: attempts.filter(Either_exports.isLeft).map((attempt) => attempt.left)
+      })
+    );
+  })
+);
+
+export {
+  CliTurnWaitTimeout,
+  CliMessageSourceError,
+  CliEquipmentConflict,
+  CliCampLifecycleError,
+  CliStdioRequestInvalid,
+  CliStdioCommandCancelled,
+  CliStdioStreamFailure,
+  PRIIISK_CLI_VERSION,
+  releaseCampRpcConnection,
+  withCampRpc,
+  withCampRpcSession,
+  acceptCampGeneration,
+  resolveCampSurface,
+  detectCampSurface,
+  DoctorCheckStatus,
+  DoctorOverallStatus,
+  doctorCheck,
+  makeDoctorReport,
+  doctorErrorMessage
+};