@nuucognition/flint-cli 0.5.6-dev.10 → 0.5.6-dev.11

package/dist/chunk-DSRNHRUX.js

@@ -0,0 +1,768 @@
+import {
+  parse,
+  stringify
+} from "./chunk-YQMGDALR.js";
+
+// ../../packages/flint/dist/chunk-52SE24LG.js
+import { readFile, writeFile, stat as stat2, mkdir } from "fs/promises";
+import { join as join2 } from "path";
+import { randomUUID } from "crypto";
+import { stat } from "fs/promises";
+import { join, dirname, basename } from "path";
+var FLINT_DIR = ".flint";
+function getFlintConfigDir(flintPath) {
+  return join(flintPath, FLINT_DIR);
+}
+async function isInsideMesh(dir) {
+  let current = dir;
+  while (current !== dirname(current)) {
+    try {
+      const tomlPath = join(current, "flint.toml");
+      await stat(tomlPath);
+      return current;
+    } catch {
+      current = dirname(current);
+    }
+  }
+  return null;
+}
+function getTypePrefix() {
+  return "(Flint)";
+}
+function getFlintName(flintPath) {
+  const folderName = basename(flintPath);
+  const match = folderName.match(/^\((Mesh|Flint)\)\s+(.+)$/);
+  if (match && match[2]) {
+    return match[2];
+  }
+  return folderName;
+}
+function resolveShardMode(decl) {
+  return decl.mode;
+}
+function isLocalShard(decl) {
+  const mode = resolveShardMode(decl);
+  return mode === "dev" || mode === "custom";
+}
+var FLINT_CONFIG_FILENAME = "flint.toml";
+var FLINT_JSON_FILENAME = "flint.json";
+var FLINT_VERSION = "0.4.0";
+function toKebabCase(name) {
+  return name.replace(/\([^)]*\)\s*/g, "").toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "").replace(/^-+|-+$/g, "");
+}
+function toSnakeCase(name) {
+  return name.replace(/\([^)]*\)\s*/g, "").toLowerCase().replace(/\s+/g, "_").replace(/[^a-z0-9_]/g, "").replace(/^_+|_+$/g, "");
+}
+function nameFormats(name) {
+  return {
+    proper: name,
+    slug: toKebabCase(name),
+    snake: toSnakeCase(name)
+  };
+}
+function getFlintConfigPath(flintPath) {
+  return join2(flintPath, FLINT_CONFIG_FILENAME);
+}
+function getFlintJsonPath(flintPath) {
+  return join2(flintPath, FLINT_JSON_FILENAME);
+}
+async function exists(path) {
+  try {
+    await stat2(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function createFlintToml(name, shards = []) {
+  const shardDeclarations = {};
+  for (const source of shards) {
+    const repo = source.includes("/") ? source.split("/").pop() : source;
+    const key = repo.replace(/^shard-/, "");
+    shardDeclarations[key] = { source };
+  }
+  const config = {
+    flint: {
+      name
+    },
+    shards: shardDeclarations
+  };
+  return config;
+}
+function createFlintJson() {
+  return {
+    version: FLINT_VERSION,
+    id: randomUUID(),
+    type: "flint",
+    created: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function readFlintJson(flintPath) {
+  const jsonPath = getFlintJsonPath(flintPath);
+  try {
+    const content = await readFile(jsonPath, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+async function writeFlintJson(flintPath, json) {
+  const jsonPath = getFlintJsonPath(flintPath);
+  await writeFile(jsonPath, JSON.stringify(json, null, 2) + "\n");
+}
+async function hasFlintJson(flintPath) {
+  return exists(getFlintJsonPath(flintPath));
+}
+async function recordMigration(flintPath, migrationId) {
+  let json = await readFlintJson(flintPath);
+  if (!json) {
+    json = createFlintJson();
+  }
+  if (!json.migrations) {
+    json.migrations = {};
+  }
+  json.migrations[migrationId] = (/* @__PURE__ */ new Date()).toISOString();
+  await writeFlintJson(flintPath, json);
+}
+async function hasMigration(flintPath, migrationId) {
+  const json = await readFlintJson(flintPath);
+  return !!json?.migrations?.[migrationId];
+}
+async function getFlintJsonVersion(flintPath) {
+  const json = await readFlintJson(flintPath);
+  return json?.version ?? null;
+}
+async function stampVersion(flintPath) {
+  let json = await readFlintJson(flintPath);
+  if (!json) {
+    json = createFlintJson();
+  }
+  json.version = FLINT_VERSION;
+  if (!json.id) json.id = randomUUID();
+  if (!json.type) json.type = "flint";
+  if (!json.created) json.created = (/* @__PURE__ */ new Date()).toISOString();
+  await writeFlintJson(flintPath, json);
+}
+async function stampSynced(flintPath) {
+  const syncPath = join2(getFlintConfigDir(flintPath), "sync.json");
+  let data = {};
+  try {
+    data = JSON.parse(await readFile(syncPath, "utf-8"));
+  } catch {
+  }
+  data.synced = (/* @__PURE__ */ new Date()).toISOString();
+  await writeFile(syncPath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+async function readFlintToml(flintPath) {
+  const configPath = getFlintConfigPath(flintPath);
+  try {
+    const content = await readFile(configPath, "utf-8");
+    return parse(content);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+function tv(v) {
+  if (typeof v === "string") return `"${v}"`;
+  if (typeof v === "boolean") return v ? "true" : "false";
+  if (typeof v === "number") return String(v);
+  if (Array.isArray(v)) return `[${v.map(tv).join(", ")}]`;
+  return String(v);
+}
+function inlineTable(obj) {
+  const parts = Object.entries(obj).filter(([, v]) => v !== void 0 && v !== null).map(([k, v]) => `${k} = ${tv(v)}`);
+  return `{ ${parts.join(", ")} }`;
+}
+function inlineTableArray(items) {
+  return [
+    "[",
+    ...items.map((item) => `  ${inlineTable(item)},`),
+    "]"
+  ];
+}
+function stringArray(items) {
+  return [
+    "[",
+    ...items.map((s) => `  "${s}",`),
+    "]"
+  ];
+}
+function formatFlintToml(config) {
+  const lines = [];
+  lines.push("[flint]");
+  lines.push(`name = ${tv(config.flint.name)}`);
+  if (config.flint.type) lines.push(`type = ${tv(config.flint.type)}`);
+  if (config.flint.description) lines.push(`description = ${tv(config.flint.description)}`);
+  if (config.flint.tags?.length) lines.push(`tags = ${tv(config.flint.tags)}`);
+  if (config.flint.org) lines.push(`org = ${tv(config.flint.org)}`);
+  lines.push("");
+  if (config.shards) {
+    const declarations = getShardDeclarationsFromConfig(config);
+    if (Object.keys(declarations).length > 0) {
+      lines.push("[shards]");
+      for (const [shorthand, decl] of Object.entries(declarations)) {
+        const mode = resolveShardMode(decl);
+        const fields = { source: decl.source };
+        if (decl.version) fields.version = decl.version;
+        if (mode) fields.mode = mode;
+        lines.push(`${shorthand} = ${inlineTable(fields)}`);
+      }
+      lines.push("");
+    }
+  }
+  if (config.exports?.required?.length) {
+    lines.push("[exports]");
+    const items = config.exports.required.map((e) => {
+      const fields = { name: e.name, file: e.file, mode: e.mode };
+      if (e.depth !== void 0 && e.depth !== 1) fields.depth = e.depth;
+      return fields;
+    });
+    lines.push(`required = ${inlineTableArray(items).join("\n")}`);
+    lines.push("");
+  }
+  const hasSourceRepositories = Boolean(config.sources?.repositories?.length);
+  const hasMeshExportSources = Boolean(config.sources?.meshexports?.length);
+  if (hasSourceRepositories || hasMeshExportSources) {
+    lines.push("[sources]");
+    if (hasSourceRepositories) {
+      const items = config.sources.repositories.map((r) => ({ name: r.name, url: r.url }));
+      lines.push(`repositories = ${inlineTableArray(items).join("\n")}`);
+    }
+    if (hasMeshExportSources) {
+      lines.push(`meshexports = ${stringArray(config.sources.meshexports).join("\n")}`);
+    }
+    lines.push("");
+  }
+  if (config.workspace?.repositories?.length) {
+    lines.push("[workspace]");
+    const items = config.workspace.repositories.map((r) => ({ name: r.name, url: r.url }));
+    lines.push(`repositories = ${inlineTableArray(items).join("\n")}`);
+    lines.push("");
+  }
+  {
+    const plateDecls = getPlateDeclarationsFromConfig(config);
+    if (Object.keys(plateDecls).length > 0) {
+      lines.push("[plates]");
+      for (const [name, decl] of Object.entries(plateDecls)) {
+        const fields = {};
+        if (decl.title) fields.title = decl.title;
+        if (decl.source) fields.source = decl.source;
+        if (decl.version) fields.version = decl.version;
+        if (decl.path) fields.path = decl.path;
+        if (decl.repo) fields.repo = decl.repo;
+        lines.push(`${name} = ${inlineTable(fields)}`);
+      }
+      lines.push("");
+    }
+  }
+  const hasRefCodebases = config.references?.codebases?.length;
+  const hasRefFlints = config.references?.flints?.length;
+  if (hasRefCodebases || hasRefFlints) {
+    lines.push("[references]");
+    if (hasRefCodebases) {
+      const items = config.references.codebases.map((c) => ({ name: c.name }));
+      lines.push(`codebases = ${inlineTableArray(items).join("\n")}`);
+    }
+    if (hasRefFlints) {
+      const items = config.references.flints.map((f) => ({ name: f.name }));
+      lines.push(`flints = ${inlineTableArray(items).join("\n")}`);
+    }
+    lines.push("");
+  }
+  if (config.lattices?.references?.length) {
+    lines.push("[lattices]");
+    const items = config.lattices.references.map((l) => ({ name: l.name }));
+    lines.push(`references = ${inlineTableArray(items).join("\n")}`);
+    lines.push("");
+  }
+  const knownKeys = /* @__PURE__ */ new Set(["flint", "shards", "exports", "imports", "sources", "workspace", "plates", "connections", "references", "lattices"]);
+  const unknownKeys = Object.keys(config).filter((k) => !knownKeys.has(k));
+  if (unknownKeys.length > 0) {
+    const unknownConfig = {};
+    for (const key of unknownKeys) {
+      unknownConfig[key] = config[key];
+    }
+    lines.push(stringify(unknownConfig));
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+async function writeFlintToml(flintPath, config) {
+  const configPath = getFlintConfigPath(flintPath);
+  const content = formatFlintToml(config);
+  await writeFile(configPath, content);
+}
+async function addShardToConfig(flintPath, shardName, source, options = {}) {
+  let config = await readFlintToml(flintPath);
+  if (!config) {
+    throw new Error("flint.toml not found");
+  }
+  const kebabName = toKebabCase(shardName);
+  if (!config.shards) {
+    config.shards = {};
+  }
+  if (config.shards.required && Array.isArray(config.shards.required)) {
+    await migrateShardConfig(flintPath);
+    config = await readFlintToml(flintPath);
+  }
+  const declarations = getShardDeclarationsFromConfig(config);
+  const existing = declarations[kebabName];
+  const effectiveSource = source || kebabName;
+  if (!existing || existing.source !== effectiveSource || options.version !== existing?.version) {
+    const decl = { source: effectiveSource };
+    if (options.version) decl.version = options.version;
+    if (options.mode) decl.mode = options.mode;
+    config.shards[kebabName] = decl;
+    await writeFlintToml(flintPath, config);
+  }
+}
+async function removeShardFromConfig(flintPath, shardName) {
+  let config = await readFlintToml(flintPath);
+  if (!config?.shards) return;
+  const kebabName = toKebabCase(shardName);
+  if (config.shards.required && Array.isArray(config.shards.required)) {
+    config.shards.required = config.shards.required.filter((n) => n !== kebabName);
+  }
+  if (kebabName in config.shards) {
+    delete config.shards[kebabName];
+  }
+  await writeFlintToml(flintPath, config);
+}
+async function getRequiredShardNames(flintPath) {
+  const config = await readFlintToml(flintPath);
+  if (!config?.shards) return [];
+  const declarations = getShardDeclarationsFromConfig(config);
+  return Object.keys(declarations);
+}
+function getShardDeclarationsFromConfig(config) {
+  if (!config.shards) return {};
+  const declarations = {};
+  for (const [key, value] of Object.entries(config.shards)) {
+    if (key === "required") continue;
+    if (value && typeof value === "object" && !Array.isArray(value) && "source" in value) {
+      declarations[key] = value;
+    }
+  }
+  if (config.shards.required && Array.isArray(config.shards.required)) {
+    for (const name of config.shards.required) {
+      if (!declarations[name]) {
+        declarations[name] = { source: name };
+      }
+    }
+  }
+  return declarations;
+}
+async function getShardDeclarations(flintPath) {
+  const config = await readFlintToml(flintPath);
+  if (!config) return {};
+  return getShardDeclarationsFromConfig(config);
+}
+async function migrateShardConfig(flintPath) {
+  const config = await readFlintToml(flintPath);
+  if (!config?.shards?.required || !Array.isArray(config.shards.required)) {
+    return false;
+  }
+  const hasNewFormat = Object.keys(config.shards).some(
+    (k) => k !== "required" && typeof config.shards[k] === "object" && !Array.isArray(config.shards[k])
+  );
+  if (hasNewFormat && config.shards.required.length === 0) {
+    return false;
+  }
+  const declarations = {};
+  for (const name of config.shards.required) {
+    declarations[name] = { source: name };
+  }
+  for (const [key, value] of Object.entries(config.shards)) {
+    if (key === "required") continue;
+    if (value && typeof value === "object" && !Array.isArray(value) && "source" in value) {
+      declarations[key] = value;
+    }
+  }
+  config.shards = declarations;
+  await writeFlintToml(flintPath, config);
+  return true;
+}
+async function hasFlintToml(flintPath) {
+  return exists(getFlintConfigPath(flintPath));
+}
+async function isFlint(flintPath) {
+  return hasFlintToml(flintPath);
+}
+async function addWorkspaceRepository(flintPath, name, url) {
+  let config = await readFlintToml(flintPath);
+  if (!config) {
+    throw new Error("flint.toml not found");
+  }
+  if (!config.workspace) {
+    config.workspace = {};
+  }
+  if (!config.workspace.repositories) {
+    config.workspace.repositories = [];
+  }
+  const existing = config.workspace.repositories.find((r) => r.name.toLowerCase() === name.toLowerCase());
+  if (existing) {
+    throw new Error(`Repository "${name}" already exists`);
+  }
+  config.workspace.repositories.push({ name, url });
+  await writeFlintToml(flintPath, config);
+}
+async function removeWorkspaceRepository(flintPath, name) {
+  let config = await readFlintToml(flintPath);
+  if (!config?.workspace?.repositories) return false;
+  const normalizedName = name.toLowerCase();
+  const index = config.workspace.repositories.findIndex((r) => r.name.toLowerCase() === normalizedName);
+  if (index === -1) return false;
+  config.workspace.repositories.splice(index, 1);
+  await writeFlintToml(flintPath, config);
+  return true;
+}
+async function getWorkspaceRepositories(flintPath) {
+  const config = await readFlintToml(flintPath);
+  return config?.workspace?.repositories || [];
+}
+async function getWorkspaceRepository(flintPath, name) {
+  const config = await readFlintToml(flintPath);
+  const normalizedName = name.toLowerCase();
+  return config?.workspace?.repositories?.find((r) => r.name.toLowerCase() === normalizedName) || null;
+}
+async function addPlateDeclaration(flintPath, name, platePath, options = {}) {
+  const config = await readFlintToml(flintPath);
+  if (!config) {
+    throw new Error("flint.toml not found");
+  }
+  if (!config.plates) {
+    config.plates = {};
+  }
+  const decl = { path: platePath };
+  if (options.title) decl.title = options.title;
+  config.plates[name] = decl;
+  await writeFlintToml(flintPath, config);
+}
+async function setPlateDeclaration(flintPath, name, declaration) {
+  const config = await readFlintToml(flintPath);
+  if (!config) {
+    throw new Error("flint.toml not found");
+  }
+  if (!config.plates) {
+    config.plates = {};
+  }
+  config.plates[name] = declaration;
+  await writeFlintToml(flintPath, config);
+}
+async function removePlateDeclaration(flintPath, name) {
+  const config = await readFlintToml(flintPath);
+  if (!config?.plates?.[name]) {
+    return false;
+  }
+  delete config.plates[name];
+  await writeFlintToml(flintPath, config);
+  return true;
+}
+async function getPlateDeclarations(flintPath) {
+  const config = await readFlintToml(flintPath);
+  return getPlateDeclarationsFromConfig(config);
+}
+function getPlateDeclarationsFromConfig(config) {
+  if (!config?.plates) return {};
+  const declarations = {};
+  for (const [key, value] of Object.entries(config.plates)) {
+    if (value && typeof value === "object" && ("path" in value || "source" in value)) {
+      declarations[key] = value;
+    }
+  }
+  return declarations;
+}
+async function setPlateRepo(flintPath, name, url) {
+  const config = await readFlintToml(flintPath);
+  if (!config) {
+    throw new Error("flint.toml not found");
+  }
+  if (!config.plates) {
+    config.plates = {};
+  }
+  const existing = config.plates[name];
+  if (!existing) {
+    throw new Error(`Plate "${name}" not found in flint.toml`);
+  }
+  config.plates[name] = { ...existing, repo: url };
+  await writeFlintToml(flintPath, config);
+}
+async function getPlateDeclaration(flintPath, name) {
+  const declarations = await getPlateDeclarations(flintPath);
+  return declarations[name] ?? null;
+}
+async function addSourceRepository(flintPath, name, url) {
+  const config = await readFlintToml(flintPath);
+  if (!config) {
+    throw new Error("flint.toml not found");
+  }
+  if (!config.sources) {
+    config.sources = {};
+  }
+  if (!config.sources.repositories) {
+    config.sources.repositories = [];
+  }
+  const existing = config.sources.repositories.find((r) => r.name.toLowerCase() === name.toLowerCase());
+  if (existing) {
+    throw new Error(`Source repository "${name}" already exists`);
+  }
+  config.sources.repositories.push({ name, url });
+  await writeFlintToml(flintPath, config);
+}
+async function removeSourceRepository(flintPath, name) {
+  const config = await readFlintToml(flintPath);
+  if (!config?.sources?.repositories) return false;
+  const normalizedName = name.toLowerCase();
+  const index = config.sources.repositories.findIndex((r) => r.name.toLowerCase() === normalizedName);
+  if (index === -1) return false;
+  config.sources.repositories.splice(index, 1);
+  await writeFlintToml(flintPath, config);
+  return true;
+}
+async function getSourceRepositories(flintPath) {
+  const config = await readFlintToml(flintPath);
+  return config?.sources?.repositories || [];
+}
+async function getSourceRepository(flintPath, name) {
+  const config = await readFlintToml(flintPath);
+  const normalizedName = name.toLowerCase();
+  return config?.sources?.repositories?.find((r) => r.name.toLowerCase() === normalizedName) || null;
+}
+function getLatticesStatePath(flintPath) {
+  return join2(flintPath, ".flint", "lattices.json");
+}
+async function readLatticesState(flintPath) {
+  const statePath = getLatticesStatePath(flintPath);
+  try {
+    const content = await readFile(statePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return { version: 1, lattices: [] };
+  }
+}
+async function writeLatticesState(flintPath, state) {
+  const statePath = getLatticesStatePath(flintPath);
+  const dir = join2(flintPath, ".flint");
+  await mkdir(dir, { recursive: true });
+  await writeFile(statePath, JSON.stringify(state, null, 2) + "\n");
+}
+async function addLatticeDeclaration(flintPath, name) {
+  let config = await readFlintToml(flintPath);
+  if (!config) {
+    throw new Error("flint.toml not found");
+  }
+  if (!config.lattices) {
+    config.lattices = { references: [] };
+  }
+  if (!config.lattices.references) {
+    config.lattices.references = [];
+  }
+  const existing = config.lattices.references.find(
+    (entry) => entry.name.toLowerCase() === name.toLowerCase()
+  );
+  if (existing) {
+    throw new Error(`Lattice "${name}" is already declared`);
+  }
+  config.lattices.references.push({ name });
+  await writeFlintToml(flintPath, config);
+}
+async function removeLatticeDeclaration(flintPath, name) {
+  let config = await readFlintToml(flintPath);
+  if (!config?.lattices?.references) return false;
+  const normalizedName = name.toLowerCase();
+  const index = config.lattices.references.findIndex(
+    (entry) => entry.name.toLowerCase() === normalizedName
+  );
+  if (index === -1) return false;
+  config.lattices.references.splice(index, 1);
+  await writeFlintToml(flintPath, config);
+  const state = await readLatticesState(flintPath);
+  state.lattices = state.lattices.filter(
+    (l) => l.name.toLowerCase() !== normalizedName
+  );
+  await writeLatticesState(flintPath, state);
+  return true;
+}
+async function fulfillLattice(flintPath, name, latticePath, lang) {
+  const fulfillment = {
+    name,
+    path: latticePath,
+    lang,
+    fulfilled: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const state = await readLatticesState(flintPath);
+  const existingIndex = state.lattices.findIndex(
+    (l) => l.name.toLowerCase() === name.toLowerCase()
+  );
+  if (existingIndex >= 0) {
+    state.lattices[existingIndex] = fulfillment;
+  } else {
+    state.lattices.push(fulfillment);
+  }
+  await writeLatticesState(flintPath, state);
+  return fulfillment;
+}
+async function getLatticeDeclarations(flintPath) {
+  const config = await readFlintToml(flintPath);
+  return config?.lattices?.references || [];
+}
+async function getLatticeDeclaration(flintPath, name) {
+  const config = await readFlintToml(flintPath);
+  const normalizedName = name.toLowerCase();
+  return config?.lattices?.references?.find(
+    (entry) => entry.name.toLowerCase() === normalizedName
+  ) || null;
+}
+async function getLatticeFulfillment(flintPath, name) {
+  const state = await readLatticesState(flintPath);
+  return state.lattices.find(
+    (l) => l.name.toLowerCase() === name.toLowerCase()
+  ) || null;
+}
+async function addExportToConfig(flintPath, declaration) {
+  let config = await readFlintToml(flintPath);
+  if (!config) {
+    throw new Error("flint.toml not found");
+  }
+  if (!config.exports) {
+    config.exports = { required: [] };
+  }
+  if (!config.exports.required) {
+    config.exports.required = [];
+  }
+  const existing = config.exports.required.find(
+    (e) => e.name.toLowerCase() === declaration.name.toLowerCase()
+  );
+  if (existing) {
+    throw new Error(`Export "${declaration.name}" already declared`);
+  }
+  config.exports.required.push({
+    name: declaration.name,
+    file: declaration.file,
+    mode: declaration.mode,
+    ...declaration.depth !== void 0 ? { depth: declaration.depth } : {}
+  });
+  await writeFlintToml(flintPath, config);
+}
+async function removeExportFromConfig(flintPath, exportName) {
+  let config = await readFlintToml(flintPath);
+  if (!config?.exports?.required) return false;
+  const index = config.exports.required.findIndex(
+    (e) => e.name.toLowerCase() === exportName.toLowerCase()
+  );
+  if (index === -1) return false;
+  config.exports.required.splice(index, 1);
+  await writeFlintToml(flintPath, config);
+  return true;
+}
+async function getExportDeclarations(flintPath) {
+  const config = await readFlintToml(flintPath);
+  return config?.exports?.required || [];
+}
+async function getMeshExportSources(flintPath) {
+  const config = await readFlintToml(flintPath);
+  return config?.sources?.meshexports || [];
+}
+async function addMeshExportToConfig(flintPath, ref) {
+  const config = await readFlintToml(flintPath);
+  if (!config) {
+    throw new Error("flint.toml not found");
+  }
+  if (!config.sources) {
+    config.sources = {};
+  }
+  if (!config.sources.meshexports) {
+    config.sources.meshexports = [];
+  }
+  if (!config.sources.meshexports.includes(ref)) {
+    config.sources.meshexports.push(ref);
+    await writeFlintToml(flintPath, config);
+  }
+}
+async function removeMeshExportFromConfig(flintPath, ref) {
+  const config = await readFlintToml(flintPath);
+  if (!config?.sources?.meshexports) return false;
+  const meshexports = config.sources.meshexports;
+  const index = meshexports.indexOf(ref);
+  if (index === -1) {
+    const lowerRef = ref.toLowerCase();
+    const foundIndex = meshexports.findIndex((r) => r.toLowerCase() === lowerRef);
+    if (foundIndex === -1) return false;
+    meshexports.splice(foundIndex, 1);
+  } else {
+    meshexports.splice(index, 1);
+  }
+  await writeFlintToml(flintPath, config);
+  return true;
+}
+
+export {
+  getFlintConfigDir,
+  isInsideMesh,
+  getTypePrefix,
+  getFlintName,
+  resolveShardMode,
+  isLocalShard,
+  FLINT_CONFIG_FILENAME,
+  FLINT_JSON_FILENAME,
+  FLINT_VERSION,
+  toKebabCase,
+  toSnakeCase,
+  nameFormats,
+  getFlintConfigPath,
+  getFlintJsonPath,
+  createFlintToml,
+  createFlintJson,
+  readFlintJson,
+  writeFlintJson,
+  hasFlintJson,
+  recordMigration,
+  hasMigration,
+  getFlintJsonVersion,
+  stampVersion,
+  stampSynced,
+  readFlintToml,
+  writeFlintToml,
+  addShardToConfig,
+  removeShardFromConfig,
+  getRequiredShardNames,
+  getShardDeclarationsFromConfig,
+  getShardDeclarations,
+  migrateShardConfig,
+  hasFlintToml,
+  isFlint,
+  addWorkspaceRepository,
+  removeWorkspaceRepository,
+  getWorkspaceRepositories,
+  getWorkspaceRepository,
+  addPlateDeclaration,
+  setPlateDeclaration,
+  removePlateDeclaration,
+  getPlateDeclarations,
+  getPlateDeclarationsFromConfig,
+  setPlateRepo,
+  getPlateDeclaration,
+  addSourceRepository,
+  removeSourceRepository,
+  getSourceRepositories,
+  getSourceRepository,
+  readLatticesState,
+  addLatticeDeclaration,
+  removeLatticeDeclaration,
+  fulfillLattice,
+  getLatticeDeclarations,
+  getLatticeDeclaration,
+  getLatticeFulfillment,
+  addExportToConfig,
+  removeExportFromConfig,
+  getExportDeclarations,
+  getMeshExportSources,
+  addMeshExportToConfig,
+  removeMeshExportFromConfig
+};