@ricsam/r5d-worker 0.0.137 → 0.0.139

package/dist/mjs/runtime/workspace/contracts.mjs

@@ -0,0 +1,60 @@
+import path from "node:path";
+import { z } from "zod";
+import { RuntimeId } from "@ricsam/r5d-api/runtime-protocol";
+import { BranchName, StorageId } from "./storage-wire.mjs";
+const ApprovedWorkbench = z.object({
+  id: StorageId,
+  userId: RuntimeId,
+  sessionId: RuntimeId,
+  sharedSessionId: RuntimeId.optional(),
+  repositoryId: StorageId,
+  branch: BranchName,
+  cwd: z.string().refine(path.isAbsolute),
+  // Supervisor-owned exact argv approvals, NOT an agent-supplied read-only flag.
+  // Approved servers must keep generated/cache files ignored and never write source.
+  nonmutatingArgv: z.array(z.array(z.string()).min(1)).max(20).default([])
+}).strict();
+const WorkspaceConfig = z.object({
+  installationId: RuntimeId,
+  root: z.string().refine(path.isAbsolute),
+  workbenches: z.array(ApprovedWorkbench).max(100),
+  dynamicWorkbenches: z.boolean().optional()
+}).strict();
+class WorkspaceError extends Error {
+  constructor(code, message, rejectedBeforeAdmission = false) {
+    super(message);
+    this.code = code;
+    this.rejectedBeforeAdmission = rejectedBeforeAdmission;
+    this.name = "WorkspaceError";
+  }
+  code;
+  rejectedBeforeAdmission;
+}
+class WorkspacePublicationNotAdmitted extends WorkspaceError {
+}
+const DEFAULT_WORKSPACE_IGNORE = `# Required destination workbench exclusions; keep these rules effective.
+.env
+.env.*
+!.env.example
+node_modules/
+.r5d/
+.r5d-next/
+.ssh/
+.kube/
+secrets/
+credentials/
+.next/
+dist/
+build/
+coverage/
+.cache/
+*.pem
+*.key
+`;
+export {
+  ApprovedWorkbench,
+  DEFAULT_WORKSPACE_IGNORE,
+  WorkspaceConfig,
+  WorkspaceError,
+  WorkspacePublicationNotAdmitted
+};

package/dist/mjs/runtime/workspace/file-write.mjs

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import { RuntimeId } from "@ricsam/r5d-api/runtime-protocol";
+import { safeTreePath } from "./storage-wire.mjs";
+const WorkspaceFileWrite = z.object({
+  method: z.literal("fileWrite"),
+  id: RuntimeId,
+  path: z.string().min(1).max(4096).refine((value) => {
+    try {
+      safeTreePath(value);
+      return true;
+    } catch {
+      return false;
+    }
+  }),
+  expectedSha256: z.string().regex(/^[a-f0-9]{64}$/).nullable(),
+  intentHash: z.string().regex(/^[a-f0-9]{64}$/).optional(),
+  base64: z.string().max(1048576)
+}).strict();
+const WorkspaceFileWriteLookup = z.object({ method: z.literal("fileWriteResult"), id: RuntimeId }).strict();
+export {
+  WorkspaceFileWrite,
+  WorkspaceFileWriteLookup
+};

package/dist/mjs/runtime/workspace/files.mjs

@@ -0,0 +1,308 @@
+import fs from "node:fs/promises";
+import { constants } from "node:fs";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { safeTreePath, STORAGE_LIMITS } from "./storage-wire.mjs";
+import { WorkspaceError } from "./contracts.mjs";
+const sha256 = (bytes) => createHash("sha256").update(bytes).digest("hex");
+async function privateRoot(root, installationId) {
+  if (!path.isAbsolute(root) || path.normalize(root) !== root || path.basename(root) !== installationId || root.split(path.sep).some((p) => [".r5d", "r5d-dev", "legacy", "app-data"].includes(p.toLowerCase())))
+    throw new WorkspaceError("unsafe_root", "Use an independently allocated private new-installation root, never a legacy worktree");
+  await noSymlinkAncestors(root);
+  const st = await fs.lstat(root);
+  if (!st.isDirectory() || st.uid !== process.getuid?.() || st.mode & 63)
+    throw new WorkspaceError("unsafe_root", "Root must already exist, be owned by current UID and mode 0700");
+}
+async function noSymlinkAncestors(file) {
+  let current = path.parse(file).root;
+  for (const part of file.slice(current.length).split(path.sep).filter(Boolean)) {
+    current = path.join(current, part);
+    if ((await fs.lstat(current)).isSymbolicLink()) throw new WorkspaceError("unsafe_path", "Symlink path component rejected");
+  }
+}
+async function readRegular(file, limit = 32 * 1024 * 1024) {
+  await noSymlinkAncestors(file);
+  const handle = await fs.open(file, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+  try {
+    const st = await handle.stat();
+    if (!st.isFile() || st.nlink !== 1 || st.size > limit)
+      throw new WorkspaceError("unsafe_file", "Only bounded single-link regular files accepted");
+    const bytes = await handle.readFile();
+    if (bytes.length > limit) throw new WorkspaceError("unsafe_file", "File exceeded budget during read");
+    return bytes;
+  } finally {
+    await handle.close();
+  }
+}
+async function durableJson(file, value) {
+  const temporary = `${file}.next`;
+  const handle = await fs.open(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 384);
+  try {
+    await handle.writeFile(JSON.stringify(value));
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+  await fs.rename(temporary, file);
+  const dir = await fs.open(path.dirname(file), constants.O_RDONLY);
+  try {
+    await dir.sync();
+  } finally {
+    await dir.close();
+  }
+}
+function git(cwd, args, input, indexFile, transport) {
+  if (indexFile && path.dirname(indexFile) !== cwd) throw new WorkspaceError("unsafe_path", "Index override must be authority-owned");
+  return new Promise((resolve, reject) => {
+    const child = spawn(
+      "/usr/bin/git",
+      [
+        "-c",
+        "core.hooksPath=/dev/null",
+        "-c",
+        "core.attributesFile=/dev/null",
+        "-c",
+        "core.fsmonitor=false",
+        "-c",
+        "protocol.allow=never",
+        "-c",
+        "gc.auto=0",
+        "-c",
+        "maintenance.auto=false",
+        "-c",
+        "pack.threads=1",
+        "-c",
+        "pack.windowMemory=16m",
+        ...args
+      ],
+      {
+        cwd,
+        env: {
+          PATH: "/usr/bin:/bin",
+          HOME: cwd,
+          LANG: "C",
+          LC_ALL: "C",
+          GIT_CONFIG_NOSYSTEM: "1",
+          GIT_CONFIG_SYSTEM: "/dev/null",
+          GIT_CONFIG_GLOBAL: "/dev/null",
+          GIT_ATTR_NOSYSTEM: "1",
+          GIT_TERMINAL_PROMPT: "0",
+          GIT_AUTHOR_NAME: "Destination Workspace",
+          GIT_AUTHOR_EMAIL: "workspace@invalid",
+          GIT_COMMITTER_NAME: "Destination Workspace",
+          GIT_COMMITTER_EMAIL: "workspace@invalid",
+          // Only the reviewed GitHub import/push boundary supplies this option.
+          // Tokens are process-private environment values, never argv, URLs or diagnostics.
+          ...transport ? { GIT_CONFIG_COUNT: "3", GIT_CONFIG_KEY_0: "http.https://github.com/.extraheader", GIT_CONFIG_VALUE_0: `AUTHORIZATION: basic ${Buffer.from(`x-access-token:${transport.token}`).toString("base64")}`, GIT_CONFIG_KEY_1: "http.followRedirects", GIT_CONFIG_VALUE_1: "false", GIT_CONFIG_KEY_2: "credential.helper", GIT_CONFIG_VALUE_2: "" } : {},
+          ...indexFile ? { GIT_INDEX_FILE: indexFile } : {}
+        },
+        stdio: ["pipe", "pipe", "pipe"]
+      }
+    );
+    let bytes = 0, failed = false;
+    const output = [];
+    const timer = setTimeout(() => {
+      failed = true;
+      child.kill("SIGKILL");
+    }, 3e4);
+    child.stdout.on("data", (b) => {
+      bytes += b.length;
+      if (bytes > 32 * 1024 * 1024) {
+        failed = true;
+        child.kill("SIGKILL");
+      } else output.push(b);
+    });
+    child.stderr.on("data", (b) => {
+      bytes += b.length;
+      if (bytes > 32 * 1024 * 1024) {
+        failed = true;
+        child.kill("SIGKILL");
+      }
+    });
+    child.on("error", (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      if (failed || code !== 0)
+        reject(new WorkspaceError("git_failed", "Bounded private Git operation failed; preserve state for inspection"));
+      else resolve(Buffer.concat(output));
+    });
+    child.stdin.on("error", () => {
+    });
+    child.stdin.end(input);
+  });
+}
+const denied = /* @__PURE__ */ new Set([
+  ".r5d",
+  ".r5d-next",
+  ".ssh",
+  ".kube",
+  ".aws",
+  ".config",
+  "secrets",
+  "credentials",
+  "node_modules",
+  ".next",
+  "dist",
+  "coverage",
+  ".cache",
+  ".pypirc",
+  ".netrc",
+  ".git-credentials"
+]);
+function sourcePath(file) {
+  safeTreePath(file);
+  if (file.split("/").some(
+    (p) => denied.has(p.toLowerCase()) || /^\.env(?:\.|$)/i.test(p) && p !== ".env.example" || /\.(pem|key|p12|pfx)$/i.test(p) || /^(id_rsa|id_ed25519|kubeconfig)$/i.test(p)
+  ))
+    throw new WorkspaceError("secret_or_runtime_path", `Refusing secret/runtime source path: ${file}`);
+}
+function sourceBytes(bytes, file) {
+  const name = file?.split("/").at(-1)?.toLowerCase();
+  if (name && /\.(sqlite|sqlite3|db)$/.test(name) && bytes.length !== 0)
+    throw new WorkspaceError("secret_content", "Only empty database placeholders may be published as source");
+  if (name === "credentials.json") {
+    const empty = (value) => typeof value === "string" ? value === "" : Array.isArray(value) ? value.every(empty) : !!value && typeof value === "object" && Object.values(value).every(empty);
+    let valid = false;
+    try {
+      valid = empty(JSON.parse(bytes.toString("utf8")));
+    } catch {
+    }
+    if (!valid) throw new WorkspaceError("secret_content", "Credential source templates must contain only empty placeholders");
+  }
+  if (name === ".npmrc") {
+    for (const raw of bytes.toString("utf8").split(/\r?\n/)) {
+      const line = raw.trim();
+      if (!line || /^[#;]/.test(line)) continue;
+      const equal = line.indexOf("=");
+      const key = (equal < 0 ? line : line.slice(0, equal)).trim();
+      if (!/auth|password|token|secret/i.test(key) || /^always-auth$/i.test(key)) continue;
+      const value = (equal < 0 ? "" : line.slice(equal + 1)).trim().replace(/^(?:"(.*)"|'(.*)')$/, (_match, a, b) => a ?? b);
+      if (equal < 0 || !(value === "" || /^\$\{[A-Za-z_][A-Za-z0-9_]*\}$/.test(value))) throw new WorkspaceError("secret_content", "npm authentication source must reference an environment variable");
+    }
+  }
+  const syntheticFixture = JSON.stringify("-----BEGIN OPENSSH PRIVATE KEY-----\nsynthetic\n");
+  const keyContent = bytes.toString("utf8").replaceAll(syntheticFixture, "");
+  if (/-----BEGIN (?:[A-Z ]*PRIVATE KEY|OPENSSH PRIVATE KEY)-----/.test(keyContent))
+    throw new WorkspaceError("secret_content", "Private key material cannot be published");
+}
+async function selectedTree(repo, commit) {
+  if (!/^[0-9a-f]{40}$/.test(commit) || (await git(repo, ["cat-file", "-t", commit])).toString().trim() !== "commit")
+    throw new WorkspaceError("invalid_tip", "Selected tip must be a SHA-1 commit");
+  const raw = await git(repo, ["ls-tree", "-rz", "--full-tree", commit]);
+  if (!Buffer.from(raw.toString("utf8")).equals(raw)) throw new WorkspaceError("unsafe_path", "Non-UTF8 tree names unsupported");
+  const entries = raw.toString("utf8").split("\0").filter(Boolean).map((record) => {
+    const match = /^(100644|100755) blob ([0-9a-f]{40})\t(.+)$/.exec(record);
+    if (!match) throw new WorkspaceError("unsafe_tree", "Symlinks, gitlinks and special modes unsupported");
+    sourcePath(match[3]);
+    return { file: match[3], mode: match[1], oid: match[2] };
+  });
+  if (entries.length > STORAGE_LIMITS.treeEntries) throw new WorkspaceError("too_large", "Too many source entries");
+  return entries;
+}
+async function verifyIgnore(repo, cwd) {
+  await readRegular(path.join(cwd, ".gitignore"), 64 * 1024);
+  const probes = [
+    ".env",
+    ".env.local",
+    "node_modules/probe",
+    ".r5d/probe",
+    ".r5d-next/probe",
+    ".ssh/probe",
+    ".kube/probe",
+    "secrets/probe",
+    "credentials/probe",
+    ".next/probe",
+    "dist/probe",
+    "coverage/probe",
+    ".cache/probe",
+    "probe.pem",
+    "probe.key"
+  ];
+  const ignored = (await git(repo, [`--work-tree=${cwd}`, "check-ignore", "--no-index", "-z", "--stdin"], probes.join("\0") + "\0")).toString().split("\0").filter(Boolean);
+  if (ignored.length !== probes.length || probes.some((p) => !ignored.includes(p)))
+    throw new WorkspaceError("ignore_policy", "Restore effective .gitignore rules for secrets, dependency, cache and runtime roots");
+}
+async function snapshotTree(repo, cwd, canonicalHead) {
+  const metadata = path.join(cwd, ".git");
+  if (await fs.lstat(metadata).then(
+    () => true,
+    (e) => {
+      if (e.code === "ENOENT") return false;
+      throw e;
+    }
+  )) {
+    await noSymlinkAncestors(metadata);
+    if (!(await fs.lstat(metadata)).isDirectory()) throw new WorkspaceError("unsafe_git", "External worktree metadata unsupported");
+    for (const name of ["MERGE_HEAD", "CHERRY_PICK_HEAD", "REVERT_HEAD", "REBASE_HEAD", "rebase-merge", "rebase-apply", "index.lock"]) {
+      if (await fs.lstat(path.join(metadata, name)).then(
+        () => true,
+        (e) => {
+          if (e.code === "ENOENT") return false;
+          throw e;
+        }
+      ))
+        throw new WorkspaceError(
+          "workbench_conflict",
+          "Git merge/rebase/index operation remains in progress; preserve and resolve it before publication"
+        );
+    }
+    const index = path.join(metadata, "index");
+    if (await fs.lstat(index).then(
+      () => true,
+      (e) => {
+        if (e.code === "ENOENT") return false;
+        throw e;
+      }
+    )) {
+      const copy = path.join(repo, "inspection-index");
+      await fs.writeFile(copy, await readRegular(index, 8 * 1024 * 1024), { mode: 384 });
+      if ((await git(repo, ["ls-files", "--unmerged", "-z"], void 0, copy)).length)
+        throw new WorkspaceError("workbench_conflict", "Unmerged index entries retained; resolve explicitly before publication");
+    }
+  }
+  await verifyIgnore(repo, cwd);
+  await git(repo, ["read-tree", "--empty"]);
+  const listing = await git(repo, [`--work-tree=${cwd}`, "ls-files", "--others", "--exclude-standard", "-z"]);
+  if (!Buffer.from(listing.toString()).equals(listing)) throw new WorkspaceError("unsafe_path", "Non-UTF8 names unsupported");
+  const tracked = [];
+  if (canonicalHead) for (const entry of await selectedTree(repo, canonicalHead)) {
+    const exists = await fs.lstat(path.join(cwd, entry.file)).then(() => true, (error) => {
+      if (error.code === "ENOENT") return false;
+      throw error;
+    });
+    if (exists) tracked.push(entry.file);
+  }
+  const files = [.../* @__PURE__ */ new Set([...listing.toString().split("\0").filter(Boolean), ...tracked])].sort();
+  if (files.length > STORAGE_LIMITS.treeEntries) throw new WorkspaceError("too_large", "Too many source files");
+  let size = 0;
+  const records = [];
+  for (const file of files) {
+    sourcePath(file);
+    const bytes = await readRegular(path.join(cwd, file));
+    sourceBytes(bytes, file);
+    if ((size += bytes.length) > 128 * 1024 * 1024) throw new WorkspaceError("too_large", "Source snapshot exceeds 128 MiB");
+    const st = await fs.lstat(path.join(cwd, file));
+    const oid = (await git(repo, ["hash-object", "-w", "--stdin", "--no-filters"], bytes)).toString().trim();
+    records.push(`${st.mode & 73 ? "100755" : "100644"} ${oid}	${file}\0`);
+  }
+  if (!files.includes(".gitignore")) throw new WorkspaceError("ignore_policy", "The .gitignore policy itself must be published");
+  await git(repo, ["update-index", "-z", "--index-info"], records.join(""));
+  return (await git(repo, ["write-tree"])).toString().trim();
+}
+export {
+  durableJson,
+  git,
+  noSymlinkAncestors,
+  privateRoot,
+  readRegular,
+  selectedTree,
+  sha256,
+  snapshotTree,
+  sourceBytes,
+  sourcePath,
+  verifyIgnore
+};

package/dist/mjs/runtime/workspace/http-body.mjs

@@ -0,0 +1,45 @@
+class BodyReadError extends Error {
+  constructor(code) {
+    super(code);
+    this.code = code;
+  }
+  code;
+}
+async function readBoundedBody(body, limit, timeoutMs) {
+  if (!Number.isSafeInteger(limit) || limit < 1 || !Number.isSafeInteger(timeoutMs) || timeoutMs < 1)
+    throw new Error("Invalid body budget");
+  if (!body) throw new BodyReadError("body_missing");
+  const reader = body.getReader();
+  const deadline = performance.now() + timeoutMs;
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new BodyReadError("body_timeout")), timeoutMs);
+  });
+  const bytes = Buffer.allocUnsafe(limit);
+  let size = 0, complete = false;
+  const reading = (async () => {
+    while (true) {
+      if (performance.now() >= deadline) throw new BodyReadError("body_timeout");
+      const next = await reader.read();
+      if (next.done) {
+        complete = true;
+        return bytes.subarray(0, size);
+      }
+      if (next.value.byteLength > limit - size) throw new BodyReadError("body_too_large");
+      bytes.set(next.value, size);
+      size += next.value.byteLength;
+    }
+  })();
+  try {
+    return await Promise.race([reading, timeout]);
+  } finally {
+    clearTimeout(timer);
+    if (!complete) void reader.cancel().catch(() => {
+    });
+    reader.releaseLock();
+  }
+}
+export {
+  BodyReadError,
+  readBoundedBody
+};

package/dist/mjs/runtime/workspace/storage-client.mjs

@@ -0,0 +1,59 @@
+import { z } from "zod";
+import { OwnershipFence } from "@ricsam/r5d-api/runtime-protocol";
+import { STORAGE_LIMITS, StorageRequest } from "./storage-wire.mjs";
+import { WorkspaceError } from "./contracts.mjs";
+import { readBoundedBody } from "./http-body.mjs";
+class WorkspaceStorageClient {
+  constructor(installationId, transport, caller) {
+    this.installationId = installationId;
+    this.transport = transport;
+    this.caller = caller;
+  }
+  installationId;
+  transport;
+  caller;
+  static http(options) {
+    const url = new URL(options.url);
+    if (url.username || url.password || url.search || url.hash || url.pathname !== "/internal/storage/v1/rpc" || url.protocol !== "https:" && !(url.protocol === "http:" && ["127.0.0.1", "[::1]"].includes(url.hostname)))
+      throw new WorkspaceError("invalid_storage_url", "Use private verified HTTPS or explicit loopback storage RPC");
+    return new WorkspaceStorageClient(
+      options.installationId,
+      async (request) => {
+        const response = await (options.fetch ?? fetch)(url, {
+          method: "POST",
+          redirect: "error",
+          signal: AbortSignal.timeout(3e4),
+          headers: { authorization: `Bearer ${await options.token(request)}`, "content-type": "application/json" },
+          body: JSON.stringify({ protocol: 1, installationId: options.installationId, request })
+        });
+        const bytes = await readBoundedBody(response.body, STORAGE_LIMITS.requestBytes, 3e4).catch(() => {
+          throw new WorkspaceError("invalid_response", "Storage response exceeded byte/time budget; inspect original receipt, no retry");
+        });
+        const body = JSON.parse(new TextDecoder().decode(bytes));
+        if (!response.ok)
+          throw new WorkspaceError(body.error ?? "storage_unavailable", "Storage rejected request; inspect original operation receipt", body.rejectedBeforeAdmission === true);
+        if (body.protocol !== 1 || !("result" in body)) throw new WorkspaceError("invalid_response", "Invalid storage envelope");
+        return body.result;
+      },
+      options.caller
+    );
+  }
+  read(request) {
+    return this.transport(StorageRequest.parse(request));
+  }
+  async mutate(input) {
+    const hello = z.object({
+      protocol: z.literal(1),
+      installationId: z.literal(this.installationId),
+      fence: OwnershipFence,
+      capabilities: z.array(z.string())
+    }).passthrough().parse(await this.read({ method: "hello" }));
+    const callerFence = OwnershipFence.parse(await this.caller());
+    if (hello.fence.installationId !== this.installationId || callerFence.installationId !== this.installationId || callerFence.resourceType === "storage-authority")
+      throw new WorkspaceError("wrong_installation", "Separate installation-bound caller ownership required");
+    return this.transport(StorageRequest.parse({ ...input, fence: hello.fence, callerFence }));
+  }
+}
+export {
+  WorkspaceStorageClient
+};

package/dist/mjs/runtime/workspace/storage-wire.mjs

@@ -0,0 +1,53 @@
+import { z } from "zod";
+import { OwnershipFence, RuntimeId } from "@ricsam/r5d-api/runtime-protocol";
+const STORAGE_LIMITS = { chunkBytes: 64 * 1024, blobBytes: 128 * 1024 * 1024, requestBytes: 96 * 1024, treeEntries: 1e4 };
+const StorageId = z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,99}$/);
+const GitOid = z.string().regex(/^[0-9a-f]{40}$/);
+const BranchName = z.string().min(1).max(150).refine((value) => value.split("/").every((part) => /^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(part)));
+const mutation = { operationId: RuntimeId, fence: OwnershipFence, callerFence: OwnershipFence };
+const Offset = z.number().int().min(0).max(STORAGE_LIMITS.blobBytes);
+const StorageRequest = z.discriminatedUnion("method", [
+  z.object({ method: z.literal("hello") }).strict(),
+  z.object({ method: z.literal("repository.get"), repositoryId: StorageId, branch: BranchName }).strict(),
+  z.object({
+    method: z.literal("repository.bundle"),
+    repositoryId: StorageId,
+    snapshot: z.string().uuid().nullable(),
+    offset: Offset,
+    limit: z.number().int().min(1).max(STORAGE_LIMITS.chunkBytes)
+  }).strict(),
+  z.object({ method: z.literal("operation.get"), lookupId: RuntimeId }).strict(),
+  z.object({ method: z.literal("repository.provision"), ...mutation, repositoryId: StorageId }).strict(),
+  z.object({ method: z.literal("repository.initializeAccount"), ...mutation, repositoryId: StorageId }).strict(),
+  z.object({ method: z.literal("repository.archive"), ...mutation, repositoryId: StorageId, branch: BranchName, expectedHead: GitOid.nullable() }).strict(),
+  z.object({
+    method: z.literal("repository.publish"),
+    ...mutation,
+    repositoryId: StorageId,
+    branch: BranchName,
+    expectedHead: GitOid.nullable(),
+    commit: GitOid,
+    bundleId: StorageId
+  }).strict(),
+  z.object({
+    method: z.literal("blob.append"),
+    ...mutation,
+    blobId: StorageId,
+    kind: z.enum(["blob", "artifact", "log"]),
+    offset: Offset,
+    data: z.string().max(Math.ceil(STORAGE_LIMITS.chunkBytes / 3) * 4),
+    seal: z.boolean()
+  }).strict()
+]);
+function safeTreePath(value) {
+  if (!value || value.length > 4096 || value.includes("\\") || /[\x00-\x1f\x7f]/.test(value) || value.split("/").some((part) => !part || part === "." || part === ".." || part.toLowerCase() === ".git"))
+    throw Object.assign(new Error("Unsafe Git tree path"), { code: "unsafe_path" });
+}
+export {
+  BranchName,
+  GitOid,
+  STORAGE_LIMITS,
+  StorageId,
+  StorageRequest,
+  safeTreePath
+};