@ggui-ai/registry-core 0.6.3 → 0.8.0

package/dist/impls/memory-bundle-storage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"memory-bundle-storage.d.ts","sourceRoot":"","sources":["../../src/impls/memory-bundle-storage.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAErE,MAAM,WAAW,4BAA4B;IAC3C;;;;;OAKG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED,wBAAgB,qBAAqB,CACnC,OAAO,GAAE,4BAAiC,GACzC,aAAa,CA2Cf"}
+{"version":3,"file":"memory-bundle-storage.d.ts","sourceRoot":"","sources":["../../src/impls/memory-bundle-storage.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAGrE,MAAM,WAAW,4BAA4B;IAC3C;;;;;OAKG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED,wBAAgB,qBAAqB,CACnC,OAAO,GAAE,4BAAiC,GACzC,aAAa,CAkDf"}

package/dist/impls/memory-bundle-storage.js

@@ -3,38 +3,41 @@ export function inMemoryBundleStorage(options = {}) {
     const bundles = new Map();
     const signatures = new Map();
     const manifests = new Map();
-    const key = (scope, name, version) => `${scope}/${name}/${version}`;
+    // Visibility segments the key (H1 prefix split) — a blob written
+    // `public` must be invisible to a `private` read of the same triple,
+    // exactly like the prefix-split object keys of the durable impls.
+    const key = (scope, name, version, visibility) => `${visibility}/${scope}/${name}/${version}`;
     return {
-        async putBundle(scope, name, version, bytes) {
-            bundles.set(key(scope, name, version), new Uint8Array(bytes));
-            return this.bundleUrl(scope, name, version);
+        async putBundle(scope, name, version, visibility, bytes) {
+            bundles.set(key(scope, name, version, visibility), new Uint8Array(bytes));
+            return this.bundleUrl(scope, name, version, visibility);
         },
-        async getBundle(scope, name, version) {
-            const bytes = bundles.get(key(scope, name, version));
+        async getBundle(scope, name, version, visibility) {
+            const bytes = bundles.get(key(scope, name, version, visibility));
             return bytes === undefined ? null : new Uint8Array(bytes);
         },
-        async putSignature(scope, name, version, signature) {
-            signatures.set(key(scope, name, version), signature);
-            return this.signatureUrl(scope, name, version);
+        async putSignature(scope, name, version, visibility, signature) {
+            signatures.set(key(scope, name, version, visibility), signature);
+            return this.signatureUrl(scope, name, version, visibility);
         },
-        async getSignature(scope, name, version) {
-            return signatures.get(key(scope, name, version)) ?? null;
+        async getSignature(scope, name, version, visibility) {
+            return signatures.get(key(scope, name, version, visibility)) ?? null;
         },
-        async putManifest(scope, name, version, manifest) {
-            manifests.set(key(scope, name, version), manifest);
-            return this.manifestUrl(scope, name, version);
+        async putManifest(scope, name, version, visibility, manifest) {
+            manifests.set(key(scope, name, version, visibility), manifest);
+            return this.manifestUrl(scope, name, version, visibility);
         },
-        async getManifest(scope, name, version) {
-            return manifests.get(key(scope, name, version)) ?? null;
+        async getManifest(scope, name, version, visibility) {
+            return manifests.get(key(scope, name, version, visibility)) ?? null;
         },
-        bundleUrl(scope, name, version) {
-            return `${bundleHost}/bundles/${scope}/${name}/${version}/bundle.js`;
+        bundleUrl(scope, name, version, visibility) {
+            return `${bundleHost}/bundles/${visibility}/${scope}/${name}/${version}/bundle.js`;
         },
-        signatureUrl(scope, name, version) {
-            return `${bundleHost}/bundles/${scope}/${name}/${version}/bundle.js.sig`;
+        signatureUrl(scope, name, version, visibility) {
+            return `${bundleHost}/bundles/${visibility}/${scope}/${name}/${version}/bundle.js.sig`;
         },
-        manifestUrl(scope, name, version) {
-            return `${bundleHost}/bundles/${scope}/${name}/${version}/manifest.json`;
+        manifestUrl(scope, name, version, visibility) {
+            return `${bundleHost}/bundles/${visibility}/${scope}/${name}/${version}/manifest.json`;
         },
     };
 }

package/dist/impls/memory-registry-storage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"memory-registry-storage.d.ts","sourceRoot":"","sources":["../../src/impls/memory-registry-storage.ts"],"names":[],"mappings":"AAkBA,OAAO,EAEL,KAAK,eAAe,EACrB,MAAM,mCAAmC,CAAC;AAK3C,wBAAgB,uBAAuB,IAAI,eAAe,CAmHzD"}
+{"version":3,"file":"memory-registry-storage.d.ts","sourceRoot":"","sources":["../../src/impls/memory-registry-storage.ts"],"names":[],"mappings":"AAoBA,OAAO,EAEL,KAAK,eAAe,EACrB,MAAM,mCAAmC,CAAC;AAM3C,wBAAgB,uBAAuB,IAAI,eAAe,CA2JzD"}

package/dist/impls/memory-registry-storage.js

@@ -1,4 +1,5 @@
 import { AuthorKeyAlreadyExistsError, } from '../interfaces/registry-storage.js';
+import { matchesMcpToolFilters } from '../mcp-tool-filters.js';
 const DEFAULT_LIMIT = 50;
 const MAX_LIMIT = 200;
 export function inMemoryRegistryStorage() {
@@ -6,8 +7,12 @@ export function inMemoryRegistryStorage() {
     const versions = new Map();
     const authorKeys = new Map();
     const compiledBlobs = new Map();
+    const scopeOwners = new Map();
     const versionKey = (artifactId, version) => `${artifactId}@${version}`;
-    const authorKey = (subject, keyId) => `${subject}/${keyId}`;
+    // JSON tuple — unambiguous for ANY subject/keyId contents. Subjects
+    // are operator-defined free text, so a `${subject}/${keyId}` composite
+    // would make ('team', …) and ('team/alice', …) collide or leak.
+    const authorKey = (subject, keyId) => JSON.stringify([subject, keyId]);
     return {
         async getArtifactMetadata(artifactId) {
             return metadata.get(artifactId) ?? null;
@@ -92,6 +97,36 @@ export function inMemoryRegistryStorage() {
             });
             return { ok: true, mode: 'dedup' };
         },
+        async getScopeOwner(scope) {
+            return scopeOwners.get(scope) ?? null;
+        },
+        async claimScope(row) {
+            // First-writer-wins. The check-and-set pair runs with no `await`
+            // between them, so the single-threaded event loop makes it
+            // atomic — two racing claims resolve strictly one-after-another.
+            if (scopeOwners.has(row.scope)) {
+                return { conflict: true };
+            }
+            scopeOwners.set(row.scope, row);
+            return { ok: true };
+        },
+        async updateScopeOwner(row, expect) {
+            // Compare-and-set against the caller's read snapshot. The
+            // check-and-set pair runs with no interleaving `await`, so the
+            // event loop makes it atomic (same discipline as claimScope).
+            const current = scopeOwners.get(row.scope);
+            if ('absent' in expect) {
+                if (current !== undefined)
+                    return { conflict: true };
+            }
+            else if (current === undefined ||
+                current.ownerSubject !== expect.ownerSubject ||
+                current.verification !== expect.verification) {
+                return { conflict: true };
+            }
+            scopeOwners.set(row.scope, row);
+            return { ok: true };
+        },
         async getAuthorKey(subject, keyId) {
             return authorKeys.get(authorKey(subject, keyId)) ?? null;
         },
@@ -103,14 +138,20 @@ export function inMemoryRegistryStorage() {
             authorKeys.set(key, row);
         },
         async listAuthorKeys(subject) {
-            const prefix = `${subject}/`;
+            // Row-field filter, not key-prefix matching — the row's own
+            // `subject` is the only unambiguous ownership signal.
             const matches = [];
-            for (const [key, row] of authorKeys) {
-                if (key.startsWith(prefix))
+            for (const row of authorKeys.values()) {
+                if (row.subject === subject)
                     matches.push(row);
             }
             return matches;
         },
+        async deleteAuthorKey(subject, keyId) {
+            // Map#delete returns whether an entry existed — exactly the
+            // contract's `deleted` signal.
+            return authorKeys.delete(authorKey(subject, keyId));
+        },
     };
 }
 function clampLimit(limit) {
@@ -137,6 +178,8 @@ function rowMatchesFilter(row, q) {
         return false;
     if (q.hook !== undefined && row.hook !== q.hook)
         return false;
+    if (!matchesMcpToolFilters(row.mcpTools, q))
+        return false;
     if (q.tag !== undefined) {
         if (row.tags === undefined || !row.tags.includes(q.tag))
             return false;

package/dist/index.d.ts

@@ -9,17 +9,22 @@
  */
 export type { AuthnContext } from './interfaces/authn.js';
 export type { BundleStorage } from './interfaces/bundle-storage.js';
-export { AuthorKeyAlreadyExistsError, type PutAuthorKeyOptions, type RegistryStorage, } from './interfaces/registry-storage.js';
-export { ARTIFACTS_METADATA_SK, type ArtifactKind, type ArtifactScanFilter, type ArtifactVersionRow, type ArtifactsMetadataRow, type AuthorKeyRow, type CompiledBlobRow, type ErrorBody, LIST_VERSIONS_ERROR_CODES, type ListVersionsErrorBody, type ListVersionsErrorCode, type ListVersionsResponse, PUBLISH_ERROR_CODES, type PublishErrorBody, type PublishErrorCode, type PublishRequestBody, type PublishResponseBody, READ_ERROR_CODES, type ReadErrorBody, type ReadErrorCode, type ReadPkgResponse, REGISTER_AUTHOR_KEY_ERROR_CODES, type RegisterAuthorKeyErrorBody, type RegisterAuthorKeyErrorCode, type RegisterAuthorKeyRequestBody, type RegisterAuthorKeyResponseBody, SEARCH_ERROR_CODES, SEARCH_SORT_OPTIONS, type SearchErrorBody, type SearchErrorCode, type SearchResponse, type SearchResultEntry, type SearchSort, type VersionListEntry, type Visibility, } from './types.js';
+export { AuthorKeyAlreadyExistsError, type PutAuthorKeyOptions, type RegistryStorage, type ScopeOwnerExpectation, } from './interfaces/registry-storage.js';
+export { ARTIFACTS_METADATA_SK, type ArtifactKind, type ArtifactScanFilter, type ArtifactVersionRow, type ArtifactsMetadataRow, type AuthorKeyListEntry, type AuthorKeyRow, type CompiledBlobRow, DELETE_AUTHOR_KEY_ERROR_CODES, type DeleteAuthorKeyErrorBody, type DeleteAuthorKeyErrorCode, type DeleteAuthorKeyResponseBody, type ErrorBody, LIST_AUTHOR_KEYS_ERROR_CODES, type ListAuthorKeysErrorBody, type ListAuthorKeysErrorCode, type ListAuthorKeysResponseBody, LIST_VERSIONS_ERROR_CODES, type ListVersionsErrorBody, type ListVersionsErrorCode, type ListVersionsResponse, PUBLISH_ERROR_CODES, type PublishErrorBody, type PublishErrorCode, type PublishRequestBody, type PublishResponseBody, READ_ERROR_CODES, type ReadErrorBody, type ReadErrorCode, type ReadPkgResponse, REGISTER_AUTHOR_KEY_ERROR_CODES, type RegisterAuthorKeyErrorBody, type RegisterAuthorKeyErrorCode, type RegisterAuthorKeyRequestBody, type RegisterAuthorKeyResponseBody, SAN_ALLOWLIST_INVALID, type SanAllowlistInvalid, SCOPE_VERIFICATIONS, type ScopeOwnerRow, type ScopeVerification, SEARCH_ERROR_CODES, SEARCH_SORT_OPTIONS, unauthorizedErrorBody, type SearchErrorBody, type SearchErrorCode, type SearchResponse, type SearchResultEntry, type SearchSort, type VersionListEntry, type Visibility, } from './types.js';
 export { compileBlueprint, type CompileBlueprintErr, type CompileBlueprintOk, type CompileBlueprintResult, } from './ops/compile.js';
 export { checkConformance, MAX_BLUEPRINT_SOURCE_BYTES, type BlueprintProbeRunner, type ConformanceError, type ConformanceErrorCode, type ConformanceFailureCode, type ConformanceRequestPayload, type ConformanceResponseBody, } from './ops/conformance.js';
-export { publishArtifact, MAX_BUNDLE_BYTES, type PublishArtifactDeps, type PublishArtifactInput, type PublishArtifactResult, } from './ops/publish.js';
+export { publishArtifact, MAX_BUNDLE_BYTES, RESERVED_SCOPES, type PublishArtifactDeps, type PublishArtifactInput, type PublishArtifactResult, type VerifiedEmailResolver, } from './ops/publish.js';
 export { readArtifact, type ReadArtifactDeps, type ReadArtifactInput, type ReadArtifactResult, } from './ops/read.js';
+export { artifactScope, canReadPrivateArtifact, createScopeOwnerResolver, } from './ops/private-read-authz.js';
 export { listArtifactVersions, type ListArtifactVersionsDeps, type ListArtifactVersionsInput, type ListArtifactVersionsResult, } from './ops/list-versions.js';
 export { searchArtifacts, type SearchArtifactsDeps, type SearchArtifactsInput, type SearchArtifactsResult, } from './ops/search.js';
 export { registerAuthorKey, type RegisterAuthorKeyDeps, type RegisterAuthorKeyInput, type RegisterAuthorKeyResult, } from './ops/register-author-key.js';
+export { listAuthorKeys, type ListAuthorKeysDeps, type ListAuthorKeysResult, } from './ops/list-author-keys.js';
+export { deleteAuthorKey, type DeleteAuthorKeyDeps, type DeleteAuthorKeyInput, type DeleteAuthorKeyResult, } from './ops/delete-author-key.js';
 export { inMemoryRegistryStorage } from './impls/memory-registry-storage.js';
 export { inMemoryBundleStorage, type InMemoryBundleStorageOptions, } from './impls/memory-bundle-storage.js';
+export { matchesMcpToolFilters } from './mcp-tool-filters.js';
+export { installCommand, type InstallCommandOptions, } from './install-command.js';
 export { compareSemver } from './utils/semver.js';
 export { base64Encode, safeBase64Decode, sha384Base64 } from './utils/base64.js';
 export type { Ed25519Signature, GadgetSignature } from '@ggui-ai/gadget-signing';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,YAAY,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAC1D,YAAY,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,EACL,2BAA2B,EAC3B,KAAK,mBAAmB,EACxB,KAAK,eAAe,GACrB,MAAM,kCAAkC,CAAC;AAG1C,OAAO,EACL,qBAAqB,EACrB,KAAK,YAAY,EACjB,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,EACzB,KAAK,YAAY,EACjB,KAAK,eAAe,EACpB,KAAK,SAAS,EACd,yBAAyB,EACzB,KAAK,qBAAqB,EAC1B,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EACzB,mBAAmB,EACnB,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EACxB,gBAAgB,EAChB,KAAK,aAAa,EAClB,KAAK,aAAa,EAClB,KAAK,eAAe,EACpB,+BAA+B,EAC/B,KAAK,0BAA0B,EAC/B,KAAK,0BAA0B,EAC/B,KAAK,4BAA4B,EACjC,KAAK,6BAA6B,EAClC,kBAAkB,EAClB,mBAAmB,EACnB,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACtB,KAAK,UAAU,EACf,KAAK,gBAAgB,EACrB,KAAK,UAAU,GAChB,MAAM,YAAY,CAAC;AAGpB,OAAO,EACL,gBAAgB,EAChB,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,sBAAsB,GAC5B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,gBAAgB,EAChB,0BAA0B,EAC1B,KAAK,oBAAoB,EACzB,KAAK,gBAAgB,EACrB,KAAK,oBAAoB,EACzB,KAAK,sBAAsB,EAC3B,KAAK,yBAAyB,EAC9B,KAAK,uBAAuB,GAC7B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,GAC3B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,YAAY,EACZ,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,GACxB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,oBAAoB,EACpB,KAAK,wBAAwB,EAC7B,KAAK,yBAAyB,EAC9B,KAAK,0BAA0B,GAChC,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,eAAe,EACf,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,GAC3B,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,iBAAiB,EACjB,KAAK,qBAAqB,EAC1B,KAAK,sBAAsB,EAC3B,KAAK,uBAAuB,GAC7B,MAAM,8BAA8B,CAAC;AAGtC,OAAO,EAAE,uBAAuB,EAAE,MAAM,oCAAoC,CAAC;AAC7E,OAAO,EACL,qBAAqB,EACrB,KAAK,4BAA4B,GAClC,MAAM,kCAAkC,CAAC;AAG1C,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAKjF,YAAY,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -9,18 +9,24 @@
  */
 export { AuthorKeyAlreadyExistsError, } from './interfaces/registry-storage.js';
 // Types — rows + wire shapes
-export { ARTIFACTS_METADATA_SK, LIST_VERSIONS_ERROR_CODES, PUBLISH_ERROR_CODES, READ_ERROR_CODES, REGISTER_AUTHOR_KEY_ERROR_CODES, SEARCH_ERROR_CODES, SEARCH_SORT_OPTIONS, } from './types.js';
+export { ARTIFACTS_METADATA_SK, DELETE_AUTHOR_KEY_ERROR_CODES, LIST_AUTHOR_KEYS_ERROR_CODES, LIST_VERSIONS_ERROR_CODES, PUBLISH_ERROR_CODES, READ_ERROR_CODES, REGISTER_AUTHOR_KEY_ERROR_CODES, SAN_ALLOWLIST_INVALID, SCOPE_VERIFICATIONS, SEARCH_ERROR_CODES, SEARCH_SORT_OPTIONS, unauthorizedErrorBody, } from './types.js';
 // Operations
 export { compileBlueprint, } from './ops/compile.js';
 export { checkConformance, MAX_BLUEPRINT_SOURCE_BYTES, } from './ops/conformance.js';
-export { publishArtifact, MAX_BUNDLE_BYTES, } from './ops/publish.js';
+export { publishArtifact, MAX_BUNDLE_BYTES, RESERVED_SCOPES, } from './ops/publish.js';
 export { readArtifact, } from './ops/read.js';
+export { artifactScope, canReadPrivateArtifact, createScopeOwnerResolver, } from './ops/private-read-authz.js';
 export { listArtifactVersions, } from './ops/list-versions.js';
 export { searchArtifacts, } from './ops/search.js';
 export { registerAuthorKey, } from './ops/register-author-key.js';
+export { listAuthorKeys, } from './ops/list-author-keys.js';
+export { deleteAuthorKey, } from './ops/delete-author-key.js';
 // In-memory impls
 export { inMemoryRegistryStorage } from './impls/memory-registry-storage.js';
 export { inMemoryBundleStorage, } from './impls/memory-bundle-storage.js';
+// Shared scan-filter semantics
+export { matchesMcpToolFilters } from './mcp-tool-filters.js';
 // Utils
+export { installCommand, } from './install-command.js';
 export { compareSemver } from './utils/semver.js';
 export { base64Encode, safeBase64Decode, sha384Base64 } from './utils/base64.js';

package/dist/install-command.d.ts

@@ -0,0 +1,25 @@
+import type { ArtifactKind } from './types.js';
+export interface InstallCommandOptions {
+    /**
+     * Registry origin to pin via an explicit `--registry=<url>` flag —
+     * pass the URL the artifact was discovered on (the same origin the
+     * search/read endpoints were queried against). When provided, the
+     * emitted command installs from exactly that registry instead of
+     * whatever the CLI's ambient default resolves to; when omitted, the
+     * flag is left off and the CLI default applies.
+     */
+    readonly registryHost?: string;
+}
+/**
+ * Compose the canonical CLI install command for a published artifact:
+ *
+ *     ggui <kind> install <scope>/<name>@<version> [--registry=<url>]
+ *
+ * Same shape the publish flow reports back after a successful publish,
+ * so every surface that displays an install command agrees on one
+ * wording. Pure string composition — callers are responsible for
+ * validating `artifactId` (`@scope/name`) and `version` (semver)
+ * before display; this function does not re-validate.
+ */
+export declare function installCommand(kind: ArtifactKind, artifactId: string, version: string, opts?: InstallCommandOptions): string;
+//# sourceMappingURL=install-command.d.ts.map

package/dist/install-command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"install-command.d.ts","sourceRoot":"","sources":["../src/install-command.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C,MAAM,WAAW,qBAAqB;IACpC;;;;;;;OAOG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;CAChC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,YAAY,EAClB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,EACf,IAAI,GAAE,qBAA0B,GAC/B,MAAM,CAIR"}

package/dist/install-command.js

@@ -0,0 +1,15 @@
+/**
+ * Compose the canonical CLI install command for a published artifact:
+ *
+ *     ggui <kind> install <scope>/<name>@<version> [--registry=<url>]
+ *
+ * Same shape the publish flow reports back after a successful publish,
+ * so every surface that displays an install command agrees on one
+ * wording. Pure string composition — callers are responsible for
+ * validating `artifactId` (`@scope/name`) and `version` (semver)
+ * before display; this function does not re-validate.
+ */
+export function installCommand(kind, artifactId, version, opts = {}) {
+    const registry = opts.registryHost !== undefined ? ` --registry=${opts.registryHost}` : '';
+    return `ggui ${kind} install ${artifactId}@${version}${registry}`;
+}

package/dist/interfaces/bundle-storage.d.ts

@@ -2,8 +2,8 @@
  * `BundleStorage` — bundle + signature + manifest blob storage. A
  * hosted implementation may serve blobs from object storage behind a
  * CDN; the open-source server backs it with the filesystem under
- * `<root>/bundles/<scope>/<name>/<version>/`. A memory impl is
- * provided for tests.
+ * `<root>/bundles/<visibility>/<scope>/<name>/<version>/`. A memory
+ * impl is provided for tests.
  *
  * Each `put*` method returns the fully-qualified URL the consumer
  * (iframe runtime, install CLI) can fetch. The URL prefix is
@@ -11,17 +11,33 @@
  * CDN-fronted implementation, or `http://localhost:9001` (or
  * whatever the server is bound to) for the open-source server.
  *
- * Bundles are immutable post-publish. Responses MUST emit
- * `Cache-Control: public, max-age=31536000, immutable` — SRI integrity
- * depends on it. The OSS server's bundle route sets this header
- * explicitly; a CDN-fronted implementation sets it via its cache
- * policy.
+ * ## Visibility-split key layout (load-bearing)
+ *
+ * Every blob lives under a visibility-segmented key:
+ *
+ *   bundles/public/<scope>/<name>/<version>/{bundle.js,bundle.js.sig,manifest.json}
+ *   bundles/private/<scope>/<name>/<version>/{...}
+ *
+ * Placement IS the access-control boundary: the `bundles/public/`
+ * prefix may be served anonymously (CDN, static route); the
+ * `bundles/private/` prefix MUST only be reachable through an
+ * authenticated route that authorizes the caller against the
+ * artifact's publisher or scope owner. An impl that flattens the two
+ * prefixes back together silently republishes every private artifact.
+ *
+ * Bundles are immutable post-publish. Public-prefix responses MUST
+ * emit `Cache-Control: public, max-age=31536000, immutable` — SRI
+ * integrity depends on it. Private-prefix responses stay immutable but
+ * MUST NOT be shared-cacheable (`Cache-Control: private, …`). The OSS
+ * server's bundle routes set these headers explicitly; a CDN-fronted
+ * implementation sets the public policy on its cache behavior.
  *
  * ## Protocol & Contract Bar
  *
  * **Parties:**
  * - Producer: {@link publishArtifact} writes bundle (gadgets),
- *   signature (gadgets), and manifest (always) on every publish.
+ *   signature (gadgets), and manifest (always) on every publish, at
+ *   the key the manifest's `visibility` selects.
  * - Consumer: iframe-runtime (bundleUrl), install CLI (signatureUrl,
  *   manifestUrl), audit tooling (manifestUrl on yanked versions).
  *
@@ -31,49 +47,57 @@
  *   per-version row immutability invariant on {@link RegistryStorage}
  *   prevents true re-publishes; the bundle-storage layer needs no
  *   conflict semantics).
+ * - Key composition MUST segment on `visibility` — a blob written
+ *   `public` is invisible to a `private` read of the same triple, and
+ *   vice versa.
  * - URL composition methods (`bundleUrl`, `signatureUrl`,
- *   `manifestUrl`) MUST be pure — no I/O, no async. Consumers cache
- *   URLs liberally.
+ *   `manifestUrl`) MUST be pure — no I/O, no async — and MUST embed
+ *   the same visibility segment the corresponding `put*` used, so the
+ *   persisted row URLs point at the blob's real location. Consumers
+ *   cache URLs liberally.
  *
  * **Failure mode:**
  * - Transport-level failures throw; the publish op wraps and returns
  *   500.
- * - Missing-blob reads return `null`; never throw.
+ * - Missing-blob reads return `null`; never throw. A visibility
+ *   mismatch reads as a miss.
  *
  * **Observable violation:**
  * - Contract test {@link bundleStorageContract} covers: bundle
  *   round-trip preserves bytes; signature round-trip preserves the
  *   structured object; manifest round-trip preserves the full
- *   discriminated-union shape; URL methods compose without side effects;
- *   missing reads return null.
+ *   discriminated-union shape; URL methods compose without side effects
+ *   and embed the visibility segment; missing reads return null;
+ *   cross-visibility reads return null.
  */
 import type { ArtifactManifest } from '@ggui-ai/artifact-manifest';
 import type { GadgetSignature } from '@ggui-ai/gadget-signing';
+import type { Visibility } from '../types.js';
 export interface BundleStorage {
-    /** Write gadget bundle bytes. Returns the public URL. */
-    putBundle(scope: string, name: string, version: string, bytes: Uint8Array): Promise<string>;
-    /** Read gadget bundle bytes. `null` on miss. */
-    getBundle(scope: string, name: string, version: string): Promise<Uint8Array | null>;
+    /** Write gadget bundle bytes. Returns the fetch URL. */
+    putBundle(scope: string, name: string, version: string, visibility: Visibility, bytes: Uint8Array): Promise<string>;
+    /** Read gadget bundle bytes. `null` on miss (including visibility mismatch). */
+    getBundle(scope: string, name: string, version: string, visibility: Visibility): Promise<Uint8Array | null>;
     /**
-     * Write the signature envelope. Returns the public URL.
+     * Write the signature envelope. Returns the fetch URL.
      *
      * The envelope is a {@link GadgetSignature} — a discriminated union
      * over `algorithm` (`ed25519` for private gadgets, `sigstore-cosign`
      * for public). Impls serialize via `JSON.stringify(signature)` and
      * store the resulting bytes verbatim.
      */
-    putSignature(scope: string, name: string, version: string, signature: GadgetSignature): Promise<string>;
-    /** Read the signature envelope. `null` on miss. */
-    getSignature(scope: string, name: string, version: string): Promise<GadgetSignature | null>;
-    /** Write the manifest verbatim. Returns the public URL. */
-    putManifest(scope: string, name: string, version: string, manifest: ArtifactManifest): Promise<string>;
-    /** Read the manifest. `null` on miss. */
-    getManifest(scope: string, name: string, version: string): Promise<ArtifactManifest | null>;
-    /** Compose the public bundle URL. No I/O. */
-    bundleUrl(scope: string, name: string, version: string): string;
-    /** Compose the public signature URL. No I/O. */
-    signatureUrl(scope: string, name: string, version: string): string;
-    /** Compose the public manifest URL. No I/O. */
-    manifestUrl(scope: string, name: string, version: string): string;
+    putSignature(scope: string, name: string, version: string, visibility: Visibility, signature: GadgetSignature): Promise<string>;
+    /** Read the signature envelope. `null` on miss (including visibility mismatch). */
+    getSignature(scope: string, name: string, version: string, visibility: Visibility): Promise<GadgetSignature | null>;
+    /** Write the manifest verbatim. Returns the fetch URL. */
+    putManifest(scope: string, name: string, version: string, visibility: Visibility, manifest: ArtifactManifest): Promise<string>;
+    /** Read the manifest. `null` on miss (including visibility mismatch). */
+    getManifest(scope: string, name: string, version: string, visibility: Visibility): Promise<ArtifactManifest | null>;
+    /** Compose the bundle URL (embeds the visibility segment). No I/O. */
+    bundleUrl(scope: string, name: string, version: string, visibility: Visibility): string;
+    /** Compose the signature URL (embeds the visibility segment). No I/O. */
+    signatureUrl(scope: string, name: string, version: string, visibility: Visibility): string;
+    /** Compose the manifest URL (embeds the visibility segment). No I/O. */
+    manifestUrl(scope: string, name: string, version: string, visibility: Visibility): string;
 }
 //# sourceMappingURL=bundle-storage.d.ts.map

package/dist/interfaces/bundle-storage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bundle-storage.d.ts","sourceRoot":"","sources":["../../src/interfaces/bundle-storage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE/D,MAAM,WAAW,aAAa;IAC5B,yDAAyD;IACzD,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC5F,gDAAgD;IAChD,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAAC;IAEpF;;;;;;;OAOG;IACH,YAAY,CACV,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,eAAe,GACzB,OAAO,CAAC,MAAM,CAAC,CAAC;IACnB,mDAAmD;IACnD,YAAY,CACV,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAAC;IAEnC,2DAA2D;IAC3D,WAAW,CACT,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,gBAAgB,GACzB,OAAO,CAAC,MAAM,CAAC,CAAC;IACnB,yCAAyC;IACzC,WAAW,CACT,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC,CAAC;IAEpC,6CAA6C;IAC7C,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC;IAChE,gDAAgD;IAChD,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC;IACnE,+CAA+C;IAC/C,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC;CACnE"}
+{"version":3,"file":"bundle-storage.d.ts","sourceRoot":"","sources":["../../src/interfaces/bundle-storage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuEG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC/D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,MAAM,WAAW,aAAa;IAC5B,wDAAwD;IACxD,SAAS,CACP,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,UAAU,EACtB,KAAK,EAAE,UAAU,GAChB,OAAO,CAAC,MAAM,CAAC,CAAC;IACnB,gFAAgF;IAChF,SAAS,CACP,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,UAAU,GACrB,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAAC;IAE9B;;;;;;;OAOG;IACH,YAAY,CACV,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,UAAU,EACtB,SAAS,EAAE,eAAe,GACzB,OAAO,CAAC,MAAM,CAAC,CAAC;IACnB,mFAAmF;IACnF,YAAY,CACV,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,UAAU,GACrB,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAAC;IAEnC,0DAA0D;IAC1D,WAAW,CACT,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,UAAU,EACtB,QAAQ,EAAE,gBAAgB,GACzB,OAAO,CAAC,MAAM,CAAC,CAAC;IACnB,yEAAyE;IACzE,WAAW,CACT,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,UAAU,GACrB,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC,CAAC;IAEpC,sEAAsE;IACtE,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,GAAG,MAAM,CAAC;IACxF,yEAAyE;IACzE,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,GAAG,MAAM,CAAC;IAC3F,wEAAwE;IACxE,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,GAAG,MAAM,CAAC;CAC3F"}

package/dist/interfaces/registry-storage.d.ts

@@ -27,6 +27,23 @@
  *   at the storage layer. Implementations
  *   MUST NOT overwrite on conflict — per-version immutability is a
  *   load-bearing registry invariant.
+ * - {@link claimScope} MUST be an atomic first-writer-wins conditional
+ *   create: when two claims race on the same scope, EXACTLY one wins
+ *   and the loser observes `{ conflict: true }` with the winner's row
+ *   left untouched. Scope ownership is the publish-authorization
+ *   invariant — a lost race that overwrote the winner would silently
+ *   reassign every future publish under that scope.
+ * - {@link getScopeOwner} MUST observe a completed {@link claimScope}
+ *   immediately (read-your-writes strong). The publish gate's
+ *   claim-conflict path re-reads to learn the winner; a read that can
+ *   lag a durable claim would fail the losing racer's publish with a
+ *   spurious storage-inconsistency error.
+ * - {@link updateScopeOwner} MUST be conditional on the caller's read
+ *   snapshot (`expect`): the write lands only when the stored row still
+ *   matches (or is still absent, for `{ absent: true }`). On mismatch
+ *   it returns `{ conflict: true }` with the stored row untouched —
+ *   an operator rewrite MUST NOT clobber a concurrent transfer or a
+ *   racing first-publish claim.
  * - {@link getArtifactMetadata} / {@link getArtifactVersion} MUST return
  *   exactly what was last written. `null` on miss; throw on transport
  *   failure (caller decides retry).
@@ -36,6 +53,13 @@
  *   rows MUST come back ordered by `publishedAt` descending (newest
  *   first), globally correct across the full cursor chain. Without an
  *   `order`, consumers MUST treat ordering as non-deterministic.
+ * - {@link scanArtifacts} MUST apply the `tool` / `server` filter
+ *   dimensions with the shared semantics of `matchesMcpToolFilters`:
+ *   `tool` matches any binding entry with that tool name; `server`
+ *   matches entries declaring that server (bare entries never match);
+ *   together they require one entry with exactly that (server, tool)
+ *   pair. Case-sensitive exact, AND-composed with every other
+ *   dimension.
  *
  * **Failure mode:**
  * - Transport-level failures (store throttling, disk full) throw.
@@ -48,10 +72,11 @@
  *   round-trip preservation, idempotent {@link putArtifactMetadata},
  *   `putArtifactVersionIfAbsent` rejects on collision, missing returns
  *   null, `listAuthorKeys` returns only keys for the queried subject,
+ *   `deleteAuthorKey` true/false idempotency + per-subject isolation,
  *   and `order: 'recent'` newest-first ordering (single page + across
  *   the cursor chain).
  */
-import type { ArtifactScanFilter, ArtifactVersionRow, ArtifactsMetadataRow, AuthorKeyRow, CompiledBlobRow } from '../types.js';
+import type { ArtifactScanFilter, ArtifactVersionRow, ArtifactsMetadataRow, AuthorKeyRow, CompiledBlobRow, ScopeOwnerRow } from '../types.js';
 /**
  * Optional flags for {@link RegistryStorage.putAuthorKey}.
  *
@@ -79,6 +104,18 @@ export declare class AuthorKeyAlreadyExistsError extends Error {
     readonly keyId: string;
     constructor(subject: string, keyId: string);
 }
+/**
+ * The caller's read snapshot for {@link RegistryStorage.updateScopeOwner}
+ * — either the `(ownerSubject, verification)` pair the caller read, or
+ * an assertion that no row exists yet (`{ absent: true }`, the operator
+ * seed path).
+ */
+export type ScopeOwnerExpectation = {
+    readonly ownerSubject: string;
+    readonly verification: ScopeOwnerRow['verification'];
+} | {
+    readonly absent: true;
+};
 export interface RegistryStorage {
     getArtifactMetadata(artifactId: string): Promise<ArtifactsMetadataRow | null>;
     putArtifactMetadata(row: ArtifactsMetadataRow): Promise<void>;
@@ -92,6 +129,10 @@ export interface RegistryStorage {
      * When `filter.order` is `'recent'`, rows MUST be returned newest
      * first by `publishedAt`, globally correct across the full cursor
      * chain — see the Obligations section above.
+     *
+     * `filter.tool` / `filter.server` follow the shared MCP-binding
+     * filter semantics (`matchesMcpToolFilters`) — see the Obligations
+     * section above.
      */
     scanArtifacts(filter: ArtifactScanFilter): Promise<{
         readonly rows: readonly ArtifactsMetadataRow[];
@@ -201,6 +242,56 @@ export interface RegistryStorage {
         ok: false;
         reason: 'version_exists';
     }>;
+    /**
+     * Fetch the ownership row for `scope` (leading `@` included, e.g.
+     * `@acme`). Returns `null` when the scope is unclaimed.
+     *
+     * MUST be read-your-writes strong with respect to {@link claimScope}
+     * and {@link updateScopeOwner} — see the Obligations section above.
+     */
+    getScopeOwner(scope: string): Promise<ScopeOwnerRow | null>;
+    /**
+     * Atomic first-writer-wins claim — creates the ownership row only
+     * when no row exists for `row.scope`. On conflict (a row already
+     * exists, including one that landed in a concurrent race) returns
+     * `{ conflict: true }` WITHOUT touching the existing row.
+     *
+     * The publish op claims on the caller's first publish into an
+     * unclaimed scope. Consumers MUST NOT pre-check with
+     * {@link getScopeOwner} + claim as a substitute for handling
+     * `conflict` — the conditional create is the only race-safe
+     * primitive (re-read on conflict instead).
+     */
+    claimScope(row: ScopeOwnerRow): Promise<{
+        ok: true;
+    } | {
+        conflict: true;
+    }>;
+    /**
+     * Conditional full-row put of the ownership row — a compare-and-set
+     * against the caller's read snapshot.
+     *
+     * `expect` states what the caller believes is stored:
+     *   - `{ ownerSubject, verification }` — the row MUST still carry
+     *     exactly this pair (the snapshot identity of an ownership row).
+     *   - `{ absent: true }` — no row may exist yet (operator seeding).
+     *
+     * On mismatch the write is refused with `{ conflict: true }` and the
+     * stored row is untouched — the caller re-reads and retries. This is
+     * the structural defense against read-modify-write races between two
+     * operators, or between an operator write and a concurrent
+     * first-publish claim.
+     *
+     * Operator-only caller: verification flips and ownership transfers
+     * (including seeding rows for reserved scopes, which are never
+     * first-publish-claimable). The publish path MUST NOT call this —
+     * {@link claimScope} is its only write.
+     */
+    updateScopeOwner(row: ScopeOwnerRow, expect: ScopeOwnerExpectation): Promise<{
+        ok: true;
+    } | {
+        conflict: true;
+    }>;
     getAuthorKey(subject: string, keyId: string): Promise<AuthorKeyRow | null>;
     /**
      * Write an AuthorKey row. With `options.ifNotExists === true`, the
@@ -211,5 +302,19 @@ export interface RegistryStorage {
      */
     putAuthorKey(row: AuthorKeyRow, options?: PutAuthorKeyOptions): Promise<void>;
     listAuthorKeys(subject: string): Promise<readonly AuthorKeyRow[]>;
+    /**
+     * Hard-delete the row for `(subject, keyId)`. Returns `true` when a
+     * row existed and was removed, `false` when no row existed — the
+     * caller-visible idempotency signal for the delete op's
+     * `deleted: false` response. Implementations MUST NOT throw on the
+     * absent case; transport failures still throw.
+     *
+     * Hard delete is the registry's established author-key removal
+     * semantic: the durable audit trail is the public key pinned per
+     * published version (`ArtifactVersionRow.authorPublicKey` +
+     * `publishedBy`), which this delete never touches — removal only
+     * blocks FUTURE publishes signed with the key.
+     */
+    deleteAuthorKey(subject: string, keyId: string): Promise<boolean>;
 }
 //# sourceMappingURL=registry-storage.d.ts.map

package/dist/interfaces/registry-storage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry-storage.d.ts","sourceRoot":"","sources":["../../src/interfaces/registry-storage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,OAAO,KAAK,EACV,kBAAkB,EAClB,kBAAkB,EAClB,oBAAoB,EACpB,YAAY,EACZ,eAAe,EAChB,MAAM,aAAa,CAAC;AAErB;;;;;;;;;GASG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;CAChC;AAED;;;;;;;;GAQG;AACH,qBAAa,2BAA4B,SAAQ,KAAK;IACpD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;gBACX,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;CAQ3C;AAED,MAAM,WAAW,eAAe;IAE9B,mBAAmB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC,CAAC;IAC9E,mBAAmB,CAAC,GAAG,EAAE,oBAAoB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9D;;;;;;;;;;OAUG;IACH,aAAa,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC;QACjD,QAAQ,CAAC,IAAI,EAAE,SAAS,oBAAoB,EAAE,CAAC;QAC/C,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;KAC9B,CAAC,CAAC;IAGH,kBAAkB,CAChB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC,CAAC;IACtC;;;;;;;;;;;;;;;;;OAiBG;IACH,oBAAoB,CAClB,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,SAAS,kBAAkB,EAAE,CAAC,CAAC;IAC1C;;;;;OAKG;IACH,0BAA0B,CACxB,GAAG,EAAE,kBAAkB,GACtB,OAAO,CAAC;QAAE,EAAE,EAAE,IAAI,CAAA;KAAE,GAAG;QAAE,EAAE,EAAE,KAAK,CAAC;QAAC,MAAM,EAAE,gBAAgB,CAAA;KAAE,CAAC,CAAC;IACnE,mBAAmB,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAGxE;;;;;;;;;;;;;OAaG;IACH,eAAe,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAAC;IAEzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgDG;IACH,oBAAoB,CAClB,UAAU,EAAE,kBAAkB,EAC9B,OAAO,EAAE,eAAe,GACvB,OAAO,CACN;QAAE,EAAE,EAAE,IAAI,CAAC;QAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAA;KAAE,GACxC;QAAE,EAAE,EAAE,KAAK,CAAC;QAAC,MAAM,EAAE,gBAAgB,CAAA;KAAE,CAC1C,CAAC;IAGF,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAAC;IAC3E;;;;;;OAMG;IACH,YAAY,CACV,GAAG,EAAE,YAAY,EACjB,OAAO,CAAC,EAAE,mBAAmB,GAC5B,OAAO,CAAC,IAAI,CAAC,CAAC;IACjB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,YAAY,EAAE,CAAC,CAAC;CACnE"}
+{"version":3,"file":"registry-storage.d.ts","sourceRoot":"","sources":["../../src/interfaces/registry-storage.ts"],"names":[],"mappings":"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"}

package/dist/mcp-tool-filters.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Shared MCP-tool search-filter predicate — the reference semantics
+ * every {@link RegistryStorage.scanArtifacts} implementation must
+ * reproduce for the `tool` / `server` filter dimensions:
+ *
+ *   - `tool` only    → any binding entry with that tool name (with or
+ *                      without a `server`).
+ *   - `server` only  → any binding entry declaring that server; bare
+ *                      (server-less) entries never match.
+ *   - both           → a single entry with exactly that (server, tool)
+ *                      pair.
+ *   - neither        → always `true` (the filter is inactive).
+ *
+ * Matching is case-sensitive exact on both dimensions — MCP tool names
+ * are case-sensitive. AND-composes with every other scan-filter
+ * dimension; artifacts without bindings never match an active filter.
+ */
+import type { McpToolBinding } from '@ggui-ai/artifact-manifest';
+export declare function matchesMcpToolFilters(bindings: ReadonlyArray<McpToolBinding> | undefined, filters: {
+    tool?: string;
+    server?: string;
+}): boolean;
+//# sourceMappingURL=mcp-tool-filters.d.ts.map

package/dist/mcp-tool-filters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-tool-filters.d.ts","sourceRoot":"","sources":["../src/mcp-tool-filters.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAEjE,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,aAAa,CAAC,cAAc,CAAC,GAAG,SAAS,EACnD,OAAO,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GAC1C,OAAO,CAST"}