@kitman-sh/cli 0.7.4 → 0.8.0

package/dist/{chunk-q6hk9ceb.js → chunk-8m4wzjt8.js}

@@ -3,8 +3,6 @@ import {
   dual,
   identity,
   constVoid,
-  flow,
-  hasProperty,
   assignProperty,
   isNone,
   isSome,
@@ -15,7 +13,6 @@ import {
   getOrUndefinedUnsafe,
   getUnsafe,
   get,
-  merge,
   Reference,
   isSuccess,
   toMillis,
@@ -29,7 +26,6 @@ import {
   interrupt,
   isFailure2,
   Scope,
-  provide,
   addFinalizerExit,
   addFinalizer,
   succeed4,
@@ -40,7 +36,6 @@ import {
   spaced,
   forEach,
   whileLoop,
-  succeed5,
   suspend,
   sync,
   void_2,
@@ -60,7 +55,6 @@ import {
   ignore,
   ignoreCause,
   timeout,
-  timeoutOrElse,
   delay,
   raceFirst,
   matchCauseEffect,
@@ -68,11 +62,8 @@ import {
   contextWith,
   provideContext,
   serviceOption,
-  updateContext,
   updateService,
-  scope,
   scoped,
-  acquireRelease,
   ensuring,
   onError,
   onExit,
@@ -100,375 +91,24 @@ import {
   shutdownUnsafe,
   fromQueue,
   unwrap,
-  empty3,
+  empty2,
   fromInput,
-  merge3,
+  merge2,
   decodeUnknownEffect,
   decodeSync,
   encodeEffect,
-  optional,
-  String2,
   NonEmptyArray,
-  Union,
-  Literals,
-  tag,
-  Int,
   Defect,
-  Error2,
-  TaggedError2,
   toCodecJson,
-  HttpClientErrorSchema,
+  Socket,
+  SocketReadError,
+  SocketError,
   isStreamSchema,
   getStreamSchemas,
-  exitSchema
-} from "./chunk-jd09xfx0.js";
-
-// node_modules/.bun/effect@4.0.4/node_modules/effect/dist/socket/Socket.js
-var TypeId = "~effect/socket/Socket";
-var Socket = /* @__PURE__ */ Service("effect/socket/Socket");
-var make4 = (options) => Socket.of({
-  [TypeId]: TypeId,
-  reader: options.reader,
-  writer: options.writer
-});
-var encoder = /* @__PURE__ */ new TextEncoder;
-var readerString = (self, encoding) => map3(self.reader, ({
-  pull
-}) => {
-  const decoder = new TextDecoder(encoding);
-  return map3(pull, (chunk) => {
-    const out = new Array(chunk.length);
-    for (let i = 0;i < chunk.length; i++) {
-      const item = chunk[i];
-      out[i] = typeof item === "string" ? item : decoder.decode(item);
-    }
-    return out;
-  });
-});
-var CloseEventTypeId = "~effect/socket/Socket/CloseEvent";
-var isCloseEvent = (u) => hasProperty(u, CloseEventTypeId);
-var SocketErrorTypeId = "~effect/socket/Socket/SocketError";
-var isSocketError = (u) => hasProperty(u, SocketErrorTypeId);
-
-class SocketReadError extends (/* @__PURE__ */ Error2("effect/socket/Socket/SocketReadError")({
-  _tag: /* @__PURE__ */ tag("SocketReadError"),
-  cause: /* @__PURE__ */ Defect()
-})) {
-  message = `An error occurred during Read`;
-}
-
-class SocketWriteError extends (/* @__PURE__ */ Error2("effect/socket/Socket/SocketWriteError")({
-  _tag: /* @__PURE__ */ tag("SocketWriteError"),
-  cause: /* @__PURE__ */ Defect()
-})) {
-  message = `An error occurred during Write`;
-}
-
-class SocketOpenError extends (/* @__PURE__ */ Error2("effect/socket/Socket/SocketOpenError")({
-  _tag: /* @__PURE__ */ tag("SocketOpenError"),
-  kind: /* @__PURE__ */ Literals(["Unknown", "Timeout"]),
-  cause: /* @__PURE__ */ Defect()
-})) {
-  get message() {
-    return this.kind === "Timeout" ? `timeout waiting for "open"` : `An error occurred during Open`;
-  }
-}
-
-class SocketUpgradeError extends (/* @__PURE__ */ Error2("effect/socket/Socket/SocketUpgradeError")({
-  _tag: /* @__PURE__ */ tag("SocketUpgradeError"),
-  cause: /* @__PURE__ */ optional(/* @__PURE__ */ Defect())
-})) {
-  static unsupported = () => fail4(new SocketError({
-    reason: new SocketUpgradeError({})
-  }));
-  get message() {
-    return this.cause === undefined ? `Socket does not support TLS upgrade` : `An error occurred during TLS upgrade`;
-  }
-}
-
-class SocketCloseError extends (/* @__PURE__ */ Error2("effect/socket/Socket/SocketCloseError")({
-  _tag: /* @__PURE__ */ tag("SocketCloseError"),
-  code: Int,
-  closeReason: /* @__PURE__ */ optional(String2)
-})) {
-  get message() {
-    if (this.closeReason) {
-      return `${this.code}: ${this.closeReason}`;
-    }
-    return `${this.code}`;
-  }
-}
-var SocketErrorReason = /* @__PURE__ */ Union([SocketReadError, SocketWriteError, SocketOpenError, SocketUpgradeError, SocketCloseError]);
-
-class SocketError extends (/* @__PURE__ */ TaggedError2(SocketErrorTypeId)("SocketError", {
-  _tag: /* @__PURE__ */ tag("SocketError"),
-  reason: SocketErrorReason
-})) {
-  constructor(props) {
-    if ("cause" in props.reason) {
-      super({
-        ...props,
-        cause: props.reason.cause
-      });
-    } else {
-      super(props);
-    }
-  }
-  [SocketErrorTypeId] = SocketErrorTypeId;
-  static is(u) {
-    return isSocketError(u);
-  }
-  message = this.reason.message;
-}
-var closeError = (code, closeReason) => new SocketError({
-  reason: new SocketCloseError({
-    code,
-    closeReason
-  })
-});
-class WebSocketConstructor extends (/* @__PURE__ */ Service()("@effect/platform/Socket/WebSocketConstructor")) {
-}
-var layerWebSocketConstructorGlobal = /* @__PURE__ */ succeed4(WebSocketConstructor)((url, options) => {
-  if (options !== undefined && typeof options !== "string" && !Array.isArray(options)) {
-    throw new TypeError("WebSocket client options are not supported by the global WebSocket constructor");
-  }
-  return new globalThis.WebSocket(url, options);
-});
-var makeWebSocket = (url, options) => WebSocketConstructor.use((makeWs) => fromWebSocket(acquireRelease((typeof url === "string" ? succeed5(url) : url).pipe(map3((url) => makeWs(url, options?.headers === undefined ? options?.protocols : {
-  protocols: options.protocols,
-  headers: options.headers
-}))), (ws) => sync(() => ws.close(1000))), options));
-var isPausable = (ws) => ("pause" in ws) && typeof ws.pause === "function";
-var fromWebSocket = (acquire, options) => withFiber((fiber) => {
-  let currentWS;
-  const latch = makeUnsafe3(false);
-  const acquireContext = fiber.context;
-  const reader = gen(function* () {
-    const scope2 = yield* scope;
-    const ws = yield* provide(acquire, scope2);
-    if ("binaryType" in ws) {
-      ws.binaryType = "arraybuffer";
-    }
-    const pausable = isPausable(ws);
-    const highWaterMark = options?.highWaterMark ?? (pausable ? defaultHighWaterMark : undefined);
-    let open = ws.readyState === 1;
-    let paused = pausable && "isPaused" in ws && ws.isPaused === true;
-    let buffer = [];
-    let bufferSize = 0;
-    let error;
-    let waiter;
-    let openWaiter;
-    function pauseWebSocket() {
-      if (!pausable || paused)
-        return;
-      ws.pause();
-      paused = true;
-    }
-    function resumeWebSocket() {
-      if (!pausable || !paused)
-        return;
-      ws.resume();
-      paused = false;
-    }
-    function takeBuffer() {
-      const chunk = buffer;
-      buffer = [];
-      bufferSize = 0;
-      if (error === undefined)
-        resumeWebSocket();
-      return chunk;
-    }
-    function deliver() {
-      if (waiter === undefined || buffer.length === 0)
-        return;
-      const resume = waiter;
-      waiter = undefined;
-      resume(succeed5(takeBuffer()));
-    }
-    function push(data) {
-      buffer.push(data);
-      if (highWaterMark !== undefined) {
-        bufferSize += typeof data === "string" ? encoder.encode(data).byteLength : data.byteLength;
-      }
-      if (waiter !== undefined)
-        deliver();
-      if (pausable && bufferSize >= highWaterMark) {
-        pauseWebSocket();
-      } else if (!pausable && !waiter && highWaterMark !== undefined && bufferSize > highWaterMark) {
-        fail(new SocketError({
-          reason: new SocketReadError({
-            cause: new Error(`Socket highWaterMark of ${highWaterMark} bytes exceeded`)
-          })
-        }));
-      }
-    }
-    function fail(err) {
-      if (error === undefined)
-        error = err;
-      if (openWaiter !== undefined) {
-        const {
-          cleanup,
-          resume
-        } = openWaiter;
-        openWaiter = undefined;
-        cleanup();
-        resume(fail4(error));
-      }
-      if (waiter !== undefined) {
-        const resume = waiter;
-        waiter = undefined;
-        resume(buffer.length > 0 ? succeed5(takeBuffer()) : fail4(error));
-      }
-    }
-    function onMessage(event) {
-      const data = event.data;
-      if (typeof Blob !== "undefined" && data instanceof Blob) {
-        data.arrayBuffer().then((buf) => push(new Uint8Array(buf)), (cause) => {
-          fail(new SocketError({
-            reason: new SocketReadError({
-              cause
-            })
-          }));
-        });
-        return;
-      }
-      push(data instanceof ArrayBuffer ? new Uint8Array(data) : data);
-    }
-    function onError(event) {
-      fail(new SocketError({
-        reason: open ? new SocketReadError({
-          cause: event
-        }) : new SocketOpenError({
-          kind: "Unknown",
-          cause: event
-        })
-      }));
-    }
-    function onClose(event) {
-      fail(closeError(typeof event.code === "number" ? event.code : 1006, event.reason));
-    }
-    ws.addEventListener("message", onMessage);
-    ws.addEventListener("error", onError, {
-      once: true
-    });
-    ws.addEventListener("close", onClose, {
-      once: true
-    });
-    yield* addFinalizer(scope2, sync(() => {
-      fail(closeError(1006));
-      ws.removeEventListener("message", onMessage);
-      ws.removeEventListener("error", onError);
-      ws.removeEventListener("close", onClose);
-      if (pausable) {
-        try {
-          resumeWebSocket();
-        } catch {}
-      }
-      latch.closeUnsafe();
-      currentWS = undefined;
-    }));
-    if (ws.readyState >= 2) {
-      return yield* fail4(error ?? closeError(1006));
-    }
-    if (!open) {
-      yield* callback((resume) => {
-        const onOpen = () => {
-          if (openWaiter?.resume !== resume)
-            return;
-          openWaiter = undefined;
-          ws.removeEventListener("open", onOpen);
-          resume(void_2);
-        };
-        const cleanup = () => ws.removeEventListener("open", onOpen);
-        openWaiter = {
-          resume,
-          cleanup
-        };
-        ws.addEventListener("open", onOpen, {
-          once: true
-        });
-        return sync(() => {
-          if (openWaiter?.resume === resume)
-            openWaiter = undefined;
-          cleanup();
-        });
-      }).pipe(timeoutOrElse({
-        duration: options?.openTimeout ?? 1e4,
-        orElse: () => fail4(new SocketError({
-          reason: new SocketOpenError({
-            kind: "Timeout",
-            cause: new Error('timeout waiting for "open"')
-          })
-        }))
-      }));
-      open = true;
-    }
-    if (error === undefined && bufferSize < highWaterMark)
-      resumeWebSocket();
-    currentWS = ws;
-    latch.openUnsafe();
-    return {
-      pull: callback((resume) => {
-        if (buffer.length > 0)
-          return resume(succeed5(takeBuffer()));
-        if (error !== undefined)
-          return resume(fail4(error));
-        waiter = resume;
-        return sync(() => {
-          if (waiter === resume)
-            waiter = undefined;
-        });
-      }),
-      upgrade: SocketUpgradeError.unsupported
-    };
-  }).pipe(updateContext((input) => merge(acquireContext, input)));
-  const write = (chunk) => suspend(() => {
-    const ws = currentWS;
-    if (ws === undefined)
-      return latch.whenOpen(write(chunk));
-    try {
-      if (isCloseEvent(chunk)) {
-        ws.close(chunk.code, chunk.reason);
-      } else {
-        ws.send(chunk);
-      }
-      return void_2;
-    } catch (cause) {
-      return fail4(new SocketError({
-        reason: new SocketWriteError({
-          cause
-        })
-      }));
-    }
-  });
-  const writeAll = (chunks) => suspend(() => {
-    const ws = currentWS;
-    if (ws === undefined)
-      return latch.whenOpen(writeAll(chunks));
-    try {
-      for (let i = 0;i < chunks.length; i++) {
-        ws.send(chunks[i]);
-      }
-      return void_2;
-    } catch (cause) {
-      return fail4(new SocketError({
-        reason: new SocketWriteError({
-          cause
-        })
-      }));
-    }
-  });
-  const writer = succeed5({
-    write,
-    writeAll
-  });
-  return succeed5(make4({
-    reader,
-    writer
-  }));
-});
-var defaultHighWaterMark = 64 * 1024;
-var layerWebSocket = /* @__PURE__ */ flow(makeWebSocket, /* @__PURE__ */ effect(Socket));
+  exitSchema,
+  RpcClientDefect,
+  RpcClientError
+} from "./chunk-fpyy4rpd.js";
 
 // node_modules/.bun/effect@4.0.4/node_modules/effect/dist/workers/Transferable.js
 class Collector extends (/* @__PURE__ */ Service()("effect/workers/Transferable/Collector")) {
@@ -494,36 +134,6 @@ var makeCollectorUnsafe = () => {
   });
 };
 
-// node_modules/.bun/effect@4.0.4/node_modules/effect/dist/workers/WorkerError.js
-class WorkerSpawnError extends (/* @__PURE__ */ Error2("effect/workers/WorkerError/WorkerSpawnError")({
-  _tag: /* @__PURE__ */ tag("WorkerSpawnError"),
-  message: String2,
-  cause: /* @__PURE__ */ optional(/* @__PURE__ */ Defect())
-})) {
-}
-
-class WorkerSendError extends (/* @__PURE__ */ Error2("effect/workers/WorkerError/WorkerSendError")({
-  _tag: /* @__PURE__ */ tag("WorkerSendError"),
-  message: String2,
-  cause: /* @__PURE__ */ optional(/* @__PURE__ */ Defect())
-})) {
-}
-
-class WorkerReceiveError extends (/* @__PURE__ */ Error2("effect/workers/WorkerError/WorkerReceiveError")({
-  _tag: /* @__PURE__ */ tag("WorkerReceiveError"),
-  message: String2,
-  cause: /* @__PURE__ */ optional(/* @__PURE__ */ Defect())
-})) {
-}
-
-class WorkerUnknownError extends (/* @__PURE__ */ Error2("effect/workers/WorkerError/WorkerUnknownError")({
-  _tag: /* @__PURE__ */ tag("WorkerUnknownError"),
-  message: String2,
-  cause: /* @__PURE__ */ optional(/* @__PURE__ */ Defect())
-})) {
-}
-var WorkerErrorReason = /* @__PURE__ */ Union([WorkerSpawnError, WorkerSendError, WorkerReceiveError, WorkerUnknownError]);
-
 // node_modules/.bun/effect@4.0.4/node_modules/effect/dist/rpc/internal/tracing.js
 var spanName = (spanPrefix, tag) => spanPrefix === undefined ? tag : `${spanPrefix}.${tag}`;
 var spanAttributes = (tag, attributes) => ({
@@ -532,26 +142,6 @@ var spanAttributes = (tag, attributes) => ({
   ...attributes
 });
 
-// node_modules/.bun/effect@4.0.4/node_modules/effect/dist/rpc/RpcClientError.js
-var TypeId2 = "~effect/rpc/RpcClientError";
-
-class RpcClientDefect extends (/* @__PURE__ */ Error2("effect/rpc/RpcClientError/RpcClientDefect")({
-  _tag: /* @__PURE__ */ tag("RpcClientDefect"),
-  message: String2,
-  cause: /* @__PURE__ */ Defect()
-})) {
-}
-
-class RpcClientError extends (/* @__PURE__ */ Error2(TypeId2)({
-  _tag: /* @__PURE__ */ tag("RpcClientError"),
-  reason: /* @__PURE__ */ Union([WorkerErrorReason, SocketErrorReason, HttpClientErrorSchema, RpcClientDefect])
-})) {
-  [TypeId2] = TypeId2;
-  get message() {
-    return `${this.reason._tag}: ${this.reason.message}`;
-  }
-}
-
 // node_modules/.bun/effect@4.0.4/node_modules/effect/dist/rpc/RpcMessage.js
 var RequestId = (id) => id;
 var constPing = {
@@ -653,7 +243,7 @@ var makeNoSerialization = /* @__PURE__ */ fnUntraced(function* (group, options)
     const isStream = isStreamSchema(rpc.successSchema);
     const middleware = getRpcClientMiddleware(rpc);
     return (payload, opts) => {
-      const headers = opts?.headers ? fromInput(opts.headers) : empty3;
+      const headers = opts?.headers ? fromInput(opts.headers) : empty2;
       const context = opts?.context ?? empty();
       if (!isStream) {
         const onRequest = (span) => onEffectRequest(rpc, middleware, span, rpc.payloadSchema.make(payload), headers, context, opts?.discard ?? false);
@@ -687,7 +277,7 @@ var makeNoSerialization = /* @__PURE__ */ fnUntraced(function* (group, options)
         spanId: span.spanId,
         sampled: span.sampled
       } : {},
-      headers: merge3(parentFiber.getRef(CurrentHeaders), headers)
+      headers: merge2(parentFiber.getRef(CurrentHeaders), headers)
     });
     if (discard) {
       return send;
@@ -761,7 +351,7 @@ var makeNoSerialization = /* @__PURE__ */ fnUntraced(function* (group, options)
         spanId: span.spanId,
         sampled: span.sampled
       } : {},
-      headers: merge3(fiber.getRef(CurrentHeaders), headers)
+      headers: merge2(fiber.getRef(CurrentHeaders), headers)
     }).pipe(span ? withParentSpan(span, {
       captureStackTrace: false
     }) : identity, onError((cause) => failCause3(queue, cause)), interruptible, forkIn(scope, {
@@ -867,7 +457,7 @@ var makeNoSerialization = /* @__PURE__ */ fnUntraced(function* (group, options)
   };
 });
 var clientIdCounter = 0;
-var make5 = /* @__PURE__ */ fnUntraced(function* (group, options) {
+var make4 = /* @__PURE__ */ fnUntraced(function* (group, options) {
   const clientId = clientIdCounter++;
   const {
     codecFor,
@@ -1015,9 +605,9 @@ var makeRpcSchemas = (codecFor) => {
   };
 };
 var CurrentHeaders = /* @__PURE__ */ Reference("effect/rpc/RpcClient/CurrentHeaders", {
-  defaultValue: () => empty3
+  defaultValue: () => empty2
 });
-var withHeaders = /* @__PURE__ */ dual(2, (effect, headers) => updateService(effect, CurrentHeaders, merge3(fromInput(headers))));
+var withHeaders = /* @__PURE__ */ dual(2, (effect, headers) => updateService(effect, CurrentHeaders, merge2(fromInput(headers))));
 
 class Protocol extends (/* @__PURE__ */ Service()("effect/rpc/RpcClient/Protocol")) {
   static make = withRunClient;
@@ -1175,4 +765,4 @@ var layerProtocolSocket = (options) => effect(Protocol)(makeProtocolSocket(optio
 class ConnectionHooks extends (/* @__PURE__ */ Service()("effect/rpc/RpcClient/ConnectionHooks")) {
 }
 
-export { make4, readerString, isCloseEvent, SocketReadError, SocketWriteError, SocketOpenError, SocketUpgradeError, SocketCloseError, SocketError, WebSocketConstructor, layerWebSocketConstructorGlobal, layerWebSocket, layerJson, make5, withHeaders, layerProtocolSocket, ConnectionHooks };
+export { layerJson, make4, withHeaders, layerProtocolSocket, ConnectionHooks };

package/dist/chunk-ad124cbc.js

@@ -0,0 +1,132 @@
+// @bun
+import {
+  getOrElse,
+  TaggedError,
+  currentTimeMillis,
+  forEach,
+  tryPromise,
+  sync,
+  gen,
+  flatMap2,
+  andThen,
+  map3,
+  scoped,
+  runForEach,
+  FileSystem,
+  is,
+  encodeEffect,
+  optionalKey,
+  String2,
+  Record,
+  ArraySchema,
+  Union,
+  TaggedStruct,
+  fromJsonString,
+  TaggedError2,
+  toCodecJson,
+  Json,
+  guard,
+  ProgramWorkUnit,
+  RunFileRefused,
+  runFileContentType,
+  sha256Hasher,
+  put,
+  setHeaders,
+  bodyUint8Array,
+  filterStatusOk,
+  HttpClient,
+  RunnerRpcError
+} from "./chunk-fpyy4rpd.js";
+import {
+  LoopManifest,
+  ManifestInvalid,
+  make,
+  Suspended,
+  LoopCheckError
+} from "./chunk-2npvts4c.js";
+
+// packages/sdk/src/program/engine.ts
+class JournalWriteFailed extends TaggedError("JournalWriteFailed") {
+  get message() {
+    return `Journal write failed: ${this.cause.message}`;
+  }
+}
+var JournalEntries = Record(String2, Json);
+var isSuspended = is(Suspended);
+var emptyWorkflow = make("kitman-loop/none", { payload: {}, idempotencyKey: () => "none" });
+var replayStatuses = new Set([401, 403, 409, 429]);
+var isRunnerRpcError = is(RunnerRpcError);
+var isRunFileRefused = is(RunFileRefused);
+var put2 = (target, contentType, body) => gen(function* () {
+  const response = yield* (yield* HttpClient).execute(put(target.url).pipe(bodyUint8Array(body, contentType), setHeaders(target.headers ?? {})));
+  return (yield* filterStatusOk(response)).headers.etag ?? "";
+});
+var readRange = (path, offset, size) => scoped(gen(function* () {
+  const file = yield* (yield* FileSystem).open(path);
+  return getOrElse(yield* file.readAlloc(size, { position: BigInt(offset) }), () => new Uint8Array);
+}));
+var partUrlMarginMillis = 60000;
+var uploadParts = (files, path, contentType, fileId, upload) => forEach(upload.parts, (part) => gen(function* () {
+  const now = yield* currentTimeMillis;
+  const fresh = Date.parse(part.expiresAt) - now > partUrlMarginMillis ? part : (yield* files.runFileParts({ fileId, partNumbers: [part.partNumber] }))[0] ?? part;
+  const body = yield* readRange(path, (part.partNumber - 1) * upload.partSize, upload.partSize);
+  return { partNumber: part.partNumber, etag: yield* put2(fresh, contentType, body) };
+}));
+var uploadRunFile = (files, file) => gen(function* () {
+  const fs = yield* FileSystem;
+  const contentType = runFileContentType(file.name);
+  const byteSize = Number((yield* fs.stat(file.path)).size);
+  const hash = sha256Hasher();
+  yield* runForEach(fs.stream(file.path), (chunk) => sync(() => hash.update(chunk)));
+  const { file: slotted, upload } = yield* files.createRunFile({
+    step: file.step,
+    name: file.name,
+    ...file.caption === undefined ? undefined : { caption: file.caption },
+    contentType,
+    byteSize,
+    sha256: hash.digest("hex")
+  });
+  if (upload === undefined)
+    return slotted;
+  return yield* upload.kind === "single" ? readRange(file.path, 0, byteSize).pipe(flatMap2((body) => put2(upload, contentType, body)), andThen(files.completeRunFile({ fileId: slotted.id }))) : flatMap2(uploadParts(files, file.path, contentType, slotted.id, upload), (parts) => files.completeRunFile({ fileId: slotted.id, parts }));
+});
+var programLease = (work) => ({
+  workUnitId: work.id,
+  leaseOwnerId: work.lease.leaseOwnerId,
+  runnerReplicaId: work.lease.runnerReplicaId,
+  leaseId: work.lease.leaseId,
+  attempt: work.lease.attempt,
+  fencingToken: work.lease.fencingToken,
+  capacitySlot: work.lease.capacitySlot
+});
+var rpcRunFiles = (rpc, lease) => ({
+  createRunFile: (file) => rpc.createRunFile({ lease, ...file }),
+  runFileParts: (request) => map3(rpc.runFileParts({ lease, ...request, partNumbers: [...request.partNumbers] }), ({ parts }) => parts),
+  completeRunFile: ({ parts, ...request }) => rpc.completeRunFile({ lease, ...request, ...parts === undefined ? undefined : { parts: [...parts] } })
+});
+
+// packages/sdk/src/program/host.ts
+var describeFlag = "--kitman-describe";
+var Described = Union([
+  TaggedStruct("Described", {
+    loops: ArraySchema(LoopManifest),
+    agents: Record(String2, Json),
+    schedules: optionalKey(Record(String2, Json)),
+    kits: optionalKey(Record(String2, Json))
+  }),
+  TaggedStruct("Refused", { error: Union([ManifestInvalid, LoopCheckError]) })
+]);
+var encodeDescribed = encodeEffect(fromJsonString(toCodecJson(Described)));
+
+class ProgramRefused extends TaggedError2()("ProgramRefused", { reason: String2 }) {
+  get message() {
+    return this.reason;
+  }
+}
+var programHostsEnv = "KITMAN_PROGRAM_HOSTS";
+var undeclaredHostsEnv = "KITMAN_UNDECLARED_HOSTS";
+var redirectStatuses = new Set([301, 302, 303, 307, 308]);
+var readStdin = tryPromise(() => Bun.stdin.text());
+var isWorkUnit = guard(ProgramWorkUnit);
+
+export { uploadRunFile, programLease, rpcRunFiles, describeFlag, Described, programHostsEnv, undeclaredHostsEnv };

package/dist/{chunk-20nwe9zd.js → chunk-dbtnt79b.js}

@@ -3,7 +3,7 @@ import {
   Random,
   succeed5,
   withFiber
-} from "./chunk-jd09xfx0.js";
+} from "./chunk-fpyy4rpd.js";
 
 // node_modules/.bun/effect@4.0.4/node_modules/effect/dist/Random.js
 var Random2 = Random;