@elizaos/agent 2.0.0-beta.2 → 2.0.11-beta.6

package/services/registry-client-local.js

@@ -0,0 +1,563 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { logger } from "@elizaos/core";
+import { packageNameToAppDisplayName } from "@elizaos/shared";
+import { isLegacyAppsWorkspaceDiscoveryEnabled } from "../config/feature-flags.js";
+import { resolveStateDir } from "../config/paths.js";
+import { readJsonFile } from "../utils/atomic-json.js";
+import { mergeAppMeta, resolveAppOverride, } from "./registry-client-app-meta.js";
+const LOCAL_PLUGIN_TAG_STOPWORDS = new Set([
+    "plugin",
+    "plugins",
+    "eliza",
+    "elizaos",
+    "eliza",
+    "elizaos-plugin",
+    "elizaos-plugins",
+    "feature",
+]);
+function uniquePaths(paths) {
+    const seen = new Set();
+    const ordered = [];
+    for (const p of paths) {
+        const resolved = path.resolve(p);
+        if (!seen.has(resolved)) {
+            seen.add(resolved);
+            ordered.push(resolved);
+        }
+    }
+    return ordered;
+}
+function resolveWorkspaceRoots() {
+    const envRoot = process.env.ELIZA_WORKSPACE_ROOT?.trim();
+    if (envRoot)
+        return uniquePaths([envRoot]);
+    const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+    const packageRoot = path.resolve(moduleDir, "..", "..");
+    const cwd = process.cwd();
+    const roots = [
+        packageRoot,
+        cwd,
+        path.resolve(cwd, ".."),
+        path.resolve(cwd, "..", ".."),
+    ].filter((candidate) => Boolean(candidate));
+    // Monorepos (e.g. Eliza) hoist `@elizaos/*` under the repo root, while this
+    // module lives in `packages/agent`. When the process cwd is deep (`apps/...`,
+    // Electrobun bundle, etc.), cwd-based roots never reach that `node_modules`.
+    // Walk up from the agent package so `getPluginInfo` can resolve vendored
+    // workspace plugins for install.
+    let walk = path.resolve(packageRoot);
+    for (let depth = 0; depth < 8; depth += 1) {
+        roots.push(walk);
+        const parent = path.dirname(walk);
+        if (parent === walk)
+            break;
+        walk = parent;
+    }
+    return uniquePaths(roots);
+}
+function isMissingPathError(err) {
+    return (err instanceof Error &&
+        "code" in err &&
+        ((err.code ?? "") === "ENOENT" ||
+            (err.code ?? "") === "ENOTDIR"));
+}
+async function readDirectoryEntries(dirPath, label, options = {}) {
+    try {
+        return await fs.readdir(dirPath, { withFileTypes: true });
+    }
+    catch (err) {
+        if (!(options.suppressMissing && isMissingPathError(err))) {
+            logger.debug(`[registry] could not read ${label} ${dirPath}: ${err}`);
+        }
+        return [];
+    }
+}
+function repoString(repo) {
+    if (!repo)
+        return null;
+    if (typeof repo === "string")
+        return repo;
+    if (typeof repo.url === "string" && repo.url.length > 0)
+        return repo.url;
+    return null;
+}
+function normaliseGitHubRepo(repo) {
+    if (!repo)
+        return null;
+    const cleaned = repo
+        .replace(/^git\+/, "")
+        .replace(/\.git$/, "")
+        .replace(/^https?:\/\/github\.com\//, "")
+        .replace(/^git@github\.com:/, "")
+        .trim();
+    if (!cleaned.includes("/"))
+        return null;
+    return cleaned;
+}
+function normalizeLocalTag(tag) {
+    const normalized = tag
+        .trim()
+        .toLowerCase()
+        .replace(/&/g, " and ")
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    if (!normalized || LOCAL_PLUGIN_TAG_STOPWORDS.has(normalized))
+        return null;
+    return normalized;
+}
+function normalizeLocalTags(values) {
+    if (!Array.isArray(values))
+        return [];
+    const tags = [];
+    const seen = new Set();
+    for (const value of values) {
+        if (typeof value !== "string")
+            continue;
+        const normalized = normalizeLocalTag(value);
+        if (!normalized || seen.has(normalized))
+            continue;
+        seen.add(normalized);
+        tags.push(normalized);
+    }
+    return tags;
+}
+function isLocalPluginPackage(packageJson) {
+    return (packageJson.packageType === "plugin" ||
+        packageJson.keywords?.includes("elizaos") ||
+        packageJson.elizaos !== undefined ||
+        packageJson.agentConfig !== undefined);
+}
+async function resolveLocalPackagePath(packageDir) {
+    try {
+        const realPath = await fs.realpath(packageDir);
+        return realPath !== packageDir ? realPath : packageDir;
+    }
+    catch {
+        return packageDir;
+    }
+}
+function toLocalAppMeta(app, fallbackDisplayName, legacy) {
+    if (!app && !legacy?.viewer && !legacy?.session)
+        return undefined;
+    const launchType = app?.launchType ?? (legacy?.viewer || legacy?.session ? "connect" : "url");
+    return {
+        displayName: app?.displayName ?? fallbackDisplayName,
+        category: app?.category ?? "game",
+        launchType,
+        launchUrl: app?.launchUrl ?? null,
+        icon: app?.icon ?? null,
+        heroImage: app?.heroImage ?? null,
+        capabilities: app?.capabilities ?? [],
+        minPlayers: app?.minPlayers ?? null,
+        maxPlayers: app?.maxPlayers ?? null,
+        runtimePlugin: app?.runtimePlugin,
+        bridgeExport: app?.bridgeExport,
+        uiExtension: app?.uiExtension,
+        viewer: app?.viewer ?? legacy?.viewer,
+        session: app?.session ?? legacy?.session,
+        developerOnly: app?.developerOnly,
+        visibleInAppStore: app?.visibleInAppStore,
+        mainTab: app?.mainTab,
+    };
+}
+function toDisplayNameFromDirName(dirName) {
+    return packageNameToAppDisplayName(dirName);
+}
+function isDiscoverableAppPackage(packageJson, manifest) {
+    if (!packageJson.name)
+        return false;
+    return Boolean(packageJson.elizaos?.kind === "app" ||
+        manifest?.kind === "app" ||
+        packageJson.elizaos?.app ||
+        packageJson.elizaos?.viewer ||
+        packageJson.elizaos?.session ||
+        manifest?.app ||
+        manifest?.viewer ||
+        manifest?.session ||
+        resolveAppOverride(packageJson.name, undefined));
+}
+async function collectWorkspacePackageCandidates(searchRoot, includeTypescriptChild = false) {
+    const candidates = new Map();
+    const entries = await readDirectoryEntries(searchRoot, "workspace dir", {
+        suppressMissing: true,
+    });
+    for (const entry of entries) {
+        if (!entry.isDirectory() && !entry.isSymbolicLink())
+            continue;
+        const repoDir = path.join(searchRoot, entry.name);
+        candidates.set(repoDir, {
+            packageDir: repoDir,
+            dirName: entry.name,
+        });
+        if (!includeTypescriptChild)
+            continue;
+        const typescriptDir = path.join(repoDir, "typescript");
+        candidates.set(typescriptDir, {
+            packageDir: typescriptDir,
+            dirName: entry.name,
+        });
+    }
+    return [...candidates.values()];
+}
+function parseRepositoryMetadata(repository) {
+    const repoValue = repoString(repository);
+    const gitRepo = normaliseGitHubRepo(repoValue) ?? "local/workspace";
+    return {
+        gitRepo,
+        gitUrl: `https://github.com/${gitRepo}.git`,
+    };
+}
+function buildDiscoveredEntry(packageDir, dirName, packageJson, manifest) {
+    if (!packageJson.name || packageJson.name.length === 0)
+        return null;
+    const packageAppMeta = toLocalAppMeta(packageJson.elizaos?.app, toDisplayNameFromDirName(dirName), {
+        viewer: packageJson.elizaos?.viewer,
+        session: packageJson.elizaos?.session,
+    });
+    const manifestAppMeta = toLocalAppMeta(manifest?.app, toDisplayNameFromDirName(dirName), {
+        viewer: manifest?.viewer,
+        session: manifest?.session,
+    });
+    const mergedMeta = mergeAppMeta(manifestAppMeta, packageAppMeta);
+    const overriddenMeta = resolveAppOverride(packageJson.name, mergedMeta);
+    const kind = packageJson.elizaos?.kind === "app" || manifest?.kind === "app"
+        ? "app"
+        : overriddenMeta
+            ? "app"
+            : undefined;
+    const repo = parseRepositoryMetadata(packageJson.repository ?? manifest?.repository);
+    const description = packageJson.description ?? manifest?.description ?? "";
+    const topics = normalizeLocalTags([
+        ...(packageJson.keywords ?? []),
+        ...(manifest?.tags ?? []),
+    ]);
+    const homepage = packageJson.homepage ??
+        manifest?.homepage ??
+        overriddenMeta?.launchUrl ??
+        null;
+    const version = packageJson.version ?? manifest?.version ?? null;
+    return {
+        name: packageJson.name,
+        gitRepo: repo.gitRepo,
+        gitUrl: repo.gitUrl,
+        description,
+        homepage,
+        topics,
+        stars: 0,
+        language: "TypeScript",
+        npm: {
+            package: packageJson.name,
+            v0Version: null,
+            v1Version: null,
+            v2Version: version,
+        },
+        git: {
+            v0Branch: null,
+            v1Branch: null,
+            v2Branch: "main",
+        },
+        supports: { v0: false, v1: false, v2: true },
+        localPath: packageDir,
+        kind,
+        appMeta: overriddenMeta ?? undefined,
+    };
+}
+async function discoverLocalWorkspaceApps() {
+    const discovered = new Map();
+    const packageCandidates = new Map();
+    for (const workspaceRoot of resolveWorkspaceRoots()) {
+        const discoveredRoots = new Map();
+        const addDiscoveredRoot = (root, includeTypescriptChild) => {
+            const resolvedRoot = path.resolve(root);
+            discoveredRoots.set(resolvedRoot, (discoveredRoots.get(resolvedRoot) ?? false) || includeTypescriptChild);
+        };
+        addDiscoveredRoot(path.join(workspaceRoot, "plugins"), true);
+        addDiscoveredRoot(path.join(workspaceRoot, "packages"), false);
+        addDiscoveredRoot(path.join(workspaceRoot, "eliza", "packages"), false);
+        addDiscoveredRoot(path.join(workspaceRoot, "eliza", "plugins"), true);
+        if (isLegacyAppsWorkspaceDiscoveryEnabled()) {
+            // Opt-in for older external workspaces that still keep app plugins
+            // under apps/app-*. The current repo discovers plugins/app-* by default.
+            addDiscoveredRoot(path.join(workspaceRoot, "apps"), false);
+            addDiscoveredRoot(path.join(workspaceRoot, "eliza", "apps"), false);
+        }
+        const workspaceEntries = await readDirectoryEntries(workspaceRoot, "workspace root");
+        for (const entry of workspaceEntries) {
+            if (!entry.isDirectory() || entry.name.startsWith(".")) {
+                continue;
+            }
+            const repoRoot = path.join(workspaceRoot, entry.name);
+            addDiscoveredRoot(path.join(repoRoot, "plugins"), true);
+            addDiscoveredRoot(path.join(repoRoot, "packages"), false);
+            addDiscoveredRoot(path.join(repoRoot, "eliza", "packages"), false);
+            addDiscoveredRoot(path.join(repoRoot, "eliza", "plugins"), true);
+            if (isLegacyAppsWorkspaceDiscoveryEnabled()) {
+                addDiscoveredRoot(path.join(repoRoot, "apps"), false);
+                addDiscoveredRoot(path.join(repoRoot, "eliza", "apps"), false);
+            }
+        }
+        for (const [root, includeTypescriptChild] of discoveredRoots) {
+            const candidates = await collectWorkspacePackageCandidates(root, includeTypescriptChild);
+            for (const candidate of candidates) {
+                packageCandidates.set(candidate.packageDir, candidate);
+            }
+        }
+    }
+    for (const { packageDir, dirName } of packageCandidates.values()) {
+        const packageJson = await readJsonFile(path.join(packageDir, "package.json"));
+        if (!packageJson)
+            continue;
+        const manifest = await readJsonFile(path.join(packageDir, "elizaos.plugin.json"));
+        if (!isDiscoverableAppPackage(packageJson, manifest))
+            continue;
+        const info = buildDiscoveredEntry(packageDir, dirName, packageJson, manifest);
+        if (info && !discovered.has(info.name)) {
+            discovered.set(info.name, info);
+        }
+    }
+    const stateDir = resolveStateDir();
+    const installedBase = path.join(stateDir, "plugins", "installed");
+    try {
+        const installedEntries = await fs.readdir(installedBase, {
+            withFileTypes: true,
+        });
+        for (const entry of installedEntries) {
+            if (!entry.isDirectory() && !entry.isSymbolicLink())
+                continue;
+            const installDir = path.join(installedBase, entry.name);
+            const nmDir = path.join(installDir, "node_modules");
+            const pkgDirs = [];
+            try {
+                const nmEntries = await fs.readdir(nmDir, { withFileTypes: true });
+                for (const nm of nmEntries) {
+                    if (nm.name.startsWith("@")) {
+                        const scopeDir = path.join(nmDir, nm.name);
+                        try {
+                            const scopeEntries = await fs.readdir(scopeDir, {
+                                withFileTypes: true,
+                            });
+                            for (const se of scopeEntries) {
+                                pkgDirs.push(path.join(scopeDir, se.name));
+                            }
+                        }
+                        catch (err) {
+                            logger.debug(`[registry] could not read scope dir ${scopeDir}: ${err}`);
+                        }
+                    }
+                    else if (nm.isDirectory() || nm.isSymbolicLink()) {
+                        pkgDirs.push(path.join(nmDir, nm.name));
+                    }
+                }
+            }
+            catch (err) {
+                logger.debug(`[registry] could not read node_modules dir ${nmDir}: ${err}`);
+                continue;
+            }
+            for (const pkgDir of pkgDirs) {
+                const pkgJson = await readJsonFile(path.join(pkgDir, "package.json"));
+                if (!pkgJson?.name)
+                    continue;
+                const manifest = await readJsonFile(path.join(pkgDir, "elizaos.plugin.json"));
+                if (!isDiscoverableAppPackage(pkgJson, manifest))
+                    continue;
+                if (discovered.has(pkgJson.name))
+                    continue;
+                const dirName = pkgJson.name
+                    .replace(/^@[^/]+\//, "")
+                    .replace(/^plugin-/, "app-");
+                const info = buildDiscoveredEntry(pkgDir, dirName, pkgJson, manifest);
+                if (info)
+                    discovered.set(info.name, info);
+            }
+        }
+    }
+    catch {
+        // installed dir may not exist
+    }
+    return discovered;
+}
+async function discoverNodeModulePlugins() {
+    const discovered = new Map();
+    for (const workspaceRoot of resolveWorkspaceRoots()) {
+        const elizaosDir = path.join(workspaceRoot, "node_modules", "@elizaos");
+        const entries = await readDirectoryEntries(elizaosDir, "@elizaos dir", {
+            suppressMissing: true,
+        });
+        for (const entry of entries) {
+            if (!entry.name.startsWith("plugin-"))
+                continue;
+            if (!entry.isDirectory() && !entry.isSymbolicLink())
+                continue;
+            const packageDir = path.join(elizaosDir, entry.name);
+            const packageJson = await readJsonFile(path.join(packageDir, "package.json"));
+            if (!packageJson?.name)
+                continue;
+            if (!isLocalPluginPackage(packageJson))
+                continue;
+            if (packageJson.elizaos?.kind === "app")
+                continue;
+            const repo = parseRepositoryMetadata(packageJson.repository);
+            const version = packageJson.version ?? null;
+            const localPath = await resolveLocalPackagePath(packageDir);
+            discovered.set(packageJson.name, {
+                name: packageJson.name,
+                gitRepo: repo.gitRepo,
+                gitUrl: repo.gitUrl,
+                description: packageJson.description ?? "",
+                homepage: packageJson.homepage ?? null,
+                topics: normalizeLocalTags(packageJson.keywords),
+                stars: 0,
+                language: "TypeScript",
+                npm: {
+                    package: packageJson.name,
+                    v0Version: null,
+                    v1Version: null,
+                    v2Version: version,
+                },
+                git: {
+                    v0Branch: null,
+                    v1Branch: null,
+                    v2Branch: "main",
+                },
+                supports: { v0: false, v1: false, v2: true },
+                localPath,
+            });
+        }
+    }
+    return discovered;
+}
+/** Workspace-vendored `packages/plugin-*` trees (not always linked under root node_modules). */
+async function discoverPackagesFolderPlugins() {
+    const discovered = new Map();
+    for (const workspaceRoot of resolveWorkspaceRoots()) {
+        const packagesDir = path.join(workspaceRoot, "packages");
+        const entries = await readDirectoryEntries(packagesDir, "packages dir", {
+            suppressMissing: true,
+        });
+        for (const entry of entries) {
+            if (!entry.name.startsWith("plugin-"))
+                continue;
+            if (!entry.isDirectory() && !entry.isSymbolicLink())
+                continue;
+            const packageDir = path.join(packagesDir, entry.name);
+            const packageJson = await readJsonFile(path.join(packageDir, "package.json"));
+            if (!packageJson?.name)
+                continue;
+            if (!isLocalPluginPackage(packageJson))
+                continue;
+            if (packageJson.elizaos?.kind === "app")
+                continue;
+            if (!packageJson.name.startsWith("@elizaos/plugin-"))
+                continue;
+            const repo = parseRepositoryMetadata(packageJson.repository);
+            const version = packageJson.version ?? null;
+            const localPath = await resolveLocalPackagePath(packageDir);
+            discovered.set(packageJson.name, {
+                name: packageJson.name,
+                gitRepo: repo.gitRepo,
+                gitUrl: repo.gitUrl,
+                description: packageJson.description ?? "",
+                homepage: packageJson.homepage ?? null,
+                topics: normalizeLocalTags(packageJson.keywords),
+                stars: 0,
+                language: "TypeScript",
+                npm: {
+                    package: packageJson.name,
+                    v0Version: null,
+                    v1Version: null,
+                    v2Version: version,
+                },
+                git: {
+                    v0Branch: null,
+                    v1Branch: null,
+                    v2Branch: "main",
+                },
+                supports: { v0: false, v1: false, v2: true },
+                localPath,
+            });
+        }
+    }
+    return discovered;
+}
+/**
+ * Local plugin discovery walks `node_modules/@elizaos` and the monorepo
+ * `packages/` folder. In very large / hoisted workspaces this can be slow, and
+ * it runs on every registry load — including the fallback taken when the remote
+ * registry is unreachable. Bound it so a slow scan degrades to "fewer local
+ * plugins" instead of stalling the whole catalog (`GET /api/apps`) past the
+ * HTTP request budget. The installable-app scan (`applyLocalWorkspaceApps`)
+ * runs separately and is intentionally not bounded here — it is what surfaces
+ * the catalog entries.
+ */
+const LOCAL_PLUGIN_SCAN_DEADLINE_MS = 6_000;
+async function withScanDeadline(task, fallback) {
+    let timer;
+    const deadline = new Promise((resolve) => {
+        timer = setTimeout(() => resolve(fallback), LOCAL_PLUGIN_SCAN_DEADLINE_MS);
+    });
+    try {
+        return await Promise.race([task, deadline]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+export async function applyNodeModulePlugins(plugins) {
+    const localPlugins = await withScanDeadline(discoverNodeModulePlugins(), new Map());
+    const packagesPlugins = await withScanDeadline(discoverPackagesFolderPlugins(), new Map());
+    for (const [name, info] of packagesPlugins) {
+        if (!localPlugins.has(name)) {
+            localPlugins.set(name, info);
+        }
+        else {
+            const existing = localPlugins.get(name);
+            if (existing && !existing.localPath && info.localPath) {
+                localPlugins.set(name, { ...existing, localPath: info.localPath });
+            }
+        }
+    }
+    if (localPlugins.size === 0)
+        return;
+    for (const [name, localInfo] of localPlugins.entries()) {
+        const existing = plugins.get(name);
+        if (!existing) {
+            plugins.set(name, localInfo);
+        }
+        else if (!existing.localPath) {
+            plugins.set(name, { ...existing, localPath: localInfo.localPath });
+        }
+    }
+}
+export async function applyLocalWorkspaceApps(plugins) {
+    const localApps = await discoverLocalWorkspaceApps();
+    if (localApps.size === 0)
+        return;
+    for (const [name, localInfo] of localApps.entries()) {
+        const existing = plugins.get(name);
+        if (!existing) {
+            plugins.set(name, localInfo);
+            continue;
+        }
+        plugins.set(name, {
+            ...existing,
+            localPath: localInfo.localPath,
+            kind: localInfo.kind ?? existing.kind,
+            appMeta: mergeAppMeta(existing.appMeta, localInfo.appMeta),
+            description: localInfo.description || existing.description,
+            homepage: localInfo.homepage ?? existing.homepage,
+            npm: {
+                ...existing.npm,
+                package: existing.npm.package || localInfo.npm.package,
+                v2Version: existing.npm.v2Version ?? localInfo.npm.v2Version,
+            },
+            git: {
+                v0Branch: existing.git.v0Branch ?? localInfo.git.v0Branch,
+                v1Branch: existing.git.v1Branch ?? localInfo.git.v1Branch,
+                v2Branch: existing.git.v2Branch ?? localInfo.git.v2Branch,
+            },
+        });
+    }
+}

package/services/registry-client-network.d.ts

@@ -0,0 +1,27 @@
+import type { RegistryPluginInfo } from "./registry-client-types.ts";
+export declare class RegistryNetworkFallbackError extends Error {
+    readonly expectedLocalFallback = true;
+    constructor(message: string);
+}
+export declare function isExpectedRegistryNetworkFallback(error: unknown): error is RegistryNetworkFallbackError;
+interface FetchFromNetworkParams {
+    generatedRegistryUrl: string;
+    indexRegistryUrl: string;
+    applyLocalWorkspaceApps: (plugins: Map<string, RegistryPluginInfo>) => Promise<void>;
+    applyNodeModulePlugins: (plugins: Map<string, RegistryPluginInfo>) => Promise<void>;
+    sanitizeSandbox: (value?: string) => string;
+}
+/**
+ * Resolve the plugin registry from the network, preferring the generated
+ * registry over the index registry.
+ *
+ * Both network attempts are issued concurrently so a doomed-offline boot
+ * waits out a single ~2.5s timeout instead of two sequential ones. The
+ * generated result still wins whenever it loads; the index result is only
+ * consulted (and its failure only surfaced) when the generated registry is
+ * absent. When the cloud is already known to be unreachable for this boot we
+ * skip both fetches entirely and go straight to the local-snapshot fallback.
+ */
+export declare function fetchFromNetwork(params: FetchFromNetworkParams): Promise<Map<string, RegistryPluginInfo>>;
+export {};
+//# sourceMappingURL=registry-client-network.d.ts.map

package/services/registry-client-network.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry-client-network.d.ts","sourceRoot":"","sources":["../../src/services/registry-client-network.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAIrE,qBAAa,4BAA6B,SAAQ,KAAK;IACrD,QAAQ,CAAC,qBAAqB,QAAQ;gBAE1B,OAAO,EAAE,MAAM;CAI5B;AAED,wBAAgB,iCAAiC,CAC/C,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,4BAA4B,CASvC;AAaD,UAAU,sBAAsB;IAC9B,oBAAoB,EAAE,MAAM,CAAC;IAC7B,gBAAgB,EAAE,MAAM,CAAC;IACzB,uBAAuB,EAAE,CACvB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC,KACrC,OAAO,CAAC,IAAI,CAAC,CAAC;IACnB,sBAAsB,EAAE,CACtB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC,KACrC,OAAO,CAAC,IAAI,CAAC,CAAC;IACnB,eAAe,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;CAC7C;AAgPD;;;;;;;;;;GAUG;AACH,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,sBAAsB,GAC7B,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC,CAmB1C"}