@p4pilot/core 0.1.0

package/dist/browser.cjs

@@ -0,0 +1,873 @@
+"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);
+
+// src/browser.ts
+var browser_exports = {};
+__export(browser_exports, {
+  DEFAULT_ASSET_GUARD_CONFIG: () => DEFAULT_ASSET_GUARD_CONFIG,
+  MockP4Runner: () => MockP4Runner,
+  P4Client: () => P4Client,
+  P4PilotError: () => P4PilotError,
+  buildChangelistDescription: () => buildChangelistDescription,
+  classifyAsset: () => classifyAsset,
+  ensureOpenForEdit: () => ensureOpenForEdit,
+  ensureOpenForEditMany: () => ensureOpenForEditMany,
+  groupIndexed: () => groupIndexed,
+  parseZtag: () => parseZtag
+});
+module.exports = __toCommonJS(browser_exports);
+
+// src/types.ts
+var P4PilotError = class extends Error {
+  constructor(message, code, detail) {
+    super(message);
+    this.code = code;
+    this.detail = detail;
+    this.name = "P4PilotError";
+  }
+  code;
+  detail;
+};
+
+// src/ztag.ts
+function parseZtag(stdout) {
+  const records = [];
+  let record = /* @__PURE__ */ new Map();
+  let previousKey;
+  const finishRecord = () => {
+    if (record.size > 0) {
+      records.push(record);
+      record = /* @__PURE__ */ new Map();
+    }
+    previousKey = void 0;
+  };
+  for (const line of stdout.split(/\r?\n/)) {
+    if (line.length === 0) {
+      finishRecord();
+    } else if (line.startsWith("... ")) {
+      const field = line.slice(4);
+      const separatorIndex = field.indexOf(" ");
+      const key = separatorIndex === -1 ? field : field.slice(0, separatorIndex);
+      const value = separatorIndex === -1 ? "" : field.slice(separatorIndex + 1);
+      record.set(key, value);
+      previousKey = key;
+    } else if (previousKey !== void 0) {
+      const previousValue = record.get(previousKey) ?? "";
+      record.set(previousKey, `${previousValue}
+${line}`);
+    }
+  }
+  finishRecord();
+  return records;
+}
+function groupIndexed(record) {
+  const grouped = {};
+  const indexed = /* @__PURE__ */ new Map();
+  for (const [key, value] of record) {
+    const match = /^(.*?)(\d+)$/.exec(key);
+    const baseKey = match?.[1];
+    const indexText = match?.[2];
+    if (baseKey === void 0 || indexText === void 0) {
+      grouped[key] = value;
+      continue;
+    }
+    const values = indexed.get(baseKey) ?? [];
+    values.push({ index: Number(indexText), value });
+    indexed.set(baseKey, values);
+  }
+  for (const [key, values] of indexed) {
+    grouped[key] = values.sort((left, right) => left.index - right.index).map(({ value }) => value);
+  }
+  return grouped;
+}
+
+// src/p4-client.ts
+var CHANGE_CREATED = /Change (\d+) created/;
+function num(value) {
+  return value === void 0 ? void 0 : Number(value);
+}
+function str(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function asArray(value) {
+  if (value === void 0) return [];
+  return Array.isArray(value) ? value : [value];
+}
+function toOpenedFile(record) {
+  return {
+    depotFile: record.get("depotFile") ?? "",
+    clientFile: record.get("clientFile"),
+    rev: num(record.get("rev")),
+    action: record.get("action") ?? "edit",
+    change: record.get("change") ?? "default",
+    type: record.get("type") ?? "text"
+  };
+}
+function toFileStat(record) {
+  const headRev = num(record.get("headRev"));
+  const action = record.get("action");
+  return {
+    depotFile: record.get("depotFile") ?? "",
+    clientFile: record.get("clientFile"),
+    headType: record.get("headType"),
+    headRev,
+    haveRev: num(record.get("haveRev")),
+    action,
+    isOpened: action !== void 0,
+    isTracked: headRev !== void 0
+  };
+}
+function toChangelistSummary(record) {
+  const status = record.get("status");
+  return {
+    change: record.get("change") ?? "",
+    description: record.get("desc") ?? "",
+    status: status === "submitted" || status === "shelved" ? status : "pending",
+    user: record.get("user"),
+    client: record.get("client")
+  };
+}
+var P4Client = class {
+  #runner;
+  constructor(runner) {
+    this.#runner = runner;
+  }
+  async #run(args, opts) {
+    const result = await this.#runner.run(args, opts);
+    if (result.exitCode !== 0) {
+      throw new P4PilotError(
+        `p4 ${args.join(" ")} failed`,
+        "P4_COMMAND_FAILED",
+        result.stderr.trim() || result.stdout.trim()
+      );
+    }
+    return result;
+  }
+  async info() {
+    const { stdout } = await this.#run(["info"]);
+    const record = parseZtag(stdout)[0];
+    const info = {};
+    if (record) {
+      for (const [key, value] of record) {
+        info[key] = value;
+      }
+    }
+    return info;
+  }
+  async opened(opts) {
+    const args = ["opened"];
+    if (opts?.changelist) args.push("-c", opts.changelist);
+    const { stdout } = await this.#run(args);
+    return parseZtag(stdout).map(toOpenedFile);
+  }
+  async fstat(files) {
+    if (files.length === 0) return [];
+    const { stdout } = await this.#run(["fstat", ...files]);
+    return parseZtag(stdout).map(toFileStat);
+  }
+  async edit(files, opts) {
+    return this.#openOp("edit", files, opts);
+  }
+  async add(files, opts) {
+    return this.#openOp("add", files, opts);
+  }
+  async deleteFiles(files, opts) {
+    return this.#openOp("delete", files, opts);
+  }
+  async #openOp(command, files, opts) {
+    if (files.length === 0) return [];
+    const args = [command];
+    if (opts?.changelist) args.push("-c", opts.changelist);
+    args.push(...files);
+    const { stdout } = await this.#run(args);
+    return parseZtag(stdout).map(toOpenedFile);
+  }
+  async revert(files) {
+    if (files.length === 0) return [];
+    const { stdout } = await this.#run(["revert", ...files]);
+    return parseZtag(stdout).map((record) => record.get("depotFile") ?? "").filter((depotFile) => depotFile.length > 0);
+  }
+  async sync(paths) {
+    const args = ["sync"];
+    if (paths && paths.length > 0) args.push(...paths);
+    const { stdout } = await this.#run(args);
+    return { synced: parseZtag(stdout).length };
+  }
+  async where(file) {
+    const { stdout } = await this.#run(["where", file]);
+    const record = parseZtag(stdout)[0];
+    if (!record) {
+      throw new P4PilotError(
+        `p4 where returned no mapping for ${file}`,
+        "FILE_NOT_IN_CLIENT"
+      );
+    }
+    const clientFile = record.get("clientFile") ?? "";
+    return {
+      depotFile: record.get("depotFile") ?? "",
+      clientFile,
+      path: record.get("path") ?? clientFile
+    };
+  }
+  async changes(opts) {
+    const args = ["changes"];
+    if (opts?.status) args.push("-s", opts.status);
+    if (opts?.max !== void 0) args.push("-m", String(opts.max));
+    if (opts?.user) args.push("-u", opts.user);
+    const { stdout } = await this.#run(args);
+    return parseZtag(stdout).map(toChangelistSummary);
+  }
+  async describe(change, opts) {
+    const args = ["describe"];
+    if (opts?.diff) args.push("-du");
+    args.push(change);
+    const { stdout } = await this.#run(args);
+    const record = parseZtag(stdout)[0];
+    if (!record) {
+      throw new P4PilotError(
+        `p4 describe returned nothing for ${change}`,
+        "P4_COMMAND_FAILED"
+      );
+    }
+    const grouped = groupIndexed(record);
+    const depotFiles = asArray(grouped.depotFile);
+    const actions = asArray(grouped.action);
+    const revs = asArray(grouped.rev);
+    const files = depotFiles.map((depotFile, index) => ({
+      depotFile,
+      action: actions[index] ?? "edit",
+      rev: revs[index] === void 0 ? void 0 : Number(revs[index])
+    }));
+    return {
+      change: str(grouped.change) ?? change,
+      description: str(grouped.desc) ?? "",
+      user: str(grouped.user),
+      files,
+      diff: str(grouped.diff)
+    };
+  }
+  async filelog(file, opts) {
+    const args = ["filelog"];
+    if (opts?.max !== void 0) args.push("-m", String(opts.max));
+    args.push(file);
+    const { stdout } = await this.#run(args);
+    const record = parseZtag(stdout)[0];
+    if (!record) return [];
+    const grouped = groupIndexed(record);
+    const revs = asArray(grouped.rev);
+    const changes = asArray(grouped.change);
+    const actions = asArray(grouped.action);
+    const users = asArray(grouped.user);
+    const descriptions = asArray(grouped.desc);
+    return revs.map((rev, index) => ({
+      rev: Number(rev),
+      change: changes[index] ?? "",
+      action: actions[index] ?? "edit",
+      user: users[index] ?? "",
+      description: descriptions[index] ?? ""
+    }));
+  }
+  async newChangelist(description) {
+    const indented = description.replace(/\n/g, "\n	");
+    const spec = `Change:	new
+
+Description:
+	${indented}
+`;
+    const { stdout } = await this.#run(["change", "-i"], { input: spec });
+    const matched = CHANGE_CREATED.exec(stdout);
+    if (matched?.[1]) return matched[1];
+    const change = parseZtag(stdout)[0]?.get("change");
+    if (change) return change;
+    throw new P4PilotError(
+      "could not parse created changelist number",
+      "P4_COMMAND_FAILED",
+      stdout.trim()
+    );
+  }
+  async reopen(files, changelist) {
+    if (files.length === 0) return [];
+    const { stdout } = await this.#run(["reopen", "-c", changelist, ...files]);
+    return parseZtag(stdout).map(toOpenedFile);
+  }
+};
+
+// src/asset-guard.ts
+var DEFAULT_ASSET_GUARD_CONFIG = {
+  largeAssetExtensions: [
+    ".uasset",
+    ".umap",
+    ".fbx",
+    ".psd",
+    ".pak",
+    ".mp4",
+    ".mov",
+    ".blend",
+    ".exr"
+  ],
+  binaryExtensions: [
+    ".png",
+    ".tga",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".bmp",
+    ".dds",
+    ".ico",
+    ".wav",
+    ".mp3",
+    ".ogg",
+    ".flac",
+    ".bin",
+    ".dll",
+    ".exe",
+    ".so",
+    ".dylib",
+    ".lib",
+    ".a",
+    ".zip",
+    ".7z",
+    ".rar",
+    ".gz",
+    ".pdf"
+  ],
+  maxTextBytes: 1e6
+};
+function extname(path) {
+  const normalized = path.replace(/\\/g, "/");
+  const base = normalized.slice(normalized.lastIndexOf("/") + 1);
+  const dot = base.lastIndexOf(".");
+  return dot <= 0 ? "" : base.slice(dot).toLowerCase();
+}
+function isBinaryFiletype(filetype) {
+  if (filetype === void 0) return false;
+  return /(binary|ubinary|apple)/i.test(filetype);
+}
+function build(path, kind, filetype, sizeBytes, reason) {
+  return {
+    path,
+    kind,
+    filetype,
+    sizeBytes,
+    shouldRead: kind === "text",
+    reason
+  };
+}
+function classifyAsset(path, opts) {
+  const config = {
+    ...DEFAULT_ASSET_GUARD_CONFIG,
+    ...opts?.config
+  };
+  const ext = extname(path);
+  const filetype = opts?.stat?.headType;
+  const sizeBytes = opts?.sizeBytes;
+  if (config.largeAssetExtensions.includes(ext)) {
+    return build(
+      path,
+      "large-asset",
+      filetype,
+      sizeBytes,
+      `large-asset extension ${ext}`
+    );
+  }
+  if (isBinaryFiletype(filetype)) {
+    return build(
+      path,
+      "binary",
+      filetype,
+      sizeBytes,
+      `binary p4 filetype ${filetype ?? ""}`
+    );
+  }
+  if (config.binaryExtensions.includes(ext)) {
+    return build(
+      path,
+      "binary",
+      filetype,
+      sizeBytes,
+      `binary extension ${ext}`
+    );
+  }
+  if (sizeBytes !== void 0 && sizeBytes > config.maxTextBytes) {
+    return build(
+      path,
+      "binary",
+      filetype,
+      sizeBytes,
+      `size ${sizeBytes} exceeds maxTextBytes ${config.maxTextBytes}`
+    );
+  }
+  return build(
+    path,
+    "text",
+    filetype,
+    sizeBytes,
+    ext ? `text extension ${ext}` : "text file"
+  );
+}
+
+// src/auto-checkout.ts
+async function ensureOpenForEdit(client, localPath, opts) {
+  const [stat] = await client.fstat([localPath]);
+  const asset = classifyAsset(localPath, { stat, config: opts?.assetConfig });
+  const changelist = opts?.changelist;
+  const openOpts = changelist === void 0 ? void 0 : { changelist };
+  if (stat?.isOpened) {
+    return {
+      path: localPath,
+      status: "already-open",
+      action: stat.action,
+      changelist,
+      asset
+    };
+  }
+  if (stat?.isTracked) {
+    const [opened] = await client.edit([localPath], openOpts);
+    return {
+      path: localPath,
+      status: "opened",
+      action: opened?.action ?? "edit",
+      changelist: opened?.change ?? changelist,
+      asset
+    };
+  }
+  const [added] = await client.add([localPath], openOpts);
+  return {
+    path: localPath,
+    status: "added",
+    action: added?.action ?? "add",
+    changelist: added?.change ?? changelist,
+    asset
+  };
+}
+async function ensureOpenForEditMany(client, localPaths, opts) {
+  const results = [];
+  for (const path of localPaths) {
+    try {
+      results.push(await ensureOpenForEdit(client, path, opts));
+    } catch {
+      results.push({ path, status: "skipped-untracked-ignored" });
+    }
+  }
+  return results;
+}
+
+// src/changelist.ts
+function buildChangelistDescription(intent, prefix = "[p4pilot] ") {
+  const trimmed = intent.trim();
+  if (trimmed.length === 0) return prefix.trimEnd();
+  return trimmed.startsWith(prefix) ? trimmed : `${prefix}${trimmed}`;
+}
+
+// src/testing/mock-runner.ts
+var success = (stdout = "") => ({
+  stdout,
+  stderr: "",
+  exitCode: 0
+});
+var failure = (stderr) => ({
+  stdout: "",
+  stderr,
+  exitCode: 1
+});
+function formatRecord(fields) {
+  return fields.filter(
+    (field) => field[1] !== void 0
+  ).map(([key, rawValue]) => {
+    const [firstLine = "", ...continuationLines] = String(rawValue).split("\n");
+    return [`... ${key} ${firstLine}`, ...continuationLines].join("\n");
+  }).join("\n");
+}
+function formatRecords(records) {
+  if (records.length === 0) {
+    return "";
+  }
+  return `${records.map(formatRecord).join("\n\n")}
+`;
+}
+function normalizePath(value) {
+  return value.replaceAll("\\", "/");
+}
+function relativePosix(from, to) {
+  const fromParts = from.replace(/\/+$/, "").split("/").filter(Boolean);
+  const toParts = to.split("/").filter(Boolean);
+  let i = 0;
+  while (i < fromParts.length && i < toParts.length && fromParts[i] === toParts[i])
+    i += 1;
+  const up = fromParts.slice(i).map(() => "..");
+  return [...up, ...toParts.slice(i)].join("/");
+}
+function parseCommandFiles(args) {
+  let change = "default";
+  const files = [];
+  for (let index = 1; index < args.length; index += 1) {
+    const argument = args[index];
+    if (argument === void 0) {
+      continue;
+    }
+    if (argument === "-c") {
+      change = args[index + 1] ?? "default";
+      index += 1;
+    } else if (!argument.startsWith("-")) {
+      files.push(argument);
+    }
+  }
+  return { change, files };
+}
+var MockP4Runner = class {
+  #state;
+  constructor(state) {
+    this.#state = state;
+  }
+  get state() {
+    return this.#state;
+  }
+  async run(args, opts) {
+    const commandArgs = args[0] === "-ztag" ? args.slice(1) : [...args];
+    const command = commandArgs[0];
+    switch (command) {
+      case "info":
+        return this.runInfo();
+      case "fstat":
+        return this.runFstat(commandArgs);
+      case "opened":
+        return this.runOpened(commandArgs);
+      case "edit":
+        return this.runEdit(commandArgs);
+      case "add":
+        return this.runAdd(commandArgs);
+      case "revert":
+        return this.runRevert(commandArgs);
+      case "where":
+        return this.runWhere(commandArgs);
+      case "changes":
+        return this.runChanges(commandArgs);
+      case "describe":
+        return this.runDescribe(commandArgs);
+      case "change":
+        return this.runChange(commandArgs, opts);
+      case "sync":
+        return this.runSync();
+      case "filelog":
+        return this.runFilelog(commandArgs);
+      default:
+        return failure(`Unsupported mock p4 command: ${command ?? ""}`);
+    }
+  }
+  runInfo() {
+    return success(
+      formatRecords([
+        [
+          ["userName", this.#state.user],
+          ["clientName", this.#state.client],
+          ["clientRoot", this.#state.root],
+          ["serverAddress", this.#state.port]
+        ]
+      ])
+    );
+  }
+  runFstat(args) {
+    const requested = args.slice(1).filter((argument) => !argument.startsWith("-"));
+    const files = requested.length === 0 ? this.#state.files : requested.flatMap((file) => this.findFiles(file));
+    return success(
+      formatRecords(files.map((file) => this.fileStatFields(file)))
+    );
+  }
+  runOpened(args) {
+    const { files } = parseCommandFiles(args);
+    const changeIndex = args.indexOf("-c");
+    const requestedChange = changeIndex === -1 ? void 0 : args[changeIndex + 1];
+    const openedFiles = this.#state.files.filter((file) => {
+      if (file.opened === void 0) {
+        return false;
+      }
+      if (requestedChange !== void 0 && file.opened.change !== requestedChange) {
+        return false;
+      }
+      return files.length === 0 || files.some((requested) => this.matches(file, requested));
+    });
+    return success(
+      formatRecords(openedFiles.map((file) => this.openedFields(file)))
+    );
+  }
+  runEdit(args) {
+    const { change, files } = parseCommandFiles(args);
+    const edited = [];
+    for (const requested of files) {
+      const file = this.findFile(requested);
+      if (file === void 0 || file.headRev === void 0) {
+        return failure(`${requested} - no such file(s).`);
+      }
+      file.opened = { action: "edit", change };
+      edited.push(file);
+    }
+    return success(
+      formatRecords(edited.map((file) => this.openedFields(file)))
+    );
+  }
+  runAdd(args) {
+    const { change, files } = parseCommandFiles(args);
+    const added = [];
+    for (const requested of files) {
+      let file = this.findFile(requested);
+      if (file === void 0) {
+        const clientFile = normalizePath(requested);
+        file = {
+          depotFile: this.toDepotFile(clientFile),
+          clientFile,
+          headType: "text"
+        };
+        this.#state.files.push(file);
+      }
+      file.opened = { action: "add", change };
+      added.push(file);
+    }
+    return success(formatRecords(added.map((file) => this.openedFields(file))));
+  }
+  runRevert(args) {
+    const { files } = parseCommandFiles(args);
+    const reverted = [];
+    for (const requested of files) {
+      const fileIndex = this.#state.files.findIndex(
+        (file2) => this.matches(file2, requested)
+      );
+      const file = this.#state.files[fileIndex];
+      if (file === void 0 || file.opened === void 0) {
+        continue;
+      }
+      reverted.push([["depotFile", file.depotFile]]);
+      if (file.opened.action === "add" && file.headRev === void 0) {
+        this.#state.files.splice(fileIndex, 1);
+      } else {
+        delete file.opened;
+      }
+    }
+    return success(formatRecords(reverted));
+  }
+  runWhere(args) {
+    const requested = args.find(
+      (argument, index) => index > 0 && !argument.startsWith("-")
+    );
+    const file = requested === void 0 ? void 0 : this.findFile(requested);
+    if (file === void 0) {
+      return failure(`${requested ?? ""} - file(s) not in client view.`);
+    }
+    return success(
+      formatRecords([
+        [
+          ["depotFile", file.depotFile],
+          ["clientFile", file.clientFile],
+          ["path", file.clientFile]
+        ]
+      ])
+    );
+  }
+  runChanges(args) {
+    let status;
+    let max;
+    for (let index = 1; index < args.length; index += 1) {
+      if (args[index] === "-s") {
+        status = args[index + 1];
+        index += 1;
+      } else if (args[index] === "-m") {
+        max = Number(args[index + 1]);
+        index += 1;
+      }
+    }
+    let changelists = [...this.#state.changelists ?? []];
+    if (status !== void 0) {
+      changelists = changelists.filter(
+        (changelist) => changelist.status === status
+      );
+    }
+    if (max !== void 0 && Number.isFinite(max)) {
+      changelists = changelists.slice(0, max);
+    }
+    return success(
+      formatRecords(
+        changelists.map((changelist) => [
+          ["change", changelist.change],
+          ["desc", changelist.description],
+          ["status", changelist.status],
+          ["user", changelist.user],
+          ["client", changelist.client]
+        ])
+      )
+    );
+  }
+  runDescribe(args) {
+    const change = [...args].reverse().find((argument) => !argument.startsWith("-"));
+    const changelist = this.#state.changelists?.find(
+      (item) => item.change === change
+    );
+    if (changelist === void 0) {
+      return failure(`Change ${change ?? ""} unknown.`);
+    }
+    const fields = [
+      ["change", changelist.change],
+      ["desc", changelist.description],
+      ["user", changelist.user],
+      ["status", changelist.status]
+    ];
+    for (const [index, depotFile] of (changelist.files ?? []).entries()) {
+      const file = this.findFile(depotFile);
+      fields.push([`depotFile${index}`, depotFile]);
+      fields.push([`action${index}`, file?.opened?.action ?? "edit"]);
+      fields.push([`rev${index}`, file?.headRev]);
+    }
+    return success(formatRecords([fields]));
+  }
+  runChange(args, opts) {
+    if (!args.includes("-i")) {
+      return failure("MockP4Runner only supports change -i.");
+    }
+    const changelists = this.#state.changelists ?? [];
+    this.#state.changelists = changelists;
+    const nextChange = String(
+      changelists.reduce((highest, changelist) => {
+        const value = Number(changelist.change);
+        return Number.isFinite(value) ? Math.max(highest, value) : highest;
+      }, 0) + 1
+    );
+    const description = this.parseDescription(opts?.input ?? "");
+    changelists.push({
+      change: nextChange,
+      description,
+      status: "pending",
+      user: this.#state.user,
+      client: this.#state.client,
+      files: []
+    });
+    return success(formatRecords([[["change", nextChange]]]));
+  }
+  runSync() {
+    const records = this.#state.files.filter((file) => file.headRev !== void 0).map((file) => [
+      ["depotFile", file.depotFile],
+      ["rev", file.headRev]
+    ]);
+    return success(formatRecords(records));
+  }
+  runFilelog(args) {
+    const files = [];
+    for (let index = 1; index < args.length; index += 1) {
+      const argument = args[index];
+      if (argument === "-m") {
+        index += 1;
+      } else if (argument !== void 0 && !argument.startsWith("-")) {
+        files.push(argument);
+      }
+    }
+    const requested = files[0];
+    const file = requested === void 0 ? void 0 : this.findFile(requested);
+    if (file === void 0 || file.headRev === void 0) {
+      return failure(`${requested ?? ""} - no such file(s).`);
+    }
+    const fields = [
+      ["depotFile", file.depotFile],
+      ["rev0", file.headRev],
+      ["change0", "1"],
+      ["action0", "add"],
+      ["user0", this.#state.user],
+      ["desc0", "initial revision"]
+    ];
+    return success(formatRecords([fields]));
+  }
+  fileStatFields(file) {
+    return [
+      ["depotFile", file.depotFile],
+      ["clientFile", file.clientFile],
+      ["headType", file.headType],
+      ["headRev", file.headRev],
+      ["fileSize", file.sizeBytes],
+      ["action", file.opened?.action],
+      ["change", file.opened?.change]
+    ];
+  }
+  openedFields(file) {
+    return [
+      ["depotFile", file.depotFile],
+      ["clientFile", file.clientFile],
+      ["rev", file.headRev],
+      ["action", file.opened?.action],
+      ["change", file.opened?.change],
+      ["type", file.headType ?? "text"]
+    ];
+  }
+  findFiles(requested) {
+    return this.#state.files.filter((file) => this.matches(file, requested));
+  }
+  findFile(requested) {
+    return this.#state.files.find((file) => this.matches(file, requested));
+  }
+  matches(file, requested) {
+    const normalized = normalizePath(requested);
+    if (normalized.endsWith("/...")) {
+      const prefix = normalized.slice(0, -3);
+      return normalizePath(file.clientFile).startsWith(prefix) || file.depotFile.startsWith(prefix);
+    }
+    return normalizePath(file.clientFile) === normalized || file.depotFile === normalized;
+  }
+  toDepotFile(clientFile) {
+    const normalizedRoot = normalizePath(this.#state.root).replace(/\/$/, "");
+    const relative = relativePosix(normalizedRoot, clientFile);
+    const trackedFile = this.#state.files.find(
+      (file) => file.headRev !== void 0
+    );
+    if (trackedFile !== void 0) {
+      const trackedRelative = relativePosix(
+        normalizedRoot,
+        normalizePath(trackedFile.clientFile)
+      );
+      const suffix = `/${trackedRelative}`;
+      const depotRoot = trackedFile.depotFile.endsWith(suffix) ? trackedFile.depotFile.slice(0, -suffix.length) : "//depot";
+      return `${depotRoot}/${relative}`;
+    }
+    return `//depot/${relative}`;
+  }
+  parseDescription(input) {
+    const lines = input.split(/\r?\n/);
+    const descriptionIndex = lines.findIndex(
+      (line) => line.startsWith("Description:")
+    );
+    if (descriptionIndex === -1) {
+      return "";
+    }
+    const descriptionLines = [];
+    for (const line of lines.slice(descriptionIndex + 1)) {
+      if (/^[A-Za-z][A-Za-z0-9-]*:/.test(line)) {
+        break;
+      }
+      descriptionLines.push(line.replace(/^\t/, ""));
+    }
+    return descriptionLines.join("\n").trim();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_ASSET_GUARD_CONFIG,
+  MockP4Runner,
+  P4Client,
+  P4PilotError,
+  buildChangelistDescription,
+  classifyAsset,
+  ensureOpenForEdit,
+  ensureOpenForEditMany,
+  groupIndexed,
+  parseZtag
+});