lody 0.66.0 → 0.67.0

package/dist/chunks/directory-handle-Bx0hMRRw.js

@@ -0,0 +1,1122 @@
+import { o as object, s as string, l as literal, b as boolean, d as discriminatedUnion, n as number, _ as _enum, a as array, u as union, r as record, E as tuple, c as unknown } from "./schemas-muln0r74.js";
+import { execFile } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import path__default from "node:path";
+import { promisify } from "node:util";
+import { a as countTextLines } from "./diff-line-counts-BLxwWP6r.js";
+_enum(["host", "write", "read"]);
+_enum([
+  "not-started",
+  "starting",
+  "online",
+  "offline",
+  "stopping",
+  "unsupported"
+]);
+_enum([
+  "live-collaborative",
+  "live-readonly",
+  "historical-turn",
+  "host-offline",
+  "degraded"
+]);
+_enum(["code-collab", "none"]);
+_enum([
+  "focused",
+  "background",
+  "idle",
+  "disconnected"
+]);
+const CodeCollabFileKindSchema = _enum([
+  "text",
+  "binary",
+  "large",
+  "symlink",
+  "special",
+  "deleted"
+]);
+const CodeCollabSpecialKindSchema = _enum([
+  "fifo",
+  "socket",
+  "block-device",
+  "char-device",
+  "unknown"
+]);
+const CodeCollabTextEolSchema = _enum(["lf", "crlf", "mixed", "unknown"]);
+const CodeCollabUnavailableReasonSchema = _enum([
+  "permission-denied",
+  "locked",
+  "transient-io",
+  "text-too-large",
+  "line-too-long",
+  "unsupported-encoding",
+  "unsupported-special",
+  "blob-too-large",
+  "path-collision",
+  "unknown"
+]);
+_enum([
+  "deleted",
+  "metadata-only",
+  "missing-text-frontiers",
+  "missing-blob-digest",
+  "blob-expired",
+  ...CodeCollabUnavailableReasonSchema.options
+]);
+const CodeCollabDomainErrorCodeSchema = _enum([
+  "permission-denied",
+  "space-not-found",
+  "secret-unavailable",
+  "streams-unavailable",
+  "blob-unavailable",
+  "workspace-path-rejected",
+  "file-ignored",
+  "file-too-large",
+  "binary-unsupported",
+  "hydration-failed",
+  "save-conflict",
+  "host-offline",
+  "lsp-unavailable",
+  "external-file-unavailable",
+  "unexpected"
+]);
+object({
+  code: CodeCollabDomainErrorCodeSchema,
+  message: string().min(1),
+  redacted: boolean().optional()
+}).strict();
+const CODE_COLLAB_V2_TEXT_LIMITS = {
+  plainTextBytes: 64 * 1024,
+  maxCompressedBytes: 1024 * 1024,
+  maxRawTextBytes: 10 * 1024 * 1024
+};
+const CODE_COLLAB_V2_ALL_CHANGES_DIFF_LIMITS = {
+  perFileMaxCompressedBytes: 256 * 1024,
+  responseBudgetCompressedBytes: 2 * 1024 * 1024,
+  perFileMaxRawBytes: 1 * 1024 * 1024
+};
+const CodeCollabV2FileDigestSchema = string().regex(/^sha256:[0-9a-f]{64}$/u);
+const CodeCollabV2TextFormatSchema = object({
+  encoding: literal("utf8"),
+  bom: boolean().optional(),
+  eol: _enum(["lf", "crlf", "mixed", "unknown"]).optional()
+}).strict();
+const CodeCollabV2EncodedTextPayloadSchema = discriminatedUnion("encoding", [
+  object({
+    encoding: literal("plain"),
+    text: string(),
+    rawBytes: number().int().nonnegative()
+  }).strict(),
+  object({
+    encoding: literal("gzip-base64"),
+    data: string().min(1),
+    rawBytes: number().int().nonnegative(),
+    compressedBytes: number().int().nonnegative()
+  }).strict()
+]);
+const CodeCollabV2ErrorCodeSchema = _enum([
+  "invalid_path",
+  "session_not_found",
+  "workspace_root_unavailable",
+  "machine_offline",
+  "file_not_found",
+  "path_conflict",
+  "unsupported_binary",
+  "unsupported_skipped",
+  "too_large",
+  "decode_error",
+  "digest_mismatch",
+  "permission_denied",
+  "transient_io",
+  "lsp_not_wired"
+]);
+const CodeCollabV2ErrorSchema = object({
+  status: literal("error"),
+  code: CodeCollabV2ErrorCodeSchema,
+  message: string().min(1).optional(),
+  path: string().min(1).optional(),
+  retryable: boolean().optional()
+}).strict();
+const CodeCollabV2OpenTextRequestSchema = object({
+  sessionId: string().trim().min(1),
+  path: string().min(1)
+}).strict();
+const CodeCollabV2OpenTextOkSchema = object({
+  status: literal("ok"),
+  path: string().min(1),
+  digest: CodeCollabV2FileDigestSchema,
+  text: CodeCollabV2EncodedTextPayloadSchema,
+  format: CodeCollabV2TextFormatSchema.optional(),
+  readonly: boolean().optional()
+}).strict();
+const CodeCollabV2RefreshTextRequestSchema = object({
+  sessionId: string().trim().min(1),
+  path: string().min(1),
+  digest: CodeCollabV2FileDigestSchema
+}).strict();
+const CodeCollabV2RefreshTextResponseSchema = discriminatedUnion("status", [
+  object({
+    status: literal("up_to_date"),
+    path: string().min(1),
+    digest: CodeCollabV2FileDigestSchema
+  }).strict(),
+  object({
+    status: literal("updated"),
+    path: string().min(1),
+    digest: CodeCollabV2FileDigestSchema,
+    text: CodeCollabV2EncodedTextPayloadSchema,
+    format: CodeCollabV2TextFormatSchema.optional(),
+    readonly: boolean().optional()
+  }).strict()
+]);
+const CodeCollabV2SaveTextRequestSchema = object({
+  sessionId: string().trim().min(1),
+  requestedByUserId: string().trim().min(1),
+  path: string().min(1),
+  baseDigest: CodeCollabV2FileDigestSchema,
+  text: CodeCollabV2EncodedTextPayloadSchema,
+  format: CodeCollabV2TextFormatSchema.optional()
+}).strict();
+const CodeCollabV2SaveTextOkSchema = object({
+  status: literal("ok"),
+  path: string().min(1),
+  digest: CodeCollabV2FileDigestSchema,
+  rawBytes: number().int().nonnegative()
+}).strict();
+const CodeCollabV2SaveTextConflictSchema = object({
+  status: literal("conflict"),
+  reason: _enum(["digest_mismatch", "path_changed", "file_deleted", "path_conflict"]),
+  path: string().min(1),
+  baseDigest: CodeCollabV2FileDigestSchema,
+  diskDigest: CodeCollabV2FileDigestSchema.optional(),
+  diskText: CodeCollabV2EncodedTextPayloadSchema.optional()
+}).strict();
+const CodeCollabV2SaveTextResponseSchema = discriminatedUnion("status", [
+  CodeCollabV2SaveTextOkSchema,
+  CodeCollabV2SaveTextConflictSchema
+]);
+const CodeCollabV2OpenCurrentDiffRequestSchema = object({
+  sessionId: string().trim().min(1),
+  path: string().min(1)
+}).strict();
+const CodeCollabV2DiffSnapshotSchema = discriminatedUnion("kind", [
+  object({
+    kind: literal("text"),
+    text: CodeCollabV2EncodedTextPayloadSchema,
+    format: CodeCollabV2TextFormatSchema.optional()
+  }).strict(),
+  object({ kind: literal("missing") }).strict(),
+  object({ kind: literal("binary") }).strict(),
+  object({ kind: literal("too_large") }).strict()
+]);
+const CodeCollabV2OpenCurrentDiffResponseSchema = discriminatedUnion("status", [
+  object({
+    status: literal("ok"),
+    path: string().min(1),
+    oldSnapshot: CodeCollabV2DiffSnapshotSchema,
+    newSnapshot: CodeCollabV2DiffSnapshotSchema,
+    add: number().int().nonnegative().optional(),
+    del: number().int().nonnegative().optional()
+  }).strict(),
+  object({
+    status: literal("unavailable"),
+    path: string().min(1),
+    reason: _enum(["base_unavailable", "not_changed", "transient_io", "unsupported_binary"]),
+    message: string().min(1).optional()
+  }).strict()
+]);
+const CodeCollabV2OpenAllChangesDiffRequestSchema = object({
+  sessionId: string().trim().min(1),
+  // Inline this file first (the file the user clicked) regardless of size ordering.
+  focusPath: string().min(1).optional()
+}).strict();
+const CodeCollabV2AllChangesDiffEntrySchema = discriminatedUnion("status", [
+  object({
+    status: literal("ok"),
+    path: string().min(1),
+    oldSnapshot: CodeCollabV2DiffSnapshotSchema,
+    newSnapshot: CodeCollabV2DiffSnapshotSchema,
+    add: number().int().nonnegative().optional(),
+    del: number().int().nonnegative().optional()
+  }).strict(),
+  // Content exists but was not inlined (over per-file cap or total budget) — the client
+  // fetches it on demand via `open-current-diff`. Line stats still ship for the list.
+  object({
+    status: literal("deferred"),
+    path: string().min(1),
+    add: number().int().nonnegative().optional(),
+    del: number().int().nonnegative().optional()
+  }).strict(),
+  // Terminal: file is in the change list but its base snapshot equals disk (no real diff
+  // vs base). Binary / too-large files are NOT unavailable — they ship as `ok` with a
+  // `binary` / `too_large` snapshot, matching single-file `open-current-diff`.
+  object({
+    status: literal("unavailable"),
+    path: string().min(1),
+    reason: _enum(["not_changed"]),
+    add: number().int().nonnegative().optional(),
+    del: number().int().nonnegative().optional()
+  }).strict()
+]);
+const CodeCollabV2OpenAllChangesDiffResponseSchema = discriminatedUnion("status", [
+  object({
+    status: literal("ok"),
+    // Resolved diff base for diagnostics/consistency: merge-base sha (git) or a source
+    // marker like `diff-store` (non-git).
+    base: string().min(1),
+    entries: array(CodeCollabV2AllChangesDiffEntrySchema),
+    // True when any entry is `deferred` (UI can hint "some files load on demand").
+    truncated: boolean()
+  }).strict(),
+  object({
+    status: literal("unavailable"),
+    reason: _enum(["base_unavailable", "transient_io"]),
+    message: string().min(1).optional()
+  }).strict()
+]);
+const CodeCollabV2OpenTurnDiffRequestSchema = object({
+  sessionId: string().trim().min(1),
+  turnId: string().trim().min(1),
+  path: string().min(1)
+}).strict();
+const CodeCollabV2OpenTurnDiffResponseSchema = discriminatedUnion("status", [
+  object({
+    status: literal("ok"),
+    path: string().min(1),
+    turnId: string().trim().min(1),
+    oldSnapshot: CodeCollabV2DiffSnapshotSchema,
+    newSnapshot: CodeCollabV2DiffSnapshotSchema,
+    add: number().int().nonnegative().optional(),
+    del: number().int().nonnegative().optional()
+  }).strict(),
+  object({
+    status: literal("unavailable"),
+    path: string().min(1),
+    turnId: string().trim().min(1),
+    reason: _enum(["turn_unavailable", "not_changed", "transient_io"]),
+    message: string().min(1).optional()
+  }).strict()
+]);
+const CodeCollabV2InitDirectoryRequestSchema = object({
+  sessionId: string().trim().min(1),
+  path: string().min(1)
+}).strict();
+const CodeCollabV2InitDirectoryOkSchema = object({
+  status: literal("ok"),
+  path: string().min(1),
+  publishedEntries: number().int().nonnegative().optional()
+}).strict();
+const CodeCollabV2LspUnsupportedSchema = object({
+  status: literal("unsupported"),
+  code: literal("lsp_not_wired")
+}).strict();
+const CodeCollabV2FileTreeValueSchema = union([
+  literal(true),
+  object({ kind: literal("lazy") }).strict(),
+  object({ kind: literal("binary") }).strict(),
+  object({
+    kind: literal("skipped"),
+    reason: string().min(1)
+  }).strict(),
+  object({
+    kind: literal("too_large"),
+    rawBytes: number().int().nonnegative().optional(),
+    compressedBytes: number().int().nonnegative().optional()
+  }).strict()
+]);
+record(
+  string().min(1),
+  CodeCollabV2FileTreeValueSchema
+);
+const CodeCollabV2AllChangesValueSchema = union([
+  literal(true),
+  object({
+    diff: tuple([number().int().nonnegative(), number().int().nonnegative()]).optional(),
+    del: literal(true).optional()
+  }).strict()
+]);
+record(
+  string().min(1),
+  CodeCollabV2AllChangesValueSchema
+);
+const CodeCollabV2FileIndexValueSchema = union([
+  literal(true),
+  object({
+    kind: literal("file"),
+    change: CodeCollabV2AllChangesValueSchema.optional()
+  }).strict(),
+  object({
+    kind: literal("text"),
+    change: CodeCollabV2AllChangesValueSchema.optional()
+  }).strict(),
+  object({
+    kind: literal("binary"),
+    change: CodeCollabV2AllChangesValueSchema.optional()
+  }).strict(),
+  object({
+    kind: literal("too_large"),
+    rawBytes: number().int().nonnegative().optional(),
+    compressedBytes: number().int().nonnegative().optional(),
+    change: CodeCollabV2AllChangesValueSchema.optional()
+  }).strict(),
+  object({
+    kind: literal("deleted"),
+    change: CodeCollabV2AllChangesValueSchema
+  }).strict(),
+  object({ kind: literal("lazy") }).strict(),
+  object({
+    kind: literal("skipped"),
+    reason: string().min(1)
+  }).strict()
+]);
+record(
+  string().min(1),
+  CodeCollabV2FileIndexValueSchema
+);
+const codeCollabFileIndexKeyForWorkspacePath = (workspacePath) => [workspacePath];
+const isCodeCollabRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isCodeCollabMissing = (value) => value === void 0 || value === null;
+const isNonNegativeInteger = (value) => typeof value === "number" && Number.isInteger(value) && value >= 0;
+const hasOnlyCodeCollabKeys = (value, allowedKeys) => Object.keys(value).every((key) => allowedKeys.includes(key));
+const normalizeCodeCollabAllChangesValue = (value) => {
+  if (value === true) {
+    return true;
+  }
+  if (!isCodeCollabRecord(value) || !hasOnlyCodeCollabKeys(value, ["diff", "del"])) {
+    return void 0;
+  }
+  const change = {};
+  if (!isCodeCollabMissing(value.diff)) {
+    if (!Array.isArray(value.diff) || value.diff.length !== 2 || !isNonNegativeInteger(value.diff[0]) || !isNonNegativeInteger(value.diff[1])) {
+      return void 0;
+    }
+    change.diff = [value.diff[0], value.diff[1]];
+  }
+  if (!isCodeCollabMissing(value.del)) {
+    if (value.del !== true) {
+      return void 0;
+    }
+    change.del = true;
+  }
+  return change;
+};
+const normalizeOptionalCodeCollabAllChangesValue = (value) => {
+  if (isCodeCollabMissing(value)) {
+    return { ok: true };
+  }
+  const normalized = normalizeCodeCollabAllChangesValue(value);
+  return normalized === void 0 ? { ok: false } : { ok: true, value: normalized };
+};
+const normalizeCodeCollabFileIndexValue = (value) => {
+  if (value === true) {
+    return true;
+  }
+  if (!isCodeCollabRecord(value)) {
+    return void 0;
+  }
+  switch (value.kind) {
+    case "file":
+    case "text":
+    case "binary": {
+      if (!hasOnlyCodeCollabKeys(value, ["kind", "change"])) {
+        return void 0;
+      }
+      const change = normalizeOptionalCodeCollabAllChangesValue(value.change);
+      if (!change.ok) {
+        return void 0;
+      }
+      return change.value === void 0 ? { kind: value.kind } : { kind: value.kind, change: change.value };
+    }
+    case "too_large": {
+      if (!hasOnlyCodeCollabKeys(value, ["kind", "rawBytes", "compressedBytes", "change"])) {
+        return void 0;
+      }
+      const change = normalizeOptionalCodeCollabAllChangesValue(value.change);
+      if (!change.ok) {
+        return void 0;
+      }
+      const fileIndexValue = {
+        kind: "too_large"
+      };
+      if (!isCodeCollabMissing(value.rawBytes)) {
+        if (!isNonNegativeInteger(value.rawBytes)) {
+          return void 0;
+        }
+        fileIndexValue.rawBytes = value.rawBytes;
+      }
+      if (!isCodeCollabMissing(value.compressedBytes)) {
+        if (!isNonNegativeInteger(value.compressedBytes)) {
+          return void 0;
+        }
+        fileIndexValue.compressedBytes = value.compressedBytes;
+      }
+      if (change.value !== void 0) {
+        fileIndexValue.change = change.value;
+      }
+      return fileIndexValue;
+    }
+    case "deleted": {
+      if (!hasOnlyCodeCollabKeys(value, ["kind", "change"]) || isCodeCollabMissing(value.change)) {
+        return void 0;
+      }
+      const change = normalizeCodeCollabAllChangesValue(value.change);
+      return change === void 0 ? void 0 : { kind: "deleted", change };
+    }
+    case "lazy":
+      return hasOnlyCodeCollabKeys(value, ["kind"]) ? { kind: "lazy" } : void 0;
+    case "skipped":
+      return hasOnlyCodeCollabKeys(value, ["kind", "reason"]) && typeof value.reason === "string" && value.reason.length > 0 ? { kind: "skipped", reason: value.reason } : void 0;
+    default:
+      return void 0;
+  }
+};
+function readCodeCollabFileIndexFromFlock(flock) {
+  const fileIndex = {};
+  for (const row of flock.scan()) {
+    if (row.value === void 0) {
+      continue;
+    }
+    const [workspacePath, ...extra] = row.key;
+    if (typeof workspacePath !== "string" || workspacePath.length === 0 || extra.length > 0) {
+      continue;
+    }
+    const parsed = normalizeCodeCollabFileIndexValue(row.value);
+    if (!parsed) {
+      continue;
+    }
+    fileIndex[workspacePath] = parsed;
+  }
+  return fileIndex;
+}
+function writeCodeCollabFileIndexToFlock(flock, next, nowMs) {
+  const previous = readCodeCollabFileIndexFromFlock(flock);
+  let changed = false;
+  for (const workspacePath of Object.keys(previous)) {
+    if (Object.prototype.hasOwnProperty.call(next, workspacePath)) {
+      continue;
+    }
+    flock.delete(codeCollabFileIndexKeyForWorkspacePath(workspacePath), nowMs);
+    changed = true;
+  }
+  for (const [workspacePath, value] of Object.entries(next)) {
+    const normalized = normalizeCodeCollabFileIndexValue(value);
+    if (!normalized || codeCollabFileIndexValuesEqual(previous[workspacePath], normalized)) {
+      continue;
+    }
+    flock.set(codeCollabFileIndexKeyForWorkspacePath(workspacePath), normalized, nowMs);
+    changed = true;
+  }
+  if (changed) {
+    flock.commit();
+  }
+  return changed;
+}
+function codeCollabAllChangesValuesEqual(left, right) {
+  if (left === right) return true;
+  if (left === void 0 || right === void 0) return false;
+  if (left === true || right === true) return false;
+  const leftDiff = left.diff;
+  const rightDiff = right.diff;
+  return left.del === right.del && (leftDiff === void 0 && rightDiff === void 0 || leftDiff !== void 0 && rightDiff !== void 0 && leftDiff[0] === rightDiff[0] && leftDiff[1] === rightDiff[1]);
+}
+function codeCollabFileIndexValuesEqual(left, right) {
+  if (left === right) return true;
+  if (left === void 0 || right === void 0) return false;
+  if (left === true || right === true) return false;
+  switch (left.kind) {
+    case "file":
+      return right.kind === "file" && codeCollabAllChangesValuesEqual(left.change, right.change);
+    case "text":
+      return right.kind === "text" && codeCollabAllChangesValuesEqual(left.change, right.change);
+    case "binary":
+      return right.kind === "binary" && codeCollabAllChangesValuesEqual(left.change, right.change);
+    case "too_large":
+      return right.kind === "too_large" && left.rawBytes === right.rawBytes && left.compressedBytes === right.compressedBytes && codeCollabAllChangesValuesEqual(left.change, right.change);
+    case "deleted":
+      return right.kind === "deleted" && codeCollabAllChangesValuesEqual(left.change, right.change);
+    case "lazy":
+      return right.kind === "lazy";
+    case "skipped":
+      return right.kind === "skipped" && left.reason === right.reason;
+  }
+  return assertNever(left);
+}
+function codeCollabFileIndexStatesEqual(left, right) {
+  const leftPaths = Object.keys(left);
+  const rightPaths = Object.keys(right);
+  if (leftPaths.length !== rightPaths.length) return false;
+  for (const workspacePath of leftPaths) {
+    if (!Object.prototype.hasOwnProperty.call(right, workspacePath)) return false;
+    if (!codeCollabFileIndexValuesEqual(left[workspacePath], right[workspacePath])) return false;
+  }
+  return true;
+}
+function codeCollabFileTreeValueToFileIndexValue(value, change) {
+  if (value === true) {
+    return change === void 0 ? true : { kind: "file", change };
+  }
+  switch (value.kind) {
+    case "lazy":
+      return { kind: "lazy" };
+    case "binary":
+    case "too_large":
+      return change === void 0 ? true : { kind: "file", change };
+    case "skipped":
+      return { kind: "skipped", reason: value.reason };
+  }
+  return assertNever(value);
+}
+function buildCodeCollabFileIndexState(fileTree, allChanges) {
+  const fileIndex = {};
+  for (const [workspacePath, value] of Object.entries(fileTree)) {
+    fileIndex[workspacePath] = codeCollabFileTreeValueToFileIndexValue(
+      value,
+      allChanges[workspacePath]
+    );
+  }
+  for (const [workspacePath, change] of Object.entries(allChanges)) {
+    if (fileIndex[workspacePath] !== void 0) {
+      continue;
+    }
+    fileIndex[workspacePath] = { kind: "deleted", change };
+  }
+  return fileIndex;
+}
+const CODE_COLLAB_V2_RPC_CONTENT_ENVELOPE_TYPE = "code-collab-v2-content-envelope";
+const CODE_COLLAB_V2_RPC_CONTENT_KEY_VERSION = 1;
+const CODE_COLLAB_V2_RPC_CONTENT_KEY_ALGORITHM = "AES-256-GCM";
+const CodeCollabV2RpcContentEnvelopeSchema = object({
+  type: literal(CODE_COLLAB_V2_RPC_CONTENT_ENVELOPE_TYPE),
+  keyVersion: literal(CODE_COLLAB_V2_RPC_CONTENT_KEY_VERSION),
+  algorithm: literal(CODE_COLLAB_V2_RPC_CONTENT_KEY_ALGORITHM),
+  ownerSessionId: string().trim().min(1),
+  keyId: string().trim().min(1),
+  iv: string().trim().min(1),
+  ciphertext: string().trim().min(1)
+}).strict();
+union([
+  CodeCollabV2OpenTextOkSchema,
+  CodeCollabV2RefreshTextResponseSchema,
+  CodeCollabV2SaveTextResponseSchema,
+  CodeCollabV2OpenCurrentDiffResponseSchema,
+  CodeCollabV2OpenAllChangesDiffResponseSchema,
+  CodeCollabV2OpenTurnDiffResponseSchema,
+  CodeCollabV2InitDirectoryOkSchema,
+  CodeCollabV2LspUnsupportedSchema
+]);
+const CODE_COLLAB_V2_CONTENT_KEY_DERIVATION_LABEL = "lody-code-collab-v2-bootstrap-content-key-v1";
+const CODE_COLLAB_V2_CONTENT_KEY_ID_DERIVATION_LABEL = "lody-code-collab-v2-bootstrap-content-key-id-v1";
+const CODE_COLLAB_V2_BOOTSTRAP_CONTENT_KEY_SALT = "lody-code-collab-v2-bootstrap-salt-v1";
+function deriveCodeCollabV2ContentKeyBytes(ownerSessionId) {
+  return sha256Bytes(
+    `${CODE_COLLAB_V2_CONTENT_KEY_DERIVATION_LABEL}\0${CODE_COLLAB_V2_BOOTSTRAP_CONTENT_KEY_SALT}\0${ownerSessionId}`
+  );
+}
+function deriveCodeCollabV2ContentKeyId(ownerSessionId) {
+  const digest = sha256Bytes(
+    `${CODE_COLLAB_V2_CONTENT_KEY_ID_DERIVATION_LABEL}\0${CODE_COLLAB_V2_BOOTSTRAP_CONTENT_KEY_SALT}\0${ownerSessionId}`
+  );
+  return `ccv2:${bytesToHex(digest).slice(0, 24)}`;
+}
+object({
+  fileId: string().min(1),
+  path: string().min(1),
+  kind: CodeCollabFileKindSchema,
+  specialKind: CodeCollabSpecialKindSchema.optional(),
+  textEol: CodeCollabTextEolSchema.optional(),
+  hasBom: boolean().optional(),
+  mode: number().int().nonnegative().optional(),
+  executable: boolean().optional(),
+  sizeBytes: number().int().nonnegative().optional(),
+  mimeType: string().optional(),
+  contentDigest: string().optional(),
+  linkTarget: string().optional(),
+  unavailableReason: CodeCollabUnavailableReasonSchema.optional(),
+  updatedAt: string().optional(),
+  deletedAt: string().optional()
+}).strict();
+_enum([
+  "regular-file",
+  "directory",
+  "symlink",
+  "fifo",
+  "socket",
+  "block-device",
+  "char-device",
+  "unknown"
+]);
+object({
+  exists: boolean(),
+  path: string().optional(),
+  kind: _enum(["text", "binary", "large"]).optional(),
+  textDocId: string().optional(),
+  textFrontiers: unknown().optional(),
+  contentDigest: string().optional(),
+  blobDigest: string().optional(),
+  mode: number().int().nonnegative().optional(),
+  executable: boolean().optional(),
+  sizeBytes: number().int().nonnegative().optional()
+}).strict();
+const SHA256_INITIAL_HASH = [
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+];
+const SHA256_K = [
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+];
+const rightRotate = (value, bits) => value >>> bits | value << 32 - bits;
+function sha256Bytes(value) {
+  const bytes = new TextEncoder().encode(value);
+  const bitLength = bytes.length * 8;
+  const paddingLength = (64 - (bytes.length + 1 + 8) % 64) % 64;
+  const data = new Uint8Array(bytes.length + 1 + paddingLength + 8);
+  data.set(bytes);
+  data[bytes.length] = 128;
+  const view = new DataView(data.buffer);
+  view.setUint32(data.length - 8, Math.floor(bitLength / 4294967296));
+  view.setUint32(data.length - 4, bitLength >>> 0);
+  const hash = [...SHA256_INITIAL_HASH];
+  const words = new Array(64).fill(0);
+  for (let offset = 0; offset < data.length; offset += 64) {
+    for (let i = 0; i < 16; i += 1) {
+      words[i] = view.getUint32(offset + i * 4);
+    }
+    for (let i = 16; i < 64; i += 1) {
+      const s0 = rightRotate(words[i - 15] ?? 0, 7) ^ rightRotate(words[i - 15] ?? 0, 18) ^ (words[i - 15] ?? 0) >>> 3;
+      const s1 = rightRotate(words[i - 2] ?? 0, 17) ^ rightRotate(words[i - 2] ?? 0, 19) ^ (words[i - 2] ?? 0) >>> 10;
+      words[i] = (words[i - 16] ?? 0) + s0 + (words[i - 7] ?? 0) + s1 >>> 0 >>> 0;
+    }
+    let [a, b, c, d, e, f, g, h] = hash;
+    for (let i = 0; i < 64; i += 1) {
+      const s1 = rightRotate(e ?? 0, 6) ^ rightRotate(e ?? 0, 11) ^ rightRotate(e ?? 0, 25);
+      const ch = (e ?? 0) & (f ?? 0) ^ ~(e ?? 0) & (g ?? 0);
+      const temp1 = (h ?? 0) + s1 + ch + SHA256_K[i] + words[i] >>> 0 >>> 0;
+      const s0 = rightRotate(a ?? 0, 2) ^ rightRotate(a ?? 0, 13) ^ rightRotate(a ?? 0, 22);
+      const maj = (a ?? 0) & (b ?? 0) ^ (a ?? 0) & (c ?? 0) ^ (b ?? 0) & (c ?? 0);
+      const temp2 = s0 + maj >>> 0;
+      h = g;
+      g = f;
+      f = e;
+      e = (d ?? 0) + temp1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = temp1 + temp2 >>> 0;
+    }
+    hash[0] = (hash[0] ?? 0) + (a ?? 0) >>> 0;
+    hash[1] = (hash[1] ?? 0) + (b ?? 0) >>> 0;
+    hash[2] = (hash[2] ?? 0) + (c ?? 0) >>> 0;
+    hash[3] = (hash[3] ?? 0) + (d ?? 0) >>> 0;
+    hash[4] = (hash[4] ?? 0) + (e ?? 0) >>> 0;
+    hash[5] = (hash[5] ?? 0) + (f ?? 0) >>> 0;
+    hash[6] = (hash[6] ?? 0) + (g ?? 0) >>> 0;
+    hash[7] = (hash[7] ?? 0) + (h ?? 0) >>> 0;
+  }
+  const output = new Uint8Array(32);
+  const outputView = new DataView(output.buffer);
+  for (let i = 0; i < hash.length; i += 1) {
+    outputView.setUint32(i * 4, hash[i] ?? 0);
+  }
+  return output;
+}
+function bytesToHex(bytes) {
+  return Array.from(bytes).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function assertNever(value) {
+  throw new Error(`Unhandled Code Collab value: ${String(value)}`);
+}
+const execFileAsync = promisify(execFile);
+const GIT_MAX_BUFFER_BYTES = 64 * 1024 * 1024;
+async function isInsideGitWorktree(workspaceRoot) {
+  const inside = await runGit(workspaceRoot, ["rev-parse", "--is-inside-work-tree"]);
+  return inside.ok && inside.stdout.trim() === "true";
+}
+async function scanGitDirectoryEntries(options) {
+  if (!options.recursive) {
+    return null;
+  }
+  const result = await runGitLsFiles(options.directoryAbsolutePath);
+  if (!result.ok) {
+    return null;
+  }
+  return buildEntriesFromGitFilePaths({
+    directoryWorkspacePath: options.directoryWorkspacePath,
+    entryBudget: options.entryBudget,
+    recursive: options.recursive,
+    relativeFilePaths: result.paths
+  });
+}
+async function runGitLsFiles(cwd) {
+  try {
+    const [{ stdout }, deleted] = await Promise.all([
+      execFileAsync(
+        "git",
+        [
+          "-C",
+          cwd,
+          "ls-files",
+          "-z",
+          "--cached",
+          "--others",
+          "--exclude-standard",
+          "--deduplicate",
+          "--",
+          "."
+        ],
+        { maxBuffer: GIT_MAX_BUFFER_BYTES }
+      ),
+      runGit(cwd, ["ls-files", "--deleted", "-z", "--", "."])
+    ]);
+    const deletedPaths = deleted.ok ? new Set(deleted.stdout.split("\0").map(normalizeGitPath).filter(isValidRelativeGitPath)) : /* @__PURE__ */ new Set();
+    return {
+      ok: true,
+      paths: stdout.split("\0").map(normalizeGitPath).filter((filePath) => isValidRelativeGitPath(filePath) && !deletedPaths.has(filePath))
+    };
+  } catch {
+    return { ok: false };
+  }
+}
+async function computeAllChanges(workspaceRoot, options = {}) {
+  const diffBase = await resolveAllChangesDiffBase(workspaceRoot, options.preferredBaseBranch);
+  const diffTarget = diffBase ?? "HEAD";
+  const [numstat, nameStatus, untracked] = await Promise.all([
+    // `--numstat` cannot use `-z`, so disable `core.quotePath` to keep non-ASCII paths
+    // raw (matching the `-z` outputs below); otherwise they are mis-keyed and lose their
+    // All Changes diff counts.
+    runGit(workspaceRoot, [
+      "-c",
+      "core.quotePath=false",
+      "diff",
+      "--numstat",
+      "--no-renames",
+      "--relative",
+      diffTarget,
+      "--"
+    ]),
+    runGit(workspaceRoot, [
+      "diff",
+      "--name-status",
+      "--no-renames",
+      "-z",
+      "--relative",
+      diffTarget,
+      "--"
+    ]),
+    runGit(workspaceRoot, ["ls-files", "--others", "--exclude-standard", "-z"])
+  ]);
+  if (!numstat.ok && !nameStatus.ok && !untracked.ok) {
+    return {};
+  }
+  const deletedPaths = nameStatus.ok ? parseDeletedPathsFromNameStatus(nameStatus.stdout) : /* @__PURE__ */ new Set();
+  const changes = {};
+  if (numstat.ok) {
+    for (const line of numstat.stdout.split(/\r?\n/u)) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      const [addRaw, delRaw, ...pathParts] = trimmed.split("	");
+      const filePath = pathParts.join("	").trim();
+      if (!filePath) continue;
+      const normalizedPath = normalizeGitPath(filePath);
+      if (addRaw === "-" || delRaw === "-") {
+        changes[normalizedPath] = true;
+        continue;
+      }
+      const add = Number(addRaw);
+      const del = Number(delRaw);
+      const diff = [
+        Number.isFinite(add) && add >= 0 ? Math.trunc(add) : 0,
+        Number.isFinite(del) && del >= 0 ? Math.trunc(del) : 0
+      ];
+      changes[normalizedPath] = deletedPaths.has(normalizedPath) ? { diff: [0, diff[1]], del: true } : { diff };
+    }
+  }
+  if (untracked.ok) {
+    for (const filePath of untracked.stdout.split("\0")) {
+      if (!filePath) continue;
+      const normalizedPath = normalizeGitPath(filePath);
+      if (!(normalizedPath in changes)) {
+        changes[normalizedPath] = await lineStatsForUntrackedFile(workspaceRoot, normalizedPath);
+      }
+    }
+  }
+  return changes;
+}
+async function resolveAllChangesDiffBase(workspaceRoot, preferredBaseBranch) {
+  if (!await isInsideGitWorktree(workspaceRoot)) {
+    return null;
+  }
+  const baseRef = await resolveAllChangesBaseRef(workspaceRoot, preferredBaseBranch);
+  if (baseRef) {
+    const mergeBase = await runGit(workspaceRoot, ["merge-base", baseRef, "HEAD"]);
+    const trimmed = mergeBase.ok ? mergeBase.stdout.trim() : "";
+    if (trimmed) {
+      return trimmed;
+    }
+  }
+  const head = await runGit(workspaceRoot, ["rev-parse", "--verify", "HEAD^{commit}"]);
+  return head.ok && head.stdout.trim() ? "HEAD" : null;
+}
+async function resolveAllChangesBaseRef(workspaceRoot, preferredBaseBranch) {
+  const candidates = [
+    ...preferredBaseBranch ? [`origin/${preferredBaseBranch}`, preferredBaseBranch] : [],
+    "origin/main",
+    "main",
+    "origin/master",
+    "master",
+    "origin/HEAD"
+  ];
+  for (const candidate of candidates) {
+    const exists = await runGit(workspaceRoot, ["rev-parse", "--verify", `${candidate}^{commit}`]);
+    if (exists.ok) {
+      return candidate;
+    }
+  }
+  return null;
+}
+async function lineStatsForUntrackedFile(workspaceRoot, workspacePath) {
+  try {
+    const absolutePath = path__default.resolve(workspaceRoot, workspacePath);
+    const bytes = await readFile(absolutePath);
+    if (hasBinaryNul(bytes)) return true;
+    const text = decodeUtf8(bytes);
+    return { diff: [countTextLines(text), 0] };
+  } catch {
+    return true;
+  }
+}
+function parseDeletedPathsFromNameStatus(stdout) {
+  const deleted = /* @__PURE__ */ new Set();
+  const tokens = stdout.split("\0").filter(Boolean);
+  for (let index = 0; index < tokens.length; ) {
+    const status = tokens[index] ?? "";
+    index += 1;
+    if (status.startsWith("R") || status.startsWith("C")) {
+      const oldPath = tokens[index];
+      const newPath = tokens[index + 1];
+      index += 2;
+      if (oldPath) deleted.add(normalizeGitPath(oldPath));
+      if (newPath) deleted.delete(normalizeGitPath(newPath));
+      continue;
+    }
+    const filePath = tokens[index];
+    index += 1;
+    if (status.startsWith("D") && filePath) {
+      deleted.add(normalizeGitPath(filePath));
+    }
+  }
+  return deleted;
+}
+async function runGit(cwd, args) {
+  try {
+    const { stdout } = await execFileAsync("git", ["-C", cwd, ...args], {
+      maxBuffer: GIT_MAX_BUFFER_BYTES
+    });
+    return { ok: true, stdout };
+  } catch {
+    return { ok: false };
+  }
+}
+function buildEntriesFromGitFilePaths(options) {
+  const candidates = /* @__PURE__ */ new Map();
+  const conflicts = buildGitPathConflictIndex(options.relativeFilePaths);
+  for (const relativeFilePath of options.relativeFilePaths) {
+    const segments = relativeFilePath.split("/").filter((segment) => segment.length > 0);
+    const maxSegmentIndex = options.recursive ? segments.length - 1 : 0;
+    for (let index = 0; index <= maxSegmentIndex; index += 1) {
+      const segment = segments[index];
+      if (!segment) {
+        break;
+      }
+      const relativePath = segments.slice(0, index + 1).join("/");
+      const workspacePath = joinWorkspacePath(options.directoryWorkspacePath, relativePath);
+      if (conflicts.has(relativePath)) {
+        candidates.set(workspacePath, { kind: "skipped", reason: "path_conflict" });
+        break;
+      }
+      if (index < segments.length - 1) {
+        if (!candidates.has(workspacePath)) {
+          candidates.set(workspacePath, { kind: "lazy" });
+        }
+      } else {
+        candidates.set(workspacePath, true);
+      }
+    }
+  }
+  const sortedCandidates = [...candidates.entries()].sort(([leftPath], [rightPath]) => {
+    const depthOrder = pathDepth(leftPath) - pathDepth(rightPath);
+    return depthOrder === 0 ? leftPath.localeCompare(rightPath) : depthOrder;
+  });
+  return new Map(sortedCandidates.slice(0, Math.max(0, options.entryBudget)));
+}
+function buildGitPathConflictIndex(relativeFilePaths) {
+  const namesByDirectoryAndKey = /* @__PURE__ */ new Map();
+  for (const relativeFilePath of relativeFilePaths) {
+    const segments = relativeFilePath.split("/").filter((segment) => segment.length > 0);
+    for (let index = 0; index < segments.length; index += 1) {
+      const segment = segments[index];
+      if (!segment) {
+        continue;
+      }
+      const parent = segments.slice(0, index).join("/");
+      const comparisonKey = pathSegmentComparisonKey(segment);
+      let namesByKey = namesByDirectoryAndKey.get(parent);
+      if (!namesByKey) {
+        namesByKey = /* @__PURE__ */ new Map();
+        namesByDirectoryAndKey.set(parent, namesByKey);
+      }
+      let names = namesByKey.get(comparisonKey);
+      if (!names) {
+        names = /* @__PURE__ */ new Set();
+        namesByKey.set(comparisonKey, names);
+      }
+      names.add(segment);
+    }
+  }
+  const conflicts = /* @__PURE__ */ new Set();
+  for (const [parent, namesByKey] of namesByDirectoryAndKey) {
+    for (const names of namesByKey.values()) {
+      if (names.size <= 1) {
+        continue;
+      }
+      for (const name of names) {
+        conflicts.add(parent ? `${parent}/${name}` : name);
+      }
+    }
+  }
+  return conflicts;
+}
+function normalizeGitPath(filePath) {
+  return filePath.replace(/\\/gu, "/").normalize("NFC");
+}
+function isValidRelativeGitPath(filePath) {
+  return filePath.length > 0 && filePath !== "." && !path__default.isAbsolute(filePath) && !filePath.split("/").some((segment) => segment.length === 0 || segment === "..");
+}
+function joinWorkspacePath(parent, child) {
+  return (parent ? `${parent}/${child}` : child).normalize("NFC");
+}
+function pathSegmentComparisonKey(segment) {
+  return segment.normalize("NFC").toLocaleLowerCase("en-US");
+}
+function pathDepth(workspacePath) {
+  return workspacePath ? workspacePath.split("/").length : 0;
+}
+function hasBinaryNul(bytes) {
+  const limit = Math.min(bytes.byteLength, 8 * 1024);
+  for (let index = 0; index < limit; index += 1) {
+    if (bytes[index] === 0) {
+      return true;
+    }
+  }
+  return false;
+}
+function decodeUtf8(bytes) {
+  return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
+}
+async function closeDirectoryQuietly(directory) {
+  try {
+    await directory.close();
+  } catch {
+  }
+}
+export {
+  writeCodeCollabFileIndexToFlock as A,
+  joinWorkspacePath as B,
+  CodeCollabV2OpenTextRequestSchema as C,
+  isInsideGitWorktree as D,
+  pathSegmentComparisonKey as E,
+  CodeCollabV2RefreshTextRequestSchema as a,
+  CodeCollabV2SaveTextRequestSchema as b,
+  CodeCollabV2OpenCurrentDiffRequestSchema as c,
+  CodeCollabV2OpenAllChangesDiffRequestSchema as d,
+  CodeCollabV2OpenTurnDiffRequestSchema as e,
+  CodeCollabV2InitDirectoryRequestSchema as f,
+  CodeCollabV2OpenTextOkSchema as g,
+  CodeCollabV2RefreshTextResponseSchema as h,
+  CodeCollabV2SaveTextResponseSchema as i,
+  CodeCollabV2OpenCurrentDiffResponseSchema as j,
+  CodeCollabV2OpenAllChangesDiffResponseSchema as k,
+  CodeCollabV2OpenTurnDiffResponseSchema as l,
+  CodeCollabV2InitDirectoryOkSchema as m,
+  CodeCollabV2LspUnsupportedSchema as n,
+  CodeCollabV2ErrorSchema as o,
+  CodeCollabV2RpcContentEnvelopeSchema as p,
+  deriveCodeCollabV2ContentKeyId as q,
+  deriveCodeCollabV2ContentKeyBytes as r,
+  CodeCollabV2ErrorCodeSchema as s,
+  CODE_COLLAB_V2_TEXT_LIMITS as t,
+  CODE_COLLAB_V2_ALL_CHANGES_DIFF_LIMITS as u,
+  computeAllChanges as v,
+  buildCodeCollabFileIndexState as w,
+  codeCollabFileIndexStatesEqual as x,
+  scanGitDirectoryEntries as y,
+  closeDirectoryQuietly as z
+};