@nuucognition/flint-cli 0.5.6-dev.7 → 0.6.0-dev.0

package/dist/chunk-IUKEMLPH.js

@@ -1,465 +0,0 @@
-import {
-  readFlintToml
-} from "./chunk-LLLVBA4Q.js";
-
-// ../../packages/flint/dist/chunk-NRALZ6JV.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);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function isPathWithinRoot(root, target) {
-  const resolvedRoot = resolve(root);
-  const resolvedTarget = resolve(target);
-  if (resolvedTarget === resolvedRoot) {
-    return true;
-  }
-  return resolvedTarget.startsWith(resolvedRoot + sep);
-}
-function stripFrontmatter(content) {
-  return content.replace(/^---\n[\s\S]*?\n---\n*/, "");
-}
-function getContentWithoutFrontmatter(content) {
-  const match = content.match(/^---\n[\s\S]*?\n---\n*/);
-  if (match) {
-    return content.slice(match[0].length);
-  }
-  return content;
-}
-async function collectReferencedFiles(content, flintPath, collected = /* @__PURE__ */ new Set(), visited = /* @__PURE__ */ new Set(), depth = -1, currentDepth = 0) {
-  if (depth !== -1 && currentDepth >= depth) {
-    return collected;
-  }
-  const contentWithoutFrontmatter = getContentWithoutFrontmatter(content);
-  const linkRegex = /!?\[\[([^\]|#]+)(?:#[^\]|]*)?(?:\|[^\]]*)?\]\]/g;
-  let match;
-  while ((match = linkRegex.exec(contentWithoutFrontmatter)) !== null) {
-    const captured = match[1];
-    if (!captured) continue;
-    const target = captured.trim();
-    const sourcePath = await resolveDocument(target, flintPath);
-    if (!sourcePath || visited.has(sourcePath)) {
-      continue;
-    }
-    collected.add(sourcePath);
-    visited.add(sourcePath);
-    if (depth === -1 || currentDepth + 1 < depth) {
-      const referencedContent = await readFile(sourcePath, "utf-8");
-      await collectReferencedFiles(referencedContent, flintPath, collected, visited, depth, currentDepth + 1);
-    }
-  }
-  return collected;
-}
-async function expandEmbeds(content, flintPath, visited = /* @__PURE__ */ new Set()) {
-  const embedRegex = /!\[\[([^\]|#]+)(?:#[^\]|]*)?(?:\|[^\]]*)?\]\]/g;
-  let result = content;
-  let match;
-  const matches = [];
-  while ((match = embedRegex.exec(content)) !== null) {
-    const captured = match[1];
-    if (!captured) continue;
-    matches.push({ full: match[0], target: captured.trim() });
-  }
-  for (const { full, target } of matches) {
-    const sourcePath = await resolveDocument(target, flintPath);
-    if (!sourcePath) {
-      continue;
-    }
-    if (visited.has(sourcePath)) {
-      result = result.replace(full, `<!-- Circular embed removed: ${target} -->`);
-      continue;
-    }
-    let embeddedContent = await readFile(sourcePath, "utf-8");
-    embeddedContent = embeddedContent.replace(/^---\n[\s\S]*?\n---\n*/, "");
-    const newVisited = new Set(visited);
-    newVisited.add(sourcePath);
-    embeddedContent = await expandEmbeds(embeddedContent, flintPath, newVisited);
-    const fileName = basename(sourcePath, ".md");
-    const quotedContent = embeddedContent.trim().split("\n").map((line) => `> ${line}`).join("\n");
-    const formattedEmbed = `> **${fileName}**
->
-${quotedContent}`;
-    result = result.replace(full, formattedEmbed);
-  }
-  return result;
-}
-async function rewriteWikilinks(content, flintName, exportName, flintPath, exportNameBySourcePath, resolveCache) {
-  const wikilinkRegex = /\[\[([^\]|#]+)(#[^\]|]*)?((\|)([^\]]*))?\]\]/g;
-  let result = "";
-  let lastIndex = 0;
-  let match;
-  while ((match = wikilinkRegex.exec(content)) !== null) {
-    const matchIndex = match.index ?? 0;
-    result += content.slice(lastIndex, matchIndex);
-    const target = match[1]?.trim();
-    const section = match[2] || "";
-    const alias = match[5];
-    if (!target) {
-      result += match[0];
-      lastIndex = matchIndex + match[0].length;
-      continue;
-    }
-    const resolvedPath = await resolveDocumentCached(target, flintPath, resolveCache);
-    const exportBaseName = resolvedPath ? exportNameBySourcePath.get(resolvedPath) : void 0;
-    if (exportBaseName) {
-      const dotName = `(Flint) ${flintName} . (Mesh Export) ${exportName} - ${exportBaseName}`;
-      const displayAlias = alias || target;
-      result += `[[${dotName}${section}|${displayAlias}]]`;
-    } else {
-      result += match[0];
-    }
-    lastIndex = matchIndex + match[0].length;
-  }
-  result += content.slice(lastIndex);
-  return result;
-}
-function parseExportDocument(content, name, sourcePath) {
-  const files = [];
-  let description;
-  let depth = 1;
-  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
-  if (frontmatterMatch && frontmatterMatch[1]) {
-    const descMatch = frontmatterMatch[1].match(/description:\s*(.+)/);
-    if (descMatch && descMatch[1]) {
-      description = descMatch[1].trim().replace(/^["']|["']$/g, "");
-    }
-    const depthMatch = frontmatterMatch[1].match(/export-depth:\s*(-?\d+)/);
-    if (depthMatch && depthMatch[1]) {
-      depth = parseInt(depthMatch[1], 10);
-    }
-  }
-  const contentWithoutFrontmatter = getContentWithoutFrontmatter(content);
-  const wikilinkRegex = /\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/g;
-  let match;
-  while ((match = wikilinkRegex.exec(contentWithoutFrontmatter)) !== null) {
-    if (match[1]) files.push(match[1]);
-  }
-  const mdLinkRegex = /\[([^\]]+)\]\(([^)]+\.md)\)/g;
-  while ((match = mdLinkRegex.exec(contentWithoutFrontmatter)) !== null) {
-    if (match[2]) files.push(match[2]);
-  }
-  return { name, description, depth, files, sourcePath };
-}
-async function findFilesRecursively(dir, fileName, matches = []) {
-  try {
-    const entries = await readdir(dir, { withFileTypes: true });
-    entries.sort((a, b) => a.name.localeCompare(b.name));
-    for (const entry of entries) {
-      const fullPath = join(dir, entry.name);
-      if (entry.isFile() && entry.name === fileName) {
-        matches.push(fullPath);
-      }
-      if (entry.isDirectory()) {
-        await findFilesRecursively(fullPath, fileName, matches);
-      }
-    }
-  } catch {
-  }
-  return matches;
-}
-async function resolveDocument(docRef, flintPath) {
-  const trimmedRef = docRef.trim();
-  if (!trimmedRef) {
-    return null;
-  }
-  const normalizedRef = trimmedRef.replace(/\\/g, "/");
-  const hasPath = normalizedRef.includes("/");
-  if (hasPath) {
-    const cleanedRef = normalizedRef.replace(/^\.?\//, "");
-    const withExt = cleanedRef.endsWith(".md") ? cleanedRef : `${cleanedRef}.md`;
-    const directCandidate = resolve(flintPath, withExt);
-    if (isPathWithinRoot(flintPath, directCandidate) && await exists(directCandidate)) {
-      return directCandidate;
-    }
-    if (!cleanedRef.startsWith("Mesh/")) {
-      const meshCandidate = resolve(flintPath, "Mesh", withExt);
-      if (isPathWithinRoot(flintPath, meshCandidate) && await exists(meshCandidate)) {
-        return meshCandidate;
-      }
-    }
-  }
-  const docName = basename(trimmedRef);
-  const fileName = docName.endsWith(".md") ? docName : `${docName}.md`;
-  const meshDir = join(flintPath, "Mesh");
-  const meshMatches = await findFilesRecursively(meshDir, fileName);
-  if (meshMatches.length > 0) {
-    meshMatches.sort();
-    return meshMatches[0] ?? null;
-  }
-  const shardsDir = join(flintPath, "Shards");
-  const shardMatches = await findFilesRecursively(shardsDir, fileName);
-  if (shardMatches.length > 0) {
-    shardMatches.sort();
-    return shardMatches[0] ?? null;
-  }
-  return null;
-}
-async function resolveDocumentCached(docRef, flintPath, cache) {
-  const key = docRef.trim();
-  if (cache.has(key)) {
-    return cache.get(key) ?? null;
-  }
-  const resolved = await resolveDocument(key, flintPath);
-  cache.set(key, resolved);
-  return resolved;
-}
-function getDisambiguatedExportName(flintPath, sourcePath, baseName) {
-  const relativePath = relative(flintPath, sourcePath);
-  const relativeDir = dirname(relativePath);
-  if (!relativeDir || relativeDir === ".") {
-    return baseName;
-  }
-  const dirLabel = relativeDir.split(sep).join(" - ");
-  return `${baseName} (${dirLabel})`;
-}
-async function scanExports(flintPath) {
-  const { readFlintToml: readFlintToml2 } = await import("./mesh-config-NTGFUNZL-BZ2GO3JY.js");
-  const config = await readFlintToml2(flintPath);
-  const declarations = config?.exports?.required;
-  if (!declarations || declarations.length === 0) {
-    return [];
-  }
-  return scanExportsFromConfig(flintPath, declarations);
-}
-async function scanExportsFromConfig(flintPath, declarations) {
-  const manifests = [];
-  for (const decl of declarations) {
-    const sourcePath = await resolveDocument(decl.file.replace(/\.md$/, ""), flintPath);
-    if (!sourcePath) continue;
-    try {
-      const content = await readFile(sourcePath, "utf-8");
-      const depth = decl.depth ?? 1;
-      const manifest = parseExportDocument(content, decl.name, sourcePath);
-      manifest.depth = depth;
-      manifests.push(manifest);
-    } catch {
-    }
-  }
-  return manifests;
-}
-async function scanExportEligible(flintPath) {
-  const meshDir = join(flintPath, "Mesh");
-  if (!await exists(meshDir)) return [];
-  const { readFlintToml: readFlintToml2 } = await import("./mesh-config-NTGFUNZL-BZ2GO3JY.js");
-  const config = await readFlintToml2(flintPath);
-  const declared = new Set(
-    (config?.exports?.required || []).map((d) => d.file.replace(/\.md$/, "").toLowerCase())
-  );
-  const eligible = [];
-  await findExportTaggedFiles(meshDir, flintPath, declared, eligible);
-  return eligible;
-}
-async function findExportTaggedFiles(dir, flintPath, declared, results) {
-  try {
-    const entries = await readdir(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = join(dir, entry.name);
-      if (entry.isDirectory()) {
-        await findExportTaggedFiles(fullPath, flintPath, declared, results);
-      } else if (entry.isFile() && entry.name.endsWith(".md")) {
-        try {
-          const content = await readFile(fullPath, "utf-8");
-          const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
-          if (!fmMatch || !fmMatch[1]) continue;
-          const hasExportTag = /["']#export["']/.test(fmMatch[1]);
-          if (!hasExportTag) continue;
-          const fileName = basename(fullPath, ".md");
-          if (declared.has(fileName.toLowerCase())) continue;
-          results.push({
-            filePath: fullPath,
-            fileName: entry.name,
-            name: fileName
-          });
-        } catch {
-        }
-      }
-    }
-  } 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 Export) ${manifest.name}`);
-  const meshOutputDir = join(outputDir, "Mesh");
-  const mediaOutputDir = join(outputDir, "Media");
-  if (await exists(outputDir)) {
-    await rm(outputDir, { recursive: true });
-  }
-  await mkdir(meshOutputDir, { recursive: true });
-  const config = await readFlintToml(flintPath);
-  const folderName = basename(flintPath);
-  const flintName = config?.flint?.name || folderName.replace(/^\(Mesh\)\s*/, "").replace(/^\(Flint\)\s*/, "");
-  const resolvedFiles = [];
-  const processedPaths = /* @__PURE__ */ new Set();
-  processedPaths.add(manifest.sourcePath);
-  const depth = manifest.depth;
-  if (depth === -1 || depth > 0) {
-    for (const docRef of manifest.files) {
-      const sourcePath = await resolveDocument(docRef, flintPath);
-      if (!sourcePath || processedPaths.has(sourcePath)) continue;
-      resolvedFiles.push({ sourcePath, docRef });
-      processedPaths.add(sourcePath);
-    }
-  }
-  const allReferencedFiles = /* @__PURE__ */ new Set();
-  const exportContent = await readFile(manifest.sourcePath, "utf-8");
-  await collectReferencedFiles(exportContent, flintPath, allReferencedFiles, new Set(processedPaths), depth, 0);
-  for (const { sourcePath } of resolvedFiles) {
-    const content = await readFile(sourcePath, "utf-8");
-    await collectReferencedFiles(content, flintPath, allReferencedFiles, new Set(processedPaths), depth, 1);
-  }
-  for (const refPath of allReferencedFiles) {
-    if (!processedPaths.has(refPath)) {
-      resolvedFiles.push({ sourcePath: refPath, docRef: basename(refPath, ".md") });
-      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") }))
-  ];
-  const baseNameCounts = /* @__PURE__ */ new Map();
-  for (const { baseName } of allExportFiles) {
-    baseNameCounts.set(baseName, (baseNameCounts.get(baseName) || 0) + 1);
-  }
-  const duplicateBaseNames = new Set(
-    Array.from(baseNameCounts.entries()).filter(([, count]) => count > 1).map(([name]) => name)
-  );
-  const exportNameBySourcePath = /* @__PURE__ */ new Map();
-  for (const { sourcePath, baseName } of allExportFiles) {
-    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, manifest.name, flintPath, exportNameBySourcePath, resolveCache);
-  const rootExportName = exportNameBySourcePath.get(manifest.sourcePath) || manifest.name;
-  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 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, manifest.name, flintPath, exportNameBySourcePath, resolveCache);
-    await writeFile(destPath, content);
-    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: `Mesh/${rootFileName}`,
-    builtAt: (/* @__PURE__ */ new Date()).toISOString(),
-    files: copiedFiles
-  };
-  await writeFile(
-    join(outputDir, "_manifest.json"),
-    JSON.stringify(manifestJson, null, 2)
-  );
-  return {
-    name: manifest.name,
-    outputPath: outputDir,
-    filesCopied
-  };
-}
-async function buildExportByName(flintPath, exportName) {
-  const manifests = await scanExports(flintPath);
-  const manifest = manifests.find((m) => m.name === exportName);
-  if (!manifest) {
-    return null;
-  }
-  return buildExport(manifest, flintPath);
-}
-async function cleanupStaleExports(flintPath) {
-  const exportsDir = join(flintPath, "Exports");
-  const removed = [];
-  if (!await exists(exportsDir)) {
-    return removed;
-  }
-  const manifests = await scanExports(flintPath);
-  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() && !validFolderNames.has(entry.name)) {
-      try {
-        await rm(join(exportsDir, entry.name), { recursive: true });
-        removed.push(entry.name);
-      } catch {
-      }
-    }
-  }
-  return removed;
-}
-async function buildAllExports(flintPath) {
-  const removed = await cleanupStaleExports(flintPath);
-  const manifests = await scanExports(flintPath);
-  const results = [];
-  for (const manifest of manifests) {
-    const result = await buildExport(manifest, flintPath);
-    results.push(result);
-  }
-  return { results, removed };
-}
-
-export {
-  resolveDocument,
-  scanExports,
-  scanExportEligible,
-  buildExport,
-  buildExportByName,
-  cleanupStaleExports,
-  buildAllExports
-};

package/dist/chunk-JNIJ5JV6.js

@@ -1,233 +0,0 @@
-// ../../packages/flint/dist/chunk-MAL7MTPY.js
-import { mkdir, readFile, writeFile } from "fs/promises";
-import { homedir } from "os";
-import { join, resolve } from "path";
-var REGISTRY_VERSION = 1;
-function getGlobalFlintDir() {
-  return join(homedir(), ".nuucognition", "flint");
-}
-function getFlintRegistryPath() {
-  return join(getGlobalFlintDir(), "registry.json");
-}
-async function ensureRegistryDir() {
-  await mkdir(getGlobalFlintDir(), { recursive: true });
-}
-function createEmptyRegistry() {
-  return {
-    version: REGISTRY_VERSION,
-    flints: []
-  };
-}
-async function getFlintRegistry() {
-  try {
-    const content = await readFile(getFlintRegistryPath(), "utf-8");
-    const registry = JSON.parse(content);
-    return registry.flints;
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return [];
-    }
-    throw error;
-  }
-}
-async function saveRegistry(registry) {
-  await ensureRegistryDir();
-  await writeFile(getFlintRegistryPath(), JSON.stringify(registry, null, 2));
-}
-async function registerFlint(entry) {
-  const normalizedEntry = { ...entry, path: resolve(entry.path) };
-  const flints = await getFlintRegistry();
-  const existing = flints.find((f) => f.path === normalizedEntry.path);
-  if (existing) {
-    throw new Error(`Flint already registered at path: ${entry.path}`);
-  }
-  flints.push(normalizedEntry);
-  await saveRegistry({ version: REGISTRY_VERSION, flints });
-}
-async function unregisterFlint(path) {
-  const resolvedPath = resolve(path);
-  const flints = await getFlintRegistry();
-  const filtered = flints.filter((f) => f.path !== resolvedPath);
-  if (filtered.length === flints.length) {
-    throw new Error(`Flint not found at path: ${path}`);
-  }
-  await saveRegistry({ version: REGISTRY_VERSION, flints: filtered });
-}
-async function findFlintByPath(path) {
-  const resolvedPath = resolve(path);
-  const flints = await getFlintRegistry();
-  return flints.find((f) => f.path === resolvedPath) ?? null;
-}
-async function findFlintByName(name) {
-  const flints = await getFlintRegistry();
-  return flints.find((f) => f.name === name) ?? null;
-}
-async function isFlintNameTaken(name) {
-  const flints = await getFlintRegistry();
-  return flints.find((f) => f.name === name);
-}
-async function upsertFlintEntry(entry) {
-  const normalizedEntry = { ...entry, path: resolve(entry.path) };
-  const flints = await getFlintRegistry();
-  const indexByPath = flints.findIndex((f) => f.path === normalizedEntry.path);
-  if (indexByPath !== -1) {
-    flints[indexByPath] = normalizedEntry;
-  } else {
-    flints.push(normalizedEntry);
-  }
-  await saveRegistry({ version: REGISTRY_VERSION, flints });
-}
-async function updateFlintEntry(path, updates) {
-  const resolvedPath = resolve(path);
-  const flints = await getFlintRegistry();
-  const entry = flints.find((f) => f.path === resolvedPath);
-  if (!entry) {
-    throw new Error(`Flint not found at path: ${path}`);
-  }
-  Object.assign(entry, updates);
-  await saveRegistry({ version: REGISTRY_VERSION, flints });
-}
-async function isPathRegistered(path) {
-  const resolvedPath = resolve(path);
-  const flints = await getFlintRegistry();
-  return flints.some((f) => f.path === resolvedPath);
-}
-async function cleanRegistryFile() {
-  const result = {
-    entriesCleaned: 0,
-    invalidEntriesRemoved: 0,
-    modified: false,
-    details: []
-  };
-  let rawContent;
-  try {
-    rawContent = await readFile(getFlintRegistryPath(), "utf-8");
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return result;
-    }
-    throw error;
-  }
-  let registry;
-  try {
-    registry = JSON.parse(rawContent);
-  } catch {
-    result.details.push("Registry file was corrupted, creating fresh registry");
-    result.modified = true;
-    await saveRegistry(createEmptyRegistry());
-    return result;
-  }
-  if (!registry || typeof registry !== "object") {
-    result.details.push("Registry file had invalid structure, creating fresh registry");
-    result.modified = true;
-    await saveRegistry(createEmptyRegistry());
-    return result;
-  }
-  if (!Array.isArray(registry.flints)) {
-    registry.flints = [];
-    result.details.push("Registry was missing flints array");
-    result.modified = true;
-  }
-  const cleanedFlints = [];
-  const deprecatedFields = ["id", "created"];
-  for (const rawEntry of registry.flints) {
-    if (!rawEntry || typeof rawEntry !== "object") {
-      result.invalidEntriesRemoved++;
-      result.details.push("Removed invalid non-object entry");
-      result.modified = true;
-      continue;
-    }
-    const entry = rawEntry;
-    if (typeof entry.name !== "string" || typeof entry.path !== "string") {
-      result.invalidEntriesRemoved++;
-      result.details.push(`Removed invalid entry missing name or path`);
-      result.modified = true;
-      continue;
-    }
-    let hadDeprecatedFields = false;
-    for (const field of deprecatedFields) {
-      if (field in entry) {
-        delete entry[field];
-        hadDeprecatedFields = true;
-      }
-    }
-    if (hadDeprecatedFields) {
-      result.entriesCleaned++;
-      result.modified = true;
-    }
-    const cleanEntry = {
-      name: entry.name,
-      path: entry.path
-    };
-    if (entry.source === "local") {
-      cleanEntry.source = entry.source;
-    }
-    if (Array.isArray(entry.tags)) {
-      cleanEntry.tags = entry.tags.filter((t) => typeof t === "string");
-    }
-    if (typeof entry.description === "string") {
-      cleanEntry.description = entry.description;
-    }
-    if (Array.isArray(entry.exports)) {
-      cleanEntry.exports = entry.exports.filter((e) => typeof e === "string");
-    }
-    cleanedFlints.push(cleanEntry);
-  }
-  if (result.modified) {
-    await saveRegistry({ version: REGISTRY_VERSION, flints: cleanedFlints });
-    if (result.entriesCleaned > 0) {
-      result.details.push(`Removed deprecated fields from ${result.entriesCleaned} entries`);
-    }
-  }
-  return result;
-}
-async function registerFlintByPath(path, options) {
-  const { readFlintToml, hasFlintToml } = await import("./mesh-config-NTGFUNZL-BZ2GO3JY.js");
-  const isFlint = await hasFlintToml(path);
-  if (!isFlint) {
-    throw new Error(`Not a valid flint: ${path}
-Missing flint.toml`);
-  }
-  const toml = await readFlintToml(path);
-  if (!toml || !toml.flint?.name) {
-    throw new Error(`Invalid flint.toml at ${path}: missing flint.name`);
-  }
-  const name = toml.flint.name;
-  const existing = await findFlintByPath(path);
-  if (existing && !options?.force) {
-    throw new Error(`Already registered: "${existing.name}" at ${path}`);
-  }
-  const nameTaken = await isFlintNameTaken(name);
-  if (nameTaken && resolve(nameTaken.path) !== resolve(path)) {
-    throw new Error(`Name "${name}" is already taken by a flint at ${nameTaken.path}`);
-  }
-  const entry = {
-    name,
-    path,
-    source: "local"
-  };
-  if (toml.flint.tags && toml.flint.tags.length > 0) {
-    entry.tags = toml.flint.tags;
-  }
-  if (toml.flint.description) {
-    entry.description = toml.flint.description;
-  }
-  await upsertFlintEntry(entry);
-  return entry;
-}
-
-export {
-  getGlobalFlintDir,
-  getFlintRegistryPath,
-  getFlintRegistry,
-  registerFlint,
-  unregisterFlint,
-  findFlintByPath,
-  findFlintByName,
-  isFlintNameTaken,
-  upsertFlintEntry,
-  updateFlintEntry,
-  isPathRegistered,
-  cleanRegistryFile,
-  registerFlintByPath
-};