@aigne/afs-ocap 1.12.0-beta.5

package/dist/provider.mjs

@@ -0,0 +1,2490 @@
+import { getTxColor, getTxGroup } from "./method-colors.mjs";
+import { OcapRemoteSource } from "./remote-source.mjs";
+import { COLLECTION_TO_TYPES, TOP_LEVEL_DIRS, TYPE_TO_COLLECTION, buildDirEntry, buildListResult, collectionKind, displayMoniker, extractAssetFilters, extractBridgeFilters, extractDelegationFilters, extractFactoryFilters, extractStakeFilters, extractTokenFilters, extractTxFilters, formatBignumValue, formatBridgeStatusColor, formatBridgeStatusLabel, formatIntegerOrSentinel, formatTxTypeName, listOpts, resolveDidRole, resolveDidRoleLabel, resolveTxParties, toPaging, toStakeAddress, txStatusIntent } from "./utils.mjs";
+import { __decorate } from "./_virtual/_@oxc-project_runtime@0.108.0/helpers/decorate.mjs";
+import { AFSNotFoundError, AFS_EVENT_TYPES } from "@aigne/afs";
+import { AFSBaseProvider, Explain, List, Meta, Read, Search, Stat } from "@aigne/afs/provider";
+import { joinURL } from "ufo";
+import { z } from "zod";
+
+//#region src/provider.ts
+/**
+* Build the `content` payload for a token detail entry. Centralizes three
+* pieces of derivation that the AUP page consumes:
+*
+*   1. `genesisTime` / `renaissanceTime` — the chain wire delivers these
+*      in two shapes (top-level for some token types, nested under a
+*      `context` mixin for others). We normalize to top-level here so
+*      the recipe can bind one stable path; this is a multi-source
+*      fallback, NOT a workaround for AUP nesting limits (AUP binds
+*      arbitrary `a.b.c` paths via `_surfaceBindField`). Stake / delegate
+*      detail handlers don't need this because their wire shape is
+*      consistent.
+*   2. `metadata.value` — issuer-supplied free-form info, sent as a JSON
+*      string. Parsed into `_issuerName` (display name) and `_communityUrl`
+*      so the page doesn't have to JSON-parse on the client.
+*   3. `_typeLabel` — humanized rendering of `state.type`. The chain stores
+*      `Token` / `BondingCurveToken` / `CreditToken`; users want
+*      "Standard / Bonding Curve / Credit Token". Falls back to deriving
+*      from `tokenFactoryAddress` when the type field is empty (older
+*      tokens minted before the type discriminator existed).
+*
+* Pure function — kept at module scope so the unit tests can exercise the
+* derivation without spinning up a provider.
+*/
+function enrichTokenContent(state) {
+	const ctxBlock = state.context;
+	let metadataValue;
+	const rawMeta = state.metadata?.value;
+	if (typeof rawMeta === "string") try {
+		const parsed = JSON.parse(rawMeta);
+		if (parsed && typeof parsed === "object") metadataValue = parsed;
+	} catch {}
+	else if (rawMeta && typeof rawMeta === "object") metadataValue = rawMeta;
+	const issuerName = typeof metadataValue?.issuer === "string" ? metadataValue.issuer : void 0;
+	const communityUrl = typeof metadataValue?.communityUrl === "string" ? metadataValue.communityUrl : void 0;
+	const typeLabel = (() => {
+		switch (state.type) {
+			case "CreditToken": return "Credit Token";
+			case "BondingCurveToken": return "Bonding Curve Token";
+			case "Token": return "Standard Token";
+			default: return state.tokenFactoryAddress ? "Bonding Curve Token" : "Standard Token";
+		}
+	})();
+	return {
+		...state,
+		genesisTime: state.genesisTime ?? ctxBlock?.genesisTime,
+		renaissanceTime: state.renaissanceTime ?? ctxBlock?.renaissanceTime,
+		_issuerName: issuerName,
+		_communityUrl: communityUrl,
+		_typeLabel: typeLabel
+	};
+}
+/**
+* Build the `_nftDisplay` payload that the AUP `nft-display` renderer
+* binds to. The chain stores the rendering hint as `display.{type,
+* content}`; for `type === "url"` we pre-attach the asset's `assetId`
+* (and `vcId` when present) so the renderer doesn't have to know about
+* the URL convention. Other types (uri / svg / svg_gzipped) need no
+* URL preprocessing — the renderer dispatches on `type` and consumes
+* `content` directly.
+*
+* Returns `null` (rather than an empty object) when the chain doesn't
+* have a display descriptor — the AUP page binds `${content._nftDisplay}`
+* and renders a "no display" placeholder for null.
+*/
+function deriveNftDisplay(state) {
+	const d = state.display;
+	if (!d || !d.type || !d.content) return null;
+	const out = {
+		type: d.type,
+		content: d.content
+	};
+	if (d.vcId) out.vcId = d.vcId;
+	if (d.type === "url") try {
+		const u = new URL(d.content);
+		if (!u.searchParams.has("assetId")) u.searchParams.set("assetId", state.address);
+		if (d.vcId && !u.searchParams.has("vcId")) u.searchParams.set("vcId", d.vcId);
+		out.resolvedUrl = u.href;
+	} catch {}
+	return out;
+}
+/**
+* Build per-tx-type label overrides for the "Type Info" card on the
+* transaction detail page. The card surfaces inner-tx subject fields
+* (`_itxAddress`, `_itxMoniker`, `_itxFactory`, `_itxRollup`,
+* `_itxBlockHash`, `_itxBlockHeight`) whose meaning is tx-type-specific —
+* "Address" alone is too vague when it could be a token, asset, factory,
+* stake, or account DID. Per-type labels make the row read clearly:
+* "Token DID" / "Asset DID" / "Rollup Block Hash" etc.
+*
+* Returns a flat object whose keys the AUP page binds via
+* `${content._typeContext.<key>}`. All keys carry a sensible fallback
+* (the same generic label the card used to ship with) so unknown tx
+* types still render without holes; the rest of the row's hide-when-
+* empty behavior keeps irrelevant rows out of the DOM regardless of
+* label content.
+*/
+function deriveTypeContext(rawType) {
+	const t = (rawType || "").toLowerCase();
+	const out = {
+		addressLabel: "Address",
+		addressPath: "accounts/{value}",
+		monikerLabel: "Moniker",
+		factoryLabel: "Factory",
+		rollupLabel: "Bridge",
+		blockHashLabel: "Block Hash",
+		blockHeightLabel: "Block Height"
+	};
+	switch (t) {
+		case "create_token":
+		case "createtoken": return {
+			...out,
+			addressLabel: "Token DID",
+			addressPath: "tokens/{value}",
+			monikerLabel: "Token Name",
+			factoryLabel: "Token Factory"
+		};
+		case "create_token_factory":
+		case "createtokenfactory":
+		case "update_token_factory":
+		case "updatetokenfactory": return {
+			...out,
+			addressLabel: "Token Factory DID",
+			addressPath: "factories/{value}",
+			monikerLabel: "Token Factory Name"
+		};
+		case "mint_token":
+		case "minttoken":
+		case "burn_token":
+		case "burntoken":
+		case "deposit_token_v2":
+		case "deposittokenv2":
+		case "withdraw_token_v2":
+		case "withdrawtokenv2": return {
+			...out,
+			factoryLabel: "Token Factory"
+		};
+		case "create_factory":
+		case "createfactory": return {
+			...out,
+			addressLabel: "NFT Factory DID",
+			addressPath: "factories/{value}",
+			monikerLabel: "NFT Factory Name"
+		};
+		case "create_asset":
+		case "createasset":
+		case "mint_asset":
+		case "mintasset":
+		case "update_asset":
+		case "updateasset":
+		case "consume_asset":
+		case "consumeasset":
+		case "acquire_asset_v2":
+		case "acquireassetv2":
+		case "acquire_asset_v3":
+		case "acquireassetv3": return {
+			...out,
+			addressLabel: "Asset DID",
+			addressPath: "assets/{value}",
+			monikerLabel: "Asset Name",
+			factoryLabel: "NFT Factory"
+		};
+		case "stake":
+		case "revoke_stake":
+		case "revokestake":
+		case "claim_stake":
+		case "claimstake":
+		case "slash_stake":
+		case "slashstake":
+		case "return_stake":
+		case "returnstake": return {
+			...out,
+			addressLabel: "Stake DID",
+			addressPath: "stakes/{value}"
+		};
+		case "create_rollup":
+		case "createrollup":
+		case "update_rollup":
+		case "updaterollup":
+		case "join_rollup":
+		case "joinrollup":
+		case "leave_rollup":
+		case "leaverollup":
+		case "pause_rollup":
+		case "pauserollup":
+		case "resume_rollup":
+		case "resumerollup":
+		case "close_rollup":
+		case "closerollup":
+		case "migrate_rollup":
+		case "migraterollup":
+		case "migrate_rollup_contract":
+		case "migraterollupcontract":
+		case "migrate_rollup_token":
+		case "migraterolluptoken": return {
+			...out,
+			rollupLabel: "Bridge Address"
+		};
+		case "create_rollup_block":
+		case "createrollupblock":
+		case "claim_block_reward":
+		case "claimblockreward": return {
+			...out,
+			rollupLabel: "Bridge Address",
+			blockHashLabel: "Bridge Block Hash",
+			blockHeightLabel: "Bridge Block Height"
+		};
+		case "declare":
+		case "account_migrate":
+		case "accountmigrate":
+		case "delegate":
+		case "revoke_delegate":
+		case "revokedelegate": return {
+			...out,
+			addressLabel: "Account DID"
+		};
+		default: return out;
+	}
+}
+var AFSOCAP = class AFSOCAP extends AFSBaseProvider {
+	static schema() {
+		return z.object({
+			endpoint: z.string().describe("OCAP endpoint URL"),
+			name: z.string().optional().describe("Provider name"),
+			description: z.string().optional().describe("Provider description"),
+			accessMode: z.enum(["readonly", "readwrite"]).optional().describe("Access mode"),
+			pageSize: z.number().optional().describe("Default page size")
+		});
+	}
+	static manifest() {
+		return {
+			name: "ocap",
+			description: "OCAP blockchain — browse transactions, accounts, tokens, factories, and more.\n- Read-only access to blockchain state\n- Path structure: `/transactions/{hash}`, `/accounts/{address}`, `/tokens/{address}`",
+			uriTemplate: "ocap://{endpoint+}",
+			category: "blockchain",
+			schema: z.object({ endpoint: z.string() }),
+			tags: [
+				"blockchain",
+				"ocap",
+				"arcblock"
+			],
+			capabilityTags: [
+				"read-only",
+				"search",
+				"auth:none",
+				"remote"
+			],
+			security: {
+				riskLevel: "sandboxed",
+				resourceAccess: []
+			},
+			capabilities: { filesystem: {
+				read: true,
+				write: false
+			} }
+		};
+	}
+	static treeSchema() {
+		return {
+			operations: [
+				"list",
+				"read",
+				"search",
+				"stat",
+				"explain"
+			],
+			tree: {
+				"/": { kind: "ocap:chain" },
+				"/transactions": { kind: "ocap:transaction" },
+				"/transactions/{hash}": { kind: "ocap:transaction" },
+				"/transactions/{hash}/receipts": { kind: "ocap:receipt" },
+				"/transactions/{hash}/receipts/{idx}": { kind: "ocap:receipt" },
+				"/accounts": { kind: "ocap:account" },
+				"/accounts/{address}": { kind: "ocap:account" },
+				"/accounts/{address}/tokens": { kind: "ocap:token" },
+				"/accounts/{address}/assets": { kind: "ocap:asset" },
+				"/accounts/{address}/stakes": { kind: "ocap:stake" },
+				"/accounts/{address}/stakes/sent": { kind: "ocap:stake" },
+				"/accounts/{address}/stakes/received": { kind: "ocap:stake" },
+				"/accounts/{address}/delegates": { kind: "ocap:delegate" },
+				"/accounts/{address}/transactions": { kind: "ocap:transaction" },
+				"/accounts/{address}/migration": { kind: "ocap:account:migration" },
+				"/accounts/{address}/token-flows": { kind: "ocap:token-flow" },
+				"/tokens": { kind: "ocap:token" },
+				"/tokens/{address}": { kind: "ocap:token" },
+				"/tokens/{address}/holders": { kind: "ocap:account" },
+				"/tokens/{address}/transactions": { kind: "ocap:transaction" },
+				"/factories": { kind: "ocap:factory" },
+				"/factories/{address}": { kind: "ocap:factory" },
+				"/factories/{address}/assets": { kind: "ocap:asset" },
+				"/factories/{address}/transactions": { kind: "ocap:transaction" },
+				"/assets": { kind: "ocap:asset" },
+				"/assets/{address}": { kind: "ocap:asset" },
+				"/assets/{address}/transactions": { kind: "ocap:transaction" },
+				"/assets/{address}/stakes": { kind: "ocap:stake" },
+				"/bridges": { kind: "ocap:bridge" },
+				"/bridges/{address}": { kind: "ocap:bridge" },
+				"/bridges/{address}/transactions": { kind: "ocap:transaction" },
+				"/bridges/{address}/deposits": { kind: "ocap:transaction" },
+				"/bridges/{address}/withdrawals": { kind: "ocap:transaction" },
+				"/bridges/{address}/governance": { kind: "ocap:transaction" },
+				"/bridges/{address}/slashes": { kind: "ocap:transaction" },
+				"/bridges/{address}/nodes": { kind: "ocap:rollup-node" },
+				"/bridges/{address}/stakes": { kind: "ocap:stake" },
+				"/bridges/{address}/blocks": { kind: "ocap:rollup-block" },
+				"/bridges/{address}/blocks/{hash}": { kind: "ocap:rollup-block" },
+				"/stakes": { kind: "ocap:stake" },
+				"/stakes/{address}": { kind: "ocap:stake" },
+				"/stakes/{address}/transactions": { kind: "ocap:transaction" },
+				"/stakes/{address}/tokens": { kind: "ocap:token" },
+				"/stakes/{address}/assets": { kind: "ocap:asset" },
+				"/delegates": { kind: "ocap:delegate" },
+				"/delegates/{address}": { kind: "ocap:delegate" },
+				"/delegates/{address}/transactions": { kind: "ocap:transaction" },
+				"/delegates/{address}/permissions": { kind: "ocap:delegate_permission" },
+				"/validators": { kind: "ocap:validator" },
+				"/validators/{address}": { kind: "ocap:validator" },
+				"/config": { kind: "ocap:config" }
+			},
+			auth: { type: "none" },
+			bestFor: [
+				"blockchain exploration",
+				"transaction analysis",
+				"account lookup"
+			],
+			notFor: ["write operations", "binary data"]
+		};
+	}
+	static async load({ config } = {}) {
+		return new AFSOCAP(AFSOCAP.schema().parse(config));
+	}
+	_name;
+	description;
+	accessMode;
+	get name() {
+		return this._name;
+	}
+	source;
+	defaultPageSize;
+	_nameResolved = false;
+	priceCache = /* @__PURE__ */ new Map();
+	static PRICE_TTL_MS = 6e4;
+	static PRICE_API = "https://token-data.arcblock.io/api/token-price-by-symbol?symbols=";
+	fetchImpl = (url) => fetch(url);
+	chainCache = /* @__PURE__ */ new Map();
+	static CHAIN_TTL_MS = 3e4;
+	nativeTokenPromise = null;
+	constructor(options) {
+		super();
+		if (options.source) this.source = options.source;
+		else if (options.endpoint) this.source = new OcapRemoteSource(options.endpoint);
+		else throw new Error("AFSOCAP requires either 'source' or 'endpoint' option");
+		this._name = options.name || "ocap";
+		this.description = options.description;
+		this.accessMode = options.accessMode ?? "readonly";
+		this.defaultPageSize = options.pageSize ?? 20;
+	}
+	/**
+	* Probed during onMount(); true when the underlying source exposes a
+	* working `subscribe(topic, cb)`. Read by `getOperationsDeclaration()`
+	* so capability discovery reflects runtime reality (worker bundles
+	* without `@arcblock/ws` advertise live:false even when the rest of
+	* the read API works fine).
+	*/
+	_liveCapable = false;
+	_unsubTxCreate = null;
+	onMount(_root, _mountPath) {
+		if (typeof this.source.subscribe !== "function") {
+			this._liveCapable = false;
+			return;
+		}
+		try {
+			this._unsubTxCreate = this.source.subscribe("tx.create", (payload) => {
+				this.handleTxCreatePayload(payload);
+			});
+			this._liveCapable = true;
+		} catch {
+			this._liveCapable = false;
+			this._unsubTxCreate = null;
+		}
+	}
+	onUnmount() {
+		if (this._unsubTxCreate) {
+			try {
+				this._unsubTxCreate();
+			} catch {}
+			this._unsubTxCreate = null;
+		}
+		this._liveCapable = false;
+	}
+	/**
+	* Bridge a phoenix `tx.create` payload onto the AFS event bus as an
+	* `afs:append /transactions/<hash>` event. Path traversal is impossible
+	* because the hash is bracketed with `joinURL` after validation; we drop
+	* the event entirely if the hash isn't a plain string.
+	*/
+	handleTxCreatePayload(payload) {
+		const p = payload;
+		if (!p || typeof p.hash !== "string" || p.hash.length === 0 || p.hash.includes("/")) return;
+		this.emit({
+			type: AFS_EVENT_TYPES.APPEND,
+			path: joinURL("/transactions", p.hash),
+			data: {
+				hash: p.hash,
+				type: typeof p.type === "string" ? p.type : void 0,
+				time: typeof p.time === "string" ? p.time : void 0,
+				sender: typeof p.sender === "string" ? p.sender : void 0,
+				receiver: typeof p.receiver === "string" ? p.receiver : void 0
+			}
+		});
+	}
+	getOperationsDeclaration() {
+		return {
+			...super.getOperationsDeclaration(),
+			subscribe: {
+				supported: true,
+				features: {
+					live: this._liveCapable,
+					eventTypes: "append,write",
+					maxRateHz: 100,
+					scope: "global"
+				}
+			}
+		};
+	}
+	async resolveNameOnce() {
+		if (this._nameResolved || this._name !== "ocap") return;
+		this._nameResolved = true;
+		const info = await this.memoize("getChainInfo", AFSOCAP.CHAIN_TTL_MS, () => this.source.getChainInfo());
+		if (info.moniker) this._name = info.moniker;
+	}
+	/**
+	* Memoize an async source call by `key` for `ttlMs`. Concurrent callers
+	* share the in-flight Promise; rejections evict the entry so the next
+	* call retries. Used by chain-level aggregate queries that are read by
+	* multiple handlers within the same homepage load.
+	*/
+	memoize(key, ttlMs, fn) {
+		const now = Date.now();
+		const cached = this.chainCache.get(key);
+		if (cached && cached.expiresAt > now) return cached.promise;
+		const promise = fn();
+		this.chainCache.set(key, {
+			promise,
+			expiresAt: now + ttlMs
+		});
+		promise.catch(() => {
+			if (this.chainCache.get(key)?.promise === promise) this.chainCache.delete(key);
+		});
+		return promise;
+	}
+	/**
+	* Resolve the chain's native gas/staking token (ABT on ArcBlock-family
+	* chains, with a fallback to the newest token when ABT isn't present —
+	* test chains, custom genesis). The result is cached for the lifetime of
+	* the provider; failures are not cached so the next caller retries.
+	*
+	* Returns `null` when no native token is discoverable (empty chain).
+	*/
+	resolveNativeToken() {
+		if (this.nativeTokenPromise) return this.nativeTokenPromise;
+		const promise = (async () => {
+			try {
+				const items = (await this.memoize("listTokens:size50", AFSOCAP.CHAIN_TTL_MS, () => this.source.listTokens({
+					size: 50,
+					offset: 0
+				})))?.items ?? [];
+				const native = items.find((t) => t.symbol === "ABT") ?? items[0];
+				if (!native?.address || !native.symbol) return null;
+				return {
+					symbol: native.symbol,
+					address: native.address
+				};
+			} catch {
+				return null;
+			}
+		})();
+		this.nativeTokenPromise = promise;
+		promise.then((result) => {
+			if (!result && this.nativeTokenPromise === promise) this.nativeTokenPromise = null;
+		});
+		return promise;
+	}
+	/**
+	* Symbol-keyed price fetch. Extracted from `readTokenPrice` so callers
+	* that already know the symbol (e.g. microbar after resolveNativeToken)
+	* can skip the `getTokenState` round-trip just to look up the symbol.
+	*
+	* Returns the normalized payload on success, a `{...stale, error}` object
+	* when fetch fails but a cache entry exists, or `null` when fetch fails
+	* with no cached fallback.
+	*/
+	async getPriceBySymbol(symbol) {
+		const cacheKey = symbol;
+		const now = Date.now();
+		const cached = this.priceCache.get(cacheKey);
+		if (cached && cached.expiresAt > now) return {
+			...cached.value,
+			fromCache: true
+		};
+		const url = `${AFSOCAP.PRICE_API}${encodeURIComponent(symbol)}`;
+		let payload = null;
+		let fetchError = null;
+		try {
+			const res = await this.fetchImpl(url);
+			if (!res.ok) fetchError = "price api returned !ok";
+			else payload = await res.json();
+		} catch (err) {
+			fetchError = err instanceof Error ? err.message : String(err);
+		}
+		if (payload) {
+			const value = this.normalizePricePayload(payload, symbol, now);
+			this.priceCache.set(cacheKey, {
+				value,
+				expiresAt: now + AFSOCAP.PRICE_TTL_MS
+			});
+			return value;
+		}
+		if (cached) return {
+			...cached.value,
+			stale: true,
+			error: fetchError ?? "fetch failed"
+		};
+		return null;
+	}
+	resolveNavPath(address) {
+		if (!address) return void 0;
+		const entityType = resolveDidRole(address);
+		if (!entityType) return void 0;
+		const collection = TYPE_TO_COLLECTION[entityType];
+		if (!collection) return void 0;
+		return joinURL("/", collection, address);
+	}
+	/**
+	* Phase 0.2 A.6 — Inject the request's account address as `_currentAccount`
+	* on every entry's content. Used by /accounts/:addr/{transactions,stakes/*,
+	* assets,token-flows} so the AUP `direction-pill` formatter can compute
+	* IN/OUT/SELF without each blocklet reaching for ctx.params.
+	*
+	* Trust boundary: the address comes from the route param (set by the AFS
+	* core router from the URL path), NOT from ctx.options (which is
+	* caller-controlled). The object spread ordering also guarantees a
+	* caller-supplied `content._currentAccount` cannot override us.
+	*/
+	withCurrentAccount(entries, currentAccount) {
+		if (!currentAccount) return entries;
+		return entries.map((e) => ({
+			...e,
+			content: {
+				...e.content ?? {},
+				_currentAccount: currentAccount
+			}
+		}));
+	}
+	/**
+	* Phase 0.6 polish — single source of truth for tx content enrichment.
+	*
+	* Both `buildTxEntries` (list path) and `readTransaction` (detail path)
+	* call this so columns and key-value-list rows that bind to the same
+	* keys (e.g. `_gasFeeRaw`) render identically. Detail-only fields like
+	* `_itxJson` / `_receiverPath` / `_prevHash` stay in `readTransaction`
+	* so the list payload doesn't grow with rendering metadata.
+	*/
+	enrichTxContent(tx, itxJson) {
+		const itx = tx.tx || {};
+		const itxInputs = itxJson.inputs;
+		const itxOutputs = itxJson.outputs;
+		const itxOutputOwner = itxOutputs?.[0]?.owner;
+		const itxTo = itxJson.to;
+		const token = itxJson.token;
+		const itxTokens = itxJson.tokens;
+		const tokenSymbols = tx.tokenSymbols;
+		const txReceipts = tx.receipts ?? [];
+		const isNoTokenValueTx = new Set([
+			"mint_asset",
+			"create_asset",
+			"update_asset",
+			"consume_asset",
+			"acquire_asset_v2",
+			"acquire_asset_v3",
+			"MintAsset",
+			"MintAssetTx",
+			"CreateAsset",
+			"CreateAssetTx",
+			"UpdateAsset",
+			"UpdateAssetTx",
+			"ConsumeAsset",
+			"ConsumeAssetTx",
+			"AcquireAssetV2",
+			"AcquireAssetV2Tx",
+			"AcquireAssetV3",
+			"AcquireAssetV3Tx"
+		]).has(tx.type || "");
+		const tokenInfoByAddr = /* @__PURE__ */ new Map();
+		for (const t of tokenSymbols ?? []) if (typeof t.address === "string" && typeof t.symbol === "string" && typeof t.decimal === "number") tokenInfoByAddr.set(t.address, {
+			symbol: t.symbol,
+			decimal: t.decimal
+		});
+		const firstTokenSymbol = (tokenSymbols ?? [])[0];
+		const fallbackTokenInfo = {
+			symbol: typeof firstTokenSymbol?.symbol === "string" ? firstTokenSymbol.symbol : "ABT",
+			decimal: typeof firstTokenSymbol?.decimal === "number" ? firstTokenSymbol.decimal : 18
+		};
+		const fallbackTokenAddr = (() => {
+			const first = tokenInfoByAddr.keys().next().value;
+			return typeof first === "string" ? first : "native";
+		})();
+		const legs = [];
+		function pushTokenLeg(target, value) {
+			if (typeof value !== "string" || value === "") return;
+			const addr = typeof target === "string" && target.length > 0 ? target : fallbackTokenAddr;
+			const info = tokenInfoByAddr.get(addr) ?? fallbackTokenInfo;
+			legs.push({
+				kind: "token",
+				target: addr,
+				symbol: info.symbol,
+				decimal: info.decimal,
+				value
+			});
+		}
+		const SUBJECT_RECEIPT_ACTIONS = new Set([
+			"mint",
+			"burn",
+			"stake",
+			"claim",
+			"fee",
+			"transfer",
+			"consume"
+		]);
+		const FEE_LIKE_RECEIPT_ACTIONS = new Set([
+			"gas",
+			"service-fee",
+			"service_fee"
+		]);
+		for (const r of txReceipts) for (const ch of r.changes ?? []) {
+			if (typeof ch.action !== "string") continue;
+			if (FEE_LIKE_RECEIPT_ACTIONS.has(ch.action)) continue;
+			if (!SUBJECT_RECEIPT_ACTIONS.has(ch.action)) continue;
+			if (typeof ch.value !== "string" || ch.value === "") continue;
+			const target = typeof ch.target === "string" ? ch.target : "";
+			if (!target && tokenInfoByAddr.size > 0) continue;
+			if (target && tokenInfoByAddr.has(target)) {
+				const info = tokenInfoByAddr.get(target);
+				legs.push({
+					kind: "token",
+					target,
+					symbol: info.symbol,
+					decimal: info.decimal,
+					value: ch.value
+				});
+			} else if (target && tokenInfoByAddr.size > 0) legs.push({
+				kind: "asset",
+				target
+			});
+			else legs.push({
+				kind: "token",
+				target: target || fallbackTokenAddr,
+				symbol: fallbackTokenInfo.symbol,
+				decimal: fallbackTokenInfo.decimal,
+				value: ch.value
+			});
+		}
+		if (legs.length === 0 && !isNoTokenValueTx) {
+			if (token && typeof token.value === "string") pushTokenLeg(token.address, token.value);
+			for (const t of itxTokens ?? []) pushTokenLeg(t.address, t.value);
+			const sideTotals = (side) => {
+				const totals = /* @__PURE__ */ new Map();
+				for (const entry of side ?? []) for (const t of entry.tokens ?? []) {
+					if (typeof t.value !== "string" || t.value === "") continue;
+					let v;
+					try {
+						v = BigInt(t.value);
+					} catch (_) {
+						continue;
+					}
+					const addr = typeof t.address === "string" && t.address.length > 0 ? t.address : fallbackTokenAddr;
+					totals.set(addr, (totals.get(addr) ?? BigInt(0)) + v);
+				}
+				return totals;
+			};
+			const inTotals = sideTotals(itxInputs);
+			const outTotals = sideTotals(itxOutputs);
+			for (const addr of new Set([...inTotals.keys(), ...outTotals.keys()])) {
+				const inV = inTotals.get(addr) ?? BigInt(0);
+				const outV = outTotals.get(addr) ?? BigInt(0);
+				pushTokenLeg(addr, (inV > outV ? inV : outV).toString());
+			}
+			const assetDids = /* @__PURE__ */ new Set();
+			const collectAssetDids = (assets) => {
+				if (!Array.isArray(assets)) return;
+				for (const a of assets) {
+					const addr = typeof a === "string" ? a : a?.address;
+					if (typeof addr === "string" && addr.length > 0) assetDids.add(addr);
+				}
+			};
+			for (const entry of itxInputs ?? []) collectAssetDids(entry.assets);
+			for (const entry of itxOutputs ?? []) collectAssetDids(entry.assets);
+			collectAssetDids(itxJson.assets);
+			for (const did of assetDids) legs.push({
+				kind: "asset",
+				target: did
+			});
+			if (legs.length === 0 && typeof itxJson.value === "string" && itxJson.value !== "") pushTokenLeg(void 0, itxJson.value);
+		}
+		const tokenGroups = /* @__PURE__ */ new Map();
+		const tokenOrder = [];
+		let assetCount = 0;
+		for (const leg of legs) if (leg.kind === "token") {
+			let v;
+			try {
+				v = BigInt(leg.value);
+			} catch (_) {
+				continue;
+			}
+			const positive = v > BigInt(0) ? v : BigInt(0);
+			const existing = tokenGroups.get(leg.target);
+			if (existing) existing.total += positive;
+			else {
+				tokenGroups.set(leg.target, {
+					kind: "token",
+					target: leg.target,
+					symbol: leg.symbol,
+					decimal: leg.decimal,
+					total: positive
+				});
+				tokenOrder.push(leg.target);
+			}
+		} else assetCount++;
+		const groups = [];
+		for (const k of tokenOrder) {
+			const g = tokenGroups.get(k);
+			if (g && g.total > BigInt(0)) groups.push(g);
+		}
+		if (assetCount > 0) groups.push({
+			kind: "asset",
+			count: assetCount
+		});
+		const principal = groups[0];
+		let txValue;
+		let txDecimal;
+		let txSymbol;
+		if (principal && principal.kind === "token") {
+			txValue = principal.total.toString();
+			txDecimal = principal.decimal;
+			txSymbol = principal.symbol;
+		} else if (principal && principal.kind === "asset") {
+			txValue = String(principal.count);
+			txDecimal = 0;
+			txSymbol = "Asset";
+		}
+		const _valueLegCount = groups.length;
+		const _valueLegCountSuffix = _valueLegCount > 1 ? ` · +${_valueLegCount - 1} more` : "";
+		const gasFeeRaw = String(itx.gasFee ?? "0");
+		const gasPaidRaw = String(itx.gasPaid ?? "0");
+		const serviceFeeRaw = String(itx.serviceFee ?? "0");
+		const gasExempted = gasFeeRaw !== "0" && (gasPaidRaw === "0" || gasPaidRaw === "");
+		const methodGroup = getTxGroup(tx.type || "");
+		const methodColor = getTxColor(tx.type || "");
+		return {
+			_typeName: formatTxTypeName(tx.type || ""),
+			_statusIntent: txStatusIntent(tx.code),
+			_statusLabel: tx.code === "OK" ? "Success" : tx.code || "",
+			_resolvedReceiver: tx.receiver || itxTo || itxOutputOwner || null,
+			_itxTokenSymbol: tokenSymbols?.[0]?.symbol,
+			_itxTokenDecimal: tokenSymbols?.[0]?.decimal,
+			_itxTokenAddress: tokenSymbols?.[0]?.address ?? "",
+			_itxAmount: token?.value,
+			_itxBlockHeight: itxJson.height ?? itxJson.blockHeight,
+			value: txValue,
+			decimal: txDecimal,
+			symbol: txSymbol,
+			_valueLegCount: txValue !== void 0 ? _valueLegCount : void 0,
+			_valueLegCountSuffix,
+			_gasFeeRaw: gasFeeRaw,
+			_gasExempted: gasExempted,
+			_gasStyle: gasExempted ? {
+				textDecoration: "line-through",
+				opacity: "0.55"
+			} : {},
+			_gasExemptedNote: gasExempted ? "Saved by staking ABT" : "",
+			_serviceFeeRaw: serviceFeeRaw,
+			_methodGroup: methodGroup,
+			_methodColor: methodColor
+		};
+	}
+	buildTxEntries(result) {
+		return result.items.map((tx) => {
+			const itxJson = tx.tx?.itxJson || {};
+			const parties = resolveTxParties(tx);
+			if (parties.sender) tx.sender = parties.sender;
+			if (parties.receiver) tx.receiver = parties.receiver;
+			return {
+				...this.buildEntry(joinURL("/transactions", tx.hash), {
+					content: {
+						...tx,
+						...this.enrichTxContent(tx, itxJson)
+					},
+					meta: { kind: tx.type ? `ocap:transaction:${tx.type}` : "ocap:transaction" }
+				}),
+				summary: `${tx.type}: ${tx.sender} → ${tx.receiver}`
+			};
+		});
+	}
+	buildBlockEntries(rollupAddr, result) {
+		return result.items.map((b) => ({
+			...this.buildEntry(joinURL("/bridges", rollupAddr, "blocks", b.hash), {
+				content: {
+					...b,
+					tokenDecimal: b.tokenInfo?.decimal
+				},
+				meta: { kind: "ocap:rollup-block" }
+			}),
+			summary: `Block #${b.height} • ${b.txs?.length ?? 0} txs`
+		}));
+	}
+	async readRoot(_ctx) {
+		await this.resolveNameOnce();
+		const minPage = {
+			size: 1,
+			offset: 0
+		};
+		const ttl = AFSOCAP.CHAIN_TTL_MS;
+		const [info, forgeStats, tokens, assets, factories, bridges, stakes] = await Promise.all([
+			this.memoize("getChainInfo", ttl, () => this.source.getChainInfo()),
+			this.memoize("getForgeStats", ttl, () => this.source.getForgeStats()).catch(() => null),
+			this.memoize("listTokens:size1", ttl, () => this.source.listTokens(minPage)).catch(() => ({ total: 0 })),
+			this.memoize("listAssets:size1", ttl, () => this.source.listAssets(minPage)).catch(() => ({ total: 0 })),
+			this.memoize("listFactories:size1", ttl, () => this.source.listFactories(minPage)).catch(() => ({ total: 0 })),
+			this.memoize("listRollups:size1", ttl, () => this.source.listRollups(minPage)).catch(() => ({ total: 0 })),
+			this.memoize("listStakes:size1", ttl, () => this.source.listStakes(minPage)).catch(() => ({ total: 0 }))
+		]);
+		const accountCount = this.computeAccountCount(forgeStats);
+		const numTxs = this.parseSafeCount(info.totalTxs);
+		return this.buildEntry("/", {
+			content: {
+				...info,
+				accountCount,
+				tokenCount: tokens.total,
+				assetCount: assets.total,
+				factoryCount: factories.total,
+				bridgeCount: bridges.total,
+				stakeCount: stakes.total,
+				numTxs
+			},
+			meta: {
+				kind: "ocap:chain",
+				childrenCount: TOP_LEVEL_DIRS.length
+			}
+		});
+	}
+	/**
+	* Phase 0.5 B.1 — chainInfo.totalTxs is a string from GraphQL ("5000").
+	* Same regex + BigInt clamp story as `computeAccountCount`: reject anything
+	* that isn't a base-10 unsigned integer to keep "1e308" and negatives out
+	* of the renderer, then clamp to MAX_SAFE_INTEGER so JSON serialization
+	* stays lossless.
+	*/
+	parseSafeCount(raw) {
+		if (typeof raw !== "string" || raw.length === 0) return 0;
+		if (!/^\d+$/.test(raw)) return 0;
+		const big = BigInt(raw);
+		if (big > BigInt(Number.MAX_SAFE_INTEGER)) return Number.MAX_SAFE_INTEGER;
+		return Number(big);
+	}
+	/**
+	* Phase 0.2 A.10 — Convert the last `numDeclareTxs` entry (a string from
+	* GraphQL) to a JS number, with explicit BigInt-then-bounds guard so a
+	* malicious / corrupt payload like "1e308" or "9".repeat(40) cannot wrap
+	* around to Infinity or lose precision via Number() coercion.
+	*
+	* Returns 0 when the source is unavailable; callers can detect "no data"
+	* vs "0 declare txs" by checking forgeStats null upstream.
+	*/
+	computeAccountCount(forgeStats) {
+		const arr = forgeStats?.forgeStats?.numDeclareTxs;
+		if (!Array.isArray(arr) || arr.length === 0) return 0;
+		const last = arr[arr.length - 1];
+		if (typeof last !== "string" || last.length === 0) return 0;
+		if (!/^\d+$/.test(last)) return 0;
+		const big = BigInt(last);
+		if (big > BigInt(Number.MAX_SAFE_INTEGER)) return Number.MAX_SAFE_INTEGER;
+		return Number(big);
+	}
+	/**
+	* Phase 1.1 — `/_microbar` aggregator powering the chain-explorer header
+	* micro-bar. The renderer can't fan out to multiple sources cheaply, so
+	* the provider produces a single object containing chain.height +
+	* sync flag + native-token price + 24h change.
+	*
+	* Price fetch is best-effort (Promise.allSettled): a slow upstream MUST
+	* NOT block chain navigation. When unavailable, tokens[i].price is null
+	* and tokens[i].stale is true so the renderer can show a dim "—".
+	*/
+	async readMicrobar(ctx) {
+		const native = await this.resolveNativeToken();
+		const [info, priceValue] = await Promise.all([this.memoize("getChainInfo", AFSOCAP.CHAIN_TTL_MS, () => this.source.getChainInfo()), native ? this.getPriceBySymbol(native.symbol).catch(() => null) : Promise.resolve(null)]);
+		const tokenEntries = [];
+		if (native) if (priceValue) tokenEntries.push({
+			symbol: priceValue.symbol ?? native.symbol,
+			address: native.address,
+			price: priceValue.price ?? null,
+			change24h: priceValue.change24h ?? null,
+			currency: priceValue.currency ?? "USD",
+			stale: Boolean(priceValue.stale),
+			fetchedAt: priceValue.fetchedAt ?? null
+		});
+		else tokenEntries.push({
+			symbol: native.symbol,
+			address: native.address,
+			price: null,
+			change24h: null,
+			currency: "USD",
+			stale: true,
+			fetchedAt: null
+		});
+		const flat = tokenEntries[0];
+		return this.buildEntry(ctx.path, {
+			content: {
+				chainHeight: this.parseSafeCount(info.blockHeight),
+				synced: Boolean(info.synced),
+				moniker: info.moniker || "",
+				nativeSymbol: flat?.symbol ?? null,
+				nativePrice: flat?.price ?? null,
+				nativeChange24h: flat?.change24h ?? null,
+				nativeCurrency: flat?.currency ?? "USD",
+				nativeStale: flat ? Boolean(flat.stale) : false,
+				tokens: tokenEntries
+			},
+			meta: {
+				kind: "ocap:microbar",
+				visibility: "hidden"
+			}
+		});
+	}
+	async readConfig(_ctx) {
+		const tx = (await this.source.getConfig()).transaction ?? {};
+		const txSize = tx.maxTxSize ?? {};
+		const txFee = tx.txFee ?? {};
+		const txGas = tx.txGas ?? {};
+		const txStake = tx.txStake ?? {};
+		const supported = tx.supportedTxs ?? [];
+		const strip = (s) => s.replace(/^fg:t:/, "");
+		const group = (keys) => keys.filter((k) => supported.includes(k)).map(strip).join(", ") || "—";
+		const content = {
+			maxAssetSize: tx.maxAssetSize,
+			maxListSize: tx.maxListSize,
+			maxMultisig: tx.maxMultisig,
+			defaultMaxTxSize: txSize.default,
+			gasPrice: txGas.price,
+			gasCreateState: txGas.createState,
+			gasUpdateState: txGas.updateState,
+			gasDataStorage: txGas.dataStorage,
+			gasMinStake: txGas.minStake,
+			gasMaxStake: txGas.maxStake,
+			gasStakeLockPeriod: txGas.stakeLockPeriod,
+			feeDefault: txFee.default ?? 0,
+			feeCreateAsset: txFee["fg:t:create_asset"] ?? 0,
+			feeMintAsset: txFee["fg:t:mint_asset"] ?? 0,
+			feeCreateFactory: txFee["fg:t:create_factory"] ?? 0,
+			feeCreateToken: txFee["fg:t:create_token"] ?? 0,
+			feeCreateRollup: txFee["fg:t:create_rollup"] ?? 0,
+			feeUpdateTokenFactory: txFee["fg:t:update_token_factory"] ?? 0,
+			stakeCreateToken: txStake.createToken,
+			stakeCreateCreditToken: txStake.createCreditToken,
+			stakeCreateTokenLockPeriod: txStake.createTokenLockPeriod,
+			txGroupAccount: group([
+				"fg:t:account_migrate",
+				"fg:t:delegate",
+				"fg:t:revoke_delegate"
+			]),
+			txGroupTrade: group([
+				"fg:t:transfer",
+				"fg:t:transfer_v2",
+				"fg:t:transfer_v3",
+				"fg:t:exchange_v2"
+			]),
+			txGroupAsset: group([
+				"fg:t:create_asset",
+				"fg:t:update_asset",
+				"fg:t:consume_asset",
+				"fg:t:acquire_asset_v2",
+				"fg:t:acquire_asset_v3",
+				"fg:t:mint_asset",
+				"fg:t:create_factory"
+			]),
+			txGroupToken: group([
+				"fg:t:create_token",
+				"fg:t:deposit_token_v2",
+				"fg:t:withdraw_token_v2",
+				"fg:t:create_token_factory",
+				"fg:t:update_token_factory",
+				"fg:t:mint_token",
+				"fg:t:burn_token"
+			]),
+			txGroupGovernance: group([
+				"fg:t:stake",
+				"fg:t:revoke_stake",
+				"fg:t:claim_stake",
+				"fg:t:slash_stake",
+				"fg:t:return_stake"
+			]),
+			txGroupRollup: group([
+				"fg:t:create_rollup",
+				"fg:t:update_rollup",
+				"fg:t:pause_rollup",
+				"fg:t:resume_rollup",
+				"fg:t:close_rollup",
+				"fg:t:join_rollup",
+				"fg:t:leave_rollup",
+				"fg:t:create_rollup_block",
+				"fg:t:migrate_rollup",
+				"fg:t:claim_block_reward"
+			])
+		};
+		return this.buildEntry("/config", {
+			content,
+			meta: { kind: "ocap:config" }
+		});
+	}
+	async listValidators(_ctx) {
+		return { data: (await this.source.getValidatorsInfo()).map((v) => ({
+			...this.buildEntry(joinURL("/validators", v.address), {
+				content: v,
+				meta: { kind: "ocap:validator" }
+			}),
+			summary: `${v.name || v.address} • voting power: ${v.votingPower}`
+		})) };
+	}
+	async readValidator(ctx) {
+		const v = (await this.source.getValidatorsInfo()).find((x) => x.address === ctx.params.address);
+		if (!v) throw new AFSNotFoundError(ctx.path);
+		return {
+			...this.buildEntry(ctx.path, {
+				content: v,
+				meta: { kind: "ocap:validator" }
+			}),
+			summary: `${v.name || v.address} • voting power: ${v.votingPower}`
+		};
+	}
+	async listTransactions(ctx) {
+		const paging = toPaging(listOpts(ctx), this.defaultPageSize);
+		const filters = extractTxFilters(listOpts(ctx));
+		const result = await this.source.listTransactions(paging, filters);
+		return buildListResult(this.buildTxEntries(result), result.total);
+	}
+	async readTransaction(ctx) {
+		const tx = await this.source.getTx(ctx.params.hash);
+		if (!tx) throw new AFSNotFoundError(ctx.path);
+		const itx = tx.tx || {};
+		const itxJson = itx.itxJson || {};
+		if (!tx.type && typeof itxJson.type_url === "string") tx.type = itxJson.type_url.split(":").pop() || "";
+		const parties = resolveTxParties(tx);
+		if (parties.sender) tx.sender = parties.sender;
+		if (parties.receiver) tx.receiver = parties.receiver;
+		const { prevHash, nextHash } = await this.findTxNeighbours(tx.time, tx.hash);
+		const shared = this.enrichTxContent(tx, itxJson);
+		const resolvedReceiver = shared._resolvedReceiver || "";
+		return {
+			...this.buildEntry(ctx.path, {
+				content: {
+					...tx,
+					...shared,
+					_prevHash: prevHash,
+					_nextHash: nextHash,
+					_receiverPath: this.resolveNavPath(resolvedReceiver),
+					_itxJson: itxJson,
+					_itxTo: itxJson.to,
+					_itxAddress: itxJson.address,
+					_itxMoniker: itxJson.moniker,
+					_itxFactory: itxJson.factory,
+					_itxTokenFactory: itxJson.tokenFactory || itxJson.token_factory,
+					_itxRollup: itxJson.rollup,
+					_itxBlockHash: itxJson.hash ?? itxJson.blockHash,
+					_itxInputOwner: itxJson.inputs?.[0]?.owner,
+					_itxOutputOwner: itxJson.outputs?.[0]?.owner,
+					_typeContext: deriveTypeContext(tx.type),
+					_hasReceipts: Array.isArray(tx.receipts) && tx.receipts.some((r) => (r.changes?.length ?? 0) > 0),
+					_nonce: itx.nonce,
+					_gasFeeFormatted: (() => {
+						const fee = String(itx.gasFee ?? "0");
+						if (!fee || fee === "0") return "0 ABT";
+						return `${formatBignumValue(fee, 18).replace(/^\+/, "")} ABT`;
+					})(),
+					_serviceFeeFormatted: (() => {
+						const fee = String(itx.serviceFee ?? "0");
+						if (!fee || fee === "0") return "0 ABT";
+						return `${formatBignumValue(fee, 18).replace(/^\+/, "")} ABT`;
+					})(),
+					_serviceFeeDisplay: (() => {
+						const fee = String(itx.serviceFee ?? "0");
+						if (!fee || fee === "0") return "Free";
+						return `${formatBignumValue(fee, 18).replace(/^\+/, "")} ABT`;
+					})()
+				},
+				meta: { kind: tx.type ? `ocap:transaction:${tx.type}` : "ocap:transaction" }
+			}),
+			summary: `${tx.type || "tx"}: ${tx.sender} → ${tx.receiver}`
+		};
+	}
+	async readTxReceiptsDir(ctx) {
+		return this.buildEntry(ctx.path, { meta: {
+			kind: "ocap:receipt",
+			childrenCount: -1
+		} });
+	}
+	async listTxReceipts(ctx) {
+		return { data: await this._buildReceiptEntries(ctx.params.hash, ctx.path) };
+	}
+	async readTxReceiptEntry(ctx) {
+		const entry = (await this._buildReceiptEntries(ctx.params.hash, joinURL(ctx.path, "..")))[Number(ctx.params.idx)];
+		if (!entry) throw new AFSNotFoundError(ctx.path);
+		return entry;
+	}
+	/**
+	* Phase 1.6 — find adjacent tx hashes by querying a tight time window
+	* around the current tx and selecting the immediate neighbours after
+	* sorting by time desc. Returns nulls for missing neighbours (newest /
+	* oldest tx). Failure of listTransactions must NOT propagate — the
+	* detail page still needs to render even when the indexer is down.
+	*/
+	async findTxNeighbours(txTime, currentHash) {
+		if (!txTime || !currentHash) return {
+			prevHash: null,
+			nextHash: null
+		};
+		const t = Date.parse(txTime);
+		if (!Number.isFinite(t)) return {
+			prevHash: null,
+			nextHash: null
+		};
+		const WINDOW_MS = 6e4;
+		const startDateTime = new Date(t - WINDOW_MS).toISOString();
+		const endDateTime = new Date(t + WINDOW_MS).toISOString();
+		try {
+			const sorted = ((await this.source.listTransactions({
+				size: 50,
+				offset: 0
+			}, { timeFilter: {
+				startDateTime,
+				endDateTime
+			} }))?.items ?? []).slice().sort((a, b) => {
+				const dt = Date.parse(b.time) - Date.parse(a.time);
+				if (dt !== 0) return dt;
+				return a.hash < b.hash ? -1 : 1;
+			});
+			const idx = sorted.findIndex((it) => it.hash === currentHash);
+			if (idx < 0) return {
+				prevHash: null,
+				nextHash: null
+			};
+			const next = sorted.slice(0, idx).find((it) => it.hash !== currentHash);
+			return {
+				prevHash: sorted.slice(idx + 1).find((it) => it.hash !== currentHash)?.hash ?? null,
+				nextHash: next?.hash ?? null
+			};
+		} catch {
+			return {
+				prevHash: null,
+				nextHash: null
+			};
+		}
+	}
+	async _buildReceiptEntries(hash, basePath) {
+		const tx = await this.source.getTx(hash);
+		if (!tx) return [];
+		const receipts = tx.receipts ?? [];
+		const tokenSymbols = tx.tokenSymbols ?? [];
+		const symbolMap = new Map(tokenSymbols.map((t) => [t.address, t]));
+		const unknownTargets = /* @__PURE__ */ new Set();
+		for (const r of receipts) for (const c of r.changes ?? []) if (c.target && !symbolMap.has(c.target)) unknownTargets.add(c.target);
+		const assetMap = /* @__PURE__ */ new Map();
+		if (unknownTargets.size > 0) await Promise.all(Array.from(unknownTargets).map(async (addr) => {
+			try {
+				const a = await this.source.getAssetState(addr);
+				if (a) assetMap.set(addr, a);
+			} catch {}
+		}));
+		const entries = [];
+		let idx = 0;
+		for (const receipt of receipts) for (const change of receipt.changes ?? []) {
+			const target = change.target ?? "";
+			const rawValue = change.value ?? "0";
+			const tokenInfo = symbolMap.get(target);
+			const assetInfo = assetMap.get(target);
+			let targetKind;
+			let symbol;
+			let valueFormatted;
+			if (tokenInfo) {
+				targetKind = "token";
+				symbol = tokenInfo.symbol;
+				valueFormatted = formatBignumValue(rawValue, tokenInfo.decimal);
+			} else if (assetInfo) {
+				targetKind = "asset";
+				symbol = assetInfo.moniker || "Asset";
+				valueFormatted = rawValue;
+			} else {
+				targetKind = "unknown";
+				symbol = "—";
+				valueFormatted = rawValue;
+			}
+			entries.push(this.buildEntry(joinURL(basePath, String(idx)), {
+				content: {
+					account: receipt.address ?? "",
+					action: change.action ?? "",
+					target,
+					targetKind,
+					symbol,
+					value: rawValue,
+					valueFormatted,
+					_tokenLink: targetKind === "token" ? target : ""
+				},
+				meta: { kind: "ocap:receipt" }
+			}));
+			idx++;
+		}
+		return entries;
+	}
+	async listAccounts(ctx) {
+		const paging = toPaging(listOpts(ctx), this.defaultPageSize);
+		const result = await this.source.listTopAccounts(paging);
+		return buildListResult(result.items.map((a) => ({
+			...this.buildEntry(joinURL("/accounts", a.address), {
+				content: {
+					...a,
+					_monikerDisplay: displayMoniker(a.moniker, a.address)
+				},
+				meta: {
+					kind: "ocap:account",
+					childrenCount: 7
+				}
+			}),
+			summary: `${a.moniker || a.address} • ${a.balance}`
+		})), result.total);
+	}
+	async readAccount(ctx) {
+		const state = await this.source.getAccountState(ctx.params.address);
+		if (!state) throw new AFSNotFoundError(ctx.path);
+		const content = {
+			...state,
+			migratedToFirst: state.migratedTo?.[0],
+			migratedFromFirst: state.migratedFrom?.[0],
+			_roleLabel: resolveDidRoleLabel(ctx.params.address) ?? "Account",
+			_hasMigration: Array.isArray(state.migratedFrom) && state.migratedFrom.length > 0 || Array.isArray(state.migratedTo) && state.migratedTo.length > 0
+		};
+		return {
+			...this.buildEntry(ctx.path, {
+				content,
+				meta: {
+					kind: "ocap:account",
+					childrenCount: 7
+				}
+			}),
+			summary: `${state.moniker || state.address} • ${state.balance}`
+		};
+	}
+	async listAccountChildren(ctx) {
+		if (ctx.params.address.startsWith(".")) throw new AFSNotFoundError(ctx.path);
+		return { data: [
+			"tokens",
+			"assets",
+			"stakes",
+			"delegates",
+			"transactions",
+			"migration",
+			"token-flows"
+		].map((sub) => buildDirEntry(ctx.path, sub)) };
+	}
+	async readAccountTokensDir(ctx) {
+		return this.buildEntry(ctx.path, { meta: {
+			kind: "ocap:token",
+			childrenCount: -1
+		} });
+	}
+	async readAccountAssetsDir(ctx) {
+		return this.buildEntry(ctx.path, { meta: {
+			kind: "ocap:asset",
+			childrenCount: -1
+		} });
+	}
+	async readAccountTxDir(ctx) {
+		return this.buildEntry(ctx.path, { meta: {
+			kind: "ocap:transaction",
+			childrenCount: -1
+		} });
+	}
+	async listAccountTokens(ctx) {
+		return { data: (await this.source.getAccountTokens(ctx.params.addr)).map((t) => ({
+			...this.buildEntry(joinURL("/tokens", t.address), {
+				content: t,
+				meta: { kind: "ocap:token" }
+			}),
+			summary: `${t.symbol} • ${t.balance}`
+		})) };
+	}
+	async metaAccountTokens(ctx) {
+		return this.buildEntry(ctx.path, { meta: {
+			kind: "ocap:token",
+			childrenCount: -1
+		} });
+	}
+	async readAccountToken(ctx) {
+		const t = (await this.source.getAccountTokens(ctx.params.addr)).find((x) => x.address === ctx.params.token);
+		if (!t) throw new AFSNotFoundError(ctx.path);
+		return {
+			...this.buildEntry(ctx.path, {
+				content: t,
+				meta: { kind: "ocap:token" }
+			}),
+			summary: `${t.symbol} • ${t.balance}`
+		};
+	}
+	async listAccountAssets(ctx) {
+		const paging = toPaging(listOpts(ctx), this.defaultPageSize);
+		const userFilters = extractAssetFilters(listOpts(ctx));
+		const result = await this.source.listAssets(paging, {
+			...userFilters,
+			ownerAddress: ctx.params.addr
+		});
+		const entries = result.items.map((a) => ({
+			...this.buildEntry(joinURL("/assets", a.address), {
+				content: a,
+				meta: {
+					kind: "ocap:asset",
+					childrenCount: 2
+				}
+			}),
+			summary: `${a.moniker || a.address} • owner: ${a.owner}`
+		}));
+		return buildListResult(this.withCurrentAccount(entries, ctx.params.addr), result.total);
+	}
+	async listAccountTransactions(ctx) {
+		const paging = toPaging(listOpts(ctx), this.defaultPageSize);
+		const userFilters = extractTxFilters(listOpts(ctx));
+		const result = await this.source.listTransactions(paging, {
+			...userFilters,
+			accountFilter: { accounts: [ctx.params.addr] }
+		});
+		return buildListResult(this.withCurrentAccount(this.buildTxEntries(result), ctx.params.addr), result.total);
+	}
+	async readAccountStakesDir(ctx) {
+		return this.buildEntry(ctx.path, { meta: {
+			kind: "ocap:stake",
+			childrenCount: -1
+		} });
+	}
+	async listAccountStakes(ctx) {
+		const paging = toPaging(listOpts(ctx), this.defaultPageSize);
+		const userFilters = extractStakeFilters(listOpts(ctx));
+		const result = await this.source.listStakes(paging, {
+			...userFilters,
+			addressFilter: {
+				sender: ctx.params.addr,
+				receiver: ctx.params.addr,
+				direction: "UNION"
+			}
+		});
+		const entries = result.items.map((s) => ({
+			...this.buildEntry(joinURL("/stakes", s.address), {
+				content: s,
+				meta: { kind: "ocap:stake" }
+			}),
+			summary: `${s.sender} → ${s.receiver}`
+		}));
+		return buildListResult(this.withCurrentAccount(entries, ctx.params.addr), result.total);
+	}
+	async readAccountSentStakesDir(ctx) {
+		return this.buildEntry(ctx.path, { meta: {
+			kind: "ocap:stake",
+			childrenCount: -1
+		} });
+	}
+	async listAccountSentStakes(ctx) {
+		const paging = toPaging(listOpts(ctx), this.defaultPageSize);
+		const userFilters = extractStakeFilters(listOpts(ctx));
+		const result = await this.source.listStakes(paging, {
+			...userFilters,
+			addressFilter: { sender: ctx.params.addr }
+		});
+		const entries = result.items.map((s) => ({
+			...this.buildEntry(joinURL("/stakes", s.address), {
+				content: s,
+				meta: { kind: "ocap:stake" }
+			}),
+			summary: `${s.sender} → ${s.receiver}`
+		}));
+		return buildListResult(this.withCurrentAccount(entries, ctx.params.addr), result.total);
+	}
+	async readAccountReceivedStakesDir(ctx) {
+		return this.buildEntry(ctx.path, { meta: {
+			kind: "ocap:stake",
+			childrenCount: -1
+		} });
+	}
+	async listAccountReceivedStakes(ctx) {
+		const paging = toPaging(listOpts(ctx), this.defaultPageSize);
+		const userFilters = extractStakeFilters(listOpts(ctx));
+		const result = await this.source.listStakes(paging, {
+			...userFilters,
+			addressFilter: { receiver: ctx.params.addr }
+		});
+		const items = result.items.map((s) => ({
+			...this.buildEntry(joinURL("/stakes", s.address), {
+				content: s,
+				meta: { kind: "ocap:stake" }
+			}),
+			summary: `${s.sender} → ${s.receiver}`
+		}));
+		return buildListResult(this.withCurrentAccount(items, ctx.params.addr), result.total);
+	}
+	async readAccountMigrationDir(ctx) {
+		return this.buildEntry(ctx.path, { meta: {
+			kind: "ocap:account:migration",
+			childrenCount: -1
+		} });
+	}
+	async listAccountMigration(ctx) {
+		const state = await this.source.getAccountState(ctx.params.addr);
+		if (!state) throw new AFSNotFoundError(ctx.path);
+		const from = Array.isArray(state.migratedFrom) ? state.migratedFrom : [];
+		const to = Array.isArray(state.migratedTo) ? state.migratedTo : [];
+		const ordered = [
+			...from.map((a) => ({
+				address: a,
+				role: "from"
+			})),
+			{
+				address: state.address,
+				role: "current"
+			},
+			...to.map((a) => ({
+				address: a,
+				role: "to"
+			}))
+		];
+		const lastIdx = ordered.length - 1;
+		const entries = ordered.map((step, idx) => ({
+			...this.buildEntry(joinURL("/accounts", step.address), {
+				content: {
+					address: step.address,
+					_migrationRole: step.role,
+					_isCurrent: step.role === "current",
+					_isLatest: idx === lastIdx,
+					_index: idx,
+					_currentAccount: ctx.params.addr
+				},
+				meta: { kind: "ocap:account:migration:step" }
+			}),
+			summary: `${step.role}: ${step.address}`
+		}));
+		return buildListResult(entries, entries.length);
+	}
+	async readAccountTokenFlowsDir(ctx) {
+		return this.buildEntry(ctx.path, { meta: {
+			kind: "ocap:token-flow",
+			childrenCount: -1
+		} });
+	}
+	async listAccountTokenFlows(ctx) {
+		const paging = toPaging(listOpts(ctx), this.defaultPageSize);
+		const opts = ctx.options ?? {};
+		const tokenAddress = typeof opts.tokenAddress === "string" ? opts.tokenAddress : void 0;
+		const depth = typeof opts.depth === "number" ? opts.depth : void 0;
+		const dirRaw = typeof opts.direction === "string" ? opts.direction.toUpperCase() : void 0;
+		const direction = dirRaw === "IN" || dirRaw === "OUT" || dirRaw === "ALL" ? dirRaw : void 0;
+		const result = await this.source.listTokenFlows(ctx.params.addr, paging, {
+			tokenAddress,
+			depth,
+			direction
+		});
+		const items = result.items.map((flow) => {
+			const isIn = flow.to === ctx.params.addr;
+			const counterparty = isIn ? flow.from : flow.to;
+			return {
+				...this.buildEntry(joinURL(ctx.path, flow.hash), {
+					content: {
+						...flow,
+						_direction: isIn ? "in" : "out",
+						_counterparty: counterparty
+					},
+					meta: { kind: "ocap:token-flow:entry" }
+				}),
+				summary: `${isIn ? "in" : "out"}: ${counterparty} • ${flow.value}`
+			};
+		});
+		return buildListResult(this.withCurrentAccount(items, ctx.params.addr), result.total);
+	}
+	async readAccountDelegatesDir(ctx) {
+		return this.buildEntry(ctx.path, { meta: {
+			kind: "ocap:delegate",
+			childrenCount: -1
+		} });
+	}
+	async listAccountDelegates(ctx) {
+		const paging = toPaging(listOpts(ctx), this.defaultPageSize);
+		const userFilters = extractDelegationFilters(listOpts(ctx));
+		const result = await this.source.listDelegations(paging, {
+			...userFilters,
+			from: ctx.params.addr
+		});
+		return buildListResult(result.items.map((d) => ({
+			...this.buildEntry(joinURL("/delegates", d.address), {
+				content: d,
+				meta: { kind: "ocap:delegate" }
+			}),
+			summary: `${d.from} → ${d.to}`
+		})), result.total);
+	}
+	async listTokens(ctx) {
+		const paging = toPaging(listOpts(ctx), this.defaultPageSize);
+		const filters = extractTokenFilters(listOpts(ctx));
+		const result = await this.source.listTokens(paging, filters);
+		return buildListResult(result.items.map((t) => ({
+			...this.buildEntry(joinURL("/tokens", t.address), {
+				content: t,
+				meta: {
+					kind: "ocap:token",
+					childrenCount: 2
+				}
+			}),
+			summary: `${t.name} (${t.symbol}) • supply: ${t.totalSupply}`
+		})), result.total);
+	}
+	async readToken(ctx) {
+		const state = await this.source.getTokenState(ctx.params.address);
+		if (!state) throw new AFSNotFoundError(ctx.path);
+		const content = enrichTokenContent(state);
+		return {
+			...this.buildEntry(ctx.path, {
+				content,
+				meta: {
+					kind: "ocap:token",
+					childrenCount: 3
+				}
+			}),
+			summary: `${state.name} (${state.symbol}) • supply: ${state.totalSupply}`
+		};
+	}
+	async listTokenChildren(ctx) {
+		if (ctx.params.address.startsWith(".")) throw new AFSNotFoundError(ctx.path);
+		return { data: [
+			"holders",
+			"transactions",
+			"price"
+		].map((sub) => buildDirEntry(ctx.path, sub)) };
+	}
+	/**
+	* Phase 0.2 A.7 — Pull `{price, change24h}` out of the token-data
+	* upstream shape into top-level fields. The upstream API returns a
+	* paginated `{ symbol, data: [{ price: {USD, CNY}, percent_change_24h:
+	* {USD, CNY}, ... }] }`. AUP nodes binding `${content.price}` should
+	* just see a number — they shouldn't have to navigate the upstream
+	* pagination wrapper.
+	*
+	* Also surfaces `currency: "USD"` so dark-launch testing or future
+	* locale work can switch to other currencies. Falls back to the raw
+	* shape (with the wrapper) when the upstream returns something
+	* unexpected — partial structure is better than throwing on a price
+	* lookup that the UI uses opportunistically.
+	*/
+	normalizePricePayload(payload, symbol, now) {
+		const fetchedAt = new Date(now).toISOString();
+		const first = (payload.data ?? [])[0];
+		if (!first) return {
+			...payload,
+			symbol,
+			fetchedAt
+		};
+		const priceMap = first.price ?? {};
+		const changeMap = first.percent_change_24h ?? {};
+		return {
+			...payload,
+			symbol,
+			price: priceMap.USD ?? null,
+			change24h: changeMap.USD ?? null,
+			currency: "USD",
+			fetchedAt
+		};
+	}
+	/**
+	* Phase 0.2 A.7 — Token price endpoint with 60s in-memory cache + stale
+	* fallback on upstream failure. Backed by token-data.arcblock.io which
+	* accepts only symbols (not addresses), so we resolve the token's symbol
+	* via getTokenState first.
+	*
+	* Cache lifecycle:
+	*  - Fresh hit (within TTL) → return cached value immediately
+	*  - Miss → fetch upstream → cache → return
+	*  - Fetch failure WITH cached value → return cached + { stale: true, error }
+	*  - Fetch failure WITHOUT cached value → throw AFSError
+	*/
+	async readTokenPrice(ctx) {
+		const addr = ctx.params.addr;
+		if (!addr || addr.startsWith(".") || addr.includes("/")) throw new AFSNotFoundError(ctx.path);
+		const state = await this.source.getTokenState(addr);
+		if (!state) throw new AFSNotFoundError(ctx.path);
+		if (!state.symbol) throw new AFSNotFoundError(joinURL(ctx.path, "no-symbol"));
+		const value = await this.getPriceBySymbol(state.symbol);
+		if (!value) throw new AFSNotFoundError(ctx.path);
+		return this.buildEntry(ctx.path, {
+			content: value,
+			meta: { kind: "ocap:token:price" }
+		});
+	}
+	async readTokenHoldersDir(ctx) {
+		return this.buildEntry(ctx.path, { meta: {
+			kind: "ocap:account",
+			childrenCount: -1
+		} });
+	}
+	async listTokenHolders(ctx) {
+		const paging = toPaging(listOpts(ctx), this.defaultPageSize);
+		const tokenAddr = ctx.params.addr;
+		const result = await this.source.listTopAccounts(paging, { tokenAddress: tokenAddr });
+		return buildListResult(result.items.map((a) => {
+			const tokenEntry = a.tokens?.find((t) => t.address === tokenAddr);
+			const tokenBalance = tokenEntry?.balance ?? "0";
+			const tokenDecimal = tokenEntry?.decimal;
+			const tokenSymbol = tokenEntry?.symbol;
+			return {
+				...this.buildEntry(joinURL("/accounts", a.address), {
+					content: {
+						...a,
+						_monikerDisplay: displayMoniker(a.moniker, a.address),
+						_tokenBalance: tokenBalance,
+						_tokenDecimal: tokenDecimal,
+						_tokenSymbol: tokenSymbol
+					},
+					meta: { kind: "ocap:account" }
+				}),
+				summary: `${a.moniker || a.address} • ${tokenBalance}`
+			};
+		}), result.total);
+	}
+	async readTokenTxDir(ctx) {
+		return this.buildEntry(ctx.path, { meta: {
+			kind: "ocap:transaction",
+			childrenCount: -1
+		} });
+	}
+	async listTokenTransactions(ctx) {
+		const paging = toPaging(listOpts(ctx), this.defaultPageSize);
+		const userFilters = extractTxFilters(listOpts(ctx));
+		const result = await this.source.listTransactions(paging, {
+			...userFilters,
+			tokenFilter: { tokens: [ctx.params.addr] }
+		});
+		return buildListResult(this.buildTxEntries(result), result.total);
+	}
+	async listAssets(ctx) {
+		const paging = toPaging(listOpts(ctx), this.defaultPageSize);
+		const filters = extractAssetFilters(listOpts(ctx));
+		const result = await this.source.listAssets(paging, filters);
+		return buildListResult(result.items.map((a) => ({
+			...this.buildEntry(joinURL("/assets", a.address), {
+				content: a,
+				meta: {
+					kind: "ocap:asset",
+					childrenCount: 2
+				}
+			}),
+			summary: `${a.moniker || a.address} • owner: ${a.owner}`
+		})), result.total);
+	}
+	async readAsset(ctx) {
+		const state = await this.source.getAssetState(ctx.params.address);
+		if (!state) throw new AFSNotFoundError(ctx.path);
+		const ttlRaw = state.ttl;
+		return {
+			...this.buildEntry(ctx.path, {
+				content: {
+					...state,
+					_issuerPath: this.resolveNavPath(state.issuer),
+					_ttlDisplay: formatIntegerOrSentinel(ttlRaw, "Never"),
+					_nftDisplay: deriveNftDisplay(state)
+				},
+				meta: {
+					kind: "ocap:asset",
+					childrenCount: 2
+				}
+			}),
+			summary: `${state.moniker || state.address} • owner: ${state.owner}`
+		};
+	}
+	async listAssetChildren(ctx) {
+		if (ctx.params.address.startsWith(".")) throw new AFSNotFoundError(ctx.path);
+		return { data: ["transactions", "stakes"].map((sub) => buildDirEntry(ctx.path, sub)) };
+	}
+	async readAssetTxDir(ctx) {
+		return this.buildEntry(ctx.path, { meta: {
+			kind: "ocap:transaction",
+			childrenCount: -1
+		} });
+	}
+	async listAssetTransactions(ctx) {
+		const paging = toPaging(listOpts(ctx), this.defaultPageSize);
+		const userFilters = extractTxFilters(listOpts(ctx));
+		const result = await this.source.listTransactions(paging, {
+			...userFilters,
+			assetFilter: { assets: [ctx.params.addr] }
+		});
+		return buildListResult(this.buildTxEntries(result), result.total);
+	}
+	async readAssetStakesDir(ctx) {
+		return this.buildEntry(ctx.path, { meta: {
+			kind: "ocap:stake",
+			childrenCount: -1
+		} });
+	}
+	async listAssetStakes(ctx) {
+		const paging = toPaging(listOpts(ctx), this.defaultPageSize);
+		const userFilters = extractStakeFilters(listOpts(ctx));
+		const result = await this.source.listStakes(paging, {
+			...userFilters,
+			addressFilter: {
+				sender: ctx.params.addr,
+				receiver: ctx.params.addr,
+				direction: "UNION"
+			}
+		});
+		return buildListResult(result.items.map((s) => ({
+			...this.buildEntry(joinURL("/stakes", s.address), {
+				content: s,
+				meta: { kind: "ocap:stake" }
+			}),
+			summary: `${s.sender} → ${s.receiver}`
+		})), result.total);
+	}
+	async listFactories(ctx) {
+		const paging = toPaging(listOpts(ctx), this.defaultPageSize);
+		const filters = extractFactoryFilters(listOpts(ctx));
+		const result = await this.source.listFactories(paging, filters);
+		return buildListResult(result.items.map((f) => ({
+			...this.buildEntry(joinURL("/factories", f.address), {
+				content: {
+					...f,
+					_limitDisplay: formatIntegerOrSentinel(f.limit, "Unlimited")
+				},
+				meta: {
+					kind: "ocap:factory",
+					childrenCount: 2
+				}
+			}),
+			summary: `${f.name} • minted: ${f.numMinted}/${f.limit}`
+		})), result.total);
+	}
+	async readFactory(ctx) {
+		const state = await this.source.getFactoryState(ctx.params.address);
+		if (!state) throw new AFSNotFoundError(ctx.path);
+		return {
+			...this.buildEntry(ctx.path, {
+				content: {
+					...state,
+					_limitDisplay: formatIntegerOrSentinel(state.limit, "Unlimited")
+				},
+				meta: {
+					kind: "ocap:factory",
+					childrenCount: 2
+				}
+			}),
+			summary: `${state.name} • minted: ${state.numMinted}/${state.limit}`
+		};
+	}
+	async listFactoryChildren(ctx) {
+		if (ctx.params.address.startsWith(".")) throw new AFSNotFoundError(ctx.path);
+		return { data: ["assets", "transactions"].map((sub) => buildDirEntry(ctx.path, sub)) };
+	}
+	async readFactoryAssetsDir(ctx) {
+		return this.buildEntry(ctx.path, { meta: {
+			kind: "ocap:asset",
+			childrenCount: -1
+		} });
+	}
+	async listFactoryAssets(ctx) {
+		const paging = toPaging(listOpts(ctx), this.defaultPageSize);
+		const userFilters = extractAssetFilters(listOpts(ctx));
+		const result = await this.source.listAssets(paging, {
+			...userFilters,
+			factoryAddress: ctx.params.addr
+		});
+		return buildListResult(result.items.map((a) => ({
+			...this.buildEntry(joinURL("/assets", a.address), {
+				content: a,
+				meta: {
+					kind: "ocap:asset",
+					childrenCount: 2
+				}
+			}),
+			summary: `${a.moniker || a.address} • owner: ${a.owner}`
+		})), result.total);
+	}
+	async readFactoryTxDir(ctx) {
+		return this.buildEntry(ctx.path, { meta: {
+			kind: "ocap:transaction",
+			childrenCount: -1
+		} });
+	}
+	async listFactoryTransactions(ctx) {
+		const paging = toPaging(listOpts(ctx), this.defaultPageSize);
+		const userFilters = extractTxFilters(listOpts(ctx));
+		const result = await this.source.listTransactions(paging, {
+			...userFilters,
+			factoryFilter: { factories: [ctx.params.addr] }
+		});
+		return buildListResult(this.buildTxEntries(result), result.total);
+	}
+	async listStakes(ctx) {
+		const paging = toPaging(listOpts(ctx), this.defaultPageSize);
+		const filters = extractStakeFilters(listOpts(ctx));
+		const result = await this.source.listStakes(paging, filters);
+		return buildListResult(result.items.map((s) => ({
+			...this.buildEntry(joinURL("/stakes", s.address), {
+				content: s,
+				meta: {
+					kind: "ocap:stake",
+					childrenCount: 3
+				}
+			}),
+			summary: `${s.sender} → ${s.receiver}`
+		})), result.total);
+	}
+	async readStake(ctx) {
+		const state = await this.source.getStakeState(ctx.params.address);
+		if (!state) throw new AFSNotFoundError(ctx.path);
+		const content = {
+			...state,
+			firstSlasher: state.slashers?.[0] ?? ""
+		};
+		return {
+			...this.buildEntry(ctx.path, {
+				content,
+				meta: {
+					kind: "ocap:stake",
+					childrenCount: 3
+				}
+			}),
+			summary: `${state.sender} → ${state.receiver}`
+		};
+	}
+	async listStakeChildren(ctx) {
+		if (ctx.params.address.startsWith(".")) throw new AFSNotFoundError(ctx.path);
+		return { data: [
+			buildDirEntry(ctx.path, "transactions"),
+			buildDirEntry(ctx.path, "tokens"),
+			buildDirEntry(ctx.path, "assets")
+		] };
+	}
+	async readStakeTxDir(ctx) {
+		return this.buildEntry(ctx.path, { meta: {
+			kind: "ocap:transaction",
+			childrenCount: -1
+		} });
+	}
+	async listStakeTransactions(ctx) {
+		const paging = toPaging(listOpts(ctx), this.defaultPageSize);
+		const userFilters = extractTxFilters(listOpts(ctx));
+		const result = await this.source.listTransactions(paging, {
+			...userFilters,
+			stakeFilter: { stakes: [ctx.params.addr] }
+		});
+		return buildListResult(this.buildTxEntries(result), result.total);
+	}
+	async readStakeTokensDir(ctx) {
+		return this.buildEntry(ctx.path, { meta: {
+			kind: "ocap:token",
+			childrenCount: -1
+		} });
+	}
+	async listStakeTokens(ctx) {
+		const state = await this.source.getStakeState(ctx.params.addr);
+		if (!state) throw new AFSNotFoundError(ctx.path);
+		const tokenMap = /* @__PURE__ */ new Map();
+		for (const t of state.tokens ?? []) tokenMap.set(t.address, {
+			address: t.address,
+			symbol: t.symbol ?? "",
+			decimal: t.decimal ?? 18,
+			unit: t.unit ?? "",
+			staked: t.value ?? "0",
+			revoked: "0"
+		});
+		for (const t of state.revokedTokens ?? []) {
+			const existing = tokenMap.get(t.address);
+			if (existing) existing.revoked = t.value ?? "0";
+			else tokenMap.set(t.address, {
+				address: t.address,
+				symbol: t.symbol ?? "",
+				decimal: t.decimal ?? 18,
+				unit: t.unit ?? "",
+				staked: "0",
+				revoked: t.value ?? "0"
+			});
+		}
+		return { data: [...tokenMap.values()].map((t) => this.buildEntry(joinURL("/tokens", t.address), {
+			content: t,
+			meta: { kind: "ocap:token" }
+		})) };
+	}
+	async readStakeAssetsDir(ctx) {
+		return this.buildEntry(ctx.path, { meta: {
+			kind: "ocap:asset",
+			childrenCount: -1
+		} });
+	}
+	async listStakeAssets(ctx) {
+		const state = await this.source.getStakeState(ctx.params.addr);
+		if (!state) throw new AFSNotFoundError(ctx.path);
+		const stakedSet = new Set(state.assets ?? []);
+		const revokedSet = new Set(state.revokedAssets ?? []);
+		return { data: [...new Set([...stakedSet, ...revokedSet])].map((addr) => this.buildEntry(joinURL("/assets", addr), {
+			content: {
+				address: addr,
+				staked: stakedSet.has(addr) ? "Yes" : "",
+				revoked: revokedSet.has(addr) ? "Yes" : ""
+			},
+			meta: { kind: "ocap:asset" }
+		})) };
+	}
+	async listBridges(ctx) {
+		const paging = toPaging(listOpts(ctx), this.defaultPageSize);
+		const filters = extractBridgeFilters(listOpts(ctx));
+		const result = await this.source.listRollups(paging, filters);
+		return buildListResult(result.items.map((r) => ({
+			...this.buildEntry(joinURL("/bridges", r.address), {
+				content: {
+					...r,
+					_statusLabel: formatBridgeStatusLabel(r.closed, r.paused),
+					_statusColor: formatBridgeStatusColor(r.closed, r.paused)
+				},
+				meta: {
+					kind: "ocap:bridge",
+					childrenCount: 8
+				}
+			}),
+			summary: `${r.tokenAddress} bridge`
+		})), result.total);
+	}
+	async readBridge(ctx) {
+		const state = await this.source.getRollupState(ctx.params.address);
+		if (!state) throw new AFSNotFoundError(ctx.path);
+		return {
+			...this.buildEntry(ctx.path, {
+				content: {
+					...state,
+					tokenDecimal: state.tokenInfo?.decimal,
+					_statusLabel: formatBridgeStatusLabel(state.closed, state.paused),
+					_statusColor: formatBridgeStatusColor(state.closed, state.paused)
+				},
+				meta: {
+					kind: "ocap:bridge",
+					childrenCount: 8
+				}
+			}),
+			summary: `${state.tokenAddress} bridge`
+		};
+	}
+	async listBridgeChildren(ctx) {
+		if (ctx.params.address.startsWith(".")) throw new AFSNotFoundError(ctx.path);
+		return { data: [
+			buildDirEntry(ctx.path, "deposits"),
+			buildDirEntry(ctx.path, "withdrawals"),
+			buildDirEntry(ctx.path, "blocks"),
+			buildDirEntry(ctx.path, "nodes"),
+			buildDirEntry(ctx.path, "stakes"),
+			buildDirEntry(ctx.path, "governance"),
+			buildDirEntry(ctx.path, "slashes"),
+			buildDirEntry(ctx.path, "transactions")
+		] };
+	}
+	async readBridgeTxDir(ctx) {
+		return this.buildEntry(ctx.path, { meta: {
+			kind: "ocap:transaction",
+			childrenCount: -1
+		} });
+	}
+	async listBridgeTransactions(ctx) {
+		const paging = toPaging(listOpts(ctx), this.defaultPageSize);
+		const userFilters = extractTxFilters(listOpts(ctx));
+		const result = await this.source.listTransactions(paging, {
+			...userFilters,
+			rollupFilter: { rollups: [ctx.params.addr] }
+		});
+		return buildListResult(this.buildTxEntries(result), result.total);
+	}
+	async readBridgeStakeDir(ctx) {
+		return this.buildEntry(ctx.path, { meta: {
+			kind: "ocap:stake",
+			childrenCount: -1
+		} });
+	}
+	async listBridgeStakes(ctx) {
+		const paging = toPaging(listOpts(ctx), this.defaultPageSize);
+		const userFilters = extractStakeFilters(listOpts(ctx));
+		const result = await this.source.listStakes(paging, {
+			...userFilters,
+			addressFilter: {
+				...userFilters?.addressFilter,
+				receiver: ctx.params.addr
+			}
+		});
+		return buildListResult(result.items.map((s) => ({
+			...this.buildEntry(joinURL("/stakes", s.address), {
+				content: s,
+				meta: {
+					kind: "ocap:stake",
+					childrenCount: 3
+				}
+			}),
+			summary: `${s.sender} → ${s.receiver}`
+		})), result.total);
+	}
+	async readBridgeDepositsDir(ctx) {
+		return this.buildEntry(ctx.path, { meta: {
+			kind: "ocap:transaction",
+			childrenCount: -1
+		} });
+	}
+	async listBridgeDeposits(ctx) {
+		const paging = toPaging(listOpts(ctx), this.defaultPageSize);
+		const userFilters = extractTxFilters(listOpts(ctx));
+		const result = await this.source.listTransactions(paging, {
+			...userFilters,
+			rollupFilter: { rollups: [ctx.params.addr] },
+			typeFilter: { types: ["deposit_token_v2", "deposit_token"] }
+		});
+		return buildListResult(this.buildTxEntries(result), result.total);
+	}
+	async readBridgeWithdrawalsDir(ctx) {
+		return this.buildEntry(ctx.path, { meta: {
+			kind: "ocap:transaction",
+			childrenCount: -1
+		} });
+	}
+	async listBridgeWithdrawals(ctx) {
+		const paging = toPaging(listOpts(ctx), this.defaultPageSize);
+		const userFilters = extractTxFilters(listOpts(ctx));
+		const result = await this.source.listTransactions(paging, {
+			...userFilters,
+			rollupFilter: { rollups: [ctx.params.addr] },
+			typeFilter: { types: ["withdraw_token_v2", "withdraw_token"] }
+		});
+		return buildListResult(this.buildTxEntries(result), result.total);
+	}
+	async readBridgeGovernanceDir(ctx) {
+		return this.buildEntry(ctx.path, { meta: {
+			kind: "ocap:transaction",
+			childrenCount: -1
+		} });
+	}
+	async listBridgeGovernance(ctx) {
+		const paging = toPaging(listOpts(ctx), this.defaultPageSize);
+		const userFilters = extractTxFilters(listOpts(ctx));
+		const result = await this.source.listTransactions(paging, {
+			...userFilters,
+			rollupFilter: { rollups: [ctx.params.addr] },
+			typeFilter: { types: [
+				"create_rollup",
+				"update_rollup",
+				"pause_rollup",
+				"resume_rollup",
+				"close_rollup",
+				"migrate_rollup",
+				"join_rollup",
+				"leave_rollup"
+			] }
+		});
+		return buildListResult(this.buildTxEntries(result), result.total);
+	}
+	async readBridgeSlashesDir(ctx) {
+		return this.buildEntry(ctx.path, { meta: {
+			kind: "ocap:transaction",
+			childrenCount: -1
+		} });
+	}
+	async listBridgeSlashes(ctx) {
+		const paging = toPaging(listOpts(ctx), this.defaultPageSize);
+		const userFilters = extractTxFilters(listOpts(ctx));
+		const validators = (await this.source.getRollupState(ctx.params.addr).catch(() => null))?.validators ?? [];
+		if (validators.length === 0) return buildListResult([], 0);
+		const stakeAddrToValidator = /* @__PURE__ */ new Map();
+		for (const v of validators) {
+			if (!v.address) continue;
+			const stakeAddr = toStakeAddress(v.address, ctx.params.addr);
+			stakeAddrToValidator.set(stakeAddr, v.address);
+		}
+		const stakeAddrs = Array.from(stakeAddrToValidator.keys());
+		const result = await this.source.listTransactions(paging, {
+			...userFilters,
+			accountFilter: { accounts: stakeAddrs },
+			typeFilter: { types: ["claim_block_reward"] }
+		});
+		const slashEntries = [];
+		for (const tx of result.items) {
+			const receipts = tx.receipts ?? [];
+			let slashStakeAddr;
+			let slashAmount;
+			for (const r of receipts) {
+				const hit = (r.changes ?? []).find((c) => c.action === "slash");
+				if (hit) {
+					slashStakeAddr = r.address;
+					slashAmount = hit.value;
+					break;
+				}
+			}
+			if (!slashStakeAddr) continue;
+			const slashedNode = slashAmount ? slashAmount && stakeAddrToValidator.get(slashStakeAddr || "") || "" : "";
+			const itxJson = tx.tx?.itxJson || {};
+			const parties = resolveTxParties(tx);
+			if (parties.sender) tx.sender = parties.sender;
+			if (parties.receiver) tx.receiver = parties.receiver;
+			slashEntries.push({
+				...this.buildEntry(joinURL("/transactions", tx.hash), {
+					content: {
+						...tx,
+						...this.enrichTxContent(tx, itxJson),
+						_slashStakeAddress: slashStakeAddr,
+						_slashedNode: slashedNode,
+						_slashAmount: slashAmount,
+						_slashBlockHeight: itxJson.blockHeight,
+						_slashBlockHash: itxJson.blockHash
+					},
+					meta: { kind: tx.type ? `ocap:transaction:${tx.type}` : "ocap:transaction" }
+				}),
+				summary: `slash ${slashedNode}`
+			});
+		}
+		return buildListResult(slashEntries, result.total);
+	}
+	async readBridgeNodesDir(ctx) {
+		return this.buildEntry(ctx.path, { meta: {
+			kind: "ocap:rollup-node",
+			childrenCount: -1
+		} });
+	}
+	async listBridgeNodes(ctx) {
+		const paging = toPaging(listOpts(ctx), this.defaultPageSize);
+		const [result, rollupState] = await Promise.all([this.source.listRollupValidators(ctx.params.addr, paging), this.source.getRollupState(ctx.params.addr).catch(() => null)]);
+		const activeSet = new Set((rollupState?.validators || []).map((v) => v.address).filter((a) => typeof a === "string"));
+		return buildListResult(result.items.map((v) => {
+			const isActive = activeSet.has(v.address);
+			return {
+				...this.buildEntry(joinURL("/accounts", v.address), {
+					content: {
+						...v,
+						_isActive: isActive,
+						_status: isActive ? "Active" : "Inactive",
+						_statusColor: isActive ? {
+							main: "#0E7C5A",
+							light: "#E8F8F1"
+						} : {
+							main: "#92400E",
+							light: "#FEF3C7"
+						}
+					},
+					meta: { kind: "ocap:rollup-node" }
+				}),
+				summary: `${v.moniker || v.address} (${v.proposedBlockCount ?? 0} blocks)`
+			};
+		}), result.total);
+	}
+	async readBridgeBlocksDir(ctx) {
+		return this.buildEntry(ctx.path, { meta: {
+			kind: "ocap:rollup-block",
+			childrenCount: -1
+		} });
+	}
+	async metaBridgeBlocks(ctx) {
+		return this.buildEntry(ctx.path, { meta: {
+			kind: "ocap:rollup-block",
+			childrenCount: -1
+		} });
+	}
+	async listBridgeBlocks(ctx) {
+		const paging = toPaging(listOpts(ctx), this.defaultPageSize);
+		const result = await this.source.listRollupBlocks(ctx.params.addr, paging);
+		return buildListResult(this.buildBlockEntries(ctx.params.addr, result), result.total);
+	}
+	async readBridgeBlock(ctx) {
+		if (ctx.params.hash.startsWith(".")) throw new AFSNotFoundError(ctx.path);
+		const [block, rollup] = await Promise.all([this.source.getRollupBlock(ctx.params.hash, ctx.params.addr), this.source.getRollupState(ctx.params.addr).catch(() => null)]);
+		if (!block) throw new AFSNotFoundError(ctx.path);
+		return {
+			...this.buildEntry(ctx.path, {
+				content: {
+					...block,
+					tokenDecimal: rollup?.tokenInfo?.decimal
+				},
+				meta: { kind: "ocap:rollup-block" }
+			}),
+			summary: `Block #${block.height} • ${block.txs?.length ?? 0} txs`
+		};
+	}
+	async listDelegates(ctx) {
+		const paging = toPaging(listOpts(ctx), this.defaultPageSize);
+		const filters = extractDelegationFilters(listOpts(ctx));
+		const result = await this.source.listDelegations(paging, filters);
+		return buildListResult(result.items.map((d) => ({
+			...this.buildEntry(joinURL("/delegates", d.address), {
+				content: d,
+				meta: {
+					kind: "ocap:delegate",
+					childrenCount: 1
+				}
+			}),
+			summary: `${d.from} → ${d.to}`
+		})), result.total);
+	}
+	async readDelegate(ctx) {
+		const state = await this.source.getDelegateState(ctx.params.address);
+		if (!state) throw new AFSNotFoundError(ctx.path);
+		const content = {
+			...state,
+			dataJson: JSON.stringify(state.data ?? {}, null, 2),
+			opsCount: (state.ops || []).length
+		};
+		return {
+			...this.buildEntry(ctx.path, {
+				content,
+				meta: {
+					kind: "ocap:delegate",
+					childrenCount: 2
+				}
+			}),
+			summary: `${state.from} → ${state.to}`
+		};
+	}
+	async listDelegateChildren(ctx) {
+		if (ctx.params.address.startsWith(".")) throw new AFSNotFoundError(ctx.path);
+		return { data: [buildDirEntry(ctx.path, "transactions"), buildDirEntry(ctx.path, "permissions")] };
+	}
+	async readDelegateTxDir(ctx) {
+		return this.buildEntry(ctx.path, { meta: {
+			kind: "ocap:transaction",
+			childrenCount: -1
+		} });
+	}
+	async listDelegateTransactions(ctx) {
+		const paging = toPaging(listOpts(ctx), this.defaultPageSize);
+		const userFilters = extractTxFilters(listOpts(ctx));
+		const result = await this.source.listTransactions(paging, {
+			...userFilters,
+			delegationFilter: { delegations: [ctx.params.addr] }
+		});
+		return buildListResult(this.buildTxEntries(result), result.total);
+	}
+	async readDelegatePermissionsDir(ctx) {
+		return this.buildEntry(ctx.path, { meta: {
+			kind: "ocap:delegate_permission",
+			childrenCount: -1
+		} });
+	}
+	async listDelegatePermissions(ctx) {
+		const state = await this.source.getDelegateState(ctx.params.addr);
+		if (!state) throw new AFSNotFoundError(ctx.path);
+		return { data: (state.ops || []).map((op) => ({
+			...this.buildEntry(joinURL(ctx.path, encodeURIComponent(op.key)), {
+				content: {
+					typeUrl: op.key,
+					rule: op.value?.rule || "",
+					numTxs: op.value?.numTxs ?? 0,
+					numTxsDelta: op.value?.numTxsDelta ?? 0,
+					balance: op.value?.balance || "0",
+					balanceDelta: op.value?.balanceDelta || "0"
+				},
+				meta: { kind: "ocap:delegate_permission" }
+			}),
+			summary: op.key
+		})) };
+	}
+	async searchHandler(ctx, query, options) {
+		const paging = toPaging({
+			limit: options?.limit,
+			offset: options?.offset
+		}, this.defaultPageSize);
+		const result = await this.source.search(query, paging);
+		let items = result.items;
+		const scope = ctx.params.path?.split("/")[0];
+		if (scope) {
+			const allowedTypes = COLLECTION_TO_TYPES[scope];
+			if (allowedTypes) items = items.filter((r) => allowedTypes.includes(r.type));
+		}
+		return {
+			data: items.map((r) => ({
+				...this.buildEntry(joinURL("/", TYPE_TO_COLLECTION[r.type] ?? `${r.type}s`, r.id), {
+					content: r,
+					meta: {
+						kind: `ocap:${r.type}`,
+						...r.tags?.length ? { tags: r.tags } : {},
+						...r.timestamp ? { timestamp: r.timestamp } : {}
+					}
+				}),
+				summary: r.description || r.subtitle
+			})),
+			message: `Found ${result.total} results${result.hasNext ? " (more available)" : ""}`
+		};
+	}
+	async explainHandler(ctx) {
+		const normalizedPath = joinURL("/", ctx.params.path ?? "");
+		const format = ctx.options?.format || "markdown";
+		const segments = normalizedPath.split("/").filter(Boolean);
+		const lines = [];
+		if (format === "markdown") if (segments.length === 0) {
+			const info = await this.source.getChainInfo();
+			lines.push(`# ${info.moniker}`);
+			lines.push("");
+			lines.push(`**Chain ID:** ${info.id}`);
+			lines.push(`**Block Height:** ${info.blockHeight}`);
+			lines.push(`**Total Txs:** ${info.totalTxs}`);
+			lines.push(`**Synced:** ${info.synced}`);
+			lines.push("");
+			lines.push("## Available Paths");
+			for (const dir of TOP_LEVEL_DIRS) lines.push(`- \`/${dir}\``);
+		} else {
+			lines.push(`# ${normalizedPath}`);
+			lines.push("");
+			lines.push(`**Type:** ${segments[0]}`);
+			if (segments.length > 1) lines.push(`**ID:** ${segments[1]}`);
+		}
+		else if (segments.length === 0) {
+			const info = await this.source.getChainInfo();
+			lines.push(`${info.moniker} (chain)`);
+			lines.push(`Height: ${info.blockHeight}, Txs: ${info.totalTxs}`);
+		} else lines.push(`${normalizedPath} (${segments[0]})`);
+		return {
+			content: lines.join("\n"),
+			format
+		};
+	}
+	async readCollection(ctx) {
+		if (!TOP_LEVEL_DIRS.includes(ctx.params.collection)) throw new AFSNotFoundError(ctx.path);
+		return this.buildEntry(ctx.path, { meta: {
+			kind: collectionKind(ctx.params.collection),
+			childrenCount: -1
+		} });
+	}
+	async listCatchAll(ctx) {
+		const normalizedPath = joinURL("/", ctx.params.path ?? "");
+		if (normalizedPath === "/") return { data: TOP_LEVEL_DIRS.map((dir) => buildDirEntry("/", dir)) };
+		const segments = normalizedPath.split("/").filter(Boolean);
+		if (segments.length >= 1 && TOP_LEVEL_DIRS.includes(segments[0])) return { data: [] };
+		throw new AFSNotFoundError(normalizedPath);
+	}
+	async readCapabilities(_ctx) {
+		const operations = this.getOperationsDeclaration();
+		return this.buildEntry("/.meta/.capabilities", {
+			content: { operations },
+			meta: { kind: "afs:capabilities" }
+		});
+	}
+	async statHandler(ctx) {
+		const normalizedPath = joinURL("/", ctx.params.path ?? "");
+		const segments = normalizedPath.split("/").filter(Boolean);
+		if (segments.length >= 1 && !TOP_LEVEL_DIRS.includes(segments[0])) throw new AFSNotFoundError(ctx.path);
+		const meta = {};
+		if (segments.length === 0) {
+			meta.kind = "ocap:chain";
+			meta.childrenCount = TOP_LEVEL_DIRS.length;
+		} else if (segments.length === 1) {
+			meta.kind = collectionKind(segments[0]);
+			meta.childrenCount = -1;
+		} else meta.kind = collectionKind(segments[0]);
+		const { content: _, ...statData } = this.buildEntry(normalizedPath, { meta });
+		return { data: statData };
+	}
+	async metaHandler(ctx) {
+		const segments = joinURL("/", ctx.params.path ?? "").split("/").filter(Boolean);
+		if (segments.length >= 1 && !TOP_LEVEL_DIRS.includes(segments[0])) throw new AFSNotFoundError(ctx.path);
+		const meta = {};
+		if (segments.length === 0) {
+			meta.kind = "ocap:chain";
+			meta.childrenCount = TOP_LEVEL_DIRS.length;
+		} else if (segments.length === 1) {
+			meta.kind = collectionKind(segments[0]);
+			meta.childrenCount = -1;
+		} else meta.kind = collectionKind(segments[0]);
+		return this.buildEntry(ctx.path, { meta });
+	}
+};
+__decorate([Read("/")], AFSOCAP.prototype, "readRoot", null);
+__decorate([Read("/_microbar")], AFSOCAP.prototype, "readMicrobar", null);
+__decorate([Read("/config")], AFSOCAP.prototype, "readConfig", null);
+__decorate([List("/validators")], AFSOCAP.prototype, "listValidators", null);
+__decorate([Read("/validators/:address")], AFSOCAP.prototype, "readValidator", null);
+__decorate([List("/transactions")], AFSOCAP.prototype, "listTransactions", null);
+__decorate([Read("/transactions/:hash")], AFSOCAP.prototype, "readTransaction", null);
+__decorate([Read("/transactions/:hash/receipts")], AFSOCAP.prototype, "readTxReceiptsDir", null);
+__decorate([List("/transactions/:hash/receipts")], AFSOCAP.prototype, "listTxReceipts", null);
+__decorate([Read("/transactions/:hash/receipts/:idx")], AFSOCAP.prototype, "readTxReceiptEntry", null);
+__decorate([List("/accounts")], AFSOCAP.prototype, "listAccounts", null);
+__decorate([Read("/accounts/:address")], AFSOCAP.prototype, "readAccount", null);
+__decorate([List("/accounts/:address")], AFSOCAP.prototype, "listAccountChildren", null);
+__decorate([Read("/accounts/:addr/tokens")], AFSOCAP.prototype, "readAccountTokensDir", null);
+__decorate([Read("/accounts/:addr/assets")], AFSOCAP.prototype, "readAccountAssetsDir", null);
+__decorate([Read("/accounts/:addr/transactions")], AFSOCAP.prototype, "readAccountTxDir", null);
+__decorate([List("/accounts/:addr/tokens")], AFSOCAP.prototype, "listAccountTokens", null);
+__decorate([Meta("/accounts/:addr/tokens")], AFSOCAP.prototype, "metaAccountTokens", null);
+__decorate([Read("/accounts/:addr/tokens/:token")], AFSOCAP.prototype, "readAccountToken", null);
+__decorate([List("/accounts/:addr/assets")], AFSOCAP.prototype, "listAccountAssets", null);
+__decorate([List("/accounts/:addr/transactions")], AFSOCAP.prototype, "listAccountTransactions", null);
+__decorate([Read("/accounts/:addr/stakes")], AFSOCAP.prototype, "readAccountStakesDir", null);
+__decorate([List("/accounts/:addr/stakes")], AFSOCAP.prototype, "listAccountStakes", null);
+__decorate([Read("/accounts/:addr/stakes/sent")], AFSOCAP.prototype, "readAccountSentStakesDir", null);
+__decorate([List("/accounts/:addr/stakes/sent")], AFSOCAP.prototype, "listAccountSentStakes", null);
+__decorate([Read("/accounts/:addr/stakes/received")], AFSOCAP.prototype, "readAccountReceivedStakesDir", null);
+__decorate([List("/accounts/:addr/stakes/received")], AFSOCAP.prototype, "listAccountReceivedStakes", null);
+__decorate([Read("/accounts/:addr/migration")], AFSOCAP.prototype, "readAccountMigrationDir", null);
+__decorate([List("/accounts/:addr/migration")], AFSOCAP.prototype, "listAccountMigration", null);
+__decorate([Read("/accounts/:addr/token-flows")], AFSOCAP.prototype, "readAccountTokenFlowsDir", null);
+__decorate([List("/accounts/:addr/token-flows")], AFSOCAP.prototype, "listAccountTokenFlows", null);
+__decorate([Read("/accounts/:addr/delegates")], AFSOCAP.prototype, "readAccountDelegatesDir", null);
+__decorate([List("/accounts/:addr/delegates")], AFSOCAP.prototype, "listAccountDelegates", null);
+__decorate([List("/tokens")], AFSOCAP.prototype, "listTokens", null);
+__decorate([Read("/tokens/:address")], AFSOCAP.prototype, "readToken", null);
+__decorate([List("/tokens/:address")], AFSOCAP.prototype, "listTokenChildren", null);
+__decorate([Read("/tokens/:addr/price")], AFSOCAP.prototype, "readTokenPrice", null);
+__decorate([Read("/tokens/:addr/holders")], AFSOCAP.prototype, "readTokenHoldersDir", null);
+__decorate([List("/tokens/:addr/holders")], AFSOCAP.prototype, "listTokenHolders", null);
+__decorate([Read("/tokens/:addr/transactions")], AFSOCAP.prototype, "readTokenTxDir", null);
+__decorate([List("/tokens/:addr/transactions")], AFSOCAP.prototype, "listTokenTransactions", null);
+__decorate([List("/assets")], AFSOCAP.prototype, "listAssets", null);
+__decorate([Read("/assets/:address")], AFSOCAP.prototype, "readAsset", null);
+__decorate([List("/assets/:address")], AFSOCAP.prototype, "listAssetChildren", null);
+__decorate([Read("/assets/:addr/transactions")], AFSOCAP.prototype, "readAssetTxDir", null);
+__decorate([List("/assets/:addr/transactions")], AFSOCAP.prototype, "listAssetTransactions", null);
+__decorate([Read("/assets/:addr/stakes")], AFSOCAP.prototype, "readAssetStakesDir", null);
+__decorate([List("/assets/:addr/stakes")], AFSOCAP.prototype, "listAssetStakes", null);
+__decorate([List("/factories")], AFSOCAP.prototype, "listFactories", null);
+__decorate([Read("/factories/:address")], AFSOCAP.prototype, "readFactory", null);
+__decorate([List("/factories/:address")], AFSOCAP.prototype, "listFactoryChildren", null);
+__decorate([Read("/factories/:addr/assets")], AFSOCAP.prototype, "readFactoryAssetsDir", null);
+__decorate([List("/factories/:addr/assets")], AFSOCAP.prototype, "listFactoryAssets", null);
+__decorate([Read("/factories/:addr/transactions")], AFSOCAP.prototype, "readFactoryTxDir", null);
+__decorate([List("/factories/:addr/transactions")], AFSOCAP.prototype, "listFactoryTransactions", null);
+__decorate([List("/stakes")], AFSOCAP.prototype, "listStakes", null);
+__decorate([Read("/stakes/:address")], AFSOCAP.prototype, "readStake", null);
+__decorate([List("/stakes/:address")], AFSOCAP.prototype, "listStakeChildren", null);
+__decorate([Read("/stakes/:addr/transactions")], AFSOCAP.prototype, "readStakeTxDir", null);
+__decorate([List("/stakes/:addr/transactions")], AFSOCAP.prototype, "listStakeTransactions", null);
+__decorate([Read("/stakes/:addr/tokens")], AFSOCAP.prototype, "readStakeTokensDir", null);
+__decorate([List("/stakes/:addr/tokens")], AFSOCAP.prototype, "listStakeTokens", null);
+__decorate([Read("/stakes/:addr/assets")], AFSOCAP.prototype, "readStakeAssetsDir", null);
+__decorate([List("/stakes/:addr/assets")], AFSOCAP.prototype, "listStakeAssets", null);
+__decorate([List("/bridges")], AFSOCAP.prototype, "listBridges", null);
+__decorate([Read("/bridges/:address")], AFSOCAP.prototype, "readBridge", null);
+__decorate([List("/bridges/:address")], AFSOCAP.prototype, "listBridgeChildren", null);
+__decorate([Read("/bridges/:addr/transactions")], AFSOCAP.prototype, "readBridgeTxDir", null);
+__decorate([List("/bridges/:addr/transactions")], AFSOCAP.prototype, "listBridgeTransactions", null);
+__decorate([Read("/bridges/:addr/stakes")], AFSOCAP.prototype, "readBridgeStakeDir", null);
+__decorate([List("/bridges/:addr/stakes")], AFSOCAP.prototype, "listBridgeStakes", null);
+__decorate([Read("/bridges/:addr/deposits")], AFSOCAP.prototype, "readBridgeDepositsDir", null);
+__decorate([List("/bridges/:addr/deposits")], AFSOCAP.prototype, "listBridgeDeposits", null);
+__decorate([Read("/bridges/:addr/withdrawals")], AFSOCAP.prototype, "readBridgeWithdrawalsDir", null);
+__decorate([List("/bridges/:addr/withdrawals")], AFSOCAP.prototype, "listBridgeWithdrawals", null);
+__decorate([Read("/bridges/:addr/governance")], AFSOCAP.prototype, "readBridgeGovernanceDir", null);
+__decorate([List("/bridges/:addr/governance")], AFSOCAP.prototype, "listBridgeGovernance", null);
+__decorate([Read("/bridges/:addr/slashes")], AFSOCAP.prototype, "readBridgeSlashesDir", null);
+__decorate([List("/bridges/:addr/slashes")], AFSOCAP.prototype, "listBridgeSlashes", null);
+__decorate([Read("/bridges/:addr/nodes")], AFSOCAP.prototype, "readBridgeNodesDir", null);
+__decorate([List("/bridges/:addr/nodes")], AFSOCAP.prototype, "listBridgeNodes", null);
+__decorate([Read("/bridges/:addr/blocks")], AFSOCAP.prototype, "readBridgeBlocksDir", null);
+__decorate([Meta("/bridges/:addr/blocks")], AFSOCAP.prototype, "metaBridgeBlocks", null);
+__decorate([List("/bridges/:addr/blocks")], AFSOCAP.prototype, "listBridgeBlocks", null);
+__decorate([Read("/bridges/:addr/blocks/:hash")], AFSOCAP.prototype, "readBridgeBlock", null);
+__decorate([List("/delegates")], AFSOCAP.prototype, "listDelegates", null);
+__decorate([Read("/delegates/:address")], AFSOCAP.prototype, "readDelegate", null);
+__decorate([List("/delegates/:address")], AFSOCAP.prototype, "listDelegateChildren", null);
+__decorate([Read("/delegates/:addr/transactions")], AFSOCAP.prototype, "readDelegateTxDir", null);
+__decorate([List("/delegates/:addr/transactions")], AFSOCAP.prototype, "listDelegateTransactions", null);
+__decorate([Read("/delegates/:addr/permissions")], AFSOCAP.prototype, "readDelegatePermissionsDir", null);
+__decorate([List("/delegates/:addr/permissions")], AFSOCAP.prototype, "listDelegatePermissions", null);
+__decorate([Search("/:path*")], AFSOCAP.prototype, "searchHandler", null);
+__decorate([Explain("/:path*")], AFSOCAP.prototype, "explainHandler", null);
+__decorate([Read("/:collection")], AFSOCAP.prototype, "readCollection", null);
+__decorate([List("/:path*")], AFSOCAP.prototype, "listCatchAll", null);
+__decorate([Read("/.meta/.capabilities")], AFSOCAP.prototype, "readCapabilities", null);
+__decorate([Stat("/:path*")], AFSOCAP.prototype, "statHandler", null);
+__decorate([Meta("/:path*")], AFSOCAP.prototype, "metaHandler", null);
+var provider_default = AFSOCAP;
+
+//#endregion
+export { AFSOCAP, provider_default as default };
+//# sourceMappingURL=provider.mjs.map