@ggui-ai/registry-core 0.8.0 → 0.9.0

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

@@ -174,6 +174,13 @@ function parseCursor(cursor) {
     return n;
 }
 function rowMatchesFilter(row, q) {
+    // #474 — visibility gating lives INSIDE every scanArtifacts impl
+    // (the ruled canonical location); the search op's post-filter stays
+    // as defense-in-depth. Without this, private rows would consume
+    // page slots on self-host impls even though the op filters them out
+    // before they ever reach the wire.
+    if (row.visibility !== 'public')
+        return false;
     if (q.kind !== undefined && row.kind !== q.kind)
         return false;
     if (q.hook !== undefined && row.hook !== q.hook)

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

@@ -60,6 +60,14 @@
  *   together they require one entry with exactly that (server, tool)
  *   pair. Case-sensitive exact, AND-composed with every other
  *   dimension.
+ * - {@link scanArtifacts} MUST exclude non-public rows
+ *   (`visibility !== 'public'`) — visibility gating lives INSIDE every
+ *   impl, not only at the caller layer (#259 delta-2 final-review
+ *   ruling, #474). {@link searchArtifacts}'s post-fetch visibility
+ *   filter is defense-in-depth ONLY; it must never be the sole gate,
+ *   because a private row that reaches the storage-layer page would
+ *   consume a `limit` slot before the op ever gets to discard it —
+ *   an observable underfill on self-host impls.
  *
  * **Failure mode:**
  * - Transport-level failures (store throttling, disk full) throw.
@@ -73,8 +81,11 @@
  *   `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).
+ *   `order: 'recent'` newest-first ordering (single page + across the
+ *   cursor chain), the `tool` / `server` filter dimensions (tool-only,
+ *   server-only with bare-entry exclusion, and the exact-pair
+ *   cross-product case), and non-public rows never appearing in
+ *   `scanArtifacts` results OR consuming a `limit` page slot.
  */
 import type { ArtifactScanFilter, ArtifactVersionRow, ArtifactsMetadataRow, AuthorKeyRow, CompiledBlobRow, ScopeOwnerRow } from '../types.js';
 /**

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":"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"}
+{"version":3,"file":"registry-storage.d.ts","sourceRoot":"","sources":["../../src/interfaces/registry-storage.ts"],"names":[],"mappings":"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"}

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

@@ -1 +1 @@
-{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../src/ops/compile.ts"],"names":[],"mappings":"AAoDA,uEAAuE;AACvE,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAClB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B;AAED,2EAA2E;AAC3E,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IACnB,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;QAC7B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;QACzB,QAAQ,CAAC,QAAQ,CAAC,EAAE;YAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;YAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC;KAC1E,CAAC,CAAC;CACJ;AAED,MAAM,MAAM,sBAAsB,GAAG,kBAAkB,GAAG,mBAAmB,CAAC;AAE9E;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,sBAAsB,CA4CvE"}
+{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../src/ops/compile.ts"],"names":[],"mappings":"AAwEA,uEAAuE;AACvE,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAClB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B;AAED,2EAA2E;AAC3E,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IACnB,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;QAC7B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;QACzB,QAAQ,CAAC,QAAQ,CAAC,EAAE;YAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;YAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC;KAC1E,CAAC,CAAC;CACJ;AAED,MAAM,MAAM,sBAAsB,GAAG,kBAAkB,GAAG,mBAAmB,CAAC;AAE9E;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,sBAAsB,CA6CvE"}

package/dist/ops/compile.js

@@ -46,9 +46,26 @@
  * load-bearing one (its OUTPUT is what's stored), but the two are
  * deliberately separate so a `POST /conformance/check` dry-run
  * remains cheap (no bundle resolution).
+ *
+ * **Lazy dependency load.** `esbuild` ships its own platform-specific
+ * native binary; loading it costs real init time and can fail outright
+ * on a host with no matching binary for the running platform. Callers
+ * that never reach `compileBlueprint` (most registry operations don't
+ * touch blueprint compilation) shouldn't pay that cost just for
+ * importing this module. `esbuild` resolves as an ordinary CommonJS
+ * package, so a `require()` obtained via `createRequire` defers the
+ * load to the first actual call, memoized at module scope so a
+ * long-lived process only pays it once — with NO change to
+ * {@link compileBlueprint}'s synchronous signature.
  */
-import * as esbuild from 'esbuild';
+import { createRequire } from 'node:module';
 import { createHash } from 'node:crypto';
+const nodeRequire = createRequire(import.meta.url);
+let esbuildModule;
+/** Lazy, memoized `esbuild` accessor — see the file-level doc above. */
+function loadEsbuild() {
+    return (esbuildModule ??= nodeRequire('esbuild'));
+}
 /**
  * Compile a blueprint's TSX `source` into canonical compiled JS bytes.
  *
@@ -63,6 +80,7 @@ import { createHash } from 'node:crypto';
  */
 export function compileBlueprint(source) {
     try {
+        const esbuild = loadEsbuild();
         // esbuild.buildSync would require a virtual-fs layer to handle
         // imports; we use transformSync which compiles a single text input
         // and emits a single text output. Tree-shaking is OFF and externals

package/dist/ops/conformance.d.ts

@@ -65,7 +65,7 @@
  * registry-core to keep this layer free of DOM-emulation deps.
  */
 import { type ArtifactManifest } from '@ggui-ai/artifact-manifest';
-import { type StaticExport, type StaticImport } from 'oxc-parser';
+import type { StaticExport, StaticImport } from 'oxc-parser';
 /**
  * Body shape of the conformance request. `bundle` is the UTF-8 text of
  * the compiled gadget entry; required for `kind: "gadget"` manifests,
@@ -116,16 +116,19 @@ export interface ConformanceResponseBody {
  */
 export declare const MAX_BLUEPRINT_SOURCE_BYTES: number;
 /**
- * Run the conformance check synchronously. Pure function: no
- * network, no env lookups. Returns the locked response body shape.
- * Every registry transport and the publish op call this.
+ * Run the conformance check. Pure beyond the (memoized, in-process)
+ * `oxc-parser` load: no network, no env lookups. Resolves to the
+ * locked response body shape. Every registry transport and the
+ * publish op call this — all are already async, so awaiting here adds
+ * no restructuring on the caller side; see `loadOxcParser`'s doc for
+ * why this can't stay synchronous.
  *
  * Static gates only — the optional runtime probe lives behind a
  * {@link BlueprintProbeRunner} seam so registry-core stays free of
  * DOM-emulation deps (happy-dom + react-dom/server land in the caller
  * that wants the probe).
  */
-export declare function checkConformance(payload: ConformanceRequestPayload): ConformanceResponseBody;
+export declare function checkConformance(payload: ConformanceRequestPayload): Promise<ConformanceResponseBody>;
 /**
  * Runtime-probe seam. Implemented by callers that opt into the
  * sandboxed render check. registry-core does not provide a default

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

@@ -1 +1 @@
-{"version":3,"file":"conformance.d.ts","sourceRoot":"","sources":["../../src/ops/conformance.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiEG;AACH,OAAO,EAEL,KAAK,gBAAgB,EACtB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAGL,KAAK,YAAY,EACjB,KAAK,YAAY,EAClB,MAAM,YAAY,CAAC;AAGpB;;;;GAIG;AACH,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,oBAAoB,GAC5B,kBAAkB,GAClB,oBAAoB,GACpB,mBAAmB,GACnB,wBAAwB,GACxB,4BAA4B,GAC5B,yBAAyB,GACzB,6BAA6B,GAC7B,kCAAkC,GAClC,8BAA8B,GAC9B,gCAAgC,CAAC;AAErC,MAAM,MAAM,sBAAsB,GAAG,oBAAoB,CAAC;AAE1D,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CAAC;IACpC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB;;;;OAIG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;IAC7C;;;OAGG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,MAAM,EAAE,SAAS,gBAAgB,EAAE,CAAC;CAC9C;AAkBD;;;;;;;GAOG;AACH,eAAO,MAAM,0BAA0B,QAAkB,CAAC;AAE1D;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,yBAAyB,GACjC,uBAAuB,CAgBzB;AAmbD;;;;;;;;;;GAUG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;;;;OAMG;IACH,KAAK,CACH,QAAQ,EAAE,OAAO,CAAC,gBAAgB,EAAE;QAAE,IAAI,EAAE,WAAW,CAAA;KAAE,CAAC,GACzD,OAAO,CAAC,uBAAuB,CAAC,CAAC;CACrC;AAED,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,CAAC"}
+{"version":3,"file":"conformance.d.ts","sourceRoot":"","sources":["../../src/ops/conformance.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiEG;AACH,OAAO,EAEL,KAAK,gBAAgB,EACtB,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAEV,YAAY,EACZ,YAAY,EACb,MAAM,YAAY,CAAC;AA4BpB;;;;GAIG;AACH,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,oBAAoB,GAC5B,kBAAkB,GAClB,oBAAoB,GACpB,mBAAmB,GACnB,wBAAwB,GACxB,4BAA4B,GAC5B,yBAAyB,GACzB,6BAA6B,GAC7B,kCAAkC,GAClC,8BAA8B,GAC9B,gCAAgC,CAAC;AAErC,MAAM,MAAM,sBAAsB,GAAG,oBAAoB,CAAC;AAE1D,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CAAC;IACpC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB;;;;OAIG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;IAC7C;;;OAGG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,MAAM,EAAE,SAAS,gBAAgB,EAAE,CAAC;CAC9C;AAkBD;;;;;;;GAOG;AACH,eAAO,MAAM,0BAA0B,QAAkB,CAAC;AAE1D;;;;;;;;;;;;GAYG;AACH,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,yBAAyB,GACjC,OAAO,CAAC,uBAAuB,CAAC,CAgBlC;AAqbD;;;;;;;;;;GAUG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;;;;OAMG;IACH,KAAK,CACH,QAAQ,EAAE,OAAO,CAAC,gBAAgB,EAAE;QAAE,IAAI,EAAE,WAAW,CAAA;KAAE,CAAC,GACzD,OAAO,CAAC,uBAAuB,CAAC,CAAC;CACrC;AAED,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,CAAC"}

package/dist/ops/conformance.js

@@ -65,7 +65,30 @@
  * registry-core to keep this layer free of DOM-emulation deps.
  */
 import { safeParseArtifactManifest, } from '@ggui-ai/artifact-manifest';
-import { parseSync, } from 'oxc-parser';
+import { memoizedRetryingImport } from '../utils/lazy-import.js';
+/**
+ * Lazy, memoized `oxc-parser` accessor. `oxc-parser` ships its own
+ * platform-specific native binding; loading it costs real init time
+ * and can fail outright on a host with no matching binding for the
+ * running platform. Callers that never reach the parse gates (most
+ * registry operations don't touch bundle/source conformance) shouldn't
+ * pay that cost just for importing this module — or the barrel that
+ * re-exports it.
+ *
+ * `oxc-parser` ships ESM-only (no CommonJS entry point), so a dynamic
+ * `import()` is the only way to defer the load — unlike `esbuild` in
+ * `compile.ts`, there's no synchronous `require()` path available.
+ * That's what pushes {@link checkConformance} (and everything that
+ * calls it) from a plain synchronous function to one returning a
+ * `Promise`. {@link memoizedRetryingImport} memoizes the promise at
+ * module scope — concurrent first callers share one in-flight load,
+ * and a long-lived process pays the import cost at most once per
+ * successful load — while clearing the cache on rejection, so a
+ * failed load doesn't poison every later call for the rest of the
+ * process (see that helper's doc for why a bare `??=` isn't safe
+ * here).
+ */
+const loadOxcParser = memoizedRetryingImport(() => import('oxc-parser'));
 /**
  * Always-permitted import sources for gadget bundles. Mirrors the
  * runtime CSP the iframe enforces — these are the only modules the
@@ -91,16 +114,19 @@ const ALWAYS_ALLOWED_IMPORTS = new Set([
  */
 export const MAX_BLUEPRINT_SOURCE_BYTES = 5 * 1024 * 1024;
 /**
- * Run the conformance check synchronously. Pure function: no
- * network, no env lookups. Returns the locked response body shape.
- * Every registry transport and the publish op call this.
+ * Run the conformance check. Pure beyond the (memoized, in-process)
+ * `oxc-parser` load: no network, no env lookups. Resolves to the
+ * locked response body shape. Every registry transport and the
+ * publish op call this — all are already async, so awaiting here adds
+ * no restructuring on the caller side; see `loadOxcParser`'s doc for
+ * why this can't stay synchronous.
  *
  * Static gates only — the optional runtime probe lives behind a
  * {@link BlueprintProbeRunner} seam so registry-core stays free of
  * DOM-emulation deps (happy-dom + react-dom/server land in the caller
  * that wants the probe).
  */
-export function checkConformance(payload) {
+export async function checkConformance(payload) {
     // ── Gate 1: manifest schema ────────────────────────────────────────
     const manifestResult = safeParseArtifactManifest(payload.manifest);
     if (!manifestResult.success) {
@@ -120,7 +146,7 @@ export function checkConformance(payload) {
  * Extracted from {@link checkConformance} so the blueprint branch can
  * stand on its own without nesting.
  */
-function checkGadgetConformance(manifest, bundle) {
+async function checkGadgetConformance(manifest, bundle) {
     // ── Gate 2: bundle is parseable ESM ────────────────────────────────
     if (typeof bundle !== 'string' || bundle.length === 0) {
         return {
@@ -133,6 +159,7 @@ function checkGadgetConformance(manifest, bundle) {
             ],
         };
     }
+    const { parseSync } = await loadOxcParser();
     const parsed = parseSync('bundle.js', bundle, {
         lang: 'js',
         sourceType: 'module',
@@ -204,7 +231,7 @@ function checkGadgetConformance(manifest, bundle) {
  * shape. Static-only; the runtime probe lives behind the optional
  * {@link BlueprintProbeRunner} seam.
  */
-function checkBlueprintConformance(manifest) {
+async function checkBlueprintConformance(manifest) {
     // ── Gate 5: source size ──────────────────────────────────────────
     const sourceBytes = utf8ByteLength(manifest.source);
     if (sourceBytes > MAX_BLUEPRINT_SOURCE_BYTES) {
@@ -225,6 +252,7 @@ function checkBlueprintConformance(manifest) {
     // (not a compiled output) is deliberate — author intent (including
     // unused imports that signal mis-configured deps) is what the
     // allow-list gates, not whatever a bundler would optimize away.
+    const { parseSync } = await loadOxcParser();
     const parsed = parseSync('blueprint.tsx', manifest.source, {
         lang: 'tsx',
         sourceType: 'module',

package/dist/ops/publish.js

@@ -353,7 +353,7 @@ export async function publishArtifact(input, deps) {
     const conformanceBundleText = bundleBytes === undefined
         ? undefined
         : Buffer.from(bundleBytes.buffer, bundleBytes.byteOffset, bundleBytes.byteLength).toString('utf8');
-    const conformanceResult = checkConformance({
+    const conformanceResult = await checkConformance({
         manifest,
         bundle: conformanceBundleText,
     });

package/dist/ops/search.d.ts

@@ -6,8 +6,11 @@
  *
  * 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';

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,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"}
+{"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/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,CAgzBhF"}
+{"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"}

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

@@ -161,6 +161,32 @@ export function registryStorageContract(makeStorage) {
                 const ids = page.rows.map((r) => r.artifactId).sort();
                 expect(ids).toEqual(['@a/1', '@b/2']);
             });
+            // #474 — visibility gating is ruled to live INSIDE every
+            // scanArtifacts impl (the search op's post-filter stays as
+            // defense-in-depth, but must never be the ONLY gate — otherwise
+            // private rows consume page slots on self-host impls, an
+            // observable underfill).
+            it('excludes private rows from scanArtifacts results (#474)', async () => {
+                const storage = makeStorage();
+                await storage.putArtifactMetadata(makeMetadata({ artifactId: '@a/secret', visibility: 'private' }));
+                await storage.putArtifactMetadata(makeMetadata({ artifactId: '@a/public', visibility: 'public' }));
+                const page = await storage.scanArtifacts({});
+                expect(page.rows.map((r) => r.artifactId)).toEqual(['@a/public']);
+            });
+            it('private rows never consume a page slot — a `limit` is satisfied entirely from public rows (#474)', async () => {
+                const storage = makeStorage();
+                // Private rows interleaved with public ones. If private rows
+                // consumed limit slots (visibility filtered only at the op
+                // layer, after pagination), a limit=2 request could return
+                // fewer than 2 public rows.
+                await storage.putArtifactMetadata(makeMetadata({ artifactId: '@a/priv1', visibility: 'private' }));
+                await storage.putArtifactMetadata(makeMetadata({ artifactId: '@a/pub1', visibility: 'public' }));
+                await storage.putArtifactMetadata(makeMetadata({ artifactId: '@a/priv2', visibility: 'private' }));
+                await storage.putArtifactMetadata(makeMetadata({ artifactId: '@a/pub2', visibility: 'public' }));
+                await storage.putArtifactMetadata(makeMetadata({ artifactId: '@a/priv3', visibility: 'private' }));
+                const page = await storage.scanArtifacts({ limit: 2 });
+                expect(page.rows.map((r) => r.artifactId).sort()).toEqual(['@a/pub1', '@a/pub2']);
+            });
             it('filters by kind', async () => {
                 const storage = makeStorage();
                 await storage.putArtifactMetadata(makeMetadata({ artifactId: '@a/g', kind: 'gadget' }));

package/dist/utils/lazy-import.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Memoizing wrapper around a lazy async load. Caches the in-flight (or
+ * already-resolved) promise so concurrent and later callers share one
+ * load — but clears the cache on rejection, so a failed attempt
+ * doesn't poison every later call for the rest of the process.
+ *
+ * A rejected promise is still a defined value, so a bare
+ * `cached ??= loader()` would cache the failure permanently: every
+ * later call would re-throw the same stale rejection even once
+ * whatever caused it (a transient resolution failure, a missing
+ * optional dependency on first use, …) is no longer true. This
+ * wrapper resets the cache to `undefined` on rejection so the next
+ * call starts a fresh attempt, while still deduping callers that
+ * arrive while an attempt is in flight.
+ */
+export declare function memoizedRetryingImport<T>(loader: () => Promise<T>): () => Promise<T>;
+//# sourceMappingURL=lazy-import.d.ts.map

package/dist/utils/lazy-import.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazy-import.d.ts","sourceRoot":"","sources":["../../src/utils/lazy-import.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,MAAM,OAAO,CAAC,CAAC,CAAC,CAWpF"}

package/dist/utils/lazy-import.js

@@ -0,0 +1,27 @@
+/**
+ * Memoizing wrapper around a lazy async load. Caches the in-flight (or
+ * already-resolved) promise so concurrent and later callers share one
+ * load — but clears the cache on rejection, so a failed attempt
+ * doesn't poison every later call for the rest of the process.
+ *
+ * A rejected promise is still a defined value, so a bare
+ * `cached ??= loader()` would cache the failure permanently: every
+ * later call would re-throw the same stale rejection even once
+ * whatever caused it (a transient resolution failure, a missing
+ * optional dependency on first use, …) is no longer true. This
+ * wrapper resets the cache to `undefined` on rejection so the next
+ * call starts a fresh attempt, while still deduping callers that
+ * arrive while an attempt is in flight.
+ */
+export function memoizedRetryingImport(loader) {
+    let cached;
+    return () => {
+        if (cached === undefined) {
+            cached = loader().catch((err) => {
+                cached = undefined;
+                throw err;
+            });
+        }
+        return cached;
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ggui-ai/registry-core",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Pure-TypeScript registry operations and storage interfaces for the ggui marketplace. No I/O, no HTTP — operations take typed inputs plus a storage deps bag and return discriminated-union results.",
   "keywords": [
     "ggui",
@@ -54,9 +54,9 @@
     "esbuild": "0.25.12",
     "oxc-parser": "^0.131.0",
     "zod": "^4.3.6",
-    "@ggui-ai/artifact-manifest": "0.8.0",
-    "@ggui-ai/gadget-signing": "0.8.0",
-    "@ggui-ai/protocol": "0.8.0"
+    "@ggui-ai/protocol": "0.9.0",
+    "@ggui-ai/artifact-manifest": "0.9.0",
+    "@ggui-ai/gadget-signing": "0.9.0"
   },
   "peerDependenciesMeta": {
     "vitest": {
@@ -71,7 +71,7 @@
     "nock": "^13.5.6",
     "typescript": "^5.0.0",
     "vitest": "^3.2.6",
-    "@ggui-ai/protocol-conformance": "0.8.0"
+    "@ggui-ai/protocol-conformance": "0.9.0"
   },
   "repository": {
     "type": "git",