@morphist/aspects 0.1.0 → 0.1.2

package/dist/cli.js

@@ -785,64 +785,6 @@ var init_prompt = __esm(() => {
   kCancel = Symbol.for("cancel");
 });
 
-// node_modules/sisteransi/src/index.js
-var require_src = __commonJS((exports, module) => {
-  var ESC = "\x1B";
-  var CSI = `${ESC}[`;
-  var beep = "\x07";
-  var cursor = {
-    to(x2, y3) {
-      if (!y3)
-        return `${CSI}${x2 + 1}G`;
-      return `${CSI}${y3 + 1};${x2 + 1}H`;
-    },
-    move(x2, y3) {
-      let ret = "";
-      if (x2 < 0)
-        ret += `${CSI}${-x2}D`;
-      else if (x2 > 0)
-        ret += `${CSI}${x2}C`;
-      if (y3 < 0)
-        ret += `${CSI}${-y3}A`;
-      else if (y3 > 0)
-        ret += `${CSI}${y3}B`;
-      return ret;
-    },
-    up: (count = 1) => `${CSI}${count}A`,
-    down: (count = 1) => `${CSI}${count}B`,
-    forward: (count = 1) => `${CSI}${count}C`,
-    backward: (count = 1) => `${CSI}${count}D`,
-    nextLine: (count = 1) => `${CSI}E`.repeat(count),
-    prevLine: (count = 1) => `${CSI}F`.repeat(count),
-    left: `${CSI}G`,
-    hide: `${CSI}?25l`,
-    show: `${CSI}?25h`,
-    save: `${ESC}7`,
-    restore: `${ESC}8`
-  };
-  var scroll = {
-    up: (count = 1) => `${CSI}S`.repeat(count),
-    down: (count = 1) => `${CSI}T`.repeat(count)
-  };
-  var erase = {
-    screen: `${CSI}2J`,
-    up: (count = 1) => `${CSI}1J`.repeat(count),
-    down: (count = 1) => `${CSI}J`.repeat(count),
-    line: `${CSI}2K`,
-    lineEnd: `${CSI}K`,
-    lineStart: `${CSI}1K`,
-    lines(count) {
-      let clear = "";
-      for (let i2 = 0;i2 < count; i2++)
-        clear += this.line + (i2 < count - 1 ? cursor.up() : "");
-      if (count)
-        clear += cursor.left;
-      return clear;
-    }
-  };
-  module.exports = { cursor, scroll, erase, beep };
-});
-
 // node_modules/picocolors/picocolors.js
 var require_picocolors = __commonJS((exports, module) => {
   var p = process || {};
@@ -913,6 +855,64 @@ var require_picocolors = __commonJS((exports, module) => {
   module.exports.createColors = createColors2;
 });
 
+// node_modules/sisteransi/src/index.js
+var require_src = __commonJS((exports, module) => {
+  var ESC = "\x1B";
+  var CSI = `${ESC}[`;
+  var beep = "\x07";
+  var cursor = {
+    to(x2, y3) {
+      if (!y3)
+        return `${CSI}${x2 + 1}G`;
+      return `${CSI}${y3 + 1};${x2 + 1}H`;
+    },
+    move(x2, y3) {
+      let ret = "";
+      if (x2 < 0)
+        ret += `${CSI}${-x2}D`;
+      else if (x2 > 0)
+        ret += `${CSI}${x2}C`;
+      if (y3 < 0)
+        ret += `${CSI}${-y3}A`;
+      else if (y3 > 0)
+        ret += `${CSI}${y3}B`;
+      return ret;
+    },
+    up: (count = 1) => `${CSI}${count}A`,
+    down: (count = 1) => `${CSI}${count}B`,
+    forward: (count = 1) => `${CSI}${count}C`,
+    backward: (count = 1) => `${CSI}${count}D`,
+    nextLine: (count = 1) => `${CSI}E`.repeat(count),
+    prevLine: (count = 1) => `${CSI}F`.repeat(count),
+    left: `${CSI}G`,
+    hide: `${CSI}?25l`,
+    show: `${CSI}?25h`,
+    save: `${ESC}7`,
+    restore: `${ESC}8`
+  };
+  var scroll = {
+    up: (count = 1) => `${CSI}S`.repeat(count),
+    down: (count = 1) => `${CSI}T`.repeat(count)
+  };
+  var erase = {
+    screen: `${CSI}2J`,
+    up: (count = 1) => `${CSI}1J`.repeat(count),
+    down: (count = 1) => `${CSI}J`.repeat(count),
+    line: `${CSI}2K`,
+    lineEnd: `${CSI}K`,
+    lineStart: `${CSI}1K`,
+    lines(count) {
+      let clear = "";
+      for (let i2 = 0;i2 < count; i2++)
+        clear += this.line + (i2 < count - 1 ? cursor.up() : "");
+      if (count)
+        clear += cursor.left;
+      return clear;
+    }
+  };
+  module.exports = { cursor, scroll, erase, beep };
+});
+
 // node_modules/node-fetch-native/dist/shared/node-fetch-native.DfbY2q-x.mjs
 function f3(e3) {
   return e3 && e3.__esModule && Object.prototype.hasOwnProperty.call(e3, "default") ? e3.default : e3;
@@ -6284,6 +6284,9 @@ async function runMain(cmd, opts = {}) {
   }
 }
 
+// src/cli.ts
+var import_picocolors5 = __toESM(require_picocolors(), 1);
+
 // scripts/lib/output.ts
 var rgb = (r3, g3, b2) => (text) => `\x1B[38;2;${r3};${g3};${b2}m${text}\x1B[0m`;
 var colors2 = {
@@ -6326,8 +6329,8 @@ function morphistBanner() {
 }
 
 // src/commands/create.ts
-import { writeFile as writeFile4, readFile as readFile5, stat as stat2, mkdir as mkdir4 } from "node:fs/promises";
-import { join as join4 } from "node:path";
+import { writeFile as writeFile4, readFile as readFile5, stat as stat3, mkdir as mkdir4 } from "node:fs/promises";
+import { join as join5 } from "node:path";
 import { execSync } from "node:child_process";
 
 // node_modules/@clack/core/dist/index.mjs
@@ -20682,7 +20685,7 @@ var aspectSchema = exports_external.object({
 
 // src/commands/set.ts
 import { mkdir as mkdir3, readFile as readFile4, writeFile as writeFile3, readdir } from "node:fs/promises";
-import { join as join3 } from "node:path";
+import { join as join4 } from "node:path";
 
 // src/utils/colors.ts
 var import_picocolors3 = __toESM(require_picocolors(), 1);
@@ -20713,32 +20716,77 @@ var icons2 = {
   sparkle: "✨",
   package: "\uD83D\uDCE6",
   search: "\uD83D\uDD0D",
-  wizard: "\uD83E\uDDD9"
+  wizard: "\uD83E\uDDD9",
+  share: "\uD83D\uDD17"
 };
 
 // src/utils/paths.ts
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { mkdir } from "node:fs/promises";
+import { mkdir, stat } from "node:fs/promises";
 var ASPECTS_HOME = join(homedir(), ".aspects");
+var PROJECT_ASPECTS_DIR_NAME = ".aspects";
 var ASPECTS_DIR = join(ASPECTS_HOME, "aspects");
 var SETS_DIR = join(ASPECTS_HOME, "sets");
 var CONFIG_PATH = join(ASPECTS_HOME, "config.json");
-async function ensureAspectsDir() {
-  await mkdir(ASPECTS_DIR, { recursive: true });
+var cachedProjectRoot = null;
+async function findProjectRoot() {
+  if (cachedProjectRoot !== null)
+    return cachedProjectRoot || null;
+  let dir = process.cwd();
+  const root = "/";
+  while (dir !== root) {
+    try {
+      await stat(join(dir, PROJECT_ASPECTS_DIR_NAME));
+      cachedProjectRoot = dir;
+      return dir;
+    } catch {
+      try {
+        await stat(join(dir, "aspects.json"));
+        cachedProjectRoot = dir;
+        return dir;
+      } catch {}
+    }
+    dir = join(dir, "..");
+  }
+  cachedProjectRoot = "";
+  return null;
+}
+function getAspectsHome(scope, projectRoot) {
+  if (scope === "global") {
+    return ASPECTS_HOME;
+  }
+  return join(projectRoot || process.cwd(), PROJECT_ASPECTS_DIR_NAME);
+}
+function getConfigPath(scope, projectRoot) {
+  return join(getAspectsHome(scope, projectRoot), "config.json");
 }
-async function ensureSetsDir() {
-  await mkdir(SETS_DIR, { recursive: true });
+async function ensureAspectsDir(scope = "global", projectRoot) {
+  const aspectsDir = join(getAspectsHome(scope, projectRoot), "aspects");
+  await mkdir(aspectsDir, { recursive: true });
 }
-function getSetsDir() {
-  return SETS_DIR;
+async function ensureSetsDir(scope = "global", projectRoot) {
+  const setsDir = join(getAspectsHome(scope, projectRoot), "sets");
+  await mkdir(setsDir, { recursive: true });
 }
-function getAspectPath(name) {
-  return join(ASPECTS_DIR, name);
+function getSetsDir(scope = "global", projectRoot) {
+  return join(getAspectsHome(scope, projectRoot), "sets");
+}
+function getAspectPath(name, scope = "global", projectRoot) {
+  const aspectsDir = join(getAspectsHome(scope, projectRoot), "aspects");
+  return join(aspectsDir, name);
 }
 
 // src/lib/config.ts
 import { readFile, writeFile } from "node:fs/promises";
+var DEFAULT_REGISTRY_API_URL = "https://aspects.sh/api/v1";
+function resolveRegistryUrl(envUrl, configUrl) {
+  if (envUrl)
+    return envUrl;
+  if (configUrl)
+    return configUrl;
+  return DEFAULT_REGISTRY_API_URL;
+}
 function createDefaultConfig() {
   return {
     version: 1,
@@ -20746,54 +20794,96 @@ function createDefaultConfig() {
     settings: {}
   };
 }
-async function readConfig() {
-  await ensureAspectsDir();
+async function readConfig(scope = "global", projectRoot) {
+  await ensureAspectsDir(scope, projectRoot);
+  const configPath = scope === "global" ? CONFIG_PATH : getConfigPath(scope, projectRoot);
   try {
-    const content = await readFile(CONFIG_PATH, "utf-8");
+    const content = await readFile(configPath, "utf-8");
     return JSON.parse(content);
   } catch (err) {
     if (err.code === "ENOENT") {
       const config2 = createDefaultConfig();
-      await writeConfig(config2);
+      await writeConfig(config2, scope, projectRoot);
       return config2;
     }
     throw err;
   }
 }
-async function writeConfig(config2) {
-  await ensureAspectsDir();
-  await writeFile(CONFIG_PATH, JSON.stringify(config2, null, 2) + `
+async function writeConfig(config2, scope = "global", projectRoot) {
+  await ensureAspectsDir(scope, projectRoot);
+  const configPath = scope === "global" ? CONFIG_PATH : getConfigPath(scope, projectRoot);
+  await writeFile(configPath, JSON.stringify(config2, null, 2) + `
 `);
 }
-async function addInstalledAspect(name, info) {
-  const config2 = await readConfig();
+async function addInstalledAspect(name, info, scope = "global", projectRoot) {
+  const config2 = await readConfig(scope, projectRoot);
   config2.installed[name] = info;
-  await writeConfig(config2);
+  await writeConfig(config2, scope, projectRoot);
 }
-async function removeInstalledAspect(name) {
-  const config2 = await readConfig();
+async function removeInstalledAspect(name, scope = "global", projectRoot) {
+  const config2 = await readConfig(scope, projectRoot);
   if (!(name in config2.installed)) {
     return false;
   }
   delete config2.installed[name];
-  await writeConfig(config2);
+  await writeConfig(config2, scope, projectRoot);
   return true;
 }
-async function getInstalledAspect(name) {
-  const config2 = await readConfig();
+async function getInstalledAspect(name, scope = "global", projectRoot) {
+  const config2 = await readConfig(scope, projectRoot);
   return config2.installed[name] ?? null;
 }
-async function listInstalledAspects() {
-  const config2 = await readConfig();
+async function listInstalledAspects(scope = "global", projectRoot) {
+  const config2 = await readConfig(scope, projectRoot);
   return Object.entries(config2.installed).map(([name, info]) => ({
     name,
+    scope,
     ...info
   }));
 }
+async function listAllInstalledAspects(projectRoot) {
+  const globalAspects = await listInstalledAspects("global");
+  try {
+    const projectAspects = await listInstalledAspects("project", projectRoot);
+    return [...projectAspects, ...globalAspects];
+  } catch {
+    return globalAspects;
+  }
+}
+async function getRegistryUrl() {
+  const config2 = await readConfig();
+  return resolveRegistryUrl(process.env.ASPECTS_REGISTRY_URL, config2.settings.registryUrl);
+}
+async function getAuthToken() {
+  const config2 = await readConfig();
+  if (!config2.auth?.accessToken)
+    return null;
+  if (config2.auth.expiresAt && new Date(config2.auth.expiresAt) < new Date) {
+    return null;
+  }
+  return config2.auth.accessToken;
+}
+async function getAuth() {
+  const config2 = await readConfig();
+  return config2.auth ?? null;
+}
+async function isLoggedIn() {
+  return await getAuthToken() !== null;
+}
+async function setAuthTokens(tokens) {
+  const config2 = await readConfig();
+  config2.auth = tokens;
+  await writeConfig(config2);
+}
+async function clearAuth() {
+  const config2 = await readConfig();
+  delete config2.auth;
+  await writeConfig(config2);
+}
 
 // src/lib/installer.ts
-import { mkdir as mkdir2, writeFile as writeFile2, readFile as readFile3, stat } from "node:fs/promises";
-import { join as join2, dirname } from "node:path";
+import { mkdir as mkdir2, writeFile as writeFile2, readFile as readFile3, stat as stat2, access } from "node:fs/promises";
+import { join as join3, dirname } from "node:path";
 
 // node_modules/ofetch/dist/node.mjs
 import http from "node:http";
@@ -21474,103 +21564,1755 @@ function formatZodErrors(error48) {
   });
 }
 
+// src/lib/api-client.ts
+var cache = new Map;
+function getCached(key) {
+  const entry = cache.get(key);
+  if (!entry)
+    return null;
+  if (Date.now() - entry.timestamp > entry.ttl) {
+    cache.delete(key);
+    return null;
+  }
+  return entry.data;
+}
+function setCache(key, data, ttlMs) {
+  cache.set(key, { data, timestamp: Date.now(), ttl: ttlMs });
+}
+class ApiClientError extends Error {
+  statusCode;
+  errorCode;
+  constructor(message, statusCode, errorCode) {
+    super(message);
+    this.statusCode = statusCode;
+    this.errorCode = errorCode;
+    this.name = "ApiClientError";
+  }
+}
+function parseApiError(err) {
+  const fetchErr = err;
+  const status = fetchErr?.statusCode ?? fetchErr?.status ?? 0;
+  const body = fetchErr?.data;
+  if (body && typeof body === "object" && "message" in body) {
+    return new ApiClientError(body.message, status, body.error);
+  }
+  if (status === 0 || !status) {
+    return new ApiClientError("Network error. Check your connection and try again.", 0, "network_error");
+  }
+  return new ApiClientError(`Request failed with status ${status}`, status);
+}
+var MAX_RETRIES = 3;
+var TIMEOUT_MS = 30000;
+async function apiFetch(path, options = {}) {
+  const baseUrl = options.baseUrl ?? await getRegistryUrl();
+  const url2 = `${baseUrl}${path}`;
+  const headers = {
+    Accept: "application/json"
+  };
+  if (options.auth) {
+    const token = await getAuthToken();
+    if (!token) {
+      throw new ApiClientError('Not logged in. Run "aspects login" first.', 401, "unauthorized");
+    }
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  if (options.body) {
+    headers["Content-Type"] = "application/json";
+  }
+  let lastError;
+  for (let attempt = 1;attempt <= MAX_RETRIES; attempt++) {
+    try {
+      return await ofetch(url2, {
+        method: options.method ?? "GET",
+        headers,
+        body: options.body ? JSON.stringify(options.body) : undefined,
+        timeout: TIMEOUT_MS,
+        parseResponse: JSON.parse
+      });
+    } catch (err) {
+      lastError = err;
+      const fetchErr = err;
+      const status = fetchErr?.statusCode ?? fetchErr?.status ?? 0;
+      if (status >= 400 && status < 500 && status !== 429) {
+        throw parseApiError(err);
+      }
+      if (attempt < MAX_RETRIES && (status === 429 || status >= 500 || status === 0)) {
+        const delay = Math.pow(2, attempt - 1) * 1000;
+        await new Promise((r6) => setTimeout(r6, delay));
+        continue;
+      }
+    }
+  }
+  throw parseApiError(lastError);
+}
+async function getRegistry(baseUrl) {
+  const cacheKey = `registry:${baseUrl ?? "default"}`;
+  const cached2 = getCached(cacheKey);
+  if (cached2)
+    return cached2;
+  const data = await apiFetch("/registry", { baseUrl });
+  setCache(cacheKey, data, 5 * 60 * 1000);
+  return data;
+}
+async function getAspect(name) {
+  return apiFetch(`/aspects/${encodeURIComponent(name)}`);
+}
+async function getAspectVersion(name, version2) {
+  return apiFetch(`/aspects/${encodeURIComponent(name)}/${encodeURIComponent(version2)}`);
+}
+async function searchAspects(params) {
+  const searchParams = new URLSearchParams;
+  if (params.q)
+    searchParams.set("q", params.q);
+  if (params.category)
+    searchParams.set("category", params.category);
+  if (params.trust)
+    searchParams.set("trust", params.trust);
+  if (params.limit)
+    searchParams.set("limit", String(params.limit));
+  if (params.offset)
+    searchParams.set("offset", String(params.offset));
+  const query = searchParams.toString();
+  return apiFetch(`/search${query ? `?${query}` : ""}`);
+}
+async function publishAspect(aspect) {
+  return apiFetch("/aspects", {
+    method: "POST",
+    body: { aspect },
+    auth: true
+  });
+}
+async function publishAnonymous(aspect) {
+  return apiFetch("/aspects/blob", {
+    method: "POST",
+    body: aspect,
+    auth: false
+  });
+}
+async function getAspectByHash(hash2) {
+  return apiFetch(`/aspects/blob/${encodeURIComponent(hash2)}`);
+}
+async function unpublishAspect(name, version2) {
+  return apiFetch(`/aspects/${encodeURIComponent(name)}/${encodeURIComponent(version2)}`, { method: "DELETE", auth: true });
+}
+async function initiateDeviceAuth() {
+  return apiFetch("/auth/device", { method: "POST" });
+}
+async function pollDeviceAuth(deviceCode, codeVerifier) {
+  const baseUrl = await getRegistryUrl();
+  const url2 = `${baseUrl}/auth/device/poll`;
+  return ofetch(url2, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Accept: "application/json"
+    },
+    body: JSON.stringify({ device_code: deviceCode, code_verifier: codeVerifier }),
+    timeout: TIMEOUT_MS,
+    parseResponse: JSON.parse
+  });
+}
+
 // src/lib/registry.ts
-var DEFAULT_REGISTRY_URL = "https://raw.githubusercontent.com/aimorphist/aspects/main/registry/index.json";
+var FALLBACK_REGISTRY_URL = "https://raw.githubusercontent.com/aimorphist/aspects/main/registry/index.json";
 var cachedIndex = null;
-async function fetchRegistryIndex(registryUrl) {
+async function fetchRegistryIndex() {
   if (cachedIndex)
     return cachedIndex;
-  const url2 = registryUrl ?? DEFAULT_REGISTRY_URL;
   try {
-    const result = await ofetch(url2, { parseResponse: JSON.parse });
-    if (!result) {
-      throw new Error("Registry returned empty response");
-    }
-    cachedIndex = result;
+    cachedIndex = await getRegistry();
     return cachedIndex;
-  } catch (err) {
-    throw new Error(`Failed to fetch registry from ${url2}: ${err.message}`);
+  } catch {
+    try {
+      const result = await ofetch(FALLBACK_REGISTRY_URL, { parseResponse: JSON.parse });
+      if (!result)
+        throw new Error("Registry returned empty response");
+      cachedIndex = result;
+      return cachedIndex;
+    } catch (err) {
+      throw new Error(`Failed to fetch registry: ${err.message}`);
+    }
   }
 }
 async function getRegistryAspect(name) {
-  const index = await fetchRegistryIndex();
-  return index.aspects[name] ?? null;
+  try {
+    const detail = await getAspect(name);
+    return apiDetailToRegistryAspect(detail);
+  } catch (err) {
+    if (err instanceof ApiClientError && err.statusCode === 404) {
+      return null;
+    }
+    try {
+      const index = await fetchRegistryIndex();
+      return index.aspects[name] ?? null;
+    } catch {
+      throw err;
+    }
+  }
 }
-async function fetchAspectYaml(url2) {
-  return await ofetch(url2, { responseType: "text" });
+async function fetchAspectVersion(name, version2) {
+  return getAspectVersion(name, version2);
 }
-
-// src/utils/hash.ts
-import { createHash } from "node:crypto";
-function sha256(content) {
-  return createHash("sha256").update(content, "utf-8").digest("hex");
+async function fetchAspectContent(url2) {
+  return await ofetch(url2, { responseType: "text" });
 }
-
-// src/utils/logger.ts
-var logger = consola.create({
-  formatOptions: {
-    date: false
-  }
-});
-var log = {
-  info: logger.info.bind(logger),
-  success: logger.success.bind(logger),
-  warn: logger.warn.bind(logger),
-  error: logger.error.bind(logger),
-  box: logger.box.bind(logger),
-  start: logger.start.bind(logger)
-};
-
-// src/lib/installer.ts
-async function installAspect(spec) {
-  switch (spec.type) {
-    case "registry":
-      return installFromRegistry(spec.name, spec.version);
-    case "local":
-      return installFromLocal(spec.path);
-    case "github":
-      return installFromGitHub(spec.owner, spec.repo, spec.ref);
-  }
+async function searchRegistry(params) {
+  return searchAspects(params);
 }
-async function installFromRegistry(name, version2) {
-  let registryAspect;
+async function getAspectDetail(name) {
   try {
-    registryAspect = await getRegistryAspect(name);
+    return await getAspect(name);
   } catch (err) {
-    return {
-      success: false,
-      error: `Unable to reach registry: ${err.message}. Make sure you have network connectivity or try installing from a local path.`
-    };
-  }
-  if (!registryAspect) {
-    return { success: false, error: `Aspect "${name}" not found in registry` };
+    if (err instanceof ApiClientError && err.statusCode === 404) {
+      return null;
+    }
+    throw err;
   }
-  const targetVersion = version2 ?? registryAspect.latest;
-  const versionInfo = registryAspect.versions[targetVersion];
-  if (!versionInfo) {
-    const available = Object.keys(registryAspect.versions).join(", ");
-    return {
-      success: false,
-      error: `Version "${targetVersion}" not found. Available: ${available}`
+}
+async function fetchAspectByHash(hash2) {
+  return getAspectByHash(hash2);
+}
+function apiDetailToRegistryAspect(detail) {
+  const versions2 = {};
+  for (const [ver, info] of Object.entries(detail.versions)) {
+    versions2[ver] = {
+      published: info.published,
+      url: "",
+      blake3: info.blake3,
+      size: info.size
     };
   }
-  const existing = await getInstalledAspect(name);
-  if (existing && existing.version === targetVersion) {
-    const aspect2 = await loadAspectFromPath(getAspectPath(name));
-    if (aspect2) {
-      return { success: true, aspect: aspect2, source: "registry", alreadyInstalled: true };
+  return {
+    latest: detail.latest,
+    versions: versions2,
+    metadata: {
+      displayName: detail.versions[detail.latest]?.aspect?.displayName ?? detail.name,
+      tagline: detail.versions[detail.latest]?.aspect?.tagline ?? "",
+      category: detail.versions[detail.latest]?.aspect?.category,
+      tags: detail.versions[detail.latest]?.aspect?.tags,
+      publisher: detail.publisher,
+      trust: detail.trust
     }
-  }
+  };
+}
+
+// node_modules/@noble/hashes/utils.js
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+function isBytes(a2) {
+  return a2 instanceof Uint8Array || ArrayBuffer.isView(a2) && a2.constructor.name === "Uint8Array";
+}
+function anumber(n5, title = "") {
+  if (!Number.isSafeInteger(n5) || n5 < 0) {
+    const prefix = title && `"${title}" `;
+    throw new Error(`${prefix}expected integer >= 0, got ${n5}`);
+  }
+}
+function abytes(value, length, title = "") {
+  const bytes = isBytes(value);
+  const len = value?.length;
+  const needsLen = length !== undefined;
+  if (!bytes || needsLen && len !== length) {
+    const prefix = title && `"${title}" `;
+    const ofLen = needsLen ? ` of length ${length}` : "";
+    const got = bytes ? `length=${len}` : `type=${typeof value}`;
+    throw new Error(prefix + "expected Uint8Array" + ofLen + ", got " + got);
+  }
+  return value;
+}
+function aexists(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function aoutput(out, instance) {
+  abytes(out, undefined, "digestInto() output");
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new Error('"digestInto() output" expected to be of length >=' + min);
+  }
+}
+function u8(arr) {
+  return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+function u32(arr) {
+  return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+}
+function clean(...arrays) {
+  for (let i2 = 0;i2 < arrays.length; i2++) {
+    arrays[i2].fill(0);
+  }
+}
+function rotr(word, shift) {
+  return word << 32 - shift | word >>> shift;
+}
+var isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
+function byteSwap(word) {
+  return word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
+}
+var swap8IfBE = isLE ? (n5) => n5 : (n5) => byteSwap(n5);
+function byteSwap32(arr) {
+  for (let i2 = 0;i2 < arr.length; i2++) {
+    arr[i2] = byteSwap(arr[i2]);
+  }
+  return arr;
+}
+var swap32IfBE = isLE ? (u4) => u4 : byteSwap32;
+function createHasher(hashCons, info = {}) {
+  const hashC = (msg, opts) => hashCons(opts).update(msg).digest();
+  const tmp = hashCons(undefined);
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = (opts) => hashCons(opts);
+  Object.assign(hashC, info);
+  return Object.freeze(hashC);
+}
+
+// node_modules/@noble/hashes/_md.js
+var SHA256_IV = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
+
+// node_modules/@noble/hashes/_u64.js
+var U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+var _32n = /* @__PURE__ */ BigInt(32);
+function fromBig(n5, le4 = false) {
+  if (le4)
+    return { h: Number(n5 & U32_MASK64), l: Number(n5 >> _32n & U32_MASK64) };
+  return { h: Number(n5 >> _32n & U32_MASK64) | 0, l: Number(n5 & U32_MASK64) | 0 };
+}
+var rotrSH = (h4, l3, s2) => h4 >>> s2 | l3 << 32 - s2;
+var rotrSL = (h4, l3, s2) => h4 << 32 - s2 | l3 >>> s2;
+var rotrBH = (h4, l3, s2) => h4 << 64 - s2 | l3 >>> s2 - 32;
+var rotrBL = (h4, l3, s2) => h4 >>> s2 - 32 | l3 << 64 - s2;
+var rotr32H = (_h, l3) => l3;
+var rotr32L = (h4, _l2) => h4;
+function add(Ah, Al2, Bh, Bl2) {
+  const l3 = (Al2 >>> 0) + (Bl2 >>> 0);
+  return { h: Ah + Bh + (l3 / 2 ** 32 | 0) | 0, l: l3 | 0 };
+}
+var add3L = (Al2, Bl2, Cl2) => (Al2 >>> 0) + (Bl2 >>> 0) + (Cl2 >>> 0);
+var add3H = (low, Ah, Bh, Ch) => Ah + Bh + Ch + (low / 2 ** 32 | 0) | 0;
+
+// node_modules/@noble/hashes/_blake.js
+var BSIGMA = /* @__PURE__ */ Uint8Array.from([
+  0,
+  1,
+  2,
+  3,
+  4,
+  5,
+  6,
+  7,
+  8,
+  9,
+  10,
+  11,
+  12,
+  13,
+  14,
+  15,
+  14,
+  10,
+  4,
+  8,
+  9,
+  15,
+  13,
+  6,
+  1,
+  12,
+  0,
+  2,
+  11,
+  7,
+  5,
+  3,
+  11,
+  8,
+  12,
+  0,
+  5,
+  2,
+  15,
+  13,
+  10,
+  14,
+  3,
+  6,
+  7,
+  1,
+  9,
+  4,
+  7,
+  9,
+  3,
+  1,
+  13,
+  12,
+  11,
+  14,
+  2,
+  6,
+  5,
+  10,
+  4,
+  0,
+  15,
+  8,
+  9,
+  0,
+  5,
+  7,
+  2,
+  4,
+  10,
+  15,
+  14,
+  1,
+  11,
+  12,
+  6,
+  8,
+  3,
+  13,
+  2,
+  12,
+  6,
+  10,
+  0,
+  11,
+  8,
+  3,
+  4,
+  13,
+  7,
+  5,
+  15,
+  14,
+  1,
+  9,
+  12,
+  5,
+  1,
+  15,
+  14,
+  13,
+  4,
+  10,
+  0,
+  7,
+  6,
+  3,
+  9,
+  2,
+  8,
+  11,
+  13,
+  11,
+  7,
+  14,
+  12,
+  1,
+  3,
+  9,
+  5,
+  0,
+  15,
+  4,
+  8,
+  6,
+  2,
+  10,
+  6,
+  15,
+  14,
+  9,
+  11,
+  3,
+  0,
+  8,
+  12,
+  2,
+  13,
+  7,
+  1,
+  4,
+  10,
+  5,
+  10,
+  2,
+  8,
+  4,
+  7,
+  6,
+  1,
+  5,
+  15,
+  11,
+  9,
+  14,
+  3,
+  12,
+  13,
+  0,
+  0,
+  1,
+  2,
+  3,
+  4,
+  5,
+  6,
+  7,
+  8,
+  9,
+  10,
+  11,
+  12,
+  13,
+  14,
+  15,
+  14,
+  10,
+  4,
+  8,
+  9,
+  15,
+  13,
+  6,
+  1,
+  12,
+  0,
+  2,
+  11,
+  7,
+  5,
+  3,
+  11,
+  8,
+  12,
+  0,
+  5,
+  2,
+  15,
+  13,
+  10,
+  14,
+  3,
+  6,
+  7,
+  1,
+  9,
+  4,
+  7,
+  9,
+  3,
+  1,
+  13,
+  12,
+  11,
+  14,
+  2,
+  6,
+  5,
+  10,
+  4,
+  0,
+  15,
+  8,
+  9,
+  0,
+  5,
+  7,
+  2,
+  4,
+  10,
+  15,
+  14,
+  1,
+  11,
+  12,
+  6,
+  8,
+  3,
+  13,
+  2,
+  12,
+  6,
+  10,
+  0,
+  11,
+  8,
+  3,
+  4,
+  13,
+  7,
+  5,
+  15,
+  14,
+  1,
+  9
+]);
+function G1s(a2, b4, c5, d4, x4) {
+  a2 = a2 + b4 + x4 | 0;
+  d4 = rotr(d4 ^ a2, 16);
+  c5 = c5 + d4 | 0;
+  b4 = rotr(b4 ^ c5, 12);
+  return { a: a2, b: b4, c: c5, d: d4 };
+}
+function G2s(a2, b4, c5, d4, x4) {
+  a2 = a2 + b4 + x4 | 0;
+  d4 = rotr(d4 ^ a2, 8);
+  c5 = c5 + d4 | 0;
+  b4 = rotr(b4 ^ c5, 7);
+  return { a: a2, b: b4, c: c5, d: d4 };
+}
+
+// node_modules/@noble/hashes/blake2.js
+var B2B_IV = /* @__PURE__ */ Uint32Array.from([
+  4089235720,
+  1779033703,
+  2227873595,
+  3144134277,
+  4271175723,
+  1013904242,
+  1595750129,
+  2773480762,
+  2917565137,
+  1359893119,
+  725511199,
+  2600822924,
+  4215389547,
+  528734635,
+  327033209,
+  1541459225
+]);
+var BBUF = /* @__PURE__ */ new Uint32Array(32);
+function G1b(a2, b4, c5, d4, msg, x4) {
+  const Xl = msg[x4], Xh = msg[x4 + 1];
+  let Al2 = BBUF[2 * a2], Ah = BBUF[2 * a2 + 1];
+  let Bl2 = BBUF[2 * b4], Bh = BBUF[2 * b4 + 1];
+  let Cl2 = BBUF[2 * c5], Ch = BBUF[2 * c5 + 1];
+  let Dl = BBUF[2 * d4], Dh = BBUF[2 * d4 + 1];
+  let ll2 = add3L(Al2, Bl2, Xl);
+  Ah = add3H(ll2, Ah, Bh, Xh);
+  Al2 = ll2 | 0;
+  ({ Dh, Dl } = { Dh: Dh ^ Ah, Dl: Dl ^ Al2 });
+  ({ Dh, Dl } = { Dh: rotr32H(Dh, Dl), Dl: rotr32L(Dh, Dl) });
+  ({ h: Ch, l: Cl2 } = add(Ch, Cl2, Dh, Dl));
+  ({ Bh, Bl: Bl2 } = { Bh: Bh ^ Ch, Bl: Bl2 ^ Cl2 });
+  ({ Bh, Bl: Bl2 } = { Bh: rotrSH(Bh, Bl2, 24), Bl: rotrSL(Bh, Bl2, 24) });
+  BBUF[2 * a2] = Al2, BBUF[2 * a2 + 1] = Ah;
+  BBUF[2 * b4] = Bl2, BBUF[2 * b4 + 1] = Bh;
+  BBUF[2 * c5] = Cl2, BBUF[2 * c5 + 1] = Ch;
+  BBUF[2 * d4] = Dl, BBUF[2 * d4 + 1] = Dh;
+}
+function G2b(a2, b4, c5, d4, msg, x4) {
+  const Xl = msg[x4], Xh = msg[x4 + 1];
+  let Al2 = BBUF[2 * a2], Ah = BBUF[2 * a2 + 1];
+  let Bl2 = BBUF[2 * b4], Bh = BBUF[2 * b4 + 1];
+  let Cl2 = BBUF[2 * c5], Ch = BBUF[2 * c5 + 1];
+  let Dl = BBUF[2 * d4], Dh = BBUF[2 * d4 + 1];
+  let ll2 = add3L(Al2, Bl2, Xl);
+  Ah = add3H(ll2, Ah, Bh, Xh);
+  Al2 = ll2 | 0;
+  ({ Dh, Dl } = { Dh: Dh ^ Ah, Dl: Dl ^ Al2 });
+  ({ Dh, Dl } = { Dh: rotrSH(Dh, Dl, 16), Dl: rotrSL(Dh, Dl, 16) });
+  ({ h: Ch, l: Cl2 } = add(Ch, Cl2, Dh, Dl));
+  ({ Bh, Bl: Bl2 } = { Bh: Bh ^ Ch, Bl: Bl2 ^ Cl2 });
+  ({ Bh, Bl: Bl2 } = { Bh: rotrBH(Bh, Bl2, 63), Bl: rotrBL(Bh, Bl2, 63) });
+  BBUF[2 * a2] = Al2, BBUF[2 * a2 + 1] = Ah;
+  BBUF[2 * b4] = Bl2, BBUF[2 * b4 + 1] = Bh;
+  BBUF[2 * c5] = Cl2, BBUF[2 * c5 + 1] = Ch;
+  BBUF[2 * d4] = Dl, BBUF[2 * d4 + 1] = Dh;
+}
+function checkBlake2Opts(outputLen, opts = {}, keyLen, saltLen, persLen) {
+  anumber(keyLen);
+  if (outputLen < 0 || outputLen > keyLen)
+    throw new Error("outputLen bigger than keyLen");
+  const { key, salt, personalization } = opts;
+  if (key !== undefined && (key.length < 1 || key.length > keyLen))
+    throw new Error('"key" expected to be undefined or of length=1..' + keyLen);
+  if (salt !== undefined)
+    abytes(salt, saltLen, "salt");
+  if (personalization !== undefined)
+    abytes(personalization, persLen, "personalization");
+}
+
+class _BLAKE2 {
+  buffer;
+  buffer32;
+  finished = false;
+  destroyed = false;
+  length = 0;
+  pos = 0;
+  blockLen;
+  outputLen;
+  constructor(blockLen, outputLen) {
+    anumber(blockLen);
+    anumber(outputLen);
+    this.blockLen = blockLen;
+    this.outputLen = outputLen;
+    this.buffer = new Uint8Array(blockLen);
+    this.buffer32 = u32(this.buffer);
+  }
+  update(data) {
+    aexists(this);
+    abytes(data);
+    const { blockLen, buffer, buffer32 } = this;
+    const len = data.length;
+    const offset = data.byteOffset;
+    const buf = data.buffer;
+    for (let pos = 0;pos < len; ) {
+      if (this.pos === blockLen) {
+        swap32IfBE(buffer32);
+        this.compress(buffer32, 0, false);
+        swap32IfBE(buffer32);
+        this.pos = 0;
+      }
+      const take = Math.min(blockLen - this.pos, len - pos);
+      const dataOffset = offset + pos;
+      if (take === blockLen && !(dataOffset % 4) && pos + take < len) {
+        const data32 = new Uint32Array(buf, dataOffset, Math.floor((len - pos) / 4));
+        swap32IfBE(data32);
+        for (let pos32 = 0;pos + blockLen < len; pos32 += buffer32.length, pos += blockLen) {
+          this.length += blockLen;
+          this.compress(data32, pos32, false);
+        }
+        swap32IfBE(data32);
+        continue;
+      }
+      buffer.set(data.subarray(pos, pos + take), this.pos);
+      this.pos += take;
+      this.length += take;
+      pos += take;
+    }
+    return this;
+  }
+  digestInto(out) {
+    aexists(this);
+    aoutput(out, this);
+    const { pos, buffer32 } = this;
+    this.finished = true;
+    clean(this.buffer.subarray(pos));
+    swap32IfBE(buffer32);
+    this.compress(buffer32, 0, true);
+    swap32IfBE(buffer32);
+    const out32 = u32(out);
+    this.get().forEach((v4, i2) => out32[i2] = swap8IfBE(v4));
+  }
+  digest() {
+    const { buffer, outputLen } = this;
+    this.digestInto(buffer);
+    const res = buffer.slice(0, outputLen);
+    this.destroy();
+    return res;
+  }
+  _cloneInto(to) {
+    const { buffer, length, finished, destroyed, outputLen, pos } = this;
+    to ||= new this.constructor({ dkLen: outputLen });
+    to.set(...this.get());
+    to.buffer.set(buffer);
+    to.destroyed = destroyed;
+    to.finished = finished;
+    to.length = length;
+    to.pos = pos;
+    to.outputLen = outputLen;
+    return to;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+}
+
+class _BLAKE2b extends _BLAKE2 {
+  v0l = B2B_IV[0] | 0;
+  v0h = B2B_IV[1] | 0;
+  v1l = B2B_IV[2] | 0;
+  v1h = B2B_IV[3] | 0;
+  v2l = B2B_IV[4] | 0;
+  v2h = B2B_IV[5] | 0;
+  v3l = B2B_IV[6] | 0;
+  v3h = B2B_IV[7] | 0;
+  v4l = B2B_IV[8] | 0;
+  v4h = B2B_IV[9] | 0;
+  v5l = B2B_IV[10] | 0;
+  v5h = B2B_IV[11] | 0;
+  v6l = B2B_IV[12] | 0;
+  v6h = B2B_IV[13] | 0;
+  v7l = B2B_IV[14] | 0;
+  v7h = B2B_IV[15] | 0;
+  constructor(opts = {}) {
+    const olen = opts.dkLen === undefined ? 64 : opts.dkLen;
+    super(128, olen);
+    checkBlake2Opts(olen, opts, 64, 16, 16);
+    let { key, personalization, salt } = opts;
+    let keyLength = 0;
+    if (key !== undefined) {
+      abytes(key, undefined, "key");
+      keyLength = key.length;
+    }
+    this.v0l ^= this.outputLen | keyLength << 8 | 1 << 16 | 1 << 24;
+    if (salt !== undefined) {
+      abytes(salt, undefined, "salt");
+      const slt = u32(salt);
+      this.v4l ^= swap8IfBE(slt[0]);
+      this.v4h ^= swap8IfBE(slt[1]);
+      this.v5l ^= swap8IfBE(slt[2]);
+      this.v5h ^= swap8IfBE(slt[3]);
+    }
+    if (personalization !== undefined) {
+      abytes(personalization, undefined, "personalization");
+      const pers = u32(personalization);
+      this.v6l ^= swap8IfBE(pers[0]);
+      this.v6h ^= swap8IfBE(pers[1]);
+      this.v7l ^= swap8IfBE(pers[2]);
+      this.v7h ^= swap8IfBE(pers[3]);
+    }
+    if (key !== undefined) {
+      const tmp = new Uint8Array(this.blockLen);
+      tmp.set(key);
+      this.update(tmp);
+    }
+  }
+  get() {
+    let { v0l, v0h, v1l, v1h, v2l, v2h, v3l, v3h, v4l, v4h, v5l, v5h, v6l, v6h, v7l, v7h } = this;
+    return [v0l, v0h, v1l, v1h, v2l, v2h, v3l, v3h, v4l, v4h, v5l, v5h, v6l, v6h, v7l, v7h];
+  }
+  set(v0l, v0h, v1l, v1h, v2l, v2h, v3l, v3h, v4l, v4h, v5l, v5h, v6l, v6h, v7l, v7h) {
+    this.v0l = v0l | 0;
+    this.v0h = v0h | 0;
+    this.v1l = v1l | 0;
+    this.v1h = v1h | 0;
+    this.v2l = v2l | 0;
+    this.v2h = v2h | 0;
+    this.v3l = v3l | 0;
+    this.v3h = v3h | 0;
+    this.v4l = v4l | 0;
+    this.v4h = v4h | 0;
+    this.v5l = v5l | 0;
+    this.v5h = v5h | 0;
+    this.v6l = v6l | 0;
+    this.v6h = v6h | 0;
+    this.v7l = v7l | 0;
+    this.v7h = v7h | 0;
+  }
+  compress(msg, offset, isLast) {
+    this.get().forEach((v4, i2) => BBUF[i2] = v4);
+    BBUF.set(B2B_IV, 16);
+    let { h: h4, l: l3 } = fromBig(BigInt(this.length));
+    BBUF[24] = B2B_IV[8] ^ l3;
+    BBUF[25] = B2B_IV[9] ^ h4;
+    if (isLast) {
+      BBUF[28] = ~BBUF[28];
+      BBUF[29] = ~BBUF[29];
+    }
+    let j2 = 0;
+    const s2 = BSIGMA;
+    for (let i2 = 0;i2 < 12; i2++) {
+      G1b(0, 4, 8, 12, msg, offset + 2 * s2[j2++]);
+      G2b(0, 4, 8, 12, msg, offset + 2 * s2[j2++]);
+      G1b(1, 5, 9, 13, msg, offset + 2 * s2[j2++]);
+      G2b(1, 5, 9, 13, msg, offset + 2 * s2[j2++]);
+      G1b(2, 6, 10, 14, msg, offset + 2 * s2[j2++]);
+      G2b(2, 6, 10, 14, msg, offset + 2 * s2[j2++]);
+      G1b(3, 7, 11, 15, msg, offset + 2 * s2[j2++]);
+      G2b(3, 7, 11, 15, msg, offset + 2 * s2[j2++]);
+      G1b(0, 5, 10, 15, msg, offset + 2 * s2[j2++]);
+      G2b(0, 5, 10, 15, msg, offset + 2 * s2[j2++]);
+      G1b(1, 6, 11, 12, msg, offset + 2 * s2[j2++]);
+      G2b(1, 6, 11, 12, msg, offset + 2 * s2[j2++]);
+      G1b(2, 7, 8, 13, msg, offset + 2 * s2[j2++]);
+      G2b(2, 7, 8, 13, msg, offset + 2 * s2[j2++]);
+      G1b(3, 4, 9, 14, msg, offset + 2 * s2[j2++]);
+      G2b(3, 4, 9, 14, msg, offset + 2 * s2[j2++]);
+    }
+    this.v0l ^= BBUF[0] ^ BBUF[16];
+    this.v0h ^= BBUF[1] ^ BBUF[17];
+    this.v1l ^= BBUF[2] ^ BBUF[18];
+    this.v1h ^= BBUF[3] ^ BBUF[19];
+    this.v2l ^= BBUF[4] ^ BBUF[20];
+    this.v2h ^= BBUF[5] ^ BBUF[21];
+    this.v3l ^= BBUF[6] ^ BBUF[22];
+    this.v3h ^= BBUF[7] ^ BBUF[23];
+    this.v4l ^= BBUF[8] ^ BBUF[24];
+    this.v4h ^= BBUF[9] ^ BBUF[25];
+    this.v5l ^= BBUF[10] ^ BBUF[26];
+    this.v5h ^= BBUF[11] ^ BBUF[27];
+    this.v6l ^= BBUF[12] ^ BBUF[28];
+    this.v6h ^= BBUF[13] ^ BBUF[29];
+    this.v7l ^= BBUF[14] ^ BBUF[30];
+    this.v7h ^= BBUF[15] ^ BBUF[31];
+    clean(BBUF);
+  }
+  destroy() {
+    this.destroyed = true;
+    clean(this.buffer32);
+    this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+  }
+}
+function compress(s2, offset, msg, rounds, v0, v1, v22, v32, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) {
+  let j2 = 0;
+  for (let i2 = 0;i2 < rounds; i2++) {
+    ({ a: v0, b: v4, c: v8, d: v12 } = G1s(v0, v4, v8, v12, msg[offset + s2[j2++]]));
+    ({ a: v0, b: v4, c: v8, d: v12 } = G2s(v0, v4, v8, v12, msg[offset + s2[j2++]]));
+    ({ a: v1, b: v5, c: v9, d: v13 } = G1s(v1, v5, v9, v13, msg[offset + s2[j2++]]));
+    ({ a: v1, b: v5, c: v9, d: v13 } = G2s(v1, v5, v9, v13, msg[offset + s2[j2++]]));
+    ({ a: v22, b: v6, c: v10, d: v14 } = G1s(v22, v6, v10, v14, msg[offset + s2[j2++]]));
+    ({ a: v22, b: v6, c: v10, d: v14 } = G2s(v22, v6, v10, v14, msg[offset + s2[j2++]]));
+    ({ a: v32, b: v7, c: v11, d: v15 } = G1s(v32, v7, v11, v15, msg[offset + s2[j2++]]));
+    ({ a: v32, b: v7, c: v11, d: v15 } = G2s(v32, v7, v11, v15, msg[offset + s2[j2++]]));
+    ({ a: v0, b: v5, c: v10, d: v15 } = G1s(v0, v5, v10, v15, msg[offset + s2[j2++]]));
+    ({ a: v0, b: v5, c: v10, d: v15 } = G2s(v0, v5, v10, v15, msg[offset + s2[j2++]]));
+    ({ a: v1, b: v6, c: v11, d: v12 } = G1s(v1, v6, v11, v12, msg[offset + s2[j2++]]));
+    ({ a: v1, b: v6, c: v11, d: v12 } = G2s(v1, v6, v11, v12, msg[offset + s2[j2++]]));
+    ({ a: v22, b: v7, c: v8, d: v13 } = G1s(v22, v7, v8, v13, msg[offset + s2[j2++]]));
+    ({ a: v22, b: v7, c: v8, d: v13 } = G2s(v22, v7, v8, v13, msg[offset + s2[j2++]]));
+    ({ a: v32, b: v4, c: v9, d: v14 } = G1s(v32, v4, v9, v14, msg[offset + s2[j2++]]));
+    ({ a: v32, b: v4, c: v9, d: v14 } = G2s(v32, v4, v9, v14, msg[offset + s2[j2++]]));
+  }
+  return { v0, v1, v2: v22, v3: v32, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 };
+}
+var B2S_IV = /* @__PURE__ */ SHA256_IV.slice();
+
+class _BLAKE2s extends _BLAKE2 {
+  v0 = B2S_IV[0] | 0;
+  v1 = B2S_IV[1] | 0;
+  v2 = B2S_IV[2] | 0;
+  v3 = B2S_IV[3] | 0;
+  v4 = B2S_IV[4] | 0;
+  v5 = B2S_IV[5] | 0;
+  v6 = B2S_IV[6] | 0;
+  v7 = B2S_IV[7] | 0;
+  constructor(opts = {}) {
+    const olen = opts.dkLen === undefined ? 32 : opts.dkLen;
+    super(64, olen);
+    checkBlake2Opts(olen, opts, 32, 8, 8);
+    let { key, personalization, salt } = opts;
+    let keyLength = 0;
+    if (key !== undefined) {
+      abytes(key, undefined, "key");
+      keyLength = key.length;
+    }
+    this.v0 ^= this.outputLen | keyLength << 8 | 1 << 16 | 1 << 24;
+    if (salt !== undefined) {
+      abytes(salt, undefined, "salt");
+      const slt = u32(salt);
+      this.v4 ^= swap8IfBE(slt[0]);
+      this.v5 ^= swap8IfBE(slt[1]);
+    }
+    if (personalization !== undefined) {
+      abytes(personalization, undefined, "personalization");
+      const pers = u32(personalization);
+      this.v6 ^= swap8IfBE(pers[0]);
+      this.v7 ^= swap8IfBE(pers[1]);
+    }
+    if (key !== undefined) {
+      const tmp = new Uint8Array(this.blockLen);
+      tmp.set(key);
+      this.update(tmp);
+    }
+  }
+  get() {
+    const { v0, v1, v2: v22, v3: v32, v4, v5, v6, v7 } = this;
+    return [v0, v1, v22, v32, v4, v5, v6, v7];
+  }
+  set(v0, v1, v22, v32, v4, v5, v6, v7) {
+    this.v0 = v0 | 0;
+    this.v1 = v1 | 0;
+    this.v2 = v22 | 0;
+    this.v3 = v32 | 0;
+    this.v4 = v4 | 0;
+    this.v5 = v5 | 0;
+    this.v6 = v6 | 0;
+    this.v7 = v7 | 0;
+  }
+  compress(msg, offset, isLast) {
+    const { h: h4, l: l3 } = fromBig(BigInt(this.length));
+    const { v0, v1, v2: v22, v3: v32, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 } = compress(BSIGMA, offset, msg, 10, this.v0, this.v1, this.v2, this.v3, this.v4, this.v5, this.v6, this.v7, B2S_IV[0], B2S_IV[1], B2S_IV[2], B2S_IV[3], l3 ^ B2S_IV[4], h4 ^ B2S_IV[5], isLast ? ~B2S_IV[6] : B2S_IV[6], B2S_IV[7]);
+    this.v0 ^= v0 ^ v8;
+    this.v1 ^= v1 ^ v9;
+    this.v2 ^= v22 ^ v10;
+    this.v3 ^= v32 ^ v11;
+    this.v4 ^= v4 ^ v12;
+    this.v5 ^= v5 ^ v13;
+    this.v6 ^= v6 ^ v14;
+    this.v7 ^= v7 ^ v15;
+  }
+  destroy() {
+    this.destroyed = true;
+    clean(this.buffer32);
+    this.set(0, 0, 0, 0, 0, 0, 0, 0);
+  }
+}
+
+// node_modules/@noble/hashes/blake3.js
+var B3_Flags = {
+  CHUNK_START: 1,
+  CHUNK_END: 2,
+  PARENT: 4,
+  ROOT: 8,
+  KEYED_HASH: 16,
+  DERIVE_KEY_CONTEXT: 32,
+  DERIVE_KEY_MATERIAL: 64
+};
+var B3_IV = /* @__PURE__ */ SHA256_IV.slice();
+var B3_SIGMA = /* @__PURE__ */ (() => {
+  const Id = Array.from({ length: 16 }, (_5, i2) => i2);
+  const permute = (arr) => [2, 6, 3, 10, 7, 0, 4, 13, 1, 11, 12, 5, 9, 14, 15, 8].map((i2) => arr[i2]);
+  const res = [];
+  for (let i2 = 0, v4 = Id;i2 < 7; i2++, v4 = permute(v4))
+    res.push(...v4);
+  return Uint8Array.from(res);
+})();
+
+class _BLAKE3 extends _BLAKE2 {
+  chunkPos = 0;
+  chunksDone = 0;
+  flags = 0 | 0;
+  IV;
+  state;
+  stack = [];
+  posOut = 0;
+  bufferOut32 = new Uint32Array(16);
+  bufferOut;
+  chunkOut = 0;
+  enableXOF = true;
+  constructor(opts = {}, flags = 0) {
+    super(64, opts.dkLen === undefined ? 32 : opts.dkLen);
+    const { key, context } = opts;
+    const hasContext = context !== undefined;
+    if (key !== undefined) {
+      if (hasContext)
+        throw new Error('Only "key" or "context" can be specified at same time');
+      abytes(key, 32, "key");
+      const k5 = key.slice();
+      this.IV = u32(k5);
+      swap32IfBE(this.IV);
+      this.flags = flags | B3_Flags.KEYED_HASH;
+    } else if (hasContext) {
+      abytes(context, undefined, "context");
+      const ctx = context;
+      const contextKey = new _BLAKE3({ dkLen: 32 }, B3_Flags.DERIVE_KEY_CONTEXT).update(ctx).digest();
+      this.IV = u32(contextKey);
+      swap32IfBE(this.IV);
+      this.flags = flags | B3_Flags.DERIVE_KEY_MATERIAL;
+    } else {
+      this.IV = B3_IV.slice();
+      this.flags = flags;
+    }
+    this.state = this.IV.slice();
+    this.bufferOut = u8(this.bufferOut32);
+  }
+  get() {
+    return [];
+  }
+  set() {}
+  b2Compress(counter, flags, buf, bufPos = 0) {
+    const { state: s2, pos } = this;
+    const { h: h4, l: l3 } = fromBig(BigInt(counter), true);
+    const { v0, v1, v2: v22, v3: v32, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 } = compress(B3_SIGMA, bufPos, buf, 7, s2[0], s2[1], s2[2], s2[3], s2[4], s2[5], s2[6], s2[7], B3_IV[0], B3_IV[1], B3_IV[2], B3_IV[3], h4, l3, pos, flags);
+    s2[0] = v0 ^ v8;
+    s2[1] = v1 ^ v9;
+    s2[2] = v22 ^ v10;
+    s2[3] = v32 ^ v11;
+    s2[4] = v4 ^ v12;
+    s2[5] = v5 ^ v13;
+    s2[6] = v6 ^ v14;
+    s2[7] = v7 ^ v15;
+  }
+  compress(buf, bufPos = 0, isLast = false) {
+    let flags = this.flags;
+    if (!this.chunkPos)
+      flags |= B3_Flags.CHUNK_START;
+    if (this.chunkPos === 15 || isLast)
+      flags |= B3_Flags.CHUNK_END;
+    if (!isLast)
+      this.pos = this.blockLen;
+    this.b2Compress(this.chunksDone, flags, buf, bufPos);
+    this.chunkPos += 1;
+    if (this.chunkPos === 16 || isLast) {
+      let chunk = this.state;
+      this.state = this.IV.slice();
+      for (let last, chunks = this.chunksDone + 1;isLast || !(chunks & 1); chunks >>= 1) {
+        if (!(last = this.stack.pop()))
+          break;
+        this.buffer32.set(last, 0);
+        this.buffer32.set(chunk, 8);
+        this.pos = this.blockLen;
+        this.b2Compress(0, this.flags | B3_Flags.PARENT, this.buffer32, 0);
+        chunk = this.state;
+        this.state = this.IV.slice();
+      }
+      this.chunksDone++;
+      this.chunkPos = 0;
+      this.stack.push(chunk);
+    }
+    this.pos = 0;
+  }
+  _cloneInto(to) {
+    to = super._cloneInto(to);
+    const { IV, flags, state, chunkPos, posOut, chunkOut, stack, chunksDone } = this;
+    to.state.set(state.slice());
+    to.stack = stack.map((i2) => Uint32Array.from(i2));
+    to.IV.set(IV);
+    to.flags = flags;
+    to.chunkPos = chunkPos;
+    to.chunksDone = chunksDone;
+    to.posOut = posOut;
+    to.chunkOut = chunkOut;
+    to.enableXOF = this.enableXOF;
+    to.bufferOut32.set(this.bufferOut32);
+    return to;
+  }
+  destroy() {
+    this.destroyed = true;
+    clean(this.state, this.buffer32, this.IV, this.bufferOut32);
+    clean(...this.stack);
+  }
+  b2CompressOut() {
+    const { state: s2, pos, flags, buffer32, bufferOut32: out32 } = this;
+    const { h: h4, l: l3 } = fromBig(BigInt(this.chunkOut++));
+    swap32IfBE(buffer32);
+    const { v0, v1, v2: v22, v3: v32, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 } = compress(B3_SIGMA, 0, buffer32, 7, s2[0], s2[1], s2[2], s2[3], s2[4], s2[5], s2[6], s2[7], B3_IV[0], B3_IV[1], B3_IV[2], B3_IV[3], l3, h4, pos, flags);
+    out32[0] = v0 ^ v8;
+    out32[1] = v1 ^ v9;
+    out32[2] = v22 ^ v10;
+    out32[3] = v32 ^ v11;
+    out32[4] = v4 ^ v12;
+    out32[5] = v5 ^ v13;
+    out32[6] = v6 ^ v14;
+    out32[7] = v7 ^ v15;
+    out32[8] = s2[0] ^ v8;
+    out32[9] = s2[1] ^ v9;
+    out32[10] = s2[2] ^ v10;
+    out32[11] = s2[3] ^ v11;
+    out32[12] = s2[4] ^ v12;
+    out32[13] = s2[5] ^ v13;
+    out32[14] = s2[6] ^ v14;
+    out32[15] = s2[7] ^ v15;
+    swap32IfBE(buffer32);
+    swap32IfBE(out32);
+    this.posOut = 0;
+  }
+  finish() {
+    if (this.finished)
+      return;
+    this.finished = true;
+    clean(this.buffer.subarray(this.pos));
+    let flags = this.flags | B3_Flags.ROOT;
+    if (this.stack.length) {
+      flags |= B3_Flags.PARENT;
+      swap32IfBE(this.buffer32);
+      this.compress(this.buffer32, 0, true);
+      swap32IfBE(this.buffer32);
+      this.chunksDone = 0;
+      this.pos = this.blockLen;
+    } else {
+      flags |= (!this.chunkPos ? B3_Flags.CHUNK_START : 0) | B3_Flags.CHUNK_END;
+    }
+    this.flags = flags;
+    this.b2CompressOut();
+  }
+  writeInto(out) {
+    aexists(this, false);
+    abytes(out);
+    this.finish();
+    const { blockLen, bufferOut } = this;
+    for (let pos = 0, len = out.length;pos < len; ) {
+      if (this.posOut >= blockLen)
+        this.b2CompressOut();
+      const take = Math.min(blockLen - this.posOut, len - pos);
+      out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
+      this.posOut += take;
+      pos += take;
+    }
+    return out;
+  }
+  xofInto(out) {
+    if (!this.enableXOF)
+      throw new Error("XOF is not possible after digest call");
+    return this.writeInto(out);
+  }
+  xof(bytes) {
+    anumber(bytes);
+    return this.xofInto(new Uint8Array(bytes));
+  }
+  digestInto(out) {
+    aoutput(out, this);
+    if (this.finished)
+      throw new Error("digest() was already called");
+    this.enableXOF = false;
+    this.writeInto(out);
+    this.destroy();
+    return out;
+  }
+  digest() {
+    return this.digestInto(new Uint8Array(this.outputLen));
+  }
+}
+var blake3 = /* @__PURE__ */ createHasher((opts = {}) => new _BLAKE3(opts));
+
+// node_modules/@scure/base/index.js
+/*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+function isBytes2(a2) {
+  return a2 instanceof Uint8Array || ArrayBuffer.isView(a2) && a2.constructor.name === "Uint8Array";
+}
+function abytes2(b4) {
+  if (!isBytes2(b4))
+    throw new Error("Uint8Array expected");
+}
+function isArrayOf(isString, arr) {
+  if (!Array.isArray(arr))
+    return false;
+  if (arr.length === 0)
+    return true;
+  if (isString) {
+    return arr.every((item) => typeof item === "string");
+  } else {
+    return arr.every((item) => Number.isSafeInteger(item));
+  }
+}
+function afn(input) {
+  if (typeof input !== "function")
+    throw new Error("function expected");
+  return true;
+}
+function astr(label, input) {
+  if (typeof input !== "string")
+    throw new Error(`${label}: string expected`);
+  return true;
+}
+function anumber2(n5) {
+  if (!Number.isSafeInteger(n5))
+    throw new Error(`invalid integer: ${n5}`);
+}
+function aArr(input) {
+  if (!Array.isArray(input))
+    throw new Error("array expected");
+}
+function astrArr(label, input) {
+  if (!isArrayOf(true, input))
+    throw new Error(`${label}: array of strings expected`);
+}
+function anumArr(label, input) {
+  if (!isArrayOf(false, input))
+    throw new Error(`${label}: array of numbers expected`);
+}
+function chain(...args) {
+  const id = (a2) => a2;
+  const wrap = (a2, b4) => (c5) => a2(b4(c5));
+  const encode4 = args.map((x4) => x4.encode).reduceRight(wrap, id);
+  const decode4 = args.map((x4) => x4.decode).reduce(wrap, id);
+  return { encode: encode4, decode: decode4 };
+}
+function alphabet(letters) {
+  const lettersA = typeof letters === "string" ? letters.split("") : letters;
+  const len = lettersA.length;
+  astrArr("alphabet", lettersA);
+  const indexes = new Map(lettersA.map((l3, i2) => [l3, i2]));
+  return {
+    encode: (digits) => {
+      aArr(digits);
+      return digits.map((i2) => {
+        if (!Number.isSafeInteger(i2) || i2 < 0 || i2 >= len)
+          throw new Error(`alphabet.encode: digit index outside alphabet "${i2}". Allowed: ${letters}`);
+        return lettersA[i2];
+      });
+    },
+    decode: (input) => {
+      aArr(input);
+      return input.map((letter) => {
+        astr("alphabet.decode", letter);
+        const i2 = indexes.get(letter);
+        if (i2 === undefined)
+          throw new Error(`Unknown letter: "${letter}". Allowed: ${letters}`);
+        return i2;
+      });
+    }
+  };
+}
+function join2(separator = "") {
+  astr("join", separator);
+  return {
+    encode: (from) => {
+      astrArr("join.decode", from);
+      return from.join(separator);
+    },
+    decode: (to) => {
+      astr("join.decode", to);
+      return to.split(separator);
+    }
+  };
+}
+function padding(bits, chr = "=") {
+  anumber2(bits);
+  astr("padding", chr);
+  return {
+    encode(data) {
+      astrArr("padding.encode", data);
+      while (data.length * bits % 8)
+        data.push(chr);
+      return data;
+    },
+    decode(input) {
+      astrArr("padding.decode", input);
+      let end = input.length;
+      if (end * bits % 8)
+        throw new Error("padding: invalid, string should have whole number of bytes");
+      for (;end > 0 && input[end - 1] === chr; end--) {
+        const last = end - 1;
+        const byte = last * bits;
+        if (byte % 8 === 0)
+          throw new Error("padding: invalid, string has too much padding");
+      }
+      return input.slice(0, end);
+    }
+  };
+}
+function normalize(fn) {
+  afn(fn);
+  return { encode: (from) => from, decode: (to) => fn(to) };
+}
+function convertRadix(data, from, to) {
+  if (from < 2)
+    throw new Error(`convertRadix: invalid from=${from}, base cannot be less than 2`);
+  if (to < 2)
+    throw new Error(`convertRadix: invalid to=${to}, base cannot be less than 2`);
+  aArr(data);
+  if (!data.length)
+    return [];
+  let pos = 0;
+  const res = [];
+  const digits = Array.from(data, (d4) => {
+    anumber2(d4);
+    if (d4 < 0 || d4 >= from)
+      throw new Error(`invalid integer: ${d4}`);
+    return d4;
+  });
+  const dlen = digits.length;
+  while (true) {
+    let carry = 0;
+    let done = true;
+    for (let i2 = pos;i2 < dlen; i2++) {
+      const digit = digits[i2];
+      const fromCarry = from * carry;
+      const digitBase = fromCarry + digit;
+      if (!Number.isSafeInteger(digitBase) || fromCarry / from !== carry || digitBase - digit !== fromCarry) {
+        throw new Error("convertRadix: carry overflow");
+      }
+      const div = digitBase / to;
+      carry = digitBase % to;
+      const rounded = Math.floor(div);
+      digits[i2] = rounded;
+      if (!Number.isSafeInteger(rounded) || rounded * to + carry !== digitBase)
+        throw new Error("convertRadix: carry overflow");
+      if (!done)
+        continue;
+      else if (!rounded)
+        pos = i2;
+      else
+        done = false;
+    }
+    res.push(carry);
+    if (done)
+      break;
+  }
+  for (let i2 = 0;i2 < data.length - 1 && data[i2] === 0; i2++)
+    res.push(0);
+  return res.reverse();
+}
+var gcd = (a2, b4) => b4 === 0 ? a2 : gcd(b4, a2 % b4);
+var radix2carry = (from, to) => from + (to - gcd(from, to));
+var powers = /* @__PURE__ */ (() => {
+  let res = [];
+  for (let i2 = 0;i2 < 40; i2++)
+    res.push(2 ** i2);
+  return res;
+})();
+function convertRadix2(data, from, to, padding2) {
+  aArr(data);
+  if (from <= 0 || from > 32)
+    throw new Error(`convertRadix2: wrong from=${from}`);
+  if (to <= 0 || to > 32)
+    throw new Error(`convertRadix2: wrong to=${to}`);
+  if (radix2carry(from, to) > 32) {
+    throw new Error(`convertRadix2: carry overflow from=${from} to=${to} carryBits=${radix2carry(from, to)}`);
+  }
+  let carry = 0;
+  let pos = 0;
+  const max = powers[from];
+  const mask = powers[to] - 1;
+  const res = [];
+  for (const n5 of data) {
+    anumber2(n5);
+    if (n5 >= max)
+      throw new Error(`convertRadix2: invalid data word=${n5} from=${from}`);
+    carry = carry << from | n5;
+    if (pos + from > 32)
+      throw new Error(`convertRadix2: carry overflow pos=${pos} from=${from}`);
+    pos += from;
+    for (;pos >= to; pos -= to)
+      res.push((carry >> pos - to & mask) >>> 0);
+    const pow = powers[pos];
+    if (pow === undefined)
+      throw new Error("invalid carry");
+    carry &= pow - 1;
+  }
+  carry = carry << to - pos & mask;
+  if (!padding2 && pos >= from)
+    throw new Error("Excess padding");
+  if (!padding2 && carry > 0)
+    throw new Error(`Non-zero padding: ${carry}`);
+  if (padding2 && pos > 0)
+    res.push(carry >>> 0);
+  return res;
+}
+function radix(num) {
+  anumber2(num);
+  const _256 = 2 ** 8;
+  return {
+    encode: (bytes) => {
+      if (!isBytes2(bytes))
+        throw new Error("radix.encode input should be Uint8Array");
+      return convertRadix(Array.from(bytes), _256, num);
+    },
+    decode: (digits) => {
+      anumArr("radix.decode", digits);
+      return Uint8Array.from(convertRadix(digits, num, _256));
+    }
+  };
+}
+function radix2(bits, revPadding = false) {
+  anumber2(bits);
+  if (bits <= 0 || bits > 32)
+    throw new Error("radix2: bits should be in (0..32]");
+  if (radix2carry(8, bits) > 32 || radix2carry(bits, 8) > 32)
+    throw new Error("radix2: carry overflow");
+  return {
+    encode: (bytes) => {
+      if (!isBytes2(bytes))
+        throw new Error("radix2.encode input should be Uint8Array");
+      return convertRadix2(Array.from(bytes), 8, bits, !revPadding);
+    },
+    decode: (digits) => {
+      anumArr("radix2.decode", digits);
+      return Uint8Array.from(convertRadix2(digits, bits, 8, revPadding));
+    }
+  };
+}
+function unsafeWrapper(fn) {
+  afn(fn);
+  return function(...args) {
+    try {
+      return fn.apply(null, args);
+    } catch (e3) {}
+  };
+}
+var base16 = chain(radix2(4), alphabet("0123456789ABCDEF"), join2(""));
+var base32 = chain(radix2(5), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"), padding(5), join2(""));
+var base32nopad = chain(radix2(5), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"), join2(""));
+var base32hex = chain(radix2(5), alphabet("0123456789ABCDEFGHIJKLMNOPQRSTUV"), padding(5), join2(""));
+var base32hexnopad = chain(radix2(5), alphabet("0123456789ABCDEFGHIJKLMNOPQRSTUV"), join2(""));
+var base32crockford = chain(radix2(5), alphabet("0123456789ABCDEFGHJKMNPQRSTVWXYZ"), join2(""), normalize((s2) => s2.toUpperCase().replace(/O/g, "0").replace(/[IL]/g, "1")));
+var hasBase64Builtin = /* @__PURE__ */ (() => typeof Uint8Array.from([]).toBase64 === "function" && typeof Uint8Array.fromBase64 === "function")();
+var decodeBase64Builtin = (s2, isUrl) => {
+  astr("base64", s2);
+  const re = isUrl ? /^[A-Za-z0-9=_-]+$/ : /^[A-Za-z0-9=+/]+$/;
+  const alphabet2 = isUrl ? "base64url" : "base64";
+  if (s2.length > 0 && !re.test(s2))
+    throw new Error("invalid base64");
+  return Uint8Array.fromBase64(s2, { alphabet: alphabet2, lastChunkHandling: "strict" });
+};
+var base643 = hasBase64Builtin ? {
+  encode(b4) {
+    abytes2(b4);
+    return b4.toBase64();
+  },
+  decode(s2) {
+    return decodeBase64Builtin(s2, false);
+  }
+} : chain(radix2(6), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"), padding(6), join2(""));
+var base64nopad = chain(radix2(6), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"), join2(""));
+var base64url3 = hasBase64Builtin ? {
+  encode(b4) {
+    abytes2(b4);
+    return b4.toBase64({ alphabet: "base64url" });
+  },
+  decode(s2) {
+    return decodeBase64Builtin(s2, true);
+  }
+} : chain(radix2(6), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"), padding(6), join2(""));
+var base64urlnopad = chain(radix2(6), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"), join2(""));
+var genBase58 = (abc) => chain(radix(58), alphabet(abc), join2(""));
+var base58 = genBase58("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz");
+var base58flickr = genBase58("123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ");
+var base58xrp = genBase58("rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz");
+var BECH_ALPHABET = chain(alphabet("qpzry9x8gf2tvdw0s3jn54khce6mua7l"), join2(""));
+var POLYMOD_GENERATORS = [996825010, 642813549, 513874426, 1027748829, 705979059];
+function bech32Polymod(pre) {
+  const b4 = pre >> 25;
+  let chk = (pre & 33554431) << 5;
+  for (let i2 = 0;i2 < POLYMOD_GENERATORS.length; i2++) {
+    if ((b4 >> i2 & 1) === 1)
+      chk ^= POLYMOD_GENERATORS[i2];
+  }
+  return chk;
+}
+function bechChecksum(prefix, words, encodingConst = 1) {
+  const len = prefix.length;
+  let chk = 1;
+  for (let i2 = 0;i2 < len; i2++) {
+    const c5 = prefix.charCodeAt(i2);
+    if (c5 < 33 || c5 > 126)
+      throw new Error(`Invalid prefix (${prefix})`);
+    chk = bech32Polymod(chk) ^ c5 >> 5;
+  }
+  chk = bech32Polymod(chk);
+  for (let i2 = 0;i2 < len; i2++)
+    chk = bech32Polymod(chk) ^ prefix.charCodeAt(i2) & 31;
+  for (let v4 of words)
+    chk = bech32Polymod(chk) ^ v4;
+  for (let i2 = 0;i2 < 6; i2++)
+    chk = bech32Polymod(chk);
+  chk ^= encodingConst;
+  return BECH_ALPHABET.encode(convertRadix2([chk % powers[30]], 30, 5, false));
+}
+function genBech32(encoding) {
+  const ENCODING_CONST = encoding === "bech32" ? 1 : 734539939;
+  const _words = radix2(5);
+  const fromWords = _words.decode;
+  const toWords = _words.encode;
+  const fromWordsUnsafe = unsafeWrapper(fromWords);
+  function encode4(prefix, words, limit = 90) {
+    astr("bech32.encode prefix", prefix);
+    if (isBytes2(words))
+      words = Array.from(words);
+    anumArr("bech32.encode", words);
+    const plen = prefix.length;
+    if (plen === 0)
+      throw new TypeError(`Invalid prefix length ${plen}`);
+    const actualLength = plen + 7 + words.length;
+    if (limit !== false && actualLength > limit)
+      throw new TypeError(`Length ${actualLength} exceeds limit ${limit}`);
+    const lowered = prefix.toLowerCase();
+    const sum = bechChecksum(lowered, words, ENCODING_CONST);
+    return `${lowered}1${BECH_ALPHABET.encode(words)}${sum}`;
+  }
+  function decode4(str, limit = 90) {
+    astr("bech32.decode input", str);
+    const slen = str.length;
+    if (slen < 8 || limit !== false && slen > limit)
+      throw new TypeError(`invalid string length: ${slen} (${str}). Expected (8..${limit})`);
+    const lowered = str.toLowerCase();
+    if (str !== lowered && str !== str.toUpperCase())
+      throw new Error(`String must be lowercase or uppercase`);
+    const sepIndex = lowered.lastIndexOf("1");
+    if (sepIndex === 0 || sepIndex === -1)
+      throw new Error(`Letter "1" must be present between prefix and data only`);
+    const prefix = lowered.slice(0, sepIndex);
+    const data = lowered.slice(sepIndex + 1);
+    if (data.length < 6)
+      throw new Error("Data must be at least 6 characters long");
+    const words = BECH_ALPHABET.decode(data).slice(0, -6);
+    const sum = bechChecksum(prefix, words, ENCODING_CONST);
+    if (!data.endsWith(sum))
+      throw new Error(`Invalid checksum in ${str}: expected "${sum}"`);
+    return { prefix, words };
+  }
+  const decodeUnsafe = unsafeWrapper(decode4);
+  function decodeToBytes(str) {
+    const { prefix, words } = decode4(str, false);
+    return { prefix, words, bytes: fromWords(words) };
+  }
+  function encodeFromBytes(prefix, bytes) {
+    return encode4(prefix, toWords(bytes));
+  }
+  return {
+    encode: encode4,
+    decode: decode4,
+    encodeFromBytes,
+    decodeToBytes,
+    decodeUnsafe,
+    fromWords,
+    fromWordsUnsafe,
+    toWords
+  };
+}
+var bech32 = genBech32("bech32");
+var bech32m = genBech32("bech32m");
+var hasHexBuiltin = /* @__PURE__ */ (() => typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function")();
+var hexBuiltin = {
+  encode(data) {
+    abytes2(data);
+    return data.toHex();
+  },
+  decode(s2) {
+    astr("hex", s2);
+    return Uint8Array.fromHex(s2);
+  }
+};
+var hex3 = hasHexBuiltin ? hexBuiltin : chain(radix2(4), alphabet("0123456789abcdef"), join2(""), normalize((s2) => {
+  if (typeof s2 !== "string" || s2.length % 2 !== 0)
+    throw new TypeError(`hex.decode: expected string, got ${typeof s2} with length ${s2.length}`);
+  return s2.toLowerCase();
+}));
+
+// src/utils/hash.ts
+function blake3Hash(content) {
+  const hash2 = blake3(new TextEncoder().encode(content));
+  return base58.encode(hash2);
+}
+function canonicalizeAspect(obj) {
+  return JSON.stringify(obj, (_5, value) => {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      return Object.keys(value).sort().reduce((sorted, key) => {
+        sorted[key] = value[key];
+        return sorted;
+      }, {});
+    }
+    return value;
+  });
+}
+function blake3HashAspect(aspect) {
+  return blake3Hash(canonicalizeAspect(aspect));
+}
+
+// src/utils/logger.ts
+var logger = consola.create({
+  formatOptions: {
+    date: false
+  }
+});
+var log = {
+  info: logger.info.bind(logger),
+  success: logger.success.bind(logger),
+  warn: logger.warn.bind(logger),
+  error: logger.error.bind(logger),
+  box: logger.box.bind(logger),
+  start: logger.start.bind(logger)
+};
+
+// src/lib/installer.ts
+var ASPECT_FILENAME = "aspect.json";
+var LEGACY_FILENAME = "aspect.yaml";
+async function installAspect(spec, options) {
+  switch (spec.type) {
+    case "registry":
+      return installFromRegistry(spec.name, spec.version, options);
+    case "local":
+      return installFromLocal(spec.path, options);
+    case "github":
+      return installFromGitHub(spec.owner, spec.repo, spec.ref, options);
+    case "hash":
+      return installFromHash(spec.hash, options);
+  }
+}
+async function installFromRegistry(name, version2, options) {
+  try {
+    return await installFromRegistryApi(name, version2, options);
+  } catch {
+    return installFromRegistryLegacy(name, version2, options);
+  }
+}
+async function installFromRegistryApi(name, version2, options) {
+  const targetVersion = version2 ?? "latest";
+  const scope = options?.scope ?? "global";
+  const projectRoot = options?.projectRoot;
+  if (!options?.force) {
+    const existing = await getInstalledAspect(name, scope, projectRoot);
+    if (existing && (version2 ? existing.version === version2 : true)) {
+      const aspect2 = await loadAspectFromPath(getAspectPath(name, scope, projectRoot));
+      if (aspect2) {
+        return { success: true, aspect: aspect2, source: "registry", alreadyInstalled: true };
+      }
+    }
+  }
+  log.start(`Fetching ${name}@${targetVersion}...`);
+  let versionData;
+  try {
+    versionData = await fetchAspectVersion(name, targetVersion);
+  } catch (err) {
+    const message = err.message;
+    if (message.includes("not_found") || message.includes("404") || message.includes("not found")) {
+      return { success: false, error: `Aspect "${name}@${targetVersion}" not found in registry` };
+    }
+    throw err;
+  }
+  const aspect = versionData.content;
+  if (aspect.name !== name) {
+    return {
+      success: false,
+      error: `Aspect name mismatch: expected "${name}", got "${aspect.name}"`
+    };
+  }
+  await ensureAspectsDir(scope, projectRoot);
+  const aspectDir = getAspectPath(name, scope, projectRoot);
+  await mkdir2(aspectDir, { recursive: true });
+  const content = JSON.stringify(aspect, null, 2);
+  await writeFile2(join3(aspectDir, ASPECT_FILENAME), content);
+  const hash2 = versionData.blake3 || blake3Hash(content);
+  await addInstalledAspect(name, {
+    version: aspect.version,
+    source: "registry",
+    installedAt: new Date().toISOString(),
+    blake3: hash2
+  }, scope, projectRoot);
+  return { success: true, aspect, source: "registry" };
+}
+async function installFromRegistryLegacy(name, version2, options) {
+  const scope = options?.scope ?? "global";
+  const projectRoot = options?.projectRoot;
+  let registryAspect;
+  try {
+    registryAspect = await getRegistryAspect(name);
+  } catch (err) {
+    return {
+      success: false,
+      error: `Unable to reach registry: ${err.message}. Make sure you have network connectivity or try installing from a local path.`
+    };
+  }
+  if (!registryAspect) {
+    return { success: false, error: `Aspect "${name}" not found in registry` };
+  }
+  const targetVersion = version2 ?? registryAspect.latest;
+  const versionInfo = registryAspect.versions[targetVersion];
+  if (!versionInfo) {
+    const available = Object.keys(registryAspect.versions).join(", ");
+    return {
+      success: false,
+      error: `Version "${targetVersion}" not found. Available: ${available}`
+    };
+  }
+  if (!options?.force) {
+    const existing = await getInstalledAspect(name, scope, projectRoot);
+    if (existing && existing.version === targetVersion) {
+      const aspect2 = await loadAspectFromPath(getAspectPath(name, scope, projectRoot));
+      if (aspect2) {
+        return { success: true, aspect: aspect2, source: "registry", alreadyInstalled: true };
+      }
+    }
+  }
+  if (!versionInfo.url) {
+    return { success: false, error: `No download URL for ${name}@${targetVersion}` };
+  }
   log.start(`Fetching ${name}@${targetVersion}...`);
-  let yamlContent;
+  let content;
   try {
-    yamlContent = await fetchAspectYaml(versionInfo.url);
+    content = await ofetch(versionInfo.url, { responseType: "text" });
   } catch (err) {
     return { success: false, error: `Failed to fetch aspect: ${err.message}` };
   }
-  const parseResult = parseAspectJson(yamlContent);
+  const parseResult = parseAspectJson(content);
   if (!parseResult.success) {
-    return { success: false, error: `Invalid aspect.yaml: ${parseResult.errors.join(", ")}` };
+    return { success: false, error: `Invalid aspect data: ${parseResult.errors.join(", ")}` };
   }
   if (parseResult.warnings.length > 0) {
     parseResult.warnings.forEach((w4) => log.warn(w4));
@@ -21582,82 +23324,98 @@ async function installFromRegistry(name, version2) {
       error: `Aspect name mismatch: expected "${name}", got "${aspect.name}"`
     };
   }
-  await ensureAspectsDir();
-  const aspectDir = getAspectPath(name);
+  await ensureAspectsDir(scope, projectRoot);
+  const aspectDir = getAspectPath(name, scope, projectRoot);
   await mkdir2(aspectDir, { recursive: true });
-  await writeFile2(join2(aspectDir, "aspect.yaml"), yamlContent);
-  const hash2 = sha256(yamlContent);
+  await writeFile2(join3(aspectDir, ASPECT_FILENAME), content);
+  const hash2 = blake3Hash(content);
   await addInstalledAspect(name, {
     version: aspect.version,
     source: "registry",
     installedAt: new Date().toISOString(),
-    sha256: hash2
-  });
+    blake3: hash2
+  }, scope, projectRoot);
   return { success: true, aspect, source: "registry" };
 }
 var DEFAULT_GITHUB_REF = "main";
-async function installFromGitHub(owner, repo, ref) {
+async function installFromGitHub(owner, repo, ref, options) {
   const targetRef = ref ?? DEFAULT_GITHUB_REF;
-  const url2 = `https://raw.githubusercontent.com/${owner}/${repo}/${targetRef}/aspect.yaml`;
-  log.start(`Fetching from github:${owner}/${repo}@${targetRef}...`);
-  let yamlContent;
-  try {
-    yamlContent = await ofetch(url2, { responseType: "text" });
-  } catch (err) {
-    const message = err.message;
-    if (message.includes("404")) {
-      return {
-        success: false,
-        error: `No aspect.yaml found at github:${owner}/${repo}@${targetRef}. Make sure the repo exists and has an aspect.yaml in the root.`
-      };
+  const scope = options?.scope ?? "global";
+  const projectRoot = options?.projectRoot;
+  let content = null;
+  for (const filename of [ASPECT_FILENAME, LEGACY_FILENAME]) {
+    const url2 = `https://raw.githubusercontent.com/${owner}/${repo}/${targetRef}/${filename}`;
+    log.start(`Fetching from github:${owner}/${repo}@${targetRef}...`);
+    try {
+      content = await ofetch(url2, { responseType: "text" });
+      break;
+    } catch (err) {
+      const message = err.message;
+      if (!message.includes("404")) {
+        return { success: false, error: `Failed to fetch from GitHub: ${message}` };
+      }
     }
-    return { success: false, error: `Failed to fetch from GitHub: ${message}` };
   }
-  const parseResult = parseAspectJson(yamlContent);
+  if (!content) {
+    return {
+      success: false,
+      error: `No aspect.json found at github:${owner}/${repo}@${targetRef}. Make sure the repo exists and has an aspect.json in the root.`
+    };
+  }
+  const parseResult = parseAspectJson(content);
   if (!parseResult.success) {
-    return { success: false, error: `Invalid aspect.yaml: ${parseResult.errors.join(", ")}` };
+    return { success: false, error: `Invalid aspect data: ${parseResult.errors.join(", ")}` };
   }
   if (parseResult.warnings.length > 0) {
     parseResult.warnings.forEach((w4) => log.warn(w4));
   }
   const aspect = parseResult.aspect;
-  const existing = await getInstalledAspect(aspect.name);
-  if (existing && existing.source === "github" && existing.githubRef === targetRef) {
-    const existingAspect = await loadAspectFromPath(getAspectPath(aspect.name));
-    if (existingAspect && existing.sha256 === sha256(yamlContent)) {
-      return { success: true, aspect: existingAspect, source: "github", alreadyInstalled: true };
+  if (!options?.force) {
+    const existing = await getInstalledAspect(aspect.name, scope, projectRoot);
+    if (existing && existing.source === "github" && existing.githubRef === targetRef) {
+      const existingAspect = await loadAspectFromPath(getAspectPath(aspect.name, scope, projectRoot));
+      if (existingAspect && existing.blake3 === blake3Hash(content)) {
+        return { success: true, aspect: existingAspect, source: "github", alreadyInstalled: true };
+      }
     }
   }
-  await ensureAspectsDir();
-  const aspectDir = getAspectPath(aspect.name);
+  await ensureAspectsDir(scope, projectRoot);
+  const aspectDir = getAspectPath(aspect.name, scope, projectRoot);
   await mkdir2(aspectDir, { recursive: true });
-  await writeFile2(join2(aspectDir, "aspect.yaml"), yamlContent);
-  const hash2 = sha256(yamlContent);
+  await writeFile2(join3(aspectDir, ASPECT_FILENAME), content);
+  const hash2 = blake3Hash(content);
   await addInstalledAspect(aspect.name, {
     version: aspect.version,
     source: "github",
     installedAt: new Date().toISOString(),
-    sha256: hash2,
+    blake3: hash2,
     githubRef: targetRef
-  });
+  }, scope, projectRoot);
   return { success: true, aspect, source: "github" };
 }
-async function installFromLocal(path) {
-  let yamlPath;
+async function installFromLocal(path, options) {
+  let filePath;
   let aspectDir;
   try {
-    const stats = await stat(path);
+    const stats = await stat2(path);
     if (stats.isDirectory()) {
       aspectDir = path;
-      yamlPath = join2(path, "aspect.yaml");
+      const jsonPath = join3(path, ASPECT_FILENAME);
+      const yamlPath = join3(path, LEGACY_FILENAME);
+      try {
+        await access(jsonPath);
+        filePath = jsonPath;
+      } catch {
+        filePath = yamlPath;
+      }
     } else {
-      yamlPath = path;
+      filePath = path;
       aspectDir = dirname(path);
     }
   } catch {
     return { success: false, error: `Path not found: ${path}` };
   }
-  const parseResult = await parseAspectFile(yamlPath);
+  const parseResult = await parseAspectFile(filePath);
   if (!parseResult.success) {
     return { success: false, error: parseResult.errors.join(", ") };
   }
@@ -21665,29 +23423,80 @@ async function installFromLocal(path) {
     parseResult.warnings.forEach((w4) => log.warn(w4));
   }
   const aspect = parseResult.aspect;
-  const yamlContent = await readFile3(yamlPath, "utf-8");
-  const hash2 = sha256(yamlContent);
-  const existing = await getInstalledAspect(aspect.name);
-  if (existing && existing.path === aspectDir && existing.sha256 === hash2) {
-    return { success: true, aspect, source: "local", alreadyInstalled: true };
+  const content = await readFile3(filePath, "utf-8");
+  const hash2 = blake3Hash(content);
+  const scope = options?.scope ?? "global";
+  const projectRoot = options?.projectRoot;
+  if (!options?.force) {
+    const existing = await getInstalledAspect(aspect.name, scope, projectRoot);
+    if (existing && existing.path === aspectDir && existing.blake3 === hash2) {
+      return { success: true, aspect, source: "local", alreadyInstalled: true };
+    }
   }
   await addInstalledAspect(aspect.name, {
     version: aspect.version,
     source: "local",
     installedAt: new Date().toISOString(),
-    sha256: hash2,
+    blake3: hash2,
     path: aspectDir
-  });
+  }, scope, projectRoot);
   return { success: true, aspect, source: "local" };
 }
+async function installFromHash(hash2, options) {
+  const scope = options?.scope ?? "global";
+  const projectRoot = options?.projectRoot;
+  log.start(`Fetching aspect by hash ${hash2.slice(0, 12)}...`);
+  let versionData;
+  try {
+    versionData = await fetchAspectByHash(hash2);
+  } catch (err) {
+    const message = err.message;
+    if (message.includes("not_found") || message.includes("404") || message.includes("not found")) {
+      return { success: false, error: `No aspect found for hash "${hash2}"` };
+    }
+    return { success: false, error: `Failed to fetch aspect by hash: ${message}` };
+  }
+  const aspect = versionData.content;
+  if (!options?.force) {
+    const existing = await getInstalledAspect(aspect.name, scope, projectRoot);
+    if (existing && existing.blake3 === hash2) {
+      const existingAspect = await loadAspectFromPath(getAspectPath(aspect.name, scope, projectRoot));
+      if (existingAspect) {
+        return { success: true, aspect: existingAspect, source: "registry", alreadyInstalled: true };
+      }
+    }
+  }
+  await ensureAspectsDir(scope, projectRoot);
+  const aspectDir = getAspectPath(aspect.name, scope, projectRoot);
+  await mkdir2(aspectDir, { recursive: true });
+  const content = JSON.stringify(aspect, null, 2);
+  await writeFile2(join3(aspectDir, ASPECT_FILENAME), content);
+  await addInstalledAspect(aspect.name, {
+    version: aspect.version,
+    source: "registry",
+    installedAt: new Date().toISOString(),
+    blake3: versionData.blake3 || blake3Hash(content)
+  }, scope, projectRoot);
+  return { success: true, aspect, source: "registry" };
+}
 async function loadAspectFromPath(aspectDir) {
-  const result = await parseAspectFile(join2(aspectDir, "aspect.yaml"));
-  return result.success ? result.aspect : null;
+  const jsonResult = await parseAspectFile(join3(aspectDir, ASPECT_FILENAME));
+  if (jsonResult.success)
+    return jsonResult.aspect;
+  const yamlResult = await parseAspectFile(join3(aspectDir, LEGACY_FILENAME));
+  return yamlResult.success ? yamlResult.aspect : null;
 }
 
 // src/lib/resolver.ts
 import { resolve, isAbsolute } from "node:path";
 function parseInstallSpec(spec) {
+  if (spec.startsWith("hash:")) {
+    const hash2 = spec.slice(5);
+    if (hash2.length < 16) {
+      throw new Error(`Invalid hash spec: ${spec}. Hash must be at least 16 characters.`);
+    }
+    return { type: "hash", hash: hash2 };
+  }
   if (spec.startsWith("github:")) {
     const rest = spec.slice(7);
     const parts = rest.split("@");
@@ -21731,7 +23540,7 @@ function parseInstallSpec(spec) {
 // src/commands/set.ts
 async function loadSet(name) {
   try {
-    const setPath = join3(getSetsDir(), name, "set.json");
+    const setPath = join4(getSetsDir(), name, "set.json");
     const content = await readFile4(setPath, "utf-8");
     return JSON.parse(content);
   } catch {
@@ -21740,10 +23549,10 @@ async function loadSet(name) {
 }
 async function saveSet(set2) {
   await ensureSetsDir();
-  const setDir = join3(getSetsDir(), set2.name);
+  const setDir = join4(getSetsDir(), set2.name);
   await mkdir3(setDir, { recursive: true });
   set2.updatedAt = new Date().toISOString();
-  await writeFile3(join3(setDir, "set.json"), JSON.stringify(set2, null, 2) + `
+  await writeFile3(join4(setDir, "set.json"), JSON.stringify(set2, null, 2) + `
 `);
 }
 async function listAllSets() {
@@ -22197,14 +24006,14 @@ var create_default = defineCommand({
     let inRegistry = false;
     let repoRoot = cwd;
     try {
-      await stat2(join4(cwd, INDEX_PATH));
+      await stat3(join5(cwd, INDEX_PATH));
       inRegistry = true;
     } catch {
       try {
         const gitRoot = execSync("git rev-parse --show-toplevel", {
           encoding: "utf-8"
         }).trim();
-        await stat2(join4(gitRoot, INDEX_PATH));
+        await stat3(join5(gitRoot, INDEX_PATH));
         inRegistry = true;
         repoRoot = gitRoot;
       } catch {}
@@ -22212,8 +24021,25 @@ var create_default = defineCommand({
     if (inRegistry) {
       M2.info(`Detected aspects registry at ${repoRoot}`);
     }
-    const answers = await Ce({
-      name: () => he2({
+    const aspectExistsAt = async (name) => {
+      let checkPath;
+      if (inRegistry) {
+        checkPath = join5(repoRoot, REGISTRY_DIR, name, "aspect.json");
+      } else if (args.path) {
+        checkPath = join5(args.path, "aspect.json");
+      } else {
+        checkPath = join5(cwd, "aspect.json");
+      }
+      try {
+        await stat3(checkPath);
+        return checkPath;
+      } catch {
+        return null;
+      }
+    };
+    let aspectName;
+    while (!aspectName) {
+      const nameInput = await he2({
         message: "Aspect name (slug)",
         placeholder: "my-wizard",
         validate: (value) => {
@@ -22223,7 +24049,34 @@ var create_default = defineCommand({
             return "Name must be lowercase letters, numbers, and hyphens only";
           }
         }
-      }),
+      });
+      if (pD2(nameInput)) {
+        xe("Cancelled");
+        process.exit(0);
+      }
+      const existingPath = await aspectExistsAt(nameInput);
+      if (existingPath) {
+        M2.warn(`An aspect already exists at ${existingPath}`);
+        const action = await ve2({
+          message: "What would you like to do?",
+          options: [
+            { value: "rename", label: "Choose a different name" },
+            { value: "overwrite", label: "Overwrite the existing aspect" },
+            { value: "cancel", label: "Cancel" }
+          ]
+        });
+        if (pD2(action) || action === "cancel") {
+          xe("Cancelled");
+          process.exit(0);
+        }
+        if (action === "overwrite") {
+          aspectName = nameInput;
+        }
+      } else {
+        aspectName = nameInput;
+      }
+    }
+    const answers = await Ce({
       displayName: () => he2({
         message: "Display name",
         placeholder: "My Wizard",
@@ -22323,9 +24176,20 @@ Keep it light! A few well-crafted rules beat many vague ones.
       const action = await ve2({
         message: "What would you like to add?",
         options: [
-          { value: "directive", label: "Add a directive (strict rule)", hint: "MUST-follow, emphasized across models" },
-          { value: "instruction", label: "Add an instruction (general guidance)", hint: "Softer preference" },
-          { value: "done", label: hasAny ? "Done — finish creating aspect" : "Skip — finish without adding any" }
+          {
+            value: "directive",
+            label: "Add a directive (strict rule)",
+            hint: "MUST-follow, emphasized across models"
+          },
+          {
+            value: "instruction",
+            label: "Add an instruction (general guidance)",
+            hint: "Softer preference"
+          },
+          {
+            value: "done",
+            label: hasAny ? "Done — finish creating aspect" : "Skip — finish without adding any"
+          }
         ]
       });
       if (pD2(action) || action === "done") {
@@ -22353,8 +24217,16 @@ Keep it light! A few well-crafted rules beat many vague ones.
         const priority = await ve2({
           message: "Priority level:",
           options: [
-            { value: "high", label: "High", hint: "Critical, always emphasized" },
-            { value: "medium", label: "Medium", hint: "Important but flexible" },
+            {
+              value: "high",
+              label: "High",
+              hint: "Critical, always emphasized"
+            },
+            {
+              value: "medium",
+              label: "Medium",
+              hint: "Important but flexible"
+            },
             { value: "low", label: "Low", hint: "Nice-to-have preference" }
           ],
           initialValue: "high"
@@ -22394,7 +24266,7 @@ Keep it light! A few well-crafted rules beat many vague ones.
     }
     const aspect = {
       schemaVersion: 1,
-      name: answers.name,
+      name: aspectName,
       publisher: answers.author || "community",
       version: "1.0.0",
       displayName: answers.displayName,
@@ -22425,20 +24297,15 @@ Keep it light! A few well-crafted rules beat many vague ones.
     let outputDir;
     let outputPath;
     if (inRegistry) {
-      outputDir = join4(repoRoot, REGISTRY_DIR, answers.name);
-      outputPath = join4(outputDir, "aspect.json");
+      outputDir = join5(repoRoot, REGISTRY_DIR, aspectName);
+      outputPath = join5(outputDir, "aspect.json");
     } else if (args.path) {
       outputDir = args.path;
-      outputPath = join4(outputDir, "aspect.json");
+      outputPath = join5(outputDir, "aspect.json");
     } else {
       outputDir = cwd;
-      outputPath = join4(cwd, "aspect.json");
+      outputPath = join5(cwd, "aspect.json");
     }
-    try {
-      await stat2(outputPath);
-      M2.error(`aspect.json already exists at ${outputPath}`);
-      process.exit(1);
-    } catch {}
     await mkdir4(outputDir, { recursive: true });
     const jsonContent = JSON.stringify(aspect, null, 2);
     await writeFile4(outputPath, jsonContent);
@@ -22450,7 +24317,7 @@ Keep it light! A few well-crafted rules beat many vague ones.
       });
       if (updateIndex) {
         try {
-          await addToRegistryIndex(repoRoot, answers.name, answers.displayName, answers.tagline, answers.category, answers.author || "community");
+          await addToRegistryIndex(repoRoot, aspectName, answers.displayName, answers.tagline, answers.category, answers.author || "community");
           M2.success("Updated registry/index.json");
         } catch (err) {
           M2.error(`Failed to update index.json: ${err}`);
@@ -22463,11 +24330,11 @@ Keep it light! A few well-crafted rules beat many vague ones.
       if (gitCommit) {
         try {
           execSync(`git add .`, { cwd: repoRoot, stdio: "pipe" });
-          execSync(`git commit -m "Add ${answers.name} aspect"`, {
+          execSync(`git commit -m "Add ${aspectName} aspect"`, {
             cwd: repoRoot,
             stdio: "pipe"
           });
-          M2.success(`Committed: "Add ${answers.name} aspect"`);
+          M2.success(`Committed: "Add ${aspectName} aspect"`);
           const gitPush = await ye2({
             message: "Push to origin?",
             initialValue: true
@@ -22491,7 +24358,7 @@ Next: Open a PR at https://github.com/${GITHUB_REPO}/compare`);
 To submit to the registry:`);
       M2.info("1. Fork https://github.com/" + GITHUB_REPO);
       M2.info("2. Clone your fork and run this command inside it");
-      M2.info("3. Or visit https://getaspects.com/create");
+      M2.info("3. Or visit https://aspects.sh/create");
     }
     const sets = await listAllSets();
     if (sets.length > 0) {
@@ -22508,8 +24375,8 @@ To submit to the registry:`);
       });
       if (!pD2(addToSet) && addToSet !== "__none__") {
         const set2 = await loadSet(addToSet);
-        if (set2 && !set2.aspects.includes(answers.name)) {
-          set2.aspects.push(answers.name);
+        if (set2 && !set2.aspects.includes(aspectName)) {
+          set2.aspects.push(aspectName);
           await saveSet(set2);
           M2.success(`Added to set: ${set2.displayName}`);
         }
@@ -22519,7 +24386,7 @@ To submit to the registry:`);
   }
 });
 async function addToRegistryIndex(repoRoot, name, displayName, tagline, category, publisher) {
-  const indexPath = join4(repoRoot, INDEX_PATH);
+  const indexPath = join5(repoRoot, INDEX_PATH);
   const indexContent = await readFile5(indexPath, "utf-8");
   const index = JSON.parse(indexContent);
   const now = new Date().toISOString();
@@ -22604,12 +24471,28 @@ var add_default = defineCommand({
     force: {
       type: "boolean",
       description: "Overwrite existing installation"
+    },
+    global: {
+      type: "boolean",
+      alias: "g",
+      description: "Install to global scope (~/.aspects) instead of project"
     }
   },
   async run({ args }) {
     const specs = Array.isArray(args.specs) ? args.specs : [args.specs];
-    const results = [];
-    for (const specStr of specs) {
+    let scope;
+    let projectRoot;
+    if (args.global) {
+      scope = "global";
+    } else {
+      projectRoot = await findProjectRoot() || undefined;
+      scope = projectRoot ? "project" : "global";
+    }
+    const scopeLabel = scope === "global" ? "~/.aspects" : "./.aspects";
+    console.log();
+    console.log(c3.muted(`Installing to ${scopeLabel}`));
+    const results = [];
+    for (const specStr of specs) {
       let spec;
       try {
         spec = parseInstallSpec(specStr);
@@ -22617,7 +24500,7 @@ var add_default = defineCommand({
         results.push({ spec: specStr, success: false, error: err.message });
         continue;
       }
-      const result = await installAspect(spec);
+      const result = await installAspect(spec, { force: !!args.force, scope, projectRoot });
       if (!result.success) {
         results.push({ spec: specStr, success: false, error: result.error });
         continue;
@@ -22666,15 +24549,19 @@ var add_default = defineCommand({
 });
 
 // src/lib/aspect-loader.ts
-import { join as join5 } from "node:path";
-async function loadInstalledAspect(name) {
-  const installed = await getInstalledAspect(name);
+import { join as join6 } from "node:path";
+var ASPECT_FILENAME2 = "aspect.json";
+var LEGACY_FILENAME2 = "aspect.yaml";
+async function loadInstalledAspect(name, scope = "global", projectRoot) {
+  const installed = await getInstalledAspect(name, scope, projectRoot);
   if (!installed)
     return null;
-  const aspectDir = installed.path ?? getAspectPath(name);
-  const yamlPath = join5(aspectDir, "aspect.yaml");
-  const result = await parseAspectFile(yamlPath);
-  return result.success ? result.aspect : null;
+  const aspectDir = installed.path ?? getAspectPath(name, scope, projectRoot);
+  const jsonResult = await parseAspectFile(join6(aspectDir, ASPECT_FILENAME2));
+  if (jsonResult.success)
+    return jsonResult.aspect;
+  const yamlResult = await parseAspectFile(join6(aspectDir, LEGACY_FILENAME2));
+  return yamlResult.success ? yamlResult.aspect : null;
 }
 
 // src/commands/list.ts
@@ -22683,9 +24570,28 @@ var list_default = defineCommand({
     name: "list",
     description: "List installed aspects"
   },
-  args: {},
-  async run() {
-    const installed = await listInstalledAspects();
+  args: {
+    global: {
+      type: "boolean",
+      alias: "g",
+      description: "List only global aspects (~/.aspects)"
+    },
+    project: {
+      type: "boolean",
+      alias: "p",
+      description: "List only project aspects (./.aspects)"
+    }
+  },
+  async run({ args }) {
+    const projectRoot = await findProjectRoot() || undefined;
+    let installed;
+    if (args.global) {
+      installed = await listInstalledAspects("global");
+    } else if (args.project) {
+      installed = await listInstalledAspects("project", projectRoot);
+    } else {
+      installed = await listAllInstalledAspects(projectRoot);
+    }
     if (installed.length === 0) {
       console.log();
       console.log(c3.muted("  No aspects installed."));
@@ -22696,13 +24602,14 @@ var list_default = defineCommand({
     console.log();
     console.log(c3.bold(`${icons2.package} Installed aspects`));
     console.log();
-    for (const installed2 of await listInstalledAspects()) {
-      const aspect = await loadInstalledAspect(installed2.name);
-      const sourceLabel = installed2.source === "local" ? c3.dim(" (local)") : installed2.source === "github" ? c3.dim(" (github)") : "";
-      const name = c3.aspect(installed2.name);
-      const version2 = c3.version(`@${installed2.version}`);
+    for (const item of installed) {
+      const aspect = await loadInstalledAspect(item.name, item.scope, projectRoot);
+      const scopeLabel = item.scope === "project" ? c3.dim(" [project]") : c3.dim(" [global]");
+      const sourceLabel = item.source === "local" ? c3.dim(" (local)") : item.source === "github" ? c3.dim(" (github)") : "";
+      const name = c3.aspect(item.name);
+      const version2 = c3.version(`@${item.version}`);
       const tagline = aspect?.tagline ? c3.muted(` — ${aspect.tagline}`) : "";
-      console.log(`  ${name}${version2}${sourceLabel}${tagline}`);
+      console.log(`  ${name}${version2}${scopeLabel}${sourceLabel}${tagline}`);
     }
     console.log();
   }
@@ -22719,9 +24626,57 @@ var search_default = defineCommand({
       type: "positional",
       description: "Search query (optional, lists all if omitted)",
       required: false
+    },
+    category: {
+      type: "string",
+      description: "Filter by category (assistant, roleplay, creative, etc.)"
+    },
+    trust: {
+      type: "string",
+      description: "Filter by trust level (verified, community)"
+    },
+    limit: {
+      type: "string",
+      description: "Max results (default 20, max 100)"
+    },
+    offset: {
+      type: "string",
+      description: "Pagination offset"
     }
   },
   async run({ args }) {
+    const query = args.query;
+    const category = args.category;
+    const trust = args.trust;
+    const limit = args.limit ? parseInt(args.limit, 10) : undefined;
+    const offset = args.offset ? parseInt(args.offset, 10) : undefined;
+    try {
+      const result = await searchRegistry({ q: query, category, trust, limit, offset });
+      if (result.results.length === 0) {
+        console.log();
+        if (query) {
+          console.log(c3.muted(`  No aspects found matching "${query}"`));
+        } else {
+          console.log(c3.muted("  No aspects found"));
+        }
+        console.log();
+        return;
+      }
+      console.log();
+      console.log(c3.bold(`${icons2.search} ${query ? `Aspects matching "${query}"` : "Available aspects"}`));
+      if (result.total > result.results.length) {
+        console.log(c3.muted(`  Showing ${result.results.length} of ${result.total} results`));
+      }
+      console.log();
+      for (const item of result.results) {
+        const verified = item.trust === "verified" ? ` ${icons2.success}` : "";
+        const downloads = formatDownloads(item.downloads);
+        console.log(`  ${c3.aspect(item.name)}${c3.version(`@${item.version}`)}${verified}  ${downloads}`);
+        console.log(`    ${c3.muted(item.tagline)}`);
+        console.log();
+      }
+      return;
+    } catch {}
     let index;
     try {
       index = await fetchRegistryIndex();
@@ -22729,13 +24684,19 @@ var search_default = defineCommand({
       log.error(err.message);
       process.exit(1);
     }
-    const query = args.query?.toLowerCase();
+    const queryLower = query?.toLowerCase();
     const aspects = Object.entries(index.aspects);
-    const matches = query ? aspects.filter(([name, info]) => name.toLowerCase().includes(query) || info.metadata.displayName.toLowerCase().includes(query) || info.metadata.tagline.toLowerCase().includes(query)) : aspects;
+    let matches = queryLower ? aspects.filter(([name, info]) => name.toLowerCase().includes(queryLower) || info.metadata.displayName.toLowerCase().includes(queryLower) || info.metadata.tagline.toLowerCase().includes(queryLower)) : aspects;
+    if (category) {
+      matches = matches.filter(([, info]) => info.metadata.category === category);
+    }
+    if (trust) {
+      matches = matches.filter(([, info]) => info.metadata.trust === trust);
+    }
     if (matches.length === 0) {
       console.log();
       if (query) {
-        console.log(c3.muted(`  No aspects found matching "${args.query}"`));
+        console.log(c3.muted(`  No aspects found matching "${query}"`));
       } else {
         console.log(c3.muted("  Registry is empty"));
       }
@@ -22743,7 +24704,7 @@ var search_default = defineCommand({
       return;
     }
     console.log();
-    console.log(c3.bold(`${icons2.search} ${query ? `Aspects matching "${args.query}"` : "Available aspects"}`));
+    console.log(c3.bold(`${icons2.search} ${query ? `Aspects matching "${query}"` : "Available aspects"}`));
     console.log();
     for (const [name, info] of matches) {
       const verified = info.metadata.trust === "verified" ? ` ${icons2.success}` : "";
@@ -22753,6 +24714,12 @@ var search_default = defineCommand({
     }
   }
 });
+function formatDownloads(count) {
+  if (count >= 1000) {
+    return c3.muted(`${(count / 1000).toFixed(1)}k dl`);
+  }
+  return c3.muted(`${count} dl`);
+}
 
 // src/commands/find.ts
 function matchesFilter(aspect, filters, deep = false) {
@@ -22986,7 +24953,7 @@ var find_default = defineCommand({
           continue;
         }
         const aspectPath = aspectInfo.path || getAspectPath(name);
-        const parseResult = await parseAspectFile(`${aspectPath}/aspect.yaml`);
+        const parseResult = await parseAspectFile(`${aspectPath}/aspect.json`);
         if (!parseResult.success)
           continue;
         const aspect = parseResult.aspect;
@@ -23050,7 +25017,7 @@ var find_default = defineCommand({
 var info_default = defineCommand({
   meta: {
     name: "info",
-    description: "Show details about an installed aspect"
+    description: "Show details about an aspect (installed or from registry)"
   },
   args: {
     name: {
@@ -23061,56 +25028,122 @@ var info_default = defineCommand({
   },
   async run({ args }) {
     const installed = await getInstalledAspect(args.name);
-    if (!installed) {
-      log.error(`Aspect "${args.name}" is not installed`);
-      process.exit(1);
-    }
-    const aspect = await loadInstalledAspect(args.name);
-    if (!aspect) {
-      log.error(`Failed to load aspect "${args.name}" — aspect.yaml may be corrupted`);
-      process.exit(1);
-    }
-    console.log();
-    console.log(`${c3.bold(aspect.displayName)} ${c3.muted("(")}${c3.aspect(aspect.name)}${c3.version(`@${aspect.version}`)}${c3.muted(")")}`);
-    console.log();
-    console.log(`  ${c3.italic(aspect.tagline)}`);
-    console.log();
-    const meta3 = [];
-    if (aspect.publisher)
-      meta3.push(["Publisher", aspect.publisher]);
-    if (aspect.author)
-      meta3.push(["Author", aspect.author]);
-    if (aspect.license)
-      meta3.push(["License", aspect.license]);
-    meta3.push(["Source", installed.source]);
-    if (meta3.length > 0) {
-      for (const [label, value] of meta3) {
-        console.log(`  ${c3.label(label.padEnd(10))} ${c3.value(value)}`);
+    if (installed) {
+      const aspect = await loadInstalledAspect(args.name);
+      if (!aspect) {
+        log.error(`Failed to load aspect "${args.name}" — aspect.json may be corrupted`);
+        process.exit(1);
       }
-    }
-    if (aspect.voiceHints) {
       console.log();
-      console.log(`  ${c3.bold("Voice")}`);
-      if (aspect.voiceHints.speed) {
-        console.log(`    ${c3.label("Speed")}     ${aspect.voiceHints.speed}`);
-      }
-      if (aspect.voiceHints.emotions?.length) {
-        console.log(`    ${c3.label("Emotions")}  ${aspect.voiceHints.emotions.join(", ")}`);
+      console.log(`${c3.bold(aspect.displayName)} ${c3.muted("(")}${c3.aspect(aspect.name)}${c3.version(`@${aspect.version}`)}${c3.muted(")")}`);
+      console.log();
+      console.log(`  ${c3.italic(aspect.tagline)}`);
+      console.log();
+      const meta3 = [];
+      if (aspect.publisher)
+        meta3.push(["Publisher", aspect.publisher]);
+      if (aspect.author)
+        meta3.push(["Author", aspect.author]);
+      if (aspect.license)
+        meta3.push(["License", aspect.license]);
+      meta3.push(["Source", installed.source]);
+      if (meta3.length > 0) {
+        for (const [label, value] of meta3) {
+          console.log(`  ${c3.label(label.padEnd(10))} ${c3.value(value)}`);
+        }
+      }
+      if (aspect.voiceHints) {
+        console.log();
+        console.log(`  ${c3.bold("Voice")}`);
+        if (aspect.voiceHints.speed) {
+          console.log(`    ${c3.label("Speed")}     ${aspect.voiceHints.speed}`);
+        }
+        if (aspect.voiceHints.emotions?.length) {
+          console.log(`    ${c3.label("Emotions")}  ${aspect.voiceHints.emotions.join(", ")}`);
+        }
+        if (aspect.voiceHints.styleHints) {
+          console.log(`    ${c3.label("Style")}     ${c3.muted(aspect.voiceHints.styleHints)}`);
+        }
       }
-      if (aspect.voiceHints.styleHints) {
-        console.log(`    ${c3.label("Style")}     ${c3.muted(aspect.voiceHints.styleHints)}`);
+      if (aspect.modes && Object.keys(aspect.modes).length > 0) {
+        console.log();
+        console.log(`  ${c3.bold("Modes")}`);
+        for (const [modeName, mode] of Object.entries(aspect.modes)) {
+          console.log(`    ${c3.highlight(modeName)} ${icons2.arrow} ${c3.muted(mode.description)}`);
+        }
       }
+      console.log();
+      return;
     }
-    if (aspect.modes && Object.keys(aspect.modes).length > 0) {
+    try {
+      const detail = await getAspectDetail(args.name);
+      if (!detail) {
+        log.error(`Aspect "${args.name}" not found (not installed or in registry)`);
+        console.log(c3.muted(`  Try "aspects search ${args.name}" to find similar aspects`));
+        process.exit(1);
+      }
+      const latestVersion = detail.versions[detail.latest];
+      const latestAspect = latestVersion?.aspect;
+      console.log();
+      console.log(`${c3.bold(latestAspect?.displayName ?? detail.name)} ${c3.muted("(")}${c3.aspect(detail.name)}${c3.version(`@${detail.latest}`)}${c3.muted(")")}`);
+      console.log();
+      if (latestAspect?.tagline) {
+        console.log(`  ${c3.italic(latestAspect.tagline)}`);
+        console.log();
+      }
+      const meta3 = [];
+      meta3.push(["Publisher", detail.publisher]);
+      if (latestAspect?.category)
+        meta3.push(["Category", latestAspect.category]);
+      meta3.push(["Trust", detail.trust]);
+      meta3.push(["Latest", detail.latest]);
+      meta3.push(["Published", formatDate(detail.modified)]);
+      for (const [label, value] of meta3) {
+        console.log(`  ${c3.label(label.padEnd(10))} ${c3.value(value)}`);
+      }
       console.log();
-      console.log(`  ${c3.bold("Modes")}`);
-      for (const [modeName, mode] of Object.entries(aspect.modes)) {
-        console.log(`    ${c3.highlight(modeName)} ${icons2.arrow} ${c3.muted(mode.description)}`);
+      console.log(`  ${c3.bold("Stats")}`);
+      console.log(`    ${c3.label("Downloads")} ${formatNumber(detail.stats.downloads.total)} total / ${formatNumber(detail.stats.downloads.weekly)} weekly`);
+      const versions2 = Object.keys(detail.versions);
+      if (versions2.length > 0) {
+        console.log();
+        console.log(`  ${c3.bold("Versions")}`);
+        for (const ver of versions2) {
+          const vInfo = detail.versions[ver];
+          const deprecated = vInfo?.deprecated ? c3.warn(` (deprecated: ${vInfo.deprecated})`) : "";
+          const current = ver === detail.latest ? ` ${c3.success("← latest")}` : "";
+          console.log(`    ${c3.version(ver)}  ${c3.muted(formatDate(vInfo?.published ?? ""))}${current}${deprecated}`);
+        }
       }
+      console.log();
+      console.log(c3.muted(`  Install: aspects install ${detail.name}`));
+      console.log();
+    } catch (err) {
+      log.error(`Aspect "${args.name}" is not installed`);
+      console.log(c3.muted(`  Try "aspects search ${args.name}" to find aspects in the registry`));
+      process.exit(1);
     }
-    console.log();
   }
 });
+function formatNumber(n5) {
+  if (n5 >= 1000) {
+    return `${(n5 / 1000).toFixed(1)}k`;
+  }
+  return String(n5);
+}
+function formatDate(isoDate) {
+  if (!isoDate)
+    return "unknown";
+  try {
+    return new Date(isoDate).toLocaleDateString("en-US", {
+      year: "numeric",
+      month: "short",
+      day: "numeric"
+    });
+  } catch {
+    return isoDate;
+  }
+}
 
 // src/commands/remove.ts
 import { rm } from "node:fs/promises";
@@ -23124,17 +25157,30 @@ var remove_default = defineCommand({
       type: "positional",
       description: "Aspect name to remove",
       required: true
+    },
+    global: {
+      type: "boolean",
+      alias: "g",
+      description: "Remove from global scope (~/.aspects) instead of project"
     }
   },
   async run({ args }) {
-    const installed = await getInstalledAspect(args.name);
+    let scope;
+    let projectRoot;
+    if (args.global) {
+      scope = "global";
+    } else {
+      projectRoot = await findProjectRoot() || undefined;
+      scope = projectRoot ? "project" : "global";
+    }
+    const installed = await getInstalledAspect(args.name, scope, projectRoot);
     if (!installed) {
       log.error(`Aspect "${args.name}" is not installed`);
       process.exit(1);
     }
-    await removeInstalledAspect(args.name);
+    await removeInstalledAspect(args.name, scope, projectRoot);
     if (installed.source === "registry" || installed.source === "github") {
-      const aspectDir = getAspectPath(args.name);
+      const aspectDir = getAspectPath(args.name, scope, projectRoot);
       try {
         await rm(aspectDir, { recursive: true });
       } catch {}
@@ -23250,8 +25296,8 @@ var update_default = defineCommand({
 });
 
 // src/commands/validate.ts
-import { readFile as readFile6, stat as stat3 } from "node:fs/promises";
-import { join as join6 } from "node:path";
+import { readFile as readFile6, stat as stat4 } from "node:fs/promises";
+import { join as join7 } from "node:path";
 var validate_default = defineCommand({
   meta: {
     name: "validate",
@@ -23278,9 +25324,9 @@ var validate_default = defineCommand({
     Ie("\uD83D\uDD0D Validate aspect");
     let aspectPath = args.path || process.cwd();
     try {
-      const stats = await stat3(aspectPath);
+      const stats = await stat4(aspectPath);
       if (stats.isDirectory()) {
-        aspectPath = join6(aspectPath, "aspect.json");
+        aspectPath = join7(aspectPath, "aspect.json");
       }
     } catch {
       M2.error(`Path not found: ${aspectPath}`);
@@ -23391,8 +25437,8 @@ var validate_default = defineCommand({
 });
 
 // src/commands/compile.ts
-import { readFile as readFile7, writeFile as writeFile5, stat as stat4 } from "node:fs/promises";
-import { join as join7 } from "node:path";
+import { readFile as readFile7, writeFile as writeFile5, stat as stat5 } from "node:fs/promises";
+import { join as join8 } from "node:path";
 function detectModelFamily(model) {
   const lower = model.toLowerCase();
   if (lower.includes("claude")) {
@@ -23477,16 +25523,16 @@ var compile_default = defineCommand({
     let aspectPath;
     let aspectContent;
     try {
-      const stats = await stat4(args.name);
+      const stats = await stat5(args.name);
       if (stats.isDirectory()) {
-        aspectPath = join7(args.name, "aspect.json");
+        aspectPath = join8(args.name, "aspect.json");
       } else {
         aspectPath = args.name;
       }
       aspectContent = await readFile7(aspectPath, "utf-8");
     } catch {
       try {
-        aspectPath = join7(ASPECTS_DIR, args.name, "aspect.json");
+        aspectPath = join8(ASPECTS_DIR, args.name, "aspect.json");
         aspectContent = await readFile7(aspectPath, "utf-8");
       } catch {
         M2.error(`Aspect not found: ${args.name}`);
@@ -23585,81 +25631,47 @@ ${modeInfo.critical}
 });
 
 // src/commands/publish.ts
-import { readFile as readFile8, writeFile as writeFile6, stat as stat5, mkdir as mkdir5, readdir as readdir2 } from "node:fs/promises";
-import { join as join8, dirname as dirname3 } from "node:path";
-import { execSync as execSync2 } from "node:child_process";
-import { homedir as homedir2 } from "node:os";
-var GITHUB_REPO2 = "aimorphist/aspects";
-var REGISTRY_DIR2 = "registry/aspects";
-var INDEX_PATH2 = "registry/index.json";
-var ISSUE_TEMPLATE_URL = `https://github.com/${GITHUB_REPO2}/issues/new?template=new-aspect.yml`;
+import { readFile as readFile8, stat as stat6, readdir as readdir2 } from "node:fs/promises";
+import { join as join9, dirname as dirname3 } from "node:path";
+var MAX_ASPECT_SIZE = 51200;
 var publish_default = defineCommand({
   meta: {
     name: "publish",
-    description: "Publish an aspect to the Morphist registry"
+    description: "Publish an aspect to the registry"
   },
   args: {
     path: {
       type: "positional",
       description: "Path to aspect directory or aspect.json (optional)",
       required: false
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Validate without publishing"
     }
   },
   async run({ args }) {
-    Ie("\uD83D\uDCE4 Publish an aspect to the Morphist registry");
-    M2.info("");
-    M2.info("Publishing options:");
-    M2.info("  1. GitHub PR — Automated fork, branch, and PR creation (requires gh CLI)");
-    M2.info("  2. Issue Template — Submit via GitHub issue form (no CLI needed)");
-    M2.info("  3. Manual — Get instructions for manual submission");
-    M2.info("");
-    M2.info(`\uD83D\uDCA1 You can also submit directly at: ${ISSUE_TEMPLATE_URL}`);
-    M2.info("");
-    const publishMethod = await ve2({
-      message: "How would you like to publish?",
-      options: [
-        { value: "pr", label: "GitHub PR (automated)", hint: "Requires GitHub CLI" },
-        { value: "issue", label: "Issue Template (web form)", hint: "Opens in browser" },
-        { value: "manual", label: "Manual Instructions", hint: "Copy-paste steps" }
-      ]
-    });
-    if (pD2(publishMethod)) {
-      xe("Cancelled");
-      process.exit(0);
-    }
-    if (publishMethod === "issue") {
-      await handleIssueTemplate(args.path);
-      return;
-    }
-    if (publishMethod === "manual") {
-      await handleManualInstructions(args.path);
-      return;
-    }
-    const hasGhCli = checkGitHubCli();
-    if (!hasGhCli) {
-      M2.error("GitHub CLI (gh) is required for automated PR publishing.");
-      M2.info("Install it from: https://cli.github.com/");
-      M2.info("Then run: gh auth login");
-      M2.info("");
-      M2.info("Alternatively, use the Issue Template option to submit without CLI.");
-      process.exit(1);
-    }
-    const ghUser = getGitHubUsername();
-    if (!ghUser) {
-      M2.error("Not authenticated with GitHub CLI.");
-      M2.info("Run: gh auth login");
-      process.exit(1);
+    const dryRun = args["dry-run"];
+    Ie(`${icons2.package} ${dryRun ? "Validate" : "Publish"} an aspect`);
+    if (!dryRun) {
+      const loggedIn = await isLoggedIn();
+      if (!loggedIn) {
+        M2.error("Login required to publish with a name.");
+        console.log();
+        M2.info(`Run ${c3.highlight("aspects login")} to create an account and claim aspect names.`);
+        console.log();
+        M2.info(`Or use ${c3.highlight("aspects share")} to publish anonymously via hash (no account needed).`);
+        process.exit(1);
+      }
     }
-    M2.info(`Authenticated as: ${ghUser}`);
-    let aspectInfo;
     let aspectPath;
     if (args.path) {
       aspectPath = args.path;
     } else {
-      const spinner3 = Y3();
-      spinner3.start("Scanning for aspects...");
+      const spinner = Y3();
+      spinner.start("Scanning for aspects...");
       const aspects = await findLocalAspects();
-      spinner3.stop("Found aspects");
+      spinner.stop("Found aspects");
       if (aspects.length === 0) {
         M2.error("No aspects found.");
         M2.info("Create one with: aspects create my-aspect");
@@ -23688,97 +25700,93 @@ var publish_default = defineCommand({
     const spinner2 = Y3();
     spinner2.start("Validating aspect...");
     const validation = await validateAspect(aspectPath);
-    if (!validation.valid || !validation.aspect) {
+    if (!validation.valid || !validation.aspect || !validation.content) {
       spinner2.stop("Validation failed");
-      M2.error("✗ Aspect validation failed:");
+      M2.error("Invalid aspect.json:");
       for (const err of validation.errors || []) {
-        M2.error(`  • ${err}`);
+        M2.error(`  ${icons2.bullet} ${err}`);
       }
       M2.info("");
       M2.info("Fix these issues before publishing.");
       process.exit(1);
     }
-    spinner2.stop("Validation passed ✓");
-    aspectInfo = validation.aspect;
-    M2.info("");
-    M2.info(`  Name:     ${aspectInfo.name}@${aspectInfo.version}`);
-    M2.info(`  Display:  ${aspectInfo.displayName}`);
-    M2.info(`  Tagline:  ${aspectInfo.tagline}`);
-    if (aspectInfo.author) {
-      M2.info(`  Author:   ${aspectInfo.author}`);
+    const sizeBytes = Buffer.byteLength(validation.content);
+    if (sizeBytes > MAX_ASPECT_SIZE) {
+      spinner2.stop("Validation failed");
+      M2.error(`Aspect too large: ${sizeBytes} bytes (${MAX_ASPECT_SIZE} byte limit)`);
+      process.exit(1);
+    }
+    if (!dryRun) {
+      const auth = await getAuth();
+      if (validation.aspect.publisher && auth && validation.aspect.publisher !== auth.username) {
+        spinner2.stop("Validation failed");
+        M2.error(`Publisher mismatch: aspect.json has "${validation.aspect.publisher}" but you are "@${auth.username}"`);
+        M2.info("Update the publisher field in aspect.json or log in with the correct account.");
+        process.exit(1);
+      }
+    }
+    spinner2.stop("Validation passed");
+    console.log();
+    console.log(`  ${c3.label("Schema")}    valid`);
+    console.log(`  ${c3.label("Size")}      ${(sizeBytes / 1024).toFixed(1)} KB / ${(MAX_ASPECT_SIZE / 1024).toFixed(0)} KB`);
+    if (!dryRun) {
+      console.log(`  ${c3.label("Publisher")} ${validation.aspect.publisher || "not set"}`);
+    }
+    console.log();
+    console.log(`  ${c3.bold(validation.aspect.displayName)} ${c3.muted(`(${validation.aspect.name}@${validation.aspect.version})`)}`);
+    console.log(`  ${c3.italic(validation.aspect.tagline)}`);
+    console.log();
+    if (dryRun) {
+      M2.success("Would publish successfully");
+      Se("(No changes made)");
+      return;
     }
-    M2.info(`  Path:     ${aspectInfo.path}`);
-    M2.info("");
     const confirmPublish = await ye2({
-      message: "Publish this aspect to the Morphist registry?",
+      message: "Publish this aspect to the registry?",
       initialValue: true
     });
     if (pD2(confirmPublish) || !confirmPublish) {
       xe("Cancelled");
       process.exit(0);
     }
-    const spinner = Y3();
-    spinner.start("Checking for fork...");
-    const hasFork = await ensureFork(ghUser);
-    if (hasFork) {
-      spinner.stop("Fork ready");
-    } else {
-      spinner.stop("Fork created");
-    }
-    spinner.start("Preparing local copy...");
-    const forkDir = await prepareLocalFork(ghUser);
-    spinner.stop("Local copy ready");
-    const branchName = `add-${aspectInfo.name}`;
-    spinner.start(`Creating branch: ${branchName}...`);
-    await createBranch(forkDir, branchName);
-    spinner.stop("Branch created");
-    spinner.start("Adding aspect to registry...");
-    await copyAspectToRegistry(forkDir, aspectInfo);
-    spinner.stop("Aspect added");
-    spinner.start("Updating registry index...");
-    await updateRegistryIndex(forkDir, aspectInfo, ghUser);
-    spinner.stop("Index updated");
-    spinner.start("Committing changes...");
-    await commitAndPush(forkDir, aspectInfo.name, branchName);
-    spinner.stop("Changes pushed");
-    spinner.start("Creating pull request...");
-    const prUrl = await createPullRequest(forkDir, aspectInfo, branchName);
-    spinner.stop("Pull request created");
-    M2.success("");
-    M2.success("✓ Pull request created!");
-    M2.info("");
-    M2.info(`  PR:     ${prUrl}`);
-    M2.info(`  Aspect: https://github.com/${ghUser}/aspects/tree/${branchName}/${REGISTRY_DIR2}/${aspectInfo.name}`);
-    M2.info("");
-    M2.info("Your aspect will be available after review and merge.");
-    Se("Thanks for contributing! \uD83C\uDF89");
+    const spinner3 = Y3();
+    spinner3.start(`Publishing ${validation.aspect.name}@${validation.aspect.version}...`);
+    try {
+      const parsed = JSON.parse(validation.content);
+      const result = await publishAspect(parsed);
+      spinner3.stop("Published");
+      console.log();
+      console.log(`${icons2.success} Published ${c3.bold(`${result.name}@${result.version}`)}`);
+      console.log();
+      console.log(`  ${c3.label("View at")} ${result.url}`);
+      console.log();
+    } catch (err) {
+      spinner3.stop("Publish failed");
+      if (err instanceof ApiClientError) {
+        M2.error(err.message);
+        if (err.errorCode === "version_exists") {
+          M2.info("");
+          M2.info("Tip: Bump the version in aspect.json and try again");
+        } else if (err.errorCode === "name_taken") {
+          M2.info("");
+          M2.info("Tip: Choose a different name in aspect.json");
+        } else if (err.errorCode === "unauthorized") {
+          M2.info("");
+          M2.info('Run "aspects login" to authenticate');
+        }
+      } else {
+        M2.error(`Publish failed: ${err.message}`);
+      }
+      process.exit(1);
+    }
   }
 });
-function checkGitHubCli() {
-  try {
-    execSync2("gh --version", { stdio: "pipe" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function getGitHubUsername() {
-  try {
-    const result = execSync2("gh api user --jq .login", {
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    return result || null;
-  } catch {
-    return null;
-  }
-}
 async function loadAspectFromPath2(inputPath) {
   let aspectPath = inputPath;
   try {
-    const stats = await stat5(inputPath);
+    const stats = await stat6(inputPath);
     if (stats.isDirectory()) {
-      aspectPath = join8(inputPath, "aspect.json");
+      aspectPath = join9(inputPath, "aspect.json");
     }
   } catch {
     return null;
@@ -23793,6 +25801,7 @@ async function loadAspectFromPath2(inputPath) {
       tagline: aspect.tagline,
       version: aspect.version || "1.0.0",
       category: aspect.category,
+      publisher: aspect.publisher,
       author: aspect.author
     };
   } catch {
@@ -23809,7 +25818,7 @@ async function findLocalAspects() {
     const entries = await readdir2(process.cwd(), { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory() && !entry.name.startsWith(".")) {
-        const subAspect = await loadAspectFromPath2(join8(process.cwd(), entry.name));
+        const subAspect = await loadAspectFromPath2(join9(process.cwd(), entry.name));
         if (subAspect && !aspects.find((a2) => a2.path === subAspect.path)) {
           aspects.push(subAspect);
         }
@@ -23820,7 +25829,7 @@ async function findLocalAspects() {
     const entries = await readdir2(ASPECTS_DIR, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        const installedAspect = await loadAspectFromPath2(join8(ASPECTS_DIR, entry.name));
+        const installedAspect = await loadAspectFromPath2(join9(ASPECTS_DIR, entry.name));
         if (installedAspect && !aspects.find((a2) => a2.path === installedAspect.path)) {
           aspects.push(installedAspect);
         }
@@ -23829,119 +25838,12 @@ async function findLocalAspects() {
   } catch {}
   return aspects;
 }
-async function ensureFork(ghUser) {
-  try {
-    execSync2(`gh repo view ${ghUser}/aspects`, { stdio: "pipe" });
-    return true;
-  } catch {
-    execSync2(`gh repo fork ${GITHUB_REPO2} --clone=false`, { stdio: "pipe" });
-    return false;
-  }
-}
-async function prepareLocalFork(ghUser) {
-  const forkDir = join8(homedir2(), ".aspects", ".publish-cache", "aspects");
-  try {
-    await stat5(join8(forkDir, ".git"));
-    execSync2("git fetch origin", { cwd: forkDir, stdio: "pipe" });
-    execSync2("git checkout main", { cwd: forkDir, stdio: "pipe" });
-    execSync2("git pull origin main", { cwd: forkDir, stdio: "pipe" });
-  } catch {
-    await mkdir5(dirname3(forkDir), { recursive: true });
-    execSync2(`gh repo clone ${ghUser}/aspects ${forkDir}`, { stdio: "pipe" });
-    try {
-      execSync2(`git remote add upstream https://github.com/${GITHUB_REPO2}.git`, {
-        cwd: forkDir,
-        stdio: "pipe"
-      });
-    } catch {}
-  }
-  try {
-    execSync2("git fetch upstream", { cwd: forkDir, stdio: "pipe" });
-    execSync2("git merge upstream/main --no-edit", {
-      cwd: forkDir,
-      stdio: "pipe"
-    });
-  } catch {}
-  return forkDir;
-}
-async function createBranch(forkDir, branchName) {
-  try {
-    execSync2(`git branch -D ${branchName}`, { cwd: forkDir, stdio: "pipe" });
-  } catch {}
-  execSync2(`git checkout -b ${branchName}`, { cwd: forkDir, stdio: "pipe" });
-}
-async function copyAspectToRegistry(forkDir, aspectInfo) {
-  const targetDir = join8(forkDir, REGISTRY_DIR2, aspectInfo.name);
-  await mkdir5(targetDir, { recursive: true });
-  const sourceFile = join8(aspectInfo.path, "aspect.json");
-  const targetFile = join8(targetDir, "aspect.json");
-  const content = await readFile8(sourceFile, "utf-8");
-  await writeFile6(targetFile, content);
-}
-async function updateRegistryIndex(forkDir, aspectInfo, ghUser) {
-  const indexPath = join8(forkDir, INDEX_PATH2);
-  const indexContent = await readFile8(indexPath, "utf-8");
-  const index = JSON.parse(indexContent);
-  const now = new Date().toISOString();
-  index.aspects[aspectInfo.name] = {
-    latest: aspectInfo.version,
-    versions: {
-      [aspectInfo.version]: {
-        published: now,
-        url: `https://raw.githubusercontent.com/${GITHUB_REPO2}/main/${REGISTRY_DIR2}/${aspectInfo.name}/aspect.json`
-      }
-    },
-    metadata: {
-      displayName: aspectInfo.displayName,
-      tagline: aspectInfo.tagline,
-      category: aspectInfo.category || "assistant",
-      publisher: ghUser,
-      githubUrl: `https://github.com/${ghUser}/aspects/tree/main/${REGISTRY_DIR2}/${aspectInfo.name}`,
-      trust: "community"
-    }
-  };
-  index.updated = now;
-  await writeFile6(indexPath, JSON.stringify(index, null, 2) + `
-`);
-}
-async function commitAndPush(forkDir, aspectName, branchName) {
-  execSync2("git add .", { cwd: forkDir, stdio: "pipe" });
-  execSync2(`git commit -m "Add ${aspectName} aspect"`, {
-    cwd: forkDir,
-    stdio: "pipe"
-  });
-  execSync2(`git push -u origin ${branchName} --force`, {
-    cwd: forkDir,
-    stdio: "pipe"
-  });
-}
-async function createPullRequest(forkDir, aspectInfo, branchName) {
-  const title = `Add ${aspectInfo.displayName} aspect`;
-  const body = `## New Aspect: ${aspectInfo.displayName}
-
-**Name:** \`${aspectInfo.name}\`
-**Version:** ${aspectInfo.version}
-**Tagline:** ${aspectInfo.tagline}
-${aspectInfo.category ? `**Category:** ${aspectInfo.category}` : ""}
-${aspectInfo.author ? `**Author:** ${aspectInfo.author}` : ""}
-
----
-
-*Submitted via \`aspects publish\`*
-`;
-  const result = execSync2(`gh pr create --repo ${GITHUB_REPO2} --title "${title}" --body "${body.replace(/"/g, "\\\"")}" --head ${branchName}`, {
-    cwd: forkDir,
-    encoding: "utf-8",
-    stdio: ["pipe", "pipe", "pipe"]
-  });
-  return result.trim();
-}
 async function validateAspect(aspectPath) {
   let filePath = aspectPath;
   try {
-    const stats = await stat5(aspectPath);
+    const stats = await stat6(aspectPath);
     if (stats.isDirectory()) {
-      filePath = join8(aspectPath, "aspect.json");
+      filePath = join9(aspectPath, "aspect.json");
     }
   } catch {
     return { valid: false, errors: [`Path not found: ${aspectPath}`] };
@@ -23956,7 +25858,12 @@ async function validateAspect(aspectPath) {
   try {
     data = JSON.parse(content);
   } catch (err) {
-    return { valid: false, errors: [`Invalid JSON: ${err instanceof Error ? err.message : "parse error"}`] };
+    return {
+      valid: false,
+      errors: [
+        `Invalid JSON: ${err instanceof Error ? err.message : "parse error"}`
+      ]
+    };
   }
   const result = aspectSchema.safeParse(data);
   if (!result.success) {
@@ -23977,118 +25884,15 @@ async function validateAspect(aspectPath) {
       tagline: aspect.tagline,
       version: aspect.version || "1.0.0",
       category: aspect.category,
+      publisher: aspect.publisher,
       author: aspect.author
     }
   };
 }
-async function handleIssueTemplate(inputPath) {
-  M2.info("");
-  M2.info("\uD83D\uDCDD Issue Template Submission");
-  M2.info("");
-  if (inputPath) {
-    const validation = await validateAspect(inputPath);
-    if (validation.valid && validation.aspect) {
-      M2.success(`✓ Aspect validated: ${validation.aspect.displayName}`);
-      M2.info("");
-      M2.info("Your aspect.json content (copy this to the issue form):");
-      M2.info("─".repeat(50));
-      console.log(validation.content);
-      M2.info("─".repeat(50));
-      M2.info("");
-    } else if (validation.errors) {
-      M2.warn("⚠️  Validation issues found:");
-      for (const err of validation.errors) {
-        M2.error(`  • ${err}`);
-      }
-      M2.info("");
-      M2.info("Fix these issues before submitting.");
-      M2.info("");
-    }
-  }
-  M2.info("\uD83D\uDCCF Field Limits:");
-  M2.info(`  • name: ${FIELD_LIMITS.name} chars (lowercase, hyphens only)`);
-  M2.info(`  • displayName: ${FIELD_LIMITS.displayName} chars`);
-  M2.info(`  • tagline: ${FIELD_LIMITS.tagline} chars`);
-  M2.info(`  • prompt: ${FIELD_LIMITS.prompt} chars`);
-  M2.info(`  • tags: max ${FIELD_LIMITS.maxTags} tags, ${FIELD_LIMITS.tag} chars each`);
-  M2.info("");
-  const openBrowser = await ye2({
-    message: "Open issue template in browser?",
-    initialValue: true
-  });
-  if (pD2(openBrowser)) {
-    xe("Cancelled");
-    process.exit(0);
-  }
-  if (openBrowser) {
-    try {
-      execSync2(`open "${ISSUE_TEMPLATE_URL}"`, { stdio: "pipe" });
-      M2.success("Opened in browser!");
-    } catch {
-      try {
-        execSync2(`xdg-open "${ISSUE_TEMPLATE_URL}"`, { stdio: "pipe" });
-        M2.success("Opened in browser!");
-      } catch {
-        M2.info(`Open this URL manually: ${ISSUE_TEMPLATE_URL}`);
-      }
-    }
-  } else {
-    M2.info(`Submit at: ${ISSUE_TEMPLATE_URL}`);
-  }
-  Se("Thanks for contributing! \uD83C\uDF89");
-}
-async function handleManualInstructions(inputPath) {
-  M2.info("");
-  M2.info("\uD83D\uDCCB Manual Submission Instructions");
-  M2.info("");
-  if (inputPath) {
-    const validation = await validateAspect(inputPath);
-    if (validation.valid && validation.aspect) {
-      M2.success(`✓ Aspect validated: ${validation.aspect.displayName}`);
-    } else if (validation.errors) {
-      M2.warn("⚠️  Validation issues found:");
-      for (const err of validation.errors) {
-        M2.error(`  • ${err}`);
-      }
-      M2.info("");
-    }
-  }
-  M2.info("Option 1: Submit via Issue Template (Easiest)");
-  M2.info("─".repeat(50));
-  M2.info(`  1. Go to: ${ISSUE_TEMPLATE_URL}`);
-  M2.info("  2. Fill out the form with your aspect details");
-  M2.info("  3. Paste your aspect.json content");
-  M2.info("  4. Submit the issue");
-  M2.info("  5. A maintainer will review and add your aspect");
-  M2.info("");
-  M2.info("Option 2: Fork & Pull Request");
-  M2.info("─".repeat(50));
-  M2.info(`  1. Fork https://github.com/${GITHUB_REPO2}`);
-  M2.info("  2. Clone your fork locally");
-  M2.info("  3. Create a new branch: git checkout -b add-your-aspect");
-  M2.info("  4. Create directory: registry/aspects/your-aspect-name/");
-  M2.info("  5. Add your aspect.json file to that directory");
-  M2.info("  6. Update registry/index.json with your aspect metadata");
-  M2.info("  7. Commit and push your changes");
-  M2.info(`  8. Open a PR to ${GITHUB_REPO2}`);
-  M2.info("");
-  M2.info("\uD83D\uDCCF Field Limits:");
-  M2.info(`  • name: ${FIELD_LIMITS.name} chars (lowercase, hyphens only)`);
-  M2.info(`  • displayName: ${FIELD_LIMITS.displayName} chars`);
-  M2.info(`  • tagline: ${FIELD_LIMITS.tagline} chars`);
-  M2.info(`  • prompt: ${FIELD_LIMITS.prompt} chars`);
-  M2.info(`  • tags: max ${FIELD_LIMITS.maxTags} tags, ${FIELD_LIMITS.tag} chars each`);
-  M2.info("");
-  M2.info("\uD83D\uDCDA Documentation:");
-  M2.info(`  • Schema: https://github.com/${GITHUB_REPO2}/blob/main/docs/CLI.md#aspect-schema-v2`);
-  M2.info(`  • Examples: https://github.com/${GITHUB_REPO2}/tree/main/registry/aspects`);
-  M2.info("");
-  Se("Good luck with your submission! \uD83C\uDF89");
-}
 
 // src/commands/edit.ts
-import { readFile as readFile9, writeFile as writeFile7 } from "node:fs/promises";
-import { join as join9 } from "node:path";
+import { readFile as readFile9, writeFile as writeFile6 } from "node:fs/promises";
+import { join as join10 } from "node:path";
 var CATEGORIES = [
   "assistant",
   "roleplay",
@@ -24105,7 +25909,7 @@ async function listLocalAspects() {
   const results = [];
   for (const [name, info] of Object.entries(config2.installed)) {
     const aspectPath = info.path || getAspectPath(name);
-    const parseResult = await parseAspectFile(join9(aspectPath, "aspect.yaml"));
+    const parseResult = await parseAspectFile(join10(aspectPath, "aspect.json"));
     if (parseResult.success) {
       results.push({ name, path: aspectPath, aspect: parseResult.aspect });
     }
@@ -24261,7 +26065,7 @@ var edit_default = defineCommand({
       xe("Cancelled");
       return;
     }
-    const aspectPath = join9(selectedAspect.path, "aspect.yaml");
+    const aspectPath = join10(selectedAspect.path, "aspect.json");
     const content = await readFile9(aspectPath, "utf-8");
     let updatedContent = content;
     if (changes.includes("displayName")) {
@@ -24290,17 +26094,17 @@ ${updatedAspect.tags.map((t4) => `  - ${t4}`).join(`
 `);
       }
     }
-    await writeFile7(aspectPath, updatedContent);
+    await writeFile6(aspectPath, updatedContent);
     console.log();
-    console.log(`${icons2.success} Updated ${c3.bold(selectedAspect.name)}/aspect.yaml`);
+    console.log(`${icons2.success} Updated ${c3.bold(selectedAspect.name)}/aspect.json`);
     console.log(`  ${c3.muted(`Changed: ${changes.join(", ")}`)}`);
     console.log();
   }
 });
 
 // src/commands/bundle.ts
-import { readFile as readFile10, writeFile as writeFile8 } from "node:fs/promises";
-import { join as join10 } from "node:path";
+import { readFile as readFile10, writeFile as writeFile7 } from "node:fs/promises";
+import { join as join11 } from "node:path";
 var import_picocolors4 = __toESM(require_picocolors(), 1);
 function parseQuery2(query) {
   const filters = [];
@@ -24380,7 +26184,7 @@ async function loadLocalAspects() {
   const aspects = [];
   for (const name of Object.keys(config2.installed || {})) {
     try {
-      const aspectPath = join10(getAspectPath(name), "aspect.json");
+      const aspectPath = join11(getAspectPath(name), "aspect.json");
       const content = await readFile10(aspectPath, "utf-8");
       aspects.push(JSON.parse(content));
     } catch {}
@@ -24394,7 +26198,7 @@ async function loadRegistryAspects() {
     try {
       const versionInfo = entry.versions[entry.latest];
       if (versionInfo?.url) {
-        const yamlContent = await fetchAspectYaml(versionInfo.url);
+        const yamlContent = await fetchAspectContent(versionInfo.url);
         const aspect = JSON.parse(yamlContent);
         aspects.push(aspect);
       }
@@ -24458,13 +26262,13 @@ var bundle_default = defineCommand({
             if (entry) {
               const versionInfo = entry.versions[entry.latest];
               if (versionInfo?.url) {
-                const content = await fetchAspectYaml(versionInfo.url);
+                const content = await fetchAspectContent(versionInfo.url);
                 const aspect = JSON.parse(content);
                 aspectsToBundle.push(aspect);
               }
             }
           } else {
-            const aspectPath = join10(getAspectPath(name), "aspect.json");
+            const aspectPath = join11(getAspectPath(name), "aspect.json");
             const content = await readFile10(aspectPath, "utf-8");
             aspectsToBundle.push(JSON.parse(content));
           }
@@ -24506,7 +26310,7 @@ var bundle_default = defineCommand({
             if (entry) {
               const versionInfo = entry.versions[entry.latest];
               if (versionInfo?.url) {
-                const content = await fetchAspectYaml(versionInfo.url);
+                const content = await fetchAspectContent(versionInfo.url);
                 const aspect = JSON.parse(content);
                 if (!aspectsToBundle.some((a2) => a2.name === aspect.name)) {
                   aspectsToBundle.push(aspect);
@@ -24514,7 +26318,7 @@ var bundle_default = defineCommand({
               }
             }
           } else {
-            const aspectPath = join10(getAspectPath(aspectName), "aspect.json");
+            const aspectPath = join11(getAspectPath(aspectName), "aspect.json");
             const content = await readFile10(aspectPath, "utf-8");
             const aspect = JSON.parse(content);
             if (!aspectsToBundle.some((a2) => a2.name === aspect.name)) {
@@ -24547,7 +26351,7 @@ var bundle_default = defineCommand({
       aspects: aspectsToBundle
     };
     const outputPath = args.output;
-    await writeFile8(outputPath, JSON.stringify(bundle, null, 2) + `
+    await writeFile7(outputPath, JSON.stringify(bundle, null, 2) + `
 `);
     console.log();
     console.log(`${c3.dim("Bundled aspects:")}`);
@@ -24560,7 +26364,7 @@ var bundle_default = defineCommand({
 });
 async function loadSet2(name) {
   try {
-    const setPath = join10(getSetsDir(), name, "set.json");
+    const setPath = join11(getSetsDir(), name, "set.json");
     const content = await readFile10(setPath, "utf-8");
     return JSON.parse(content);
   } catch {
@@ -24568,41 +26372,406 @@ async function loadSet2(name) {
   }
 }
 
+// src/commands/login.ts
+var login_default = defineCommand({
+  meta: {
+    name: "login",
+    description: "Authenticate with the aspects registry"
+  },
+  async run() {
+    const auth = await getAuth();
+    if (auth && await isLoggedIn()) {
+      console.log();
+      console.log(`${icons2.info} Already logged in as ${c3.bold(`@${auth.username}`)}`);
+      console.log(c3.muted('  Run "aspects logout" to sign out first.'));
+      console.log();
+      return;
+    }
+    console.log();
+    log.start("Requesting authorization...");
+    let deviceCode;
+    try {
+      deviceCode = await initiateDeviceAuth();
+    } catch (err) {
+      log.error(`Failed to initiate login: ${err.message}`);
+      process.exit(1);
+    }
+    console.log();
+    console.log(`  ${c3.bold("Please visit this URL and enter the code:")}`);
+    console.log(`  ${c3.highlight(deviceCode.verification_uri_complete)}`);
+    console.log();
+    console.log(`  Code: ${c3.bold(deviceCode.user_code)}`);
+    console.log();
+    try {
+      const { exec } = await import("node:child_process");
+      const platform2 = process.platform;
+      const openCmd = platform2 === "darwin" ? "open" : platform2 === "win32" ? "start" : "xdg-open";
+      exec(`${openCmd} "${deviceCode.verification_uri_complete}"`);
+    } catch {}
+    console.log(c3.muted("  Waiting for authorization... (Press Ctrl+C to cancel)"));
+    console.log();
+    let interval = deviceCode.interval * 1000;
+    const expiresAt = Date.now() + deviceCode.expires_in * 1000;
+    while (Date.now() < expiresAt) {
+      await new Promise((r6) => setTimeout(r6, interval));
+      try {
+        const result = await pollDeviceAuth(deviceCode.device_code, deviceCode.code_verifier);
+        if (result.ok && result.access_token) {
+          const expiresIn = result.expires_in ?? 3600;
+          const expiresAtDate = new Date(Date.now() + expiresIn * 1000).toISOString();
+          const username = extractUsernameFromToken(result.access_token) ?? "user";
+          await setAuthTokens({
+            accessToken: result.access_token,
+            refreshToken: result.refresh_token,
+            expiresAt: expiresAtDate,
+            username
+          });
+          console.log(`${icons2.success} Authorized as ${c3.bold(`@${username}`)}`);
+          console.log(c3.muted("  Access token stored in ~/.aspects/config.json"));
+          console.log();
+          return;
+        }
+        if (!result.ok) {
+          switch (result.status) {
+            case "pending":
+              continue;
+            case "slow_down":
+              interval *= 2;
+              continue;
+            case "expired":
+              log.error('Authorization code expired. Please run "aspects login" again.');
+              process.exit(1);
+              break;
+            case "denied":
+              log.error("Authorization denied.");
+              process.exit(1);
+              break;
+            default:
+              log.error(`Unexpected status: ${result.status}`);
+              process.exit(1);
+          }
+        }
+      } catch (err) {
+        continue;
+      }
+    }
+    log.error('Authorization timed out. Please run "aspects login" again.');
+    process.exit(1);
+  }
+});
+function extractUsernameFromToken(token) {
+  try {
+    const parts = token.split(".");
+    if (parts.length !== 3)
+      return null;
+    const payload = JSON.parse(Buffer.from(parts[1], "base64url").toString());
+    return payload.username ?? payload.sub ?? payload.preferred_username ?? null;
+  } catch {
+    return null;
+  }
+}
+
+// src/commands/logout.ts
+var logout_default = defineCommand({
+  meta: {
+    name: "logout",
+    description: "Clear stored authentication tokens"
+  },
+  async run() {
+    const auth = await getAuth();
+    if (!auth) {
+      console.log();
+      console.log(`${icons2.info} Not logged in.`);
+      console.log();
+      return;
+    }
+    const username = auth.username;
+    await clearAuth();
+    console.log();
+    console.log(`${icons2.success} Logged out${username ? ` from @${username}` : ""}`);
+    console.log(c3.muted("  Auth tokens removed from ~/.aspects/config.json"));
+    console.log();
+  }
+});
+
+// src/commands/share.ts
+import { stat as stat7 } from "node:fs/promises";
+import { join as join12 } from "node:path";
+var MAX_ASPECT_SIZE2 = 51200;
+var share_default = defineCommand({
+  meta: {
+    name: "share",
+    description: "Share an aspect anonymously via content hash (no account required)"
+  },
+  args: {
+    target: {
+      type: "positional",
+      description: "Aspect name (if installed) or path to aspect.json",
+      required: false
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Compute hash without uploading"
+    }
+  },
+  async run({ args }) {
+    const dryRun = args["dry-run"];
+    Ie(`${icons2.share} ${dryRun ? "Preview" : "Share"} an aspect`);
+    const target = args.target;
+    if (!target) {
+      M2.error("Please specify an aspect to share.");
+      console.log();
+      M2.info("Usage:");
+      console.log(`  ${c3.cmd("aspects share <name>")}     Share an installed aspect`);
+      console.log(`  ${c3.cmd("aspects share ./path")}     Share from a local path`);
+      console.log();
+      const installed = await listInstalledAspects();
+      if (installed.length > 0) {
+        M2.info("Installed aspects you can share:");
+        for (const item of installed.slice(0, 10)) {
+          console.log(`  ${icons2.bullet} ${c3.aspect(item.name)}`);
+        }
+        if (installed.length > 10) {
+          console.log(`  ${c3.muted(`...and ${installed.length - 10} more`)}`);
+        }
+      }
+      process.exit(1);
+    }
+    let aspect;
+    if (target.startsWith(".") || target.startsWith("/")) {
+      let filePath = target;
+      try {
+        const stats = await stat7(target);
+        if (stats.isDirectory()) {
+          const jsonPath = join12(target, "aspect.json");
+          const yamlPath = join12(target, "aspect.yaml");
+          try {
+            await stat7(jsonPath);
+            filePath = jsonPath;
+          } catch {
+            filePath = yamlPath;
+          }
+        }
+      } catch {
+        M2.error(`Path not found: ${target}`);
+        process.exit(1);
+      }
+      const result = await parseAspectFile(filePath);
+      if (!result.success) {
+        M2.error(`Invalid aspect: ${result.errors.join(", ")}`);
+        process.exit(1);
+      }
+      aspect = result.aspect;
+    } else {
+      const loaded = await loadInstalledAspect(target);
+      if (!loaded) {
+        M2.error(`Aspect "${target}" is not installed or cannot be read`);
+        M2.info("To share from a path, use: aspects share ./path/to/aspect.json");
+        process.exit(1);
+      }
+      aspect = loaded;
+    }
+    const content = canonicalizeAspect(aspect);
+    const sizeBytes = Buffer.byteLength(content);
+    if (sizeBytes > MAX_ASPECT_SIZE2) {
+      M2.error(`Aspect too large: ${sizeBytes} bytes (${MAX_ASPECT_SIZE2} byte limit)`);
+      process.exit(1);
+    }
+    const hash2 = blake3HashAspect(aspect);
+    console.log();
+    console.log(`  ${c3.bold(aspect.displayName)} ${c3.muted(`(${aspect.name}@${aspect.version})`)}`);
+    console.log(`  ${c3.italic(aspect.tagline)}`);
+    console.log();
+    console.log(`  ${c3.label("Size")} ${(sizeBytes / 1024).toFixed(1)} KB`);
+    console.log(`  ${c3.label("Hash")} ${hash2}`);
+    console.log();
+    if (dryRun) {
+      M2.info("Dry run — not uploading");
+      console.log();
+      console.log(`  ${c3.label("Install")} aspects add hash:${hash2}`);
+      console.log();
+      Se("(No upload performed)");
+      return;
+    }
+    const spinner = Y3();
+    spinner.start("Uploading...");
+    try {
+      const response = await publishAnonymous(aspect);
+      spinner.stop("Uploaded");
+      if (response.blake3 !== hash2) {
+        M2.warn("Hash mismatch: client and server computed different hashes.");
+        console.log(`  ${c3.muted("Client:")} ${hash2}`);
+        console.log(`  ${c3.muted("Server:")} ${response.blake3}`);
+        console.log(`  ${c3.muted("Using server hash (authoritative).")}`);
+        console.log();
+      }
+      console.log();
+      console.log(`${icons2.success} ${c3.bold("Shared successfully!")}`);
+      console.log();
+      console.log(`  ${c3.label("Hash")}    ${response.blake3}`);
+      console.log(`  ${c3.label("Install")} ${c3.highlight(`aspects add blake3:${response.blake3}`)}`);
+      if (response.existing) {
+        console.log(`  ${c3.muted("(Already existed on registry)")}`);
+      }
+      console.log();
+      Se("Share this hash with anyone to let them install your aspect!");
+    } catch (err) {
+      spinner.stop("Upload failed");
+      if (err instanceof ApiClientError) {
+        M2.error(err.message);
+        if (err.errorCode === "already_exists") {
+          console.log();
+          console.log(`${icons2.info} This aspect is already available on the registry.`);
+          console.log();
+          console.log(`  ${c3.label("Hash")}    ${hash2}`);
+          console.log(`  ${c3.label("Install")} ${c3.highlight(`aspects add hash:${hash2}`)}`);
+          console.log();
+          return;
+        }
+      } else {
+        M2.error(`Upload failed: ${err.message}`);
+      }
+      process.exit(1);
+    }
+  }
+});
+
+// src/commands/unpublish.ts
+var unpublish_default = defineCommand({
+  meta: {
+    name: "unpublish",
+    description: "Unpublish a version from the registry"
+  },
+  args: {
+    target: {
+      type: "positional",
+      description: "Aspect to unpublish (name@version)",
+      required: true
+    }
+  },
+  async run({ args }) {
+    const target = args.target;
+    const atIndex = target.lastIndexOf("@");
+    if (atIndex <= 0) {
+      M2.error("Please specify name@version (e.g. my-aspect@1.0.0)");
+      process.exit(1);
+    }
+    const name = target.slice(0, atIndex);
+    const version2 = target.slice(atIndex + 1);
+    Ie(`${icons2.package} Unpublish ${c3.bold(`${name}@${version2}`)}`);
+    const loggedIn = await isLoggedIn();
+    if (!loggedIn) {
+      M2.error('Not logged in. Run "aspects login" first.');
+      process.exit(1);
+    }
+    const confirmed = await ye2({
+      message: `Are you sure you want to unpublish ${name}@${version2}? This cannot be undone.`,
+      initialValue: false
+    });
+    if (pD2(confirmed) || !confirmed) {
+      xe("Cancelled");
+      process.exit(0);
+    }
+    const spinner = Y3();
+    spinner.start(`Unpublishing ${name}@${version2}...`);
+    try {
+      const result = await unpublishAspect(name, version2);
+      spinner.stop("Done");
+      console.log();
+      console.log(`${icons2.success} ${result.message}`);
+      console.log();
+    } catch (err) {
+      spinner.stop("Failed");
+      if (err instanceof ApiClientError) {
+        M2.error(err.message);
+        if (err.errorCode === "forbidden") {
+          M2.info("Unpublish is only allowed within 72 hours of publishing.");
+        } else if (err.errorCode === "not_found") {
+          M2.info("That version does not exist in the registry.");
+        } else if (err.errorCode === "unauthorized") {
+          M2.info('Run "aspects login" to authenticate.');
+        }
+      } else {
+        M2.error(`Unpublish failed: ${err.message}`);
+      }
+      process.exit(1);
+    }
+  }
+});
+
 // src/cli.ts
+var ALIASES = {
+  c: "create",
+  new: "create",
+  n: "create",
+  install: "add",
+  get: "add",
+  a: "add",
+  i: "add",
+  g: "add"
+};
+var ALIAS_HINTS = {};
+for (const [alias, canonical] of Object.entries(ALIASES)) {
+  (ALIAS_HINTS[canonical] ??= []).push(alias);
+}
+var cmdArg = process.argv[2];
+if (cmdArg && ALIASES[cmdArg]) {
+  process.argv[2] = ALIASES[cmdArg];
+}
+var COMMANDS = [
+  { name: "create", cmd: create_default, desc: "Create a new aspect interactively", aliases: ["c", "new", "n"] },
+  { name: "add", cmd: add_default, desc: "Install aspect(s) to your local library", aliases: ["install", "get", "a", "i", "g"] },
+  { name: "list", cmd: list_default, desc: "List installed aspects" },
+  { name: "search", cmd: search_default, desc: "Search the aspect registry" },
+  { name: "find", cmd: find_default, desc: "Search aspects with filters and operators" },
+  { name: "info", cmd: info_default, desc: "Show details about an aspect" },
+  { name: "remove", cmd: remove_default, desc: "Remove an installed aspect" },
+  { name: "update", cmd: update_default, desc: "Update installed aspect(s) to latest version" },
+  { name: "validate", cmd: validate_default, desc: "Validate an aspect.json file" },
+  { name: "compile", cmd: compile_default, desc: "Compile an aspect's prompt for a model" },
+  { name: "publish", cmd: publish_default, desc: "Publish an aspect to the registry" },
+  { name: "set", cmd: set_default, desc: "Manage aspect sets (collections)" },
+  { name: "edit", cmd: edit_default, desc: "Edit an existing aspect" },
+  { name: "bundle", cmd: bundle_default, desc: "Bundle multiple aspects into one file" },
+  { name: "share", cmd: share_default, desc: "Share an aspect via content hash" },
+  { name: "unpublish", cmd: unpublish_default, desc: "Unpublish a version from the registry" },
+  { name: "login", cmd: login_default, desc: "Authenticate with the registry" },
+  { name: "logout", cmd: logout_default, desc: "Clear stored authentication tokens" }
+];
+function showCustomHelp() {
+  morphistBanner();
+  console.log(import_picocolors5.default.dim(`Package manager for AI personality aspects (v0.1.0)`));
+  console.log();
+  console.log(`${import_picocolors5.default.bold(import_picocolors5.default.underline("USAGE"))} ${import_picocolors5.default.cyan("aspects")} ${import_picocolors5.default.dim("<command>")} ${import_picocolors5.default.dim("[options]")}`);
+  console.log();
+  console.log(import_picocolors5.default.bold(import_picocolors5.default.underline("COMMANDS")));
+  console.log();
+  const maxNameLen = Math.max(...COMMANDS.map((c5) => c5.name.length));
+  for (const { name, desc, aliases } of COMMANDS) {
+    const paddedName = name.padStart(maxNameLen);
+    const aliasPart = aliases?.length ? `  ${import_picocolors5.default.dim("also:")} ${aliases.map((a2) => import_picocolors5.default.cyan(a2)).join(import_picocolors5.default.dim(", "))}` : "";
+    console.log(`  ${import_picocolors5.default.cyan(paddedName)}  ${desc}${aliasPart}`);
+  }
+  console.log();
+  console.log(`Use ${import_picocolors5.default.cyan("aspects <command> --help")} for more info.`);
+  console.log();
+}
+var showingHelp = process.argv.length === 2 || process.argv.length === 3 && (process.argv[2] === "--help" || process.argv[2] === "-h");
+if (showingHelp) {
+  showCustomHelp();
+  process.exit(0);
+}
+var subCommands = {};
+for (const { name, cmd } of COMMANDS) {
+  subCommands[name] = cmd;
+}
 var main = defineCommand({
   meta: {
     name: "aspects",
     version: "0.1.0",
     description: "Package manager for AI personality aspects"
   },
-  subCommands: {
-    create: create_default,
-    c: create_default,
-    new: create_default,
-    n: create_default,
-    add: add_default,
-    install: add_default,
-    get: add_default,
-    a: add_default,
-    i: add_default,
-    g: add_default,
-    list: list_default,
-    search: search_default,
-    find: find_default,
-    info: info_default,
-    remove: remove_default,
-    update: update_default,
-    validate: validate_default,
-    compile: compile_default,
-    publish: publish_default,
-    set: set_default,
-    edit: edit_default,
-    bundle: bundle_default
-  }
+  subCommands
 });
 morphistBanner();
-var args = process.argv.slice(2);
-if (args.length === 0 || args[0] && args[0].startsWith("-") && args[0] !== "--help" && args[0] !== "-h") {
-  process.argv.splice(2, 0, "create");
-}
 runMain(main);