@ggui-ai/registry-core 0.7.0 → 0.9.0

package/dist/ops/read.d.ts

@@ -5,14 +5,34 @@
  *
  * Flow:
  *   1. Point-read the version row via {@link RegistryStorage.getArtifactVersion}.
- *   2. Enforce row `visibility`: `private` → require an {@link AuthnContext}.
+ *   2. Enforce row `visibility`: `private` → the caller must satisfy
+ *      {@link canReadPrivateArtifact} (publisher or scope owner).
+ *      Anyone else receives a response byte-identical to a true
+ *      not-found — no status, code, or message distinguishes "exists
+ *      but you may not read it" from "does not exist".
  *   3. Yanked → 410 with the manifest still in the body (audit-friendly).
+ *      The private gate fires FIRST — an unauthorized caller never sees
+ *      the 410 body.
  *   4. For blueprints, resolve the {@link CompiledBlobRow} via
  *      `row.compiledDigest` (two-layer content-addressed storage). A
  *      missing blob when the pointer is set is a critical storage
  *      inconsistency — the op returns 500 rather than silently
  *      omitting `compiledBytes`.
- *   5. Project the row + blob into the {@link ReadPkgResponse} wire shape.
+ *   5. Project the row + blob into the {@link ReadPkgResponse} wire shape,
+ *      including `scopeVerification`/`verifiedDomain`.
+ *
+ * Scope-owner reads (2026-08-10, MCP discovery §2): every read — public
+ * or private — now costs exactly ONE memoized {@link RegistryStorage.getScopeOwner}
+ * point-read via {@link createScopeOwnerResolver}, shared between the
+ * private-read gate (when applicable) and the `scopeVerification` /
+ * `verifiedDomain` wire projection. This deliberately SUPERSEDES the
+ * prior "public reads cost zero extra storage reads" guarantee from
+ * the private-read-ownership work ({@link ./private-read-authz.js}) —
+ * verification surfacing needs the scope row on every read, public
+ * included, so the old zero-reads pin was retired in favor of a
+ * one-read invariant instead. A failed or missing scope-owner read
+ * degrades to absent `scopeVerification`/`verifiedDomain` (never
+ * defaulted to `'unverified'`) and never fails the read itself.
  */
 import type { ReadErrorBody, ReadPkgResponse } from '../types.js';
 import type { AuthnContext } from '../interfaces/authn.js';
@@ -29,9 +49,11 @@ export interface ReadArtifactInput {
 export interface ReadArtifactDeps {
     readonly storage: RegistryStorage;
     /**
-     * Optional — when undefined, the op rejects `private` rows with 403.
-     * Cloud transport extracts from the JWT authorizer; OSS extracts from
-     * the bearer authn middleware.
+     * Optional — the verified caller context, produced by the
+     * transport's own credential verification. When the requested row
+     * is `private`, the op admits only the row's publisher or the
+     * artifact's scope owner ({@link canReadPrivateArtifact}); every
+     * other caller — anonymous included — gets the not-found shape.
      */
     readonly authn?: AuthnContext;
 }
@@ -45,7 +67,7 @@ export type ReadArtifactResult = {
     readonly body: ReadPkgResponse;
 } | {
     readonly ok: false;
-    readonly status: 400 | 403 | 404 | 500;
+    readonly status: 400 | 404 | 500;
     readonly body: ReadErrorBody;
 };
 export declare function readArtifact(input: ReadArtifactInput, deps: ReadArtifactDeps): Promise<ReadArtifactResult>;

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

@@ -1 +1 @@
-{"version":3,"file":"read.d.ts","sourceRoot":"","sources":["../../src/ops/read.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,KAAK,EAGV,aAAa,EAEb,eAAe,EAChB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAEzE,MAAM,WAAW,iBAAiB;IAChC;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;IAClC;;;;OAIG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,YAAY,CAAC;CAC/B;AAED,MAAM,MAAM,kBAAkB,GAC1B;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAA;CAAE,GAC3E;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAA;CAAE,GAC5E;IACE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IACnB,QAAQ,CAAC,MAAM,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;IACvC,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;CAC9B,CAAC;AAEN,wBAAsB,YAAY,CAChC,KAAK,EAAE,iBAAiB,EACxB,IAAI,EAAE,gBAAgB,GACrB,OAAO,CAAC,kBAAkB,CAAC,CAkE7B"}
+{"version":3,"file":"read.d.ts","sourceRoot":"","sources":["../../src/ops/read.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,OAAO,KAAK,EAGV,aAAa,EAEb,eAAe,EAEhB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAMzE,MAAM,WAAW,iBAAiB;IAChC;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;IAClC;;;;;;OAMG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,YAAY,CAAC;CAC/B;AAED,MAAM,MAAM,kBAAkB,GAC1B;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAA;CAAE,GAC3E;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAA;CAAE,GAC5E;IACE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IACnB,QAAQ,CAAC,MAAM,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;IACjC,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;CAC9B,CAAC;AAEN,wBAAsB,YAAY,CAChC,KAAK,EAAE,iBAAiB,EACxB,IAAI,EAAE,gBAAgB,GACrB,OAAO,CAAC,kBAAkB,CAAC,CA0E7B"}

package/dist/ops/read.js

@@ -1,3 +1,4 @@
+import { canReadPrivateArtifact, createScopeOwnerResolver, } from './private-read-authz.js';
 export async function readArtifact(input, deps) {
     if (typeof input.artifactId !== 'string' || input.artifactId.length === 0) {
         return errorResult(400, 'invalid_request', 'missing artifactId');
@@ -5,18 +6,33 @@ export async function readArtifact(input, deps) {
     if (typeof input.version !== 'string' || input.version.length === 0) {
         return errorResult(400, 'invalid_request', 'missing version');
     }
+    // Scope-owner resolver — memoized, so the private-read gate and the
+    // verification surfacing share at most ONE storage read. Fail-closed:
+    // a storage fault resolves null, which denies on the private gate and
+    // omits the verification fields (state unknown is not 'unverified').
+    const resolveScopeOwner = createScopeOwnerResolver(deps.storage, input.artifactId);
     let row;
     try {
         row = await deps.storage.getArtifactVersion(input.artifactId, input.version);
     }
     catch (err) {
-        return errorResult(500, 'server_error', `failed to read package: ${err instanceof Error ? err.message : String(err)}`);
+        logStorageFailure('read version row', input.artifactId, err);
+        return errorResult(500, 'server_error', 'failed to read package');
     }
     if (row === null) {
-        return errorResult(404, 'not_found', `package ${input.artifactId}@${input.version} not found`);
+        return notFoundResult(input);
     }
-    if (row.visibility === 'private' && deps.authn === undefined) {
-        return errorResult(403, 'forbidden', 'private package requires authentication');
+    if (row.visibility === 'private') {
+        // Ownership gate — publisher or scope owner only. The
+        // unauthorized response is produced by the SAME function as a
+        // true miss so the two are structurally indistinguishable. The
+        // resolver is fail-closed: a storage fault during the owner
+        // lookup denies (logged server-side) rather than erroring — a
+        // 500 only private rows could trigger would leak existence.
+        const allowed = await canReadPrivateArtifact(deps.authn, row, resolveScopeOwner);
+        if (!allowed) {
+            return notFoundResult(input);
+        }
     }
     // Two-layer resolution — blueprint rows carry a pointer into the
     // compiled-blob table. Yanked rows still resolve so the 410
@@ -28,7 +44,8 @@ export async function readArtifact(input, deps) {
             compiledBlob = await deps.storage.getCompiledBlob(row.compiledDigest);
         }
         catch (err) {
-            return errorResult(500, 'server_error', `failed to read compiled blob for compiledDigest=${row.compiledDigest}: ${err instanceof Error ? err.message : String(err)}`);
+            logStorageFailure('read compiled blob', input.artifactId, err);
+            return errorResult(500, 'server_error', `failed to read compiled blob for compiledDigest=${row.compiledDigest}`);
         }
         if (compiledBlob === null) {
             // CRITICAL — version row points at a digest with no blob.
@@ -36,13 +53,14 @@ export async function readArtifact(input, deps) {
             return errorResult(500, 'server_error', `version row points at compiledDigest=${row.compiledDigest} but no compiled-blob row exists`);
         }
     }
-    const body = rowToResponse(row, compiledBlob);
+    const scopeOwner = await resolveScopeOwner();
+    const body = rowToResponse(row, compiledBlob, scopeOwner);
     if (row.yanked === true) {
         return { ok: false, status: 410, body };
     }
     return { ok: true, status: 200, body };
 }
-function rowToResponse(row, compiledBlob) {
+function rowToResponse(row, compiledBlob, scopeOwner) {
     return {
         manifest: row.manifest,
         bundleUrl: row.bundleUrl,
@@ -53,8 +71,30 @@ function rowToResponse(row, compiledBlob) {
         authorPublicKey: row.authorPublicKey,
         publishedAt: row.publishedAt,
         publishedBy: row.publishedBy,
+        scopeVerification: scopeOwner?.verification,
+        verifiedDomain: scopeOwner?.verification === 'verified' ? scopeOwner.verifiedDomain : undefined,
     };
 }
+/**
+ * Structured server-side failure log. Raw storage error text stays
+ * OUT of wire bodies (it can carry backend identifiers a caller has
+ * no business seeing); this log line is the operator's copy.
+ */
+function logStorageFailure(operation, artifactId, err) {
+    // eslint-disable-next-line no-console -- server-side operator signal; the wire stays generic
+    console.error(`registry read: failed to ${operation}`, {
+        artifactId,
+        error: err instanceof Error ? err.message : String(err),
+    });
+}
+/**
+ * The one not-found projection — used for BOTH a true miss and an
+ * unauthorized private read, so the two responses cannot drift apart
+ * (drift would reintroduce the existence signal).
+ */
+function notFoundResult(input) {
+    return errorResult(404, 'not_found', `package ${input.artifactId}@${input.version} not found`);
+}
 function errorResult(status, error, message) {
     return { ok: false, status, body: { error, message } };
 }

package/dist/ops/search.d.ts

@@ -2,12 +2,15 @@
  * `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.
- * Impls SHOULD apply the visibility filter inside `scanArtifacts`; the
- * op verifies defensively after the page returns.
+ * Impls MUST apply the visibility filter inside `scanArtifacts` — the
+ * normative obligation on {@link RegistryStorage.scanArtifacts} (#474);
+ * this op's post-fetch check is defense-in-depth ONLY, never the sole
+ * gate (a private row that reaches the storage-layer page would
+ * consume a `limit` slot before this filter ever discards it).
  */
 import type { SearchErrorBody, SearchResponse } from '../types.js';
 import type { RegistryStorage } from '../interfaces/registry-storage.js';
@@ -31,6 +34,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;;;;;;;;;;;;;GAaG;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.map

@@ -1 +1 @@
-{"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,CAkqBhF"}
+{"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,CA01BhF"}