@nuucognition/flint-cli 0.3.0-alpha.1 → 0.4.0-alpha.0

package/README.md

@@ -201,10 +201,19 @@ flint git init
 
 #### `flint git sync`
 
-Update `.gitignore` with workspace entries.
+Run the collaboration flow for a Flint repository: `flint sync`, stage all changes, commit with an identity-stamped sync message, pull with rebase, and push.
 
 ```bash
 flint git sync
+flint git sync -m "custom message"
+```
+
+#### `flint git publish <url>`
+
+Initialize git if needed, run `flint sync`, configure `origin`, create the initial commit if needed, and push to `main`.
+
+```bash
+flint git publish <url>
 ```
 
 #### `flint git <command>`
@@ -227,14 +236,15 @@ flint export build
 flint export build <name>
 ```
 
-### `flint import`
+### `flint source`
 
-Manage imports from other registered flints.
+Manage external sources declared by the Flint.
 
 ```bash
-flint import list
-flint import add "NUU Flint/Guide"
-flint import remove "NUU Flint/Guide"
+flint source repo add "Reference Repo" <url>
+flint source repo list
+flint source meshexport add "NUU Flint/Guide"
+flint source meshexport list
 ```
 
 ## Configuration
@@ -255,7 +265,7 @@ required = ["core"]
 required = ["git"]
 ```
 
-Optional sections include `[imports]` and `[workspace]` declarations.
+Optional sections include `[sources]` and `[workspace]` declarations.
 
 ### flint.lock
 

package/dist/{chunk-ODSWKVNZ.js → chunk-AUNE7HYH.js}

@@ -1,6 +1,10 @@
-// ../../packages/flint/dist/chunk-HCE4DXJK.js
-import { readdir, readFile, mkdir, writeFile, rm, stat } from "fs/promises";
-import { join, basename, dirname, resolve, relative, sep } from "path";
+import {
+  readFlintToml
+} from "./chunk-GQSLJAUU.js";
+
+// ../../packages/flint/dist/chunk-RLEEB7QI.js
+import { readdir, readFile, mkdir, writeFile, rm, stat, copyFile } from "fs/promises";
+import { join, basename, dirname, resolve, relative, sep, extname } from "path";
 async function exists(path) {
   try {
     await stat(path);
@@ -84,7 +88,7 @@ ${quotedContent}`;
   }
   return result;
 }
-async function rewriteWikilinks(content, flintName, flintPath, exportNameBySourcePath, resolveCache) {
+async function rewriteWikilinks(content, flintName, exportName, flintPath, exportNameBySourcePath, resolveCache) {
   const wikilinkRegex = /\[\[([^\]|#]+)(#[^\]|]*)?((\|)([^\]]*))?\]\]/g;
   let result = "";
   let lastIndex = 0;
@@ -103,9 +107,9 @@ async function rewriteWikilinks(content, flintName, flintPath, exportNameBySourc
     const resolvedPath = await resolveDocumentCached(target, flintPath, resolveCache);
     const exportBaseName = resolvedPath ? exportNameBySourcePath.get(resolvedPath) : void 0;
     if (exportBaseName) {
-      const prefixedName = `Export - (${flintName}) ${exportBaseName}`;
+      const dotName = `(Flint) ${flintName} . (Mesh Export) ${exportName} - ${exportBaseName}`;
       const displayAlias = alias || target;
-      result += `[[${prefixedName}${section}|${displayAlias}]]`;
+      result += `[[${dotName}${section}|${displayAlias}]]`;
     } else {
       result += match[0];
     }
@@ -208,8 +212,8 @@ function getDisambiguatedExportName(flintPath, sourcePath, baseName) {
   return `${baseName} (${dirLabel})`;
 }
 async function scanExports(flintPath) {
-  const { readFlintToml } = await import("./mesh-config-7GOTOVCM-TZEJ43E5.js");
-  const config = await readFlintToml(flintPath);
+  const { readFlintToml: readFlintToml2 } = await import("./mesh-config-TEPKR6QZ-TINWSM6H.js");
+  const config = await readFlintToml2(flintPath);
   const declarations = config?.exports?.required;
   if (!declarations || declarations.length === 0) {
     return [];
@@ -223,7 +227,7 @@ async function scanExportsFromConfig(flintPath, declarations) {
     if (!sourcePath) continue;
     try {
       const content = await readFile(sourcePath, "utf-8");
-      const depth = decl.depth ?? (decl.mode === "mesh" ? 1 : 1);
+      const depth = decl.depth ?? 1;
       const manifest = parseExportDocument(content, decl.name, sourcePath);
       manifest.depth = depth;
       manifests.push(manifest);
@@ -235,8 +239,8 @@ async function scanExportsFromConfig(flintPath, declarations) {
 async function scanExportEligible(flintPath) {
   const meshDir = join(flintPath, "Mesh");
   if (!await exists(meshDir)) return [];
-  const { readFlintToml } = await import("./mesh-config-7GOTOVCM-TZEJ43E5.js");
-  const config = await readFlintToml(flintPath);
+  const { readFlintToml: readFlintToml2 } = await import("./mesh-config-TEPKR6QZ-TINWSM6H.js");
+  const config = await readFlintToml2(flintPath);
   const declared = new Set(
     (config?.exports?.required || []).map((d) => d.file.replace(/\.md$/, "").toLowerCase())
   );
@@ -272,15 +276,40 @@ async function findExportTaggedFiles(dir, flintPath, declared, results) {
   } catch {
   }
 }
+async function collectMediaFiles(content, flintPath, collected) {
+  const contentBody = getContentWithoutFrontmatter(content);
+  const embedRegex = /!\[\[([^\]|#]+)(?:#[^\]|]*)?(?:\|[^\]]*)?\]\]/g;
+  let match;
+  while ((match = embedRegex.exec(contentBody)) !== null) {
+    const target = match[1]?.trim();
+    if (!target) continue;
+    if (target.endsWith(".md") || !target.includes(".")) continue;
+    const mediaPath = join(flintPath, "Media", target);
+    if (await exists(mediaPath)) {
+      collected.add(mediaPath);
+      continue;
+    }
+    const mediaDir = join(flintPath, "Media");
+    if (await exists(mediaDir)) {
+      const matches = await findFilesRecursively(mediaDir, basename(target));
+      if (matches.length > 0 && matches[0]) {
+        collected.add(matches[0]);
+      }
+    }
+  }
+}
 async function buildExport(manifest, flintPath) {
   const exportsDir = join(flintPath, "Exports");
-  const outputDir = join(exportsDir, `(Mesh) ${manifest.name}`);
+  const outputDir = join(exportsDir, `(Mesh Export) ${manifest.name}`);
+  const meshOutputDir = join(outputDir, "Mesh");
+  const mediaOutputDir = join(outputDir, "Media");
   if (await exists(outputDir)) {
     await rm(outputDir, { recursive: true });
   }
-  await mkdir(outputDir, { recursive: true });
+  await mkdir(meshOutputDir, { recursive: true });
+  const config = await readFlintToml(flintPath);
   const folderName = basename(flintPath);
-  const flintName = folderName.replace(/^\(Mesh\)\s*/, "").replace(/^\(Flint\)\s*/, "");
+  const flintName = config?.flint?.name || folderName.replace(/^\(Mesh\)\s*/, "").replace(/^\(Flint\)\s*/, "");
   const resolvedFiles = [];
   const processedPaths = /* @__PURE__ */ new Set();
   processedPaths.add(manifest.sourcePath);
@@ -306,6 +335,12 @@ async function buildExport(manifest, flintPath) {
       processedPaths.add(refPath);
     }
   }
+  const mediaFiles = /* @__PURE__ */ new Set();
+  await collectMediaFiles(exportContent, flintPath, mediaFiles);
+  for (const { sourcePath } of resolvedFiles) {
+    const content = await readFile(sourcePath, "utf-8");
+    await collectMediaFiles(content, flintPath, mediaFiles);
+  }
   const allExportFiles = [
     { sourcePath: manifest.sourcePath, baseName: basename(manifest.sourcePath, ".md") },
     ...resolvedFiles.map((f) => ({ sourcePath: f.sourcePath, baseName: basename(f.sourcePath, ".md") }))
@@ -319,37 +354,48 @@ async function buildExport(manifest, flintPath) {
   );
   const exportNameBySourcePath = /* @__PURE__ */ new Map();
   for (const { sourcePath, baseName } of allExportFiles) {
-    const exportName = duplicateBaseNames.has(baseName) ? getDisambiguatedExportName(flintPath, sourcePath, baseName) : baseName;
-    exportNameBySourcePath.set(sourcePath, exportName);
+    const name = duplicateBaseNames.has(baseName) ? getDisambiguatedExportName(flintPath, sourcePath, baseName) : baseName;
+    exportNameBySourcePath.set(sourcePath, name);
   }
+  const dotPrefix = `(Flint) ${flintName} . (Mesh Export) ${manifest.name}`;
   let filesCopied = 0;
   const copiedFiles = [];
   const resolveCache = /* @__PURE__ */ new Map();
   let rootContent = await readFile(manifest.sourcePath, "utf-8");
   rootContent = stripFrontmatter(rootContent);
   rootContent = await expandEmbeds(rootContent, flintPath, /* @__PURE__ */ new Set([manifest.sourcePath]));
-  rootContent = await rewriteWikilinks(rootContent, flintName, flintPath, exportNameBySourcePath, resolveCache);
+  rootContent = await rewriteWikilinks(rootContent, flintName, manifest.name, flintPath, exportNameBySourcePath, resolveCache);
   const rootExportName = exportNameBySourcePath.get(manifest.sourcePath) || manifest.name;
-  const rootFileName = `Export - (${flintName}) ${rootExportName}.md`;
-  await writeFile(join(outputDir, rootFileName), rootContent);
-  copiedFiles.push(rootFileName);
+  const rootFileName = `${dotPrefix} - ${rootExportName}.md`;
+  await writeFile(join(meshOutputDir, rootFileName), rootContent);
+  copiedFiles.push(`Mesh/${rootFileName}`);
   filesCopied++;
   for (const { sourcePath } of resolvedFiles) {
     const exportBaseName = exportNameBySourcePath.get(sourcePath) || basename(sourcePath, ".md");
-    const prefixedName = `Export - (${flintName}) ${exportBaseName}.md`;
-    const destPath = join(outputDir, prefixedName);
+    const fileName = `${dotPrefix} - ${exportBaseName}.md`;
+    const destPath = join(meshOutputDir, fileName);
     let content = await readFile(sourcePath, "utf-8");
     content = stripFrontmatter(content);
     content = await expandEmbeds(content, flintPath, /* @__PURE__ */ new Set([sourcePath]));
-    content = await rewriteWikilinks(content, flintName, flintPath, exportNameBySourcePath, resolveCache);
+    content = await rewriteWikilinks(content, flintName, manifest.name, flintPath, exportNameBySourcePath, resolveCache);
     await writeFile(destPath, content);
-    copiedFiles.push(prefixedName);
+    copiedFiles.push(`Mesh/${fileName}`);
     filesCopied++;
   }
+  if (mediaFiles.size > 0) {
+    await mkdir(mediaOutputDir, { recursive: true });
+    for (const mediaPath of mediaFiles) {
+      const originalName = basename(mediaPath);
+      const mediaFileName = `${dotPrefix} - ${originalName}`;
+      await copyFile(mediaPath, join(mediaOutputDir, mediaFileName));
+      copiedFiles.push(`Media/${mediaFileName}`);
+      filesCopied++;
+    }
+  }
   const manifestJson = {
     name: manifest.name,
     flint: flintName,
-    rootFile: rootFileName,
+    rootFile: `Mesh/${rootFileName}`,
     builtAt: (/* @__PURE__ */ new Date()).toISOString(),
     files: copiedFiles
   };
@@ -378,22 +424,13 @@ async function cleanupStaleExports(flintPath) {
     return removed;
   }
   const manifests = await scanExports(flintPath);
-  const validFolderNames = new Set(manifests.map((m) => `(Mesh) ${m.name}`));
-  const validLegacyNames = new Set(manifests.map((m) => m.name));
+  const validFolderNames = new Set(manifests.map((m) => `(Mesh Export) ${m.name}`));
   const entries = await readdir(exportsDir, { withFileTypes: true });
   for (const entry of entries) {
-    if (entry.isDirectory()) {
-      if (!validFolderNames.has(entry.name) && !validLegacyNames.has(entry.name)) {
-        try {
-          await rm(join(exportsDir, entry.name), { recursive: true });
-          removed.push(entry.name);
-        } catch {
-        }
-      }
-    } else if (entry.isFile() && entry.name.endsWith(".md")) {
+    if (entry.isDirectory() && !validFolderNames.has(entry.name)) {
       try {
-        await rm(join(exportsDir, entry.name));
-        removed.push(`${entry.name} (legacy manifest)`);
+        await rm(join(exportsDir, entry.name), { recursive: true });
+        removed.push(entry.name);
       } catch {
       }
     }

package/dist/{chunk-KLFK7CPM.js → chunk-GQSLJAUU.js}

@@ -1,7 +1,3 @@
-// ../../packages/flint/dist/chunk-HP5CLO2G.js
-import { readFile, writeFile, stat, mkdir } from "fs/promises";
-import { join as pathJoin } from "path";
-
 // ../../node_modules/.pnpm/smol-toml@1.6.0/node_modules/smol-toml/dist/error.js
 function getLineColFromPtr(string, ptr) {
   let lines = string.slice(0, ptr).split(/\r\n|\n|\r/g);
@@ -828,7 +824,9 @@ function stringify(obj, { maxDepth = 1e3, numbersAsFloat = false } = {}) {
   return str;
 }
 
-// ../../packages/flint/dist/chunk-HP5CLO2G.js
+// ../../packages/flint/dist/chunk-2MJMC5SY.js
+import { readFile, writeFile, stat, mkdir } from "fs/promises";
+import { join as pathJoin } from "path";
 import { randomUUID } from "crypto";
 var join = pathJoin;
 function resolveShardMode(decl) {
@@ -840,10 +838,20 @@ function isLocalShard(decl) {
 }
 var FLINT_CONFIG_FILENAME = "flint.toml";
 var FLINT_JSON_FILENAME = "flint.json";
-var FLINT_VERSION = "0.3.0";
+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 join(flintPath, FLINT_CONFIG_FILENAME);
 }
@@ -1001,6 +1009,7 @@ function formatFlintToml(config) {
       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)}`);
       }
@@ -1017,42 +1026,37 @@ function formatFlintToml(config) {
     lines.push(`required = ${inlineTableArray(items).join("\n")}`);
     lines.push("");
   }
-  const flintImports = config.imports?.flints || config.imports?.required || [];
-  if (flintImports.length) {
-    lines.push("[imports]");
-    lines.push(`flints = ${stringArray(flintImports).join("\n")}`);
-    lines.push("");
-  }
-  const hasRefs = config.workspace?.references?.length;
-  const hasRepos = config.workspace?.repositories?.length;
-  const hasSrcRepos = config.workspace?.sources?.repositories?.length;
-  if (hasRefs || hasRepos) {
-    lines.push("[workspace]");
-    if (hasRefs) {
-      const items = config.workspace.references.map((r) => ({ name: r.name, type: r.type }));
-      lines.push(`references = ${inlineTableArray(items).join("\n")}`);
-    }
-    if (hasRepos) {
-      const items = config.workspace.repositories.map((r) => ({ name: r.name, url: r.url }));
+  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 (hasSrcRepos) {
-    lines.push("[workspace.sources]");
-    const items = config.workspace.sources.repositories.map((r) => ({ name: r.name, url: r.url }));
+  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("");
   }
-  if (config.connections?.flints?.length) {
-    lines.push("[connections]");
-    const items = config.connections.flints.map((c) => ({ name: c.name }));
-    lines.push(`flints = ${inlineTableArray(items).join("\n")}`);
-    lines.push("");
-  }
-  if (config.git?.remote) {
-    lines.push("[git]");
-    lines.push(`remote = ${tv(config.git.remote)}`);
+  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) {
@@ -1061,7 +1065,7 @@ function formatFlintToml(config) {
     lines.push(`references = ${inlineTableArray(items).join("\n")}`);
     lines.push("");
   }
-  const knownKeys = /* @__PURE__ */ new Set(["flint", "shards", "exports", "imports", "workspace", "connections", "git", "lattices"]);
+  const knownKeys = /* @__PURE__ */ new Set(["flint", "shards", "exports", "imports", "sources", "workspace", "connections", "references", "lattices"]);
   const unknownKeys = Object.keys(config).filter((k) => !knownKeys.has(k));
   if (unknownKeys.length > 0) {
     const unknownConfig = {};
@@ -1094,8 +1098,9 @@ async function addShardToConfig(flintPath, shardName, source, options = {}) {
   const declarations = getShardDeclarationsFromConfig(config);
   const existing = declarations[kebabName];
   const effectiveSource = source || kebabName;
-  if (!existing || existing.source !== effectiveSource) {
+  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);
@@ -1173,43 +1178,6 @@ async function hasFlintToml(flintPath) {
 async function isFlint(flintPath) {
   return hasFlintToml(flintPath);
 }
-async function addWorkspaceReference(flintPath, name, type = "codebase") {
-  let config = await readFlintToml(flintPath);
-  if (!config) {
-    throw new Error("flint.toml not found");
-  }
-  if (!config.workspace) {
-    config.workspace = {};
-  }
-  if (!config.workspace.references) {
-    config.workspace.references = [];
-  }
-  const existing = config.workspace.references.find((r) => r.name.toLowerCase() === name.toLowerCase());
-  if (existing) {
-    throw new Error(`Workspace reference "${name}" already exists`);
-  }
-  config.workspace.references.push({ name, type });
-  await writeFlintToml(flintPath, config);
-}
-async function removeWorkspaceReference(flintPath, name) {
-  let config = await readFlintToml(flintPath);
-  if (!config?.workspace?.references) return false;
-  const normalizedName = name.toLowerCase();
-  const index = config.workspace.references.findIndex((r) => r.name.toLowerCase() === normalizedName);
-  if (index === -1) return false;
-  config.workspace.references.splice(index, 1);
-  await writeFlintToml(flintPath, config);
-  return true;
-}
-async function getWorkspaceReferences(flintPath) {
-  const config = await readFlintToml(flintPath);
-  return config?.workspace?.references || [];
-}
-async function getWorkspaceReference(flintPath, name) {
-  const config = await readFlintToml(flintPath);
-  const normalizedName = name.toLowerCase();
-  return config?.workspace?.references?.find((r) => r.name.toLowerCase() === normalizedName) || null;
-}
 async function addWorkspaceRepository(flintPath, name, url) {
   let config = await readFlintToml(flintPath);
   if (!config) {
@@ -1247,45 +1215,42 @@ async function getWorkspaceRepository(flintPath, name) {
   const normalizedName = name.toLowerCase();
   return config?.workspace?.repositories?.find((r) => r.name.toLowerCase() === normalizedName) || null;
 }
-async function addWorkspaceSourceRepository(flintPath, name, url) {
-  let config = await readFlintToml(flintPath);
+async function addSourceRepository(flintPath, name, url) {
+  const config = await readFlintToml(flintPath);
   if (!config) {
     throw new Error("flint.toml not found");
   }
-  if (!config.workspace) {
-    config.workspace = {};
-  }
-  if (!config.workspace.sources) {
-    config.workspace.sources = {};
+  if (!config.sources) {
+    config.sources = {};
   }
-  if (!config.workspace.sources.repositories) {
-    config.workspace.sources.repositories = [];
+  if (!config.sources.repositories) {
+    config.sources.repositories = [];
   }
-  const existing = config.workspace.sources.repositories.find((r) => r.name.toLowerCase() === name.toLowerCase());
+  const existing = config.sources.repositories.find((r) => r.name.toLowerCase() === name.toLowerCase());
   if (existing) {
     throw new Error(`Source repository "${name}" already exists`);
   }
-  config.workspace.sources.repositories.push({ name, url });
+  config.sources.repositories.push({ name, url });
   await writeFlintToml(flintPath, config);
 }
-async function removeWorkspaceSourceRepository(flintPath, name) {
-  let config = await readFlintToml(flintPath);
-  if (!config?.workspace?.sources?.repositories) return false;
+async function removeSourceRepository(flintPath, name) {
+  const config = await readFlintToml(flintPath);
+  if (!config?.sources?.repositories) return false;
   const normalizedName = name.toLowerCase();
-  const index = config.workspace.sources.repositories.findIndex((r) => r.name.toLowerCase() === normalizedName);
+  const index = config.sources.repositories.findIndex((r) => r.name.toLowerCase() === normalizedName);
   if (index === -1) return false;
-  config.workspace.sources.repositories.splice(index, 1);
+  config.sources.repositories.splice(index, 1);
   await writeFlintToml(flintPath, config);
   return true;
 }
-async function getWorkspaceSourceRepositories(flintPath) {
+async function getSourceRepositories(flintPath) {
   const config = await readFlintToml(flintPath);
-  return config?.workspace?.sources?.repositories || [];
+  return config?.sources?.repositories || [];
 }
-async function getWorkspaceSourceRepository(flintPath, name) {
+async function getSourceRepository(flintPath, name) {
   const config = await readFlintToml(flintPath);
   const normalizedName = name.toLowerCase();
-  return config?.workspace?.sources?.repositories?.find((r) => r.name.toLowerCase() === normalizedName) || null;
+  return config?.sources?.repositories?.find((r) => r.name.toLowerCase() === normalizedName) || null;
 }
 function getLatticesStatePath(flintPath) {
   return pathJoin(flintPath, ".flint", "lattices.json");
@@ -1422,54 +1387,42 @@ async function getExportDeclarations(flintPath) {
   const config = await readFlintToml(flintPath);
   return config?.exports?.required || [];
 }
-function resolveFlintImports(config) {
-  return config.imports?.flints || config.imports?.required || [];
-}
-function ensureFlintImports(config) {
-  if (!config.imports) {
-    config.imports = { flints: [] };
-  }
-  if (config.imports.required && !config.imports.flints) {
-    config.imports.flints = config.imports.required;
-  }
-  delete config.imports.required;
-  if (!config.imports.flints) {
-    config.imports.flints = [];
-  }
-  return config.imports.flints;
+async function getMeshExportSources(flintPath) {
+  const config = await readFlintToml(flintPath);
+  return config?.sources?.meshexports || [];
 }
-async function addImportToConfig(flintPath, ref) {
-  let config = await readFlintToml(flintPath);
+async function addMeshExportToConfig(flintPath, ref) {
+  const config = await readFlintToml(flintPath);
   if (!config) {
     throw new Error("flint.toml not found");
   }
-  const flints = ensureFlintImports(config);
-  if (!flints.includes(ref)) {
-    flints.push(ref);
+  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 removeImportFromConfig(flintPath, ref) {
-  let config = await readFlintToml(flintPath);
-  if (!config) return false;
-  const flints = ensureFlintImports(config);
-  const index = flints.indexOf(ref);
+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 = flints.findIndex((r) => r.toLowerCase() === lowerRef);
+    const foundIndex = meshexports.findIndex((r) => r.toLowerCase() === lowerRef);
     if (foundIndex === -1) return false;
-    flints.splice(foundIndex, 1);
+    meshexports.splice(foundIndex, 1);
   } else {
-    flints.splice(index, 1);
+    meshexports.splice(index, 1);
   }
   await writeFlintToml(flintPath, config);
   return true;
 }
-async function getFlintImports(flintPath) {
-  const config = await readFlintToml(flintPath);
-  if (!config) return [];
-  return resolveFlintImports(config);
-}
 
 export {
   parse,
@@ -1480,6 +1433,8 @@ export {
   FLINT_JSON_FILENAME,
   FLINT_VERSION,
   toKebabCase,
+  toSnakeCase,
+  nameFormats,
   getFlintConfigPath,
   getFlintJsonPath,
   createFlintToml,
@@ -1502,18 +1457,14 @@ export {
   migrateShardConfig,
   hasFlintToml,
   isFlint,
-  addWorkspaceReference,
-  removeWorkspaceReference,
-  getWorkspaceReferences,
-  getWorkspaceReference,
   addWorkspaceRepository,
   removeWorkspaceRepository,
   getWorkspaceRepositories,
   getWorkspaceRepository,
-  addWorkspaceSourceRepository,
-  removeWorkspaceSourceRepository,
-  getWorkspaceSourceRepositories,
-  getWorkspaceSourceRepository,
+  addSourceRepository,
+  removeSourceRepository,
+  getSourceRepositories,
+  getSourceRepository,
   readLatticesState,
   addLatticeDeclaration,
   removeLatticeDeclaration,
@@ -1528,9 +1479,9 @@ export {
   addExportToConfig,
   removeExportFromConfig,
   getExportDeclarations,
-  addImportToConfig,
-  removeImportFromConfig,
-  getFlintImports
+  getMeshExportSources,
+  addMeshExportToConfig,
+  removeMeshExportFromConfig
 };
 /*! Bundled license information: