@ggui-ai/registry-core 0.6.3 → 0.8.0

package/dist/ops/register-author-key.js

@@ -40,6 +40,8 @@ import { derivePublicKeyId } from '@ggui-ai/gadget-signing';
 import { AuthorKeyAlreadyExistsError, } from '../interfaces/registry-storage.js';
 import { safeBase64Decode } from '../utils/base64.js';
 const ED25519_PUBLIC_KEY_BYTES = 32;
+/** Display-name budget — a label is a short human hint, not a document. */
+export const MAX_LABEL_LENGTH = 100;
 export async function registerAuthorKey(input, deps) {
     if (typeof input.publicKeyBase64 !== 'string' ||
         input.publicKeyBase64.length === 0) {
@@ -73,12 +75,42 @@ export async function registerAuthorKey(input, deps) {
             },
         };
     }
+    // Label ([E] enrichment) — defend with a typeof check even though the
+    // input type says string (transports hand over parsed JSON); trim;
+    // whitespace-only collapses to absent.
+    if (input.label !== undefined && typeof input.label !== 'string') {
+        return {
+            ok: false,
+            status: 400,
+            body: {
+                error: 'invalid_request',
+                message: '`label` must be a string',
+            },
+        };
+    }
+    const trimmedLabel = input.label?.trim();
+    const label = trimmedLabel !== undefined && trimmedLabel.length > 0
+        ? trimmedLabel
+        : undefined;
+    if (label !== undefined && label.length > MAX_LABEL_LENGTH) {
+        return {
+            ok: false,
+            status: 400,
+            body: {
+                error: 'invalid_request',
+                message: `\`label\` must be at most ${MAX_LABEL_LENGTH} characters (got ${label.length})`,
+            },
+        };
+    }
     const keyId = derivePublicKeyId(decoded);
     const subject = deps.authn.subject;
+    const clock = deps.clock ?? (() => new Date());
     const row = {
         subject,
         keyId,
         publicKeyBase64: input.publicKeyBase64,
+        createdAt: clock().toISOString(),
+        ...(label !== undefined ? { label } : {}),
     };
     // Atomic first-write attempt. The `ifNotExists` flag tells the
     // storage adapter to use a conditional put (a DDB
@@ -103,6 +135,8 @@ export async function registerAuthorKey(input, deps) {
                 subject,
                 keyId,
                 publicKeyBase64: input.publicKeyBase64,
+                ...(row.createdAt !== undefined ? { createdAt: row.createdAt } : {}),
+                ...(row.label !== undefined ? { label: row.label } : {}),
             },
         };
     }
@@ -150,6 +184,10 @@ export async function registerAuthorKey(input, deps) {
         };
     }
     if (existing.publicKeyBase64 === input.publicKeyBase64) {
+        // Idempotent re-register echoes the EXISTING row untouched — a
+        // different label on a retry does NOT rewrite the stored one
+        // (relabeling is a deliberate future op, not a register side
+        // effect).
         return {
             ok: true,
             status: 200,
@@ -157,6 +195,10 @@ export async function registerAuthorKey(input, deps) {
                 subject: existing.subject,
                 keyId: existing.keyId,
                 publicKeyBase64: existing.publicKeyBase64,
+                ...(existing.createdAt !== undefined
+                    ? { createdAt: existing.createdAt }
+                    : {}),
+                ...(existing.label !== undefined ? { label: existing.label } : {}),
             },
         };
     }

package/dist/ops/search.d.ts

@@ -2,7 +2,7 @@
  * `searchArtifacts` — pure op for `GET /search?…`. Delegates the
  * post-fetch filter + cursor to {@link RegistryStorage.scanArtifacts} so
  * every storage impl shares the single semantic — AND-composition over
- * q/kind/hook/tag/author.
+ * q/kind/hook/tag/author/tool/server.
  *
  * Visibility: only `visibility: "public"` rows are exposed. Without that
  * filter the public `/search` route would leak private artifact IDs.
@@ -31,6 +31,18 @@ export interface SearchArtifactsInput {
      * globally-correct newest-first order across the full cursor chain.
      */
     readonly sort?: string;
+    /**
+     * Exact MCP tool-name filter — matches artifacts whose bindings
+     * include this tool (declared under any server, or none). Must match
+     * `^[A-Za-z0-9_.-]{1,128}$`; anything else is a 400.
+     */
+    readonly tool?: string;
+    /**
+     * Exact MCP server-name filter — matches artifacts whose bindings
+     * declare this server; bindings without a server never match. Same
+     * charset rule as `tool`.
+     */
+    readonly server?: string;
 }
 export interface SearchArtifactsDeps {
     readonly storage: RegistryStorage;

package/dist/ops/search.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../src/ops/search.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EAIV,eAAe,EACf,cAAc,EAGf,MAAM,aAAa,CAAC;AAErB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAKzE,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACjC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;CACnC;AAED,MAAM,MAAM,qBAAqB,GAC7B;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAA;CAAE,GAC1E;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,GAAG,GAAG,GAAG,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAA;CAAE,CAAC;AAEvF,wBAAsB,eAAe,CACnC,KAAK,EAAE,oBAAoB,EAC3B,IAAI,EAAE,mBAAmB,GACxB,OAAO,CAAC,qBAAqB,CAAC,CAsFhC"}
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../src/ops/search.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EAKV,eAAe,EACf,cAAc,EAGf,MAAM,aAAa,CAAC;AAErB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAOzE,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACjC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;CACnC;AAED,MAAM,MAAM,qBAAqB,GAC7B;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAA;CAAE,GAC1E;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,GAAG,GAAG,GAAG,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAA;CAAE,CAAC;AAEvF,wBAAsB,eAAe,CACnC,KAAK,EAAE,oBAAoB,EAC3B,IAAI,EAAE,mBAAmB,GACxB,OAAO,CAAC,qBAAqB,CAAC,CAwHhC"}

package/dist/ops/search.js

@@ -1,4 +1,6 @@
 import { SEARCH_SORT_OPTIONS } from '../types.js';
+import { artifactScope } from './private-read-authz.js';
+import { MCP_TOOL_BINDING_NAME_RE } from '@ggui-ai/artifact-manifest';
 const DEFAULT_LIMIT = 50;
 const MAX_LIMIT = 200;
 export async function searchArtifacts(input, deps) {
@@ -45,12 +47,36 @@ export async function searchArtifacts(input, deps) {
         }
         sort = input.sort;
     }
+    const tool = nonEmpty(input.tool);
+    if (tool !== undefined && !MCP_TOOL_BINDING_NAME_RE.test(tool)) {
+        return {
+            ok: false,
+            status: 400,
+            body: {
+                error: 'invalid_request',
+                message: '`tool` must match ^[A-Za-z0-9_.-]{1,128}$',
+            },
+        };
+    }
+    const server = nonEmpty(input.server);
+    if (server !== undefined && !MCP_TOOL_BINDING_NAME_RE.test(server)) {
+        return {
+            ok: false,
+            status: 400,
+            body: {
+                error: 'invalid_request',
+                message: '`server` must match ^[A-Za-z0-9_.-]{1,128}$',
+            },
+        };
+    }
     const filter = {
         q: nonEmpty(input.q),
         kind,
         hook: nonEmpty(input.hook),
         tag: nonEmpty(input.tag),
         author: nonEmpty(input.author),
+        tool,
+        server,
         limit,
         cursor: nonEmpty(input.cursor),
         order: sort,
@@ -72,11 +98,16 @@ export async function searchArtifacts(input, deps) {
             continue;
         visibleRows.push(row);
     }
+    // Scope-verification surfacing — ONE owner read per unique scope on
+    // the page, batched. A failed or empty read leaves the fields ABSENT
+    // (state unknown is not 'unverified'): the wire only carries a label
+    // the ownership row actually asserted.
+    const ownersByScope = await readScopeOwners(deps.storage, visibleRows);
     // `sort=recent` ordering is served by the storage layer (the filter
     // carries `order: 'recent'`); rows arrive newest-first and are
     // emitted verbatim — no re-sort here, so page order and cursor order
     // cannot diverge.
-    const results = visibleRows.map(rowToEntry);
+    const results = visibleRows.map((row) => rowToEntry(row, ownersByScope.get(artifactScope(row.artifactId)) ?? null));
     return {
         ok: true,
         status: 200,
@@ -86,7 +117,24 @@ export async function searchArtifacts(input, deps) {
 function isSearchSort(value) {
     return SEARCH_SORT_OPTIONS.includes(value);
 }
-function rowToEntry(row) {
+async function readScopeOwners(storage, rows) {
+    const scopes = [...new Set(rows.map((row) => artifactScope(row.artifactId)))];
+    const entries = await Promise.all(scopes.map(async (scope) => {
+        try {
+            return [scope, await storage.getScopeOwner(scope)];
+        }
+        catch (err) {
+            // eslint-disable-next-line no-console -- server-side operator signal; the wire simply omits the fields
+            console.error('registry search: scope-owner lookup failed; omitting verification fields', {
+                scope,
+                error: err instanceof Error ? err.message : String(err),
+            });
+            return [scope, null];
+        }
+    }));
+    return new Map(entries);
+}
+function rowToEntry(row, scopeOwner) {
     return {
         artifactId: row.artifactId,
         latestVersion: row.latestVersion,
@@ -94,6 +142,10 @@ function rowToEntry(row) {
         description: row.description,
         tags: row.tags,
         publishedAt: row.publishedAt,
+        mcpTools: row.mcpTools,
+        mcpToolsSource: row.mcpToolsSource,
+        scopeVerification: scopeOwner?.verification,
+        verifiedDomain: scopeOwner?.verification === 'verified' ? scopeOwner.verifiedDomain : undefined,
     };
 }
 function nonEmpty(s) {

package/dist/testing/bundle-storage-contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bundle-storage-contract.d.ts","sourceRoot":"","sources":["../../src/testing/bundle-storage-contract.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AA0DrE,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,MAAM,aAAa,GAAG,IAAI,CA6H5E"}
+{"version":3,"file":"bundle-storage-contract.d.ts","sourceRoot":"","sources":["../../src/testing/bundle-storage-contract.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AA0DrE,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,MAAM,aAAa,GAAG,IAAI,CA8K5E"}

package/dist/testing/bundle-storage-contract.js

@@ -69,35 +69,69 @@ export function bundleStorageContract(makeStorage) {
         describe('bundle', () => {
             it('returns null on miss', async () => {
                 const s = makeStorage();
-                expect(await s.getBundle('@test', 'foo', '0.1.0')).toBe(null);
+                expect(await s.getBundle('@test', 'foo', '0.1.0', 'public')).toBe(null);
             });
             it('round-trips bundle bytes', async () => {
                 const s = makeStorage();
                 const bytes = new Uint8Array([0xff, 0x00, 0x10, 0x20]);
-                await s.putBundle('@test', 'foo', '0.1.0', bytes);
-                const fetched = await s.getBundle('@test', 'foo', '0.1.0');
+                await s.putBundle('@test', 'foo', '0.1.0', 'public', bytes);
+                const fetched = await s.getBundle('@test', 'foo', '0.1.0', 'public');
                 expect(fetched).toEqual(bytes);
             });
             it('isolates bundles by (scope, name, version)', async () => {
                 const s = makeStorage();
-                await s.putBundle('@a', 'pkg', '0.1.0', new Uint8Array([1]));
-                await s.putBundle('@a', 'pkg', '0.2.0', new Uint8Array([2]));
-                await s.putBundle('@b', 'pkg', '0.1.0', new Uint8Array([3]));
-                expect((await s.getBundle('@a', 'pkg', '0.1.0'))?.[0]).toBe(1);
-                expect((await s.getBundle('@a', 'pkg', '0.2.0'))?.[0]).toBe(2);
-                expect((await s.getBundle('@b', 'pkg', '0.1.0'))?.[0]).toBe(3);
+                await s.putBundle('@a', 'pkg', '0.1.0', 'public', new Uint8Array([1]));
+                await s.putBundle('@a', 'pkg', '0.2.0', 'public', new Uint8Array([2]));
+                await s.putBundle('@b', 'pkg', '0.1.0', 'public', new Uint8Array([3]));
+                expect((await s.getBundle('@a', 'pkg', '0.1.0', 'public'))?.[0]).toBe(1);
+                expect((await s.getBundle('@a', 'pkg', '0.2.0', 'public'))?.[0]).toBe(2);
+                expect((await s.getBundle('@b', 'pkg', '0.1.0', 'public'))?.[0]).toBe(3);
+            });
+        });
+        describe('visibility key split (H1)', () => {
+            it('a private-written bundle is invisible to a public read of the same triple', async () => {
+                const s = makeStorage();
+                await s.putBundle('@acme', 'secret', '1.0.0', 'private', new Uint8Array([7]));
+                expect(await s.getBundle('@acme', 'secret', '1.0.0', 'public')).toBe(null);
+                expect((await s.getBundle('@acme', 'secret', '1.0.0', 'private'))?.[0]).toBe(7);
+            });
+            it('a public-written bundle is invisible to a private read of the same triple', async () => {
+                const s = makeStorage();
+                await s.putBundle('@acme', 'open', '1.0.0', 'public', new Uint8Array([9]));
+                expect(await s.getBundle('@acme', 'open', '1.0.0', 'private')).toBe(null);
+                expect((await s.getBundle('@acme', 'open', '1.0.0', 'public'))?.[0]).toBe(9);
+            });
+            it('splits signatures and manifests by visibility too', async () => {
+                const s = makeStorage();
+                await s.putSignature('@acme', 'secret', '1.0.0', 'private', stubSignature());
+                await s.putManifest('@acme', 'secret', '1.0.0', 'private', stubManifest());
+                expect(await s.getSignature('@acme', 'secret', '1.0.0', 'public')).toBe(null);
+                expect(await s.getManifest('@acme', 'secret', '1.0.0', 'public')).toBe(null);
+                expect(await s.getSignature('@acme', 'secret', '1.0.0', 'private')).not.toBe(null);
+                expect(await s.getManifest('@acme', 'secret', '1.0.0', 'private')).not.toBe(null);
+            });
+            it('embeds the visibility segment in every composed URL', () => {
+                const s = makeStorage();
+                for (const compose of [
+                    s.bundleUrl.bind(s),
+                    s.signatureUrl.bind(s),
+                    s.manifestUrl.bind(s),
+                ]) {
+                    expect(compose('@test', 'foo', '0.1.0', 'public')).toContain('/bundles/public/');
+                    expect(compose('@test', 'foo', '0.1.0', 'private')).toContain('/bundles/private/');
+                }
             });
         });
         describe('signature', () => {
             it('returns null on miss', async () => {
                 const s = makeStorage();
-                expect(await s.getSignature('@test', 'foo', '0.1.0')).toBe(null);
+                expect(await s.getSignature('@test', 'foo', '0.1.0', 'public')).toBe(null);
             });
             it('round-trips an Ed25519 signature envelope', async () => {
                 const s = makeStorage();
                 const sig = stubSignature();
-                await s.putSignature('@test', 'foo', '0.1.0', sig);
-                const fetched = await s.getSignature('@test', 'foo', '0.1.0');
+                await s.putSignature('@test', 'foo', '0.1.0', 'private', sig);
+                const fetched = await s.getSignature('@test', 'foo', '0.1.0', 'private');
                 expect(fetched).toEqual(sig);
             });
             // Pin the sigstore round-trip through the storage layer. Guards
@@ -110,8 +144,8 @@ export function bundleStorageContract(makeStorage) {
             it('round-trips a sigstore signature envelope including the embedded cosign bundle', async () => {
                 const s = makeStorage();
                 const sig = stubSigstoreSignature();
-                await s.putSignature('@test', 'foo', '0.1.0', sig);
-                const fetched = await s.getSignature('@test', 'foo', '0.1.0');
+                await s.putSignature('@test', 'foo', '0.1.0', 'public', sig);
+                const fetched = await s.getSignature('@test', 'foo', '0.1.0', 'public');
                 expect(fetched).toEqual(sig);
                 // Specifically pin the `algorithm` discriminator + the
                 // `bundle` field — these are sigstore-only fields the prior
@@ -135,41 +169,41 @@ export function bundleStorageContract(makeStorage) {
                 // case is covered by the round-trip tests; this test pins the
                 // null-on-miss contract specifically — without it, a regression
                 // that silently returns a stub object would slip through.
-                const fetched = await s.getSignature('@no-such-scope', 'no-such-name', '0.0.0');
+                const fetched = await s.getSignature('@no-such-scope', 'no-such-name', '0.0.0', 'public');
                 expect(fetched).toBe(null);
             });
         });
         describe('manifest', () => {
             it('returns null on miss', async () => {
                 const s = makeStorage();
-                expect(await s.getManifest('@test', 'foo', '0.1.0')).toBe(null);
+                expect(await s.getManifest('@test', 'foo', '0.1.0', 'public')).toBe(null);
             });
             it('round-trips the manifest', async () => {
                 const s = makeStorage();
                 const m = stubManifest();
-                await s.putManifest('@test', 'foo', '0.1.0', m);
-                const fetched = await s.getManifest('@test', 'foo', '0.1.0');
+                await s.putManifest('@test', 'foo', '0.1.0', 'public', m);
+                const fetched = await s.getManifest('@test', 'foo', '0.1.0', 'public');
                 expect(fetched).toEqual(m);
             });
         });
         describe('URL composition', () => {
             it('produces distinct URLs for bundle / sig / manifest', async () => {
                 const s = makeStorage();
-                const b = s.bundleUrl('@test', 'foo', '0.1.0');
-                const sig = s.signatureUrl('@test', 'foo', '0.1.0');
-                const man = s.manifestUrl('@test', 'foo', '0.1.0');
+                const b = s.bundleUrl('@test', 'foo', '0.1.0', 'public');
+                const sig = s.signatureUrl('@test', 'foo', '0.1.0', 'public');
+                const man = s.manifestUrl('@test', 'foo', '0.1.0', 'public');
                 expect(b).not.toBe(sig);
                 expect(b).not.toBe(man);
                 expect(sig).not.toBe(man);
             });
             it('matches the URL returned from put*', async () => {
                 const s = makeStorage();
-                const putBundleUrl = await s.putBundle('@test', 'foo', '0.1.0', new Uint8Array([1]));
-                expect(putBundleUrl).toBe(s.bundleUrl('@test', 'foo', '0.1.0'));
-                const putSigUrl = await s.putSignature('@test', 'foo', '0.1.0', stubSignature());
-                expect(putSigUrl).toBe(s.signatureUrl('@test', 'foo', '0.1.0'));
-                const putManUrl = await s.putManifest('@test', 'foo', '0.1.0', stubManifest());
-                expect(putManUrl).toBe(s.manifestUrl('@test', 'foo', '0.1.0'));
+                const putBundleUrl = await s.putBundle('@test', 'foo', '0.1.0', 'private', new Uint8Array([1]));
+                expect(putBundleUrl).toBe(s.bundleUrl('@test', 'foo', '0.1.0', 'private'));
+                const putSigUrl = await s.putSignature('@test', 'foo', '0.1.0', 'private', stubSignature());
+                expect(putSigUrl).toBe(s.signatureUrl('@test', 'foo', '0.1.0', 'private'));
+                const putManUrl = await s.putManifest('@test', 'foo', '0.1.0', 'private', stubManifest());
+                expect(putManUrl).toBe(s.manifestUrl('@test', 'foo', '0.1.0', 'private'));
             });
         });
     });

package/dist/testing/registry-storage-contract.d.ts

@@ -1,3 +1,3 @@
-import type { RegistryStorage } from '../interfaces/registry-storage.js';
+import { type RegistryStorage } from '../interfaces/registry-storage.js';
 export declare function registryStorageContract(makeStorage: () => RegistryStorage): void;
 //# sourceMappingURL=registry-storage-contract.d.ts.map

package/dist/testing/registry-storage-contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry-storage-contract.d.ts","sourceRoot":"","sources":["../../src/testing/registry-storage-contract.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAsHzE,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,MAAM,eAAe,GAAG,IAAI,CA+ZhF"}
+{"version":3,"file":"registry-storage-contract.d.ts","sourceRoot":"","sources":["../../src/testing/registry-storage-contract.ts"],"names":[],"mappings":"AAkBA,OAAO,EAEL,KAAK,eAAe,EACrB,MAAM,mCAAmC,CAAC;AAqI3C,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,MAAM,eAAe,GAAG,IAAI,CAgzBhF"}