@decocms/start 2.28.2 → 2.30.0

package/scripts/migrate/templates/github-workflows.ts

@@ -0,0 +1,98 @@
+// Caller workflow stubs for new sites. Each stub delegates to a reusable
+// workflow under `decocms/deco-start/.github/workflows/` -- the customer repo
+// holds no deploy/build logic of its own. See D6 in
+// `.cursor/rules/migration-tooling-policy.mdc` and the `deploy/` directory
+// for the central registry contract.
+
+const DEPLOY_YML = `name: Deploy
+
+# Thin caller for decocms/deco-start's central deploy workflow.
+
+on:
+  push:
+    branches: [main]
+
+permissions:
+  contents: write
+
+jobs:
+  deploy:
+    uses: decocms/deco-start/.github/workflows/deploy.yml@v2
+    secrets: inherit
+`;
+
+const PREVIEW_YML = `name: Preview
+
+# Thin caller for decocms/deco-start's central preview workflow.
+
+on:
+  repository_dispatch:
+    types: [preview-deploy]
+  pull_request:
+    types: [opened, synchronize, reopened]
+  push:
+    branches: ['env/**']
+
+permissions:
+  contents: read
+  pull-requests: write
+  statuses: write
+
+jobs:
+  preview:
+    uses: decocms/deco-start/.github/workflows/preview.yml@v2
+    secrets: inherit
+`;
+
+const REGEN_BLOCKS_YML = `name: Regenerate blocks.gen.json
+
+# Thin caller for decocms/deco-start's central regen-blocks workflow.
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - ".deco/blocks/**"
+
+permissions:
+  contents: write
+
+jobs:
+  regen:
+    uses: decocms/deco-start/.github/workflows/regen-blocks.yml@v2
+    secrets: inherit
+`;
+
+const SYNC_SECRETS_YML = `name: Sync worker secrets
+
+# Thin caller for decocms/deco-start's central sync-secrets workflow.
+
+on:
+  workflow_dispatch:
+    inputs:
+      mode:
+        description: "dry-run = print diff only | apply = set secrets on worker"
+        required: true
+        default: "dry-run"
+        type: choice
+        options: [dry-run, apply]
+
+permissions:
+  contents: read
+
+jobs:
+  sync:
+    uses: decocms/deco-start/.github/workflows/sync-secrets.yml@v2
+    with:
+      mode: \${{ inputs.mode }}
+    secrets: inherit
+`;
+
+export function generateGithubWorkflows(): Record<string, string> {
+  return {
+    ".github/workflows/deploy.yml": DEPLOY_YML,
+    ".github/workflows/preview.yml": PREVIEW_YML,
+    ".github/workflows/regen-blocks.yml": REGEN_BLOCKS_YML,
+    ".github/workflows/sync-secrets.yml": SYNC_SECRETS_YML,
+  };
+}

package/scripts/migrate/templates/package-json.ts

@@ -109,8 +109,15 @@ export function generatePackageJson(ctx: MigrationContext): string {
       build:
         "npm run generate:blocks && npm run generate:sections && npm run generate:loaders && npm run generate:schema && npm run generate:invoke && tsr generate && vite build",
       preview: "vite preview",
-      deploy: "npm run build && wrangler deploy",
-      types: "wrangler types",
+      // wrangler.jsonc is generated by `deco-wrangler gen` from the central
+      // registry in @decocms/start (D6). Predev/prebuild ensure it is up to
+      // date before vite runs the @cloudflare/vite-plugin which reads it.
+      "gen:wrangler": "deco-wrangler gen",
+      predev: "deco-wrangler gen",
+      prebuild: "deco-wrangler gen",
+      deploy:
+        "echo 'Production deploys are managed by .github/workflows/deploy.yml on push to main. For an emergency manual deploy run: npx deco-wrangler deploy'; exit 1",
+      types: "deco-wrangler types",
       typecheck: "tsc --noEmit",
       format: 'prettier --write "src/**/*.{ts,tsx}"',
       "format:check": 'prettier --check "src/**/*.{ts,tsx}"',

package/src/cms/resolve.ts

@@ -1,9 +1,15 @@
+import {
+  type ActionConfig,
+  type LoaderConfig,
+  registerActionSchemas,
+  registerLoaderSchemas,
+} from "../admin/schema";
+import { getMeter, MetricNames, withTracing } from "../middleware/observability";
+import { djb2Hex } from "../sdk/djb2";
+import { normalizeUrlsInObject } from "../sdk/normalizeUrls";
 import { findPageByPath, loadBlocks } from "./loader";
 import { getOnBeforeResolveProps, getSection, registerOnBeforeResolveProps } from "./registry";
 import { isLayoutSection, runSingleSectionLoader } from "./sectionLoaders";
-import { normalizeUrlsInObject } from "../sdk/normalizeUrls";
-import { djb2Hex } from "../sdk/djb2";
-import { registerLoaderSchemas, registerActionSchemas, type LoaderConfig, type ActionConfig } from "../admin/schema";
 
 // globalThis-backed: share state across Vite server function split modules
 const G = globalThis as any;
@@ -134,10 +140,7 @@ export function setAsyncRenderingConfig(config?: {
   respectCmsLazy?: boolean;
 }): void {
   const existing = getAsyncConfig();
-  const merged = new Set([
-    ...(existing?.alwaysEager ?? []),
-    ...(config?.alwaysEager ?? []),
-  ]);
+  const merged = new Set([...(existing?.alwaysEager ?? []), ...(config?.alwaysEager ?? [])]);
   G.__deco.asyncConfig = {
     respectCmsLazy: config?.respectCmsLazy ?? existing?.respectCmsLazy ?? true,
     foldThreshold: config?.foldThreshold ?? existing?.foldThreshold ?? Infinity,
@@ -321,7 +324,13 @@ export function registerCommerceLoaders(loaders: Record<string, CommerceLoader>)
     if (key.includes("/actions/")) {
       actionConfigs.push({ key, title: key, namespace, propsSchema: schema });
     } else {
-      loaderConfigs.push({ key, title: key, namespace, propsSchema: schema, tags: inferLoaderTags(key) });
+      loaderConfigs.push({
+        key,
+        title: key,
+        namespace,
+        propsSchema: schema,
+        tags: inferLoaderTags(key),
+      });
     }
   }
 
@@ -374,18 +383,24 @@ export function registerMatcher(
 if (!G.__deco._builtinMatchersRegistered) {
   G.__deco._builtinMatchersRegistered = true;
 
-  const builtinMatchers: Record<string, (rule: Record<string, unknown>, ctx: MatcherContext) => boolean> = {
+  const builtinMatchers: Record<
+    string,
+    (rule: Record<string, unknown>, ctx: MatcherContext) => boolean
+  > = {
     "website/matchers/always.ts": () => true,
     "$live/matchers/MatchAlways.ts": () => true,
     "website/matchers/never.ts": () => false,
     "website/matchers/device.ts": (rule, ctx) => {
       const ua = (ctx.userAgent || "").toLowerCase();
       const isTablet = /ipad|android(?!.*mobile)|tablet/i.test(ua);
-      const isMobile = !isTablet && /mobile|android|iphone|ipod|webos|blackberry|opera mini|iemobile/i.test(ua);
+      const isMobile =
+        !isTablet && /mobile|android|iphone|ipod|webos|blackberry|opera mini|iemobile/i.test(ua);
       const isDesktop = !isMobile && !isTablet;
       // If no flags are set, match everything (permissive default)
       if (!rule.mobile && !rule.tablet && !rule.desktop) return true;
-      return !!(rule.mobile && isMobile) || !!(rule.tablet && isTablet) || !!(rule.desktop && isDesktop);
+      return (
+        !!(rule.mobile && isMobile) || !!(rule.tablet && isTablet) || !!(rule.desktop && isDesktop)
+      );
     },
     "website/matchers/random.ts": (rule) => {
       const traffic = typeof rule.traffic === "number" ? rule.traffic : 0.5;
@@ -457,7 +472,10 @@ function ensureInitialized() {
 // Matcher evaluation
 // ---------------------------------------------------------------------------
 
-export function evaluateMatcher(rule: Record<string, unknown> | undefined, ctx: MatcherContext): boolean {
+export function evaluateMatcher(
+  rule: Record<string, unknown> | undefined,
+  ctx: MatcherContext,
+): boolean {
   if (!rule) return true;
 
   const resolveType = rule.__resolveType as string | undefined;
@@ -828,10 +846,7 @@ export async function resolvePageSeoBlock(
     }
 
     // Multivariate flag — evaluate matcher and follow matched variant
-    if (
-      rt === "website/flags/multivariate.ts" ||
-      rt === "website/flags/multivariate/section.ts"
-    ) {
+    if (rt === "website/flags/multivariate.ts" || rt === "website/flags/multivariate/section.ts") {
       const variants = current.variants as Array<{ value: unknown; rule?: unknown }> | undefined;
       if (!variants?.length) return null;
       let matched: unknown = null;
@@ -909,10 +924,7 @@ function isRawSectionLayout(section: unknown): string | null {
  * unwrapping Lazy/Deferred wrappers, and evaluating multivariate flags.
  * Returns null if not determinable.
  */
-function resolveFinalSectionKey(
-  section: unknown,
-  matcherCtx?: MatcherContext,
-): string | null {
+function resolveFinalSectionKey(section: unknown, matcherCtx?: MatcherContext): string | null {
   if (!section || typeof section !== "object") return null;
 
   const blocks = loadBlocks();
@@ -946,13 +958,8 @@ function resolveFinalSectionKey(
       continue;
     }
 
-    if (
-      rt === WELL_KNOWN_TYPES.MULTIVARIATE ||
-      rt === WELL_KNOWN_TYPES.MULTIVARIATE_SECTION
-    ) {
-      const variants = current.variants as
-        | Array<{ value: unknown; rule?: unknown }>
-        | undefined;
+    if (rt === WELL_KNOWN_TYPES.MULTIVARIATE || rt === WELL_KNOWN_TYPES.MULTIVARIATE_SECTION) {
+      const variants = current.variants as Array<{ value: unknown; rule?: unknown }> | undefined;
       if (!variants?.length) return null;
 
       let matched: unknown = null;
@@ -999,21 +1006,13 @@ function isCmsDeferralWrapped(section: unknown, matcherCtx?: MatcherContext): bo
     const rt = current.__resolveType as string | undefined;
     if (!rt) return false;
 
-    if (
-      rt === WELL_KNOWN_TYPES.LAZY ||
-      rt === WELL_KNOWN_TYPES.DEFERRED
-    ) {
+    if (rt === WELL_KNOWN_TYPES.LAZY || rt === WELL_KNOWN_TYPES.DEFERRED) {
       return true;
     }
 
     // Walk through multivariate flags to check the matched variant
-    if (
-      rt === WELL_KNOWN_TYPES.MULTIVARIATE ||
-      rt === WELL_KNOWN_TYPES.MULTIVARIATE_SECTION
-    ) {
-      const variants = current.variants as
-        | Array<{ value: unknown; rule?: unknown }>
-        | undefined;
+    if (rt === WELL_KNOWN_TYPES.MULTIVARIATE || rt === WELL_KNOWN_TYPES.MULTIVARIATE_SECTION) {
+      const variants = current.variants as Array<{ value: unknown; rule?: unknown }> | undefined;
       if (!variants?.length) return false;
 
       let matched: unknown = null;
@@ -1125,13 +1124,8 @@ function resolveSectionShallow(
     }
 
     // Multivariate flags — evaluate matchers and continue with matched variant
-    if (
-      rt === WELL_KNOWN_TYPES.MULTIVARIATE ||
-      rt === WELL_KNOWN_TYPES.MULTIVARIATE_SECTION
-    ) {
-      const variants = current.variants as
-        | Array<{ value: unknown; rule?: unknown }>
-        | undefined;
+    if (rt === WELL_KNOWN_TYPES.MULTIVARIATE || rt === WELL_KNOWN_TYPES.MULTIVARIATE_SECTION) {
+      const variants = current.variants as Array<{ value: unknown; rule?: unknown }> | undefined;
       if (!variants?.length) return null;
 
       let matched: unknown = null;
@@ -1331,6 +1325,30 @@ export interface DecoPageResult {
 export async function resolveDecoPage(
   targetPath: string,
   matcherCtx?: MatcherContext,
+): Promise<DecoPageResult | null> {
+  const startedAt = performance.now();
+  return withTracing(
+    "deco.cms.resolvePage",
+    async () => {
+      const result = await resolveDecoPageImpl(targetPath, matcherCtx);
+      try {
+        getMeter()?.histogramRecord?.(
+          MetricNames.RESOLVE_DURATION_MS,
+          performance.now() - startedAt,
+          { path: targetPath },
+        );
+      } catch {
+        /* observability never fails the request */
+      }
+      return result;
+    },
+    { "deco.route": targetPath },
+  );
+}
+
+async function resolveDecoPageImpl(
+  targetPath: string,
+  matcherCtx?: MatcherContext,
 ): Promise<DecoPageResult | null> {
   ensureInitialized();
 
@@ -1378,7 +1396,12 @@ export async function resolveDecoPage(
           // Cache rawProps server-side and strip from the deferred object
           // so they are NOT serialized into the HTML payload.
           if (deferred.rawProps) {
-            cacheDeferredRawProps(targetPath, deferred.component, currentFlatIndex, deferred.rawProps);
+            cacheDeferredRawProps(
+              targetPath,
+              deferred.component,
+              currentFlatIndex,
+              deferred.rawProps,
+            );
             delete deferred.rawProps;
           }
 
@@ -1430,10 +1453,12 @@ export async function resolveDecoPage(
       })();
 
       const idx = currentFlatIndex;
-      eagerResults.push(promise.then((sections) => {
-        for (const s of sections) s.index = idx;
-        return sections;
-      }));
+      eagerResults.push(
+        promise.then((sections) => {
+          for (const s of sections) s.index = idx;
+          return sections;
+        }),
+      );
       flatIndex++;
     }
   }
@@ -1445,10 +1470,7 @@ export async function resolveDecoPage(
   let seoSection: ResolvedSection | null = null;
   if (page.seo) {
     try {
-      seoSection = await resolvePageSeoBlock(
-        page.seo as Record<string, unknown>,
-        rctx,
-      );
+      seoSection = await resolvePageSeoBlock(page.seo as Record<string, unknown>, rctx);
     } catch (e) {
       onResolveError(e, "page.seo", "Page SEO block resolution");
     }
@@ -1588,18 +1610,14 @@ export async function resolveDeferredSectionFull(
   matcherCtx?: MatcherContext,
 ): Promise<ResolvedSection | null> {
   // rawProps may be stripped from the client payload — resolve from cache or page
-  const rawProps = ds.rawProps
-    ?? getDeferredRawProps(pagePath, ds.component, ds.index)
-    ?? await reExtractRawProps(pagePath, ds.component, ds.index, matcherCtx);
+  const rawProps =
+    ds.rawProps ??
+    getDeferredRawProps(pagePath, ds.component, ds.index) ??
+    (await reExtractRawProps(pagePath, ds.component, ds.index, matcherCtx));
 
   if (!rawProps) return null;
 
-  const section = await resolveDeferredSection(
-    ds.component,
-    rawProps,
-    pagePath,
-    matcherCtx,
-  );
+  const section = await resolveDeferredSection(ds.component, rawProps, pagePath, matcherCtx);
   if (!section) return null;
   section.index = ds.index;
   const enriched = await runSingleSectionLoader(section, request);

package/src/cms/sectionLoaders.ts

@@ -8,6 +8,8 @@
  * This runs AFTER resolveDecoPage and BEFORE React rendering,
  * inside the TanStack Start server function.
  */
+
+import { withTracing } from "../middleware/observability";
 import { getCacheProfile } from "../sdk/cacheHeaders";
 import { djb2 } from "../sdk/djb2";
 import type { ResolvedSection } from "./resolve";
@@ -326,6 +328,15 @@ function withPageContext(loader: SectionLoaderFn): SectionLoaderFn {
 export async function runSingleSectionLoader(
   section: ResolvedSection,
   request: Request,
+): Promise<ResolvedSection> {
+  return withTracing("deco.section.loader", () => runSingleSectionLoaderImpl(section, request), {
+    "deco.section": section.component,
+  });
+}
+
+async function runSingleSectionLoaderImpl(
+  section: ResolvedSection,
+  request: Request,
 ): Promise<ResolvedSection> {
   const loader = loaderRegistry.get(section.component);
 

package/src/index.ts

@@ -3,4 +3,7 @@ export * from "./admin/index";
 export * from "./cms/index";
 export * from "./hooks/index";
 export * from "./middleware/index";
+// Observability surface — logger + instrumentWorker live behind their own
+// granular imports too (see `@decocms/start/sdk/logger`, `.../observability`).
+export { type Logger, type LogLevel, logger, setLogLevel } from "./sdk/logger";
 export * from "./types/index";

package/src/sdk/cachedLoader.ts

@@ -11,7 +11,8 @@
  * (e.g. "product") which derives timing from the unified profile system.
  */
 
-import { loaderCacheOptions, type CacheProfileName } from "./cacheHeaders";
+import { recordCacheMetric, withTracing } from "../middleware/observability";
+import { type CacheProfileName, loaderCacheOptions } from "./cacheHeaders";
 
 export type CachePolicy = "no-store" | "no-cache" | "stale-while-revalidate";
 
@@ -85,12 +86,7 @@ export function createCachedLoader<TProps, TResult>(
   optionsOrProfile: CachedLoaderOptions | CacheProfileName,
 ): (props: TProps) => Promise<TResult> {
   const resolved = resolveOptions(optionsOrProfile);
-  const {
-    policy,
-    maxAge = DEFAULT_MAX_AGE,
-    staleIfError = 0,
-    keyFn = JSON.stringify,
-  } = resolved;
+  const { policy, maxAge = DEFAULT_MAX_AGE, staleIfError = 0, keyFn = JSON.stringify } = resolved;
 
   const env = typeof globalThis.process !== "undefined" ? globalThis.process.env : undefined;
   const isDev = env?.DECO_CACHE_DISABLE === "true" || env?.NODE_ENV === "development";
@@ -101,10 +97,20 @@ export function createCachedLoader<TProps, TResult>(
     const cacheKey = `${name}::${keyFn(props)}`;
 
     const inflight = inflightRequests.get(cacheKey);
-    if (inflight) return inflight as Promise<TResult>;
+    if (inflight) {
+      // Treat in-flight dedup as a cache hit — avoided the origin call.
+      recordCacheMetric(true, name);
+      return inflight as Promise<TResult>;
+    }
 
     if (isDev) {
-      const promise = loaderFn(props).finally(() => inflightRequests.delete(cacheKey));
+      // Dev mode: no caching, but still useful to count attempts.
+      recordCacheMetric(false, name);
+      const promise = withTracing(
+        "deco.cachedLoader",
+        () => loaderFn(props).finally(() => inflightRequests.delete(cacheKey)),
+        { "deco.loader": name, "deco.cache.policy": "no-cache-dev" },
+      );
       inflightRequests.set(cacheKey, promise);
       return promise;
     }
@@ -114,13 +120,21 @@ export function createCachedLoader<TProps, TResult>(
     const isStale = entry ? now - entry.createdAt > maxAge : true;
 
     if (policy === "no-cache") {
-      if (entry && !isStale) return entry.value;
+      if (entry && !isStale) {
+        recordCacheMetric(true, name);
+        return entry.value;
+      }
     }
 
     if (policy === "stale-while-revalidate") {
-      if (entry && !isStale) return entry.value;
+      if (entry && !isStale) {
+        recordCacheMetric(true, name);
+        return entry.value;
+      }
 
       if (entry && isStale && !entry.refreshing) {
+        // Stale-while-revalidate hit: serve stale, refresh in background.
+        recordCacheMetric(true, name);
         entry.refreshing = true;
         loaderFn(props)
           .then((result) => {
@@ -141,10 +155,19 @@ export function createCachedLoader<TProps, TResult>(
         return entry.value;
       }
 
-      if (entry) return entry.value;
+      if (entry) {
+        recordCacheMetric(true, name);
+        return entry.value;
+      }
     }
 
-    const promise = loaderFn(props)
+    // Cache miss — emit metric, then run loader inside a span so individual
+    // slow loaders are visible in traces.
+    recordCacheMetric(false, name);
+    const promise = withTracing("deco.cachedLoader", () => loaderFn(props), {
+      "deco.loader": name,
+      "deco.cache.policy": policy,
+    })
       .then((result) => {
         cache.set(cacheKey, {
           value: result,

package/src/sdk/composite.test.ts

@@ -0,0 +1,121 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { MeterAdapter } from "../middleware/observability";
+import { createCompositeLogger, createCompositeMeter } from "./composite";
+import type { LoggerAdapter } from "./logger";
+
+describe("createCompositeLogger", () => {
+  afterEach(() => vi.restoreAllMocks());
+
+  it("fans calls out to every adapter", () => {
+    const aCalls: any[][] = [];
+    const bCalls: any[][] = [];
+    const a: LoggerAdapter = { log: (...args) => void aCalls.push(args) };
+    const b: LoggerAdapter = { log: (...args) => void bCalls.push(args) };
+    const composite = createCompositeLogger([a, b]);
+
+    composite.log("info", "hello", { foo: 1 });
+
+    expect(aCalls).toEqual([["info", "hello", { foo: 1 }]]);
+    expect(bCalls).toEqual([["info", "hello", { foo: 1 }]]);
+  });
+
+  it("filters falsy entries (null/undefined/false)", () => {
+    const calls: any[] = [];
+    const a: LoggerAdapter = { log: (...args) => void calls.push(args) };
+    const composite = createCompositeLogger([null, a, undefined, false]);
+    composite.log("info", "ok");
+    // adapter receives the call with no third arg (undefined is omitted)
+    expect(calls.length).toBe(1);
+    expect(calls[0][0]).toBe("info");
+    expect(calls[0][1]).toBe("ok");
+  });
+
+  it("isolates errors so one bad adapter does not block others", () => {
+    const errSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    const okCalls: any[][] = [];
+    const broken: LoggerAdapter = {
+      log() {
+        throw new Error("boom");
+      },
+    };
+    const ok: LoggerAdapter = { log: (...args) => void okCalls.push(args) };
+    const composite = createCompositeLogger([broken, ok]);
+
+    expect(() => composite.log("error", "still goes through")).not.toThrow();
+    expect(okCalls.length).toBe(1);
+    expect(okCalls[0][0]).toBe("error");
+    expect(okCalls[0][1]).toBe("still goes through");
+    expect(errSpy).toHaveBeenCalled(); // composite reports the failure
+  });
+
+  it("returns the single adapter directly when only one is provided", () => {
+    const a: LoggerAdapter = { log: () => {} };
+    expect(createCompositeLogger([a])).toBe(a);
+  });
+});
+
+describe("createCompositeMeter", () => {
+  afterEach(() => vi.restoreAllMocks());
+
+  function recorder() {
+    const counter: any[] = [];
+    const gauge: any[] = [];
+    const histo: any[] = [];
+    const meter: MeterAdapter = {
+      counterInc: (n, v, l) => void counter.push([n, v, l]),
+      gaugeSet: (n, v, l) => void gauge.push([n, v, l]),
+      histogramRecord: (n, v, l) => void histo.push([n, v, l]),
+    };
+    return { meter, counter, gauge, histo };
+  }
+
+  it("fans counter/gauge/histogram across meters", () => {
+    const a = recorder();
+    const b = recorder();
+    const composite = createCompositeMeter([a.meter, b.meter]);
+
+    composite.counterInc("c", 1, { p: "/" });
+    composite.gaugeSet?.("g", 5);
+    composite.histogramRecord?.("h", 100, { route: "/p" });
+
+    expect(a.counter[0].slice(0, 2)).toEqual(["c", 1]);
+    expect(a.counter[0][2]).toEqual({ p: "/" });
+    expect(b.counter[0].slice(0, 2)).toEqual(["c", 1]);
+    expect(a.gauge[0].slice(0, 2)).toEqual(["g", 5]);
+    expect(b.gauge[0].slice(0, 2)).toEqual(["g", 5]);
+    expect(a.histo[0]).toEqual(["h", 100, { route: "/p" }]);
+    expect(b.histo[0]).toEqual(["h", 100, { route: "/p" }]);
+  });
+
+  it("isolates errors per meter and per call type", () => {
+    vi.spyOn(console, "error").mockImplementation(() => {});
+    const broken: MeterAdapter = {
+      counterInc: () => {
+        throw new Error("c");
+      },
+      gaugeSet: () => {
+        throw new Error("g");
+      },
+      histogramRecord: () => {
+        throw new Error("h");
+      },
+    };
+    const ok = recorder();
+    const composite = createCompositeMeter([broken, ok.meter]);
+
+    composite.counterInc("c", 1);
+    composite.gaugeSet?.("g", 5);
+    composite.histogramRecord?.("h", 100);
+
+    expect(ok.counter[0].slice(0, 2)).toEqual(["c", 1]);
+    expect(ok.gauge[0].slice(0, 2)).toEqual(["g", 5]);
+    expect(ok.histo[0].slice(0, 2)).toEqual(["h", 100]);
+  });
+
+  it("skips meters that don't implement optional ops", () => {
+    const onlyCounter: MeterAdapter = { counterInc: () => {} };
+    const composite = createCompositeMeter([onlyCounter]);
+    expect(() => composite.gaugeSet?.("g", 1)).not.toThrow();
+    expect(() => composite.histogramRecord?.("h", 1)).not.toThrow();
+  });
+});