npm - @bendyline/gezel-catalog - Versions diffs - 0.1.0 - Mend

@bendyline/gezel-catalog 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/dist/index.js ADDED Viewed

@@ -0,0 +1,2496 @@
+// src/service.ts
+import { join as join4 } from "path";
+// src/builtin-toolset-icons.ts
+var SVG_ATTRS = 'xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"';
+var BUILTIN_TOOLSET_ICONS = {
+  // Constellation of nodes — recall as a network of remembered points.
+  memory: `<svg ${SVG_ATTRS}><circle cx="6" cy="8" r="1.5"/><circle cx="12" cy="5" r="1.5"/><circle cx="18" cy="8" r="1.5"/><circle cx="9" cy="14" r="1.5"/><circle cx="15" cy="14" r="1.5"/><circle cx="12" cy="20" r="1.5"/><path d="M6 8l3 6M12 5l-3 9M12 5l3 9M18 8l-3 6M9 14l3 6M15 14l-3 6"/></svg>`,
+  // Folder + magnifying glass — read/inspect, no mutation.
+  "workspace-fs-read": `<svg ${SVG_ATTRS}><path d="M3 7a2 2 0 0 1 2-2h4l2 2.5h8a2 2 0 0 1 2 2V17a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V7z"/><circle cx="14" cy="13" r="2"/><path d="M15.5 14.5L17 16"/></svg>`,
+  // Folder + pencil — mutate.
+  "workspace-fs-write": `<svg ${SVG_ATTRS}><path d="M3 7a2 2 0 0 1 2-2h4l2 2.5h8a2 2 0 0 1 2 2V17a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V7z"/><path d="M11 14l4-4 2 2-4 4h-2v-2z"/></svg>`,
+  // Code braces + locator dot — navigate symbols.
+  "code-intel": `<svg ${SVG_ATTRS}><path d="M8 4C6 4 6 8 4 8c2 0 2 4 4 4M16 4c2 0 2 4 4 4-2 0-2 4-4 4"/><circle cx="12" cy="17" r="3"/><path d="M14.5 19.5L18 22"/></svg>`,
+  // Shield + magnifier — inspect the codebase for weaknesses.
+  "security-intel": `<svg ${SVG_ATTRS}><path d="M12 3l7 3v5c0 4.5-3 7.5-7 9-4-1.5-7-4.5-7-9V6l7-3z"/><circle cx="11" cy="10" r="2.5"/><path d="M12.8 11.8L15 14"/></svg>`,
+  // Document + magnifier — search/read converted docs.
+  "doc-intel": `<svg ${SVG_ATTRS}><path d="M13 3H7a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h7"/><path d="M13 3v5h5"/><circle cx="16" cy="15" r="3"/><path d="M18 17l2.5 2.5"/></svg>`,
+  // Picture frame + mountains — image library.
+  "image-intel": `<svg ${SVG_ATTRS}><rect x="3" y="5" width="18" height="14" rx="2"/><circle cx="8.5" cy="10" r="1.5"/><path d="M21 16l-5-5-4 4-2-2-7 7"/></svg>`,
+  // Person node linked to mentions — cross-file entities.
+  "entity-intel": `<svg ${SVG_ATTRS}><circle cx="7" cy="8" r="2.5"/><path d="M3 19a4 4 0 0 1 8 0"/><circle cx="18" cy="6" r="1.5"/><circle cx="18" cy="12" r="1.5"/><circle cx="18" cy="18" r="1.5"/><path d="M9.5 8H16M11 17h5.5M12 12h4.5"/></svg>`,
+  // Stacked rectangles + a zip-pull notch.
+  archives: `<svg ${SVG_ATTRS}><rect x="3" y="6" width="18" height="5" rx="1"/><rect x="3" y="13" width="18" height="6" rx="1"/><path d="M10 16h4"/></svg>`,
+  // Page with corner fold + body lines.
+  documents: `<svg ${SVG_ATTRS}><path d="M14 3H6a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V9l-6-6z"/><path d="M14 3v6h6"/><path d="M8 13h8M8 17h6"/></svg>`,
+  // Cube/package — outputs you produce and bundle.
+  artifacts: `<svg ${SVG_ATTRS}><path d="M21 8L12 3 3 8v8l9 5 9-5V8z"/><path d="M3 8l9 5 9-5"/><path d="M12 13v8"/></svg>`,
+  // Checkbox + list lines.
+  tasks: `<svg ${SVG_ATTRS}><rect x="3" y="4" width="6" height="6" rx="1"/><path d="M4.5 7L6 8.5 8 5.5"/><rect x="3" y="14" width="6" height="6" rx="1"/><path d="M12 7h9M12 17h9"/></svg>`,
+  // Three connected nodes — a small team.
+  "team-management": `<svg ${SVG_ATTRS}><circle cx="12" cy="6" r="2.5"/><circle cx="6" cy="17" r="2.5"/><circle cx="18" cy="17" r="2.5"/><path d="M10.5 8L7.5 14.5M13.5 8l3 6.5M8.5 17h7"/></svg>`,
+  // Terminal-like frame with a prompt arrow.
+  "code-execution": `<svg ${SVG_ATTRS}><rect x="3" y="4" width="18" height="16" rx="2"/><path d="M7 10l3 2-3 2M13 14h4"/></svg>`,
+  // Browser window + a tiny pointer.
+  "browser-automation": `<svg ${SVG_ATTRS}><rect x="3" y="4" width="18" height="14" rx="2"/><path d="M3 9h18"/><circle cx="6" cy="6.5" r="0.5" fill="currentColor"/><circle cx="8" cy="6.5" r="0.5" fill="currentColor"/><circle cx="10" cy="6.5" r="0.5" fill="currentColor"/><path d="M11 13l3 6 1-3 3-1z"/></svg>`,
+  // Branch graph — two nodes on a trunk + a side node.
+  git: `<svg ${SVG_ATTRS}><circle cx="6" cy="6" r="2"/><circle cx="6" cy="18" r="2"/><circle cx="18" cy="12" r="2"/><path d="M6 8v8"/><path d="M6 12c0-3 3-6 6-6 2 0 4 2 4 4"/></svg>`,
+  // Globe with meridian + equator.
+  web: `<svg ${SVG_ATTRS}><circle cx="12" cy="12" r="9"/><ellipse cx="12" cy="12" rx="4" ry="9"/><path d="M3 12h18"/></svg>`,
+  // Picture frame — sun + mountain.
+  images: `<svg ${SVG_ATTRS}><rect x="3" y="4" width="18" height="16" rx="2"/><circle cx="8.5" cy="9" r="1.5"/><path d="M4 18l5-5 3 3 4-4 4 4"/></svg>`,
+  // Clock + back arrow — looking back over time.
+  history: `<svg ${SVG_ATTRS}><path d="M3 12a9 9 0 1 0 3-6.7"/><path d="M3 4v5h5"/><path d="M12 8v4l3 2"/></svg>`,
+  handboek: `<svg ${SVG_ATTRS}><path d="M4 19.5A2.5 2.5 0 0 1 6.5 17H20"/><path d="M6.5 2H20v20H6.5A2.5 2.5 0 0 1 4 19.5v-15A2.5 2.5 0 0 1 6.5 2z"/><path d="M10 2v7l2.5-1.8L15 9V2"/></svg>`,
+  // Speech bubble with a question mark.
+  interaction: `<svg ${SVG_ATTRS}><path d="M21 12a8 8 0 0 1-12.5 6.5L3 20l1.5-5.5A8 8 0 1 1 21 12z"/><path d="M9.5 9.5a2.5 2.5 0 0 1 5 0c0 1.5-2.5 2-2.5 3.5"/><circle cx="12" cy="16" r="0.6" fill="currentColor"/></svg>`
+};
+// src/builtin-toolsets.ts
+var BUILTIN_VERSION = "1.0.0";
+var BUILTIN_RELEASED_AT = "2026-04-25T00:00:00Z";
+var BUILTIN_TOOLSETS = [
+  {
+    id: "memory",
+    name: "Memory",
+    description: "Persistent notes a gezel can search, recall, and write back. Backed by the gezel's per-day memory files plus a vector index.",
+    tools: ["search_memory", "save_memory", "list_memories"]
+  },
+  {
+    id: "workspace-fs-read",
+    name: "Workspace File Reading",
+    description: "Read, list, search, and diff files in the project workspace. Mirrors Node's `fs` reads plus content/glob search. Diagnose-only \u2014 pair with `workspace-fs-write` to actually mutate.",
+    tools: [
+      "list_dir",
+      "read_file",
+      "read_files",
+      "stat",
+      "validate",
+      "grep_files",
+      "find_files",
+      "diff_files"
+    ]
+  },
+  {
+    id: "code-intel",
+    name: "Code Intelligence",
+    description: "Navigate and understand the codebase via the workspace index instead of reading whole files: outline a file's symbols, jump to a definition, read just one symbol's source, find usages, and map the repo. Every result carries line ranges so the model reads only the span it needs \u2014 a big context saver for small/medium local models.",
+    tools: [
+      "outline_file",
+      "find_symbol",
+      "read_symbol",
+      "find_references",
+      "map_repo",
+      "search_code",
+      "file_review",
+      "list_file_issues"
+    ]
+  },
+  {
+    id: "security-intel",
+    name: "Security Intelligence",
+    description: "Static security analysis pushed into the index and reused as tools: run a whole-repo scan (dependency inventory + opportunistic semgrep/osv-scanner/gitleaks), get a posture overview with candidate systemic themes, list findings by severity/category, map the attack surface (entry points, routes, auth boundaries, secret touchpoints), inventory dependencies with advisories, and trace import-graph reachability for source\u2192sink flows. The substrate for a deep, systemic security review.",
+    tools: [
+      "security_scan",
+      "security_overview",
+      "scan_findings",
+      "map_attack_surface",
+      "list_dependencies",
+      "trace_taint"
+    ]
+  },
+  {
+    id: "doc-intel",
+    name: "Document Intelligence",
+    description: "Search and read office documents (Word, PDF, PowerPoint, Excel) that gezel has converted to markdown in the index. Keyword-search across a document corpus and read any document as scannable markdown on demand \u2014 no need to wrestle with binary files.",
+    tools: ["search_docs", "read_doc_as_markdown"]
+  },
+  {
+    id: "image-intel",
+    name: "Image Intelligence",
+    description: "Navigate an indexed image library: search images by filename/caption/dimensions, summarize a folder of images for review or reorganizing, and find visually similar images. Built for folder-operations over large image collections.",
+    tools: ["search_images", "find_similar_images", "describe_folder"]
+  },
+  {
+    id: "entity-intel",
+    name: "Entity Intelligence",
+    description: 'Cross-file entities the index resolved from structured metadata \u2014 email senders, document parties \u2014 and where each appears. Ask "every email from X" or "every contract naming Y" and get a dated, cross-file view.',
+    tools: ["find_entity", "list_entity_mentions"]
+  },
+  {
+    id: "workspace-fs-write",
+    name: "Workspace File Writing",
+    description: "Create, write, surgically edit, rename, and delete files in the project workspace. Always paired with `workspace-fs-read` for the roles that build (developer, designer, reviewer); split out so coordinator roles (voorman) can investigate without being tempted to do the building themselves.",
+    tools: [
+      "write_file",
+      "append_to_file",
+      "replace_in_file",
+      "replace_lines",
+      "apply_patch",
+      "insert_at_marker",
+      "copy_artifact_to_workspace",
+      "make_dir",
+      "delete_path",
+      "rename"
+    ]
+  },
+  {
+    id: "archives",
+    name: "Archive Tools",
+    description: "List and extract zip / tar archives in the workspace.",
+    tools: ["list_archive", "extract_archive"]
+  },
+  {
+    id: "documents",
+    name: "Documents",
+    description: "Cross-project shared library \u2014 mission docs, guidelines, and any markdown the user wants every gezel to be able to find.",
+    tools: [
+      "list_documents",
+      "read_document",
+      "write_document",
+      "delete_document",
+      "search_documents"
+    ]
+  },
+  {
+    id: "artifacts",
+    name: "Project Artifacts",
+    description: "Project-scoped read-write outputs (reports, scratch files, scripts a gezel produces, and large outputs auto-saved by tools that exceed the inline cap).",
+    tools: ["list_artifacts", "read_artifact", "write_artifact", "grep_artifact"]
+  },
+  {
+    id: "tasks",
+    name: "Task Management",
+    description: "Create, assign, advance, and report on tasks. The full task surface including notes, steps, and child instance spawning.",
+    tools: [
+      "list_tasks",
+      "get_task",
+      "list_craftbooks",
+      "suggest_craftbook",
+      "import_skill",
+      "create_task",
+      "start_plan",
+      "invoke_craftbook",
+      "update_task",
+      "set_outcomes",
+      "verify_outcome",
+      "add_verification_step",
+      "set_task_status",
+      "activate_task",
+      "list_task_children",
+      "add_task_step",
+      "advance_task_step",
+      "assign_task",
+      "read_task_notes",
+      "write_task_note",
+      "spawn_task_instances"
+    ]
+  },
+  {
+    id: "craftbooks",
+    name: "Craftbook Authoring",
+    description: "Read and write a whole craftbook, add/remove/reorder steps, set the entry step, and attach focused deliverable gates. `craftbook_write` is the atomic create/replace path; the large surgical update schema is loaded only inside an explicit craftbook-editing session. The unified surface targets either a task's embedded craftbook or a standalone local template.",
+    tools: [
+      "craftbook_read",
+      "craftbook_write",
+      "craftbook_add_step",
+      "set_step_deliverable",
+      "craftbook_remove_step",
+      "craftbook_reorder_steps",
+      "craftbook_set_entry",
+      "craftbook_update",
+      "export_task_craftbook"
+    ]
+  },
+  {
+    id: "tasks-readonly",
+    name: "Task Visibility",
+    description: 'Read-only task surface for delegation roles \u2014 list tasks, inspect a specific task, read its notes. The "ping projects to see status" subset, without any of the mutation tools (create, update, assign, status, advance) that belong to the assignee or voorman. Pair with `team-management` for a complete delegation surface.',
+    tools: ["list_tasks", "get_task", "list_craftbooks", "suggest_craftbook", "read_task_notes"]
+  },
+  {
+    id: "craftbook-launch",
+    name: "Craftbook Launcher",
+    description: "Procedure-first task launch surface for coordinators: rank applicable craftbooks and invoke a selected recipe after its required setup is ready.",
+    tools: ["list_craftbooks", "suggest_craftbook", "invoke_craftbook"]
+  },
+  {
+    id: "team-management",
+    name: "Team & Project Management",
+    description: "Spin up other gezels, message them, browse the gilde of templates, and manage projects + project membership. The Meester surface.",
+    tools: [
+      "list_gezels",
+      "create_gezel",
+      "update_gezel",
+      "ensure_gezel",
+      "message_gezel",
+      "list_projects",
+      "start_project",
+      "fetch_repo",
+      "fetch_diff",
+      "update_project",
+      "list_gilde",
+      "list_project_types",
+      "apply_project_type",
+      "start_project_from_type",
+      "export_project_type",
+      "import_project_type",
+      "list_project_gezels",
+      "add_gezel_to_project",
+      "remove_gezel_from_project",
+      "list_suggested_work",
+      "enable_suggested_work",
+      "disable_suggested_work"
+    ]
+  },
+  {
+    id: "audio",
+    name: "Audio",
+    description: "Speech-to-text (`transcribe_audio`) and text-to-speech (`synthesize_speech`). Heavy \u2014 only useful for gezels that do voice work.",
+    tools: ["transcribe_audio", "synthesize_speech"]
+  },
+  {
+    id: "code-execution",
+    name: "Code Execution",
+    description: "Run Node scripts, npm install, run package scripts, invoke npx. Sandboxed to the project workspace.",
+    tools: [
+      "run_nodejs_script",
+      "derive_file",
+      "npm_install",
+      "run_npx",
+      "run_installed_script",
+      "run_package_script",
+      "list_packages",
+      "list_package_scripts",
+      "list_scripts",
+      "get_script_run"
+    ]
+  },
+  {
+    id: "browser-automation",
+    name: "Browser Automation",
+    description: "Drive a headless Chromium via Playwright scripts. Heavy \u2014 only useful for gezels that genuinely need browser work.",
+    tools: ["run_playwright_script"]
+  },
+  {
+    id: "git",
+    name: "Git & GitHub",
+    description: "Run read-only git commands inside the project workspace, inspect GitHub pull requests, post review comments, open PRs, and check workflow status for linked project repositories.",
+    tools: [
+      "run_git",
+      "github_pr_list",
+      "github_pr_view",
+      "github_pr_files",
+      "github_pr_diff",
+      "github_pr_comments",
+      "github_pr_comment",
+      "github_pr_create",
+      "github_workflow_runs",
+      "github_check_status"
+    ]
+  },
+  {
+    id: "web",
+    name: "Web Access",
+    description: "Search the web (when a keyed backend like Brave is configured) or Wikipedia, fetch URL contents, and find interactive elements on a browser-controlled page (after a Playwright navigate / click / type). `web_search` only registers when a real keyed backend is configured; `wikipedia_search` only registers for non-cloud models (cloud models already have Wikipedia in training).",
+    tools: ["web_search", "wikipedia_search", "fetch_url", "browser_find_page_element"]
+  },
+  {
+    id: "images",
+    name: "Image Tools",
+    description: "Render charts/diagrams, read and describe existing images, and generate new images via the configured image model.",
+    tools: [
+      "render_image",
+      "read_image_as_base64",
+      "generate_image",
+      "describe_image",
+      "read_image_metadata"
+    ]
+  },
+  {
+    id: "videos",
+    name: "Video Tools",
+    description: "Generate short video clips via the configured local video model (LTX / WAN).",
+    tools: ["generate_video"]
+  },
+  {
+    id: "history",
+    name: "Audit & History",
+    description: "Search the install-wide audit log of who did what and when, plus past chat transcripts.",
+    tools: ["search_history", "search_sessions"]
+  },
+  {
+    id: "handboek",
+    name: "Handboek",
+    description: "Consult gezel's built-in documentation for meta questions about gezel itself \u2014 roles, craftbooks, projects, memory, models, setup. In every role's kit so a gezel answers 'how does gezel work?' from the real docs instead of guessing.",
+    tools: ["how_do_i"]
+  },
+  {
+    id: "interaction",
+    name: "User Interaction",
+    description: "Pose a structured question mid-turn \u2014 to the user (`ask_user_question`), to a specific gezel (`ask_gezel`), or to a role-shaped specialist (`ask_specialist`) \u2014 instead of guessing.",
+    tools: ["ask_user_question", "ask_gezel", "ask_specialist"]
+  },
+  {
+    id: "role-delegation",
+    name: "Role Delegation (downward)",
+    description: "Hand work to a teammate by ROLE instead of by name: `delegate_<role>` (async hand-off) and `consult_<role>` (sync question) for each doer role \u2014 developer, designer, reviewer, planner, researcher, builder, writer, image-generator. The target lives in the tool identity (no free-text `gezel`/`role` argument), which small/medium local models route far more reliably. Each resolves to the project gezel of that role, creating one on demand. Orchestrator (meester/voorman) surface; gated by the `tools.gezels-as-roles` behavior.",
+    tools: [
+      "delegate_developer",
+      "consult_developer",
+      "delegate_designer",
+      "consult_designer",
+      "delegate_reviewer",
+      "consult_reviewer",
+      "delegate_planner",
+      "consult_planner",
+      "delegate_researcher",
+      "consult_researcher",
+      "delegate_builder",
+      "consult_builder",
+      "delegate_writer",
+      "consult_writer",
+      "delegate_image_generator",
+      "consult_image_generator"
+    ]
+  },
+  {
+    id: "role-delegation-escalation",
+    name: "Role Delegation (escalation)",
+    description: "Reach a coordination role by ROLE: `delegate_voorman` / `consult_voorman` and `delegate_meester` / `consult_meester`. The escalation counterpart to `role-delegation` \u2014 lets a specialist hand work or questions UP to their voorman or the meester. Gated by the `tools.gezels-as-roles` behavior.",
+    tools: ["delegate_voorman", "consult_voorman", "delegate_meester", "consult_meester"]
+  }
+];
+var BUILTIN_BY_ID = new Map(BUILTIN_TOOLSETS.map((g) => [g.id, g]));
+function getBuiltinToolset(id) {
+  return BUILTIN_BY_ID.get(id);
+}
+var BUILTIN_TOOL_TO_GROUP = new Map(
+  BUILTIN_TOOLSETS.flatMap((g) => g.tools.map((toolName) => [toolName, g]))
+);
+function builtinCatalogId(groupId) {
+  return `builtin.${groupId}`;
+}
+var SOURCE_ID = "builtin";
+function manifestForGroup(g) {
+  return {
+    schemaVersion: 1,
+    kind: "toolset",
+    id: builtinCatalogId(g.id),
+    name: g.name,
+    description: g.description,
+    tags: ["built-in"],
+    maintainer: { name: "Gezel" },
+    version: BUILTIN_VERSION,
+    releasedAt: BUILTIN_RELEASED_AT,
+    logo: "icon.svg",
+    tools: g.tools.map((name) => ({ name, description: "" })),
+    runtime: { kind: "builtin", toolsetGroupId: g.id },
+    config: [],
+    availableVersions: [BUILTIN_VERSION]
+  };
+}
+var BuiltinToolsetsSource = class {
+  id = SOURCE_ID;
+  label = "Built-in";
+  async listKinds() {
+    return ["toolset"];
+  }
+  async list(kind) {
+    if (kind !== "toolset") return [];
+    return BUILTIN_TOOLSETS.map((g) => {
+      const manifest = manifestForGroup(g);
+      return {
+        sourceId: this.id,
+        kind,
+        manifest,
+        ...BUILTIN_TOOLSET_ICONS[g.id] ? { iconSvg: BUILTIN_TOOLSET_ICONS[g.id] } : {}
+      };
+    });
+  }
+  async get(kind, id, version) {
+    if (kind !== "toolset") return null;
+    if (version !== void 0 && version !== BUILTIN_VERSION) return null;
+    const groupId = id.startsWith("builtin.") ? id.slice("builtin.".length) : null;
+    if (!groupId) return null;
+    const g = BUILTIN_BY_ID.get(groupId);
+    if (!g) return null;
+    const manifest = manifestForGroup(g);
+    return {
+      sourceId: this.id,
+      kind,
+      manifest,
+      ...BUILTIN_TOOLSET_ICONS[g.id] ? { iconSvg: BUILTIN_TOOLSET_ICONS[g.id] } : {}
+    };
+  }
+  async listVersions(kind, id) {
+    if (kind !== "toolset") return [];
+    const groupId = id.startsWith("builtin.") ? id.slice("builtin.".length) : null;
+    if (!groupId || !BUILTIN_BY_ID.has(groupId)) return [];
+    return [{ version: BUILTIN_VERSION, releasedAt: BUILTIN_RELEASED_AT, yanked: false }];
+  }
+  async readItemFile(kind, id, relPath, _version) {
+    if (kind !== "toolset" || relPath !== "icon.svg") return null;
+    if (!id.startsWith("builtin.")) return null;
+    const groupId = id.slice("builtin.".length);
+    const svg = BUILTIN_TOOLSET_ICONS[groupId];
+    if (!svg) return null;
+    return Buffer.from(svg, "utf8");
+  }
+};
+// src/community-source.ts
+import { join as join3 } from "path";
+// src/gilde-data.ts
+import { createRequire } from "module";
+import { dirname, join } from "path";
+function gildePackageRoot() {
+  const require2 = createRequire(import.meta.url);
+  return dirname(require2.resolve("@bendyline/gilde/package.json"));
+}
+function gildeDataDir() {
+  const override = process.env.GEZEL_GILDE_DATA_DIR?.trim();
+  if (override) return override;
+  return join(gildePackageRoot(), "data");
+}
+// src/source.ts
+import { readFile, readdir } from "fs/promises";
+import { join as join2 } from "path";
+import {
+  CRAFTBOOK_TEST_FILENAME,
+  CatalogItemIdentitySchema,
+  ChatModelVersionManifestSchema,
+  ConnectorTypeVersionManifestSchema,
+  CraftbookTemplateVersionManifestSchema,
+  GEZEL_VERSION,
+  GezelTemplateVersionManifestSchema,
+  ImageModelVersionManifestSchema,
+  ProjectTypeVersionManifestSchema,
+  ToolsetVersionManifestSchema,
+  VideoModelVersionManifestSchema,
+  compareSemver,
+  expandStepDeliverables,
+  formatCraftbookDocErrors,
+  isSemver,
+  maxMinGezelVersion,
+  parseCraftbookDoc,
+  parseCraftbookTestSpec,
+  satisfiesMinGezelVersion
+} from "@bendyline/gezel";
+var KINDS = [
+  "toolset",
+  "gezel-template",
+  "craftbook-template",
+  "project-type",
+  "connector-type",
+  "chat-model",
+  "image-model",
+  "video-model"
+];
+var KIND_DIR = {
+  toolset: "toolsets",
+  "gezel-template": "gezel-templates",
+  "craftbook-template": "craftbook-templates",
+  "project-type": "project-types",
+  "connector-type": "connector-types",
+  "chat-model": "chat-models",
+  "image-model": "image-models",
+  "video-model": "video-models"
+};
+function shardPrefix(id) {
+  return id.slice(0, 2).toLowerCase();
+}
+function isAbsentDir(err) {
+  const code = err?.code;
+  return code === "ENOENT" || code === "ENOTDIR";
+}
+function defaultBundledDataDir() {
+  return gildeDataDir();
+}
+var BundledSource = class {
+  id;
+  label;
+  rootProvider;
+  useIndex;
+  gezelVersion;
+  constructor(options = {}) {
+    const opts = typeof options === "string" ? { dataDir: options } : options;
+    const dataDir = opts.dataDir;
+    if (typeof dataDir === "function") {
+      this.rootProvider = dataDir;
+    } else {
+      const fixed = dataDir ?? defaultBundledDataDir();
+      this.rootProvider = () => fixed;
+    }
+    this.id = opts.id ?? "bundled";
+    this.label = opts.label ?? "Bundled";
+    this.useIndex = !opts.noIndex;
+    this.gezelVersion = opts.gezelVersion ?? GEZEL_VERSION;
+  }
+  get root() {
+    return this.rootProvider();
+  }
+  /** True when this build satisfies a content `minGezelVersion` floor. */
+  floorSatisfied(floor) {
+    return satisfiesMinGezelVersion(floor, this.gezelVersion);
+  }
+  async listKinds() {
+    return KINDS;
+  }
+  async list(kind) {
+    if (this.useIndex) {
+      const indexed = await this.listFromIndex(kind);
+      if (indexed) return indexed;
+    }
+    return this.listFromDisk(kind);
+  }
+  /**
+   * Fast-path: when `{kindDir}/index.json` is present, load every
+   * summary from that one file instead of walking ~3,800 per-item
+   * folders. The index is generated by gilde `tools/build-index.mjs` and
+   * embeds the same `CatalogItemManifest` shape this source produces
+   * via the slow walk, plus a derived `category` for toolsets.
+   *
+   * Returns null when the index is missing or unreadable; callers fall
+   * back to `listFromDisk()`. Per-entry parse failures are skipped.
+   */
+  async listFromIndex(kind) {
+    const indexPath = join2(this.root, KIND_DIR[kind], "index.json");
+    let raw;
+    try {
+      raw = await readFile(indexPath, "utf8");
+    } catch {
+      return null;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (err) {
+      console.warn(`[catalog] failed to parse ${indexPath}:`, err);
+      return null;
+    }
+    const obj = parsed;
+    if (obj.kind !== kind || !Array.isArray(obj.entries)) {
+      console.warn(`[catalog] ${indexPath}: kind/entries mismatch \u2014 falling back to disk walk`);
+      return null;
+    }
+    const items = [];
+    for (const raw2 of obj.entries) {
+      const e = raw2;
+      if (!e.manifest || typeof e.manifest !== "object") continue;
+      let manifest = e.manifest;
+      if (!this.floorSatisfied(manifest.minGezelVersion)) {
+        const reResolved = await this.loadResolvedManifest(kind, manifest.id);
+        if (!reResolved) continue;
+        manifest = reResolved;
+      }
+      const item = {
+        sourceId: this.id,
+        kind,
+        manifest,
+        ...typeof e.iconSvg === "string" ? { iconSvg: e.iconSvg } : {}
+      };
+      const logo = this.logoUrlFor(kind, manifest.id, manifest);
+      if (logo) item.logoUrl = logo;
+      items.push(item);
+    }
+    items.sort((a, b) => a.manifest.name.localeCompare(b.manifest.name));
+    return items;
+  }
+  async listFromDisk(kind) {
+    const base = join2(this.root, KIND_DIR[kind]);
+    let shards = [];
+    try {
+      shards = await readdir(base);
+    } catch (err) {
+      if (isAbsentDir(err)) return [];
+      throw err;
+    }
+    const items = [];
+    for (const shard of shards) {
+      if (shard === "index.json") continue;
+      let ids = [];
+      try {
+        ids = await readdir(join2(base, shard));
+      } catch (err) {
+        if (isAbsentDir(err)) continue;
+        throw err;
+      }
+      for (const id of ids) {
+        const manifest = await this.loadResolvedManifest(kind, id);
+        if (!manifest) continue;
+        items.push({
+          sourceId: this.id,
+          kind,
+          manifest,
+          logoUrl: this.logoUrlFor(kind, id, manifest)
+        });
+      }
+    }
+    items.sort((a, b) => a.manifest.name.localeCompare(b.manifest.name));
+    return items;
+  }
+  async get(kind, id, version) {
+    const manifest = await this.loadResolvedManifest(kind, id, version);
+    if (!manifest) return null;
+    const itemDir = this.itemDir(kind, id);
+    const versionDir = join2(itemDir, "versions", manifest.version);
+    const readme = await this.readOptional(join2(itemDir, "readme.md"));
+    let about;
+    if ((manifest.kind === "gezel-template" || manifest.kind === "craftbook-template") && manifest.about) {
+      about = await this.readOptional(join2(versionDir, manifest.about)) ?? void 0;
+    } else if (manifest.kind === "craftbook-template") {
+      about = (await this.readCraftbookDoc(versionDir))?.description;
+    } else if (manifest.kind === "project-type" && manifest.aboutTemplate) {
+      about = await this.readOptional(join2(versionDir, manifest.aboutTemplate)) ?? void 0;
+    }
+    return {
+      sourceId: this.id,
+      kind,
+      manifest,
+      logoUrl: this.logoUrlFor(kind, id, manifest),
+      ...readme ? { readme } : {},
+      ...about ? { about } : {}
+    };
+  }
+  async listVersions(kind, id) {
+    const identity = await this.loadIdentity(kind, id);
+    if (!identity) return [];
+    const versions = await this.discoverVersionFolders(kind, id);
+    if (versions.length === 0) return [];
+    const yanked = new Set(identity.yankedVersions);
+    const minSupported = identity.minSupportedVersion;
+    const out = [];
+    for (const v of versions) {
+      if (minSupported && safeCompare(v.version, minSupported) < 0) continue;
+      if (!this.floorSatisfied(v.minGezelVersion)) continue;
+      out.push({
+        version: v.version,
+        releasedAt: v.releasedAt,
+        yanked: yanked.has(v.version)
+      });
+    }
+    out.sort((a, b) => safeCompare(b.version, a.version));
+    return out;
+  }
+  async readItemFile(kind, id, relPath, version) {
+    if (relPath.includes("..") || relPath.startsWith("/")) return null;
+    const itemDir = this.itemDir(kind, id);
+    if (version) {
+      if (!isSemver(version)) return null;
+      const versioned = join2(itemDir, "versions", version, relPath);
+      try {
+        return await readFile(versioned);
+      } catch {
+        if (kind === "craftbook-template") {
+          const scriptName = /^scripts\/(.+)\.ts$/.exec(relPath)?.[1];
+          if (scriptName) {
+            const doc = await this.readCraftbookDoc(join2(itemDir, "versions", version));
+            const source = doc?.scripts?.[scriptName];
+            if (source !== void 0) return Buffer.from(source, "utf8");
+          }
+        }
+      }
+    }
+    try {
+      return await readFile(join2(itemDir, relPath));
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Every file under an item's folder, as item-relative paths (e.g.
+   * `manifest.json`, `versions/1.0.0/pages/gallery/index.html`), sorted. Used
+   * by the `.gzl` exporter to pack an item verbatim — pages, seeds, and all
+   * assets, not just the ones the manifest names. Read each back with
+   * `readItemFile(kind, id, relPath)` (no version → item-relative). Empty when
+   * the item folder is missing.
+   */
+  async listItemFiles(kind, id) {
+    const dir = this.itemDir(kind, id);
+    let entries;
+    try {
+      entries = await readdir(dir, { recursive: true, withFileTypes: true });
+    } catch {
+      return [];
+    }
+    const out = [];
+    for (const e of entries) {
+      if (!e.isFile()) continue;
+      const parent = e.parentPath ?? e.path ?? dir;
+      const abs = join2(parent, e.name);
+      const rel = abs.startsWith(dir) ? abs.slice(dir.length).replace(/^[/\\]+/, "") : e.name;
+      out.push(rel.split("\\").join("/"));
+    }
+    out.sort();
+    return out;
+  }
+  /** Parse a version folder's `craftbook.json`, or null when absent/invalid. */
+  async readCraftbookDoc(versionDir) {
+    const text = await this.readOptional(join2(versionDir, "craftbook.json"));
+    if (text === null) return null;
+    const parsed = parseCraftbookDoc(text, "json");
+    return parsed.ok ? parsed.doc : null;
+  }
+  /**
+   * A craftbook's eval descriptor (`versions/<v>/test.json`), tolerant-
+   * parsed so a spec written by a newer author still loads. Resolution
+   * mirrors `get`: no `version` → the latest non-yanked semver. Null on
+   * missing book/version/sidecar or an unparseable spec (CI's strict
+   * guard is where invalid specs get surfaced loudly — runtime readers
+   * degrade quietly).
+   */
+  async getCraftbookTestSpec(id, version) {
+    const identity = await this.loadIdentity("craftbook-template", id);
+    if (!identity) return null;
+    const picked = await this.pickVersion("craftbook-template", id, identity, version);
+    if (!picked) return null;
+    const file = join2(
+      this.itemDir("craftbook-template", id),
+      "versions",
+      picked,
+      CRAFTBOOK_TEST_FILENAME
+    );
+    const text = await this.readOptional(file);
+    if (text === null) return null;
+    let raw;
+    try {
+      raw = JSON.parse(text);
+    } catch {
+      console.warn(`[catalog] ${file}: test spec is not valid JSON`);
+      return null;
+    }
+    const parsed = parseCraftbookTestSpec(raw, { mode: "tolerant" });
+    if (!parsed.ok) {
+      console.warn(`[catalog] ${file}: invalid test spec \u2014 ${parsed.errors[0]}`);
+      return null;
+    }
+    return { version: picked, spec: parsed.spec };
+  }
+  itemDir(kind, id) {
+    return join2(this.root, KIND_DIR[kind], shardPrefix(id), id);
+  }
+  /** Read + validate the identity (root) manifest for an item. */
+  async loadIdentity(kind, id) {
+    const file = join2(this.itemDir(kind, id), "manifest.json");
+    let raw;
+    try {
+      raw = await readFile(file, "utf8");
+    } catch {
+      return null;
+    }
+    try {
+      const parsed = CatalogItemIdentitySchema.parse(JSON.parse(raw));
+      if (parsed.kind !== kind) {
+        console.warn(
+          `[catalog] ${file}: identity kind=${parsed.kind} doesn't match directory kind=${kind}, skipping`
+        );
+        return null;
+      }
+      if (parsed.id !== id) {
+        console.warn(
+          `[catalog] ${file}: identity id=${parsed.id} doesn't match directory id=${id}, skipping`
+        );
+        return null;
+      }
+      if (!this.floorSatisfied(parsed.minGezelVersion)) return null;
+      return parsed;
+    } catch (err) {
+      console.warn(`[catalog] invalid identity manifest ${file}:`, err);
+      return null;
+    }
+  }
+  /** Enumerate `versions/{semver}/manifest.json` entries. Unsorted. */
+  async discoverVersionFolders(kind, id) {
+    const versionsDir = join2(this.itemDir(kind, id), "versions");
+    let names;
+    try {
+      names = await readdir(versionsDir);
+    } catch {
+      return [];
+    }
+    const out = [];
+    for (const name of names) {
+      if (!isSemver(name)) continue;
+      const candidates = kind === "craftbook-template" ? ["craftbook.json", "manifest.json"] : ["manifest.json"];
+      for (const filename of candidates) {
+        const versionFile = join2(versionsDir, name, filename);
+        let raw;
+        try {
+          raw = await readFile(versionFile, "utf8");
+        } catch {
+          continue;
+        }
+        try {
+          const json = JSON.parse(raw);
+          const version = typeof json.version === "string" ? json.version : null;
+          const releasedAt = typeof json.releasedAt === "string" ? json.releasedAt : null;
+          if (!version || !releasedAt) continue;
+          if (version !== name) {
+            console.warn(
+              `[catalog] ${versionFile}: version=${version} doesn't match folder name=${name}, skipping`
+            );
+            continue;
+          }
+          out.push({
+            version,
+            releasedAt,
+            ...typeof json.minGezelVersion === "string" ? { minGezelVersion: json.minGezelVersion } : {}
+          });
+        } catch {
+          continue;
+        }
+        break;
+      }
+    }
+    return out;
+  }
+  /**
+   * Pick a target version. When `requested` is set, validate it exists —
+   * an explicit pin deliberately bypasses the yank / `minSupportedVersion`
+   * / `minGezelVersion` filters so installed content keeps resolving.
+   * Otherwise resolve the highest non-yanked semver above
+   * `minSupportedVersion` whose `minGezelVersion` floor this build
+   * satisfies. Returns null when nothing satisfies.
+   */
+  async pickVersion(kind, id, identity, requested) {
+    const folders = await this.discoverVersionFolders(kind, id);
+    if (folders.length === 0) return null;
+    if (requested) {
+      return folders.some((f) => f.version === requested) ? requested : null;
+    }
+    const yanked = new Set(identity.yankedVersions);
+    const minSupported = identity.minSupportedVersion;
+    const eligible = folders.filter((f) => {
+      if (yanked.has(f.version)) return false;
+      if (minSupported && safeCompare(f.version, minSupported) < 0) return false;
+      if (!this.floorSatisfied(f.minGezelVersion)) return false;
+      return true;
+    }).map((f) => f.version);
+    if (eligible.length === 0) return null;
+    eligible.sort((a, b) => safeCompare(b, a));
+    return eligible[0] ?? null;
+  }
+  /**
+   * Compose identity + version into the resolved (flat) manifest shape
+   * that consumers expect. Returns null when identity is missing,
+   * version is missing, or validation fails.
+   */
+  async loadResolvedManifest(kind, id, version) {
+    const identity = await this.loadIdentity(kind, id);
+    if (!identity) return null;
+    const chosen = await this.pickVersion(kind, id, identity, version);
+    if (!chosen) {
+      if (version) {
+        console.warn(`[catalog] ${kind}/${id}: requested version ${version} not found on disk`);
+      } else {
+        const folders = await this.discoverVersionFolders(kind, id);
+        const yanked = new Set(identity.yankedVersions);
+        const everythingIneligible = folders.length > 0 && folders.every((f) => yanked.has(f.version) || !this.floorSatisfied(f.minGezelVersion));
+        if (!everythingIneligible) {
+          console.warn(`[catalog] ${kind}/${id}: no eligible versions on disk`);
+        }
+      }
+      return null;
+    }
+    const versionDir = join2(this.itemDir(kind, id), "versions", chosen);
+    const yankedSet = new Set(identity.yankedVersions);
+    const minSupportedVersion = identity.minSupportedVersion;
+    const allFolders = await this.discoverVersionFolders(kind, id);
+    const availableVersions = allFolders.filter((f) => {
+      if (yankedSet.has(f.version)) return false;
+      if (minSupportedVersion && safeCompare(f.version, minSupportedVersion) < 0) return false;
+      if (!this.floorSatisfied(f.minGezelVersion)) return false;
+      return true;
+    }).map((f) => f.version).sort((a, b) => safeCompare(b, a));
+    if (kind === "craftbook-template" && identity.kind === "craftbook-template") {
+      const docText = await this.readOptional(join2(versionDir, "craftbook.json"));
+      if (docText !== null) {
+        const parsed = parseCraftbookDoc(docText, "json");
+        if (!parsed.ok) {
+          console.warn(
+            `[catalog] invalid craftbook document ${join2(versionDir, "craftbook.json")}:
+${formatCraftbookDocErrors(parsed.errors)}`
+          );
+          return null;
+        }
+        return craftbookManifestFromDoc(identity, parsed.doc, chosen, availableVersions);
+      }
+    }
+    const versionFile = join2(versionDir, "manifest.json");
+    let versionPayload;
+    try {
+      versionPayload = JSON.parse(await readFile(versionFile, "utf8"));
+    } catch (err) {
+      console.warn(`[catalog] failed to read ${versionFile}:`, err);
+      return null;
+    }
+    const parsedVersion = parseVersionPayload(kind, versionPayload);
+    if (!parsedVersion) {
+      console.warn(`[catalog] invalid version manifest ${versionFile}`);
+      return null;
+    }
+    if (kind === "chat-model") {
+      const v = parsedVersion;
+      if (!v.ollama && !v.llamaCpp && !v.mlx && !v.ds4) {
+        console.warn(
+          `[catalog] ${versionFile}: chat-model version has no ollama / llamaCpp / mlx / ds4 source \u2014 skipping`
+        );
+        return null;
+      }
+    }
+    if (kind === "video-model") {
+      const v = parsedVersion;
+      if (!v.source || !Array.isArray(v.source.files) || v.source.files.length === 0) {
+        console.warn(
+          `[catalog] ${versionFile}: video-model version has no source files \u2014 skipping`
+        );
+        return null;
+      }
+    }
+    return mergeIdentityAndVersion(kind, identity, parsedVersion, availableVersions);
+  }
+  async readOptional(path) {
+    try {
+      return await readFile(path, "utf8");
+    } catch {
+      return null;
+    }
+  }
+  logoUrlFor(kind, id, manifest) {
+    if (!manifest.logo) return void 0;
+    if (/^https?:\/\//.test(manifest.logo)) return manifest.logo;
+    return `/api/catalog/${kind}/${encodeURIComponent(id)}/file/${encodeURIComponent(
+      manifest.logo
+    )}?source=${encodeURIComponent(this.id)}`;
+  }
+};
+function craftbookManifestFromDoc(identity, doc, version, availableVersions) {
+  if (!doc.releasedAt) {
+    console.warn(`[catalog] craftbook-template/${identity.id}@${version}: doc has no releasedAt`);
+    return null;
+  }
+  const steps = expandStepDeliverables(doc.steps);
+  const entryStepId = doc.entryStepId ?? steps[0].id;
+  const scriptNames = Object.keys(doc.scripts ?? {});
+  const minGezelVersion = maxMinGezelVersion(identity.minGezelVersion, doc.minGezelVersion);
+  return {
+    schemaVersion: 1,
+    kind: "craftbook-template",
+    id: identity.id,
+    name: identity.name,
+    description: identity.description,
+    tags: identity.tags,
+    maintainer: identity.maintainer,
+    ...identity.logo !== void 0 ? { logo: identity.logo } : {},
+    ...identity.license !== void 0 ? { license: identity.license } : {},
+    ...minGezelVersion !== void 0 ? { minGezelVersion } : {},
+    version,
+    releasedAt: doc.releasedAt,
+    role: identity.role,
+    ...identity.workflow ? { workflow: identity.workflow } : {},
+    // The prose lives inline on the doc (`description`) — there is no
+    // separate about.md file to point at. `get()` surfaces it directly.
+    about: "",
+    steps,
+    entryStepId,
+    ...doc.defaultAssignee ? { defaultAssignee: doc.defaultAssignee } : {},
+    ...doc.basedOn ? { basedOn: doc.basedOn } : {},
+    ...doc.plan !== void 0 ? { plan: doc.plan } : {},
+    ...doc.triggers ? { triggers: doc.triggers } : {},
+    ...doc.scripts ? { scripts: doc.scripts } : {},
+    ...scriptNames.length > 0 ? { bundledScripts: scriptNames.map((n) => `${n}.ts`) } : {},
+    ...doc.paramSchema ? { paramSchema: doc.paramSchema } : {},
+    ...doc.command ? { command: doc.command } : {},
+    ...doc.requirements ? { requirements: doc.requirements } : {},
+    ...doc.runModes ? { runModes: doc.runModes } : {},
+    ...doc.toolsets ? { toolsets: doc.toolsets } : {},
+    ...doc.connectors ? { connectors: doc.connectors } : {},
+    ...doc.hooks ? { hooks: doc.hooks } : {},
+    ...doc.spawn ? { spawn: doc.spawn } : {},
+    availableVersions
+  };
+}
+function safeCompare(a, b) {
+  try {
+    return compareSemver(a, b);
+  } catch {
+    return 0;
+  }
+}
+function parseVersionPayload(kind, raw) {
+  try {
+    if (kind === "toolset") {
+      const p2 = ToolsetVersionManifestSchema.parse(raw);
+      return { ...p2, __kind: "toolset" };
+    }
+    if (kind === "gezel-template") {
+      const p2 = GezelTemplateVersionManifestSchema.parse(raw);
+      return { ...p2, __kind: "gezel-template" };
+    }
+    if (kind === "craftbook-template") {
+      const p2 = CraftbookTemplateVersionManifestSchema.parse(raw);
+      return { ...p2, __kind: "craftbook-template" };
+    }
+    if (kind === "project-type") {
+      const p2 = ProjectTypeVersionManifestSchema.parse(raw);
+      return { ...p2, __kind: "project-type" };
+    }
+    if (kind === "connector-type") {
+      const p2 = ConnectorTypeVersionManifestSchema.parse(raw);
+      return { ...p2, __kind: "connector-type" };
+    }
+    if (kind === "chat-model") {
+      const p2 = ChatModelVersionManifestSchema.parse(raw);
+      return { ...p2, __kind: "chat-model" };
+    }
+    if (kind === "video-model") {
+      const p2 = VideoModelVersionManifestSchema.parse(raw);
+      return { ...p2, __kind: "video-model" };
+    }
+    const p = ImageModelVersionManifestSchema.parse(raw);
+    return { ...p, __kind: "image-model" };
+  } catch {
+    return null;
+  }
+}
+function mergeIdentityAndVersion(kind, identity, version, availableVersions) {
+  const minGezelVersion = maxMinGezelVersion(identity.minGezelVersion, version.minGezelVersion);
+  if (kind === "toolset" && identity.kind === "toolset" && version.__kind === "toolset") {
+    return {
+      schemaVersion: 1,
+      kind: "toolset",
+      id: identity.id,
+      name: identity.name,
+      description: identity.description,
+      tags: identity.tags,
+      maintainer: identity.maintainer,
+      ...identity.logo !== void 0 ? { logo: identity.logo } : {},
+      ...identity.license !== void 0 ? { license: identity.license } : {},
+      ...minGezelVersion !== void 0 ? { minGezelVersion } : {},
+      version: version.version,
+      releasedAt: version.releasedAt,
+      runtime: version.runtime,
+      tools: version.tools,
+      config: version.config,
+      ...version.requirements ? { requirements: version.requirements } : {},
+      ...version.notes !== void 0 ? { notes: version.notes } : {},
+      availableVersions,
+      ...identity.category ? { category: identity.category } : {}
+    };
+  }
+  if (kind === "craftbook-template" && identity.kind === "craftbook-template" && version.__kind === "craftbook-template") {
+    return {
+      schemaVersion: 1,
+      kind: "craftbook-template",
+      id: identity.id,
+      name: identity.name,
+      description: identity.description,
+      tags: identity.tags,
+      maintainer: identity.maintainer,
+      ...identity.logo !== void 0 ? { logo: identity.logo } : {},
+      ...identity.license !== void 0 ? { license: identity.license } : {},
+      ...minGezelVersion !== void 0 ? { minGezelVersion } : {},
+      version: version.version,
+      releasedAt: version.releasedAt,
+      role: identity.role,
+      ...identity.workflow ? { workflow: identity.workflow } : {},
+      about: version.about,
+      steps: version.steps,
+      entryStepId: version.entryStepId,
+      ...version.defaultAssignee ? { defaultAssignee: version.defaultAssignee } : {},
+      ...version.basedOn ? { basedOn: version.basedOn } : {},
+      ...version.plan !== void 0 ? { plan: version.plan } : {},
+      ...version.notes !== void 0 ? { notes: version.notes } : {},
+      ...version.triggers ? { triggers: version.triggers } : {},
+      ...version.hooks ? { hooks: version.hooks } : {},
+      ...version.bundledScripts ? { bundledScripts: version.bundledScripts } : {},
+      ...version.paramSchema ? { paramSchema: version.paramSchema } : {},
+      ...version.command ? { command: version.command } : {},
+      ...version.requirements ? { requirements: version.requirements } : {},
+      ...version.runModes ? { runModes: version.runModes } : {},
+      ...version.toolsets ? { toolsets: version.toolsets } : {},
+      ...version.connectors ? { connectors: version.connectors } : {},
+      availableVersions
+    };
+  }
+  if (kind === "project-type" && identity.kind === "project-type" && version.__kind === "project-type") {
+    return {
+      schemaVersion: 1,
+      kind: "project-type",
+      id: identity.id,
+      name: identity.name,
+      description: identity.description,
+      tags: identity.tags,
+      ...identity.category !== void 0 ? { category: identity.category } : {},
+      maintainer: identity.maintainer,
+      ...identity.logo !== void 0 ? { logo: identity.logo } : {},
+      ...identity.license !== void 0 ? { license: identity.license } : {},
+      ...minGezelVersion !== void 0 ? { minGezelVersion } : {},
+      version: version.version,
+      releasedAt: version.releasedAt,
+      ...version.extends !== void 0 ? { extends: version.extends } : {},
+      ...version.meesterManaged !== void 0 ? { meesterManaged: version.meesterManaged } : {},
+      ...version.tabVisibility !== void 0 ? { tabVisibility: version.tabVisibility } : {},
+      ...version.mode !== void 0 ? { mode: version.mode } : {},
+      ...version.leadLabel !== void 0 ? { leadLabel: version.leadLabel } : {},
+      ...version.leanProfile !== void 0 ? { leanProfile: version.leanProfile } : {},
+      ...version.indexingEnabled !== void 0 ? { indexingEnabled: version.indexingEnabled } : {},
+      ...version.params !== void 0 ? { params: version.params } : {},
+      ...version.nameTemplate !== void 0 ? { nameTemplate: version.nameTemplate } : {},
+      ...version.aboutTemplate !== void 0 ? { aboutTemplate: version.aboutTemplate } : {},
+      ...version.missionTemplate !== void 0 ? { missionTemplate: version.missionTemplate } : {},
+      gezels: version.gezels,
+      toolsets: version.toolsets,
+      craftbooks: version.craftbooks,
+      ...version.scripts !== void 0 ? { scripts: version.scripts } : {},
+      tools: version.tools,
+      ...version.pages !== void 0 ? { pages: version.pages } : {},
+      schedules: version.schedules,
+      workspaceSeed: version.workspaceSeed,
+      artifactsSeed: version.artifactsSeed,
+      ...version.notes !== void 0 ? { notes: version.notes } : {},
+      availableVersions
+    };
+  }
+  if (kind === "connector-type" && identity.kind === "connector-type" && version.__kind === "connector-type") {
+    return {
+      schemaVersion: 1,
+      kind: "connector-type",
+      id: identity.id,
+      name: identity.name,
+      description: identity.description,
+      tags: identity.tags,
+      maintainer: identity.maintainer,
+      ...identity.logo !== void 0 ? { logo: identity.logo } : {},
+      ...identity.license !== void 0 ? { license: identity.license } : {},
+      ...minGezelVersion !== void 0 ? { minGezelVersion } : {},
+      version: version.version,
+      releasedAt: version.releasedAt,
+      driver: version.driver,
+      ...version.configSchema !== void 0 ? { configSchema: version.configSchema } : {},
+      ...version.secretShape !== void 0 ? { secretShape: version.secretShape } : {},
+      source: version.source,
+      normalize: version.normalize,
+      actions: version.actions,
+      ...version.completeness !== void 0 ? { completeness: version.completeness } : {},
+      ...version.notes !== void 0 ? { notes: version.notes } : {},
+      availableVersions
+    };
+  }
+  if (kind === "gezel-template" && identity.kind === "gezel-template" && version.__kind === "gezel-template") {
+    return {
+      schemaVersion: 1,
+      kind: "gezel-template",
+      id: identity.id,
+      name: identity.name,
+      description: identity.description,
+      tags: identity.tags,
+      maintainer: identity.maintainer,
+      ...identity.logo !== void 0 ? { logo: identity.logo } : {},
+      ...identity.license !== void 0 ? { license: identity.license } : {},
+      ...minGezelVersion !== void 0 ? { minGezelVersion } : {},
+      version: version.version,
+      releasedAt: version.releasedAt,
+      role: identity.role,
+      about: version.about,
+      ...version.suggestedProvider ? { suggestedProvider: version.suggestedProvider } : {},
+      ...version.suggestedModel ? { suggestedModel: version.suggestedModel } : {},
+      suggestedTools: version.suggestedTools,
+      meesterCandidate: identity.meesterCandidate,
+      ...version.notes !== void 0 ? { notes: version.notes } : {},
+      ...version.frontmatter ? { frontmatter: version.frontmatter } : {},
+      ...version.nameSuggestions ? { nameSuggestions: version.nameSuggestions } : {},
+      ...version.suggestedCraftbooks ? { suggestedCraftbooks: version.suggestedCraftbooks } : {},
+      availableVersions
+    };
+  }
+  if (kind === "chat-model" && identity.kind === "chat-model" && version.__kind === "chat-model") {
+    return {
+      schemaVersion: 1,
+      kind: "chat-model",
+      id: identity.id,
+      name: identity.name,
+      description: identity.description,
+      tags: identity.tags,
+      maintainer: identity.maintainer,
+      ...identity.logo !== void 0 ? { logo: identity.logo } : {},
+      ...identity.license !== void 0 ? { license: identity.license } : {},
+      ...identity.licenseClass !== void 0 ? { licenseClass: identity.licenseClass } : {},
+      ...identity.licenseShortName !== void 0 ? { licenseShortName: identity.licenseShortName } : {},
+      ...identity.licenseUrl !== void 0 ? { licenseUrl: identity.licenseUrl } : {},
+      ...identity.recoScore !== void 0 ? { recoScore: identity.recoScore } : {},
+      ...minGezelVersion !== void 0 ? { minGezelVersion } : {},
+      version: version.version,
+      releasedAt: version.releasedAt,
+      parameterSize: identity.parameterSize,
+      approxSizeBytes: version.approxSizeBytes,
+      supportsTools: identity.supportsTools,
+      ...identity.contextWindow !== void 0 ? { contextWindow: identity.contextWindow } : {},
+      // KV geometry is architecture-determined, so it rides on identity and
+      // must be forwarded explicitly — this merge builds the resolved
+      // manifest from a fixed field list, which is why authoring the fields
+      // alone did nothing: they were silently dropped here and the
+      // pre-install fit badge kept pricing weights only.
+      ...identity.kvBytesPerTokenF16 !== void 0 ? { kvBytesPerTokenF16: identity.kvBytesPerTokenF16 } : {},
+      ...identity.kvFixedBytesF16 !== void 0 ? { kvFixedBytesF16: identity.kvFixedBytesF16 } : {},
+      ...identity.upstream !== void 0 ? { upstream: identity.upstream } : {},
+      ...identity.category ? { category: identity.category } : {},
+      ...identity.style ? { style: identity.style } : {},
+      ...identity.behaviors ? { behaviors: identity.behaviors } : {},
+      ...identity.tuning ? { tuning: identity.tuning } : {},
+      ...version.ollama ? { ollama: version.ollama } : {},
+      ...version.llamaCpp ? { llamaCpp: version.llamaCpp } : {},
+      ...version.mlx ? { mlx: version.mlx } : {},
+      ...version.ds4 ? { ds4: version.ds4 } : {},
+      ...version.notes !== void 0 ? { notes: version.notes } : {},
+      availableVersions
+    };
+  }
+  if (kind === "image-model" && identity.kind === "image-model" && version.__kind === "image-model") {
+    return {
+      schemaVersion: 1,
+      kind: "image-model",
+      id: identity.id,
+      name: identity.name,
+      description: identity.description,
+      tags: identity.tags,
+      maintainer: identity.maintainer,
+      ...identity.logo !== void 0 ? { logo: identity.logo } : {},
+      ...identity.license !== void 0 ? { license: identity.license } : {},
+      ...identity.licenseClass !== void 0 ? { licenseClass: identity.licenseClass } : {},
+      ...identity.licenseShortName !== void 0 ? { licenseShortName: identity.licenseShortName } : {},
+      ...identity.licenseUrl !== void 0 ? { licenseUrl: identity.licenseUrl } : {},
+      ...identity.recoScore !== void 0 ? { recoScore: identity.recoScore } : {},
+      ...minGezelVersion !== void 0 ? { minGezelVersion } : {},
+      version: version.version,
+      releasedAt: version.releasedAt,
+      downloadUrl: version.downloadUrl,
+      sha256: version.sha256,
+      approxSizeBytes: version.approxSizeBytes,
+      ...version.quantization ? { quantization: version.quantization } : {},
+      recommendedSteps: identity.recommendedSteps,
+      ...identity.widthRange ? { widthRange: identity.widthRange } : {},
+      ...identity.heightRange ? { heightRange: identity.heightRange } : {},
+      ...identity.upstream !== void 0 ? { upstream: identity.upstream } : {},
+      ...identity.category ? { category: identity.category } : {},
+      weightsKind: identity.weightsKind,
+      ...identity.supportsImg2Img !== void 0 ? { supportsImg2Img: identity.supportsImg2Img } : {},
+      auxiliaryFiles: version.auxiliaryFiles,
+      hardwareTier: identity.hardwareTier,
+      minRamGB: identity.minRamGB,
+      commercialUse: identity.commercialUse,
+      ...version.notes !== void 0 ? { notes: version.notes } : {},
+      availableVersions
+    };
+  }
+  if (kind === "video-model" && identity.kind === "video-model" && version.__kind === "video-model") {
+    return {
+      schemaVersion: 1,
+      kind: "video-model",
+      id: identity.id,
+      name: identity.name,
+      description: identity.description,
+      tags: identity.tags,
+      maintainer: identity.maintainer,
+      ...identity.logo !== void 0 ? { logo: identity.logo } : {},
+      ...identity.license !== void 0 ? { license: identity.license } : {},
+      ...identity.licenseClass !== void 0 ? { licenseClass: identity.licenseClass } : {},
+      ...identity.licenseShortName !== void 0 ? { licenseShortName: identity.licenseShortName } : {},
+      ...identity.licenseUrl !== void 0 ? { licenseUrl: identity.licenseUrl } : {},
+      ...identity.recoScore !== void 0 ? { recoScore: identity.recoScore } : {},
+      ...minGezelVersion !== void 0 ? { minGezelVersion } : {},
+      version: version.version,
+      releasedAt: version.releasedAt,
+      family: identity.family,
+      ...identity.load !== void 0 ? { load: identity.load } : {},
+      source: version.source,
+      approxSizeBytes: version.source.approxSizeBytes,
+      recommendedSteps: identity.recommendedSteps,
+      ...identity.guidanceScale !== void 0 ? { guidanceScale: identity.guidanceScale } : {},
+      defaultNumFrames: identity.defaultNumFrames,
+      ...identity.numFramesRange ? { numFramesRange: identity.numFramesRange } : {},
+      defaultFps: identity.defaultFps,
+      ...identity.fpsRange ? { fpsRange: identity.fpsRange } : {},
+      ...identity.maxDurationSeconds !== void 0 ? { maxDurationSeconds: identity.maxDurationSeconds } : {},
+      ...identity.widthRange ? { widthRange: identity.widthRange } : {},
+      ...identity.heightRange ? { heightRange: identity.heightRange } : {},
+      ...identity.defaultWidth !== void 0 ? { defaultWidth: identity.defaultWidth } : {},
+      ...identity.defaultHeight !== void 0 ? { defaultHeight: identity.defaultHeight } : {},
+      supportsImageToVideo: identity.supportsImageToVideo,
+      ...identity.upstream !== void 0 ? { upstream: identity.upstream } : {},
+      hardwareTier: identity.hardwareTier,
+      minVramGB: identity.minVramGB,
+      commercialUse: identity.commercialUse,
+      ...version.notes !== void 0 ? { notes: version.notes } : {},
+      availableVersions
+    };
+  }
+  return null;
+}
+// src/community-source.ts
+function defaultCommunityDataDir() {
+  return join3(gildeDataDir(), "community");
+}
+var CommunitySource = class extends BundledSource {
+  constructor(dataDir = defaultCommunityDataDir(), gezelVersion) {
+    super({
+      dataDir,
+      id: "community",
+      label: "MCP Registry (community)",
+      ...gezelVersion !== void 0 ? { gezelVersion } : {}
+    });
+  }
+};
+// src/local-source.ts
+var LOCAL_KINDS = /* @__PURE__ */ new Set([
+  "project-type",
+  "gezel-template",
+  "connector-type",
+  "toolset"
+]);
+var LocalCatalogSource = class extends BundledSource {
+  constructor(home, gezelVersion) {
+    super({
+      dataDir: home,
+      id: "local",
+      label: "Installed",
+      noIndex: true,
+      ...gezelVersion !== void 0 ? { gezelVersion } : {}
+    });
+  }
+  async listKinds() {
+    return [...LOCAL_KINDS];
+  }
+  async list(kind) {
+    if (!LOCAL_KINDS.has(kind)) return [];
+    return super.list(kind);
+  }
+  async get(kind, id, version) {
+    if (!LOCAL_KINDS.has(kind)) return null;
+    return super.get(kind, id, version);
+  }
+  async listVersions(kind, id) {
+    if (!LOCAL_KINDS.has(kind)) return [];
+    return super.listVersions(kind, id);
+  }
+  async readItemFile(kind, id, relPath, version) {
+    if (!LOCAL_KINDS.has(kind)) return null;
+    return super.readItemFile(kind, id, relPath, version);
+  }
+  async listItemFiles(kind, id) {
+    if (!LOCAL_KINDS.has(kind)) return [];
+    return super.listItemFiles(kind, id);
+  }
+};
+// src/service.ts
+var CatalogService = class {
+  sources;
+  contentRootProvider;
+  /**
+   * @param sources explicit source list (replaces the defaults entirely).
+   * @param opts.localRoot a GEZEL_HOME to read user-installed / `.gzl`-imported
+   *   catalog items from (project types + gezel roles). Appended just ahead of
+   *   the bundled tier so a user's imported item shadows a same-id bundled one.
+   * @param opts.contentRoot dynamic gilde content root for the default
+   *   bundled + community tiers, re-read on every disk access. The live
+   *   gilde update mechanism flips it without reconstructing this service
+   *   (which is built once at boot and held by many subsystems).
+   * @param opts.gezelVersion the running app's version, compared against
+   *   content `minGezelVersion` floors. Defaults to `GEZEL_VERSION`
+   *   inside each source; injectable so tests can exercise gating (dev
+   *   checkouts report `0.0.0`, which bypasses all filtering).
+   */
+  constructor(sources, opts) {
+    this.contentRootProvider = opts?.contentRoot ?? null;
+    if (sources && sources.length > 0) {
+      this.sources = sources;
+      return;
+    }
+    const contentRoot = opts?.contentRoot;
+    const gezelVersion = opts?.gezelVersion;
+    const local = opts?.localRoot ? [new LocalCatalogSource(opts.localRoot, gezelVersion)] : [];
+    this.sources = [
+      new BuiltinToolsetsSource(),
+      ...local,
+      new BundledSource({
+        ...contentRoot ? { dataDir: contentRoot } : {},
+        ...gezelVersion !== void 0 ? { gezelVersion } : {}
+      }),
+      new CommunitySource(
+        contentRoot ? () => join4(contentRoot(), "community") : void 0,
+        gezelVersion
+      )
+    ];
+  }
+  /**
+   * The effective gilde content root, or null when constructed without a
+   * provider (tests, CLI one-shots). Cheap and synchronous — ChatManager
+   * snapshots it per session to detect a live content flip and rebuild
+   * cached model profiles/tuning on the next turn.
+   */
+  contentRoot() {
+    return this.contentRootProvider ? this.contentRootProvider() : null;
+  }
+  /** All active sources in priority order (higher trust first). */
+  listSources() {
+    return this.sources.map((s) => ({ id: s.id, label: s.label }));
+  }
+  /**
+   * Merged listing across sources. Items from earlier sources (bundled)
+   * shadow later sources (remote) on id collision.
+   */
+  async list(kind) {
+    const seen = /* @__PURE__ */ new Set();
+    const merged = [];
+    for (const source of this.sources) {
+      const items = await source.list(kind);
+      for (const item of items) {
+        if (seen.has(item.manifest.id)) continue;
+        seen.add(item.manifest.id);
+        merged.push(item);
+      }
+    }
+    return merged;
+  }
+  async get(kind, id, sourceId, version) {
+    for (const source of this.sources) {
+      if (sourceId && source.id !== sourceId) continue;
+      const detail = await source.get(kind, id, version);
+      if (detail) return detail;
+    }
+    return null;
+  }
+  async listVersions(kind, id, sourceId) {
+    for (const source of this.sources) {
+      if (sourceId && source.id !== sourceId) continue;
+      const versions = await source.listVersions(kind, id);
+      if (versions.length > 0) return versions;
+    }
+    return [];
+  }
+  async readItemFile(kind, id, relPath, sourceId, version) {
+    for (const source of this.sources) {
+      if (sourceId && source.id !== sourceId) continue;
+      const buf = await source.readItemFile(kind, id, relPath, version);
+      if (buf) return buf;
+    }
+    return null;
+  }
+  /** Every file under an item's folder (item-relative paths). For the exporter. */
+  async listItemFiles(kind, id, sourceId) {
+    for (const source of this.sources) {
+      if (sourceId && source.id !== sourceId) continue;
+      if (!source.listItemFiles) continue;
+      const files = await source.listItemFiles(kind, id);
+      if (files.length > 0) return files;
+    }
+    return [];
+  }
+  /**
+   * A craftbook's eval descriptor (`test.json` sidecar), from the first
+   * source that carries one. Null when no source ships it.
+   */
+  async getCraftbookTestSpec(id, version) {
+    for (const source of this.sources) {
+      if (!source.getCraftbookTestSpec) continue;
+      const found = await source.getCraftbookTestSpec(id, version);
+      if (found) return found;
+    }
+    return null;
+  }
+};
+// src/categorize.ts
+var RULES = [
+  {
+    category: "search",
+    keywords: [
+      "search",
+      "scrape",
+      "scraping",
+      "crawl",
+      "crawler",
+      "web fetch",
+      "web search",
+      "lookup",
+      "duckduckgo",
+      "serpapi",
+      "tavily",
+      "brave search",
+      "exa-",
+      "perplexity",
+      "kagi",
+      "searxng"
+    ]
+  },
+  {
+    category: "dev-tools",
+    keywords: [
+      "github",
+      "gitlab",
+      "bitbucket",
+      "sentry",
+      "pull request",
+      "pull-request",
+      "issue tracker",
+      "code review",
+      "lint",
+      "test runner",
+      "devops",
+      "ci/cd",
+      "jenkins",
+      "circleci",
+      "github actions",
+      "pagerduty",
+      "datadog",
+      "logs ",
+      "monitoring",
+      "observability",
+      "apm ",
+      "compiler",
+      "package manager",
+      "npm ",
+      "pypi",
+      " pip ",
+      "docker hub",
+      "container registry",
+      "release notes",
+      "deploy",
+      "deployment",
+      "vercel",
+      "netlify",
+      "fly.io",
+      "render.com",
+      "heroku"
+    ]
+  },
+  {
+    category: "data",
+    keywords: [
+      "database",
+      "postgres",
+      "postgresql",
+      "mysql",
+      "mariadb",
+      "sqlite",
+      "mongodb",
+      " mongo ",
+      "redis",
+      "elasticsearch",
+      "opensearch",
+      "clickhouse",
+      "snowflake",
+      "bigquery",
+      "duckdb",
+      "cassandra",
+      "dynamodb",
+      "firestore",
+      "firebase",
+      "supabase",
+      "data warehouse",
+      "data lake",
+      "spreadsheet",
+      "airtable",
+      "data analytics",
+      "metabase",
+      "tableau",
+      "looker",
+      "csv",
+      "excel ",
+      "sql ",
+      "graphql",
+      "data pipeline",
+      "etl "
+    ]
+  },
+  {
+    category: "cloud",
+    keywords: [
+      " aws ",
+      "amazon web services",
+      " s3 ",
+      "ec2",
+      "lambda",
+      " azure ",
+      " gcp ",
+      "google cloud",
+      "cloudflare",
+      "kubernetes",
+      " k8s ",
+      "docker",
+      "containers",
+      "terraform",
+      "pulumi",
+      "helm",
+      "serverless",
+      "cloud run",
+      "fargate",
+      "cloudformation",
+      "digitalocean",
+      "linode"
+    ]
+  },
+  {
+    category: "productivity",
+    keywords: [
+      "calendar",
+      "tasks",
+      "todo",
+      " jira",
+      "linear ",
+      " asana",
+      "trello",
+      "clickup",
+      "project management",
+      "task management",
+      "kanban",
+      "monday.com",
+      "shortcut",
+      "pivotaltracker",
+      "basecamp",
+      "time tracking",
+      "pomodoro",
+      "reminder"
+    ]
+  },
+  {
+    category: "communication",
+    keywords: [
+      "slack",
+      "discord",
+      " email",
+      "gmail",
+      "outlook",
+      "teams ",
+      "whatsapp",
+      "telegram",
+      "twitter",
+      " x.com",
+      "linkedin",
+      "mastodon",
+      "bluesky",
+      "reddit",
+      "messaging",
+      "chat ",
+      "sms ",
+      "twilio",
+      "mailchimp",
+      "mailgun",
+      "sendgrid",
+      "newsletter",
+      "matrix",
+      "rocket.chat"
+    ]
+  },
+  {
+    category: "content",
+    keywords: [
+      "notion",
+      " wiki",
+      "document",
+      "documents",
+      "docx",
+      " pdf",
+      "markdown",
+      "obsidian",
+      "confluence",
+      "cms",
+      "wordpress",
+      "blog",
+      "medium",
+      "substack",
+      "ghost ",
+      "translate",
+      "translation",
+      " rss",
+      "note-taking",
+      "note taking",
+      "evernote",
+      "google docs",
+      "sharepoint",
+      "onedrive",
+      "dropbox",
+      "box.com",
+      "file storage",
+      "pdf parser",
+      "docs "
+    ]
+  },
+  {
+    category: "media",
+    keywords: [
+      "image",
+      "video",
+      "audio",
+      "photo",
+      "figma",
+      "sketch",
+      "music",
+      "render",
+      "design",
+      "spotify",
+      "youtube",
+      "vimeo",
+      "soundcloud",
+      "twitch",
+      "streaming",
+      "podcast",
+      "tts ",
+      "text-to-speech",
+      "speech-to-text",
+      "transcribe",
+      "transcription",
+      "whisper",
+      "stable diffusion",
+      "midjourney",
+      "dalle",
+      "dall-e",
+      "flux",
+      "photo editor",
+      "image editor",
+      "image generation",
+      "image generator",
+      "video generation"
+    ]
+  },
+  {
+    category: "ai",
+    keywords: [
+      "llm ",
+      "embedding",
+      "embeddings",
+      "vector db",
+      "vector database",
+      "vector store",
+      "pinecone",
+      "weaviate",
+      "qdrant",
+      "chroma db",
+      "chromadb",
+      "milvus",
+      "lancedb",
+      "langchain",
+      "llamaindex",
+      "agentic",
+      "openai api",
+      "anthropic api",
+      " rag ",
+      "retrieval-augmented",
+      "huggingface",
+      "hugging face",
+      "inference engine",
+      "fine-tuning",
+      "fine-tune",
+      "prompt engineering",
+      "prompt library",
+      "agent framework",
+      "agent orchestration",
+      "multi-agent",
+      "ml ops",
+      "mlops"
+    ]
+  }
+];
+function categorizeToolset(input) {
+  const haystack = [
+    input.name,
+    input.description,
+    input.id,
+    input.tags.join(" "),
+    input.maintainerName ?? ""
+  ].join(" ").toLowerCase();
+  for (const rule of RULES) {
+    for (const kw of rule.keywords) {
+      if (haystack.includes(kw)) return rule.category;
+    }
+  }
+  return "other";
+}
+// src/install/npm-package.ts
+import { spawn } from "child_process";
+import { createHash, randomUUID } from "crypto";
+import { createReadStream } from "fs";
+import { mkdir, open, readFile as readFile2, realpath, rename, rm, stat, writeFile } from "fs/promises";
+import { dirname as dirname2, isAbsolute, join as join5, relative, resolve } from "path";
+import {
+  HttpStatusError,
+  PNPM_HOISTED_NODE_LINKER,
+  resolvePnpmInvocation,
+  retryTransient
+} from "@bendyline/gezel";
+import * as tar from "tar";
+var DEFAULT_NPM_REGISTRY = "https://registry.npmjs.org";
+var MAX_PACKUMENT_BYTES = 5 * 1024 * 1024;
+var MAX_TARBALL_BYTES = 100 * 1024 * 1024;
+var MAX_UNPACKED_BYTES = 500 * 1024 * 1024;
+var MAX_ARCHIVE_ENTRIES = 5e4;
+var REGISTRY_TIMEOUT_MS = 3e4;
+var DOWNLOAD_TIMEOUT_MS = 2 * 6e4;
+var INSTALL_TIMEOUT_MS = 5 * 6e4;
+var NETWORK_ATTEMPTS = 3;
+async function installNpmPackageToolset(opts) {
+  const { manifest } = opts;
+  const { package: packageName, version, sha256: expectedHash, entry } = manifest.runtime;
+  const registry = validateRegistry(opts.registry ?? DEFAULT_NPM_REGISTRY);
+  const slug = `${packageName.replace("/", "__")}@${version}`;
+  const target = join5(opts.installRoot, slug);
+  const staging = `${target}.staging-${process.pid}-${randomUUID()}`;
+  const backup = `${target}.previous`;
+  await mkdir(opts.installRoot, { recursive: true });
+  await recoverInterruptedNpmInstall(target, backup);
+  await mkdir(staging, { recursive: true });
+  try {
+    const tarballUrl = await retryTransient(
+      () => resolveTarballUrl(packageName, version, registry),
+      { attempts: NETWORK_ATTEMPTS, label: `${packageName}@${version} metadata` }
+    );
+    const tarballPath = join5(staging, "package.tgz");
+    const actualHash = await retryTransient(
+      () => downloadTarball(tarballUrl, tarballPath, registry.origin),
+      { attempts: NETWORK_ATTEMPTS, label: `${packageName}@${version} tarball` }
+    );
+    if (actualHash !== expectedHash) {
+      throw new Error(
+        `[catalog] sha256 mismatch for ${packageName}@${version}: manifest=${expectedHash} actual=${actualHash}. Refusing to install.`
+      );
+    }
+    await extractNpmPackageTarball({
+      tarballPath,
+      destination: staging,
+      expectedName: packageName,
+      expectedVersion: version
+    });
+    await rm(tarballPath, { force: true });
+    const packageDir = join5(staging, "package");
+    const pnpm = resolvePnpmInvocation(
+      [
+        "install",
+        "--prod",
+        "--ignore-scripts",
+        "--frozen-lockfile=false",
+        PNPM_HOISTED_NODE_LINKER
+      ],
+      {
+        pnpmPath: process.env.GEZEL_PNPM_PATH,
+        nodePath: process.env.GEZEL_NODE_PATH,
+        processExecPath: process.execPath,
+        platform: process.platform
+      }
+    );
+    await runAndWait(pnpm.command, pnpm.args, packageDir, pnpm.shell);
+    await resolvePackageEntry(packageDir, entry);
+    await publishStagedNpmInstall(staging, target, backup);
+    return { installPath: join5(target, "package"), tarballSha256: actualHash };
+  } catch (err) {
+    await rm(staging, { recursive: true, force: true }).catch(() => {
+    });
+    throw err;
+  }
+}
+async function verifyTarballSha256(tarballPath) {
+  const hash = createHash("sha256");
+  for await (const chunk of createReadStream(tarballPath)) hash.update(chunk);
+  return hash.digest("hex");
+}
+function validateRegistry(input) {
+  const registry = new URL(input.endsWith("/") ? input : `${input}/`);
+  const loopback = registry.hostname === "127.0.0.1" || registry.hostname === "localhost";
+  if (registry.protocol !== "https:" && !(loopback && registry.protocol === "http:") || registry.username || registry.password) {
+    throw new Error(
+      "[catalog] npm registry must be HTTPS (or loopback HTTP) without URL credentials"
+    );
+  }
+  return registry;
+}
+async function resolveTarballUrl(packageName, version, registry) {
+  const url = new URL(encodePackumentPath(packageName), registry);
+  const { response, dispose } = await fetchSameOrigin(url, registry.origin, REGISTRY_TIMEOUT_MS);
+  try {
+    if (!response.ok) {
+      throw new HttpStatusError(
+        response.status,
+        `[catalog] registry returned HTTP ${response.status}`
+      );
+    }
+    const raw = await readBoundedBody(response, MAX_PACKUMENT_BYTES);
+    let packument;
+    try {
+      packument = JSON.parse(new TextDecoder().decode(raw));
+    } catch {
+      throw new Error("[catalog] registry returned malformed package metadata");
+    }
+    const tarball = packument.versions?.[version]?.dist?.tarball;
+    if (!tarball) throw new Error(`[catalog] version ${version} of ${packageName} was not found`);
+    const parsed = new URL(tarball, registry);
+    assertSameOrigin(parsed, registry.origin);
+    return parsed.href;
+  } finally {
+    dispose();
+  }
+}
+function encodePackumentPath(packageName) {
+  return packageName.startsWith("@") ? packageName.replace("/", "%2f") : packageName;
+}
+async function downloadTarball(url, dest, origin) {
+  const { response, dispose } = await fetchSameOrigin(new URL(url), origin, DOWNLOAD_TIMEOUT_MS);
+  const handle = await open(dest, "wx", 384);
+  let total = 0;
+  const hash = createHash("sha256");
+  try {
+    if (!response.ok || !response.body) {
+      throw new HttpStatusError(
+        response.status,
+        `[catalog] tarball download returned HTTP ${response.status}`
+      );
+    }
+    const declared = Number(response.headers.get("content-length"));
+    if (Number.isFinite(declared) && declared > MAX_TARBALL_BYTES) {
+      throw new Error("[catalog] tarball exceeds the 100 MiB download limit");
+    }
+    const reader = response.body.getReader();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        total += value.byteLength;
+        if (total > MAX_TARBALL_BYTES) {
+          throw new Error("[catalog] tarball exceeds the 100 MiB download limit");
+        }
+        hash.update(value);
+        let offset = 0;
+        while (offset < value.byteLength) {
+          const written = await handle.write(value, offset, value.byteLength - offset);
+          offset += written.bytesWritten;
+        }
+      }
+    } finally {
+      await reader.cancel().catch(() => {
+      });
+    }
+    return hash.digest("hex");
+  } catch (err) {
+    await rm(dest, { force: true }).catch(() => {
+    });
+    throw err;
+  } finally {
+    dispose();
+    await handle.close();
+  }
+}
+async function extractNpmPackageTarball(opts) {
+  await inspectTarball(opts.tarballPath);
+  await tar.extract({
+    file: opts.tarballPath,
+    cwd: opts.destination,
+    strict: true,
+    preservePaths: false
+  });
+  const packageDir = join5(opts.destination, "package");
+  await validateExtractedPackage(packageDir, opts.expectedName, opts.expectedVersion);
+  return packageDir;
+}
+async function inspectTarball(path) {
+  let entries = 0;
+  let unpackedBytes = 0;
+  await tar.list({
+    file: path,
+    strict: true,
+    onentry: (entry) => {
+      entries += 1;
+      unpackedBytes += entry.size;
+      if (entries > MAX_ARCHIVE_ENTRIES || unpackedBytes > MAX_UNPACKED_BYTES) {
+        throw new Error("[catalog] package archive exceeds extraction limits");
+      }
+      validateNpmArchiveEntry(entry.path, entry.type);
+    }
+  });
+}
+function validateNpmArchiveEntry(path, type) {
+  const withoutDot = path.startsWith("./") ? path.slice(2) : path;
+  const clean = type === "Directory" && withoutDot.endsWith("/") ? withoutDot.slice(0, -1) : withoutDot;
+  const parts = clean.split("/");
+  const hasWindowsUnsafeSegment = parts.some((part) => {
+    const stem = part.split(".")[0]?.toUpperCase() ?? "";
+    return part.includes(":") || part.endsWith(" ") || part.endsWith(".") || RESERVED_WINDOWS_BASENAMES.has(stem);
+  });
+  if (clean.includes("\\") || clean.includes("\0") || clean.startsWith("/") || parts[0] !== "package" || parts.some((part) => part === ".." || part === "" || part === ".") || hasWindowsUnsafeSegment || !["File", "Directory"].includes(type)) {
+    throw new Error(`[catalog] unsafe package archive entry: ${path}`);
+  }
+}
+async function validateExtractedPackage(packageDir, expectedName, expectedVersion) {
+  const raw = await readFile2(join5(packageDir, "package.json"), "utf8");
+  const parsed = JSON.parse(raw);
+  if (parsed.name !== expectedName || parsed.version !== expectedVersion) {
+    throw new Error("[catalog] extracted package identity does not match the pinned manifest");
+  }
+}
+async function resolvePackageEntry(packageDir, entry) {
+  const root = await realpath(packageDir);
+  const candidate = await realpath(resolve(root, entry));
+  const rel = relative(root, candidate);
+  if (rel === "" || rel.startsWith("..") || isAbsolute(rel)) {
+    throw new Error("[catalog] package entry escapes the installed package");
+  }
+  if (!(await stat(candidate)).isFile()) throw new Error("[catalog] package entry is not a file");
+  return candidate;
+}
+async function readBoundedBody(response, maxBytes) {
+  if (!response.body) throw new Error("[catalog] registry returned an empty response");
+  const declared = Number(response.headers.get("content-length"));
+  if (Number.isFinite(declared) && declared > maxBytes) {
+    throw new Error("[catalog] registry metadata response is too large");
+  }
+  const chunks = [];
+  let total = 0;
+  const reader = response.body.getReader();
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      total += value.byteLength;
+      if (total > maxBytes) throw new Error("[catalog] registry metadata response is too large");
+      chunks.push(value);
+    }
+  } finally {
+    await reader.cancel().catch(() => {
+    });
+  }
+  const joined = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    joined.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return joined;
+}
+async function fetchSameOrigin(initial, origin, timeoutMs, headers) {
+  let current = initial;
+  for (let redirects = 0; redirects <= 3; redirects++) {
+    assertSameOrigin(current, origin);
+    const controller = new AbortController();
+    const timer = setTimeout(
+      () => controller.abort(new Error("[catalog] registry request timed out")),
+      timeoutMs
+    );
+    try {
+      const response = await fetch(current, {
+        redirect: "manual",
+        signal: controller.signal,
+        ...headers ? { headers } : {}
+      });
+      if (response.status >= 300 && response.status < 400) {
+        clearTimeout(timer);
+        const location = response.headers.get("location");
+        if (!location || redirects === 3) throw new Error("[catalog] invalid registry redirect");
+        current = new URL(location, current);
+        continue;
+      }
+      return { response, dispose: () => clearTimeout(timer) };
+    } catch (err) {
+      clearTimeout(timer);
+      throw err;
+    }
+  }
+  throw new Error("[catalog] too many registry redirects");
+}
+function assertSameOrigin(url, origin) {
+  if (url.origin !== origin || url.username || url.password) {
+    throw new Error("[catalog] refusing to send registry traffic to an untrusted origin");
+  }
+}
+var RESERVED_WINDOWS_BASENAMES = /* @__PURE__ */ new Set([
+  "CON",
+  "PRN",
+  "AUX",
+  "NUL",
+  ...Array.from({ length: 9 }, (_, i) => `COM${i + 1}`),
+  ...Array.from({ length: 9 }, (_, i) => `LPT${i + 1}`)
+]);
+async function publishStagedNpmInstall(staging, target, backup) {
+  await rm(backup, { recursive: true, force: true });
+  let hadTarget = false;
+  try {
+    await stat(target);
+    hadTarget = true;
+  } catch {
+  }
+  if (hadTarget) await rename(target, backup);
+  try {
+    await rename(staging, target);
+  } catch (err) {
+    if (hadTarget) await rename(backup, target).catch(() => {
+    });
+    throw err;
+  }
+  await rm(backup, { recursive: true, force: true });
+}
+async function recoverInterruptedNpmInstall(target, backup) {
+  try {
+    await stat(target);
+  } catch {
+    try {
+      await rename(backup, target);
+    } catch {
+    }
+  }
+}
+function runAndWait(command, args, cwd, shell) {
+  return new Promise((resolvePromise, reject) => {
+    const child = spawn(command, args, {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      // DETACHED_PROCESS on Windows / a new process group on POSIX. The
+      // Windows half is load-bearing: the machine service's restricted SID
+      // cannot allocate a console, so a console-subsystem child started any
+      // other way dies as `spawn EPERM`. `windowsHide` (CREATE_NO_WINDOW)
+      // does not help — it still allocates one.
+      detached: true,
+      shell
+    });
+    let output = "";
+    let settled = false;
+    const capture = (chunk) => {
+      if (output.length < 32e3) output += chunk.toString("utf8").slice(0, 32e3 - output.length);
+    };
+    child.stdout?.on("data", capture);
+    child.stderr?.on("data", capture);
+    const timer = setTimeout(() => {
+      killProcessTree(child);
+      finish(new Error(`[catalog] dependency install exceeded ${INSTALL_TIMEOUT_MS}ms`));
+    }, INSTALL_TIMEOUT_MS);
+    timer.unref?.();
+    const finish = (error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (error) reject(error);
+      else resolvePromise();
+    };
+    child.on("error", (err) => finish(err));
+    child.on(
+      "close",
+      (code) => finish(
+        code === 0 ? void 0 : new Error(`[catalog] dependency install failed (exit ${code}): ${output.trim()}`)
+      )
+    );
+  });
+}
+function killProcessTree(child) {
+  if (process.platform === "win32" && child.pid) {
+    const killer = spawn("taskkill.exe", ["/PID", String(child.pid), "/T", "/F"], {
+      detached: true,
+      stdio: "ignore"
+    });
+    killer.once("error", () => child.kill("SIGKILL"));
+    killer.unref();
+    return;
+  }
+  if (child.pid) {
+    try {
+      process.kill(-child.pid, "SIGKILL");
+      return;
+    } catch {
+    }
+  }
+  child.kill("SIGKILL");
+}
+// src/live/gilde-npm.ts
+import { createHash as createHash2 } from "crypto";
+import { createReadStream as createReadStream2 } from "fs";
+import { mkdir as mkdir2, rm as rm2 } from "fs/promises";
+import { join as join6 } from "path";
+import { HttpStatusError as HttpStatusError2, retryTransient as retryTransient2 } from "@bendyline/gezel";
+var GILDE_PACKAGE_NAME = "@bendyline/gilde";
+var MAX_PACKUMENT_BYTES2 = 5 * 1024 * 1024;
+var REGISTRY_TIMEOUT_MS2 = 3e4;
+var NETWORK_ATTEMPTS2 = 3;
+var PACKUMENT_ACCEPT = "application/vnd.npm.install-v1+json, application/json;q=0.9";
+var RELEASE_VERSION_RE = /^\d+\.\d+\.\d+$/;
+async function fetchGildeReleases(opts = {}) {
+  const registry = validateRegistry(opts.registry ?? DEFAULT_NPM_REGISTRY);
+  return retryTransient2(() => fetchReleasesOnce(registry), {
+    attempts: NETWORK_ATTEMPTS2,
+    label: `${GILDE_PACKAGE_NAME} metadata`
+  });
+}
+async function fetchReleasesOnce(registry) {
+  const url = new URL(encodePackumentPath(GILDE_PACKAGE_NAME), registry);
+  const { response, dispose } = await fetchSameOrigin(url, registry.origin, REGISTRY_TIMEOUT_MS2, {
+    accept: PACKUMENT_ACCEPT
+  });
+  try {
+    if (!response.ok) {
+      throw new HttpStatusError2(
+        response.status,
+        `[catalog] registry returned HTTP ${response.status}`
+      );
+    }
+    const raw = await readBoundedBody(response, MAX_PACKUMENT_BYTES2);
+    let packument;
+    try {
+      packument = JSON.parse(new TextDecoder().decode(raw));
+    } catch {
+      throw new Error("[catalog] registry returned malformed package metadata");
+    }
+    const releases = [];
+    for (const [version, info] of Object.entries(packument.versions ?? {})) {
+      if (!RELEASE_VERSION_RE.test(version)) continue;
+      const tarball = info?.dist?.tarball;
+      if (typeof tarball !== "string" || tarball.length === 0) continue;
+      let parsed;
+      try {
+        parsed = new URL(tarball, registry);
+      } catch {
+        continue;
+      }
+      if (parsed.origin !== registry.origin) continue;
+      releases.push({
+        version,
+        tarballUrl: parsed.href,
+        integrity: typeof info?.dist?.integrity === "string" ? info.dist.integrity : void 0,
+        shasum: typeof info?.dist?.shasum === "string" ? info.dist.shasum : void 0
+      });
+    }
+    return releases;
+  } finally {
+    dispose();
+  }
+}
+function pickGildePatchUpdate(releases, bundledPin, currentLive) {
+  if (!RELEASE_VERSION_RE.test(bundledPin)) return null;
+  const [pinMajor, pinMinor] = bundledPin.split(".");
+  const floor = currentLive && RELEASE_VERSION_RE.test(currentLive) && compareRelease(currentLive, bundledPin) > 0 ? currentLive : bundledPin;
+  let best = null;
+  for (const release of releases) {
+    if (!RELEASE_VERSION_RE.test(release.version)) continue;
+    const [major, minor] = release.version.split(".");
+    if (major !== pinMajor || minor !== pinMinor) continue;
+    if (compareRelease(release.version, floor) <= 0) continue;
+    if (!best || compareRelease(release.version, best.version) > 0) best = release;
+  }
+  return best;
+}
+function compareRelease(a, b) {
+  const pa = a.split(".").map((n) => Number.parseInt(n, 10));
+  const pb = b.split(".").map((n) => Number.parseInt(n, 10));
+  for (let i = 0; i < 3; i++) {
+    const diff = (pa[i] ?? 0) - (pb[i] ?? 0);
+    if (diff !== 0) return diff;
+  }
+  return 0;
+}
+function isGildeReleaseVersion(v) {
+  return RELEASE_VERSION_RE.test(v);
+}
+async function stageGildeVersion(opts) {
+  const registry = validateRegistry(opts.registry ?? DEFAULT_NPM_REGISTRY);
+  const { release } = opts;
+  assertVerifiable(release);
+  await mkdir2(opts.stagingDir, { recursive: true });
+  const tarballPath = join6(opts.stagingDir, "package.tgz");
+  try {
+    await retryTransient2(() => downloadTarball(release.tarballUrl, tarballPath, registry.origin), {
+      attempts: NETWORK_ATTEMPTS2,
+      label: `${GILDE_PACKAGE_NAME}@${release.version} tarball`
+    });
+    await verifyReleaseIntegrity(tarballPath, release);
+    const packageDir = await extractNpmPackageTarball({
+      tarballPath,
+      destination: opts.stagingDir,
+      expectedName: GILDE_PACKAGE_NAME,
+      expectedVersion: release.version
+    });
+    return { packageDir };
+  } finally {
+    await rm2(tarballPath, { force: true }).catch(() => {
+    });
+  }
+}
+function assertVerifiable(release) {
+  if (parseSha512Sri(release.integrity)) return;
+  if (release.shasum && /^[0-9a-f]{40}$/i.test(release.shasum)) return;
+  throw new Error(
+    `[catalog] registry metadata for ${GILDE_PACKAGE_NAME}@${release.version} carries no usable integrity hash; refusing to download`
+  );
+}
+async function verifyReleaseIntegrity(tarballPath, release) {
+  const sri = parseSha512Sri(release.integrity);
+  if (sri) {
+    const actual = await hashFile(tarballPath, "sha512", "base64");
+    if (actual !== sri) {
+      throw new Error(
+        `[catalog] sha512 integrity mismatch for ${GILDE_PACKAGE_NAME}@${release.version}; refusing to install`
+      );
+    }
+    return;
+  }
+  const shasum = release.shasum?.toLowerCase();
+  if (shasum && /^[0-9a-f]{40}$/.test(shasum)) {
+    const actual = await hashFile(tarballPath, "sha1", "hex");
+    if (actual !== shasum) {
+      throw new Error(
+        `[catalog] sha1 shasum mismatch for ${GILDE_PACKAGE_NAME}@${release.version}; refusing to install`
+      );
+    }
+    return;
+  }
+  throw new Error(
+    `[catalog] registry metadata for ${GILDE_PACKAGE_NAME}@${release.version} carries no usable integrity hash; refusing to install`
+  );
+}
+function parseSha512Sri(integrity) {
+  if (!integrity) return null;
+  for (const entry of integrity.trim().split(/\s+/)) {
+    if (entry.startsWith("sha512-") && entry.length > "sha512-".length) {
+      return entry.slice("sha512-".length);
+    }
+  }
+  return null;
+}
+async function hashFile(path, algorithm, encoding) {
+  const hash = createHash2(algorithm);
+  for await (const chunk of createReadStream2(path)) hash.update(chunk);
+  return hash.digest(encoding);
+}
+// src/live/validate.ts
+import { join as join7 } from "path";
+var MAX_REPORTED_REGRESSIONS = 25;
+async function validateGildeContentUpgrade(opts) {
+  const gezelVersion = opts.gezelVersion;
+  const versionOpt = gezelVersion !== void 0 ? { gezelVersion } : {};
+  const currentBundled = new BundledSource({ dataDir: opts.currentDataDir, ...versionOpt });
+  const current = new CatalogService([
+    currentBundled,
+    new CommunitySource(join7(opts.currentDataDir, "community"), gezelVersion)
+  ]);
+  const candidate = new CatalogService([
+    new BundledSource({ dataDir: opts.candidateDataDir, ...versionOpt }),
+    new CommunitySource(join7(opts.candidateDataDir, "community"), gezelVersion)
+  ]);
+  const kinds = await currentBundled.listKinds();
+  const regressions = [];
+  let checked = 0;
+  for (const kind of kinds) {
+    const items = await current.list(kind);
+    for (const item of items) {
+      checked += 1;
+      const resolved = await candidate.get(kind, item.manifest.id).catch(() => null);
+      if (!resolved) {
+        regressions.push({ kind, id: item.manifest.id });
+        if (regressions.length >= MAX_REPORTED_REGRESSIONS) {
+          return { ok: false, regressions };
+        }
+      }
+    }
+  }
+  if (regressions.length > 0) return { ok: false, regressions };
+  return { ok: true, checked };
+}
+// src/hf-api.ts
+var HF_HUB_BASE = "https://huggingface.co";
+async function fetchHuggingfaceTree(repo, opts = {}) {
+  const rev = opts.rev ?? "main";
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const out = [];
+  await walk(repo, rev, "", out, fetchImpl);
+  return out;
+}
+async function fetchHuggingfaceCommit(repo, opts = {}) {
+  const rev = opts.rev ?? "main";
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const url = `${HF_HUB_BASE}/api/models/${repo}/revision/${encodeURIComponent(rev)}`;
+  const res = await fetchImpl(url);
+  if (!res.ok) {
+    throw new Error(`[hf] commit resolve ${url} failed: ${res.status} ${res.statusText}`);
+  }
+  const body = await res.json();
+  if (!body.sha || !/^[0-9a-f]{40}$/.test(body.sha)) {
+    throw new Error(`[hf] commit resolve ${url} returned no valid sha (got ${String(body.sha)})`);
+  }
+  return body.sha;
+}
+async function walk(repo, rev, subpath, out, fetchImpl) {
+  const url = `${HF_HUB_BASE}/api/models/${repo}/tree/${rev}${subpath ? `/${subpath}` : ""}`;
+  const res = await fetchImpl(url);
+  if (!res.ok) {
+    throw new Error(`[hf] tree fetch ${url} failed: ${res.status} ${res.statusText}`);
+  }
+  const entries = await res.json();
+  for (const e of entries) {
+    if (e.type === "directory") {
+      await walk(repo, rev, e.path, out, fetchImpl);
+      continue;
+    }
+    if (e.type !== "file") continue;
+    const lfsOid = e.lfs?.oid;
+    const sha256 = lfsOid ?? e.oid ?? "";
+    if (!sha256) continue;
+    out.push({
+      path: e.path,
+      sizeBytes: e.size ?? 0,
+      sha256,
+      lfsBacked: Boolean(lfsOid)
+    });
+  }
+}
+function totalSize(files) {
+  return files.reduce((sum, f) => sum + f.sizeBytes, 0);
+}
+function selectMlxInstallFiles(files) {
+  const KEEP = (path) => {
+    if (/\.safetensors(\.index\.json)?$/.test(path)) return true;
+    if (/^(?:config|generation_config|preprocessor_config|processor_config|video_preprocessor_config|tokenizer_config|special_tokens_map)\.json$/.test(
+      path
+    ))
+      return true;
+    if (path === "tokenizer.json") return true;
+    if (path === "tokenizer.model") return true;
+    if (path === "vocab.json") return true;
+    if (path === "merges.txt") return true;
+    if (path === "chat_template.jinja") return true;
+    return false;
+  };
+  return files.filter((f) => KEEP(f.path));
+}
+export {
+  BUILTIN_TOOLSETS,
+  BUILTIN_TOOL_TO_GROUP,
+  BuiltinToolsetsSource,
+  BundledSource,
+  CatalogService,
+  CommunitySource,
+  GILDE_PACKAGE_NAME,
+  LocalCatalogSource,
+  builtinCatalogId,
+  categorizeToolset,
+  compareRelease,
+  extractNpmPackageTarball,
+  fetchGildeReleases,
+  fetchHuggingfaceCommit,
+  fetchHuggingfaceTree,
+  getBuiltinToolset,
+  gildeDataDir,
+  gildePackageRoot,
+  installNpmPackageToolset,
+  isGildeReleaseVersion,
+  pickGildePatchUpdate,
+  publishStagedNpmInstall,
+  recoverInterruptedNpmInstall,
+  selectMlxInstallFiles,
+  stageGildeVersion,
+  totalSize,
+  validateGildeContentUpgrade,
+  validateNpmArchiveEntry,
+  verifyTarballSha256
+};