@skaile/workspaces 0.8.5

package/dist/chunk-46T37EBP.js

@@ -0,0 +1,1517 @@
+import { AssetKindRegistryFrozenError, AssetKindConflictError, AssetKindPatternConflictError, AssetKindPathAmbiguityError } from './chunk-OKRUTSG7.js';
+import { parseFrontmatter } from './chunk-BVHFSUFM.js';
+import { validatePersona, validateRuleset, validateSkill, validateAgent, validateConnector, validateMount, validateMcpServer, validateContract, validatePrompt, validatePreset } from './chunk-Z3RER6YZ.js';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as z from 'zod';
+import * as yaml from 'js-yaml';
+import * as crypto from 'crypto';
+
+// discovery/src/asset-kind-registry.ts
+var AssetKindRegistry = class {
+  providers = /* @__PURE__ */ new Map();
+  patternOwnership = /* @__PURE__ */ new Map();
+  // pattern -> kind
+  _frozen = false;
+  get frozen() {
+    return this._frozen;
+  }
+  // -------------------------------------------------------------------------
+  // Registration (open state only)
+  // -------------------------------------------------------------------------
+  register(provider) {
+    if (this._frozen) {
+      throw new AssetKindRegistryFrozenError();
+    }
+    if (this.providers.has(provider.kind)) {
+      throw new AssetKindConflictError(provider.kind);
+    }
+    for (const pattern of provider.discoveryPatterns) {
+      const existingOwner = this.patternOwnership.get(pattern);
+      if (existingOwner) {
+        throw new AssetKindPatternConflictError(provider.kind, existingOwner, pattern);
+      }
+    }
+    this.providers.set(provider.kind, provider);
+    for (const pattern of provider.discoveryPatterns) {
+      this.patternOwnership.set(pattern, provider.kind);
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Freeze
+  // -------------------------------------------------------------------------
+  freeze() {
+    this._frozen = true;
+  }
+  // -------------------------------------------------------------------------
+  // Read operations (auto-freeze)
+  // -------------------------------------------------------------------------
+  getProvider(kind) {
+    this.autoFreeze();
+    return this.providers.get(kind);
+  }
+  getAllProviders() {
+    this.autoFreeze();
+    return [...this.providers.values()];
+  }
+  getAllKinds() {
+    this.autoFreeze();
+    return [...this.providers.keys()];
+  }
+  resolveKind(relativePath) {
+    this.autoFreeze();
+    const matches = [];
+    for (const provider of this.providers.values()) {
+      if (provider.matchesPath(relativePath)) {
+        matches.push(provider.kind);
+      }
+    }
+    if (matches.length === 0) return void 0;
+    if (matches.length === 1) return matches[0];
+    throw new AssetKindPathAmbiguityError(relativePath, matches);
+  }
+  // -------------------------------------------------------------------------
+  // Convenience delegates
+  // -------------------------------------------------------------------------
+  validateManifest(kind, data) {
+    this.autoFreeze();
+    const provider = this.providers.get(kind);
+    if (!provider) {
+      return {
+        ok: false,
+        errors: [
+          {
+            path: "kind",
+            message: `No provider registered for kind "${kind}"`
+          }
+        ]
+      };
+    }
+    return provider.validateManifest(data);
+  }
+  defaultFileFilter(kind, manifestPath) {
+    this.autoFreeze();
+    const provider = this.providers.get(kind);
+    if (!provider) return void 0;
+    return provider.defaultFileFilter(manifestPath);
+  }
+  extractRequires(kind, assetRef, manifest) {
+    this.autoFreeze();
+    const provider = this.providers.get(kind);
+    if (!provider?.extractRequires) return [];
+    return provider.extractRequires(assetRef, manifest);
+  }
+  // -------------------------------------------------------------------------
+  // Internal
+  // -------------------------------------------------------------------------
+  autoFreeze() {
+    if (!this._frozen) {
+      this._frozen = true;
+    }
+  }
+};
+
+// discovery/src/requires-graph.ts
+function extractRequires(assetRef, kind, manifest) {
+  const edges = [];
+  switch (kind) {
+    case "agent":
+      extractAgentRequires(assetRef, manifest, edges);
+      break;
+    case "flow":
+      extractFlowRequires(assetRef, manifest, edges);
+      break;
+    case "preset":
+      extractPresetRequires(assetRef, manifest, edges);
+      break;
+    case "skill":
+      extractSkillRequires(assetRef, manifest, edges);
+      break;
+  }
+  return edges;
+}
+function buildRequiresGraph(allEdges) {
+  const { acyclic, cyclePath } = detectCycles(allEdges);
+  return { edges: allEdges, acyclic, cyclePath };
+}
+function detectCycles(edges) {
+  if (edges.length === 0) return { acyclic: true };
+  const nodes = /* @__PURE__ */ new Set();
+  const adj = /* @__PURE__ */ new Map();
+  const inDegree = /* @__PURE__ */ new Map();
+  for (const e of edges) {
+    nodes.add(e.from);
+    nodes.add(e.to);
+    if (!adj.has(e.from)) adj.set(e.from, /* @__PURE__ */ new Set());
+    adj.get(e.from).add(e.to);
+    inDegree.set(e.to, (inDegree.get(e.to) ?? 0) + 1);
+    if (!inDegree.has(e.from)) inDegree.set(e.from, 0);
+  }
+  const queue = [];
+  for (const node of nodes) {
+    if ((inDegree.get(node) ?? 0) === 0) queue.push(node);
+  }
+  const sorted = [];
+  while (queue.length > 0) {
+    const n = queue.shift();
+    sorted.push(n);
+    for (const neighbor of adj.get(n) ?? []) {
+      const deg = inDegree.get(neighbor) - 1;
+      inDegree.set(neighbor, deg);
+      if (deg === 0) queue.push(neighbor);
+    }
+  }
+  if (sorted.length === nodes.size) {
+    return { acyclic: true };
+  }
+  const remaining = new Set([...nodes].filter((n) => !sorted.includes(n)));
+  const cyclePath = findCyclePath(remaining, adj);
+  return { acyclic: false, cyclePath };
+}
+function extractAgentRequires(ref, m, edges) {
+  if (Array.isArray(m.skills)) {
+    for (const s of m.skills) {
+      if (typeof s === "string") edges.push({ from: ref, to: s, field: "skills" });
+    }
+  }
+  if (Array.isArray(m.composes)) {
+    for (const c of m.composes) {
+      if (isObjectWithStringField(c, "ref")) {
+        edges.push({ from: ref, to: c.ref, field: "composes" });
+      }
+    }
+  }
+  if (typeof m.extends === "string") {
+    edges.push({ from: ref, to: m.extends, field: "extends" });
+  }
+}
+function extractFlowRequires(ref, m, edges) {
+  if (!Array.isArray(m.nodes)) return;
+  for (const node of m.nodes) {
+    if (isObjectWithStringField(node, "skill")) {
+      edges.push({
+        from: ref,
+        to: node.skill,
+        field: "nodes[].skill"
+      });
+    }
+  }
+}
+function extractPresetRequires(ref, m, edges) {
+  if (!Array.isArray(m.items)) return;
+  for (const item of m.items) {
+    if (typeof item !== "object" || item === null) continue;
+    const i = item;
+    if (typeof i.ref === "string" && !i.ref.startsWith("library://")) {
+      edges.push({ from: ref, to: i.ref, field: "items[].ref" });
+    }
+    if (Array.isArray(i.composes)) {
+      for (const c of i.composes) {
+        if (!isObjectWithStringField(c, "ref")) continue;
+        const cRef = c.ref;
+        if (!cRef.startsWith("#") && !cRef.startsWith("library://")) {
+          edges.push({ from: ref, to: cRef, field: "items[].composes[].ref" });
+        }
+      }
+    }
+  }
+}
+function extractSkillRequires(ref, m, edges) {
+  const metadata = m.metadata;
+  if (!metadata) return;
+  const artifacts = metadata.artifacts;
+  if (!artifacts) return;
+  if (!Array.isArray(artifacts.requires)) return;
+  for (const r of artifacts.requires) {
+    if (isObjectWithStringField(r, "id")) {
+      edges.push({
+        from: ref,
+        to: r.id,
+        field: "metadata.artifacts.requires"
+      });
+    }
+  }
+}
+function findCyclePath(nodes, adj) {
+  const visited = /* @__PURE__ */ new Set();
+  const stack = /* @__PURE__ */ new Set();
+  const path6 = [];
+  for (const start of nodes) {
+    if (visited.has(start)) continue;
+    const cycle = dfs(start, adj, visited, stack, path6, nodes);
+    if (cycle) return cycle;
+  }
+  return [...nodes];
+}
+function dfs(node, adj, visited, stack, path6, scope) {
+  visited.add(node);
+  stack.add(node);
+  path6.push(node);
+  for (const neighbor of adj.get(node) ?? []) {
+    if (!scope.has(neighbor)) continue;
+    if (stack.has(neighbor)) {
+      const cycleStart = path6.indexOf(neighbor);
+      return [...path6.slice(cycleStart), neighbor];
+    }
+    if (!visited.has(neighbor)) {
+      const result = dfs(neighbor, adj, visited, stack, path6, scope);
+      if (result) return result;
+    }
+  }
+  stack.delete(node);
+  path6.pop();
+  return null;
+}
+function isObjectWithStringField(val, field) {
+  return typeof val === "object" && val !== null && field in val && typeof val[field] === "string";
+}
+
+// discovery/src/builtin-providers.ts
+function matchesSuffix(relativePath, suffix) {
+  return relativePath.endsWith(suffix);
+}
+function matchesFilename(relativePath, filename) {
+  const parts = relativePath.split("/");
+  return parts[parts.length - 1] === filename;
+}
+function collectDirRecursive(baseDir, relativeDir) {
+  const full = path.join(baseDir, relativeDir);
+  if (!fs.existsSync(full) || !fs.statSync(full).isDirectory()) return [];
+  const results = [];
+  for (const entry of fs.readdirSync(full, { withFileTypes: true })) {
+    const rel = path.posix.join(relativeDir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...collectDirRecursive(baseDir, rel));
+    } else if (entry.isFile()) {
+      results.push(rel);
+    }
+  }
+  return results;
+}
+function manifestOnlyFilter(manifestPath) {
+  return {
+    assetRoot: path.dirname(manifestPath),
+    files: [path.basename(manifestPath)]
+  };
+}
+function skillFilter(manifestPath) {
+  const dir = path.dirname(manifestPath);
+  const manifestName = path.basename(manifestPath);
+  const files = [manifestName];
+  for (const leaf of ["validator.py", "CLI.md"]) {
+    if (fs.existsSync(path.join(dir, leaf))) files.push(leaf);
+  }
+  files.push(...collectDirRecursive(dir, "references"));
+  try {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      if (entry.isDirectory() && entry.name !== "references") {
+        if (fs.existsSync(path.join(dir, entry.name, "SKILL.md"))) {
+          files.push(...collectDirRecursive(dir, entry.name));
+        }
+      }
+    }
+  } catch {
+  }
+  files.sort();
+  return { assetRoot: dir, files };
+}
+function agentFilter(manifestPath) {
+  const dir = path.dirname(manifestPath);
+  const manifestName = path.basename(manifestPath);
+  const files = [manifestName];
+  for (const companion of ["SOUL.md", "RULES.md"]) {
+    if (fs.existsSync(path.join(dir, companion))) files.push(companion);
+  }
+  files.push(...collectDirRecursive(dir, "knowledge"));
+  files.sort();
+  return { assetRoot: dir, files };
+}
+function contractFilter(manifestPath) {
+  const dir = path.dirname(manifestPath);
+  const manifestName = path.basename(manifestPath);
+  const files = [manifestName];
+  try {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      if (entry.isFile() && entry.name !== manifestName) {
+        files.push(entry.name);
+      }
+    }
+  } catch {
+  }
+  files.sort();
+  return { assetRoot: dir, files };
+}
+function connectorFilter(manifestPath) {
+  const dir = path.dirname(manifestPath);
+  const manifestName = path.basename(manifestPath);
+  const files = [manifestName];
+  if (fs.existsSync(path.join(dir, "adapter.ts"))) files.push("adapter.ts");
+  files.sort();
+  return { assetRoot: dir, files };
+}
+function mountFilter(manifestPath) {
+  const dir = path.dirname(manifestPath);
+  const manifestName = path.basename(manifestPath);
+  const files = [manifestName];
+  if (fs.existsSync(path.join(dir, "driver.ts"))) files.push("driver.ts");
+  files.sort();
+  return { assetRoot: dir, files };
+}
+function makeProvider(config) {
+  return {
+    kind: config.kind,
+    displayName: config.displayName,
+    providerVersion: config.providerVersion,
+    discoveryPatterns: config.discoveryPatterns,
+    matchesPath: config.matchesPath,
+    validateManifest: config.validate,
+    defaultFileFilter: config.fileFilter,
+    ...config.hasExtractRequires !== false && {
+      extractRequires: (assetRef, manifest) => extractRequires(assetRef, config.kind, manifest)
+    }
+  };
+}
+var skillProvider = makeProvider({
+  kind: "skill",
+  displayName: "Skill",
+  providerVersion: "1.0.0",
+  discoveryPatterns: ["**/SKILL.md"],
+  matchesPath: (p) => matchesFilename(p, "SKILL.md"),
+  validate: validateSkill,
+  fileFilter: skillFilter,
+  hasExtractRequires: true
+});
+var agentProvider = makeProvider({
+  kind: "agent",
+  displayName: "Agent",
+  providerVersion: "1.0.0",
+  discoveryPatterns: ["**/agent.yaml", "**/AGENT.md"],
+  matchesPath: (p) => matchesFilename(p, "agent.yaml") || matchesFilename(p, "AGENT.md"),
+  validate: validateAgent,
+  fileFilter: agentFilter,
+  hasExtractRequires: true
+});
+var connectorProvider = makeProvider({
+  kind: "connector",
+  displayName: "Connector",
+  providerVersion: "1.0.0",
+  discoveryPatterns: ["**/CONNECTOR.md"],
+  matchesPath: (p) => matchesFilename(p, "CONNECTOR.md"),
+  validate: validateConnector,
+  fileFilter: connectorFilter,
+  hasExtractRequires: false
+});
+var mountProvider = makeProvider({
+  kind: "mount",
+  displayName: "Mount",
+  providerVersion: "1.0.0",
+  discoveryPatterns: ["**/MOUNT.md"],
+  matchesPath: (p) => matchesFilename(p, "MOUNT.md"),
+  validate: validateMount,
+  fileFilter: mountFilter,
+  hasExtractRequires: false
+});
+var mcpServerProvider = makeProvider({
+  kind: "mcp-server",
+  displayName: "MCP Server",
+  providerVersion: "1.0.0",
+  discoveryPatterns: ["**/MCP.md"],
+  matchesPath: (p) => matchesFilename(p, "MCP.md"),
+  validate: validateMcpServer,
+  fileFilter: manifestOnlyFilter,
+  hasExtractRequires: false
+});
+var contractProvider = makeProvider({
+  kind: "contract",
+  displayName: "Contract",
+  providerVersion: "1.0.0",
+  discoveryPatterns: ["**/CONTRACT.md"],
+  matchesPath: (p) => matchesFilename(p, "CONTRACT.md"),
+  validate: validateContract,
+  fileFilter: contractFilter,
+  hasExtractRequires: false
+});
+var promptProvider = makeProvider({
+  kind: "prompt",
+  displayName: "Prompt",
+  providerVersion: "1.0.0",
+  discoveryPatterns: ["**/*.prompt.md"],
+  matchesPath: (p) => matchesSuffix(p, ".prompt.md"),
+  validate: validatePrompt,
+  fileFilter: manifestOnlyFilter,
+  hasExtractRequires: false
+});
+var personaProvider = {
+  kind: "persona",
+  displayName: "Persona",
+  providerVersion: "1.0.0",
+  discoveryPatterns: [],
+  matchesPath: () => false,
+  validateManifest: validatePersona,
+  defaultFileFilter: manifestOnlyFilter
+};
+var rulesetProvider = {
+  kind: "ruleset",
+  displayName: "Ruleset",
+  providerVersion: "1.0.0",
+  discoveryPatterns: [],
+  matchesPath: () => false,
+  validateManifest: validateRuleset,
+  defaultFileFilter: manifestOnlyFilter
+};
+var presetProvider = makeProvider({
+  kind: "preset",
+  displayName: "Preset",
+  providerVersion: "1.0.0",
+  discoveryPatterns: ["**/*.preset.yaml"],
+  matchesPath: (p) => matchesSuffix(p, ".preset.yaml"),
+  validate: validatePreset,
+  fileFilter: manifestOnlyFilter,
+  hasExtractRequires: true
+});
+var BUILTIN_PROVIDERS = [
+  // 9 core kinds
+  skillProvider,
+  agentProvider,
+  connectorProvider,
+  mountProvider,
+  mcpServerProvider,
+  contractProvider,
+  promptProvider,
+  personaProvider,
+  rulesetProvider,
+  // Composition entity (discoverable, not in AssetKind enum)
+  presetProvider
+];
+var SEMVER_RE = /^\d+\.\d+\.\d+(?:-[a-zA-Z0-9.-]+)?(?:\+[a-zA-Z0-9.-]+)?$/;
+var PublisherOverrideSchema = z.object({
+  /** Relative path within the repo (trailing slash convention). */
+  path: z.string().min(1),
+  /** Publisher namespace override for assets under this path. */
+  publisher: z.string().regex(/^@[\w-]+$/, "Publisher must start with @ and contain only word chars / hyphens")
+});
+var SyncConfigSchema = z.object({
+  /** How the catalog backend learns about repo changes. */
+  trigger: z.enum(["webhook", "poll"]).default("webhook"),
+  /** Seconds between polls. Required when trigger=poll. */
+  poll_interval: z.number().int().positive().optional()
+}).refine((data) => data.trigger !== "poll" || data.poll_interval !== void 0, {
+  message: "poll_interval is required when trigger is poll",
+  path: ["poll_interval"]
+});
+var AssetEntrySchema = z.object({
+  /** Relative path within the repo (directory or file). */
+  path: z.string().min(1),
+  /** Asset kind — validated against `IAssetKindRegistry` at discovery time. */
+  kind: z.string().min(1),
+  /** Publisher namespace. Required per entry; overrides publisher_default / _overrides. */
+  publisher: z.string().regex(/^@[\w-]+$/, "Publisher must start with @ and contain only word chars / hyphens"),
+  /** Asset name. Identity tuple is `<publisher>/<name>@<version>`. */
+  name: z.string().min(1),
+  /** Semver version string. */
+  version: z.string().regex(SEMVER_RE, "Version must be semver MAJOR.MINOR.PATCH"),
+  /**
+   * Hex-encoded SHA256 hash of the deterministic tarball contents.
+   * Optional on write, REQUIRED on Catalog publish (Phase 4).
+   */
+  sha256: z.string().regex(/^[a-f0-9]{64}$/, "sha256 must be 64-character hex").optional(),
+  /** Curated file filter (paths relative to `path:`). At least one entry. */
+  files: z.array(z.string().min(1)).min(1),
+  /** Author-declared requires-graph entries. */
+  requires: z.array(z.string().min(1)).default([]),
+  /** Optional passthrough to `AssetDefinition.manifest`. */
+  metadata: z.record(z.unknown()).optional()
+});
+var SourceConfigSchema = z.object({
+  /** Schema version. `1` (glob mode) or `2` (allows `assets:` block). */
+  version: z.union([z.literal(1), z.literal(2)]),
+  /**
+   * Default publisher namespace template.
+   * Use `@<domain>` to derive from first-level directory name.
+   * Use a literal like `@skaile` if the entire repo maps to one publisher.
+   */
+  publisher_default: z.string().min(1).refine((v) => v.startsWith("@"), "publisher_default must start with @"),
+  /** Default git ref for version resolution. */
+  default_ref: z.string().min(1).default("main"),
+  /** Per-path publisher overrides. Evaluated in order; first match wins. */
+  publisher_overrides: z.array(PublisherOverrideSchema).default([]),
+  /** Optional sync configuration for the catalog backend. */
+  sync: SyncConfigSchema.optional(),
+  /**
+   * Optional author-shipped asset inventory. When present, discovery uses
+   * these entries verbatim and skips glob walk + AI enrichment.
+   *
+   * Requires `version: 2`.
+   */
+  assets: z.array(AssetEntrySchema).optional()
+}).refine((data) => !(data.assets && data.version !== 2), {
+  message: "`assets:` block requires version 2",
+  path: ["version"]
+});
+function parseSourceConfig(yamlText) {
+  return yaml.load(yamlText);
+}
+function validateSourceConfig(parsed) {
+  const result = SourceConfigSchema.safeParse(parsed);
+  if (result.success) {
+    const warnings = collectWarnings(result.data);
+    return warnings.length > 0 ? { ok: true, config: result.data, warnings } : { ok: true, config: result.data };
+  }
+  return {
+    ok: false,
+    errors: result.error.issues.map((issue) => ({
+      path: issue.path.join("."),
+      message: issue.message
+    }))
+  };
+}
+function loadSourceConfig(yamlText) {
+  const parsed = parseSourceConfig(yamlText);
+  return validateSourceConfig(parsed);
+}
+function isManifestMode(config) {
+  return config.version === 2 && Array.isArray(config.assets);
+}
+function collectWarnings(config) {
+  const warnings = [];
+  if (Array.isArray(config.assets) && config.publisher_overrides.length > 0) {
+    warnings.push(
+      "`assets:` block is present; `publisher_overrides:` will be ignored in manifest mode."
+    );
+  }
+  return warnings;
+}
+function mergeSourceConfigs(base, overlay) {
+  if (!base && !overlay) return void 0;
+  if (!overlay) return base;
+  if (!base) return overlay;
+  const merged = { ...base };
+  merged.version = overlay.version;
+  if (overlay.publisher_default && overlay.publisher_default.length > 0) {
+    merged.publisher_default = overlay.publisher_default;
+  }
+  if (Array.isArray(overlay.publisher_overrides) && overlay.publisher_overrides.length > 0) {
+    merged.publisher_overrides = overlay.publisher_overrides;
+  }
+  if (overlay.default_ref && overlay.default_ref.length > 0) {
+    merged.default_ref = overlay.default_ref;
+  }
+  if (overlay.sync !== void 0) {
+    merged.sync = overlay.sync;
+  }
+  if (overlay.assets !== void 0) {
+    merged.assets = overlay.assets;
+  }
+  return merged;
+}
+function loadMergedSourceConfig(rootPath, sidecarPath) {
+  const baseResult = loadSourceConfigFromDir(rootPath);
+  if (baseResult && !baseResult.ok) return baseResult;
+  const base = baseResult?.ok ? baseResult.config : void 0;
+  let overlay;
+  const overlayWarnings = [];
+  if (sidecarPath) {
+    const overlayResult = loadSourceConfigFromDir(sidecarPath);
+    if (overlayResult && !overlayResult.ok) return overlayResult;
+    if (overlayResult?.ok) {
+      overlay = overlayResult.config;
+      if (overlayResult.warnings) overlayWarnings.push(...overlayResult.warnings);
+    }
+  }
+  const merged = mergeSourceConfigs(base, overlay);
+  if (!merged) {
+    return {
+      ok: true,
+      config: {
+        version: 2,
+        publisher_default: "@<domain>",
+        default_ref: "main",
+        publisher_overrides: []
+      }
+    };
+  }
+  const warnings = collectWarnings(merged);
+  if (overlayWarnings.length > 0) warnings.push(...overlayWarnings);
+  return warnings.length > 0 ? { ok: true, config: merged, warnings } : { ok: true, config: merged };
+}
+function loadSourceConfigFromDir(dir) {
+  const filePath = path.join(dir, ".skaile-source.yaml");
+  if (!fs.existsSync(filePath)) return void 0;
+  try {
+    const text = fs.readFileSync(filePath, "utf-8");
+    return loadSourceConfig(text);
+  } catch (err) {
+    return {
+      ok: false,
+      errors: [
+        {
+          path: filePath,
+          message: err instanceof Error ? err.message : String(err)
+        }
+      ]
+    };
+  }
+}
+function computeDeterministicHash(assetRoot, files) {
+  const hash = crypto.createHash("sha256");
+  const sorted = [...files].sort();
+  for (const file of sorted) {
+    const fullPath = path.join(assetRoot, file);
+    try {
+      hash.update(file);
+      hash.update("\0");
+      const content = fs.readFileSync(fullPath);
+      hash.update(content);
+      hash.update("\0");
+    } catch {
+    }
+  }
+  return hash.digest("hex");
+}
+function computeDeterministicHashDetailed(assetRoot, files) {
+  const hash = crypto.createHash("sha256");
+  const sorted = [...files].sort();
+  const present = [];
+  const missing = [];
+  for (const file of sorted) {
+    const fullPath = path.join(assetRoot, file);
+    let content = null;
+    try {
+      content = fs.readFileSync(fullPath);
+    } catch {
+      missing.push(file);
+      continue;
+    }
+    hash.update(file);
+    hash.update("\0");
+    hash.update(content);
+    hash.update("\0");
+    present.push(file);
+  }
+  return { sha256: hash.digest("hex"), present, missing };
+}
+function discoverFromManifest(rootPath, sourceConfig, registry) {
+  const assets = [];
+  const errors = [];
+  const allEdges = [];
+  const sortedEntries = [...sourceConfig.assets].sort((a, b) => a.path < b.path ? -1 : 1);
+  for (const entry of sortedEntries) {
+    const result = processEntry(rootPath, entry, registry);
+    if (result.errors.length > 0) {
+      errors.push(...result.errors);
+      if (!result.asset) continue;
+    }
+    if (result.asset) {
+      assets.push(result.asset);
+      allEdges.push(...result.asset.requires);
+    }
+  }
+  const graph = buildRequiresGraph(allEdges);
+  return { assets, graph, errors };
+}
+function processEntry(rootPath, entry, registry) {
+  const errors = [];
+  const assetRoot = path.resolve(rootPath, entry.path);
+  const assetRootRelative = entry.path;
+  const manifestFileRel = pickManifestFile(entry, registry);
+  const manifestAbsPath = path.join(assetRoot, manifestFileRel);
+  const missing = [];
+  for (const file of entry.files) {
+    if (!fs.existsSync(path.join(assetRoot, file))) {
+      missing.push(file);
+    }
+  }
+  if (missing.length > 0) {
+    errors.push({
+      path: assetRootRelative,
+      error: `ManifestFileMissing: ${missing.join(", ")}`
+    });
+    return { asset: null, errors };
+  }
+  const manifest = parseManifest(manifestAbsPath);
+  if (!manifest) {
+    errors.push({
+      path: assetRootRelative,
+      error: `ManifestSchemaError: failed to parse manifest file ${manifestFileRel}`
+    });
+    return { asset: null, errors };
+  }
+  if (!registry.getProvider(entry.kind)) {
+    errors.push({
+      path: assetRootRelative,
+      error: `Unknown asset kind "${entry.kind}" \u2014 ghost-installing without provider validation`
+    });
+  }
+  const requiresErrors = validateRequiresSyntax(entry.requires);
+  if (requiresErrors.length > 0) {
+    errors.push({
+      path: assetRootRelative,
+      error: `ManifestRequiresError: ${requiresErrors.join("; ")}`
+    });
+    return { asset: null, errors };
+  }
+  const { sha256: computedHash, missing: hashMissing } = computeDeterministicHashDetailed(
+    assetRoot,
+    entry.files
+  );
+  if (hashMissing.length > 0) {
+    errors.push({
+      path: assetRootRelative,
+      error: `ManifestFileMissing: ${hashMissing.join(", ")} (became unreadable during hashing)`
+    });
+    return { asset: null, errors };
+  }
+  if (entry.sha256 && entry.sha256 !== computedHash) {
+    errors.push({
+      path: assetRootRelative,
+      error: `ManifestHashMismatch: declared ${entry.sha256}, computed ${computedHash}`
+    });
+    return { asset: null, errors };
+  }
+  if (!entry.sha256) {
+    errors.push({
+      path: assetRootRelative,
+      error: `Missing sha256 \u2014 computed ${computedHash}. Re-run \`skaile source build-manifest --write\` to pin it.`
+    });
+  }
+  const ref = `${entry.publisher}/${entry.name}@${entry.version}`;
+  const requires = entry.requires.map((to) => ({
+    from: ref,
+    to,
+    field: "assets[].requires"
+  }));
+  const mergedManifest = {
+    ...entry.metadata ?? {},
+    ...manifest
+  };
+  const asset = {
+    ref,
+    kind: entry.kind,
+    publisher: entry.publisher,
+    name: entry.name,
+    version: entry.version,
+    manifest: mergedManifest,
+    manifestPath: manifestAbsPath,
+    relativePath: path.join(assetRootRelative, manifestFileRel).replace(/\\/g, "/"),
+    fileFilter: {
+      assetRoot,
+      files: [...entry.files].sort()
+    },
+    sha256: computedHash,
+    requires
+  };
+  return { asset, errors };
+}
+var MANIFEST_FILENAMES = /* @__PURE__ */ new Set([
+  "SKILL.md",
+  "AGENT.md",
+  "agent.yaml",
+  "CONNECTOR.md",
+  "MOUNT.md",
+  "MCP.md",
+  "CONTRACT.md",
+  "PERSONA.md",
+  "RULESET.md"
+]);
+var MANIFEST_SUFFIXES = [".flow.yaml", ".flow.json", ".prompt.md", ".preset.yaml"];
+function pickManifestFile(entry, registry) {
+  const provider = registry.getProvider(entry.kind);
+  if (provider) {
+    for (const file of entry.files) {
+      if (provider.matchesPath(path.join(entry.path, file).replace(/\\/g, "/"))) {
+        return file;
+      }
+    }
+  }
+  for (const file of entry.files) {
+    if (MANIFEST_FILENAMES.has(path.basename(file))) return file;
+    if (MANIFEST_SUFFIXES.some((s) => file.endsWith(s))) return file;
+  }
+  return entry.files[0];
+}
+function parseManifest(absPath) {
+  try {
+    const content = fs.readFileSync(absPath, "utf-8");
+    if (absPath.endsWith(".md")) {
+      const { data } = parseFrontmatter(content);
+      return data;
+    }
+    if (absPath.endsWith(".yaml") || absPath.endsWith(".yml")) {
+      const parsed = yaml.load(content);
+      if (typeof parsed === "object" && parsed !== null) {
+        return parsed;
+      }
+      return null;
+    }
+    if (absPath.endsWith(".json")) {
+      return JSON.parse(content);
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function validateRequiresSyntax(requires) {
+  const errors = [];
+  const RE = /^@[\w-]+\/[\w.-]+(?:@.+)?$/;
+  for (const r of requires) {
+    if (!RE.test(r)) errors.push(`invalid requires entry "${r}"`);
+  }
+  return errors;
+}
+
+// discovery/src/discover.ts
+function createDefaultRegistry() {
+  const registry = new AssetKindRegistry();
+  for (const provider of BUILTIN_PROVIDERS) {
+    registry.register(provider);
+  }
+  return registry;
+}
+function discoverAssetsInTree(rootPath, optionsOrSourceConfig) {
+  let sourceConfig;
+  let registry;
+  let sidecarPath;
+  if (optionsOrSourceConfig && ("registry" in optionsOrSourceConfig || "sourceConfig" in optionsOrSourceConfig || "sidecarPath" in optionsOrSourceConfig)) {
+    sourceConfig = optionsOrSourceConfig.sourceConfig;
+    registry = optionsOrSourceConfig.registry;
+    sidecarPath = optionsOrSourceConfig.sidecarPath;
+  } else {
+    sourceConfig = optionsOrSourceConfig;
+  }
+  if (!registry) {
+    registry = createDefaultRegistry();
+  }
+  if (!sourceConfig && sidecarPath) {
+    const merged = loadMergedSourceConfig(rootPath, sidecarPath);
+    if (merged.ok) {
+      sourceConfig = merged.config;
+    }
+  }
+  if (sourceConfig && isManifestMode(sourceConfig)) {
+    return discoverFromManifest(rootPath, sourceConfig, registry);
+  }
+  const assets = [];
+  const errors = [];
+  const allEdges = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const { absPath, relativePath } of walkTree(rootPath)) {
+    let kind;
+    try {
+      kind = registry.resolveKind(relativePath);
+    } catch (err) {
+      errors.push({
+        path: relativePath,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      continue;
+    }
+    if (!kind) continue;
+    const dir = path.dirname(relativePath);
+    const dedupKey = `${dir}:${kind}`;
+    if (seen.has(dedupKey)) continue;
+    seen.add(dedupKey);
+    try {
+      const manifest = parseManifest2(absPath);
+      if (!manifest) {
+        errors.push({ path: relativePath, error: "Failed to parse manifest" });
+        continue;
+      }
+      const publisher = resolvePublisher(relativePath, sourceConfig);
+      const name = deriveName(relativePath, kind, manifest);
+      const version = typeof manifest.version === "string" ? manifest.version : "0.0.0";
+      const ref = `${publisher}/${name}@${version}`;
+      const fileFilter = registry.defaultFileFilter(kind, absPath) ?? {
+        assetRoot: path.dirname(absPath),
+        files: [path.basename(absPath)]
+      };
+      const sha256 = computeDeterministicHash(fileFilter.assetRoot, fileFilter.files);
+      const requires = registry.extractRequires(kind, ref, manifest);
+      allEdges.push(...requires);
+      assets.push({
+        ref,
+        kind,
+        publisher,
+        name,
+        version,
+        manifest,
+        manifestPath: absPath,
+        relativePath,
+        fileFilter,
+        sha256,
+        requires
+      });
+    } catch (err) {
+      errors.push({
+        path: relativePath,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  const graph = buildRequiresGraph(allEdges);
+  return { assets, graph, errors };
+}
+function* walkTree(rootDir) {
+  function* walk(dir, relDir) {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries.sort((a, b) => a.name < b.name ? -1 : 1)) {
+      const full = path.join(dir, e.name);
+      const rel = relDir ? `${relDir}/${e.name}` : e.name;
+      if (e.isDirectory()) {
+        if (e.name === ".git" || e.name === "node_modules" || e.name === ".skaile") continue;
+        yield* walk(full, rel);
+      } else if (e.isFile()) {
+        yield { absPath: full, relativePath: rel };
+      }
+    }
+  }
+  yield* walk(rootDir, "");
+}
+function parseManifest2(absPath) {
+  try {
+    const content = fs.readFileSync(absPath, "utf-8");
+    if (absPath.endsWith(".md")) {
+      const { data } = parseFrontmatter(content);
+      return data;
+    }
+    if (absPath.endsWith(".yaml") || absPath.endsWith(".yml")) {
+      const parsed = yaml.load(content);
+      if (typeof parsed === "object" && parsed !== null) {
+        return parsed;
+      }
+      return null;
+    }
+    if (absPath.endsWith(".json")) {
+      return JSON.parse(content);
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function resolvePublisher(relativePath, sourceConfig) {
+  if (!sourceConfig) {
+    const domain = relativePath.split("/")[0] ?? "unknown";
+    return `@${domain}`;
+  }
+  for (const override of sourceConfig.publisher_overrides) {
+    if (relativePath.startsWith(override.path)) {
+      return override.publisher;
+    }
+  }
+  const template = sourceConfig.publisher_default;
+  if (template.includes("<domain>")) {
+    const domain = relativePath.split("/")[0] ?? "unknown";
+    return template.replace("<domain>", domain);
+  }
+  return template;
+}
+function deriveName(relativePath, kind, manifest) {
+  if (typeof manifest.name === "string" && manifest.name.length > 0) {
+    return manifest.name;
+  }
+  const parts = relativePath.split("/");
+  if (kind === "flow") {
+    const filename2 = parts[parts.length - 1] ?? "";
+    return filename2.replace(/\.flow\.(yaml|json)$/, "");
+  }
+  if (kind === "prompt") {
+    const filename2 = parts[parts.length - 1] ?? "";
+    return filename2.replace(/\.prompt\.md$/, "");
+  }
+  if (kind === "preset") {
+    const filename2 = parts[parts.length - 1] ?? "";
+    return filename2.replace(/\.preset\.yaml$/, "");
+  }
+  if (parts.length >= 2) {
+    return parts[parts.length - 2];
+  }
+  const filename = parts[parts.length - 1] ?? "unknown";
+  return filename.replace(/\.(md|yaml|json)$/, "");
+}
+async function discoverAssetsInTreeEntries(entries, options) {
+  const registry = options.registry ?? createDefaultRegistry();
+  const blobByPath = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (entry.type === "blob") {
+      blobByPath.set(entry.path, entry);
+    }
+  }
+  const baseSourceConfig = await resolveSourceConfigFromTree(
+    options.sourceConfig,
+    blobByPath,
+    options.fetchBlob
+  );
+  const resolvedSourceConfig = options.sidecarSourceConfig ? mergeSourceConfigs(baseSourceConfig, options.sidecarSourceConfig) : baseSourceConfig;
+  if (resolvedSourceConfig && isManifestMode(resolvedSourceConfig)) {
+    return discoverFromManifestTree(resolvedSourceConfig, blobByPath, options.fetchBlob, registry);
+  }
+  const sortedBlobPaths = [...blobByPath.keys()].sort();
+  const assets = [];
+  const errors = [];
+  const allEdges = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const relativePath of sortedBlobPaths) {
+    if (relativePath.startsWith(".git/") || relativePath.startsWith("node_modules/") || relativePath.startsWith(".skaile/") || relativePath.includes("/.git/") || relativePath.includes("/node_modules/") || relativePath.includes("/.skaile/")) {
+      continue;
+    }
+    let kind;
+    try {
+      kind = registry.resolveKind(relativePath);
+    } catch (err) {
+      errors.push({
+        path: relativePath,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      continue;
+    }
+    if (!kind) continue;
+    const dir = posixDirname(relativePath);
+    const dedupKey = `${dir}:${kind}`;
+    if (seen.has(dedupKey)) continue;
+    seen.add(dedupKey);
+    const manifestEntry = blobByPath.get(relativePath);
+    if (!manifestEntry) {
+      errors.push({ path: relativePath, error: "Manifest blob disappeared from tree index" });
+      continue;
+    }
+    let manifestBytes;
+    try {
+      manifestBytes = await fetchAsBuffer(options.fetchBlob, manifestEntry.sha);
+    } catch (err) {
+      errors.push({
+        path: relativePath,
+        error: `Failed to fetch manifest blob: ${err instanceof Error ? err.message : String(err)}`
+      });
+      continue;
+    }
+    if (!manifestBytes) {
+      errors.push({ path: relativePath, error: "Failed to fetch manifest blob" });
+      continue;
+    }
+    const manifestText = manifestBytes.toString("utf-8");
+    const manifest = parseManifestText(relativePath, manifestText);
+    if (!manifest) {
+      errors.push({ path: relativePath, error: "Failed to parse manifest" });
+      continue;
+    }
+    const publisher = resolvePublisher2(relativePath, resolvedSourceConfig);
+    const name = deriveName2(relativePath, kind, manifest);
+    const version = typeof manifest.version === "string" ? manifest.version : "0.0.0";
+    const ref = `${publisher}/${name}@${version}`;
+    const fileFilter = computeFileFilter(kind, relativePath, blobByPath);
+    let sha256;
+    try {
+      sha256 = await computeDeterministicHashFromTree(fileFilter, blobByPath, options.fetchBlob);
+    } catch (err) {
+      errors.push({
+        path: relativePath,
+        error: `Failed to compute hash: ${err instanceof Error ? err.message : String(err)}`
+      });
+      continue;
+    }
+    const requires = registry.extractRequires(kind, ref, manifest);
+    allEdges.push(...requires);
+    assets.push({
+      ref,
+      kind,
+      publisher,
+      name,
+      version,
+      manifest,
+      // The tree-entries variant has no on-disk path — surface the
+      // repo-relative path here so downstream consumers can build a
+      // Manifest URL (raw.githubusercontent.com link).
+      manifestPath: relativePath,
+      relativePath,
+      fileFilter,
+      sha256,
+      requires
+    });
+  }
+  const graph = buildRequiresGraph(allEdges);
+  return { assets, graph, errors };
+}
+function parseManifestText(relativePath, text) {
+  try {
+    if (relativePath.endsWith(".md")) {
+      const { data } = parseFrontmatter(text);
+      return data;
+    }
+    if (relativePath.endsWith(".yaml") || relativePath.endsWith(".yml")) {
+      const parsed = yaml.load(text);
+      if (typeof parsed === "object" && parsed !== null) {
+        return parsed;
+      }
+      return null;
+    }
+    if (relativePath.endsWith(".json")) {
+      return JSON.parse(text);
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function resolvePublisher2(relativePath, sourceConfig) {
+  if (!sourceConfig) {
+    const domain = relativePath.split("/")[0] ?? "unknown";
+    return `@${domain}`;
+  }
+  for (const override of sourceConfig.publisher_overrides) {
+    if (relativePath.startsWith(override.path)) {
+      return override.publisher;
+    }
+  }
+  const template = sourceConfig.publisher_default;
+  if (template.includes("<domain>")) {
+    const domain = relativePath.split("/")[0] ?? "unknown";
+    return template.replace("<domain>", domain);
+  }
+  return template;
+}
+function deriveName2(relativePath, kind, manifest) {
+  if (typeof manifest.name === "string" && manifest.name.length > 0) {
+    return manifest.name;
+  }
+  const parts = relativePath.split("/");
+  if (kind === "flow") {
+    const filename2 = parts[parts.length - 1] ?? "";
+    return filename2.replace(/\.flow\.(yaml|json)$/, "");
+  }
+  if (kind === "prompt") {
+    const filename2 = parts[parts.length - 1] ?? "";
+    return filename2.replace(/\.prompt\.md$/, "");
+  }
+  if (kind === "preset") {
+    const filename2 = parts[parts.length - 1] ?? "";
+    return filename2.replace(/\.preset\.yaml$/, "");
+  }
+  if (parts.length >= 2) {
+    return parts[parts.length - 2];
+  }
+  const filename = parts[parts.length - 1] ?? "unknown";
+  return filename.replace(/\.(md|yaml|json)$/, "");
+}
+function computeFileFilter(kind, manifestPath, blobByPath) {
+  const dir = posixDirname(manifestPath);
+  const manifestName = posixBasename(manifestPath);
+  switch (kind) {
+    case "skill":
+      return skillFilterVirtual(dir, manifestName, blobByPath);
+    case "agent":
+      return agentFilterVirtual(dir, manifestName, blobByPath);
+    case "contract":
+      return contractFilterVirtual(dir, manifestName, blobByPath);
+    case "connector":
+      return connectorFilterVirtual(dir, manifestName, blobByPath);
+    case "mount":
+      return mountFilterVirtual(dir, manifestName, blobByPath);
+    // mcp-server, prompt, preset, persona, ruleset, knowledge: manifest-only
+    default:
+      return { assetRoot: dir, files: [manifestName] };
+  }
+}
+function skillFilterVirtual(dir, manifestName, blobByPath) {
+  const files = /* @__PURE__ */ new Set([manifestName]);
+  for (const leaf of ["validator.py", "CLI.md"]) {
+    if (blobByPath.has(joinPosix(dir, leaf))) files.add(leaf);
+  }
+  const directChildDirs = /* @__PURE__ */ new Set();
+  for (const blobPath of blobByPath.keys()) {
+    if (!isInDir(blobPath, dir)) continue;
+    const remainder = blobPath.slice(dir === "" ? 0 : dir.length + 1);
+    const slash = remainder.indexOf("/");
+    if (slash === -1) continue;
+    const childDir = remainder.slice(0, slash);
+    directChildDirs.add(childDir);
+  }
+  if (directChildDirs.has("references")) {
+    addAllUnder(files, dir, "references", blobByPath);
+  }
+  for (const childDir of directChildDirs) {
+    if (childDir === "references") continue;
+    if (blobByPath.has(joinPosix(dir, childDir, "SKILL.md"))) {
+      addAllUnder(files, dir, childDir, blobByPath);
+    }
+  }
+  return { assetRoot: dir, files: [...files].sort() };
+}
+function agentFilterVirtual(dir, manifestName, blobByPath) {
+  const files = /* @__PURE__ */ new Set([manifestName]);
+  for (const companion of ["SOUL.md", "RULES.md"]) {
+    if (blobByPath.has(joinPosix(dir, companion))) files.add(companion);
+  }
+  addAllUnder(files, dir, "knowledge", blobByPath);
+  return { assetRoot: dir, files: [...files].sort() };
+}
+function contractFilterVirtual(dir, manifestName, blobByPath) {
+  const files = /* @__PURE__ */ new Set([manifestName]);
+  for (const blobPath of blobByPath.keys()) {
+    if (!isInDir(blobPath, dir)) continue;
+    const remainder = blobPath.slice(dir === "" ? 0 : dir.length + 1);
+    if (remainder.includes("/")) continue;
+    files.add(remainder);
+  }
+  return { assetRoot: dir, files: [...files].sort() };
+}
+function connectorFilterVirtual(dir, manifestName, blobByPath) {
+  const files = /* @__PURE__ */ new Set([manifestName]);
+  if (blobByPath.has(joinPosix(dir, "adapter.ts"))) files.add("adapter.ts");
+  return { assetRoot: dir, files: [...files].sort() };
+}
+function mountFilterVirtual(dir, manifestName, blobByPath) {
+  const files = /* @__PURE__ */ new Set([manifestName]);
+  if (blobByPath.has(joinPosix(dir, "driver.ts"))) files.add("driver.ts");
+  return { assetRoot: dir, files: [...files].sort() };
+}
+async function computeDeterministicHashFromTree(fileFilter, blobByPath, fetchBlob) {
+  const hash = crypto.createHash("sha256");
+  const sorted = [...fileFilter.files].sort();
+  for (const file of sorted) {
+    const fullPath = joinPosix(fileFilter.assetRoot, file);
+    const entry = blobByPath.get(fullPath);
+    if (!entry) continue;
+    hash.update(file);
+    hash.update("\0");
+    let bytes;
+    try {
+      bytes = await fetchAsBuffer(fetchBlob, entry.sha);
+    } catch {
+      bytes = null;
+    }
+    if (bytes) hash.update(bytes);
+    hash.update("\0");
+  }
+  return hash.digest("hex");
+}
+function posixDirname(p) {
+  const i = p.lastIndexOf("/");
+  return i === -1 ? "" : p.slice(0, i);
+}
+function posixBasename(p) {
+  const i = p.lastIndexOf("/");
+  return i === -1 ? p : p.slice(i + 1);
+}
+function joinPosix(...segments) {
+  return segments.filter((s) => s !== "").join("/");
+}
+function isInDir(blobPath, dir) {
+  if (dir === "") return true;
+  return blobPath.startsWith(`${dir}/`);
+}
+function addAllUnder(out, baseDir, subDir, blobByPath) {
+  const prefix = baseDir === "" ? `${subDir}/` : `${baseDir}/${subDir}/`;
+  for (const blobPath of blobByPath.keys()) {
+    if (blobPath.startsWith(prefix)) {
+      const relToAssetRoot = baseDir === "" ? blobPath : blobPath.slice(baseDir.length + 1);
+      out.add(relToAssetRoot);
+    } else if (blobPath === prefix.slice(0, -1)) {
+      out.add(subDir);
+    }
+  }
+}
+async function fetchAsBuffer(fetchBlob, sha) {
+  const result = await fetchBlob(sha);
+  if (result == null) return null;
+  if (Buffer.isBuffer(result)) return result;
+  if (typeof result === "string") return Buffer.from(result, "utf-8");
+  return Buffer.from(result);
+}
+async function resolveSourceConfigFromTree(explicit, blobByPath, fetchBlob) {
+  if (explicit) return explicit;
+  const entry = blobByPath.get(".skaile-source.yaml");
+  if (!entry) return void 0;
+  const bytes = await fetchAsBuffer(fetchBlob, entry.sha);
+  if (!bytes) return void 0;
+  const result = loadSourceConfig(bytes.toString("utf-8"));
+  return result.ok ? result.config : void 0;
+}
+async function discoverFromManifestTree(sourceConfig, blobByPath, fetchBlob, registry) {
+  const assets = [];
+  const errors = [];
+  const allEdges = [];
+  const sortedEntries = [...sourceConfig.assets].sort((a, b) => a.path < b.path ? -1 : 1);
+  for (const entry of sortedEntries) {
+    const result = await processManifestEntryTree(entry, blobByPath, fetchBlob, registry);
+    if (result.errors.length > 0) {
+      errors.push(...result.errors);
+      if (!result.asset) continue;
+    }
+    if (result.asset) {
+      assets.push(result.asset);
+      allEdges.push(...result.asset.requires);
+    }
+  }
+  const graph = buildRequiresGraph(allEdges);
+  return { assets, graph, errors };
+}
+async function processManifestEntryTree(entry, blobByPath, fetchBlob, registry) {
+  const errors = [];
+  const assetRootRelative = entry.path;
+  const missing = [];
+  for (const file of entry.files) {
+    const full = joinPosix(entry.path, file);
+    if (!blobByPath.has(full)) missing.push(file);
+  }
+  if (missing.length > 0) {
+    errors.push({
+      path: assetRootRelative,
+      error: `ManifestFileMissing: ${missing.join(", ")}`
+    });
+    return { asset: null, errors };
+  }
+  const manifestFileRel = pickManifestFileTree(entry, registry);
+  const manifestFull = joinPosix(entry.path, manifestFileRel);
+  const manifestEntry = blobByPath.get(manifestFull);
+  let manifestBytes;
+  try {
+    manifestBytes = await fetchAsBuffer(fetchBlob, manifestEntry.sha);
+  } catch (err) {
+    errors.push({
+      path: assetRootRelative,
+      error: `ManifestSchemaError: failed to fetch manifest blob: ${err instanceof Error ? err.message : String(err)}`
+    });
+    return { asset: null, errors };
+  }
+  if (!manifestBytes) {
+    errors.push({
+      path: assetRootRelative,
+      error: `ManifestSchemaError: failed to fetch manifest blob`
+    });
+    return { asset: null, errors };
+  }
+  const manifest = parseManifestText(manifestFull, manifestBytes.toString("utf-8"));
+  if (!manifest) {
+    errors.push({
+      path: assetRootRelative,
+      error: `ManifestSchemaError: failed to parse manifest file ${manifestFileRel}`
+    });
+    return { asset: null, errors };
+  }
+  if (!registry.getProvider(entry.kind)) {
+    errors.push({
+      path: assetRootRelative,
+      error: `Unknown asset kind "${entry.kind}" \u2014 ghost-installing without provider validation`
+    });
+  }
+  const requiresErrors = validateRequiresSyntax2(entry.requires);
+  if (requiresErrors.length > 0) {
+    errors.push({
+      path: assetRootRelative,
+      error: `ManifestRequiresError: ${requiresErrors.join("; ")}`
+    });
+    return { asset: null, errors };
+  }
+  let computedHash;
+  try {
+    computedHash = await computeManifestHashTree(entry, blobByPath, fetchBlob);
+  } catch (err) {
+    errors.push({
+      path: assetRootRelative,
+      error: `Failed to compute hash: ${err instanceof Error ? err.message : String(err)}`
+    });
+    return { asset: null, errors };
+  }
+  if (entry.sha256 && entry.sha256 !== computedHash) {
+    errors.push({
+      path: assetRootRelative,
+      error: `ManifestHashMismatch: declared ${entry.sha256}, computed ${computedHash}`
+    });
+    return { asset: null, errors };
+  }
+  if (!entry.sha256) {
+    errors.push({
+      path: assetRootRelative,
+      error: `Missing sha256 \u2014 computed ${computedHash}. Re-run \`skaile source build-manifest --write\` to pin it.`
+    });
+  }
+  const ref = `${entry.publisher}/${entry.name}@${entry.version}`;
+  const requires = entry.requires.map((to) => ({
+    from: ref,
+    to,
+    field: "assets[].requires"
+  }));
+  const mergedManifest = {
+    ...entry.metadata ?? {},
+    ...manifest
+  };
+  const asset = {
+    ref,
+    kind: entry.kind,
+    publisher: entry.publisher,
+    name: entry.name,
+    version: entry.version,
+    manifest: mergedManifest,
+    manifestPath: manifestFull,
+    relativePath: manifestFull,
+    fileFilter: {
+      assetRoot: entry.path,
+      files: [...entry.files].sort()
+    },
+    sha256: computedHash,
+    requires
+  };
+  return { asset, errors };
+}
+var MANIFEST_FILENAMES2 = /* @__PURE__ */ new Set([
+  "SKILL.md",
+  "AGENT.md",
+  "agent.yaml",
+  "CONNECTOR.md",
+  "MOUNT.md",
+  "MCP.md",
+  "CONTRACT.md",
+  "PERSONA.md",
+  "RULESET.md"
+]);
+var MANIFEST_SUFFIXES2 = [".flow.yaml", ".flow.json", ".prompt.md", ".preset.yaml"];
+function pickManifestFileTree(entry, registry) {
+  const provider = registry.getProvider(entry.kind);
+  if (provider) {
+    for (const file of entry.files) {
+      if (provider.matchesPath(joinPosix(entry.path, file))) return file;
+    }
+  }
+  for (const file of entry.files) {
+    const base = file.split("/").pop() ?? file;
+    if (MANIFEST_FILENAMES2.has(base)) return file;
+    if (MANIFEST_SUFFIXES2.some((s) => file.endsWith(s))) return file;
+  }
+  return entry.files[0];
+}
+async function computeManifestHashTree(entry, blobByPath, fetchBlob) {
+  const hash = crypto.createHash("sha256");
+  const sorted = [...entry.files].sort();
+  for (const file of sorted) {
+    const full = joinPosix(entry.path, file);
+    const blob = blobByPath.get(full);
+    if (!blob) continue;
+    hash.update(file);
+    hash.update("\0");
+    const bytes = await fetchAsBuffer(fetchBlob, blob.sha);
+    if (bytes) hash.update(bytes);
+    hash.update("\0");
+  }
+  return hash.digest("hex");
+}
+function validateRequiresSyntax2(requires) {
+  const errors = [];
+  const RE = /^@[\w-]+\/[\w.-]+(?:@.+)?$/;
+  for (const r of requires) {
+    if (!RE.test(r)) errors.push(`invalid requires entry "${r}"`);
+  }
+  return errors;
+}
+
+// discovery/src/index.ts
+var VERSION = "0.0.0";
+
+export { AssetKindRegistry, BUILTIN_PROVIDERS, SEMVER_RE, SourceConfigSchema, VERSION, agentProvider, buildRequiresGraph, computeDeterministicHash, computeDeterministicHashDetailed, connectorProvider, contractProvider, createDefaultRegistry, detectCycles, discoverAssetsInTree, discoverAssetsInTreeEntries, discoverFromManifest, extractRequires, isManifestMode, loadMergedSourceConfig, loadSourceConfig, mcpServerProvider, mergeSourceConfigs, mountProvider, parseSourceConfig, personaProvider, presetProvider, promptProvider, rulesetProvider, skillProvider, validateSourceConfig };
+//# sourceMappingURL=chunk-46T37EBP.js.map
+//# sourceMappingURL=chunk-46T37EBP.js.map