@uipath/vertical-solutions-tool 1.204.0 → 1.205.0-preview.258

package/dist/tool-s9qbxa2g.js

@@ -0,0 +1,638 @@
+import {
+  jsonObject
+} from "./tool-87e2ps7f.js";
+import {
+  exports_external
+} from "./tool-vf2mgth0.js";
+import {
+  canPrompt,
+  catchError
+} from "./tool-pz9qm3dv.js";
+import {
+  getFileSystem
+} from "./tool-hdxtgckw.js";
+
+// src/services/seed/workspace.ts
+import { randomUUID } from "node:crypto";
+var SEED_ROOT_DIR = "seeding";
+var SEED_CONTEXT_FILE = ".seed-context.json";
+var SEED_JOURNAL_FILE = ".seed-ids.json";
+function tempPathFor(target) {
+  return `${target}.${randomUUID()}.uip-tmp`;
+}
+async function writeFileByRename(target, contents) {
+  const fs = getFileSystem();
+  const temp = tempPathFor(target);
+  const [writeError] = await catchError(fs.writeFile(temp, contents));
+  const [renameError] = writeError ? [writeError] : await catchError(fs.rename(temp, target));
+  if (renameError) {
+    await catchError(fs.rm(temp));
+    throw renameError;
+  }
+}
+function isPreservedWorkspaceFile(name) {
+  const folded = name.replace(/[. ]+$/, "").toLowerCase();
+  return folded === SEED_CONTEXT_FILE || folded === SEED_JOURNAL_FILE || folded.startsWith(`${SEED_CONTEXT_FILE}.`) || folded.startsWith(`${SEED_JOURNAL_FILE}.`);
+}
+function seedRoot(fs = getFileSystem()) {
+  return fs.path.join(fs.env.cwd(), SEED_ROOT_DIR);
+}
+var PACKAGE_NAME_PATTERN = /^[A-Za-z0-9_](?:[A-Za-z0-9._-]{0,198}[A-Za-z0-9_-])?$/;
+var WINDOWS_DEVICE_NAME = /^(?:CON|PRN|AUX|NUL|COM[1-9¹²³]|LPT[1-9¹²³])$/i;
+function isWindowsDeviceName(segment) {
+  const base = segment.split(".")[0].replace(/ +$/, "");
+  return WINDOWS_DEVICE_NAME.test(base);
+}
+function reservedOnThisPlatform(segment, platform = process.platform) {
+  return platform === "win32" && isWindowsDeviceName(segment);
+}
+function packageNameProblem(packageName) {
+  if (packageName === "" || packageName === "." || packageName === "..") {
+    return `"${packageName}" is not a package name.`;
+  }
+  if (!PACKAGE_NAME_PATTERN.test(packageName)) {
+    return `"${packageName}" cannot name a seed workspace: use letters, digits, ` + "dots, hyphens and underscores only, with no path separators and " + "no dot at the end.";
+  }
+  if (reservedOnThisPlatform(packageName)) {
+    return `"${packageName}" cannot name a seed workspace: Windows reserves it as a device name.`;
+  }
+  return;
+}
+function entityNameProblem(entityName) {
+  if (entityName === "" || /^\.+$/.test(entityName)) {
+    return `"${entityName}" is not an entity name.`;
+  }
+  if (!PACKAGE_NAME_PATTERN.test(entityName)) {
+    return `"${entityName}" cannot name a seed file: use letters, digits, dots, ` + "hyphens and underscores only, with no path separators and no dot " + "at the end.";
+  }
+  if (reservedOnThisPlatform(entityName)) {
+    return `"${entityName}" cannot name a seed file: Windows reserves it as a device name.`;
+  }
+  return;
+}
+function packageDir(packageName) {
+  const problem = packageNameProblem(packageName);
+  if (problem)
+    throw new Error(problem);
+  return getFileSystem().path.join(seedRoot(), packageName);
+}
+
+// src/services/error-code.ts
+var WithCode = exports_external.object({ code: exports_external.string() });
+function errorCode(error) {
+  const parsed = WithCode.safeParse(error);
+  return parsed.success ? parsed.data.code : undefined;
+}
+
+// src/services/seed/workspace-containment.ts
+async function workspaceRoot(dir, fs = getFileSystem()) {
+  const lexical = fs.path.resolve(dir);
+  return { lexical, real: await realpathThroughAncestors(lexical, fs) };
+}
+async function isCaseInsensitiveDisk(root, fs = getFileSystem()) {
+  const probe = await nearestProbe(root.real, fs);
+  if (probe === undefined)
+    return;
+  const flipped = flipCase(probe);
+  if (!await fs.exists(flipped))
+    return false;
+  const [listError, entries] = await catchError(fs.readdir(fs.path.dirname(flipped)));
+  if (listError || entries === undefined)
+    return;
+  const flippedName = fs.path.basename(flipped).normalize("NFC");
+  if (entries.some((entry) => entry.normalize("NFC") === flippedName)) {
+    return false;
+  }
+  const [resolveError, resolved] = await catchError(fs.realpath(flipped));
+  if (resolveError || resolved === undefined)
+    return;
+  return resolved.normalize("NFC") === probe.normalize("NFC");
+}
+function flipCase(path) {
+  return path.replace(/[A-Za-z]/g, (char) => char === char.toLowerCase() ? char.toUpperCase() : char.toLowerCase());
+}
+async function nearestProbe(path, fs) {
+  for (let current = path;; current = fs.path.dirname(current)) {
+    if (/[A-Za-z]/.test(fs.path.basename(current)) && await fs.exists(current)) {
+      return current;
+    }
+    if (fs.path.dirname(current) === current)
+      return;
+  }
+}
+async function pathHasExpectedTarget(root, path, fs) {
+  if (!await fs.exists(path)) {
+    const [listError, entries] = await catchError(fs.readdir(fs.path.dirname(path)));
+    if (listError) {
+      return isMissingOrNotADirectory(listError) ? true : undefined;
+    }
+    if (!entries)
+      return true;
+    const name = fs.path.basename(path).normalize("NFC");
+    const folded = name.toLowerCase();
+    const exact = entries.some((entry) => entry.normalize("NFC") === name);
+    if (exact)
+      return false;
+    if (await isCaseInsensitiveDisk(root) === false)
+      return true;
+    return !entries.some((entry) => {
+      const normalized = entry.normalize("NFC");
+      return normalized.toLowerCase() === folded;
+    });
+  }
+  const lexical = fs.path.resolve(path);
+  const relative = fs.path.relative(root.lexical, lexical);
+  const expected = fs.path.join(root.real, relative).normalize("NFC");
+  const actual = (await fs.realpath(path)).normalize("NFC");
+  if (expected === actual)
+    return true;
+  if (await isCaseInsensitiveDisk(root) !== true)
+    return false;
+  return expected.toLowerCase() === actual.toLowerCase();
+}
+function isUnder(fs, root, path) {
+  const relative = fs.path.relative(root, path);
+  return relative === "" || relative.split(/[\\/]/)[0] !== ".." && !fs.path.isAbsolute(relative);
+}
+async function namesSeedRoot(dir, fs = getFileSystem()) {
+  const root = fs.path.resolve(seedRoot(fs));
+  const target = fs.path.resolve(fs.env.cwd(), dir);
+  if (isUnder(fs, root, target))
+    return true;
+  const folds = await isCaseInsensitiveDisk(await workspaceRoot(root, fs));
+  if (folds === false)
+    return false;
+  return isUnder(fs, root.toLowerCase(), target.toLowerCase());
+}
+async function isInsideWorkspace(root, path, fs = getFileSystem()) {
+  const resolved = await realpathThroughAncestors(path, fs);
+  return isUnder(fs, root.real, resolved) || isUnder(fs, root.lexical, resolved);
+}
+function isMissingOrNotADirectory(error) {
+  const code = errorCode(error);
+  return code === "ENOENT" || code === "ENOTDIR";
+}
+var MAX_ANCESTOR_WALK = 64;
+async function realpathThroughAncestors(path, fs, depth = 0) {
+  const absolute = fs.path.resolve(path);
+  const real = await fs.realpath(absolute);
+  if (real !== absolute)
+    return real;
+  if (typeof fs.exists === "function" && await fs.exists(absolute)) {
+    return absolute;
+  }
+  const parent = fs.path.dirname(absolute);
+  if (depth > 0 && typeof fs.readdir === "function" && parent !== absolute) {
+    const [listError, entries] = await catchError(fs.readdir(parent));
+    if (listError && !isMissingOrNotADirectory(listError)) {
+      throw new Error(`Could not check where ${path} leads: ${parent} could not be ` + `listed (${listError.message}).`);
+    }
+    const name = fs.path.basename(absolute).normalize("NFC");
+    const folded = name.toLowerCase();
+    const sameName = (entry) => entry.normalize("NFC") === name;
+    const foldsOnto = (entry) => entry.normalize("NFC").toLowerCase() === folded;
+    const dangling = entries?.some(sameName) === true || entries?.some(foldsOnto) === true && await isCaseInsensitiveDisk({
+      lexical: parent,
+      real: await fs.realpath(parent)
+    }) !== false;
+    if (dangling) {
+      throw new Error(`${path} is a link to a path that does not exist; refusing to ` + "use it. Replace the link with a real file or folder.");
+    }
+  }
+  if (parent === absolute)
+    return absolute;
+  if (depth >= MAX_ANCESTOR_WALK) {
+    throw new Error(`Could not work out where ${path} leads: it names more than ` + `${MAX_ANCESTOR_WALK} folders that do not exist yet.`);
+  }
+  const realParent = await realpathThroughAncestors(parent, fs, depth + 1);
+  return realParent === parent ? absolute : fs.path.join(realParent, fs.path.basename(absolute));
+}
+async function isDanglingLink(path, fs = getFileSystem()) {
+  if (await fs.exists(path))
+    return false;
+  const parent = fs.path.dirname(path);
+  const [listError, entries] = await catchError(fs.readdir(parent));
+  if (listError) {
+    if (isMissingOrNotADirectory(listError))
+      return false;
+    throw listError;
+  }
+  if (!entries)
+    return false;
+  const name = fs.path.basename(path);
+  const spelled = name.normalize("NFC");
+  if (entries.some((entry) => entry.normalize("NFC") === spelled)) {
+    return true;
+  }
+  const caseless = await isCaseInsensitiveDisk(await workspaceRoot(parent, fs), fs);
+  if (caseless === false)
+    return false;
+  const folded = name.normalize("NFC").toLowerCase();
+  return entries.some((entry) => entry.normalize("NFC").toLowerCase() === folded);
+}
+
+// src/services/seed/seed-dir.ts
+async function metadataIsItsOwnFile(dir, name, fs) {
+  const [error, ok] = await catchError(async () => {
+    if (await namesSeedRoot(dir, fs)) {
+      const inside = await insideSeedRoot(dir, fs);
+      if (!inside.ok)
+        return false;
+    }
+    const root = await workspaceRoot(dir, fs);
+    const path = fs.path.join(dir, name);
+    return await isInsideWorkspace(root, path, fs) && await pathHasExpectedTarget(root, path, fs);
+  });
+  return !error && ok === true;
+}
+async function resolveSeedDir(options) {
+  const fs = getFileSystem();
+  if (options.dir !== undefined)
+    return resolveExplicitDir(options.dir);
+  const linkedRoot = await seedRootLinkProblem();
+  if (linkedRoot)
+    return linkedRoot;
+  if (options.packageName !== undefined) {
+    const problem = packageNameProblem(options.packageName);
+    if (problem) {
+      return {
+        ok: false,
+        message: `--package-name ${problem}`,
+        instructions: "Pass the package name as the manifest spells it, or point --dir at the seed folder."
+      };
+    }
+    return resolvePackageDir(options.packageName);
+  }
+  const root = seedRoot();
+  const rootProblem = await seedRootProblem(root);
+  if (rootProblem)
+    return rootProblem;
+  if (await holdsSeedFiles(root))
+    return insideSeedRoot(root);
+  const candidates = await listPackageDirs(root);
+  if (candidates.length === 0) {
+    return { ok: true, dir: root };
+  }
+  if (candidates.length === 1) {
+    return insideSeedRoot(fs.path.join(root, candidates[0]));
+  }
+  if (!canPrompt() || !options.pickOne) {
+    return {
+      ok: false,
+      message: `${candidates.length} seed workspaces exist: ${candidates.join(", ")}.`,
+      instructions: "Name the one to seed with --package-name <name>, or pass --dir <path>."
+    };
+  }
+  const picked = await options.pickOne("Seed workspace", candidates);
+  const chosen = await insideSeedRoot(fs.path.join(root, picked));
+  return chosen.ok ? { ...chosen, picked: true } : chosen;
+}
+async function seedRootLinkProblem() {
+  const fs = getFileSystem();
+  const root = await workspaceRoot(seedRoot(), fs);
+  const target = await seedRootIsLinked(root, fs);
+  if (!target)
+    return;
+  return {
+    ok: false,
+    message: `The seed root ${root.lexical} is a link to ${target}.`,
+    instructions: LINKED_OUT_INSTRUCTIONS
+  };
+}
+async function insideSeedRoot(dir, fs = getFileSystem()) {
+  const root = await workspaceRoot(seedRoot(fs), fs);
+  const linkedRoot = await seedRootIsLinked(root, fs);
+  if (linkedRoot) {
+    return {
+      ok: false,
+      message: `The seed root ${root.lexical} is a link to ${linkedRoot}.`,
+      instructions: LINKED_OUT_INSTRUCTIONS
+    };
+  }
+  if (await isDanglingLink(dir, fs)) {
+    return {
+      ok: false,
+      message: `The seed workspace ${dir} is a link to a path that does not exist.`,
+      instructions: LINKED_OUT_INSTRUCTIONS
+    };
+  }
+  const inside = await isInsideWorkspace(root, dir, fs);
+  const ownPath = inside ? await pathHasExpectedTarget(root, dir, fs) : false;
+  if (ownPath === true)
+    return { ok: true, dir };
+  if (inside && ownPath === undefined) {
+    return {
+      ok: false,
+      message: `The seed workspace ${dir} could not be checked for a link.`,
+      instructions: LINKED_OUT_INSTRUCTIONS
+    };
+  }
+  if (inside) {
+    return {
+      ok: false,
+      message: `The seed workspace ${dir} is a link to another seed workspace.`,
+      instructions: LINKED_OUT_INSTRUCTIONS
+    };
+  }
+  return {
+    ok: false,
+    message: `The seed workspace ${dir} links outside ${root.lexical}.`,
+    instructions: LINKED_OUT_INSTRUCTIONS
+  };
+}
+async function seedRootIsLinked(root, fs) {
+  if (!await fs.exists(root.lexical)) {
+    const [danglingError, dangling] = await catchError(isDanglingLink(root.lexical, fs));
+    if (danglingError)
+      return "a path that could not be checked";
+    return dangling ? "a path that does not exist" : undefined;
+  }
+  const parent = await workspaceRoot(fs.path.dirname(root.lexical), fs);
+  const [error, ownPath] = await catchError(pathHasExpectedTarget(parent, root.lexical, fs));
+  if (ownPath === true)
+    return;
+  const [, real] = await catchError(fs.realpath(root.lexical));
+  if (error || ownPath === undefined) {
+    return real === undefined || real === root.lexical ? "a path that could not be checked" : real;
+  }
+  return real ?? "somewhere else";
+}
+var LINKED_OUT_INSTRUCTIONS = "Replace the link with a real folder, or pass --dir <path> to seed from that folder on purpose.";
+async function seedRootProblem(root) {
+  const [, stats] = await catchError(getFileSystem().stat(root));
+  if (!stats) {
+    return {
+      ok: false,
+      message: `No seed workspace found at ${root}.`,
+      instructions: "A successful deploy writes the seed templates. Run 'uip vss deploy' first, " + "or pass --dir <path>."
+    };
+  }
+  if (!stats.isDirectory()) {
+    return {
+      ok: false,
+      message: `The seed workspace root is not a directory: ${root}`,
+      instructions: "Move the file at that path out of the way, or point --dir at the folder holding the seed CSVs."
+    };
+  }
+  return;
+}
+async function resolvePackageDir(packageName) {
+  const dir = packageDir(packageName);
+  const [, stats] = await catchError(getFileSystem().stat(dir));
+  if (!stats && await isDanglingLink(dir))
+    return insideSeedRoot(dir);
+  if (!stats) {
+    return {
+      ok: false,
+      message: `No seed workspace for "${packageName}" at ${dir}.`,
+      instructions: "A deploy that runs to the end writes it. Pass --package-version <version> " + "to create it from that version's seed templates, or --dir <path> to use " + "another folder.",
+      missing: true
+    };
+  }
+  if (!stats.isDirectory()) {
+    return {
+      ok: false,
+      message: `The seed workspace for "${packageName}" is not a directory: ${dir}`,
+      instructions: "Remove or rename that file, or pass --dir <path> to use another folder."
+    };
+  }
+  return insideSeedRoot(dir);
+}
+async function resolveExplicitDir(dir) {
+  const fs = getFileSystem();
+  if (dir.trim() === "") {
+    return {
+      ok: false,
+      message: "--dir was given no path.",
+      instructions: "Pass the folder holding the seed workspace, or drop --dir to use " + "./seeding/<package-name>."
+    };
+  }
+  const absolute = fs.path.isAbsolute(dir) ? dir : fs.path.join(fs.env.cwd(), dir);
+  const [, stats] = await catchError(fs.stat(absolute));
+  if (!stats?.isDirectory()) {
+    return {
+      ok: false,
+      message: stats ? `--dir is not a directory: ${dir}` : `--dir not found: ${dir}`,
+      instructions: "Run a deploy first, or point --dir at the folder holding the seed CSVs."
+    };
+  }
+  if (await namesSeedRoot(absolute)) {
+    return insideSeedRoot(absolute);
+  }
+  return { ok: true, dir: absolute };
+}
+async function holdsSeedFiles(dir) {
+  const fs = getFileSystem();
+  const [listError, entries] = await catchError(fs.readdir(dir));
+  if (listError && !isMissingOrNotADirectory(listError))
+    throw listError;
+  if (listError || !entries)
+    return false;
+  return entries.some((entry) => !entry.startsWith(".") && entry.toLowerCase().endsWith(".csv"));
+}
+async function listPackageDirs(root) {
+  const fs = getFileSystem();
+  const [listError, entries] = await catchError(fs.readdir(root));
+  if (listError && !isMissingOrNotADirectory(listError))
+    throw listError;
+  if (listError || !entries)
+    return [];
+  const dirs = [];
+  for (const entry of entries) {
+    if (entry.startsWith("."))
+      continue;
+    const path = fs.path.join(root, entry);
+    const [, stats] = await catchError(fs.stat(path));
+    if (stats?.isDirectory()) {
+      dirs.push(entry);
+      continue;
+    }
+    if (!stats && await isDanglingLink(path))
+      dirs.push(entry);
+  }
+  return dirs.sort((a, b) => a.localeCompare(b));
+}
+
+// src/services/seed/journal.ts
+async function acquireSeedWorkspaceLock(dir, fs = getFileSystem()) {
+  const root = await workspaceRoot(dir, fs);
+  const journal = fs.path.join(dir, SEED_JOURNAL_FILE);
+  if (typeof fs.acquireLock !== "function")
+    return async () => {
+      return;
+    };
+  if (typeof fs.exists !== "function")
+    return fs.acquireLock(journal);
+  if (!await isInsideWorkspace(root, journal, fs) || await pathHasExpectedTarget(root, journal, fs) === false) {
+    throw new Error(`The seed journal ${journal} is a link; refusing to lock it. Replace the link with a real file.`);
+  }
+  return fs.acquireLock(journal);
+}
+var JOURNAL_VERSION = 1;
+function journalScopeKeys(scope) {
+  const raw = (value) => (value ?? "").trim();
+  if (raw(scope.organizationId) && raw(scope.tenantId)) {
+    return [
+      ...new Set([
+        `${raw(scope.organizationId)}/${raw(scope.tenantId)}/` + `${raw(scope.folderKey) || "tenant"}`,
+        journalScopeKey({
+          organizationId: scope.organizationId,
+          tenantId: scope.tenantId,
+          folderKey: scope.folderKey
+        })
+      ])
+    ];
+  }
+  return [journalScopeKey(scope)];
+}
+function journalReadKeys(scope) {
+  return journalScopeKeys(scope);
+}
+function journalScopeKey(scope) {
+  const part = (value) => encodeURIComponent((value ?? "").trim().toLowerCase());
+  const org = part(scope.organizationName) || part(scope.organizationId);
+  const tenant = part(scope.tenantName) || part(scope.tenantId);
+  if (org === "" || tenant === "") {
+    throw new Error("Cannot record seeded rows: this run does not know which " + "organization and tenant it is seeding. Run `uip login` and " + "try again.");
+  }
+  return `${org}/${tenant}/${part(scope.folderKey) || "tenant"}`;
+}
+function emptyJournalFile() {
+  return { version: JOURNAL_VERSION, scopes: Object.create(null) };
+}
+async function readJournalFile(dir) {
+  const fs = getFileSystem();
+  const path = fs.path.join(dir, SEED_JOURNAL_FILE);
+  if (!await metadataIsItsOwnFile(dir, SEED_JOURNAL_FILE, fs)) {
+    return {
+      file: emptyJournalFile(),
+      unreadable: true,
+      warning: `Seed journal ${path} is not the workspace's own file — it, or the ` + `workspace holding it, is a link. Refusing to read it. ${JOURNAL_LOST_HINT}`
+    };
+  }
+  const [readError, contents] = await catchError(fs.readFile(path, "utf-8"));
+  if (readError) {
+    return {
+      file: emptyJournalFile(),
+      unreadable: true,
+      warning: `Seed journal ${path} could not be read (${readError.message}) — starting fresh. ` + JOURNAL_LOST_HINT
+    };
+  }
+  if (contents === null)
+    return { file: emptyJournalFile() };
+  const [parseError, parsed] = catchError(() => JSON.parse(contents));
+  const current = CurrentJournalSchema.safeParse(parsed);
+  if (!parseError && current.success) {
+    return { file: normalizeJournalFile(current.data.scopes) };
+  }
+  const foreign = ForeignJournalSchema.safeParse(parsed);
+  if (!parseError && foreign.success) {
+    return {
+      file: emptyJournalFile(),
+      unreadable: true,
+      warning: `Seed journal ${path} is version ${String(foreign.data.version)}, which this CLI ` + "does not know — leaving it alone and seeding without it. " + JOURNAL_LOST_HINT
+    };
+  }
+  return {
+    file: emptyJournalFile(),
+    warning: `Seed journal ${path} is unreadable or in an old format — starting fresh. ` + JOURNAL_LOST_HINT
+  };
+}
+var CurrentJournalSchema = exports_external.object({
+  version: exports_external.literal(JOURNAL_VERSION),
+  scopes: jsonObject
+});
+var ForeignJournalSchema = exports_external.object({
+  version: exports_external.custom((version) => typeof version === "number" || typeof version === "string").refine((version) => version !== JOURNAL_VERSION),
+  scopes: jsonObject
+});
+var JournalMapSchema = exports_external.union([jsonObject, exports_external.array(exports_external.unknown())]);
+var JournalEntrySchema = exports_external.object({
+  recordId: exports_external.string().min(1),
+  pendingFiles: exports_external.array(exports_external.unknown()).optional().catch(undefined)
+}).transform((entry) => ({
+  recordId: entry.recordId,
+  ...entry.pendingFiles !== undefined && entry.pendingFiles.length > 0 ? { pendingFiles: entry.pendingFiles.map(String) } : {}
+}));
+var JOURNAL_LOST_HINT = "Retry protection for previously seeded rows is lost; rows already in Data Fabric " + "may be inserted again.";
+function normalizeJournalFile(rawScopes) {
+  const scopes = Object.create(null);
+  for (const [scopeKey, raw] of Object.entries(rawScopes)) {
+    const scope = JournalMapSchema.safeParse(raw);
+    if (scope.success)
+      scopes[scopeKey] = normalizeScope(scope.data);
+  }
+  return { version: JOURNAL_VERSION, scopes };
+}
+function normalizeScope(scope) {
+  const entities = Object.create(null);
+  for (const [entity, raw] of Object.entries(scope)) {
+    const rows = JournalMapSchema.safeParse(raw);
+    if (rows.success)
+      entities[entity] = normalizeRows(rows.data);
+  }
+  return entities;
+}
+function normalizeRows(rows) {
+  const kept = Object.create(null);
+  for (const [key, raw] of Object.entries(rows)) {
+    const entry = JournalEntrySchema.safeParse(raw);
+    if (entry.success)
+      kept[key] = entry.data;
+  }
+  return kept;
+}
+async function readJournal(dir, scope) {
+  const { file, warning } = await readJournalFile(dir);
+  const journal = Object.create(null);
+  for (const key of journalReadKeys(scope)) {
+    const scoped = file.scopes[key];
+    if (!scoped)
+      continue;
+    for (const [entity, rows] of Object.entries(scoped)) {
+      if (!Object.hasOwn(journal, entity)) {
+        const empty = Object.create(null);
+        journal[entity] = empty;
+      }
+      const target = journal[entity];
+      for (const [rowKey, entry] of Object.entries(rows)) {
+        if (!Object.hasOwn(target, rowKey))
+          target[rowKey] = entry;
+      }
+    }
+  }
+  return { journal, warning };
+}
+async function writeJournal(dir, scope, journal, lockHeld = false) {
+  const fs = getFileSystem();
+  if (lockHeld) {
+    const { file, unreadable, warning } = await readJournalFile(dir);
+    if (unreadable)
+      throw new Error(warning);
+    writeScope(file, scope, journal);
+    await writeJournalFile(dir, file);
+    return;
+  }
+  const release = await acquireSeedWorkspaceLock(dir, fs);
+  try {
+    const { file, unreadable, warning } = await readJournalFile(dir);
+    if (unreadable)
+      throw new Error(warning);
+    writeScope(file, scope, journal);
+    await writeJournalFile(dir, file);
+  } finally {
+    await catchError(release());
+  }
+}
+function writeScope(file, scope, journal) {
+  for (const key of journalScopeKeys(scope))
+    file.scopes[key] = journal;
+}
+async function writeJournalFile(dir, file) {
+  const fs = getFileSystem();
+  await writeFileByRename(fs.path.join(dir, SEED_JOURNAL_FILE), JSON.stringify(file, null, 2));
+}
+
+export { SEED_ROOT_DIR, SEED_CONTEXT_FILE, tempPathFor, writeFileByRename, isPreservedWorkspaceFile, seedRoot, reservedOnThisPlatform, packageNameProblem, entityNameProblem, packageDir, errorCode, workspaceRoot, isCaseInsensitiveDisk, pathHasExpectedTarget, namesSeedRoot, isInsideWorkspace, isMissingOrNotADirectory, isDanglingLink, metadataIsItsOwnFile, resolveSeedDir, insideSeedRoot, acquireSeedWorkspaceLock, readJournal, writeJournal };
+
+//# debugId=E9C29EF019AD78A464756E2164756E21