@bendyline/gezel-catalog 1.0.6 → 1.0.7

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import { CatalogKind, CatalogItemSummary, CatalogItemDetail, CatalogItemVersionInfo, CraftbookTestSpec, ToolsetCategory, ToolsetManifest } from '@bendyline/gezel';
+import { z } from 'zod';
 
 /**
  * ─ CatalogSource ───────────────────────────────────────────────────
@@ -43,7 +44,7 @@ interface CatalogSource {
     readItemFile(kind: CatalogKind, id: string, relPath: string, version?: string): Promise<Buffer | null>;
     /**
      * Optional: every file under an item's folder as item-relative paths. Only
-     * on-disk sources implement it (used by the `.gzl` exporter); synthetic
+     * on-disk sources implement it (used by the `.gezapp` exporter); synthetic
      * sources (builtin toolsets) omit it.
      */
     listItemFiles?(kind: CatalogKind, id: string): Promise<string[]>;
@@ -122,7 +123,7 @@ declare class BundledSource implements CatalogSource {
     /**
      * 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
+     * by the `.gezapp` 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.
@@ -172,9 +173,11 @@ declare class BundledSource implements CatalogSource {
  *
  *   1. BuiltinToolsetsSource — synthetic groups for our in-process MCP
  *      server. Tools we ship and own.
- *   2. BundledSource — pre-reviewed third-party catalog shipped with
+ *   2. InstalledAiAppsSource — active `.gezapp` packages mounted as units.
+ *   3. LocalCatalogSource — manually authored/imported user content.
+ *   4. BundledSource — pre-reviewed third-party catalog shipped with
  *      the app (`data/`). Hand-curated.
- *   3. CommunitySource — auto-imported entries from the upstream MCP
+ *   5. CommunitySource — auto-imported entries from the upstream MCP
  *      registry (`data/community/`). Permissively-licensed only;
  *      treated as a second tier that the UI can label distinctly.
  *
@@ -185,9 +188,9 @@ declare class CatalogService {
     private readonly 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.localRoot a GEZEL_HOME to read user-installed catalog items and
+     *   mounted `.gezapp` packages from. Both sit ahead of the bundled tier so a
+     *   user's installed 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
@@ -217,7 +220,7 @@ declare class CatalogService {
         label: string;
     }>;
     /**
-     * Merged listing across sources. Items from earlier sources (bundled)
+     * Merged listing across sources. Items from earlier sources
      * shadow later sources (remote) on id collision.
      */
     list(kind: CatalogKind): Promise<CatalogItemSummary[]>;
@@ -288,6 +291,29 @@ declare class LocalCatalogSource extends BundledSource {
     listItemFiles(kind: CatalogKind, id: string): Promise<string[]>;
 }
 
+/**
+ * Dynamic catalog source over the active `.gezapp` registry. Package versions
+ * stay mounted as units under `~/.gezel/ai-apps/`; the importer never flattens
+ * their files into the generic local catalog, so provenance and uninstall
+ * remain tractable.
+ */
+declare class InstalledAiAppsSource implements CatalogSource {
+    private readonly home;
+    private readonly gezelVersion?;
+    readonly id = "installed-ai-apps";
+    readonly label = "AI Apps";
+    constructor(home: string, gezelVersion?: string | undefined);
+    listKinds(): Promise<CatalogKind[]>;
+    list(kind: CatalogKind): Promise<CatalogItemSummary[]>;
+    get(kind: CatalogKind, id: string, version?: string): Promise<CatalogItemDetail | null>;
+    listVersions(kind: CatalogKind, id: string): Promise<CatalogItemVersionInfo[]>;
+    readItemFile(kind: CatalogKind, id: string, relPath: string, version?: string): Promise<Buffer | null>;
+    listItemFiles(kind: CatalogKind, id: string): Promise<string[]>;
+    private registry;
+    private sources;
+    private rescope;
+}
+
 /**
  * Categorize a toolset by its identity-manifest fields. The order of
  * checks matches the priority order of `RULES` above.
@@ -304,6 +330,42 @@ declare function categorizeToolset(input: {
     maintainerName?: string;
 }): ToolsetCategory;
 
+/**
+ * The gilde `schemas/` payload, defined once and consumed twice: the
+ * `export-gilde-schemas` script writes it into a gilde checkout, and
+ * `gilde-schema-freshness.test.ts` diffs it against the gilde this build
+ * actually resolves.
+ *
+ * The two consumers resolve gilde differently on purpose. The script
+ * writes to the sibling checkout (`GILDE_DIR`) because that is what you
+ * PR; the test reads the RESOLVED package (`gildePackageRoot()`) because
+ * that is what gezel ships against. With `pnpm link:gilde` they are the
+ * same tree; without it, the test is checking the pinned tarball.
+ *
+ * Why the test exists: gilde's `build-index` normalizes every manifest
+ * through these committed JSON Schemas, and a property the schema does
+ * not declare is dropped from the published `index.json` — which is the
+ * fast path `BundledSource` reads at runtime. So a core schema field
+ * added without re-exporting does not fail anywhere; it is silently
+ * erased from shipped content. Three craftbooks were shipping that way
+ * (`pull-request-review` lost `corpusCoverage.artifact`,
+ * `powerpoint-deck` lost `markdownHeadingsMatch.outlineArtifact`,
+ * `invoice-run` lost `spawn.overArtifact`) before anyone noticed.
+ */
+
+/**
+ * `unrepresentable` stays at its default ('throw') so a future transform
+ * in a published schema fails loudly here instead of silently weakening
+ * gilde validation.
+ */
+declare function renderSchema(filename: string, schema: z.ZodType): string;
+/**
+ * Every file the gilde `schemas/` directory should contain, as exact
+ * file contents. Byte-for-byte what the exporter writes, so a test can
+ * compare against the committed copies without reimplementing anything.
+ */
+declare function renderGildeSchemaFiles(): Array<[filename: string, content: string]>;
+
 /**
  * ─ Built-in toolsets ────────────────────────────────────────────────
  *
@@ -560,4 +622,4 @@ declare function totalSize(files: ReadonlyArray<HfFileEntry>): number;
  */
 declare function selectMlxInstallFiles(files: ReadonlyArray<HfFileEntry>): HfFileEntry[];
 
-export { BUILTIN_TOOLSETS, BUILTIN_TOOL_TO_GROUP, type BuiltinToolsetGroup, BuiltinToolsetsSource, BundledSource, type BundledSourceOptions, CatalogService, type CatalogSource, CommunitySource, type FetchTreeOptions, GILDE_PACKAGE_NAME, type GildeContentRegression, type GildeContentValidation, type GildeReleaseInfo, type HfFileEntry, LocalCatalogSource, builtinCatalogId, categorizeToolset, compareRelease, extractNpmPackageTarball, fetchGildeReleases, fetchHuggingfaceCommit, fetchHuggingfaceTree, getBuiltinToolset, gildeDataDir, gildePackageRoot, installNpmPackageToolset, isGildeReleaseVersion, pickGildePatchUpdate, publishStagedNpmInstall, recoverInterruptedNpmInstall, selectMlxInstallFiles, stageGildeVersion, totalSize, validateGildeContentUpgrade, validateNpmArchiveEntry, verifyTarballSha256 };
+export { BUILTIN_TOOLSETS, BUILTIN_TOOL_TO_GROUP, type BuiltinToolsetGroup, BuiltinToolsetsSource, BundledSource, type BundledSourceOptions, CatalogService, type CatalogSource, CommunitySource, type FetchTreeOptions, GILDE_PACKAGE_NAME, type GildeContentRegression, type GildeContentValidation, type GildeReleaseInfo, type HfFileEntry, InstalledAiAppsSource, LocalCatalogSource, builtinCatalogId, categorizeToolset, compareRelease, extractNpmPackageTarball, fetchGildeReleases, fetchHuggingfaceCommit, fetchHuggingfaceTree, getBuiltinToolset, gildeDataDir, gildePackageRoot, installNpmPackageToolset, isGildeReleaseVersion, pickGildePatchUpdate, publishStagedNpmInstall, recoverInterruptedNpmInstall, renderGildeSchemaFiles, renderSchema, selectMlxInstallFiles, stageGildeVersion, totalSize, validateGildeContentUpgrade, validateNpmArchiveEntry, verifyTarballSha256 };

package/dist/index.js

@@ -33,6 +33,8 @@ var BUILTIN_TOOLSET_ICONS = {
   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>`,
+  // A closed shipping box — a packaged app bundle.
+  "ai-apps": `<svg ${SVG_ATTRS}><path d="M21 8L12 3 3 8v8l9 5 9-5V8z"/><path d="M3 8l9 5 9-5"/><path d="M7.5 5.5l9 5"/></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.
@@ -61,8 +63,8 @@ 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"]
+    description: "Search indexed project knowledge through one unified surface, plus persistent notes a gezel can recall and write back. The generic search spans workspace content, artifacts, project/gezel memory, and shared documents.",
+    tools: ["search", "search_memory", "save_memory", "list_memories"]
   },
   {
     id: "workspace-fs-read",
@@ -168,6 +170,12 @@ var BUILTIN_TOOLSETS = [
     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: "data-tables",
+    name: "Data Tables",
+    description: "Read a project's mirrored data tables with SQL. `list_tables` shows what is there, `describe_table` explains a table's columns and units, and `query_table` runs one read-only query and returns the answer \u2014 never the underlying rows, which is what lets a table be far larger than the context window.",
+    tools: ["list_tables", "describe_table", "query_table"]
+  },
   {
     id: "tasks",
     name: "Task Management",
@@ -243,8 +251,6 @@ var BUILTIN_TOOLSETS = [
       "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",
@@ -253,6 +259,12 @@ var BUILTIN_TOOLSETS = [
       "disable_suggested_work"
     ]
   },
+  {
+    id: "ai-apps",
+    name: "AI Apps",
+    description: "Package a configured project into a shareable .gezapp bundle and install one back. Deliberately in no role default: this is a distribution chore the user drives from Settings or the `gezel app` CLI, not something a gezel reaches for mid-conversation. Install it on a gezel whose actual job is publishing app bundles.",
+    tools: ["export_ai_app", "import_ai_app"]
+  },
   {
     id: "audio",
     name: "Audio",
@@ -303,8 +315,14 @@ var BUILTIN_TOOLSETS = [
   {
     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"]
+    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` / `wikipedia_read` only register for non-cloud models (cloud models already have Wikipedia in training). Wikipedia search results arrive with article lead text already included, so reading a result does not need a follow-up fetch.",
+    tools: [
+      "web_search",
+      "wikipedia_search",
+      "wikipedia_read",
+      "fetch_url",
+      "browser_find_page_element"
+    ]
   },
   {
     id: "images",
@@ -718,7 +736,7 @@ var BundledSource = class {
   /**
    * 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
+   * by the `.gezapp` 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.
@@ -1005,6 +1023,7 @@ function craftbookManifestFromDoc(identity, doc, version, availableVersions) {
     version,
     releasedAt: doc.releasedAt,
     role: identity.role,
+    ...identity.category ? { category: identity.category } : {},
     ...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.
@@ -1020,11 +1039,15 @@ function craftbookManifestFromDoc(identity, doc, version, availableVersions) {
     ...doc.paramSchema ? { paramSchema: doc.paramSchema } : {},
     ...doc.command ? { command: doc.command } : {},
     ...doc.requirements ? { requirements: doc.requirements } : {},
+    ...doc.recommends ? { recommends: doc.recommends } : {},
     ...doc.runModes ? { runModes: doc.runModes } : {},
     ...doc.toolsets ? { toolsets: doc.toolsets } : {},
+    ...doc.commands ? { commands: doc.commands } : {},
     ...doc.connectors ? { connectors: doc.connectors } : {},
     ...doc.hooks ? { hooks: doc.hooks } : {},
     ...doc.spawn ? { spawn: doc.spawn } : {},
+    ...doc.diffpackCapable ? { diffpackCapable: true } : {},
+    ...doc.capabilityFloor ? { capabilityFloor: doc.capabilityFloor } : {},
     availableVersions
   };
 }
@@ -1111,6 +1134,7 @@ function mergeIdentityAndVersion(kind, identity, version, availableVersions) {
       version: version.version,
       releasedAt: version.releasedAt,
       role: identity.role,
+      ...identity.category ? { category: identity.category } : {},
       ...identity.workflow ? { workflow: identity.workflow } : {},
       about: version.about,
       steps: version.steps,
@@ -1125,6 +1149,7 @@ function mergeIdentityAndVersion(kind, identity, version, availableVersions) {
       ...version.paramSchema ? { paramSchema: version.paramSchema } : {},
       ...version.command ? { command: version.command } : {},
       ...version.requirements ? { requirements: version.requirements } : {},
+      ...version.recommends ? { recommends: version.recommends } : {},
       ...version.runModes ? { runModes: version.runModes } : {},
       ...version.toolsets ? { toolsets: version.toolsets } : {},
       ...version.connectors ? { connectors: version.connectors } : {},
@@ -1364,6 +1389,108 @@ var CommunitySource = class extends BundledSource {
   }
 };
 
+// src/installed-ai-apps-source.ts
+import { readFile as readFile2 } from "fs/promises";
+import { GezappRegistrySchema } from "@bendyline/gezel";
+import { aiAppItemsDir, aiAppsRegistryFile } from "@bendyline/gezel/paths";
+var AI_APP_KINDS = /* @__PURE__ */ new Set([
+  "project-type",
+  "gezel-template",
+  "craftbook-template"
+]);
+var InstalledAiAppsSource = class {
+  constructor(home, gezelVersion) {
+    this.home = home;
+    this.gezelVersion = gezelVersion;
+  }
+  home;
+  gezelVersion;
+  id = "installed-ai-apps";
+  label = "AI Apps";
+  async listKinds() {
+    return [...AI_APP_KINDS];
+  }
+  async list(kind) {
+    if (!AI_APP_KINDS.has(kind)) return [];
+    const seen = /* @__PURE__ */ new Set();
+    const out = [];
+    for (const source of await this.sources()) {
+      for (const item of await source.list(kind)) {
+        if (seen.has(item.manifest.id)) continue;
+        seen.add(item.manifest.id);
+        out.push(this.rescope(item));
+      }
+    }
+    out.sort((a, b) => a.manifest.name.localeCompare(b.manifest.name));
+    return out;
+  }
+  async get(kind, id, version) {
+    if (!AI_APP_KINDS.has(kind)) return null;
+    for (const source of await this.sources()) {
+      const item = await source.get(kind, id, version);
+      if (item) return this.rescope(item);
+    }
+    return null;
+  }
+  async listVersions(kind, id) {
+    if (!AI_APP_KINDS.has(kind)) return [];
+    const byVersion = /* @__PURE__ */ new Map();
+    for (const source of await this.sources()) {
+      for (const version of await source.listVersions(kind, id)) {
+        if (!byVersion.has(version.version)) byVersion.set(version.version, version);
+      }
+    }
+    return [...byVersion.values()];
+  }
+  async readItemFile(kind, id, relPath, version) {
+    if (!AI_APP_KINDS.has(kind)) return null;
+    for (const source of await this.sources()) {
+      const content = await source.readItemFile(kind, id, relPath, version);
+      if (content) return content;
+    }
+    return null;
+  }
+  async listItemFiles(kind, id) {
+    if (!AI_APP_KINDS.has(kind)) return [];
+    for (const source of await this.sources()) {
+      const files = await source.listItemFiles(kind, id);
+      if (files.length > 0) return files;
+    }
+    return [];
+  }
+  async registry() {
+    try {
+      return GezappRegistrySchema.parse(
+        JSON.parse(await readFile2(aiAppsRegistryFile(this.home), "utf8"))
+      );
+    } catch {
+      return { schemaVersion: 1, apps: [] };
+    }
+  }
+  async sources() {
+    const registry = await this.registry();
+    return registry.apps.filter((entry) => entry.enabled).map(
+      (entry) => new BundledSource({
+        dataDir: aiAppItemsDir(this.home, entry.appId, entry.version),
+        id: `gezapp:${entry.appId}@${entry.version}`,
+        label: this.label,
+        noIndex: true,
+        ...this.gezelVersion !== void 0 ? { gezelVersion: this.gezelVersion } : {}
+      })
+    );
+  }
+  rescope(item) {
+    const { logoUrl: _ignored, ...rest } = item;
+    const logo = item.manifest.logo;
+    const logoUrl = logo && /^https?:\/\//.test(logo) ? logo : logo ? `/api/catalog/${item.kind}/${encodeURIComponent(item.manifest.id)}/file/${encodeURIComponent(logo)}?source=${encodeURIComponent(this.id)}` : void 0;
+    return {
+      ...rest,
+      sourceId: this.id,
+      ...logoUrl ? { logoUrl } : {}
+    };
+  }
+};
+
 // src/local-source.ts
 var LOCAL_KINDS = /* @__PURE__ */ new Set([
   "project-type",
@@ -1412,9 +1539,9 @@ var CatalogService = class {
   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.localRoot a GEZEL_HOME to read user-installed catalog items and
+   *   mounted `.gezapp` packages from. Both sit ahead of the bundled tier so a
+   *   user's installed 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
@@ -1435,8 +1562,10 @@ var CatalogService = class {
     const contentRoot = opts?.contentRoot;
     const gezelVersion = opts?.gezelVersion;
     const local = opts?.localRoot ? [new LocalCatalogSource(opts.localRoot, gezelVersion)] : [];
+    const aiApps = opts?.localRoot ? [new InstalledAiAppsSource(opts.localRoot, gezelVersion)] : [];
     this.sources = [
       new BuiltinToolsetsSource(),
+      ...aiApps,
       ...local,
       new BundledSource({
         ...contentRoot ? { dataDir: contentRoot } : {},
@@ -1462,7 +1591,7 @@ var CatalogService = class {
     return this.sources.map((s) => ({ id: s.id, label: s.label }));
   }
   /**
-   * Merged listing across sources. Items from earlier sources (bundled)
+   * Merged listing across sources. Items from earlier sources
    * shadow later sources (remote) on id collision.
    */
   async list(kind) {
@@ -1833,11 +1962,114 @@ function categorizeToolset(input) {
   return "other";
 }
 
+// src/gilde-schema-export.ts
+import {
+  ChatModelIdentitySchema,
+  ChatModelVersionManifestSchema as ChatModelVersionManifestSchema2,
+  ConnectorTypeIdentitySchema,
+  ConnectorTypeVersionManifestSchema as ConnectorTypeVersionManifestSchema2,
+  CraftbookDocSchema,
+  CraftbookTemplateIdentitySchema,
+  CraftbookTemplateVersionManifestSchema as CraftbookTemplateVersionManifestSchema2,
+  CraftbookTestSpecSchema,
+  GezelTemplateIdentitySchema,
+  GezelTemplateVersionManifestSchema as GezelTemplateVersionManifestSchema2,
+  ImageModelIdentitySchema,
+  ImageModelVersionManifestSchema as ImageModelVersionManifestSchema2,
+  ProjectTypeIdentitySchema,
+  ProjectTypeVersionManifestSchema as ProjectTypeVersionManifestSchema2,
+  ToolsetIdentitySchema,
+  ToolsetVersionManifestSchema as ToolsetVersionManifestSchema2,
+  VideoModelIdentitySchema,
+  VideoModelVersionManifestSchema as VideoModelVersionManifestSchema2
+} from "@bendyline/gezel";
+import { z } from "zod";
+var GILDE_SCHEMA_EXPORTS = [
+  ["toolset-identity.schema.json", ToolsetIdentitySchema],
+  ["toolset-version.schema.json", ToolsetVersionManifestSchema2],
+  ["gezel-template-identity.schema.json", GezelTemplateIdentitySchema],
+  ["gezel-template-version.schema.json", GezelTemplateVersionManifestSchema2],
+  ["craftbook-template-identity.schema.json", CraftbookTemplateIdentitySchema],
+  ["craftbook-template-version.schema.json", CraftbookTemplateVersionManifestSchema2],
+  ["project-type-identity.schema.json", ProjectTypeIdentitySchema],
+  ["project-type-version.schema.json", ProjectTypeVersionManifestSchema2],
+  ["connector-type-identity.schema.json", ConnectorTypeIdentitySchema],
+  ["connector-type-version.schema.json", ConnectorTypeVersionManifestSchema2],
+  ["chat-model-identity.schema.json", ChatModelIdentitySchema],
+  ["chat-model-version.schema.json", ChatModelVersionManifestSchema2],
+  ["image-model-identity.schema.json", ImageModelIdentitySchema],
+  ["image-model-version.schema.json", ImageModelVersionManifestSchema2],
+  ["video-model-identity.schema.json", VideoModelIdentitySchema],
+  ["video-model-version.schema.json", VideoModelVersionManifestSchema2],
+  ["craftbook-doc.schema.json", CraftbookDocSchema],
+  ["craftbook-test.schema.json", CraftbookTestSpecSchema]
+];
+var CATALOG_INDEX_SCHEMA = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://gezelgilde.com/schemas/catalog-index.schema.json",
+  type: "object",
+  properties: {
+    schemaVersion: { type: "number", const: 1 },
+    kind: { type: "string" },
+    count: { type: "number", minimum: 0 },
+    entries: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          manifest: { type: "object" },
+          iconSvg: { type: "string" }
+        },
+        required: ["manifest"]
+      }
+    }
+  },
+  required: ["schemaVersion", "kind", "count", "entries"]
+};
+var GILDE_SCHEMAS_README = `# schemas/
+
+JSON Schemas for every content file in \`data/\`, consumed by
+\`tools/validate.mjs\`.
+
+**Generated \u2014 do not edit.** These are exported from the Zod schemas in
+gezel core (\`packages/core/src/schemas/\`), which remain the source of
+truth. Regenerate from a gezel checkout with:
+
+\`\`\`
+pnpm gilde:export-schemas
+\`\`\`
+
+Note: Zod refinements do not survive the export, so validation here is
+slightly looser than gezel's runtime parse. Layout and cross-reference
+rules that matter are re-implemented in \`tools/validate.mjs\`.
+`;
+function renderSchema(filename, schema) {
+  const json = z.toJSONSchema(schema, { target: "draft-2020-12", io: "input" });
+  const withId = {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $id: `https://gezelgilde.com/schemas/${filename}`,
+    ...json
+  };
+  withId.$schema = "https://json-schema.org/draft/2020-12/schema";
+  return `${JSON.stringify(withId, null, 2)}
+`;
+}
+function renderGildeSchemaFiles() {
+  return [
+    ...GILDE_SCHEMA_EXPORTS.map(
+      ([filename, schema]) => [filename, renderSchema(filename, schema)]
+    ),
+    ["catalog-index.schema.json", `${JSON.stringify(CATALOG_INDEX_SCHEMA, null, 2)}
+`],
+    ["README.md", GILDE_SCHEMAS_README]
+  ];
+}
+
 // 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 { mkdir, open, readFile as readFile3, realpath, rename, rm, stat, writeFile } from "fs/promises";
 import { dirname as dirname2, isAbsolute, join as join5, relative, resolve } from "path";
 import {
   HttpStatusError,
@@ -2046,7 +2278,7 @@ function validateNpmArchiveEntry(path, type) {
   }
 }
 async function validateExtractedPackage(packageDir, expectedName, expectedVersion) {
-  const raw = await readFile2(join5(packageDir, "package.json"), "utf8");
+  const raw = await readFile3(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");
@@ -2490,6 +2722,7 @@ export {
   CatalogService,
   CommunitySource,
   GILDE_PACKAGE_NAME,
+  InstalledAiAppsSource,
   LocalCatalogSource,
   builtinCatalogId,
   categorizeToolset,
@@ -2506,6 +2739,8 @@ export {
   pickGildePatchUpdate,
   publishStagedNpmInstall,
   recoverInterruptedNpmInstall,
+  renderGildeSchemaFiles,
+  renderSchema,
   selectMlxInstallFiles,
   stageGildeVersion,
   totalSize,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bendyline/gezel-catalog",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "Gezel catalog loader: sources, install pipeline, and authoring scripts over the external @bendyline/gilde content package.",
   "license": "MIT",
   "keywords": [
@@ -47,8 +47,8 @@
     "!dist/**/*.map"
   ],
   "dependencies": {
-    "@bendyline/gezel": "1.0.6",
-    "@bendyline/gilde": "0.1.36",
+    "@bendyline/gezel": "1.0.7",
+    "@bendyline/gilde": "0.1.51",
     "tar": "7.5.21",
     "zod": "^4.4.3"
   },