@aigne/aos 0.2.0-beta

package/dist/blocklet/did-space-registry.mjs

@@ -0,0 +1,281 @@
+import { createAfsBlockletReader, createMapBlockletReader } from "./registry.mjs";
+import { joinURL } from "ufo";
+import { normalizeId } from "@aigne/afs-did-space";
+import { getRequestScope } from "@aigne/afs-logger";
+import { time } from "@aigne/afs-timing";
+
+//#region src/blocklet/did-space-registry.ts
+/**
+* DID-Space-backed BlockletRegistry — runtime-agnostic engine (#674 v2).
+*
+* Resolves blocklets published to a DID Space via the global resolve table
+* (`resolve/blocklet/<id>` → { owner, path }, written by the did-space provider's
+* blocklet write-hook) and reads their files back through AFS. This lives in
+* @aigne/aos (NOT @aigne/afs-did-space) because it needs `createAfsBlockletReader`
+* + the Blocklet types, and aos already depends on did-space — the reverse
+* dependency would be a cycle. Both runtimes (Node + CF) depend on aos, so this
+* engine is shared: each runtime injects only the two things it does
+* differently — how to read the resolve table and how to open an owner's space.
+*
+* Lookup path:
+*   1. resolver.resolveBlocklet(name) → { owner, path }
+*   2. openUserSpace(owner)           → AFS rooted at the owner's whole space
+*   3. createAfsBlockletReader(afs, "/"+path) → file reader for the blocklet
+*
+* The engine is decoupled from any concrete class via two minimal structural
+* interfaces (BlockletResolveSource + the loose BlockletAfsReader): a
+* `DIDSpaceResolver` satisfies the former, a mounted `AFS` the latter.
+*/
+/**
+* Publish-time serve bundle for a DID-Space blocklet (#674 Phase 4): small text
+* files inlined so a cold serve reads one object instead of one-per-file. Sits
+* at the blocklet root as the matched partner of the `.blocklet-publish.json`
+* register marker (a distinct name — NOT http-mount's `.afs/bundle.json`, which
+* is a different mechanism / consumer).
+*/
+const BLOCKLET_BUNDLE_PATH = ".blocklet-bundle.json";
+const BUNDLE_DECODER = new TextDecoder();
+/** Extract UTF-8 text from an AFS read result's `content` (string | bytes). */
+function decodeAfsText(raw) {
+	const content = raw?.content;
+	if (typeof content === "string") return content;
+	if (content instanceof Uint8Array) return BUNDLE_DECODER.decode(content);
+	if (content instanceof ArrayBuffer) return BUNDLE_DECODER.decode(new Uint8Array(content));
+	return "";
+}
+/**
+* A BlockletReader backed by a publish-time `.afs/bundle.json` (small text files
+* inlined at publish; see `shouldBundle`) layered over the live per-file AFS
+* reader — the fallback serves large/binary files (not bundled) and blocklets
+* that have no bundle.
+*
+* Why this exists: blocklet serve is one-file-per-request, so a cold isolate's
+* first page load of a many-file blocklet would otherwise do one object read per
+* file. Reading the bundle once serves every small file from memory instead.
+*
+* Why it does NOT go stale (the trap #729 fell into): the reader is memoized per
+* name for the isolate lifetime, but it never freezes content. Every call does a
+* cheap `stat` of the bundle to read its cid (a fresh path→cid index lookup, no
+* object read); the parsed map is memoized by that cid (immutable). An unchanged
+* bundle skips the re-read/re-parse; a re-publish yields a new cid and is picked
+* up on the very next request.
+*/
+function createBundleBackedReader(afs, root, fallback) {
+	const bundlePath = joinURL(root, BLOCKLET_BUNDLE_PATH);
+	let memoCid;
+	let memoReader;
+	async function currentBundle() {
+		const rc = getRequestScope();
+		const rcKey = `bundle-cid:${bundlePath}`;
+		let cid;
+		if (rc?.has(rcKey)) cid = rc.get(rcKey);
+		else {
+			try {
+				const meta = (await afs.stat(bundlePath, {
+					includeActions: "none",
+					noReadFallback: true
+				}))?.data?.meta;
+				cid = meta?.version ?? meta?.cid;
+			} catch {
+				cid = void 0;
+			}
+			rc?.set(rcKey, cid);
+		}
+		if (!cid) {
+			memoCid = void 0;
+			memoReader = void 0;
+			return;
+		}
+		if (cid === memoCid && memoReader) return memoReader;
+		try {
+			memoReader = createMapBlockletReader(JSON.parse(decodeAfsText((await afs.read(bundlePath, { includeActions: "none" }))?.data)));
+			memoCid = cid;
+			return memoReader;
+		} catch {
+			return;
+		}
+	}
+	const reader = {
+		async exists(relPath) {
+			const b = await currentBundle();
+			if (b && await b.exists(relPath)) return true;
+			return fallback.exists(relPath);
+		},
+		async readText(relPath) {
+			const b = await currentBundle();
+			if (b) {
+				const v = await b.readText(relPath);
+				if (v !== void 0) return v;
+			}
+			return fallback.readText(relPath);
+		},
+		async readBytes(relPath) {
+			const b = await currentBundle();
+			if (b) {
+				const v = await b.readBytes(relPath);
+				if (v !== void 0) return v;
+			}
+			return fallback.readBytes(relPath);
+		},
+		async hasDir(relDir) {
+			const b = await currentBundle();
+			if (b && await b.hasDir(relDir)) return true;
+			return fallback.hasDir(relDir);
+		},
+		async listDir(relDir) {
+			const b = await currentBundle();
+			const fromBundle = b ? await b.listDir(relDir) : [];
+			const fromFallback = await fallback.listDir(relDir);
+			return [...new Set([...fromBundle, ...fromFallback])];
+		}
+	};
+	if (fallback.listEntries) reader.listEntries = (relDir) => fallback.listEntries(relDir);
+	return reader;
+}
+/**
+* Create a runtime-agnostic DID-Space BlockletRegistry. Positive resolves are
+* cached per-instance; misses are NOT cached, so a newly published blocklet is
+* visible on the next lookup.
+*/
+function createDidSpaceBlockletRegistry(deps) {
+	const { resolver, openUserSpace } = deps;
+	const warn = deps.onWarn ?? (() => {});
+	const entryCache = /* @__PURE__ */ new Map();
+	async function lookup(name) {
+		const cached = entryCache.get(name);
+		if (cached !== void 0) return cached;
+		const rc = getRequestScope();
+		const rcKey = `blocklet-lookup:${name}`;
+		if (rc?.has(rcKey)) return rc.get(rcKey);
+		const result = await lookupUncached(name);
+		rc?.set(rcKey, result);
+		return result;
+	}
+	async function lookupUncached(name) {
+		if (resolver.resolveBlockletOrDomain) try {
+			const r = await resolver.resolveBlockletOrDomain(name);
+			if (!r) return null;
+			const result = r.source === "blocklet" ? {
+				owner: r.owner,
+				path: r.path ?? "",
+				canonicalName: name
+			} : {
+				owner: r.owner,
+				path: r.path ?? "",
+				canonicalName: normalizeId(r.did)
+			};
+			entryCache.set(name, result);
+			return result;
+		} catch (err) {
+			warn(`resolveBlockletOrDomain("${name}") failed: ${err instanceof Error ? err.message : err}`);
+			return null;
+		}
+		try {
+			const entry = await resolver.resolveBlocklet(name);
+			if (entry?.owner) {
+				const result = {
+					owner: entry.owner,
+					path: entry.path ?? "",
+					canonicalName: name
+				};
+				entryCache.set(name, result);
+				return result;
+			}
+		} catch (err) {
+			warn(`resolveBlocklet("${name}") failed: ${err instanceof Error ? err.message : err}`);
+			return null;
+		}
+		if (!resolver.resolveDomain) return null;
+		try {
+			const domainEntry = await resolver.resolveDomain(name);
+			if (!domainEntry?.owner) return null;
+			const result = {
+				owner: domainEntry.owner,
+				path: domainEntry.path ?? "",
+				canonicalName: normalizeId(domainEntry.did)
+			};
+			entryCache.set(name, result);
+			return result;
+		} catch (err) {
+			warn(`resolveDomain("${name}") failed: ${err instanceof Error ? err.message : err}`);
+			return null;
+		}
+	}
+	return {
+		source: "remote",
+		async list() {
+			try {
+				return (await resolver.listBlocklets()).map((b) => b.id);
+			} catch {
+				return [];
+			}
+		},
+		async resolveName(name) {
+			return (await lookup(name))?.canonicalName ?? null;
+		},
+		async reader(name) {
+			const entry = await lookup(name);
+			if (!entry) return null;
+			try {
+				const afs = await openUserSpace(entry.owner);
+				const root = joinURL("/", entry.path);
+				return createBundleBackedReader(afs, root, createAfsBlockletReader(afs, root));
+			} catch (err) {
+				warn(`reader("${name}") failed: ${err instanceof Error ? err.message : err}`);
+				return null;
+			}
+		},
+		async afsRoot(name) {
+			const entry = await lookup(name);
+			if (!entry) return null;
+			try {
+				return {
+					afs: await openUserSpace(entry.owner),
+					rootPath: joinURL("/", entry.path)
+				};
+			} catch (err) {
+				warn(`afsRoot("${name}") failed: ${err instanceof Error ? err.message : err}`);
+				return null;
+			}
+		}
+	};
+}
+/**
+* Combine a static-bundle registry with a fallback registry (e.g. DID Space).
+*
+* The static bundle always wins — the fallback is only tried when the static
+* registry returns null/empty. This preserves zero-regression for existing
+* built-in blocklets. Fully generic (composes two BlockletRegistry objects).
+*/
+function createCompositeBlockletRegistry(staticRegistry, fallbackRegistry) {
+	if (!fallbackRegistry) return staticRegistry;
+	return {
+		source: "remote",
+		async list() {
+			const [staticNames, fallbackNames] = await Promise.all([staticRegistry.list(), fallbackRegistry.list()]);
+			const seen = new Set(staticNames);
+			const merged = [...staticNames];
+			for (const name of fallbackNames) if (!seen.has(name)) merged.push(name);
+			return merged;
+		},
+		async resolveName(name) {
+			const staticResult = await staticRegistry.resolveName?.(name);
+			if (staticResult) return staticResult;
+			return fallbackRegistry.resolveName?.(name) ?? null;
+		},
+		async reader(name) {
+			const staticReader = await time("resolve.static", () => staticRegistry.reader(name));
+			if (staticReader) return staticReader;
+			return time("resolve.didspace", () => fallbackRegistry.reader(name));
+		},
+		async afsRoot(name) {
+			const staticRoot = await staticRegistry.afsRoot?.(name);
+			if (staticRoot) return staticRoot;
+			return await fallbackRegistry.afsRoot?.(name) ?? null;
+		}
+	};
+}
+
+//#endregion
+export { BLOCKLET_BUNDLE_PATH, createCompositeBlockletRegistry, createDidSpaceBlockletRegistry };
+//# sourceMappingURL=did-space-registry.mjs.map

package/dist/blocklet/did-space-registry.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"did-space-registry.mjs","names":[],"sources":["../../src/blocklet/did-space-registry.ts"],"sourcesContent":["/**\n * DID-Space-backed BlockletRegistry — runtime-agnostic engine (#674 v2).\n *\n * Resolves blocklets published to a DID Space via the global resolve table\n * (`resolve/blocklet/<id>` → { owner, path }, written by the did-space provider's\n * blocklet write-hook) and reads their files back through AFS. This lives in\n * @aigne/aos (NOT @aigne/afs-did-space) because it needs `createAfsBlockletReader`\n * + the Blocklet types, and aos already depends on did-space — the reverse\n * dependency would be a cycle. Both runtimes (Node + CF) depend on aos, so this\n * engine is shared: each runtime injects only the two things it does\n * differently — how to read the resolve table and how to open an owner's space.\n *\n * Lookup path:\n *   1. resolver.resolveBlocklet(name) → { owner, path }\n *   2. openUserSpace(owner)           → AFS rooted at the owner's whole space\n *   3. createAfsBlockletReader(afs, \"/\"+path) → file reader for the blocklet\n *\n * The engine is decoupled from any concrete class via two minimal structural\n * interfaces (BlockletResolveSource + the loose BlockletAfsReader): a\n * `DIDSpaceResolver` satisfies the former, a mounted `AFS` the latter.\n */\n\nimport { normalizeId } from \"@aigne/afs-did-space\";\nimport { getRequestScope } from \"@aigne/afs-logger\";\nimport { time } from \"@aigne/afs-timing\";\nimport { joinURL } from \"ufo\";\nimport {\n  type BlockletAfsReader,\n  type BlockletReader,\n  type BlockletRegistry,\n  createAfsBlockletReader,\n  createMapBlockletReader,\n} from \"./registry.js\";\n\n/**\n * Publish-time serve bundle for a DID-Space blocklet (#674 Phase 4): small text\n * files inlined so a cold serve reads one object instead of one-per-file. Sits\n * at the blocklet root as the matched partner of the `.blocklet-publish.json`\n * register marker (a distinct name — NOT http-mount's `.afs/bundle.json`, which\n * is a different mechanism / consumer).\n */\nexport const BLOCKLET_BUNDLE_PATH = \".blocklet-bundle.json\";\n\nconst BUNDLE_DECODER = new TextDecoder();\n\n/** Extract UTF-8 text from an AFS read result's `content` (string | bytes). */\nfunction decodeAfsText(raw: unknown): string {\n  const content = (raw as { content?: unknown } | null | undefined)?.content;\n  if (typeof content === \"string\") return content;\n  if (content instanceof Uint8Array) return BUNDLE_DECODER.decode(content);\n  if (content instanceof ArrayBuffer) return BUNDLE_DECODER.decode(new Uint8Array(content));\n  return \"\";\n}\n\n/**\n * A BlockletReader backed by a publish-time `.afs/bundle.json` (small text files\n * inlined at publish; see `shouldBundle`) layered over the live per-file AFS\n * reader — the fallback serves large/binary files (not bundled) and blocklets\n * that have no bundle.\n *\n * Why this exists: blocklet serve is one-file-per-request, so a cold isolate's\n * first page load of a many-file blocklet would otherwise do one object read per\n * file. Reading the bundle once serves every small file from memory instead.\n *\n * Why it does NOT go stale (the trap #729 fell into): the reader is memoized per\n * name for the isolate lifetime, but it never freezes content. Every call does a\n * cheap `stat` of the bundle to read its cid (a fresh path→cid index lookup, no\n * object read); the parsed map is memoized by that cid (immutable). An unchanged\n * bundle skips the re-read/re-parse; a re-publish yields a new cid and is picked\n * up on the very next request.\n */\nfunction createBundleBackedReader(\n  afs: BlockletAfsReader,\n  root: string,\n  fallback: BlockletReader,\n): BlockletReader {\n  const bundlePath = joinURL(root, BLOCKLET_BUNDLE_PATH);\n  let memoCid: string | undefined;\n  let memoReader: BlockletReader | undefined;\n\n  async function currentBundle(): Promise<BlockletReader | undefined> {\n    // The bundle cid is re-`stat`ed on every reader op so a re-publish is picked\n    // up (see doc above) — but within ONE request nothing can re-publish, and a\n    // no-bundle blocklet pays that miss `stat` (get + isDirectory probe = 2 D1)\n    // per op (detectBlockletPattern.exists + loadManifest.readText + …). Memo the\n    // cid per REQUEST (issue #808 #5): zero staleness (cross-request stat still\n    // runs → freshness kept), just no intra-request repeats.\n    const rc = getRequestScope();\n    const rcKey = `bundle-cid:${bundlePath}`;\n    let cid: string | undefined;\n    if (rc?.has(rcKey)) {\n      cid = rc.get(rcKey) as string | undefined;\n    } else {\n      try {\n        // noReadFallback: a bundle-less blocklet's stat miss must NOT trigger the\n        // core's read() double-check — it would only miss again (issue #808,\n        // halves the cold D1 on a DID-space serve without a bundle).\n        const meta = (await afs.stat(bundlePath, { includeActions: \"none\", noReadFallback: true }))\n          ?.data?.meta as { version?: string; cid?: string } | undefined;\n        cid = meta?.version ?? meta?.cid;\n      } catch {\n        cid = undefined;\n      }\n      rc?.set(rcKey, cid);\n    }\n    if (!cid) {\n      memoCid = undefined;\n      memoReader = undefined;\n      return undefined; // no bundle → per-file fallback\n    }\n    if (cid === memoCid && memoReader) return memoReader;\n    try {\n      const files = JSON.parse(\n        decodeAfsText((await afs.read(bundlePath, { includeActions: \"none\" }))?.data),\n      ) as Record<string, string>;\n      memoReader = createMapBlockletReader(files);\n      memoCid = cid;\n      return memoReader;\n    } catch {\n      return undefined; // unreadable/corrupt bundle → per-file fallback\n    }\n  }\n\n  const reader: BlockletReader = {\n    async exists(relPath) {\n      const b = await currentBundle();\n      if (b && (await b.exists(relPath))) return true;\n      return fallback.exists(relPath);\n    },\n    async readText(relPath) {\n      const b = await currentBundle();\n      if (b) {\n        const v = await b.readText(relPath);\n        if (v !== undefined) return v;\n      }\n      return fallback.readText(relPath);\n    },\n    async readBytes(relPath) {\n      const b = await currentBundle();\n      if (b) {\n        const v = await b.readBytes(relPath);\n        if (v !== undefined) return v;\n      }\n      return fallback.readBytes(relPath);\n    },\n    async hasDir(relDir) {\n      const b = await currentBundle();\n      if (b && (await b.hasDir(relDir))) return true;\n      return fallback.hasDir(relDir);\n    },\n    async listDir(relDir) {\n      const b = await currentBundle();\n      const fromBundle = b ? await b.listDir(relDir) : [];\n      const fromFallback = await fallback.listDir(relDir);\n      return [...new Set([...fromBundle, ...fromFallback])];\n    },\n  };\n\n  // `detectBlockletPattern` needs each root entry's name + kind (metadata), NOT\n  // file CONTENT — and one `afs.list` of the root is complete for large + small\n  // files alike. So forward `listEntries` straight to the inner AFS reader,\n  // bypassing the bundle entirely: this avoids BOTH the bundle stat/read AND the\n  // per-file MISS stats `exists`/`hasDir` fall back to (a bundle-less blocklet\n  // like arcblock paid 4 serial cold stats here — issue #808 `resolve.pattern`).\n  // Only exposed when the inner reader supports it, so detectBlockletPattern's\n  // sequential fallback still fires for readers that don't.\n  if (fallback.listEntries) {\n    reader.listEntries = (relDir) => fallback.listEntries!(relDir);\n  }\n  return reader;\n}\n\n/**\n * Minimal resolve-table surface the engine needs. `DIDSpaceResolver`\n * (@aigne/afs-did-space) satisfies this structurally — typed here so aos doesn't\n * import the concrete class just for two methods.\n *\n * `resolveDomain` is OPTIONAL (#764 Phase 4b): a custom-domain fallback for\n * `lookup()` when the id-keyed `resolveBlocklet` misses. Optional so any other\n * structural implementer of this interface (e.g. a test fake, or a future\n * resolve-table backend that never grew domain support) degrades gracefully —\n * `lookup()` just skips straight to \"not found\" instead of throwing.\n */\nexport interface BlockletResolveSource {\n  resolveBlocklet(id: string): Promise<{ owner?: string; path?: string } | null>;\n  listBlocklets(): Promise<Array<{ id: string }>>;\n  resolveDomain?(domain: string): Promise<{ did: string; owner: string; path: string } | null>;\n  /**\n   * Optional batched host resolution (issue #808): one backend round trip for\n   * BOTH the `resolve/blocklet/<name>` and `resolve/domain/<name>` lookups the\n   * sequential `resolveBlocklet` → `resolveDomain` ladder below performs. Blocklet\n   * wins (id key), same priority. Preferred when present; absent → the ladder\n   * runs (any structural implementer without it still works). `DIDSpaceResolver`\n   * satisfies it structurally on both the D1 (CF) and SQLite (Node) stores.\n   */\n  resolveBlockletOrDomain?(\n    name: string,\n  ): Promise<\n    | { source: \"blocklet\"; owner: string; path: string }\n    | { source: \"domain\"; owner: string; path: string; did: string }\n    | null\n  >;\n}\n\nexport interface DidSpaceBlockletRegistryDeps {\n  /** Global DID Space resolve table (resolve/blocklet/<id> → {owner, path}). */\n  resolver: BlockletResolveSource;\n  /**\n   * Open the whole user-space AFS for a publisher's PLAINTEXT owner DID. The\n   * runtime constructs the backend (CloudflareDIDSpace / local) and may cache it.\n   */\n  openUserSpace: (ownerDid: string) => Promise<BlockletAfsReader> | BlockletAfsReader;\n  /** Optional sink for non-fatal failures (resolve/read errors are swallowed). */\n  onWarn?: (message: string) => void;\n}\n\n/**\n * Create a runtime-agnostic DID-Space BlockletRegistry. Positive resolves are\n * cached per-instance; misses are NOT cached, so a newly published blocklet is\n * visible on the next lookup.\n */\nexport function createDidSpaceBlockletRegistry(\n  deps: DidSpaceBlockletRegistryDeps,\n): BlockletRegistry {\n  const { resolver, openUserSpace } = deps;\n  const warn = deps.onWarn ?? (() => {});\n  const entryCache = new Map<string, { owner: string; path: string; canonicalName: string }>();\n\n  /**\n   * Resolve `name` to `{owner, path}` — id-keyed first, then (#764 Phase 4b)\n   * a custom-domain fallback. `canonicalName` is the blocklet's actual id: on\n   * an id-keyed hit that's `name` itself; on a domain-keyed hit it's derived\n   * from the domain entry's `did` (`normalizeId` strips the `did:blocklet:`\n   * prefix — same normalization `resolveInstanceId` uses, see design.md). This\n   * matters because `resolveName`'s result is treated everywhere downstream as\n   * \"the canonical blocklet name\" (routes, AUP render, logging, tenant\n   * partitioning) — returning the raw domain string instead would make the\n   * same blocklet disagree with itself depending on which host reached it.\n   */\n  type LookupResult = { owner: string; path: string; canonicalName: string } | null;\n\n  async function lookup(name: string): Promise<LookupResult> {\n    const cached = entryCache.get(name);\n    if (cached !== undefined) return cached;\n    // Per-request memo INCLUDING negatives (issue #808 #2): a host that isn't a\n    // blocklet id gets looked up repeatedly in one request — patternCache\n    // resolveName + reader each call lookup(), and the domain router resolves\n    // host-context more than once — every miss re-hitting `resolve/blocklet` +\n    // `resolve/domain` D1. An isolate-level negative cache would break \"a newly\n    // published blocklet is visible on the next lookup\" (positives stay on\n    // `entryCache`, misses are NOT cached there); scoping the miss to the\n    // request is zero-staleness. Outside a request scope (CLI/tests) → no memo.\n    const rc = getRequestScope();\n    const rcKey = `blocklet-lookup:${name}`;\n    if (rc?.has(rcKey)) return rc.get(rcKey) as LookupResult;\n    const result = await lookupUncached(name);\n    rc?.set(rcKey, result);\n    return result;\n  }\n\n  async function lookupUncached(name: string): Promise<LookupResult> {\n    // Preferred: one round trip for both keys (issue #808 serve batching). Same\n    // blocklet-wins priority as the sequential ladder — just one query.\n    if (resolver.resolveBlockletOrDomain) {\n      try {\n        const r = await resolver.resolveBlockletOrDomain(name);\n        if (!r) return null;\n        const result =\n          r.source === \"blocklet\"\n            ? { owner: r.owner, path: r.path ?? \"\", canonicalName: name }\n            : { owner: r.owner, path: r.path ?? \"\", canonicalName: normalizeId(r.did) };\n        entryCache.set(name, result);\n        return result;\n      } catch (err) {\n        warn(\n          `resolveBlockletOrDomain(\"${name}\") failed: ${err instanceof Error ? err.message : err}`,\n        );\n        return null;\n      }\n    }\n    // Fallback ladder for resolvers without the batched method.\n    try {\n      const entry = await resolver.resolveBlocklet(name);\n      if (entry?.owner) {\n        const result = { owner: entry.owner, path: entry.path ?? \"\", canonicalName: name };\n        entryCache.set(name, result);\n        return result;\n      }\n    } catch (err) {\n      warn(`resolveBlocklet(\"${name}\") failed: ${err instanceof Error ? err.message : err}`);\n      return null;\n    }\n    if (!resolver.resolveDomain) return null;\n    try {\n      const domainEntry = await resolver.resolveDomain(name);\n      if (!domainEntry?.owner) return null;\n      const result = {\n        owner: domainEntry.owner,\n        path: domainEntry.path ?? \"\",\n        canonicalName: normalizeId(domainEntry.did),\n      };\n      entryCache.set(name, result);\n      return result;\n    } catch (err) {\n      warn(`resolveDomain(\"${name}\") failed: ${err instanceof Error ? err.message : err}`);\n      return null;\n    }\n  }\n\n  return {\n    source: \"remote\",\n\n    async list(): Promise<string[]> {\n      try {\n        return (await resolver.listBlocklets()).map((b) => b.id);\n      } catch {\n        return [];\n      }\n    },\n\n    async resolveName(name: string): Promise<string | null> {\n      const entry = await lookup(name);\n      return entry?.canonicalName ?? null;\n    },\n\n    async reader(name: string): Promise<BlockletReader | null> {\n      const entry = await lookup(name);\n      if (!entry) return null;\n      try {\n        const afs = await openUserSpace(entry.owner);\n        // `entry.path` is the scope-absolute tree path captured at publish time\n        // (no leading slash); root the reader at `/<path>` in the owner's space.\n        // Bundle-backed reader: serve small files from the publish-time\n        // `.afs/bundle.json` (one object read warms them all) with a per-file AFS\n        // fallback for large/binary files. It stays fresh by re-checking the\n        // bundle's cid on each call, so no staleness (unlike the retired #729\n        // path-keyed cache). Raw byte reuse below it is handled by the provider's\n        // content-addressed (cid-keyed) cache — immutable, so never stale.\n        const root = joinURL(\"/\", entry.path);\n        return createBundleBackedReader(afs, root, createAfsBlockletReader(afs, root));\n      } catch (err) {\n        warn(`reader(\"${name}\") failed: ${err instanceof Error ? err.message : err}`);\n        return null;\n      }\n    },\n\n    async afsRoot(name: string): Promise<{ afs: BlockletAfsReader; rootPath: string } | null> {\n      const entry = await lookup(name);\n      if (!entry) return null;\n      try {\n        const afs = await openUserSpace(entry.owner);\n        return { afs, rootPath: joinURL(\"/\", entry.path) };\n      } catch (err) {\n        warn(`afsRoot(\"${name}\") failed: ${err instanceof Error ? err.message : err}`);\n        return null;\n      }\n    },\n  };\n}\n\n/**\n * Combine a static-bundle registry with a fallback registry (e.g. DID Space).\n *\n * The static bundle always wins — the fallback is only tried when the static\n * registry returns null/empty. This preserves zero-regression for existing\n * built-in blocklets. Fully generic (composes two BlockletRegistry objects).\n */\nexport function createCompositeBlockletRegistry(\n  staticRegistry: BlockletRegistry,\n  fallbackRegistry: BlockletRegistry | null,\n): BlockletRegistry {\n  if (!fallbackRegistry) return staticRegistry;\n\n  return {\n    source: \"remote\",\n\n    async list(): Promise<string[]> {\n      const [staticNames, fallbackNames] = await Promise.all([\n        staticRegistry.list(),\n        fallbackRegistry.list(),\n      ]);\n      const seen = new Set(staticNames);\n      const merged = [...staticNames];\n      for (const name of fallbackNames) {\n        if (!seen.has(name)) merged.push(name);\n      }\n      return merged;\n    },\n\n    async resolveName(name: string): Promise<string | null> {\n      const staticResult = await staticRegistry.resolveName?.(name);\n      if (staticResult) return staticResult;\n      return fallbackRegistry.resolveName?.(name) ?? null;\n    },\n\n    async reader(name: string): Promise<BlockletReader | null> {\n      // Split cold-start attribution: `resolve.static` is the /registry-store\n      // probe (a MISS for a DID-Space-published blocklet still pays the bundle\n      // fetch — issue #808), `resolve.didspace` is the D1 lookup that actually\n      // hits for those blocklets.\n      const staticReader = await time(\"resolve.static\", () => staticRegistry.reader(name));\n      if (staticReader) return staticReader;\n      return time(\"resolve.didspace\", () => fallbackRegistry.reader(name));\n    },\n\n    async afsRoot(name: string) {\n      const staticRoot = await staticRegistry.afsRoot?.(name);\n      if (staticRoot) return staticRoot;\n      return (await fallbackRegistry.afsRoot?.(name)) ?? null;\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,MAAa,uBAAuB;AAEpC,MAAM,iBAAiB,IAAI,aAAa;;AAGxC,SAAS,cAAc,KAAsB;CAC3C,MAAM,UAAW,KAAkD;AACnE,KAAI,OAAO,YAAY,SAAU,QAAO;AACxC,KAAI,mBAAmB,WAAY,QAAO,eAAe,OAAO,QAAQ;AACxE,KAAI,mBAAmB,YAAa,QAAO,eAAe,OAAO,IAAI,WAAW,QAAQ,CAAC;AACzF,QAAO;;;;;;;;;;;;;;;;;;;AAoBT,SAAS,yBACP,KACA,MACA,UACgB;CAChB,MAAM,aAAa,QAAQ,MAAM,qBAAqB;CACtD,IAAI;CACJ,IAAI;CAEJ,eAAe,gBAAqD;EAOlE,MAAM,KAAK,iBAAiB;EAC5B,MAAM,QAAQ,cAAc;EAC5B,IAAI;AACJ,MAAI,IAAI,IAAI,MAAM,CAChB,OAAM,GAAG,IAAI,MAAM;OACd;AACL,OAAI;IAIF,MAAM,QAAQ,MAAM,IAAI,KAAK,YAAY;KAAE,gBAAgB;KAAQ,gBAAgB;KAAM,CAAC,GACtF,MAAM;AACV,UAAM,MAAM,WAAW,MAAM;WACvB;AACN,UAAM;;AAER,OAAI,IAAI,OAAO,IAAI;;AAErB,MAAI,CAAC,KAAK;AACR,aAAU;AACV,gBAAa;AACb;;AAEF,MAAI,QAAQ,WAAW,WAAY,QAAO;AAC1C,MAAI;AAIF,gBAAa,wBAHC,KAAK,MACjB,eAAe,MAAM,IAAI,KAAK,YAAY,EAAE,gBAAgB,QAAQ,CAAC,GAAG,KAAK,CAC9E,CAC0C;AAC3C,aAAU;AACV,UAAO;UACD;AACN;;;CAIJ,MAAM,SAAyB;EAC7B,MAAM,OAAO,SAAS;GACpB,MAAM,IAAI,MAAM,eAAe;AAC/B,OAAI,KAAM,MAAM,EAAE,OAAO,QAAQ,CAAG,QAAO;AAC3C,UAAO,SAAS,OAAO,QAAQ;;EAEjC,MAAM,SAAS,SAAS;GACtB,MAAM,IAAI,MAAM,eAAe;AAC/B,OAAI,GAAG;IACL,MAAM,IAAI,MAAM,EAAE,SAAS,QAAQ;AACnC,QAAI,MAAM,OAAW,QAAO;;AAE9B,UAAO,SAAS,SAAS,QAAQ;;EAEnC,MAAM,UAAU,SAAS;GACvB,MAAM,IAAI,MAAM,eAAe;AAC/B,OAAI,GAAG;IACL,MAAM,IAAI,MAAM,EAAE,UAAU,QAAQ;AACpC,QAAI,MAAM,OAAW,QAAO;;AAE9B,UAAO,SAAS,UAAU,QAAQ;;EAEpC,MAAM,OAAO,QAAQ;GACnB,MAAM,IAAI,MAAM,eAAe;AAC/B,OAAI,KAAM,MAAM,EAAE,OAAO,OAAO,CAAG,QAAO;AAC1C,UAAO,SAAS,OAAO,OAAO;;EAEhC,MAAM,QAAQ,QAAQ;GACpB,MAAM,IAAI,MAAM,eAAe;GAC/B,MAAM,aAAa,IAAI,MAAM,EAAE,QAAQ,OAAO,GAAG,EAAE;GACnD,MAAM,eAAe,MAAM,SAAS,QAAQ,OAAO;AACnD,UAAO,CAAC,GAAG,IAAI,IAAI,CAAC,GAAG,YAAY,GAAG,aAAa,CAAC,CAAC;;EAExD;AAUD,KAAI,SAAS,YACX,QAAO,eAAe,WAAW,SAAS,YAAa,OAAO;AAEhE,QAAO;;;;;;;AAoDT,SAAgB,+BACd,MACkB;CAClB,MAAM,EAAE,UAAU,kBAAkB;CACpC,MAAM,OAAO,KAAK,iBAAiB;CACnC,MAAM,6BAAa,IAAI,KAAqE;CAe5F,eAAe,OAAO,MAAqC;EACzD,MAAM,SAAS,WAAW,IAAI,KAAK;AACnC,MAAI,WAAW,OAAW,QAAO;EASjC,MAAM,KAAK,iBAAiB;EAC5B,MAAM,QAAQ,mBAAmB;AACjC,MAAI,IAAI,IAAI,MAAM,CAAE,QAAO,GAAG,IAAI,MAAM;EACxC,MAAM,SAAS,MAAM,eAAe,KAAK;AACzC,MAAI,IAAI,OAAO,OAAO;AACtB,SAAO;;CAGT,eAAe,eAAe,MAAqC;AAGjE,MAAI,SAAS,wBACX,KAAI;GACF,MAAM,IAAI,MAAM,SAAS,wBAAwB,KAAK;AACtD,OAAI,CAAC,EAAG,QAAO;GACf,MAAM,SACJ,EAAE,WAAW,aACT;IAAE,OAAO,EAAE;IAAO,MAAM,EAAE,QAAQ;IAAI,eAAe;IAAM,GAC3D;IAAE,OAAO,EAAE;IAAO,MAAM,EAAE,QAAQ;IAAI,eAAe,YAAY,EAAE,IAAI;IAAE;AAC/E,cAAW,IAAI,MAAM,OAAO;AAC5B,UAAO;WACA,KAAK;AACZ,QACE,4BAA4B,KAAK,aAAa,eAAe,QAAQ,IAAI,UAAU,MACpF;AACD,UAAO;;AAIX,MAAI;GACF,MAAM,QAAQ,MAAM,SAAS,gBAAgB,KAAK;AAClD,OAAI,OAAO,OAAO;IAChB,MAAM,SAAS;KAAE,OAAO,MAAM;KAAO,MAAM,MAAM,QAAQ;KAAI,eAAe;KAAM;AAClF,eAAW,IAAI,MAAM,OAAO;AAC5B,WAAO;;WAEF,KAAK;AACZ,QAAK,oBAAoB,KAAK,aAAa,eAAe,QAAQ,IAAI,UAAU,MAAM;AACtF,UAAO;;AAET,MAAI,CAAC,SAAS,cAAe,QAAO;AACpC,MAAI;GACF,MAAM,cAAc,MAAM,SAAS,cAAc,KAAK;AACtD,OAAI,CAAC,aAAa,MAAO,QAAO;GAChC,MAAM,SAAS;IACb,OAAO,YAAY;IACnB,MAAM,YAAY,QAAQ;IAC1B,eAAe,YAAY,YAAY,IAAI;IAC5C;AACD,cAAW,IAAI,MAAM,OAAO;AAC5B,UAAO;WACA,KAAK;AACZ,QAAK,kBAAkB,KAAK,aAAa,eAAe,QAAQ,IAAI,UAAU,MAAM;AACpF,UAAO;;;AAIX,QAAO;EACL,QAAQ;EAER,MAAM,OAA0B;AAC9B,OAAI;AACF,YAAQ,MAAM,SAAS,eAAe,EAAE,KAAK,MAAM,EAAE,GAAG;WAClD;AACN,WAAO,EAAE;;;EAIb,MAAM,YAAY,MAAsC;AAEtD,WADc,MAAM,OAAO,KAAK,GAClB,iBAAiB;;EAGjC,MAAM,OAAO,MAA8C;GACzD,MAAM,QAAQ,MAAM,OAAO,KAAK;AAChC,OAAI,CAAC,MAAO,QAAO;AACnB,OAAI;IACF,MAAM,MAAM,MAAM,cAAc,MAAM,MAAM;IAS5C,MAAM,OAAO,QAAQ,KAAK,MAAM,KAAK;AACrC,WAAO,yBAAyB,KAAK,MAAM,wBAAwB,KAAK,KAAK,CAAC;YACvE,KAAK;AACZ,SAAK,WAAW,KAAK,aAAa,eAAe,QAAQ,IAAI,UAAU,MAAM;AAC7E,WAAO;;;EAIX,MAAM,QAAQ,MAA4E;GACxF,MAAM,QAAQ,MAAM,OAAO,KAAK;AAChC,OAAI,CAAC,MAAO,QAAO;AACnB,OAAI;AAEF,WAAO;KAAE,KADG,MAAM,cAAc,MAAM,MAAM;KAC9B,UAAU,QAAQ,KAAK,MAAM,KAAK;KAAE;YAC3C,KAAK;AACZ,SAAK,YAAY,KAAK,aAAa,eAAe,QAAQ,IAAI,UAAU,MAAM;AAC9E,WAAO;;;EAGZ;;;;;;;;;AAUH,SAAgB,gCACd,gBACA,kBACkB;AAClB,KAAI,CAAC,iBAAkB,QAAO;AAE9B,QAAO;EACL,QAAQ;EAER,MAAM,OAA0B;GAC9B,MAAM,CAAC,aAAa,iBAAiB,MAAM,QAAQ,IAAI,CACrD,eAAe,MAAM,EACrB,iBAAiB,MAAM,CACxB,CAAC;GACF,MAAM,OAAO,IAAI,IAAI,YAAY;GACjC,MAAM,SAAS,CAAC,GAAG,YAAY;AAC/B,QAAK,MAAM,QAAQ,cACjB,KAAI,CAAC,KAAK,IAAI,KAAK,CAAE,QAAO,KAAK,KAAK;AAExC,UAAO;;EAGT,MAAM,YAAY,MAAsC;GACtD,MAAM,eAAe,MAAM,eAAe,cAAc,KAAK;AAC7D,OAAI,aAAc,QAAO;AACzB,UAAO,iBAAiB,cAAc,KAAK,IAAI;;EAGjD,MAAM,OAAO,MAA8C;GAKzD,MAAM,eAAe,MAAM,KAAK,wBAAwB,eAAe,OAAO,KAAK,CAAC;AACpF,OAAI,aAAc,QAAO;AACzB,UAAO,KAAK,0BAA0B,iBAAiB,OAAO,KAAK,CAAC;;EAGtE,MAAM,QAAQ,MAAc;GAC1B,MAAM,aAAa,MAAM,eAAe,UAAU,KAAK;AACvD,OAAI,WAAY,QAAO;AACvB,UAAQ,MAAM,iBAAiB,UAAU,KAAK,IAAK;;EAEtD"}

package/dist/blocklet/handlers.cjs

@@ -0,0 +1,66 @@
+
+//#region src/blocklet/handlers.ts
+function toSummary(activated) {
+	const { info, domains } = activated;
+	return {
+		id: info.id,
+		name: info.name,
+		description: info.manifest.description,
+		source: info.source,
+		mountPath: info.mountPath,
+		domains,
+		sites: info.manifest.sites?.map((s) => ({
+			name: s.name,
+			...s.domain && { domain: s.domain },
+			...s.port && { port: s.port }
+		}))
+	};
+}
+/**
+* Create a handler for `GET /.well-known/service/blocklets`.
+* Returns a JSON array of activated blocklets (sanitized — no credentials).
+*/
+function blockletListHandler(getActivated) {
+	return async (request) => {
+		if (request.method !== "GET") return new Response(JSON.stringify({ error: "Method Not Allowed" }), {
+			status: 405,
+			headers: { "Content-Type": "application/json" }
+		});
+		const list = getActivated().map(toSummary);
+		return new Response(JSON.stringify(list), {
+			status: 200,
+			headers: { "Content-Type": "application/json" }
+		});
+	};
+}
+/**
+* Create a handler for `GET /.well-known/service/blocklets/:id`.
+* Returns a single blocklet's details (sanitized).
+*/
+function blockletDetailHandler(getActivated) {
+	return async (request) => {
+		if (request.method !== "GET") return new Response(JSON.stringify({ error: "Method Not Allowed" }), {
+			status: 405,
+			headers: { "Content-Type": "application/json" }
+		});
+		const parts = new URL(request.url).pathname.split("/");
+		const blockletId = decodeURIComponent(parts[parts.length - 1] ?? "");
+		if (!blockletId) return new Response(JSON.stringify({ error: "Missing blocklet ID" }), {
+			status: 400,
+			headers: { "Content-Type": "application/json" }
+		});
+		const activated = getActivated().find((a) => a.info.id === blockletId || a.info.name === blockletId);
+		if (!activated) return new Response(JSON.stringify({ error: "Blocklet not found" }), {
+			status: 404,
+			headers: { "Content-Type": "application/json" }
+		});
+		return new Response(JSON.stringify(toSummary(activated)), {
+			status: 200,
+			headers: { "Content-Type": "application/json" }
+		});
+	};
+}
+
+//#endregion
+exports.blockletDetailHandler = blockletDetailHandler;
+exports.blockletListHandler = blockletListHandler;

package/dist/blocklet/handlers.d.cts

@@ -0,0 +1,16 @@
+import { ActivatedBlocklet } from "./types.cjs";
+
+//#region src/blocklet/handlers.d.ts
+/**
+ * Create a handler for `GET /.well-known/service/blocklets`.
+ * Returns a JSON array of activated blocklets (sanitized — no credentials).
+ */
+declare function blockletListHandler(getActivated: () => ActivatedBlocklet[]): (request: Request) => Promise<Response>;
+/**
+ * Create a handler for `GET /.well-known/service/blocklets/:id`.
+ * Returns a single blocklet's details (sanitized).
+ */
+declare function blockletDetailHandler(getActivated: () => ActivatedBlocklet[]): (request: Request) => Promise<Response>;
+//#endregion
+export { blockletDetailHandler, blockletListHandler };
+//# sourceMappingURL=handlers.d.cts.map

package/dist/blocklet/handlers.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlers.d.cts","names":[],"sources":["../../src/blocklet/handlers.ts"],"mappings":";;;;;;;iBAyCgB,mBAAA,CACd,YAAA,QAAoB,iBAAA,MAClB,OAAA,EAAS,OAAA,KAAY,OAAA,CAAQ,QAAA;;;;;iBAqBjB,qBAAA,CACd,YAAA,QAAoB,iBAAA,MAClB,OAAA,EAAS,OAAA,KAAY,OAAA,CAAQ,QAAA"}

package/dist/blocklet/handlers.d.mts

@@ -0,0 +1,16 @@
+import { ActivatedBlocklet } from "./types.mjs";
+
+//#region src/blocklet/handlers.d.ts
+/**
+ * Create a handler for `GET /.well-known/service/blocklets`.
+ * Returns a JSON array of activated blocklets (sanitized — no credentials).
+ */
+declare function blockletListHandler(getActivated: () => ActivatedBlocklet[]): (request: Request) => Promise<Response>;
+/**
+ * Create a handler for `GET /.well-known/service/blocklets/:id`.
+ * Returns a single blocklet's details (sanitized).
+ */
+declare function blockletDetailHandler(getActivated: () => ActivatedBlocklet[]): (request: Request) => Promise<Response>;
+//#endregion
+export { blockletDetailHandler, blockletListHandler };
+//# sourceMappingURL=handlers.d.mts.map

package/dist/blocklet/handlers.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlers.d.mts","names":[],"sources":["../../src/blocklet/handlers.ts"],"mappings":";;;;;;;iBAyCgB,mBAAA,CACd,YAAA,QAAoB,iBAAA,MAClB,OAAA,EAAS,OAAA,KAAY,OAAA,CAAQ,QAAA;;;;;iBAqBjB,qBAAA,CACd,YAAA,QAAoB,iBAAA,MAClB,OAAA,EAAS,OAAA,KAAY,OAAA,CAAQ,QAAA"}

package/dist/blocklet/handlers.mjs

@@ -0,0 +1,65 @@
+//#region src/blocklet/handlers.ts
+function toSummary(activated) {
+	const { info, domains } = activated;
+	return {
+		id: info.id,
+		name: info.name,
+		description: info.manifest.description,
+		source: info.source,
+		mountPath: info.mountPath,
+		domains,
+		sites: info.manifest.sites?.map((s) => ({
+			name: s.name,
+			...s.domain && { domain: s.domain },
+			...s.port && { port: s.port }
+		}))
+	};
+}
+/**
+* Create a handler for `GET /.well-known/service/blocklets`.
+* Returns a JSON array of activated blocklets (sanitized — no credentials).
+*/
+function blockletListHandler(getActivated) {
+	return async (request) => {
+		if (request.method !== "GET") return new Response(JSON.stringify({ error: "Method Not Allowed" }), {
+			status: 405,
+			headers: { "Content-Type": "application/json" }
+		});
+		const list = getActivated().map(toSummary);
+		return new Response(JSON.stringify(list), {
+			status: 200,
+			headers: { "Content-Type": "application/json" }
+		});
+	};
+}
+/**
+* Create a handler for `GET /.well-known/service/blocklets/:id`.
+* Returns a single blocklet's details (sanitized).
+*/
+function blockletDetailHandler(getActivated) {
+	return async (request) => {
+		if (request.method !== "GET") return new Response(JSON.stringify({ error: "Method Not Allowed" }), {
+			status: 405,
+			headers: { "Content-Type": "application/json" }
+		});
+		const parts = new URL(request.url).pathname.split("/");
+		const blockletId = decodeURIComponent(parts[parts.length - 1] ?? "");
+		if (!blockletId) return new Response(JSON.stringify({ error: "Missing blocklet ID" }), {
+			status: 400,
+			headers: { "Content-Type": "application/json" }
+		});
+		const activated = getActivated().find((a) => a.info.id === blockletId || a.info.name === blockletId);
+		if (!activated) return new Response(JSON.stringify({ error: "Blocklet not found" }), {
+			status: 404,
+			headers: { "Content-Type": "application/json" }
+		});
+		return new Response(JSON.stringify(toSummary(activated)), {
+			status: 200,
+			headers: { "Content-Type": "application/json" }
+		});
+	};
+}
+
+//#endregion
+export { blockletDetailHandler, blockletListHandler };
+//# sourceMappingURL=handlers.mjs.map

package/dist/blocklet/handlers.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlers.mjs","names":[],"sources":["../../src/blocklet/handlers.ts"],"sourcesContent":["/**\n * AOS Blocklet HTTP handlers — list/detail endpoints.\n *\n * Returns JSON responses with blocklet metadata.\n * Credential/secret fields are stripped from the response.\n */\n\nimport type { ActivatedBlocklet } from \"./types.js\";\n\n/** Sanitized blocklet info for HTTP response (no credentials/secrets). */\ninterface BlockletSummary {\n  id: string;\n  name: string;\n  description?: string;\n  source: \"local\" | \"embedded\" | \"remote\";\n  mountPath: string;\n  domains: string[];\n  sites?: Array<{ name: string; domain?: string; port?: number }>;\n}\n\nfunction toSummary(activated: ActivatedBlocklet): BlockletSummary {\n  const { info, domains } = activated;\n  return {\n    id: info.id,\n    name: info.name,\n    description: info.manifest.description,\n    source: info.source,\n    mountPath: info.mountPath,\n    domains,\n    sites: info.manifest.sites?.map((s) => ({\n      name: s.name,\n      ...(s.domain && { domain: s.domain }),\n      ...(s.port && { port: s.port }),\n    })),\n  };\n}\n\n/**\n * Create a handler for `GET /.well-known/service/blocklets`.\n * Returns a JSON array of activated blocklets (sanitized — no credentials).\n */\nexport function blockletListHandler(\n  getActivated: () => ActivatedBlocklet[],\n): (request: Request) => Promise<Response> {\n  return async (request: Request) => {\n    if (request.method !== \"GET\") {\n      return new Response(JSON.stringify({ error: \"Method Not Allowed\" }), {\n        status: 405,\n        headers: { \"Content-Type\": \"application/json\" },\n      });\n    }\n\n    const list = getActivated().map(toSummary);\n    return new Response(JSON.stringify(list), {\n      status: 200,\n      headers: { \"Content-Type\": \"application/json\" },\n    });\n  };\n}\n\n/**\n * Create a handler for `GET /.well-known/service/blocklets/:id`.\n * Returns a single blocklet's details (sanitized).\n */\nexport function blockletDetailHandler(\n  getActivated: () => ActivatedBlocklet[],\n): (request: Request) => Promise<Response> {\n  return async (request: Request) => {\n    if (request.method !== \"GET\") {\n      return new Response(JSON.stringify({ error: \"Method Not Allowed\" }), {\n        status: 405,\n        headers: { \"Content-Type\": \"application/json\" },\n      });\n    }\n\n    const url = new URL(request.url);\n    const parts = url.pathname.split(\"/\");\n    const blockletId = decodeURIComponent(parts[parts.length - 1] ?? \"\");\n    if (!blockletId) {\n      return new Response(JSON.stringify({ error: \"Missing blocklet ID\" }), {\n        status: 400,\n        headers: { \"Content-Type\": \"application/json\" },\n      });\n    }\n\n    const activated = getActivated().find(\n      (a) => a.info.id === blockletId || a.info.name === blockletId,\n    );\n    if (!activated) {\n      return new Response(JSON.stringify({ error: \"Blocklet not found\" }), {\n        status: 404,\n        headers: { \"Content-Type\": \"application/json\" },\n      });\n    }\n\n    return new Response(JSON.stringify(toSummary(activated)), {\n      status: 200,\n      headers: { \"Content-Type\": \"application/json\" },\n    });\n  };\n}\n"],"mappings":";AAoBA,SAAS,UAAU,WAA+C;CAChE,MAAM,EAAE,MAAM,YAAY;AAC1B,QAAO;EACL,IAAI,KAAK;EACT,MAAM,KAAK;EACX,aAAa,KAAK,SAAS;EAC3B,QAAQ,KAAK;EACb,WAAW,KAAK;EAChB;EACA,OAAO,KAAK,SAAS,OAAO,KAAK,OAAO;GACtC,MAAM,EAAE;GACR,GAAI,EAAE,UAAU,EAAE,QAAQ,EAAE,QAAQ;GACpC,GAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM;GAC/B,EAAE;EACJ;;;;;;AAOH,SAAgB,oBACd,cACyC;AACzC,QAAO,OAAO,YAAqB;AACjC,MAAI,QAAQ,WAAW,MACrB,QAAO,IAAI,SAAS,KAAK,UAAU,EAAE,OAAO,sBAAsB,CAAC,EAAE;GACnE,QAAQ;GACR,SAAS,EAAE,gBAAgB,oBAAoB;GAChD,CAAC;EAGJ,MAAM,OAAO,cAAc,CAAC,IAAI,UAAU;AAC1C,SAAO,IAAI,SAAS,KAAK,UAAU,KAAK,EAAE;GACxC,QAAQ;GACR,SAAS,EAAE,gBAAgB,oBAAoB;GAChD,CAAC;;;;;;;AAQN,SAAgB,sBACd,cACyC;AACzC,QAAO,OAAO,YAAqB;AACjC,MAAI,QAAQ,WAAW,MACrB,QAAO,IAAI,SAAS,KAAK,UAAU,EAAE,OAAO,sBAAsB,CAAC,EAAE;GACnE,QAAQ;GACR,SAAS,EAAE,gBAAgB,oBAAoB;GAChD,CAAC;EAIJ,MAAM,QADM,IAAI,IAAI,QAAQ,IAAI,CACd,SAAS,MAAM,IAAI;EACrC,MAAM,aAAa,mBAAmB,MAAM,MAAM,SAAS,MAAM,GAAG;AACpE,MAAI,CAAC,WACH,QAAO,IAAI,SAAS,KAAK,UAAU,EAAE,OAAO,uBAAuB,CAAC,EAAE;GACpE,QAAQ;GACR,SAAS,EAAE,gBAAgB,oBAAoB;GAChD,CAAC;EAGJ,MAAM,YAAY,cAAc,CAAC,MAC9B,MAAM,EAAE,KAAK,OAAO,cAAc,EAAE,KAAK,SAAS,WACpD;AACD,MAAI,CAAC,UACH,QAAO,IAAI,SAAS,KAAK,UAAU,EAAE,OAAO,sBAAsB,CAAC,EAAE;GACnE,QAAQ;GACR,SAAS,EAAE,gBAAgB,oBAAoB;GAChD,CAAC;AAGJ,SAAO,IAAI,SAAS,KAAK,UAAU,UAAU,UAAU,CAAC,EAAE;GACxD,QAAQ;GACR,SAAS,EAAE,gBAAgB,oBAAoB;GAChD,CAAC"}

package/dist/blocklet/index.d.mts

@@ -0,0 +1,7 @@
+import { ActivatedBlocklet, ActivationHooks, BlockletCredentialStore, BlockletInfo, BlockletLoader, TriggerSpec } from "./types.mjs";
+import { ActivateBlockletOptions, activateBlocklet, deactivateBlocklet } from "./activation.mjs";
+import { AfsBlockletRegistryOptions, BlockletAfsReader, BlockletPattern, BlockletPatternCache, BlockletPatternKind, BlockletReader, BlockletRegistry, TERMINAL_INDEX_FILES, createAfsBlockletReader, createAfsBlockletRegistry, createMapBlockletReader, createPatternCache, createStaticBlockletRegistry, detectBlockletPattern, normalizeRel } from "./registry.mjs";
+import { BLOCKLET_BUNDLE_PATH, BlockletResolveSource, DidSpaceBlockletRegistryDeps, createCompositeBlockletRegistry, createDidSpaceBlockletRegistry } from "./did-space-registry.mjs";
+import { blockletDetailHandler, blockletListHandler } from "./handlers.mjs";
+import { BlockletManifest, parseBlockletManifest } from "./manifest.mjs";
+import { StaticRenderResult, guessContentType, isConventionalAssetPath, renderStaticBlocklet, serveBlockletAsset } from "./static-render.mjs";

package/dist/blocklet/manifest.d.cts

@@ -0,0 +1,2 @@
+import { BlockletManifest as BlockletManifest$1, parseBlockletManifest } from "@aigne/afs";
+export { type BlockletManifest$1 as BlockletManifest, parseBlockletManifest };

package/dist/blocklet/manifest.d.mts

@@ -0,0 +1,2 @@
+import { BlockletManifest as BlockletManifest$1, parseBlockletManifest as parseBlockletManifest$1 } from "@aigne/afs";
+export { type BlockletManifest$1 as BlockletManifest, parseBlockletManifest$1 as parseBlockletManifest };

package/dist/blocklet/manifest.mjs

@@ -0,0 +1,3 @@
+import { parseBlockletManifest as parseBlockletManifest$1 } from "@aigne/afs";
+
+export { parseBlockletManifest$1 as parseBlockletManifest };