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

package/dist/tool-e4qgwf9h.js

@@ -0,0 +1,2281 @@
+import {
+  SEED_CONTEXT_FILE,
+  entityNameProblem,
+  insideSeedRoot,
+  isDanglingLink,
+  isInsideWorkspace,
+  metadataIsItsOwnFile,
+  namesSeedRoot,
+  packageDir,
+  packageNameProblem,
+  pathHasExpectedTarget,
+  workspaceRoot,
+  writeFileByRename
+} from "./tool-s9qbxa2g.js";
+import {
+  writeWarning
+} from "./tool-v15vxc4x.js";
+import {
+  validateServiceUrl
+} from "./tool-xd2ejt3h.js";
+import {
+  encodeSegment,
+  scopeQuery,
+  vssRequestParsed
+} from "./tool-4z1dy1rn.js";
+import {
+  anyNumber,
+  jsonObject,
+  optionalText,
+  plainRecord
+} from "./tool-87e2ps7f.js";
+import {
+  exports_external
+} from "./tool-vf2mgth0.js";
+import {
+  catchError,
+  extractErrorMessage
+} from "./tool-pz9qm3dv.js";
+import {
+  getFileSystem
+} from "./tool-hdxtgckw.js";
+import {
+  __require
+} from "./tool-1yh8g550.js";
+
+// src/api/config-keys.ts
+var RESERVED_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+function configKeyProblem(key) {
+  if (key.trim() === "") {
+    return "a configuration key cannot be empty.";
+  }
+  if (RESERVED_KEYS.has(key)) {
+    return `"${key}" is not a valid configuration key.`;
+  }
+  return;
+}
+
+// src/api/manifest-sections.ts
+var ConfigurationDeclarationSchema = exports_external.looseObject({
+  isRequired: exports_external.unknown().optional().transform((value) => value !== false),
+  isSecret: exports_external.unknown().optional().transform((value) => value !== undefined && value !== false),
+  description: optionalText,
+  value: optionalText
+});
+var ManifestConfigurationsSchema = jsonObject.transform((declared) => {
+  const declarations = new Map;
+  for (const [key, meta] of Object.entries(declared)) {
+    const parsed = ConfigurationDeclarationSchema.safeParse(meta);
+    if (parsed.success)
+      declarations.set(key, parsed.data);
+  }
+  return declarations;
+}).catch(() => new Map);
+var PropertyMetaSchema = exports_external.looseObject({
+  description: optionalText,
+  default: exports_external.unknown().optional(),
+  required: exports_external.unknown().optional(),
+  value: exports_external.unknown().optional()
+});
+var RequiredSchema = exports_external.union([
+  exports_external.boolean().transform((value) => ({ value, fromText: false })),
+  exports_external.string().trim().toLowerCase().pipe(exports_external.enum(["true", "false"])).transform((text) => ({ value: text === "true", fromText: true }))
+]).optional();
+var DefaultSchema = exports_external.union([exports_external.string(), exports_external.number(), exports_external.boolean()]).transform(String).nullish();
+var DeclaredConfigurationSchema = exports_external.unknown().transform(parseDeclared).optional();
+function parseDeclared(declaration) {
+  const properties = [];
+  const warnings = [];
+  const resources = jsonObject.safeParse(declaration);
+  if (!resources.success) {
+    warnings.push("Ignoring solution.configuration in the manifest: it is not an object.");
+    return { properties, warnings };
+  }
+  for (const [resourceName, resource] of Object.entries(resources.data)) {
+    const declared = jsonObject.safeParse(resource);
+    if (!declared.success) {
+      warnings.push(`Ignoring solution.configuration.${resourceName}: it is not an object.`);
+      continue;
+    }
+    for (const [propertyName, meta] of Object.entries(declared.data)) {
+      const parsed = toDeclaredProperty(resourceName, propertyName, meta, warnings);
+      if (parsed)
+        properties.push(parsed);
+    }
+  }
+  return { properties, warnings };
+}
+function toDeclaredProperty(resourceName, propertyName, meta, warnings) {
+  const problem = configKeyProblem(propertyName);
+  if (problem) {
+    warnings.push(`Ignoring ${resourceName}.${propertyName}: ${problem}`);
+    return;
+  }
+  const parsed = PropertyMetaSchema.safeParse(meta);
+  if (!parsed.success) {
+    return {
+      resourceName,
+      propertyName,
+      required: false,
+      hasManifestValue: false
+    };
+  }
+  const label = `${resourceName}.${propertyName}`;
+  return {
+    resourceName,
+    propertyName,
+    description: parsed.data.description,
+    defaultValue: readDefault(parsed.data.default, label, warnings),
+    required: readRequired(parsed.data.required, label, warnings),
+    hasManifestValue: hasValue(parsed.data.value)
+  };
+}
+function hasValue(value) {
+  if (typeof value === "string")
+    return value.trim() !== "";
+  return typeof value === "number" || typeof value === "boolean";
+}
+function readRequired(value, label, warnings) {
+  const parsed = RequiredSchema.safeParse(value);
+  if (!parsed.success) {
+    warnings.push(`Configuration ${label}: ignoring 'required' — expected true or false, got ${describeType(value)}.`);
+    return false;
+  }
+  if (parsed.data?.fromText) {
+    warnings.push(`Configuration ${label}: 'required' should be a boolean, not a string.`);
+  }
+  return parsed.data?.value === true;
+}
+function readDefault(value, label, warnings) {
+  const parsed = DefaultSchema.safeParse(value);
+  if (parsed.success)
+    return parsed.data ?? undefined;
+  warnings.push(`Ignoring the default for ${label}: only text, numbers and true/false can be configuration values.`);
+  return;
+}
+function describeType(value) {
+  if (value === null)
+    return "null";
+  if (Array.isArray(value))
+    return "a list";
+  if (typeof value === "object")
+    return "an object";
+  return `a ${typeof value}`;
+}
+var SeedingEntrySchema = exports_external.looseObject({ strategy: optionalText });
+var SeedingSchema = jsonObject.transform((declared) => {
+  const entities = Object.create(null);
+  for (const [name, entry] of Object.entries(declared)) {
+    const parsed = SeedingEntrySchema.safeParse(entry);
+    Object.defineProperty(entities, name, {
+      value: parsed.success ? parsed.data : {},
+      writable: true,
+      enumerable: true,
+      configurable: true
+    });
+  }
+  return entities;
+}).optional().catch(undefined);
+var DeclaredNamesSchema = jsonObject.transform((declared) => Object.keys(declared)).optional().catch(undefined);
+var ConnectionEntrySchema = exports_external.looseObject({ connector: optionalText });
+var DeclaredConnectionsSchema = jsonObject.transform((declared) => {
+  const connectors = new Map;
+  for (const [name, entry] of Object.entries(declared)) {
+    const parsed = ConnectionEntrySchema.safeParse(entry);
+    connectors.set(name, parsed.success ? parsed.data.connector ?? "" : "");
+  }
+  return connectors;
+}).optional().catch(undefined);
+
+// src/api/manifest-schema.ts
+var TenantSectionSchema = exports_external.union([jsonObject, exports_external.array(exports_external.unknown())]).optional().catch(undefined);
+var PackageManifestSchema = exports_external.looseObject({
+  packageVersion: optionalText,
+  configurations: ManifestConfigurationsSchema.optional(),
+  solution: exports_external.looseObject({
+    artifactFilename: optionalText,
+    configuration: DeclaredConfigurationSchema,
+    processes: DeclaredNamesSchema,
+    assets: DeclaredNamesSchema,
+    connections: DeclaredConnectionsSchema
+  }).optional().catch(undefined),
+  dataFabric: exports_external.looseObject({
+    schemaFilename: exports_external.unknown().optional(),
+    seeding: SeedingSchema
+  }).optional().catch(undefined),
+  storageBuckets: TenantSectionSchema,
+  indexes: TenantSectionSchema
+});
+
+// src/api/packages.ts
+var VerticalListSchema = exports_external.looseObject({
+  verticals: exports_external.array(exports_external.string()).optional()
+});
+var VerticalSolutionPackageSchema = exports_external.looseObject({
+  packageName: exports_external.string(),
+  displayName: exports_external.string().nullish().catch(undefined),
+  currentVersion: optionalText
+});
+var PackageListSchema = exports_external.looseObject({
+  packages: exports_external.array(VerticalSolutionPackageSchema).optional()
+});
+var PackageVersionSchema = exports_external.looseObject({
+  version: exports_external.string(),
+  relation: exports_external.enum(["previous", "current", "next", "blocked"]).optional().catch(undefined),
+  allowed: exports_external.boolean().optional().catch(undefined),
+  requiredVersion: optionalText
+});
+var VersionNavSchema = exports_external.looseObject({
+  versions: exports_external.array(exports_external.union([exports_external.string(), PackageVersionSchema]))
+});
+async function listVerticals(config, signal) {
+  const result = await vssRequestParsed(config, "verticals", VerticalListSchema, { query: scopeQuery(config), signal });
+  return result.verticals ?? [];
+}
+async function listPackages(config, vertical, stage, signal) {
+  const result = await vssRequestParsed(config, "packages", PackageListSchema, { query: { ...scopeQuery(config), vertical, env: stage }, signal });
+  return result.packages ?? [];
+}
+async function listPackageVersions(config, packageName, options = {}) {
+  return vssRequestParsed(config, `packages/${encodeSegment("packageName", packageName)}/versions`, VersionNavSchema, {
+    query: {
+      ...scopeQuery(config),
+      env: options.stage,
+      anchorVersion: options.anchorVersion,
+      after: options.after,
+      before: options.before
+    },
+    signal: options.signal
+  });
+}
+function normalizeVersions(nav) {
+  return nav.versions.map((entry) => typeof entry === "string" ? { version: entry } : entry);
+}
+async function getManifest(config, packageName, version, signal) {
+  return vssRequestParsed(config, `packages/${encodeSegment("packageName", packageName)}` + `/versions/${encodeSegment("version", version)}/manifest`, PackageManifestSchema, { query: scopeQuery(config), signal });
+}
+
+// src/services/seed/seed-context.ts
+var SeedContextSchema = exports_external.object({
+  packageName: exports_external.string().min(1).refine((name) => packageNameProblem(name) === undefined),
+  packageVersion: exports_external.string().min(1),
+  serviceUrl: optionalText,
+  organizationId: optionalText,
+  organizationName: optionalText,
+  tenantId: optionalText,
+  tenantName: optionalText,
+  folderKey: optionalText,
+  deploymentName: optionalText
+});
+async function writeSeedContext(context, workspaceDir) {
+  const fs = getFileSystem();
+  const dir = workspaceDir ?? packageDir(context.packageName);
+  const refuseALinkedWorkspace = async () => {
+    if (!await namesSeedRoot(dir))
+      return;
+    const inside = await insideSeedRoot(dir);
+    if (!inside.ok)
+      throw new Error(inside.message);
+  };
+  await refuseALinkedWorkspace();
+  await fs.mkdir(dir);
+  await refuseALinkedWorkspace();
+  const path = fs.path.join(dir, SEED_CONTEXT_FILE);
+  await writeFileByRename(path, JSON.stringify(context, null, 2));
+  return path;
+}
+async function removeSeedContext(dir) {
+  const fs = getFileSystem();
+  if (await namesSeedRoot(dir)) {
+    const inside = await insideSeedRoot(dir);
+    if (!inside.ok)
+      throw new Error(inside.message);
+  }
+  const path = fs.path.join(dir, SEED_CONTEXT_FILE);
+  if (typeof fs.stat === "function") {
+    const stats = await fs.stat(path);
+    if (stats?.isDirectory()) {
+      throw new Error(`Refusing to remove context directory ${path}.`);
+    }
+  }
+  await fs.rm(path);
+}
+async function readSeedContext(dir) {
+  const fs = getFileSystem();
+  const path = fs.path.join(dir, SEED_CONTEXT_FILE);
+  if (!await metadataIsItsOwnFile(dir, SEED_CONTEXT_FILE, fs)) {
+    return;
+  }
+  const [readError, contents] = await catchError(fs.readFile(path, "utf-8"));
+  if (readError || contents === null)
+    return;
+  const [parseError, parsed] = catchError(() => JSON.parse(contents));
+  if (parseError)
+    return;
+  return asSeedContext(parsed);
+}
+function asSeedContext(value) {
+  const parsed = SeedContextSchema.safeParse(value);
+  if (!parsed.success)
+    return;
+  const context = parsed.data;
+  const [urlError, normalized] = catchError(() => context.serviceUrl === undefined ? undefined : validateServiceUrl(context.serviceUrl));
+  if (urlError) {
+    writeWarning(`Ignoring the service URL recorded in ${SEED_CONTEXT_FILE}: ${urlError.message} ` + "The run goes to the platform's own service; pass --service-url to name another.");
+  }
+  return {
+    packageName: context.packageName,
+    packageVersion: context.packageVersion,
+    serviceUrl: urlError ? undefined : normalized,
+    organizationId: context.organizationId,
+    organizationName: context.organizationName,
+    tenantId: context.tenantId,
+    tenantName: context.tenantName,
+    folderKey: context.folderKey,
+    deploymentName: context.deploymentName
+  };
+}
+
+// src/api/folders.ts
+var FOLDER_PAGE_SIZE = 1000;
+var MAX_FOLDER_PAGES = 50;
+async function findFolderPath(config, folderKey, signal) {
+  const [clientError, api] = await catchError(foldersApi(config));
+  if (clientError || !api)
+    return;
+  const [error, folder] = await catchError(api.foldersGetByKeyByIdentifier({ identifier: folderKey }, { signal }));
+  if (!error && folder?.fullyQualifiedName) {
+    return folder.fullyQualifiedName;
+  }
+  const [listError, folders] = await catchError(listFolderDtos(config, signal));
+  if (listError || !folders)
+    return;
+  const wanted = folderKey.toLowerCase();
+  return folders.find((entry) => entry.key?.toLowerCase() === wanted)?.fullyQualifiedName ?? undefined;
+}
+async function orchestratorApi(config, pick, folderKey) {
+  if (!config.tenantName) {
+    throw new Error("No tenant selected — run 'uip login tenant set <tenant>' first.");
+  }
+  if (!config.organizationId) {
+    throw new Error("The login carries no organization id, which the Orchestrator route needs — " + "run 'uip login' again.");
+  }
+  const sdk = await import("./index-7a3eqtxv.js");
+  return sdk.createApiClient(pick(sdk), {
+    tenant: config.tenantName,
+    ...folderKey ? { folderKey } : {}
+  });
+}
+function foldersApi(config) {
+  return orchestratorApi(config, (sdk) => sdk.FoldersApi);
+}
+async function listAllFolders(config, signal) {
+  const raw = await listFolderDtos(config, signal);
+  return raw.flatMap((folder) => {
+    const key = folder.key;
+    if (!key)
+      return [];
+    const displayName = folder.displayName ?? key;
+    return [
+      {
+        key,
+        displayName,
+        path: folder.fullyQualifiedName ?? displayName,
+        kind: folder.folderType
+      }
+    ];
+  }).sort((a, b) => a.path.localeCompare(b.path));
+}
+async function listFolderDtos(config, signal) {
+  const api = await foldersApi(config);
+  return readAllPages("Orchestrator folders", (page) => api.foldersGet(page, { signal }));
+}
+async function readAllPages(what, fetchPage) {
+  const rows = [];
+  let previousFirst;
+  for (let page = 0;page < MAX_FOLDER_PAGES; page += 1) {
+    const [error, response] = await catchError(fetchPage({
+      $top: FOLDER_PAGE_SIZE,
+      $skip: page * FOLDER_PAGE_SIZE
+    }));
+    if (error) {
+      throw new Error(`Could not list ${what}: ${await extractErrorMessage(error)}`);
+    }
+    const values = response.value ?? [];
+    const first = values.length > 0 ? JSON.stringify(values[0]) : "";
+    if (values.length === 0 || first === previousFirst)
+      break;
+    previousFirst = first;
+    rows.push(...values);
+    if (values.length < FOLDER_PAGE_SIZE)
+      break;
+  }
+  return rows;
+}
+
+// src/services/seed/sdk-schemas.ts
+var flag = exports_external.boolean().optional().catch(undefined);
+var TypeNameSchema = exports_external.union([exports_external.string(), exports_external.looseObject({ name: optionalText })]).optional().catch(undefined);
+var FieldSchema = exports_external.looseObject({
+  name: optionalText,
+  sqlType: TypeNameSchema,
+  fieldDataType: TypeNameSchema,
+  fieldDisplayType: optionalText,
+  isRequired: flag,
+  isUnique: flag,
+  isPrimaryKey: flag,
+  isSystemField: flag,
+  isAttachment: flag,
+  isForeignKey: flag,
+  choiceSetId: optionalText,
+  referenceChoiceSet: exports_external.looseObject({ id: optionalText }).optional().catch(undefined),
+  referenceEntity: exports_external.looseObject({ name: optionalText }).optional().catch(undefined)
+});
+var EntitySchema = exports_external.looseObject({
+  id: optionalText,
+  name: optionalText,
+  fields: exports_external.array(exports_external.unknown()).optional().catch(undefined),
+  externalFields: exports_external.array(exports_external.unknown()).optional().catch(undefined)
+});
+var EntityListSchema = exports_external.array(exports_external.unknown()).nullish();
+var ChoiceValueSchema = exports_external.looseObject({
+  name: optionalText,
+  displayName: optionalText,
+  numberId: anyNumber.optional().catch(undefined)
+});
+var CursorSchema = exports_external.union([
+  exports_external.string().transform((value) => ({ value })),
+  exports_external.looseObject({ value: exports_external.string() })
+]).optional().catch(undefined);
+var PageSchema = exports_external.looseObject({
+  items: exports_external.array(exports_external.unknown()).optional().catch(undefined),
+  hasNextPage: exports_external.unknown().optional(),
+  nextCursor: CursorSchema
+});
+var RecordItemsSchema = exports_external.array(jsonObject);
+var list = exports_external.array(exports_external.unknown()).optional().catch(undefined);
+var BatchResponseSchema = exports_external.looseObject({
+  successRecords: list,
+  records: list,
+  items: list,
+  value: list,
+  failureRecords: list
+});
+var WrittenRecordSchema = exports_external.looseObject({
+  Id: exports_external.unknown().optional(),
+  id: exports_external.unknown().optional()
+});
+var FailureRecordSchema = exports_external.looseObject({ error: optionalText });
+var ExpandedValueSchema = exports_external.looseObject({
+  Id: optionalText,
+  Name: optionalText,
+  Size: anyNumber.optional().catch(undefined)
+});
+
+// src/services/seed/entities.ts
+function needsExpandedRecords(entity) {
+  for (const field of entity.fields.values()) {
+    if (field.isForeignKey || field.isAttachment)
+      return true;
+  }
+  return false;
+}
+var SYSTEM_FIELDS = new Set([
+  "Id",
+  "CreateTime",
+  "CreatedBy",
+  "UpdateTime",
+  "UpdatedBy",
+  "RecordOwner"
+].map((name) => name.toLowerCase()));
+async function loadLiveEntities(sdk, folderKey) {
+  const response = await sdk.entities.getAll(folderKey === undefined ? undefined : { folderKey });
+  const entities = EntityListSchema.safeParse(response);
+  if (!entities.success) {
+    throw new Error("Data Fabric sent an entity list that is not a list.");
+  }
+  const byName = new Map;
+  for (const entity of entities.data ?? []) {
+    const normalized = toSeedEntity(camelKeys(entity));
+    if (normalized)
+      byName.set(normalized.name.toLowerCase(), normalized);
+  }
+  return { byName };
+}
+function setOwn(target, key, value) {
+  if (key === "__proto__") {
+    Object.defineProperty(target, key, {
+      value,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+    return;
+  }
+  target[key] = value;
+}
+function camelKeys(value) {
+  if (Array.isArray(value))
+    return value.map(camelKeys);
+  const record = plainRecord.safeParse(value);
+  if (!record.success)
+    return value;
+  const entries = Object.entries(record.data);
+  const out = {};
+  for (const [key, val] of entries) {
+    if (key[0] === key[0]?.toLowerCase())
+      setOwn(out, key, camelKeys(val));
+  }
+  for (const [key, val] of entries) {
+    const lowered = (key[0]?.toLowerCase() ?? "") + key.slice(1);
+    if (!Object.hasOwn(out, lowered)) {
+      setOwn(out, lowered, camelKeys(val));
+    }
+  }
+  return out;
+}
+function toSeedEntity(value) {
+  const parsed = EntitySchema.safeParse(value);
+  if (!parsed.success)
+    return;
+  const entity = parsed.data;
+  if (!entity.id || !entity.name)
+    return;
+  const fields = new Map;
+  const identityFields = [];
+  for (const item of entity.fields ?? []) {
+    const raw = FieldSchema.safeParse(item);
+    if (!raw.success || !raw.data.name)
+      continue;
+    const field = toSeedField(raw.data, raw.data.name);
+    fields.set(field.name.toLowerCase(), field);
+    if (field.isUnique && !field.isSystemField && !field.isAutoNumber) {
+      identityFields.push(field.name);
+    }
+  }
+  return {
+    id: entity.id,
+    name: entity.name,
+    fields,
+    identityFields,
+    isFederated: (entity.externalFields?.length ?? 0) > 0
+  };
+}
+function toSeedField(raw, name) {
+  const displayType = raw.fieldDisplayType ?? "";
+  const dataType = dataTypeNameOf(raw);
+  const isFile = raw.isAttachment === true || displayType === "File" || dataType === "FILE";
+  return {
+    name,
+    sqlType: sqlTypeOf(raw),
+    isRequired: raw.isRequired === true,
+    isUnique: raw.isUnique === true,
+    isPrimaryKey: raw.isPrimaryKey === true,
+    isSystemField: raw.isSystemField === true || SYSTEM_FIELDS.has(name.toLowerCase()),
+    isAttachment: isFile,
+    choiceSetId: raw.choiceSetId ?? raw.referenceChoiceSet?.id,
+    isMultiChoice: displayType === "ChoiceSetMultiple" || dataType === "CHOICE_SET_MULTIPLE",
+    isLazyText: dataType === "MULTILINE_MAX",
+    isAutoNumber: displayType === "AutoNumber" || dataType === "AUTO_NUMBER",
+    isForeignKey: !isFile && (raw.isForeignKey === true || displayType === "Relationship" || dataType === "RELATIONSHIP"),
+    referenceEntityName: isFile ? undefined : raw.referenceEntity?.name
+  };
+}
+function dataTypeNameOf(raw) {
+  const dataType = typeof raw.fieldDataType === "string" ? raw.fieldDataType : raw.fieldDataType?.name;
+  return (dataType ?? "").toUpperCase();
+}
+function sqlTypeOf(raw) {
+  if (typeof raw.sqlType === "string")
+    return raw.sqlType.toUpperCase();
+  if (raw.sqlType?.name)
+    return raw.sqlType.name.toUpperCase();
+  switch (dataTypeNameOf(raw)) {
+    case "BOOLEAN":
+      return "BIT";
+    case "INTEGER":
+      return "INT";
+    case "BIG_INTEGER":
+      return "BIGINT";
+    case "DECIMAL":
+      return "DECIMAL";
+    case "FLOAT":
+    case "DOUBLE":
+      return "FLOAT";
+    case "DATE":
+      return "DATE";
+    case "DATETIME":
+      return "DATETIME";
+    case "DATETIME_WITH_TZ":
+      return "DATETIMEOFFSET";
+    case "STRING":
+    case "MULTILINE_TEXT":
+    case "MULTILINE_MAX":
+    case "UUID":
+      return "NVARCHAR";
+    default:
+      return;
+  }
+}
+async function loadChoiceSetValues(sdk, choiceSetId, folderKey) {
+  const [error, items] = await catchError(readAllChoiceValues(sdk, choiceSetId, folderKey));
+  if (error || items === undefined)
+    return;
+  const byLabel = new Map;
+  const labelsById = new Map;
+  const labels = [];
+  for (const item of items) {
+    if (item.numberId === undefined)
+      continue;
+    if (item.name)
+      byLabel.set(item.name.toLowerCase(), item.numberId);
+    if (item.displayName) {
+      byLabel.set(item.displayName.toLowerCase(), item.numberId);
+    }
+    const label = item.displayName ?? item.name;
+    if (label) {
+      labels.push(label);
+      labelsById.set(item.numberId, label);
+    }
+  }
+  return { byLabel, labelsById, labels };
+}
+async function readAllChoiceValues(sdk, choiceSetId, folderKey) {
+  const scope = folderKey === undefined ? {} : { folderKey };
+  const values = [];
+  const guard = pageGuard(`choice set ${choiceSetId}`);
+  let cursor;
+  do {
+    const response = await sdk.entities.choicesets.getById(choiceSetId, cursor === undefined ? { ...scope, pageSize: RECORD_PAGE_SIZE } : { ...scope, pageSize: RECORD_PAGE_SIZE, cursor });
+    const page = PageSchema.safeParse(response);
+    if (!page.success || page.data.items === undefined)
+      return;
+    for (const item of page.data.items) {
+      const value = ChoiceValueSchema.safeParse(camelKeys(item));
+      if (value.success)
+        values.push(value.data);
+    }
+    cursor = nextCursorOf(page.data, `choice set ${choiceSetId}`);
+    guard.next(cursor);
+  } while (cursor !== undefined);
+  return values;
+}
+function withSystemKeyAliases(record) {
+  const out = {};
+  for (const [key, val] of Object.entries(record)) {
+    setOwn(out, key, aliasNested(val));
+  }
+  for (const key of SYSTEM_VALUE_KEYS) {
+    const lower = key.toLowerCase();
+    if (!Object.hasOwn(out, key) && Object.hasOwn(out, lower)) {
+      setOwn(out, key, out[lower]);
+    }
+  }
+  return out;
+}
+function aliasNested(value) {
+  if (Array.isArray(value))
+    return value.map(aliasNested);
+  const record = plainRecord.safeParse(value);
+  return record.success ? withSystemKeyAliases(record.data) : value;
+}
+var SYSTEM_VALUE_KEYS = ["Id", "Name", "Size"];
+async function loadLiveRecords(sdk, entityId, folderKey, expand = false) {
+  const records = [];
+  const scope = {
+    ...folderKey === undefined ? {} : { folderKey },
+    ...expand ? { expansionLevel: 1 } : {}
+  };
+  const guard = pageGuard(`entity ${entityId}`);
+  let cursor;
+  do {
+    const response = await sdk.entities.getAllRecords(entityId, cursor === undefined ? { ...scope, pageSize: RECORD_PAGE_SIZE } : { ...scope, pageSize: RECORD_PAGE_SIZE, cursor });
+    const page = PageSchema.safeParse(response);
+    if (!page.success || page.data.items === undefined) {
+      throw new Error(`Data Fabric sent a page of entity ${entityId} records with no items list. ` + "Stopping rather than acting on a partial read.");
+    }
+    const items = RecordItemsSchema.safeParse(page.data.items);
+    if (!items.success) {
+      throw new Error(`Data Fabric sent a page of entity ${entityId} records with an item that is ` + "not a record. Stopping rather than acting on a partial read.");
+    }
+    for (const item of items.data) {
+      records.push(plainRecord.safeParse(item).success ? withSystemKeyAliases(item) : item);
+    }
+    cursor = nextCursorOf(page.data, `entity ${entityId}`);
+    guard.next(cursor);
+  } while (cursor !== undefined);
+  return records;
+}
+var MAX_RECORD_PAGES = 1000;
+function nextCursorOf(page, what) {
+  if (!page.hasNextPage)
+    return;
+  if (page.nextCursor === undefined) {
+    throw new Error(`Data Fabric said there are more pages of ${what} but sent no cursor to read ` + "them. Stopping rather than acting on a partial read.");
+  }
+  return page.nextCursor;
+}
+function pageGuard(what) {
+  const seen = new Set;
+  let pages = 1;
+  return {
+    next(cursor) {
+      if (cursor === undefined)
+        return;
+      const key = JSON.stringify(cursor);
+      if (seen.has(key)) {
+        throw new Error(`Data Fabric returned the same page cursor twice while reading ${what}; ` + "stopping rather than reading forever.");
+      }
+      seen.add(key);
+      pages += 1;
+      if (pages > MAX_RECORD_PAGES) {
+        throw new Error(`Reading ${what} did not end after ${MAX_RECORD_PAGES} pages; stopping.`);
+      }
+    }
+  };
+}
+var RECORD_PAGE_SIZE = 1000;
+
+// src/services/seed/csv.ts
+function parseCsv(contents) {
+  const state = {
+    rows: [],
+    row: [],
+    field: "",
+    quoted: false,
+    quoteOpenedAt: 0,
+    fieldStarted: false,
+    rowStarted: false
+  };
+  const text = contents.replace(/^/, "");
+  let index = 0;
+  while (index < text.length) {
+    index = state.quoted ? stepQuoted(state, text, index) : stepUnquoted(state, text, index);
+  }
+  if (state.quoted) {
+    const line = text.slice(0, state.quoteOpenedAt).split(`
+`).length;
+    throw new Error(`unterminated quoted field: the quote opened on line ${line} is never closed`);
+  }
+  if (state.rowStarted)
+    endRow(state);
+  if (state.rows.length === 0)
+    return { headers: [], rows: [] };
+  return {
+    headers: state.rows[0].map((header) => header.trim()),
+    rows: state.rows.slice(1)
+  };
+}
+function endField(state) {
+  state.row.push(state.field);
+  state.field = "";
+  state.fieldStarted = false;
+}
+function endRow(state) {
+  if (!state.rowStarted) {
+    state.row = [];
+    state.field = "";
+    state.fieldStarted = false;
+    return;
+  }
+  endField(state);
+  state.rows.push(state.row);
+  state.row = [];
+  state.rowStarted = false;
+}
+function stepQuoted(state, text, index) {
+  const char = text[index];
+  if (char !== '"') {
+    state.field += char;
+    return index + 1;
+  }
+  if (text[index + 1] === '"') {
+    state.field += '"';
+    return index + 2;
+  }
+  state.quoted = false;
+  return index + 1;
+}
+function stepUnquoted(state, text, index) {
+  const char = text[index];
+  if (char === '"' && !state.fieldStarted) {
+    state.quoted = true;
+    state.quoteOpenedAt = index;
+    state.fieldStarted = true;
+    state.rowStarted = true;
+    return index + 1;
+  }
+  if (char === ",") {
+    state.rowStarted = true;
+    endField(state);
+    return index + 1;
+  }
+  if (char === "\r") {
+    if (text[index + 1] === `
+`)
+      return index + 1;
+    endRow(state);
+    return index + 1;
+  }
+  if (char === `
+`) {
+    endRow(state);
+    return index + 1;
+  }
+  state.field += char;
+  state.fieldStarted = true;
+  if (char.trim() !== "")
+    state.rowStarted = true;
+  return index + 1;
+}
+
+// src/services/seed/expressions.ts
+var EXPRESSION = /%\{([^}]*)\}%/g;
+var INDEXED_LOOKUP = /^([A-Za-z]+)\.([A-Za-z]+)\['([^']+)'\]\.([A-Za-z]+)$/;
+function resolveExpressions(raw, context) {
+  if (!raw.includes("%{"))
+    return { value: raw, errors: [] };
+  const errors = [];
+  const spans = [];
+  let value = "";
+  let at = 0;
+  let kept = false;
+  EXPRESSION.lastIndex = 0;
+  for (let match = EXPRESSION.exec(raw);match !== null; match = EXPRESSION.exec(raw)) {
+    const [text, body] = match;
+    value += raw.slice(at, match.index);
+    const shared = kept && match.index < at ? at - match.index : 0;
+    const resolved = resolveOne(body.trim(), context);
+    if (resolved === undefined)
+      errors.push(text);
+    value += resolved ?? text.slice(shared);
+    kept = resolved === undefined;
+    spans.push([match.index, match.index + text.length]);
+    at = match.index + text.length;
+    EXPRESSION.lastIndex = raw[at] === "{" && raw[at - 1] === "%" ? at - 1 : at;
+  }
+  value += raw.slice(!kept && raw[at - 1] === "%" && raw[at] === "{" ? at - 1 : at);
+  errors.push(...strayMarkers(raw, spans));
+  return { value, errors };
+}
+function consumed(spans, at) {
+  return spans.some(([from, to]) => at === from || at > from && at < to - 1);
+}
+function strayMarkers(raw, spans) {
+  const stray = [];
+  for (let at = raw.indexOf("%{");at !== -1; at = raw.indexOf("%{", at + 2)) {
+    if (consumed(spans, at))
+      continue;
+    const rest = raw.slice(at);
+    stray.push(rest.length > 40 ? `${rest.slice(0, 40)}…` : rest);
+  }
+  return stray;
+}
+function resolveOne(body, context) {
+  const contextValue = resolveContextVariable(body, context);
+  if (contextValue !== undefined)
+    return contextValue;
+  const solutionValue = resolveSolutionScoped(body, context);
+  if (solutionValue !== undefined)
+    return solutionValue;
+  const indexed = INDEXED_LOOKUP.exec(body);
+  if (indexed) {
+    const [, namespace, collection, name, property] = indexed;
+    return resolveIndexed(namespace, collection, name, property, context);
+  }
+  return;
+}
+function resolveContextVariable(body, context) {
+  switch (body) {
+    case "UIPATH_BASE_URL":
+      return context.baseUrl;
+    case "UIPATH_ORG_ID":
+      return context.organizationId;
+    case "UIPATH_ORG_NAME":
+      return context.organizationName;
+    case "UIPATH_TENANT_ID":
+      return context.tenantId;
+    case "UIPATH_TENANT_NAME":
+      return context.tenantName;
+    case "UIPATH_FOLDER_KEY":
+      return context.folderKey;
+    case "UIPATH_FOLDER_ID":
+      return context.solutionFolderId;
+    case "UIPATH_FOLDER_PATH":
+      return context.solutionFolderPath;
+    default:
+      return;
+  }
+}
+function resolveSolutionScoped(body, context) {
+  switch (body) {
+    case "Solution.FolderPath":
+      return context.solutionFolderPath;
+    case "Solution.FolderKey":
+      return context.solutionFolderKey;
+    case "Solution.FolderId":
+      return context.solutionFolderId;
+    case "Solution.ParentFolderId":
+      return context.solutionParentFolderId;
+    case "Solution.ParentFolderKey":
+      return context.solutionParentFolderKey;
+    default:
+      return;
+  }
+}
+function resolveIndexed(namespace, collection, name, property, context) {
+  if (namespace === "Solution") {
+    return context.solutionResources?.get(collection)?.get(name)?.get(property);
+  }
+  if (namespace !== "DataFabric" || collection !== "Entities")
+    return;
+  const entity = name.toLowerCase();
+  if (property === "Id")
+    return context.entityIds?.get(entity);
+  if (property === "Name")
+    return context.entityNames?.get(entity);
+  return;
+}
+var INSTALLED_FOLDER_EXPRESSIONS = new Set([
+  "Solution.FolderPath",
+  "Solution.FolderKey",
+  "Solution.FolderId",
+  "Solution.ParentFolderId",
+  "Solution.ParentFolderKey",
+  "UIPATH_FOLDER_KEY",
+  "UIPATH_FOLDER_ID",
+  "UIPATH_FOLDER_PATH"
+]);
+function describeUnresolved(expression) {
+  const body = expression.replace(/^%\{/, "").replace(/\}%$/, "").trim();
+  if (!expression.endsWith("}%")) {
+    return `${expression} is not closed: a seed expression is written %{NAME}%. ` + "Close it, or remove the %{ if the cell is meant to hold that text.";
+  }
+  if (body === "") {
+    return `${expression} names no expression. Write the name inside it, for example ` + "%{UIPATH_TENANT_ID}%, or remove it if the cell is meant to be empty.";
+  }
+  if (INSTALLED_FOLDER_EXPRESSIONS.has(body)) {
+    return `${expression} needs the folder the solution installed into, which this seed run did ` + "not know or could not read. Seed after the install completes, or pass --folder-key or " + "--folder-path for the installed folder.";
+  }
+  if (body.startsWith("Solution.")) {
+    return `${expression} names a solution resource that was not found in the folder the ` + "solution installed into. Check that the manifest declares it and that it is " + "deployed, or replace it with a literal value in the seed file.";
+  }
+  return `${expression} is not a supported seed expression. Supported: ` + "%{UIPATH_BASE_URL}%, %{UIPATH_ORG_ID}%, %{UIPATH_ORG_NAME}%, %{UIPATH_TENANT_ID}%, " + "%{UIPATH_TENANT_NAME}%, %{UIPATH_FOLDER_KEY}%, %{UIPATH_FOLDER_ID}%, %{UIPATH_FOLDER_PATH}%, " + "%{Solution.FolderPath}%, %{Solution.Processes['Name'].Id}% and the other Solution " + "resources, %{DataFabric.Entities['Name'].Id}%.";
+}
+
+// src/services/seed/own-keys.ts
+function journalEntity(journal, entityName) {
+  if (Object.hasOwn(journal, entityName))
+    return journal[entityName];
+  const entries = Object.create(null);
+  return entries;
+}
+function putOwn(map, key, value) {
+  Object.defineProperty(map, key, {
+    value,
+    writable: true,
+    enumerable: true,
+    configurable: true
+  });
+}
+function fieldMap(from) {
+  const map = Object.create(null);
+  return from === undefined ? map : Object.assign(map, from);
+}
+function ownValue(record, key) {
+  return Object.hasOwn(record, key) ? record[key] : undefined;
+}
+
+// src/services/seed/csv-cells.ts
+var CSV_NULL = "NULL";
+var DATE_PATTERNS = [
+  { pattern: /^(\d{4})-(\d{1,2})-(\d{1,2})$/, order: [1, 2, 3] },
+  { pattern: /^(\d{1,2})\/(\d{1,2})\/(\d{4})$/, order: [3, 2, 1] },
+  { pattern: /^(\d{1,2})\.(\d{1,2})\.(\d{4})$/, order: [3, 2, 1] }
+];
+function pad(value) {
+  return value.length === 1 ? `0${value}` : value;
+}
+var TIME_SUFFIX = /[T ](\d{1,2}):(\d{1,2})(?::(\d{1,2})(\.\d{1,6})?)?$/;
+var ZONE_SUFFIX = /(Z|[+-]\d{2}:\d{2})$/i;
+function readCell(raw, sqlType) {
+  const trimmed = raw.trim();
+  if (trimmed === "")
+    return { present: false };
+  if (trimmed.toUpperCase() === CSV_NULL) {
+    return { present: true, value: null };
+  }
+  if (trimmed === `\\${CSV_NULL}`) {
+    return { present: true, value: CSV_NULL };
+  }
+  return coerce(trimmed, sqlType, raw);
+}
+function coerce(value, sqlType, raw = value) {
+  switch ((sqlType ?? "").toUpperCase()) {
+    case "BIT":
+      return coerceBoolean(value);
+    case "INT":
+      return coerceInteger(value, false);
+    case "BIGINT":
+      return coerceInteger(value, true);
+    case "DECIMAL":
+    case "FLOAT":
+    case "NUMERIC":
+      return coerceNumber(value);
+    case "DATE":
+      return coerceDate(value);
+    case "DATETIME":
+    case "DATETIME2":
+      return coerceDateTime(value, false);
+    case "DATETIMEOFFSET":
+      return coerceDateTime(value, true);
+    default:
+      return { present: true, value: raw };
+  }
+}
+function coerceBoolean(value) {
+  const lower = value.toLowerCase();
+  if (["true", "1", "yes", "y"].includes(lower)) {
+    return { present: true, value: true };
+  }
+  if (["false", "0", "no", "n"].includes(lower)) {
+    return { present: true, value: false };
+  }
+  return { present: true, error: `"${value}" is not a boolean` };
+}
+var INTEGER_RANGES = {
+  INT: { min: -(2n ** 31n), max: 2n ** 31n - 1n },
+  BIGINT: { min: -(2n ** 63n), max: 2n ** 63n - 1n }
+};
+function coerceInteger(value, bigint) {
+  if (!/^[+-]?\d+$/.test(value)) {
+    return { present: true, error: `"${value}" is not an integer` };
+  }
+  const type = bigint ? "BIGINT" : "INT";
+  const { min, max } = INTEGER_RANGES[type];
+  const exact = BigInt(value.startsWith("+") ? value.slice(1) : value);
+  if (exact < min || exact > max) {
+    return {
+      present: true,
+      error: `"${value}" is outside the ${type} range (${min} to ${max})`
+    };
+  }
+  const parsed = Number(value);
+  if (Number.isSafeInteger(parsed))
+    return { present: true, value: parsed };
+  return { present: true, value };
+}
+var DECIMAL_NUMBER = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/;
+var EXACT_DIGITS = 15;
+function coerceNumber(value) {
+  const parsed = DECIMAL_NUMBER.test(value) ? Number(value) : Number.NaN;
+  if (!Number.isFinite(parsed)) {
+    return { present: true, error: `"${value}" is not a number` };
+  }
+  const digits = significantDigits(value);
+  if (digits > EXACT_DIGITS || parsed === 0 && digits > 0) {
+    return { present: true, value };
+  }
+  return { present: true, value: parsed };
+}
+function significantDigits(value) {
+  return value.replace(/^[+-]/, "").replace(/[eE].*$/, "").replace(".", "").replace(/^0+/, "").replace(/0+$/, "").length;
+}
+function coerceDate(value) {
+  const parts = matchDateParts(value);
+  if (!parts) {
+    return {
+      present: true,
+      error: `"${value}" is not a date (use YYYY-MM-DD, DD/MM/YYYY or DD.MM.YYYY)`
+    };
+  }
+  return { present: true, value: parts };
+}
+function coerceDateTime(value, zoned) {
+  const zoneMatch = ZONE_SUFFIX.exec(value);
+  if (!zoned && zoneMatch) {
+    return {
+      present: true,
+      error: `"${value}" carries a time zone, but this column holds a wall-clock date/time with none — drop the ${zoneMatch[1]}`
+    };
+  }
+  const zone = zoneMatch ? zoneMatch[1] : "Z";
+  const withoutZone = zoneMatch ? value.slice(0, value.length - zoneMatch[1].length).trim() : value;
+  const suffix = zoned ? normalizeZone(zone) : "";
+  const timeMatch = TIME_SUFFIX.exec(withoutZone);
+  const datePart = timeMatch ? withoutZone.slice(0, withoutZone.length - timeMatch[0].length) : withoutZone;
+  const date = matchDateParts(datePart.trim());
+  if (!date) {
+    return {
+      present: true,
+      error: `"${value}" is not a date/time (use YYYY-MM-DDTHH:MM:SS)`
+    };
+  }
+  if (!timeMatch) {
+    if (zoneMatch) {
+      return {
+        present: true,
+        error: `"${value}" carries a time zone but no time — write the time too (YYYY-MM-DDTHH:MM:SS${zoneMatch[1]}), or drop the ${zoneMatch[1]}`
+      };
+    }
+    if (!isRealZone(zone)) {
+      return {
+        present: true,
+        error: `"${value}" is not a date/time: the zone offset is out of range`
+      };
+    }
+    return {
+      present: true,
+      value: `${date}T00:00:00${suffix}`
+    };
+  }
+  const hours = pad(timeMatch[1]);
+  const minutes = pad(timeMatch[2]);
+  const seconds = pad(timeMatch[3] ?? "00");
+  const fraction = timeMatch[4] ?? "";
+  if (!isRealTime(hours, minutes, seconds) || !isRealZone(zone)) {
+    return {
+      present: true,
+      error: `"${value}" is not a date/time: the time or zone offset is out of range`
+    };
+  }
+  return {
+    present: true,
+    value: `${date}T${hours}:${minutes}:${seconds}${fraction}${suffix}`
+  };
+}
+function normalizeZone(zone) {
+  return zone.toUpperCase() === "Z" ? "Z" : zone;
+}
+function isRealTime(hours, minutes, seconds) {
+  return Number(hours) <= 23 && Number(minutes) <= 59 && Number(seconds) <= 59;
+}
+function isRealZone(zone) {
+  if (zone.toUpperCase() === "Z")
+    return true;
+  const maxHours = zone.startsWith("-") ? 12 : 14;
+  const hours = Number(zone.slice(1, 3));
+  const minutes = Number(zone.slice(4, 6));
+  if (minutes > 59 || hours > maxHours)
+    return false;
+  return hours < maxHours || minutes === 0;
+}
+function matchDateParts(value) {
+  for (const { pattern, order } of DATE_PATTERNS) {
+    const match = pattern.exec(value);
+    if (!match)
+      continue;
+    const [yearIndex, monthIndex, dayIndex] = order;
+    const year = match[yearIndex];
+    const month = match[monthIndex];
+    const day = match[dayIndex];
+    if (!isRealDate(Number(year), Number(month), Number(day)))
+      return;
+    return `${year}-${pad(month)}-${pad(day)}`;
+  }
+  return;
+}
+function isRealDate(year, month, day) {
+  if (year < 1 || month < 1 || month > 12 || day < 1 || day > 31) {
+    return false;
+  }
+  const date = new Date(0);
+  date.setUTCFullYear(year, month - 1, day);
+  return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day;
+}
+
+// src/services/seed/plan-columns.ts
+import { createHash } from "node:crypto";
+function stripColumnAnnotation(header) {
+  const trimmed = header.trim();
+  if (!trimmed.endsWith(")"))
+    return trimmed;
+  const open = trimmed.lastIndexOf("(");
+  if (open < 0 || trimmed.slice(open + 1, -1).includes(")"))
+    return trimmed;
+  return trimmed.slice(0, open).trim();
+}
+function mapColumns(entity, headers, warnings) {
+  const columns = [];
+  for (const [sourceIndex, header] of headers.entries()) {
+    const lower = stripColumnAnnotation(header).toLowerCase();
+    if (SYSTEM_FIELDS.has(lower))
+      continue;
+    const field = entity.fields.get(lower);
+    if (!field) {
+      warnings.push(`${entity.name}: ignoring column "${header}" — the entity has no such field.`);
+      continue;
+    }
+    if (field.isAutoNumber)
+      continue;
+    columns.push({ header, sourceIndex, field });
+  }
+  return columns;
+}
+function noSeedableColumns(entityName, table, columns) {
+  if (columns.length > 0 || table.rows.length === 0)
+    return;
+  const ignored = table.headers.filter((header) => stripColumnAnnotation(header).toLowerCase() !== "id");
+  return `${entityName}: no column in ${entityName}.csv matches a field of the entity` + (ignored.length > 0 ? ` (ignored: ${ignored.join(", ")})` : "") + ", so its rows were not seeded. Fix the column headers and run again.";
+}
+function seedableFields(entity) {
+  return [...entity.fields.values()].filter((field) => !field.isSystemField && !field.isPrimaryKey && !field.isAutoNumber);
+}
+function requiredColumnsMissing(entity, columns) {
+  const present = new Set(columns.map((column) => column.field.name.toLowerCase()));
+  return seedableFields(entity).filter((field) => field.isRequired && !present.has(field.name.toLowerCase())).map((field) => field.name);
+}
+function optionalColumnsMissing(entity, columns) {
+  const present = new Set(columns.map((column) => column.field.name.toLowerCase()));
+  return seedableFields(entity).filter((field) => !field.isRequired && !present.has(field.name.toLowerCase())).map((field) => field.name);
+}
+function rowKeysFor(headers, rows) {
+  const localIds = localIdsFor(headers, rows);
+  const seen = new Map;
+  return rows.map((cells, index) => {
+    const localId = localIds[index];
+    const base = localId ? `id:${localId}` : `h:${contentHash(headers, cells)}`;
+    const occurrence = (seen.get(base) ?? 0) + 1;
+    seen.set(base, occurrence);
+    return occurrence === 1 ? base : `${base}#${occurrence}`;
+  });
+}
+function localIdsFor(headers, rows) {
+  const idIndex = headers.findIndex((header) => stripColumnAnnotation(header).toLowerCase() === "id");
+  return rows.map((cells) => idIndex >= 0 ? (cells[idIndex] ?? "").trim() : "");
+}
+function contentHash(headers, cells) {
+  const canonical = JSON.stringify(headers.map((header, index) => [header, cells[index] ?? ""]).sort(([a], [b]) => a.localeCompare(b)));
+  return createHash("sha256").update(canonical, "utf8").digest("hex").slice(0, 16);
+}
+function rowLabel(key, line) {
+  return key.startsWith("id:") ? key.slice(3) : `row ${line}`;
+}
+
+// src/services/seed/plan-values.ts
+var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var EMPTY = "<empty>";
+var LAZY_TEXT_MARKER = /^HasValue=(true|false) Length=\d+$/i;
+var LAZY_TEXT_TRUNCATED = /\.\.\.\[Truncated\]$/i;
+function lazyTextPreview(liveText) {
+  const marker = LAZY_TEXT_MARKER.exec(liveText);
+  if (marker)
+    return { hasValue: marker[1].toLowerCase() === "true" };
+  return LAZY_TEXT_TRUNCATED.test(liveText) ? { hasValue: true } : undefined;
+}
+function truncatedPreviewText(liveText) {
+  return LAZY_TEXT_TRUNCATED.test(liveText) ? liveText.replace(LAZY_TEXT_TRUNCATED, "") : undefined;
+}
+function matchValue(value, field) {
+  return field.isForeignKey ? referenceId(value).toLowerCase() : comparableText(value, field).toLowerCase();
+}
+function comparableText(value, field) {
+  return roundLikeJson(normalizeForCompare(value, field), field);
+}
+var ROUNDED_BY_JSON = new Set(["BIGINT", "DECIMAL", "NUMERIC", "FLOAT"]);
+function roundLikeJson(text, field) {
+  return ROUNDED_BY_JSON.has((field.sqlType ?? "").toUpperCase()) && /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/.test(text) ? String(Number(text)) : text;
+}
+function choiceLabels(text, choices) {
+  if (!choices || text === "")
+    return text;
+  return text.split(",").map((part) => part.trim()).filter((part) => part !== "").map((part) => /^\d+$/.test(part) ? choices.labelsById.get(Number(part)) ?? part : part).join(", ");
+}
+var ATTACHED_FILE = "an attached file";
+function expanded(value) {
+  const parsed = ExpandedValueSchema.safeParse(value);
+  return parsed.success ? parsed.data : undefined;
+}
+function attachmentName(value) {
+  if (value === null || typeof value !== "object") {
+    return typeof value === "string" && !UUID.test(value.trim()) ? value.trim() : "";
+  }
+  return expanded(value)?.Name ?? "";
+}
+function hasAttachment(value) {
+  if (value === null || value === undefined)
+    return false;
+  if (typeof value === "string")
+    return value.trim() !== "";
+  const file = expanded(value);
+  return file?.Id !== undefined || file?.Name !== undefined;
+}
+function attachmentSize(value) {
+  return expanded(value)?.Size;
+}
+function referenceId(value) {
+  if (typeof value === "string")
+    return value.trim();
+  return expanded(value)?.Id ?? "";
+}
+function normalizeForCompare(value, field) {
+  if (value === null || value === undefined)
+    return "";
+  if (typeof value === "boolean")
+    return value ? "true" : "false";
+  if (typeof value === "number")
+    return String(value);
+  if (Array.isArray(value)) {
+    const items = value.map((item) => normalizeForCompare(item, field));
+    return (field.isMultiChoice ? [...items].sort((left, right) => left.localeCompare(right)) : items).join(",");
+  }
+  if (typeof value === "object")
+    return normalizeObject(value);
+  if (typeof value !== "string")
+    return "";
+  return normalizeText(value, field);
+}
+function normalizeObject(value) {
+  const record = expanded(value);
+  if (record?.Id !== undefined)
+    return record.Id;
+  if (record?.Name !== undefined)
+    return record.Name;
+  return JSON.stringify(value);
+}
+function normalizeText(raw, field) {
+  const sqlType = (field.sqlType ?? "").toUpperCase();
+  const text = raw.trim();
+  if (sqlType === "BIT")
+    return normalizeBit(text);
+  if (field.isMultiChoice) {
+    return text.split(",").map((part) => part.trim()).filter((part) => part !== "").sort((left, right) => left.localeCompare(right)).join(",");
+  }
+  if (sqlType === "DATE") {
+    return text.length >= 10 && /^\d{4}-\d{2}-\d{2}/.test(text) ? text.slice(0, 10) : text;
+  }
+  if (sqlType.startsWith("DATETIME"))
+    return normalizeDateTime(text);
+  return raw;
+}
+function normalizeBit(text) {
+  const lower = text.toLowerCase();
+  if (["1", "yes", "y", "true"].includes(lower))
+    return "true";
+  if (["0", "no", "n", "false"].includes(lower))
+    return "false";
+  return lower;
+}
+function normalizeDateTime(text) {
+  const withZone = /(Z|[+-]\d{2}:\d{2})$/i.test(text) ? text : `${text}Z`;
+  const parsed = Date.parse(withZone);
+  if (Number.isFinite(parsed)) {
+    return new Date(parsed).toISOString().replace(/\.000Z$/, "Z");
+  }
+  return text;
+}
+
+// src/services/seed/plan-cells.ts
+function buildRow(identity, cells, columns, input, errors, unresolved, ownLocalIds) {
+  const parts = {
+    values: fieldMap(),
+    display: fieldMap(),
+    attachments: fieldMap(),
+    foreignKeys: fieldMap(),
+    uuidReferences: fieldMap(),
+    ownLocalIds
+  };
+  const { values, display, attachments, foreignKeys } = parts;
+  const prefix = `${input.entityName} row ${identity.line}`;
+  let rowFailed = false;
+  for (const column of columns) {
+    const error = readColumn(column, cells, input, parts, unresolved);
+    if (error !== undefined) {
+      errors.push(`${prefix}, column "${column.header}": ${error}`);
+      rowFailed = true;
+    }
+  }
+  if (rowFailed)
+    return;
+  const missing = missingRequiredValues(input.entity, columns, values, attachments, foreignKeys);
+  if (missing.length > 0) {
+    errors.push(`${prefix}: required ${missing.length === 1 ? "field" : "fields"} left empty: ${missing.join(", ")}.`);
+    return;
+  }
+  const { uuidReferences } = parts;
+  return {
+    ...identity,
+    values,
+    display,
+    attachments,
+    foreignKeys,
+    ...Object.keys(uuidReferences).length > 0 ? { uuidReferences } : {}
+  };
+}
+function readColumn(column, cells, input, parts, unresolved) {
+  const raw = cells[column.sourceIndex] ?? "";
+  const { field } = column;
+  const resolved = resolveExpressions(raw, input.expressionContext);
+  let value = resolved.value;
+  if (resolved.errors.length > 0) {
+    for (const expression of resolved.errors)
+      unresolved.add(expression);
+    value = "";
+  }
+  const text = value.trim();
+  parts.display[field.name] = displayText(text);
+  if (field.isAttachment) {
+    return readAttachmentCell(text, field, input, parts.attachments) || undefined;
+  }
+  if (field.isForeignKey) {
+    return readForeignKeyCell(text, field, input, parts);
+  }
+  const cell = readCell(value, field.sqlType);
+  if (!cell.present)
+    return;
+  if (cell.error)
+    return `${cell.error}.`;
+  if (typeof cell.value === "string" && isDateType(field.sqlType)) {
+    parts.display[field.name] = cell.value;
+  }
+  const choice = mapChoiceValue(field, cell.value, input);
+  if (choice.error)
+    return choice.error;
+  parts.values[field.name] = choice.value;
+  return;
+}
+function isDateType(sqlType) {
+  return (sqlType ?? "").toUpperCase().startsWith("DATE");
+}
+function displayText(text) {
+  if (text === "")
+    return EMPTY;
+  if (text.toUpperCase() === "NULL")
+    return "<null>";
+  if (text === String.raw`\NULL`)
+    return "NULL";
+  return text;
+}
+function readAttachmentCell(text, field, input, attachments) {
+  if (text === "" || text.toUpperCase() === "NULL")
+    return;
+  if (text.includes("/") || text.includes("\\")) {
+    return `an attachment cell must be a filename, not a path: "${text}". Put the file under ${input.entityName}/ in the seed workspace.`;
+  }
+  const path = `${input.entityName}/${text}`;
+  if (input.bundledFiles && !input.bundledFiles.has(path)) {
+    return `file not found for "${field.name}": ${path}.`;
+  }
+  attachments[field.name] = path;
+  return;
+}
+function readForeignKeyCell(text, field, input, parts) {
+  if (text === "" || text.toUpperCase() === "NULL")
+    return;
+  const entity = (field.referenceEntityName ?? "").toLowerCase();
+  const reference = { entity, localId: text };
+  if (entity === input.entity.name.toLowerCase()) {
+    if (UUID.test(text) && !parts.ownLocalIds.has(text)) {
+      parts.values[field.name] = { Id: text };
+      return;
+    }
+    const resolvedBefore = input.idMaps?.get(entity)?.get(text);
+    if (!parts.ownLocalIds.has(text) && resolvedBefore === undefined && field.isRequired) {
+      return `"${text}" does not match the Id of any row in ` + `${input.entityName}.csv, and ${field.name} is required. ` + "Add that row, or put the record id of an existing " + `${input.entityName} in the cell.`;
+    }
+    parts.foreignKeys[field.name] = reference;
+    return;
+  }
+  const known = input.idMaps?.get(entity)?.get(text);
+  if (known) {
+    parts.values[field.name] = { Id: known };
+    return;
+  }
+  if (UUID.test(text)) {
+    parts.values[field.name] = { Id: text };
+    parts.uuidReferences[field.name] = reference;
+    return;
+  }
+  parts.foreignKeys[field.name] = reference;
+  return;
+}
+function mapChoiceValue(field, value, input) {
+  if (value === undefined || value === null)
+    return { value: value ?? null };
+  if (!field.choiceSetId || typeof value !== "string")
+    return { value };
+  const choices = input.choiceValues?.get(field.name.toLowerCase());
+  const parts = field.isMultiChoice ? value.split(",").map((part) => part.trim()).filter((part) => part !== "") : [value.trim()];
+  const mapped = [];
+  for (const part of parts) {
+    const id = choices?.byLabel.get(part.toLowerCase());
+    if (id !== undefined) {
+      mapped.push(String(id));
+      continue;
+    }
+    if (/^\d+$/.test(part)) {
+      mapped.push(part);
+      continue;
+    }
+    if (choices) {
+      return {
+        value,
+        error: `"${part}" is not a valid choice for "${field.name}". Valid: ${choices.labels.join(", ")}.`
+      };
+    }
+    mapped.push(part);
+  }
+  if (field.isMultiChoice)
+    return { value: mapped.join(",") };
+  const only = mapped[0];
+  return { value: /^\d+$/.test(only) ? Number(only) : only };
+}
+function missingRequiredValues(entity, columns, values, attachments, foreignKeys) {
+  const declared = new Set(columns.map((column) => column.field.name));
+  return seedableFields(entity).filter((field) => field.isRequired && declared.has(field.name)).filter((field) => {
+    if (field.isAttachment) {
+      return attachments[field.name] === undefined;
+    }
+    if (field.isForeignKey) {
+      return foreignKeys[field.name] === undefined && values[field.name] === undefined;
+    }
+    return values[field.name] === undefined || values[field.name] === null;
+  }).map((field) => field.name);
+}
+function relationshipKey(row, field) {
+  const reference = row.foreignKeys[field.name];
+  if (reference) {
+    return `${reference.entity}\x00${reference.localId.toLowerCase()}`;
+  }
+  return matchValue(row.values[field.name], field);
+}
+function uniqueValuesFree(row, columns, seen, input, errors) {
+  for (const { field } of columns) {
+    if (!field.isUnique || field.isAttachment)
+      continue;
+    const value = field.isForeignKey ? relationshipKey(row, field) : normalizeForCompare(row.values[field.name], field).toLowerCase();
+    if (value === "")
+      continue;
+    const tracker = seen.get(field.name) ?? new Map;
+    seen.set(field.name, tracker);
+    const first = tracker.get(value);
+    if (first !== undefined) {
+      errors.push(`${input.entityName} row ${row.line}: duplicate value "${row.display[field.name] ?? value}" for unique field "${field.name}" (first seen in row ${first}).`);
+      return false;
+    }
+    tracker.set(value, row.line);
+  }
+  return true;
+}
+
+// src/services/seed/plan-compare.ts
+function compareWithLive(row, recordId, live, columns, input, pendingFiles) {
+  const changes = fieldMap();
+  const optional = fieldMap();
+  const attachmentChanges = fieldMap();
+  const optionalClears = [];
+  for (const { field } of columns) {
+    const liveValue = ownValue(live, field.name);
+    if (field.isAttachment) {
+      if (pendingFiles?.includes(field.name) && row.attachments[field.name] !== undefined) {
+        continue;
+      }
+      compareAttachment({
+        row,
+        field,
+        liveValue,
+        input,
+        changes,
+        optional,
+        attachmentChanges,
+        optionalClears
+      });
+      continue;
+    }
+    const scope = { row, field, liveValue, input, changes, optional };
+    if (field.isForeignKey) {
+      compareForeignKey(scope);
+      continue;
+    }
+    compareScalar(scope);
+  }
+  return {
+    ...row,
+    recordId,
+    changes,
+    optional,
+    attachmentChanges,
+    optionalClears,
+    allAttachments: row.attachments,
+    ...pendingFiles && pendingFiles.length > 0 ? { pendingFiles } : {}
+  };
+}
+function compareForeignKey({
+  row,
+  field,
+  liveValue,
+  input,
+  changes,
+  optional
+}) {
+  const liveId = referenceId(liveValue);
+  const ref = row.foreignKeys[field.name];
+  if (ref !== undefined) {
+    if (ref.entity !== input.entity.name.toLowerCase()) {
+      changes[field.name] = {
+        from: liveId || EMPTY,
+        to: `${ref.localId} (local Id)`
+      };
+    }
+    return;
+  }
+  const wanted = referenceId(row.values[field.name]);
+  if (liveId.toLowerCase() === wanted.toLowerCase())
+    return;
+  const change = { from: liveId || EMPTY, to: wanted || EMPTY };
+  if (wanted === "" && !field.isRequired) {
+    optional[field.name] = change;
+  } else {
+    changes[field.name] = change;
+  }
+}
+function compareScalar({
+  row,
+  field,
+  liveValue,
+  input,
+  changes,
+  optional
+}) {
+  const liveText = normalizeForCompare(liveValue, field);
+  const hasCell = Object.hasOwn(row.values, field.name);
+  const wantedText = hasCell ? normalizeForCompare(row.values[field.name], field) : "";
+  const preview = field.isLazyText ? lazyTextPreview(liveText) : undefined;
+  if (preview) {
+    compareLazyText({
+      scope: { row, field, liveValue, input, changes, optional },
+      liveText,
+      liveHasValue: preview.hasValue,
+      hasCell,
+      wantedText
+    });
+    return;
+  }
+  if (roundLikeJson(liveText, field).toLowerCase() === roundLikeJson(wantedText, field).toLowerCase()) {
+    return;
+  }
+  const choices = field.choiceSetId ? input.choiceValues?.get(field.name.toLowerCase()) : undefined;
+  const change = {
+    from: choiceLabels(liveText, choices) || EMPTY,
+    to: choiceLabels(wantedText, choices) || EMPTY
+  };
+  if (!hasCell && !field.isRequired) {
+    optional[field.name] = change;
+  } else {
+    changes[field.name] = change;
+  }
+}
+function compareLazyText(input) {
+  const { scope, liveText, liveHasValue, hasCell, wantedText } = input;
+  const { field, changes, optional } = scope;
+  if (!liveHasValue) {
+    if (wantedText !== "") {
+      changes[field.name] = { from: EMPTY, to: wantedText };
+    }
+    return;
+  }
+  if (wantedText !== "") {
+    changes[field.name] = { from: liveText, to: wantedText };
+    return;
+  }
+  const change = { from: liveText, to: EMPTY };
+  if (!hasCell && !field.isRequired) {
+    optional[field.name] = change;
+  } else {
+    changes[field.name] = change;
+  }
+}
+function withSelfReferenceChanges(row, input, idMap) {
+  const own = input.entity.name.toLowerCase();
+  const live = input.liveRecords.find((record) => typeof record.Id === "string" && record.Id.toLowerCase() === row.recordId.toLowerCase());
+  const changes = fieldMap(row.changes);
+  let changed = false;
+  for (const [field, ref] of Object.entries(row.foreignKeys)) {
+    if (ref.entity !== own)
+      continue;
+    const liveId = referenceId(live === undefined ? undefined : ownValue(live, field));
+    const wanted = idMap.get(ref.localId);
+    if (wanted?.toLowerCase() === liveId.toLowerCase()) {
+      continue;
+    }
+    changes[field] = {
+      from: liveId || EMPTY,
+      to: wanted ?? `${ref.localId} (local Id)`
+    };
+    changed = true;
+  }
+  return changed ? { ...row, changes } : row;
+}
+function compareAttachment({
+  row,
+  field,
+  liveValue,
+  input,
+  changes,
+  optional,
+  attachmentChanges,
+  optionalClears
+}) {
+  const liveName = attachmentName(liveValue);
+  const livePresent = hasAttachment(liveValue);
+  const path = row.attachments[field.name];
+  if (path === undefined) {
+    if (livePresent) {
+      optionalClears.push(field.name);
+      optional[field.name] = {
+        from: liveName || ATTACHED_FILE,
+        to: EMPTY
+      };
+    }
+    return;
+  }
+  const wantedName = path.slice(path.lastIndexOf("/") + 1);
+  if (livePresent && !liveName) {
+    return;
+  }
+  if (liveName.toLowerCase() !== wantedName.toLowerCase()) {
+    changes[field.name] = { from: liveName || EMPTY, to: wantedName };
+    attachmentChanges[field.name] = path;
+    return;
+  }
+  const liveSize = attachmentSize(liveValue);
+  const bundledSize = input.bundledFiles?.get(path);
+  if (liveSize !== undefined && bundledSize !== undefined && liveSize !== bundledSize) {
+    changes[field.name] = {
+      from: `${liveName} (${liveSize} B)`,
+      to: `${wantedName} (${bundledSize} B)`
+    };
+    attachmentChanges[field.name] = path;
+  }
+}
+
+// src/services/seed/plan-live.ts
+function recordsNewSincePlan(records, planned) {
+  const seen = new Set(planned.map((record) => record.Id).filter((id) => typeof id === "string").map((id) => id.toLowerCase()));
+  return records.filter((record) => typeof record.Id !== "string" || !seen.has(record.Id.toLowerCase()));
+}
+function indexLive(records, entity, columns, options = {}) {
+  const claimed = new Set;
+  const claim = (row, recordId) => {
+    if (recordId === undefined || options.claimOnce === false) {
+      return recordId;
+    }
+    const key = recordId.toLowerCase();
+    if (claimed.has(key)) {
+      options.onDoubleClaim?.(row, recordId);
+      return;
+    }
+    claimed.add(key);
+    return recordId;
+  };
+  const byId = new Map;
+  for (const record of records) {
+    if (typeof record.Id === "string") {
+      byId.set(record.Id.toLowerCase(), record);
+    }
+  }
+  const identity = entity.identityFields.map((name) => entity.fields.get(name.toLowerCase())).filter((field) => field !== undefined);
+  const filledOf = contentFields(columns);
+  const linksOf = linkFields(columns);
+  if (identity.length > 0) {
+    const indexes = new Map;
+    const indexFor = (used) => {
+      const signature = used.map((field) => field.name).join("\x00");
+      const cached = indexes.get(signature);
+      if (cached)
+        return cached;
+      const built = keyIndex(records, used);
+      indexes.set(signature, built);
+      return built;
+    };
+    const lookup2 = (row) => {
+      const used = identity.filter((field) => {
+        if (unresolvedRelationship(row, field))
+          return false;
+        if (field.isRequired)
+          return true;
+        if (!Object.hasOwn(row.values, field.name))
+          return false;
+        return row.values[field.name] === null || normalizeForCompare(row.values[field.name], field) !== "";
+      });
+      const key = used.length === 0 ? undefined : identityKey(used.map((field) => [field, row.values[field.name]]));
+      if (key === undefined) {
+        return options.contentFallback ? {
+          recordId: soleContentMatch(records, row, [
+            ...filledOf(row),
+            ...identity
+          ])
+        } : {};
+      }
+      const { byKey, counts } = indexFor(used);
+      const hits = counts.get(key) ?? 0;
+      const ambiguous = ambiguityOf(row, used, hits);
+      if (ambiguous)
+        return { ambiguous };
+      const recordId = byKey.get(key);
+      return hits > 1 ? { recordId, shared: hits } : { recordId };
+    };
+    return liveIndex(byId, lookup2, claim);
+  }
+  const lookup = (row) => {
+    const filled = filledOf(row);
+    if (filled.length === 0)
+      return {};
+    const scalarHits = records.filter((record) => sameContent(record, row, filled));
+    const hits = narrowByLinks(scalarHits, row, linksOf(row));
+    const ambiguous = ambiguityOf(row, filled, hits.length);
+    if (ambiguous)
+      return { ambiguous };
+    const hit = hits[0];
+    if (typeof hit?.Id !== "string")
+      return {};
+    return hits.length > 1 ? { recordId: hit.Id, shared: hits.length } : { recordId: hit.Id };
+  };
+  return liveIndex(byId, lookup, claim);
+}
+function liveIndex(byId, lookup, claim) {
+  return {
+    byId,
+    match: (row) => claim(row, lookup(row).recordId),
+    ambiguous: (row) => lookup(row).ambiguous,
+    shared: (row) => lookup(row).shared
+  };
+}
+function keyIndex(records, used) {
+  const byKey = new Map;
+  const counts = new Map;
+  for (const record of records) {
+    if (typeof record.Id !== "string")
+      continue;
+    const key = identityKey(used.map((field) => [field, ownValue(record, field.name)]));
+    if (key === undefined)
+      continue;
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+    if (!byKey.has(key))
+      byKey.set(key, record.Id);
+  }
+  return { byKey, counts };
+}
+function ambiguityOf(row, fields, records) {
+  if (records < 2)
+    return;
+  const field = roundedBigintField(row, fields);
+  return field ? { field, records } : undefined;
+}
+function roundedBigintField(row, fields) {
+  return fields.find((field) => {
+    if ((field.sqlType ?? "").toUpperCase() !== "BIGINT")
+      return false;
+    const text = normalizeForCompare(row.values[field.name], field);
+    return /^[+-]?\d+$/.test(text) && !Number.isSafeInteger(Number(text));
+  });
+}
+function contentFields(columns) {
+  const scalars = columns.map((column) => column.field).filter((field) => !field.isForeignKey && !field.isAttachment);
+  const relationships = columns.map((column) => column.field).filter((field) => field.isForeignKey);
+  return (row) => {
+    const filled = scalars.filter((field) => fills(row, field));
+    return filled.length > 0 ? filled : relationships.filter((field) => fills(row, field));
+  };
+}
+function linkFields(columns) {
+  const relationships = columns.map((column) => column.field).filter((field) => field.isForeignKey);
+  return (row) => relationships.filter((field) => fills(row, field));
+}
+function fills(row, field) {
+  return Object.hasOwn(row.values, field.name) && !unresolvedRelationship(row, field);
+}
+function narrowByLinks(hits, row, links) {
+  if (hits.length < 2 || links.length === 0)
+    return hits;
+  const narrowed = hits.filter((record) => sameContent(record, row, links));
+  return narrowed.length > 0 ? narrowed : hits;
+}
+function sameContent(record, row, fields) {
+  const usePreviews = fields.some((field) => !field.isLazyText && normalizeForCompare(row.values[field.name], field) !== "");
+  return fields.every((field) => sameValue(ownValue(record, field.name), row.values[field.name], field, usePreviews));
+}
+function sameValue(live, wanted, field, usePreviews) {
+  const liveText = normalizeForCompare(live, field);
+  const preview = usePreviews && field.isLazyText ? lazyTextPreview(liveText) : undefined;
+  if (!preview)
+    return matchValue(live, field) === matchValue(wanted, field);
+  const wantedText = normalizeForCompare(wanted, field);
+  if (!preview.hasValue)
+    return wantedText === "";
+  const shown = truncatedPreviewText(liveText);
+  return shown === undefined ? wantedText !== "" : wantedText.toLowerCase().startsWith(shown.toLowerCase());
+}
+function soleContentMatch(records, row, fields) {
+  if (!fields.some((field) => Object.hasOwn(row.values, field.name))) {
+    return;
+  }
+  const hits = records.flatMap((record) => typeof record.Id === "string" && sameContent(record, row, fields) ? [record.Id] : []);
+  return hits.length === 1 ? hits[0] : undefined;
+}
+function unresolvedRelationship(row, field) {
+  return field.isForeignKey && Object.hasOwn(row.foreignKeys, field.name);
+}
+function locateRows(rows, records, entity, columns) {
+  const live = indexLive(records, entity, columns, {
+    claimOnce: false,
+    contentFallback: true
+  });
+  const ids = rows.map((row) => live.match(row));
+  const claims = new Map;
+  for (const id of ids) {
+    if (id !== undefined)
+      claims.set(id, (claims.get(id) ?? 0) + 1);
+  }
+  return ids.map((id) => id !== undefined && claims.get(id) === 1 ? id : undefined);
+}
+function identityKey(parts) {
+  const normalized = parts.map(([field, value]) => [field.name, matchValue(value, field)]);
+  if (parts.every(([field, value]) => normalizeForCompare(value, field) === "")) {
+    return;
+  }
+  return JSON.stringify(normalized);
+}
+
+// src/services/seed/plan.ts
+function readStrategy(raw) {
+  if (raw === undefined)
+    return { strategy: "insert" };
+  const lower = raw.toLowerCase();
+  if (lower === "insert" || lower === "upsert") {
+    return { strategy: lower };
+  }
+  return {
+    strategy: "upsert",
+    warning: `Unknown seeding strategy "${raw}" — treating it as upsert.`
+  };
+}
+function buildEntityPlan(input) {
+  const errors = [];
+  const warnings = [];
+  const [parseError, table] = catchError(() => parseCsv(input.csv));
+  if (parseError || !table) {
+    errors.push(`${input.entityName}: ${input.entityName}.csv could not be read — ${parseError?.message ?? "unknown error"}.`);
+    return emptyPlan(input, errors, warnings, 0);
+  }
+  if (table.headers.length === 0) {
+    return emptyPlan(input, errors, warnings, 0);
+  }
+  const columns = mapColumns(input.entity, table.headers, warnings);
+  const noColumns = noSeedableColumns(input.entityName, table, columns);
+  if (noColumns !== undefined) {
+    errors.push(noColumns);
+    return emptyPlan(input, errors, warnings, table.rows.length);
+  }
+  const missingRequired = requiredColumnsMissing(input.entity, columns);
+  if (missingRequired.length > 0) {
+    errors.push(`${input.entityName}: the CSV is missing required ${missingRequired.length === 1 ? "column" : "columns"}: ${missingRequired.join(", ")}.`);
+    return emptyPlan(input, errors, warnings, table.rows.length);
+  }
+  const missingOptional = optionalColumnsMissing(input.entity, columns);
+  if (missingOptional.length > 0) {
+    warnings.push(`${input.entityName}: optional columns not in the CSV (Data Fabric defaults apply): ${missingOptional.join(", ")}.`);
+  }
+  const entityJournal = journalEntity(input.journal, input.entityName);
+  const journalKeys = rowKeysFor(table.headers, table.rows);
+  const localIds = localIdsFor(table.headers, table.rows);
+  const live = indexLive(input.liveRecords, input.entity, columns, {
+    onDoubleClaim: (row, recordId) => {
+      warnings.push(`${input.entityName} ${row.label}: another row already matches ` + `record ${recordId}, so this one is planned as a new record. ` + "Give the entity an identity field, or make the rows tell " + "themselves apart, if that is not what you want.");
+    }
+  });
+  const state = {
+    input,
+    columns,
+    live,
+    entityJournal,
+    errors,
+    warnings,
+    uniqueSeen: new Map,
+    firstLineOfLocalId: new Map,
+    idMap: new Map,
+    ownLocalIds: new Set(localIds.filter((localId) => localId !== "")),
+    unresolved: new Set,
+    journalChanged: false,
+    toInsert: [],
+    matched: []
+  };
+  for (const [index, cells] of table.rows.entries()) {
+    planRow(state, cells, index, journalKeys[index], localIds[index]);
+  }
+  const { idMap, unresolved, journalChanged, toInsert, matched } = state;
+  for (const [index, row] of matched.entries()) {
+    matched[index] = withSelfReferenceChanges(row, input, idMap);
+  }
+  if (journalChanged) {
+    putOwn(input.journal, input.entityName, entityJournal);
+  }
+  if (unresolved.size > 0) {
+    warnings.push(`${input.entityName}: unresolved expressions (replaced with empty): ${[...unresolved].sort((a, b) => a.localeCompare(b)).join(", ")}. ` + describeUnresolved([...unresolved][0]));
+  }
+  return {
+    entityName: input.entityName,
+    entityId: input.entity.id,
+    expandRecords: needsExpandedRecords(input.entity),
+    requiredRelationships: requiredRelationshipsOf(input.entity),
+    strategy: input.strategy,
+    toInsert,
+    ...classify(matched, input.strategy, false),
+    optionalDiffs: matched.flatMap((row) => Object.entries(row.optional).map(([field, change]) => ({
+      rowKey: row.key,
+      label: row.label,
+      field,
+      live: change.from
+    }))),
+    idMap,
+    journalChanged,
+    rowCount: table.rows.length,
+    errors,
+    warnings,
+    matched,
+    locate: (rows, records) => locateRows(rows, recordsNewSincePlan(records, input.liveRecords), input.entity, columns)
+  };
+}
+function planRow(state, cells, index, key, localId) {
+  const { input, columns, errors } = state;
+  const line = index + 2;
+  if (localId) {
+    const first = state.firstLineOfLocalId.get(localId);
+    if (first !== undefined) {
+      errors.push(`${input.entityName} row ${line}: duplicate local Id "${localId}" (also on row ${first}) — local Ids must be unique per entity.`);
+      return;
+    }
+    state.firstLineOfLocalId.set(localId, line);
+  }
+  const row = buildRow({
+    line,
+    key,
+    ...localId ? { localId } : {},
+    label: rowLabel(key, line)
+  }, cells, columns, input, errors, state.unresolved, state.ownLocalIds);
+  if (!row)
+    return;
+  if (!uniqueValuesFree(row, columns, state.uniqueSeen, input, errors)) {
+    return;
+  }
+  const journaled = Object.hasOwn(state.entityJournal, row.key) ? state.entityJournal[row.key] : undefined;
+  const journaledId = journaled?.recordId;
+  if (journaledId === undefined && !liveMatchIsClear(state, row))
+    return;
+  const recordId = journaledId === undefined ? adoptLiveMatch(state, row) : journaledId;
+  if (recordId === undefined) {
+    state.toInsert.push(row);
+    return;
+  }
+  if (localId)
+    state.idMap.set(localId, recordId);
+  const liveRecord = state.live.byId.get(recordId.toLowerCase());
+  state.matched.push(compareWithLive(row, recordId, liveRecord ?? {}, columns, input, journaled?.pendingFiles));
+}
+function liveMatchIsClear(state, row) {
+  const ambiguous = state.live.ambiguous(row);
+  if (ambiguous === undefined)
+    return true;
+  const { field, records } = ambiguous;
+  const name = state.input.entityName;
+  const reported = comparableText(row.values[field.name], field);
+  state.errors.push(`${name} row ${row.line}, field "${field.name}": ${records} live ` + `records share the value ${reported} as the service reports it ` + "(values past 2^53 lose precision), so seed cannot tell which " + `one this row is. ${name} is not seeded until the duplicate is ` + "removed or the row is journaled.");
+  return false;
+}
+function adoptLiveMatch(state, row) {
+  const recordId = state.live.match(row);
+  if (recordId === undefined)
+    return;
+  const shared = state.live.shared(row);
+  if (shared !== undefined) {
+    state.warnings.push(`${state.input.entityName} row ${row.line}: ${shared} live records match every ` + "column this row fills in, so which one it is cannot be told — the first was " + "used and the match was not recorded. Remove the duplicates, or give the " + "entity a unique field, so re-runs stay on the same record.");
+    return recordId;
+  }
+  putOwn(state.entityJournal, row.key, { recordId });
+  state.journalChanged = true;
+  return recordId;
+}
+function withOptionalClears(plan) {
+  return {
+    ...plan,
+    ...classify(plan.matched, plan.strategy, true)
+  };
+}
+function classify(matched, strategy, includeOptional) {
+  const toUpdate = [];
+  const toRepairAttachments = [];
+  const ignoredRows = [];
+  let unchanged = 0;
+  for (const row of matched) {
+    const { changes, clears } = requestedChanges(row, includeOptional);
+    const pending = (row.pendingFiles ?? []).filter((field) => Object.hasOwn(row.allAttachments, field));
+    if (Object.keys(changes).length === 0) {
+      if (pending.length > 0) {
+        toRepairAttachments.push(repairRow(row, pending));
+      } else {
+        unchanged += 1;
+      }
+      continue;
+    }
+    if (strategy === "insert") {
+      ignoredRows.push({ ...withoutMatchDetail(row), changes });
+      if (pending.length > 0) {
+        toRepairAttachments.push(repairRow(row, pending));
+      }
+      continue;
+    }
+    toUpdate.push(updateRow(row, changes, clears, pending));
+  }
+  return {
+    toUpdate,
+    toRepairAttachments,
+    ignoredRows,
+    ignored: ignoredRows.length,
+    unchanged
+  };
+}
+function requestedChanges(row, includeOptional) {
+  const changes = fieldMap(row.changes);
+  if (includeOptional)
+    Object.assign(changes, row.optional);
+  const clears = includeOptional ? row.optionalClears : [];
+  return { changes, clears };
+}
+function updateRow(row, changes, clears, pending) {
+  const values = fieldMap();
+  for (const field of Object.keys(changes)) {
+    if (Object.hasOwn(row.attachmentChanges, field) || clears.includes(field) || Object.hasOwn(row.foreignKeys, field)) {
+      continue;
+    }
+    values[field] = Object.hasOwn(row.values, field) ? row.values[field] : null;
+  }
+  const attachments = fieldMap(row.attachmentChanges);
+  for (const field of pending) {
+    attachments[field] = row.allAttachments[field];
+  }
+  return {
+    ...withoutMatchDetail(row),
+    values,
+    attachments,
+    ...clears.length > 0 ? { attachmentClears: clears } : {},
+    changes
+  };
+}
+function repairRow(row, pending) {
+  return {
+    ...withoutMatchDetail(row),
+    values: fieldMap(),
+    attachments: fieldMap(Object.fromEntries(pending.map((field) => [field, row.allAttachments[field]]))),
+    pendingFiles: pending
+  };
+}
+function withoutMatchDetail(row) {
+  const {
+    optional: _optional,
+    attachmentChanges: _attachmentChanges,
+    optionalClears: _optionalClears,
+    allAttachments: _allAttachments,
+    pendingFiles: _pendingFiles,
+    ...planned
+  } = row;
+  return planned;
+}
+function emptyPlan(input, errors, warnings, rowCount) {
+  return {
+    entityName: input.entityName,
+    entityId: input.entity.id,
+    expandRecords: needsExpandedRecords(input.entity),
+    requiredRelationships: requiredRelationshipsOf(input.entity),
+    strategy: input.strategy,
+    toInsert: [],
+    toUpdate: [],
+    toRepairAttachments: [],
+    ignoredRows: [],
+    ignored: 0,
+    unchanged: 0,
+    optionalDiffs: [],
+    idMap: new Map,
+    journalChanged: false,
+    rowCount,
+    errors,
+    warnings,
+    matched: [],
+    locate: (rows) => rows.map(() => {
+      return;
+    })
+  };
+}
+function requiredRelationshipsOf(entity) {
+  const names = new Set;
+  for (const field of entity.fields.values()) {
+    if (field.isForeignKey && field.isRequired && !field.isAttachment) {
+      names.add(field.name);
+    }
+  }
+  return names;
+}
+
+// src/services/seed/seed-file.ts
+async function readSeedFile(fs, workspaceDir, entityName) {
+  const nameProblem = entityNameProblem(entityName);
+  if (nameProblem) {
+    return { kind: "invalid", path: workspaceDir, why: nameProblem };
+  }
+  const path = fs.path.join(workspaceDir, `${entityName}.csv`);
+  const linkProblem = await seedFileLinkProblem(fs, workspaceDir, path);
+  if (linkProblem)
+    return { kind: "invalid", path, why: linkProblem };
+  const [readError, csv] = await catchError(fs.readFile(path, "utf-8"));
+  if (readError) {
+    return { kind: "invalid", path, why: readError.message };
+  }
+  if (csv === null)
+    return { kind: "absent", path };
+  const [parseError, table] = catchError(() => parseCsv(csv));
+  if (parseError || !table) {
+    return {
+      kind: "invalid",
+      path,
+      why: parseError?.message ?? "unknown error"
+    };
+  }
+  return { kind: "table", path, csv, table };
+}
+async function seedFileLinkProblem(fs, workspaceDir, path) {
+  const [rootError, rooted] = await catchError(async () => {
+    if (!await namesSeedRoot(workspaceDir, fs))
+      return;
+    return insideSeedRoot(workspaceDir, fs);
+  });
+  if (rootError) {
+    return `Could not check where the workspace leads: ${rootError.message}`;
+  }
+  if (rooted && !rooted.ok)
+    return rooted.message;
+  const [checkError, inside] = await catchError(async () => {
+    const root = await workspaceRoot(workspaceDir, fs);
+    return await isInsideWorkspace(root, path, fs) ? root : undefined;
+  });
+  if (checkError) {
+    return `Could not check where the file leads: ${checkError.message}`;
+  }
+  if (!inside) {
+    return "The file is a link that leads outside the seed workspace; " + "refusing to read it. Replace the link with the file itself.";
+  }
+  const [danglingError, dangling] = await catchError(isDanglingLink(path, fs));
+  if (danglingError) {
+    return `Could not check where the file leads: ${danglingError.message}`;
+  }
+  if (dangling) {
+    return "The file is a link to a path that does not exist; refusing to " + "read it. Replace the link with the file itself.";
+  }
+  const [aliasError, ownFile] = await catchError(pathHasExpectedTarget(inside, path, fs));
+  if (aliasError || ownFile === undefined) {
+    return `Could not check where the file leads: ${aliasError?.message ?? "the folder could not be listed"}`;
+  }
+  return ownFile ? undefined : "The file is a link to another file in the seed workspace; " + "refusing to read it — that file's rows would be seeded as " + "this entity's. Replace the link with the file itself.";
+}
+
+export { configKeyProblem, listVerticals, listPackages, listPackageVersions, normalizeVersions, getManifest, findFolderPath, orchestratorApi, listAllFolders, listFolderDtos, readAllPages, writeSeedContext, removeSeedContext, readSeedContext, BatchResponseSchema, WrittenRecordSchema, FailureRecordSchema, needsExpandedRecords, loadLiveEntities, loadChoiceSetValues, loadLiveRecords, journalEntity, putOwn, fieldMap, readStrategy, buildEntityPlan, withOptionalClears, readSeedFile };
+
+//# debugId=6FF4397A8C3FBAFA64756E2164756E21