@aigne/afs-did-space 1.12.0-beta.5

package/dist/rsync.cjs

@@ -0,0 +1,400 @@
+const require_cid = require('./cid.cjs');
+const require_afs_metadata_context = require('./afs-metadata-context.cjs');
+const require_rsync_content = require('./rsync-content.cjs');
+
+//#region src/rsync.ts
+/**
+* Compute how many files to sample for verification.
+* Formula: max(1, min(100, ceil(totalTransferred / 10)))
+*/
+function computeSampleCount(totalTransferred) {
+	if (totalTransferred === 0) return 0;
+	return Math.max(1, Math.min(100, Math.ceil(totalTransferred / 10)));
+}
+/**
+* Select a random sample of `count` items from `files`.
+* Uses partial Fisher-Yates shuffle. Returns a copy.
+*/
+function sampleFiles(files, count) {
+	if (count >= files.length) return [...files];
+	const shuffled = [...files];
+	for (let i = 0; i < count; i++) {
+		const j = i + Math.floor(Math.random() * (shuffled.length - i));
+		[shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+	}
+	return shuffled.slice(0, count);
+}
+/** Content-decoding helpers shared with the local metadata subscriber. */
+const resolveContent = require_rsync_content.resolveAFSContent;
+/**
+* Fetch a file manifest from a remote server's POST /api/space/manifest endpoint.
+*
+* This replaces the N-request paginated list + per-file CID read with a single
+* request that returns the complete manifest directly from the server's D1 index.
+*
+* @param baseUrl    Server base URL (e.g. "https://computer.afsd.dev")
+* @param authHeader Authorization header value (e.g. "Bearer <token>")
+* @param basePath   Path within the space (e.g. "/" or "/blocklets/z1blk/")
+* @param since      Optional: only return files modified after this ms timestamp
+* @param fetchFn    Optional fetch override (for testing)
+*/
+async function fetchRemoteManifest(baseUrl, authHeader, basePath, since, fetchFn = globalThis.fetch) {
+	const url = `${baseUrl.replace(/\/$/, "")}/api/space/manifest`;
+	const body = { basePath };
+	if (since !== void 0) body.since = since;
+	const response = await fetchFn(url, {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			Authorization: authHeader
+		},
+		body: JSON.stringify(body)
+	});
+	if (!response.ok) throw new Error(`fetchRemoteManifest failed: ${response.status} ${response.statusText} from ${url}`);
+	const raw = await response.json();
+	const files = raw.entries ?? raw.files ?? [];
+	return {
+		files,
+		entries: files,
+		manifestSeq: raw.manifestSeq,
+		createdAt: raw.createdAt
+	};
+}
+const BUILD_MANIFEST_PAGE_SIZE = 1e3;
+async function buildManifest(afs, basePath, options) {
+	if (options?.fetchManifest) return options.fetchManifest(basePath, options.since);
+	if (options?.localMetadataDb && options.localRootPath && options.localScope) return buildManifestFromDB(options.localMetadataDb, options.localRootPath, options.localScope, basePath);
+	if (!options?.skipLocalMetadataDb) {
+		const ctx = require_afs_metadata_context.getMetadataContext(afs);
+		if (ctx) return buildManifestFromDB(ctx.metadataDb, ctx.userDir, ctx.scope, basePath);
+	}
+	const SYSTEM_VIRTUAL_PATHS = new Set([
+		"/.knowledge",
+		"/.meta",
+		"/.actions"
+	]);
+	const allEntries = [];
+	let offset = 0;
+	let pageEntries = [];
+	do {
+		const batch = await afs.list(basePath, {
+			maxDepth: 99,
+			limit: BUILD_MANIFEST_PAGE_SIZE,
+			offset
+		});
+		pageEntries = basePath === "/" ? batch.data.filter((e) => !SYSTEM_VIRTUAL_PATHS.has(e.path)) : batch.data;
+		allEntries.push(...pageEntries);
+		offset += pageEntries.length;
+	} while (pageEntries.length === BUILD_MANIFEST_PAGE_SIZE);
+	const files = [];
+	for (const entry of allEntries) {
+		if (entry.meta?.childrenCount != null) continue;
+		let cid = entry.meta?.cid;
+		if (!cid) try {
+			const readResult = await afs.read(entry.path);
+			const content = readResult.data?.content;
+			if (content != null) cid = await require_cid.computeCID(resolveContent(content, readResult.data?.meta));
+		} catch {}
+		files.push({
+			path: entry.path,
+			size: entry.meta?.size ?? 0,
+			cid,
+			mtime: entry.updatedAt?.getTime()
+		});
+	}
+	return {
+		files,
+		createdAt: Date.now()
+	};
+}
+function computeDiff(src, dst, options) {
+	const dstMap = /* @__PURE__ */ new Map();
+	for (const f of dst.files) dstMap.set(f.path, f);
+	const entries = [];
+	let added = 0;
+	let modified = 0;
+	let unchanged = 0;
+	const seenPaths = /* @__PURE__ */ new Set();
+	for (const srcFile of src.files) {
+		seenPaths.add(srcFile.path);
+		const dstFile = dstMap.get(srcFile.path);
+		if (!dstFile) {
+			entries.push({
+				path: srcFile.path,
+				reason: "added"
+			});
+			added++;
+			continue;
+		}
+		if (isModified(srcFile, dstFile)) {
+			entries.push({
+				path: srcFile.path,
+				reason: "modified"
+			});
+			modified++;
+		} else unchanged++;
+	}
+	let deleted = 0;
+	if (options?.delete) {
+		for (const dstFile of dst.files) if (!seenPaths.has(dstFile.path)) {
+			entries.push({
+				path: dstFile.path,
+				reason: "deleted"
+			});
+			deleted++;
+		}
+	}
+	return {
+		entries,
+		stats: {
+			added,
+			modified,
+			deleted,
+			unchanged
+		}
+	};
+}
+function isModified(src, dst) {
+	if (src.cid && dst.cid) return src.cid !== dst.cid;
+	return src.size !== dst.size;
+}
+async function transferFiles(srcAfs, dstAfs, diff, options) {
+	const concurrency = options?.concurrency ?? 5;
+	const dryRun = options?.dryRun ?? false;
+	const errors = [];
+	let transferred = 0;
+	let sessionId = null;
+	const completedPaths = /* @__PURE__ */ new Set();
+	const checkpointOpts = options?.checkpointOptions;
+	if (checkpointOpts && !dryRun) {
+		const { metadataDb, direction, remoteUrl, basePath } = checkpointOpts;
+		const existing = await metadataDb.getActiveCheckpoint(direction, remoteUrl, basePath);
+		if (existing) {
+			sessionId = existing.session_id;
+			try {
+				const parsed = JSON.parse(existing.completed);
+				if (Array.isArray(parsed)) {
+					for (const p of parsed) if (typeof p === "string") completedPaths.add(p);
+				}
+			} catch {
+				await metadataDb.updateCheckpointCompleted(sessionId, []);
+			}
+		} else {
+			sessionId = crypto.randomUUID();
+			await metadataDb.createCheckpoint({
+				session_id: sessionId,
+				direction,
+				remote_url: remoteUrl,
+				base_path: basePath,
+				status: "active",
+				diff_json: JSON.stringify(diff.entries),
+				completed: "[]",
+				created_at: Date.now(),
+				updated_at: Date.now()
+			});
+		}
+	}
+	const progress = {
+		phase: "transferring",
+		filesTotal: diff.entries.length,
+		filesProcessed: 0,
+		bytesTotal: 0,
+		bytesTransferred: 0,
+		errors: [],
+		startedAt: Date.now(),
+		updatedAt: Date.now()
+	};
+	const toTransfer = diff.entries.filter((e) => e.reason === "added" || e.reason === "modified");
+	const toDelete = diff.entries.filter((e) => e.reason === "deleted");
+	const transferOne = async (entry) => {
+		if (completedPaths.has(entry.path)) {
+			transferred++;
+			progress.filesProcessed++;
+			progress.updatedAt = Date.now();
+			options?.onProgress?.(progress);
+			return;
+		}
+		try {
+			if (dryRun) return;
+			const readResult = await srcAfs.read(entry.path);
+			const rawContent = readResult.data?.content;
+			if (rawContent == null) throw new Error(`Failed to read ${entry.path}: no content`);
+			const content = resolveContent(rawContent, readResult.data?.meta);
+			await dstAfs.write(entry.path, { content });
+			transferred++;
+			progress.bytesTransferred += readResult.data?.meta?.size ?? 0;
+			if (sessionId && checkpointOpts) {
+				completedPaths.add(entry.path);
+				await checkpointOpts.metadataDb.updateCheckpointCompleted(sessionId, [...completedPaths]);
+			}
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			errors.push({
+				path: entry.path,
+				error: msg
+			});
+		} finally {
+			progress.filesProcessed++;
+			progress.updatedAt = Date.now();
+			progress.errors = [...errors];
+			options?.onProgress?.(progress);
+		}
+	};
+	await runWithConcurrency(toTransfer.map((e) => () => transferOne(e)), concurrency);
+	for (const entry of toDelete) {
+		if (dryRun) continue;
+		try {
+			await dstAfs.delete(entry.path);
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			errors.push({
+				path: entry.path,
+				error: msg
+			});
+		} finally {
+			progress.filesProcessed++;
+			progress.updatedAt = Date.now();
+			progress.errors = [...errors];
+			options?.onProgress?.(progress);
+		}
+	}
+	if (sessionId && checkpointOpts) await checkpointOpts.metadataDb.completeCheckpoint(sessionId);
+	return {
+		transferred,
+		errors
+	};
+}
+async function runWithConcurrency(tasks, limit) {
+	const executing = /* @__PURE__ */ new Set();
+	for (const task of tasks) {
+		const p = task().then(() => {
+			executing.delete(p);
+		});
+		executing.add(p);
+		if (executing.size >= limit) await Promise.race(executing);
+	}
+	await Promise.all(executing);
+}
+/**
+* Verify sync by sampling transferred files and comparing CIDs.
+*
+* Phase 3 change: instead of full buildManifest on dst, we sample
+* max(1, min(100, ceil(transferred/10))) files from the transferred set,
+* read each from dst, compute its CID, and compare against srcManifest CID.
+*
+* @param dstAfs          Destination AFS to read files from
+* @param transferredFiles FileFingerprints from srcManifest for transferred files
+*/
+async function verifySync(dstAfs, transferredFiles) {
+	if (transferredFiles.length === 0) return true;
+	const sample = sampleFiles(transferredFiles, computeSampleCount(transferredFiles.length));
+	for (const srcFile of sample) {
+		if (!srcFile.cid) continue;
+		try {
+			const readResult = await dstAfs.read(srcFile.path);
+			const rawContent = readResult.data?.content;
+			if (rawContent == null) return false;
+			if (await require_cid.computeCID(resolveContent(rawContent, readResult.data?.meta)) !== srcFile.cid) return false;
+		} catch {
+			return false;
+		}
+	}
+	return true;
+}
+async function syncDIDSpace(srcAfs, dstAfs, basePath, options) {
+	const startTime = Date.now();
+	const verify = options?.verify ?? true;
+	const progress = {
+		phase: "scanning",
+		filesTotal: 0,
+		filesProcessed: 0,
+		bytesTotal: 0,
+		bytesTransferred: 0,
+		errors: [],
+		startedAt: startTime,
+		updatedAt: startTime
+	};
+	options?.onProgress?.(progress);
+	let [srcManifest, dstManifest] = await Promise.all([buildManifest(srcAfs, basePath, options?.srcFetchManifest ? { fetchManifest: options.srcFetchManifest } : void 0), buildManifest(dstAfs, basePath, options?.dstFetchManifest ? { fetchManifest: options.dstFetchManifest } : void 0)]);
+	if (options?.pathFilter) {
+		const pf = options.pathFilter;
+		srcManifest = {
+			...srcManifest,
+			files: srcManifest.files.filter((f) => pf(f.path))
+		};
+		dstManifest = {
+			...dstManifest,
+			files: dstManifest.files.filter((f) => pf(f.path))
+		};
+	}
+	progress.phase = "diffing";
+	progress.updatedAt = Date.now();
+	options?.onProgress?.(progress);
+	const diff = computeDiff(srcManifest, dstManifest, options);
+	progress.phase = "transferring";
+	progress.filesTotal = diff.entries.filter((e) => e.reason !== "deleted").length;
+	progress.updatedAt = Date.now();
+	options?.onProgress?.(progress);
+	const { transferred, errors } = await transferFiles(srcAfs, dstAfs, diff, options);
+	let verified = false;
+	if (verify && !options?.dryRun) {
+		progress.phase = "verifying";
+		progress.updatedAt = Date.now();
+		options?.onProgress?.(progress);
+		const transferredPaths = new Set(diff.entries.filter((e) => e.reason === "added" || e.reason === "modified").map((e) => e.path));
+		verified = await verifySync(dstAfs, srcManifest.files.filter((f) => transferredPaths.has(f.path)));
+	}
+	progress.phase = errors.length > 0 ? "failed" : "done";
+	progress.updatedAt = Date.now();
+	options?.onProgress?.(progress);
+	return {
+		success: errors.length === 0,
+		diff,
+		transferred,
+		verified,
+		errors,
+		durationMs: Date.now() - startTime
+	};
+}
+/**
+* Build a manifest purely from `_metadata.db` (the index is the source of
+* truth after the Node backend moved to content-addressed storage, Phase 3).
+*
+* The old `reconcile({ rootPath })` FS-scan prelude is GONE: there is no
+* verbatim file tree to walk anymore — content lives at `objects/{cid}` and the
+* index already reflects every write (the provider writes entries atomically).
+* Reconciling against the CAS layout would mis-scan internal object files.
+* `rootPath` is retained in the signature for caller compatibility but unused.
+*/
+async function buildManifestFromDB(metadataDb, _rootPath, scope, basePath) {
+	const dbBasePath = afsBasePathToDbPrefix(basePath);
+	return {
+		files: (await metadataDb.getFiles(scope, dbBasePath)).map((row) => ({
+			path: `/${row.path}`,
+			size: row.size,
+			cid: row.cid ?? void 0,
+			mtime: row.mtime
+		})),
+		createdAt: Date.now()
+	};
+}
+/**
+* Convert an AFS basePath to a MetadataDB path prefix.
+*
+* Examples:
+*   "/"          → undefined (match all)
+*   "/appDid"    → "appDid/"
+*   "/appDid/"   → "appDid/"
+*/
+function afsBasePathToDbPrefix(basePath) {
+	const stripped = basePath.replace(/^\/+/, "").replace(/\/*$/, "");
+	if (!stripped) return void 0;
+	return `${stripped}/`;
+}
+
+//#endregion
+exports.buildManifest = buildManifest;
+exports.computeDiff = computeDiff;
+exports.fetchRemoteManifest = fetchRemoteManifest;
+exports.runWithConcurrency = runWithConcurrency;
+exports.syncDIDSpace = syncDIDSpace;

package/dist/rsync.d.cts

@@ -0,0 +1,157 @@
+import { MetadataDB } from "./metadata-db.cjs";
+import { AFS } from "@aigne/afs";
+
+//#region src/rsync.d.ts
+interface FileFingerprint {
+  path: string;
+  size: number;
+  cid?: string;
+  mtime?: number;
+}
+interface SyncManifest {
+  /**
+   * Legacy file list field — kept REQUIRED for backward compatibility
+   * with existing consumers (rsync.ts pipeline, computeDiff, e2e tests).
+   *
+   * Task 3.2: as of the G5.b manifest endpoint rewrite, the server now
+   * also returns this same data under the `entries` field plus a fresh
+   * `manifestSeq` cursor. New code should prefer `entries` + `manifestSeq`
+   * but reading `files` continues to work — both arrays carry identical
+   * data, they are two views of the same underlying snapshot.
+   */
+  files: FileFingerprint[];
+  /**
+   * Task 3.2 — canonical "entries" view of the same data as `files`.
+   * Optional because clients constructing a manifest locally (e.g.
+   * `buildManifestFromDB`) may omit it; the wire format from the server
+   * always includes it.
+   */
+  entries?: FileFingerprint[];
+  /**
+   * Task 3.2 — server-provided changelog cursor at the moment the
+   * manifest was assembled. After reading the manifest a client can
+   * call `GET /sync/changes?since=manifestSeq` to fetch all subsequent
+   * deltas without missing or replaying entries (CTE single-shot
+   * snapshot — entries and manifestSeq come from the same point-in-time
+   * read).
+   *
+   * Optional because client-constructed manifests have no server seq.
+   * 0 is a valid value (empty changelog == nothing has been written
+   * to this scope yet).
+   */
+  manifestSeq?: number;
+  createdAt: number;
+}
+interface SyncDiffEntry {
+  path: string;
+  reason: "added" | "modified" | "deleted";
+}
+interface SyncDiff {
+  entries: SyncDiffEntry[];
+  stats: {
+    added: number;
+    modified: number;
+    deleted: number;
+    unchanged: number;
+  };
+}
+interface SyncProgress {
+  phase: "scanning" | "diffing" | "transferring" | "verifying" | "done" | "failed";
+  filesTotal: number;
+  filesProcessed: number;
+  bytesTotal: number;
+  bytesTransferred: number;
+  errors: Array<{
+    path: string;
+    error: string;
+  }>;
+  startedAt: number;
+  updatedAt: number;
+}
+interface SyncResult {
+  success: boolean;
+  diff: SyncDiff;
+  transferred: number;
+  verified: boolean;
+  errors: Array<{
+    path: string;
+    error: string;
+  }>;
+  durationMs: number;
+}
+interface SyncOptions {
+  delete?: boolean;
+  dryRun?: boolean;
+  verify?: boolean;
+  concurrency?: number;
+  onProgress?: (progress: SyncProgress) => void;
+  /** Filter function to exclude paths from sync. Return true to include. */
+  pathFilter?: (path: string) => boolean;
+  /**
+   * If provided, fetch the src manifest from a remote server endpoint instead of
+   * paginating through srcAfs. Useful when the remote side has a manifest endpoint.
+   */
+  srcFetchManifest?: (basePath: string, since?: number) => Promise<SyncManifest>;
+  /**
+   * If provided, fetch the dst manifest from a remote server endpoint instead of
+   * paginating through dstAfs. Useful when the remote side has a manifest endpoint.
+   */
+  dstFetchManifest?: (basePath: string, since?: number) => Promise<SyncManifest>;
+  /**
+   * Phase 3: If provided, enable checkpoint-based resume-on-failure.
+   * transferFiles() will persist progress to sync_checkpoint table and resume
+   * from the last completed file if interrupted.
+   */
+  checkpointOptions?: {
+    metadataDb: MetadataDB;
+    direction: string;
+    remoteUrl: string;
+    basePath: string;
+  };
+}
+interface BuildManifestOptions {
+  /**
+   * If provided, fetch manifest from a remote server endpoint instead of
+   * paginating through the AFS. The `afs` parameter is unused when this is set.
+   */
+  fetchManifest?: (basePath: string, since?: number) => Promise<SyncManifest>;
+  /** Only return files modified after this timestamp (ms). Passed to fetchManifest. */
+  since?: number;
+  /**
+   * Phase 2: If provided (together with localRootPath + localScope), build the
+   * manifest by calling reconcile() then querying _metadata.db directly.
+   * This replaces the O(N) full stat+read+CID scan with an O(1) SQL query.
+   */
+  localMetadataDb?: MetadataDB;
+  /** Root directory of the user's DID space (required when localMetadataDb is set). */
+  localRootPath?: string;
+  /** userDid / scope for the entries query (required when localMetadataDb is set). */
+  localScope?: string;
+  /**
+   * Task 1.3: explicit opt-out — skip both the explicit DB params and the
+   * metadata context attached by DIDSpace, and fall through to the legacy
+   * AFS pagination path. Used for back-compat testing + rare callers that
+   * must re-scan the filesystem from scratch.
+   */
+  skipLocalMetadataDb?: boolean;
+}
+/**
+ * Fetch a file manifest from a remote server's POST /api/space/manifest endpoint.
+ *
+ * This replaces the N-request paginated list + per-file CID read with a single
+ * request that returns the complete manifest directly from the server's D1 index.
+ *
+ * @param baseUrl    Server base URL (e.g. "https://computer.afsd.dev")
+ * @param authHeader Authorization header value (e.g. "Bearer <token>")
+ * @param basePath   Path within the space (e.g. "/" or "/blocklets/z1blk/")
+ * @param since      Optional: only return files modified after this ms timestamp
+ * @param fetchFn    Optional fetch override (for testing)
+ */
+declare function fetchRemoteManifest(baseUrl: string, authHeader: string, basePath: string, since?: number, fetchFn?: typeof globalThis.fetch): Promise<SyncManifest>;
+declare function buildManifest(afs: AFS, basePath: string, options?: BuildManifestOptions): Promise<SyncManifest>;
+declare function computeDiff(src: SyncManifest, dst: SyncManifest, options?: Pick<SyncOptions, "delete">): SyncDiff;
+declare function runWithConcurrency(tasks: Array<() => Promise<void>>, limit: number): Promise<void>;
+declare function syncDIDSpace(srcAfs: AFS, dstAfs: AFS, basePath: string, options?: SyncOptions): Promise<SyncResult>;
+//#endregion
+export { BuildManifestOptions, FileFingerprint, SyncDiff, SyncDiffEntry, SyncManifest, SyncOptions, SyncProgress, SyncResult, buildManifest, computeDiff, fetchRemoteManifest, runWithConcurrency, syncDIDSpace };
+//# sourceMappingURL=rsync.d.cts.map

package/dist/rsync.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rsync.d.cts","names":[],"sources":["../src/rsync.ts"],"mappings":";;;;UAuCiB,eAAA;EACf,IAAA;EACA,IAAA;EACA,GAAA;EACA,KAAA;AAAA;AAAA,UAGe,YAAA;EAgCN;;AAGX;;;;;AAKA;;;EA7BE,KAAA,EAAO,eAAA;EA8BP;;;;;;EAvBA,OAAA,GAAU,eAAA;EAwB0D;;AAGtE;;;;;;;;;;EAdE,WAAA;EACA,SAAA;AAAA;AAAA,UAGe,aAAA;EACf,IAAA;EACA,MAAA;AAAA;AAAA,UAGe,QAAA;EACf,OAAA,EAAS,aAAA;EACT,KAAA;IAAS,KAAA;IAAe,QAAA;IAAkB,OAAA;IAAiB,SAAA;EAAA;AAAA;AAAA,UAG5C,YAAA;EACf,KAAA;EACA,UAAA;EACA,cAAA;EACA,UAAA;EACA,gBAAA;EACA,MAAA,EAAQ,KAAA;IAAQ,IAAA;IAAc,KAAA;EAAA;EAC9B,SAAA;EACA,SAAA;AAAA;AAAA,UAGe,UAAA;EACf,OAAA;EACA,IAAA,EAAM,QAAA;EACN,WAAA;EACA,QAAA;EACA,MAAA,EAAQ,KAAA;IAAQ,IAAA;IAAc,KAAA;EAAA;EAC9B,UAAA;AAAA;AAAA,UAGe,WAAA;EACf,MAAA;EACA,MAAA;EACA,MAAA;EACA,WAAA;EACA,UAAA,IAAc,QAAA,EAAU,YAAA;EAOiC;EALzD,UAAA,IAAc,IAAA;EAUd;;;;EALA,gBAAA,IAAoB,QAAA,UAAkB,KAAA,cAAmB,OAAA,CAAQ,YAAA;EAWjE;;;;EANA,gBAAA,IAAoB,QAAA,UAAkB,KAAA,cAAmB,OAAA,CAAQ,YAAA;EAU/D;;;AAIJ;;EARE,iBAAA;IACE,UAAA,EAAY,UAAA;IACZ,SAAA;IACA,SAAA;IACA,QAAA;EAAA;AAAA;AAAA,UAIa,oBAAA;EAKoB;;;;EAAnC,aAAA,IAAiB,QAAA,UAAkB,KAAA,cAAmB,OAAA,CAAQ,YAAA;EAQ5C;EANlB,KAAA;EAUA;;;;AA6BF;EAjCE,eAAA,GAAkB,UAAA;;EAElB,aAAA;EAqCS;EAnCT,UAAA;EAmCQ;;;;;;EA5BR,mBAAA;AAAA;;;;;;AAoEF;;;;;;;iBA9CsB,mBAAA,CACpB,OAAA,UACA,UAAA,UACA,QAAA,UACA,KAAA,WACA,OAAA,UAAgB,UAAA,CAAW,KAAA,GAC1B,OAAA,CAAQ,YAAA;AAAA,iBAwCW,aAAA,CACpB,GAAA,EAAK,GAAA,EACL,QAAA,UACA,OAAA,GAAU,oBAAA,GACT,OAAA,CAAQ,YAAA;AAAA,iBAwFK,WAAA,CACd,GAAA,EAAK,YAAA,EACL,GAAA,EAAK,YAAA,EACL,OAAA,GAAU,IAAA,CAAK,WAAA,cACd,QAAA;AAAA,iBA4LmB,kBAAA,CACpB,KAAA,EAAO,KAAA,OAAY,OAAA,SACnB,KAAA,WACC,OAAA;AAAA,iBAyDmB,YAAA,CACpB,MAAA,EAAQ,GAAA,EACR,MAAA,EAAQ,GAAA,EACR,QAAA,UACA,OAAA,GAAU,WAAA,GACT,OAAA,CAAQ,UAAA"}