@ricsam/r5d-worker 0.0.136 → 0.0.138

package/dist/types/runtime/workspace/storage-wire.d.ts

@@ -0,0 +1,138 @@
+import { z } from "zod";
+/** Client-side v1 wire contract only. No server/control/catalog filesystem imports.
+ * Keep matched to storage RPC; integration tests exercise the real authenticated parser.
+ */
+export declare const STORAGE_LIMITS: {
+    readonly chunkBytes: number;
+    readonly blobBytes: number;
+    readonly requestBytes: number;
+    readonly treeEntries: 10000;
+};
+export declare const StorageId: z.ZodString;
+export declare const GitOid: z.ZodString;
+export declare const BranchName: z.ZodString;
+export declare const StorageRequest: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    method: z.ZodLiteral<"hello">;
+}, z.core.$strict>, z.ZodObject<{
+    method: z.ZodLiteral<"repository.get">;
+    repositoryId: z.ZodString;
+    branch: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    method: z.ZodLiteral<"repository.bundle">;
+    repositoryId: z.ZodString;
+    snapshot: z.ZodNullable<z.ZodString>;
+    offset: z.ZodNumber;
+    limit: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    method: z.ZodLiteral<"operation.get">;
+    lookupId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    repositoryId: z.ZodString;
+    operationId: z.ZodString;
+    fence: z.ZodObject<{
+        installationId: z.ZodString;
+        resourceType: z.ZodString;
+        resourceId: z.ZodString;
+        ownerId: z.ZodString;
+        epoch: z.ZodNumber;
+    }, z.core.$strict>;
+    callerFence: z.ZodObject<{
+        installationId: z.ZodString;
+        resourceType: z.ZodString;
+        resourceId: z.ZodString;
+        ownerId: z.ZodString;
+        epoch: z.ZodNumber;
+    }, z.core.$strict>;
+    method: z.ZodLiteral<"repository.provision">;
+}, z.core.$strict>, z.ZodObject<{
+    repositoryId: z.ZodString;
+    operationId: z.ZodString;
+    fence: z.ZodObject<{
+        installationId: z.ZodString;
+        resourceType: z.ZodString;
+        resourceId: z.ZodString;
+        ownerId: z.ZodString;
+        epoch: z.ZodNumber;
+    }, z.core.$strict>;
+    callerFence: z.ZodObject<{
+        installationId: z.ZodString;
+        resourceType: z.ZodString;
+        resourceId: z.ZodString;
+        ownerId: z.ZodString;
+        epoch: z.ZodNumber;
+    }, z.core.$strict>;
+    method: z.ZodLiteral<"repository.initializeAccount">;
+}, z.core.$strict>, z.ZodObject<{
+    repositoryId: z.ZodString;
+    branch: z.ZodString;
+    expectedHead: z.ZodNullable<z.ZodString>;
+    operationId: z.ZodString;
+    fence: z.ZodObject<{
+        installationId: z.ZodString;
+        resourceType: z.ZodString;
+        resourceId: z.ZodString;
+        ownerId: z.ZodString;
+        epoch: z.ZodNumber;
+    }, z.core.$strict>;
+    callerFence: z.ZodObject<{
+        installationId: z.ZodString;
+        resourceType: z.ZodString;
+        resourceId: z.ZodString;
+        ownerId: z.ZodString;
+        epoch: z.ZodNumber;
+    }, z.core.$strict>;
+    method: z.ZodLiteral<"repository.archive">;
+}, z.core.$strict>, z.ZodObject<{
+    repositoryId: z.ZodString;
+    branch: z.ZodString;
+    expectedHead: z.ZodNullable<z.ZodString>;
+    commit: z.ZodString;
+    bundleId: z.ZodString;
+    operationId: z.ZodString;
+    fence: z.ZodObject<{
+        installationId: z.ZodString;
+        resourceType: z.ZodString;
+        resourceId: z.ZodString;
+        ownerId: z.ZodString;
+        epoch: z.ZodNumber;
+    }, z.core.$strict>;
+    callerFence: z.ZodObject<{
+        installationId: z.ZodString;
+        resourceType: z.ZodString;
+        resourceId: z.ZodString;
+        ownerId: z.ZodString;
+        epoch: z.ZodNumber;
+    }, z.core.$strict>;
+    method: z.ZodLiteral<"repository.publish">;
+}, z.core.$strict>, z.ZodObject<{
+    blobId: z.ZodString;
+    kind: z.ZodEnum<{
+        blob: "blob";
+        artifact: "artifact";
+        log: "log";
+    }>;
+    offset: z.ZodNumber;
+    data: z.ZodString;
+    seal: z.ZodBoolean;
+    operationId: z.ZodString;
+    fence: z.ZodObject<{
+        installationId: z.ZodString;
+        resourceType: z.ZodString;
+        resourceId: z.ZodString;
+        ownerId: z.ZodString;
+        epoch: z.ZodNumber;
+    }, z.core.$strict>;
+    callerFence: z.ZodObject<{
+        installationId: z.ZodString;
+        resourceType: z.ZodString;
+        resourceId: z.ZodString;
+        ownerId: z.ZodString;
+        epoch: z.ZodNumber;
+    }, z.core.$strict>;
+    method: z.ZodLiteral<"blob.append">;
+}, z.core.$strict>], "method">;
+export type StorageRequest = z.infer<typeof StorageRequest>;
+export type StorageMutation = Extract<StorageRequest, {
+    operationId: string;
+}>;
+export declare function safeTreePath(value: string): void;

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.136",
+  "version": "0.0.138",
   "type": "module",
-  "main": "./dist/cjs/main.cjs",
+  "main": "./dist/mjs/main.mjs",
   "module": "./dist/mjs/main.mjs",
   "types": "./dist/types/main.d.ts",
   "exports": {
     ".": {
       "types": "./dist/types/main.d.ts",
       "import": "./dist/mjs/main.mjs",
-      "require": "./dist/cjs/main.cjs"
+      "default": "./dist/mjs/main.mjs"
     }
   },
   "repository": {
@@ -18,11 +18,13 @@
     "directory": "packages/r5d-worker"
   },
   "bin": {
-    "r5d-worker": "dist/cjs/main.cjs"
+    "r5d-worker": "dist/mjs/main.mjs"
   },
   "dependencies": {
-    "@ricsam/r5d-api": "^0.0.136",
-    "node-pty": "^1.1.0",
+    "@ricsam/r5d-api": "^0.0.138",
+    "@ricsam/r5dctl": "0.0.138",
+    "node-pty": "1.1.0",
+    "zod": "^4.1.13",
     "picomatch": "^4.0.3"
   },
   "files": [

package/dist/cjs/atomic-rename.cjs

@@ -1,303 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var atomic_rename_exports = {};
-__export(atomic_rename_exports, {
-  AtomicRenameError: () => AtomicRenameError,
-  atomicRenamePrimitivesFor: () => atomicRenamePrimitivesFor,
-  atomicRenameSupport: () => atomicRenameSupport,
-  exchangePaths: () => exchangePaths,
-  isAtomicRenameUnsupported: () => isAtomicRenameUnsupported,
-  overrideAtomicRenameSupportForTests: () => overrideAtomicRenameSupportForTests,
-  probeAtomicRenameSupport: () => probeAtomicRenameSupport,
-  renameNoReplace: () => renameNoReplace,
-  resetAtomicRenameProbesForTests: () => resetAtomicRenameProbesForTests
-});
-module.exports = __toCommonJS(atomic_rename_exports);
-var import_node_fs = __toESM(require("node:fs"), 1);
-var import_node_os = __toESM(require("node:os"), 1);
-var import_node_path = __toESM(require("node:path"), 1);
-var import_node_crypto = require("node:crypto");
-class AtomicRenameError extends Error {
-  constructor(syscall, code, errno, path2, dest) {
-    super(`${code}: ${syscall} failed, ${path2} -> ${dest}`);
-    this.syscall = syscall;
-    this.code = code;
-    this.errno = errno;
-    this.path = path2;
-    this.dest = dest;
-    this.name = "AtomicRenameError";
-  }
-  syscall;
-  code;
-  errno;
-  path;
-  dest;
-}
-const UNSUPPORTED_CODES = /* @__PURE__ */ new Set(["EINVAL", "ENOSYS", "ENOTSUP", "EOPNOTSUPP", "EPERM"]);
-function isAtomicRenameUnsupported(error) {
-  return error instanceof AtomicRenameError && UNSUPPORTED_CODES.has(error.code);
-}
-const LINUX_AT_FDCWD = -100;
-const LINUX_RENAME_NOREPLACE = 1;
-const LINUX_RENAME_EXCHANGE = 2;
-const DARWIN_RENAME_SWAP = 2;
-const DARWIN_RENAME_EXCL = 4;
-const LINUX_SYS_RENAMEAT2 = { x64: 316, arm64: 276 };
-const PROBE_PREFIX = ".r5d-atomic-rename-probe-";
-let loaded = null;
-let override = null;
-const errnoNames = /* @__PURE__ */ new Map();
-for (const [name, value] of Object.entries(import_node_os.default.constants.errno)) errnoNames.set(value, name);
-function errnoCode(errno) {
-  return errnoNames.get(errno) ?? `E${errno}`;
-}
-function cString(value) {
-  return Buffer.from(`${value}\0`, "utf8");
-}
-function loadNative() {
-  if (loaded) return loaded;
-  loaded = { calls: null, detail: "not attempted" };
-  try {
-    const ffi = require("bun:ffi");
-    const { dlopen, FFIType, ptr, read } = ffi;
-    if (process.platform === "darwin") {
-      const lib = dlopen("libSystem.B.dylib", {
-        renamex_np: { args: [FFIType.ptr, FFIType.ptr, FFIType.u32], returns: FFIType.i32 },
-        __error: { args: [], returns: FFIType.ptr }
-      });
-      loaded = {
-        calls: {
-          rename2: (from, to, flags) => {
-            const fromBuffer = cString(from);
-            const toBuffer = cString(to);
-            return lib.symbols.renamex_np(ptr(fromBuffer), ptr(toBuffer), flags);
-          },
-          errno: () => read.i32(lib.symbols.__error(), 0),
-          exchangeFlag: DARWIN_RENAME_SWAP,
-          noReplaceFlag: DARWIN_RENAME_EXCL,
-          backend: "renamex_np"
-        }
-      };
-      return loaded;
-    }
-    if (process.platform === "linux") {
-      const errnoLib = dlopen("libc.so.6", { __errno_location: { args: [], returns: FFIType.ptr } });
-      const errno = () => read.i32(errnoLib.symbols.__errno_location(), 0);
-      try {
-        const lib = dlopen("libc.so.6", {
-          renameat2: { args: [FFIType.i32, FFIType.ptr, FFIType.i32, FFIType.ptr, FFIType.u32], returns: FFIType.i32 }
-        });
-        loaded = {
-          calls: {
-            rename2: (from, to, flags) => {
-              const fromBuffer = cString(from);
-              const toBuffer = cString(to);
-              return lib.symbols.renameat2(LINUX_AT_FDCWD, ptr(fromBuffer), LINUX_AT_FDCWD, ptr(toBuffer), flags);
-            },
-            errno,
-            exchangeFlag: LINUX_RENAME_EXCHANGE,
-            noReplaceFlag: LINUX_RENAME_NOREPLACE,
-            backend: "renameat2"
-          }
-        };
-        return loaded;
-      } catch (error) {
-        const number = LINUX_SYS_RENAMEAT2[process.arch];
-        if (number === void 0) {
-          loaded = { calls: null, detail: `renameat2 symbol unavailable and no syscall number for ${process.arch}: ${String(error)}` };
-          return loaded;
-        }
-        const lib = dlopen("libc.so.6", {
-          syscall: {
-            args: [FFIType.i64, FFIType.i64, FFIType.i64, FFIType.i64, FFIType.i64, FFIType.i64],
-            returns: FFIType.i64
-          }
-        });
-        loaded = {
-          calls: {
-            rename2: (from, to, flags) => {
-              const fromBuffer = cString(from);
-              const toBuffer = cString(to);
-              return Number(
-                lib.symbols.syscall(number, LINUX_AT_FDCWD, Number(ptr(fromBuffer)), LINUX_AT_FDCWD, Number(ptr(toBuffer)), flags)
-              );
-            },
-            errno,
-            exchangeFlag: LINUX_RENAME_EXCHANGE,
-            noReplaceFlag: LINUX_RENAME_NOREPLACE,
-            backend: "syscall"
-          }
-        };
-        return loaded;
-      }
-    }
-    loaded = { calls: null, detail: `no atomic exchange primitive on ${process.platform}` };
-  } catch (error) {
-    loaded = { calls: null, detail: `bun:ffi unavailable: ${error instanceof Error ? error.message : String(error)}` };
-  }
-  return loaded;
-}
-function applyOverride(support) {
-  if (override?.exchange !== void 0) support.exchange = override.exchange;
-  if (override?.noReplace !== void 0) support.noReplace = override.noReplace;
-  return support;
-}
-function atomicRenameSupport() {
-  const native = loadNative();
-  return applyOverride(
-    native.calls ? { platform: process.platform, exchange: native.calls.backend, noReplace: native.calls.backend } : { platform: process.platform, exchange: "unavailable", noReplace: "link", detail: native.detail }
-  );
-}
-function overrideAtomicRenameSupportForTests(value) {
-  override = value;
-}
-function resetAtomicRenameProbesForTests() {
-  probes.clear();
-}
-function call(native, syscall, from, to, flags) {
-  if (native.rename2(from, to, flags) === 0) return;
-  const errno = native.errno();
-  throw new AtomicRenameError(syscall, errnoCode(errno), errno, from, to);
-}
-function exchangeWith(support, a, b) {
-  const native = loadNative().calls;
-  if (support.exchange === "unavailable" || !native) {
-    throw new AtomicRenameError("exchange", "ENOSYS", import_node_os.default.constants.errno.ENOSYS, a, b);
-  }
-  call(native, support.exchange, a, b, native.exchangeFlag);
-}
-function renameNoReplaceWith(support, from, to) {
-  const native = loadNative().calls;
-  if (support.noReplace !== "link" && native) {
-    call(native, support.noReplace, from, to, native.noReplaceFlag);
-    return;
-  }
-  const source = import_node_fs.default.lstatSync(from);
-  if (!source.isFile()) throw new AtomicRenameError("link", "ENOTSUP", import_node_os.default.constants.errno.ENOTSUP, from, to);
-  try {
-    import_node_fs.default.linkSync(from, to);
-  } catch (error) {
-    const code = error.code ?? "EIO";
-    throw new AtomicRenameError("link", code, error.errno ?? 0, from, to);
-  }
-  import_node_fs.default.unlinkSync(from);
-}
-function exchangePaths(a, b) {
-  exchangeWith(atomicRenameSupport(), a, b);
-}
-function renameNoReplace(from, to) {
-  renameNoReplaceWith(atomicRenameSupport(), from, to);
-}
-const probes = /* @__PURE__ */ new Map();
-function withoutTemporaries(directory, run) {
-  const token = (0, import_node_crypto.randomUUID)();
-  const a = import_node_path.default.join(directory, `${PROBE_PREFIX}${token}-a`);
-  const b = import_node_path.default.join(directory, `${PROBE_PREFIX}${token}-b`);
-  try {
-    run(a, b);
-  } finally {
-    import_node_fs.default.rmSync(a, { force: true });
-    import_node_fs.default.rmSync(b, { force: true });
-  }
-}
-function createProbeFile(filePath, content) {
-  const descriptor = import_node_fs.default.openSync(filePath, import_node_fs.default.constants.O_WRONLY | import_node_fs.default.constants.O_CREAT | import_node_fs.default.constants.O_EXCL, 384);
-  try {
-    import_node_fs.default.writeSync(descriptor, content);
-    return import_node_fs.default.fstatSync(descriptor);
-  } finally {
-    import_node_fs.default.closeSync(descriptor);
-  }
-}
-function probeAtomicRenameSupport(directory) {
-  const native = atomicRenameSupport();
-  const dev = import_node_fs.default.lstatSync(directory).dev;
-  const cached = probes.get(dev);
-  if (cached) return applyOverride({ ...cached });
-  const probed = { ...native };
-  if (native.exchange !== "unavailable") {
-    withoutTemporaries(directory, (a, b) => {
-      const statA = createProbeFile(a, "a");
-      const statB = createProbeFile(b, "b");
-      let swapped = false;
-      let detail;
-      try {
-        exchangeWith(native, a, b);
-        const afterA = import_node_fs.default.lstatSync(a);
-        const afterB = import_node_fs.default.lstatSync(b);
-        swapped = afterA.ino === statB.ino && afterB.ino === statA.ino;
-        if (!swapped) detail = `exchange flag ignored by the filesystem holding ${directory}`;
-      } catch (error) {
-        detail = `exchange rejected by the filesystem holding ${directory}: ${error instanceof Error ? error.message : String(error)}`;
-      }
-      if (!swapped) {
-        probed.exchange = "unavailable";
-        probed.detail = detail;
-      }
-    });
-  }
-  if (native.noReplace !== "link") {
-    withoutTemporaries(directory, (a, b) => {
-      createProbeFile(a, "a");
-      createProbeFile(b, "b");
-      let refused = false;
-      try {
-        renameNoReplaceWith(native, a, b);
-      } catch (error) {
-        refused = error instanceof AtomicRenameError && error.code === "EEXIST";
-      }
-      if (!refused) {
-        probed.noReplace = "link";
-        probed.detail = `${probed.detail ? `${probed.detail}; ` : ""}no-replace flag ignored by the filesystem holding ${directory}`;
-      }
-    });
-  }
-  probes.set(dev, probed);
-  return applyOverride({ ...probed });
-}
-function atomicRenamePrimitivesFor(directory) {
-  const support = probeAtomicRenameSupport(directory);
-  return {
-    support,
-    exchange: (a, b) => exchangeWith(support, a, b),
-    renameNoReplace: (from, to) => renameNoReplaceWith(support, from, to)
-  };
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  AtomicRenameError,
-  atomicRenamePrimitivesFor,
-  atomicRenameSupport,
-  exchangePaths,
-  isAtomicRenameUnsupported,
-  overrideAtomicRenameSupportForTests,
-  probeAtomicRenameSupport,
-  renameNoReplace,
-  resetAtomicRenameProbesForTests
-});

package/dist/cjs/browser-upload.cjs

@@ -1,73 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var browser_upload_exports = {};
-__export(browser_upload_exports, {
-  readBrowserUploadChunk: () => readBrowserUploadChunk
-});
-module.exports = __toCommonJS(browser_upload_exports);
-var import_promises = __toESM(require("node:fs/promises"), 1);
-var import_node_fs = require("node:fs");
-var import_node_os = __toESM(require("node:os"), 1);
-var import_node_path = __toESM(require("node:path"), 1);
-var import_browser_upload = require("@ricsam/r5d-api/browser-upload");
-async function readBrowserUploadChunk(input, context) {
-  if (typeof input.filePath !== "string" || !input.filePath.trim() || input.filePath.includes("\0"))
-    throw new Error("Upload requires a file path.");
-  if (!Number.isSafeInteger(input.offset) || input.offset < 0) throw new Error("Invalid upload read offset.");
-  if (input.offset > 0 && !input.version) throw new Error("Upload continuation requires a file version.");
-  const expanded = input.filePath.replace(/\$\{R5D_ROOT\}|\$R5D_ROOT\b/g, () => context.rootDir).replace(/\$\{R5D_SESSION_ID\}|\$R5D_SESSION_ID\b/g, () => context.sessionId).replace(/^~\//, () => `${import_node_os.default.homedir()}/`);
-  const filePath = import_node_path.default.resolve(context.cwd, expanded);
-  const handle = await import_promises.default.open(filePath, import_node_fs.constants.O_RDONLY | import_node_fs.constants.O_NONBLOCK);
-  try {
-    const stat = await handle.stat({ bigint: true });
-    if (!stat.isFile()) throw new Error(`Upload source is not a regular file: ${input.filePath}`);
-    const metadata = (0, import_browser_upload.validateUploadFile)({ filename: import_node_path.default.basename(filePath), size: Number(stat.size) });
-    const versionOf = (s) => `${s.dev}:${s.ino}:${s.size}:${s.mtimeNs}:${s.ctimeNs}`;
-    const version = versionOf(stat);
-    if (input.version !== void 0 && input.version !== version)
-      throw new Error(`Upload source changed while being transferred: ${input.filePath}`);
-    if (input.offset > metadata.size) throw new Error("Upload offset is past the end of the file.");
-    const bytes = Buffer.alloc(input.metadataOnly === true ? 0 : Math.min(import_browser_upload.BROWSER_UPLOAD_CHUNK_BYTES, metadata.size - input.offset));
-    let read = 0;
-    while (read < bytes.length) {
-      const { bytesRead } = await handle.read(bytes, read, bytes.length - read, input.offset + read);
-      if (!bytesRead) throw new Error(`Upload source was truncated: ${input.filePath}`);
-      read += bytesRead;
-    }
-    if (versionOf(await handle.stat({ bigint: true })) !== version)
-      throw new Error(`Upload source changed while being read: ${input.filePath}`);
-    return { type: "browser_upload_read", ...metadata, version, offset: input.offset, base64: bytes.toString("base64") };
-  } finally {
-    await handle.close();
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  readBrowserUploadChunk
-});

package/dist/cjs/cli-update.cjs

@@ -1,108 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var cli_update_exports = {};
-__export(cli_update_exports, {
-  getManualCliUpdateCommand: () => getManualCliUpdateCommand,
-  installCliUpdate: () => installCliUpdate,
-  parseCliVersion: () => parseCliVersion,
-  readInstalledCliVersion: () => readInstalledCliVersion,
-  runCommand: () => runCommand
-});
-module.exports = __toCommonJS(cli_update_exports);
-const UPDATE_OUTPUT_LIMIT = 8e3;
-function collectOutput(value) {
-  if (!value || typeof value === "number") {
-    return Promise.resolve("");
-  }
-  return new Response(value).text();
-}
-async function runCommand(argv) {
-  const child = Bun.spawn(argv, {
-    stdout: "pipe",
-    stderr: "pipe",
-    env: process.env
-  });
-  const [stdout, stderr, exitCode] = await Promise.all([collectOutput(child.stdout), collectOutput(child.stderr), child.exited]);
-  return { exitCode, stdout, stderr };
-}
-function parseCliVersion(cliName, output) {
-  const escapedName = cliName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const match = output.trim().match(new RegExp(`(?:^|\\n)${escapedName}\\s+(\\S+)`));
-  return match?.[1]?.trim() || null;
-}
-function readInstalledCliVersion(cliName) {
-  try {
-    const result = Bun.spawnSync([cliName, "--version"], {
-      stdout: "pipe",
-      stderr: "pipe",
-      env: process.env
-    });
-    if (result.exitCode !== 0) {
-      return null;
-    }
-    return parseCliVersion(cliName, Buffer.from(result.stdout).toString("utf8"));
-  } catch {
-    return null;
-  }
-}
-function shellQuote(value) {
-  return `'${value.replaceAll("'", `'\\''`)}'`;
-}
-function getManualCliUpdateCommand(input) {
-  return `npm install -g --omit=dev ${shellQuote(input.workerPackageSpec)} ${shellQuote(input.r5dctlPackageSpec)}`;
-}
-function commandErrorDetail(result) {
-  const detail = `${result.stderr.trim()}${result.stderr.trim() && result.stdout.trim() ? "\n" : ""}${result.stdout.trim()}`.trim();
-  if (!detail) {
-    return `exit code ${result.exitCode}`;
-  }
-  return detail.slice(-UPDATE_OUTPUT_LIMIT);
-}
-async function readVerifiedVersion(cliName, targetVersion, runner) {
-  const result = await runner([cliName, "--version"]);
-  const installedVersion = result.exitCode === 0 ? parseCliVersion(cliName, result.stdout) : null;
-  if (!installedVersion) {
-    throw new Error(`${cliName} was installed but is not runnable: ${commandErrorDetail(result)}`);
-  }
-  if (installedVersion !== targetVersion) {
-    throw new Error(`${cliName} ${installedVersion} was installed; expected ${targetVersion}`);
-  }
-  return installedVersion;
-}
-async function installCliUpdate(input, runner = runCommand) {
-  const installArgs = ["npm", "install", "-g", "--omit=dev", input.workerPackageSpec, input.r5dctlPackageSpec];
-  const result = await runner(installArgs);
-  if (result.exitCode !== 0) {
-    throw new Error(`CLI update failed: ${commandErrorDetail(result)}
-Run manually: ${getManualCliUpdateCommand(input)}`);
-  }
-  const [installedWorkerVersion, installedR5dctlVersion] = await Promise.all([
-    readVerifiedVersion("r5d-worker", input.targetWorkerVersion, runner),
-    readVerifiedVersion("r5dctl", input.targetR5dctlVersion, runner)
-  ]);
-  return { installedWorkerVersion, installedR5dctlVersion };
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  getManualCliUpdateCommand,
-  installCliUpdate,
-  parseCliVersion,
-  readInstalledCliVersion,
-  runCommand
-});