@open-mercato/telemetry 0.6.7-develop.6834.1.e76f4b8cbc

package/.turbo/turbo-build.log

@@ -0,0 +1,2 @@
+[build:telemetry] found 20 entry points
+[build:telemetry] built successfully

package/AGENTS.md

@@ -0,0 +1,71 @@
+# Telemetry Package — Agent Rules
+
+`@open-mercato/telemetry` supplies vendor-neutral spans, metrics, error
+reporting, and an optional remote sink for the canonical shared logger. It is
+off by default. Spec:
+`.ai/specs/2026-04-29-telemetry-and-otel.md`.
+
+## Always
+
+- Use `createLogger(namespace)` from
+  `@open-mercato/shared/lib/logger` for operational logging. Telemetry must
+  extend that logger, never introduce another logger or stdout/stderr path.
+- Keep host integration default-unloaded: check
+  `isTelemetryBackendEnabled()` from shared code before dynamically importing
+  this package.
+- Treat an unset, `noop`, or unregistered backend as absolute off. A custom
+  provider activates only after an explicit bootstrap registers the exact
+  configured name and calls `initTelemetry()`.
+- Name spans `module.entity.action` (lowercase, dot-separated).
+- Use semantic-convention metric/attribute names when available.
+- Keep metric labels low-cardinality. Tenant, organization, and user IDs belong
+  on span attributes, never metric labels.
+- Apply redaction at the provider boundary as well as at facade call sites.
+
+## Ask First
+
+- Ask before adding a built-in metric, auto-instrumentation, production
+  dependency, or new global hook.
+- OpenTelemetry packages must stay optional and may only be imported by
+  `provider/otlp-provider.ts`.
+- Ask before changing the `pg` `enhancedDatabaseReporting: false` guard or
+  broadening the accepted inbound-trace trust model.
+
+## Never
+
+- Never emit PII, credentials, record content, SQL parameters, request bodies,
+  or arbitrary thrown-object properties.
+- Never trust `traceparent` or `x-original-traceparent` at an inbound/global
+  boundary unless `TELEMETRY_TRUST_INBOUND_TRACE=true`.
+- Never store provider, shared-logger extension, or runtime bridge state only in
+  a module local; cross-bundle state uses `globalThis` symbol registries.
+- Never replace provider-owned span delegation with a finished-span sink.
+- Never import this package from a client component.
+
+## Architecture
+
+```
+@open-mercato/shared/lib/logger ── local output (always)
+          │
+          └─ process-wide extension (only after telemetry init) ── remote logs
+
+host/queue shared runtime bridge ── absent while off
+          │
+          └─ registered provider: console | OTLP
+```
+
+- `src/facade/*`: spans, metrics, propagation, error funnel, redaction, and
+  shared-logger adapter.
+- `src/provider/*`: noop/console/OTLP providers and global provider registry.
+- `src/init.ts`: explicit-enabled initialization and process-wide bridge
+  registration.
+- `src/nextjs-config.ts`: build-time constants only; no runtime imports.
+- `src/nextjs.ts`: enabled runtime helper.
+
+## Validation
+
+```bash
+yarn workspace @open-mercato/telemetry build
+yarn workspace @open-mercato/telemetry test
+yarn typecheck
+```

package/README.md

@@ -0,0 +1,164 @@
+# @open-mercato/telemetry
+
+Vendor-neutral tracing, metrics, log export, and error reporting for Open
+Mercato, backed by a pluggable provider with OpenTelemetry (OTLP) as the default
+transport.
+
+Telemetry is explicitly opt-in. The platform checks `TELEMETRY_BACKEND` from
+shared code before importing this package, so the telemetry runtime is not
+evaluated when the variable is unset, `noop`, or unknown. OpenTelemetry packages
+are optional dependencies and are dynamically imported only for an OTLP backend.
+Package managers may still install optional dependencies; the guarantee is zero
+disabled-path runtime loading, hook registration, or export traffic.
+
+See [the telemetry spec](../../.ai/specs/2026-04-29-telemetry-and-otel.md).
+
+## Usage
+
+The canonical application logger remains
+`@open-mercato/shared/lib/logger`. Telemetry extends it after successful
+initialization with trace correlation and one remote sink; it does not create a
+second logger or local output path.
+
+```ts
+import { createLogger } from '@open-mercato/shared/lib/logger'
+import { withSpan, counter, reportError } from '@open-mercato/telemetry'
+
+const log = createLogger('orders').child({ module: 'sales' })
+log.info('Order placed', { orderId })
+
+await withSpan('orders.checkout', async (span) => {
+  span.setAttribute('om.tenant_id', tenantId)
+  // pg/undici auto-spans nest here when OTLP is enabled
+})
+
+counter('om.errors', 1, { module: 'orders' })
+
+try {
+  // ...
+} catch (error) {
+  reportError(error, { module: 'orders' })
+  throw error
+}
+```
+
+Use `OM_LOG_LEVEL`, `OM_LOG_PRETTY`, and `OM_LOG_DESTINATION` for both the
+normal local logger and telemetry-backed log export. Remote records follow the
+same shared level gate as local records.
+
+## Enabling
+
+Leave `TELEMETRY_BACKEND` unset (or set it to `noop`) to keep telemetry off.
+Unknown values also resolve to off.
+
+```dotenv
+TELEMETRY_BACKEND=otlp
+TELEMETRY_SAMPLING_RATIO=0.1
+OTEL_EXPORTER_OTLP_ENDPOINT=https://<your-collector>:4318
+OTEL_EXPORTER_OTLP_HEADERS=<auth-header>=<key>
+OTEL_SERVICE_NAME=open-mercato
+OTEL_RESOURCE_ATTRIBUTES=deployment.environment=production
+```
+
+`otlp`, `signoz`, and `newrelic` select the same OTLP provider and differ
+only by endpoint and headers. `console` is an explicit local span/metric
+diagnostic backend.
+
+`TELEMETRY_TRUST_INBOUND_TRACE` defaults to false. In that mode both
+`traceparent` and `x-original-traceparent` from inbound/global carriers are
+ignored because either header is caller-controlled. Set it to true only behind a
+trusted upstream when global W3C continuation is required. The queue package's
+dedicated `metadata._trace` carrier does not require this flag. The richer
+`bullmq-otel` queue spans do use the process-global propagator, so they stay
+disabled while this flag is false; async queues then use the dedicated carrier.
+
+Custom providers remain supported through `registerProvider()`. Because the
+default host guard deliberately imports telemetry only for built-in backend
+names, a custom-provider bootstrap must import `@open-mercato/telemetry`,
+register a provider whose `name` matches `TELEMETRY_BACKEND`, and call
+`initTelemetry()` directly. Unregistered names remain a hard no-op.
+
+## Existing apps
+
+Fresh create-app scaffolds are already wired. Older apps can run:
+
+```bash
+yarn mercato telemetry init
+```
+
+The command is idempotent and supports `--dry-run`. The equivalent manual
+wiring is:
+
+```ts
+// src/instrumentation.ts
+import { isTelemetryBackendEnabled } from '@open-mercato/shared/lib/telemetry/runtime'
+
+export async function register(): Promise<void> {
+  if (process.env.NEXT_RUNTIME === 'nodejs' && isTelemetryBackendEnabled()) {
+    const { registerTelemetryForNextjs } =
+      await import('@open-mercato/telemetry/nextjs')
+    await registerTelemetryForNextjs()
+  }
+}
+```
+
+```ts
+// next.config.ts — config-only entrypoint, no telemetry runtime imports
+import { telemetryServerExternalPackages } from '@open-mercato/telemetry/nextjs-config'
+```
+
+```ts
+// shared API dispatcher
+import { getTelemetryRuntime } from '@open-mercato/shared/lib/telemetry/runtime'
+
+getTelemetryRuntime()?.recordHttpDuration(method, route.path, status, startedAt)
+getTelemetryRuntime()?.reportError(error, {
+  attributes: { 'http.route': route.path },
+})
+```
+
+The CLI and queue worker use the same explicit-backend check before their dynamic
+telemetry import. Queue enqueue/dispatch code talks only to the shared runtime
+bridge, so the package is not loaded on the disabled path.
+
+## Public API
+
+| Export | Description |
+| --- | --- |
+| `withSpan(name, fn, opts?)` | Run `fn` in a provider-owned span |
+| `currentSpan()` / `setAttributes(attrs)` | Active span access |
+| `counter` / `histogram` / `gauge` | Metric helpers |
+| `reportError(err, ctx?)` | Span exception + shared error log + `om.errors` |
+| `captureTraceContext()` / `continueTrace(...)` | Dedicated cross-boundary propagation |
+| `initTelemetry()` / `shutdownTelemetry()` | Opt-in bootstrap and flush |
+| `registerProvider(provider)` | Register a custom provider for an enabled backend name |
+
+`@open-mercato/telemetry/nextjs` exports the runtime
+`registerTelemetryForNextjs()` and `recordHttpDuration()` helpers.
+`@open-mercato/telemetry/nextjs-config` separately exports only
+`telemetryServerExternalPackages` for build configuration.
+
+## Security and privacy
+
+- Explicit off is absolute: custom providers cannot override an unset/noop
+  backend, and no process-wide logger/runtime hooks are registered.
+- Secret-looking attribute keys (including exact `token`) are masked, while
+  benign keys such as `token_count` remain intact.
+- Error serialization includes only name, message, and stack. Arbitrary thrown
+  objects are never JSON-stringified.
+- Redaction runs again at the OTLP provider boundary for log bodies, error
+  fields, span attributes, and metric labels.
+- Postgres parameter-value capture is locked off with
+  `enhancedDatabaseReporting: false`.
+- Metric labels must remain low-cardinality and must never contain tenant,
+  organization, or user IDs.
+
+The package is server-only because span context uses `node:async_hooks`.
+
+## Validation
+
+```bash
+yarn workspace @open-mercato/telemetry build
+yarn workspace @open-mercato/telemetry test
+yarn typecheck
+```

package/build.mjs

@@ -0,0 +1,10 @@
+import { dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { buildPackage } from '../../scripts/build-package.mjs'
+
+const packageDir = dirname(fileURLToPath(import.meta.url))
+
+await buildPackage(packageDir, {
+  name: 'telemetry',
+  entryPoints: 'src/**/*.ts',
+})

package/dist/env.js

@@ -0,0 +1,44 @@
+import { isTelemetryBackendEnabled } from "@open-mercato/shared/lib/telemetry/runtime";
+const OTLP_BACKENDS = ["signoz", "newrelic", "otlp"];
+function isOtlpBackend(name) {
+  return OTLP_BACKENDS.includes(name);
+}
+function parseBackend(raw) {
+  const v = (raw ?? "").trim().toLowerCase();
+  return isTelemetryBackendEnabled(v) ? v : "noop";
+}
+function parseSampling(raw, isProd) {
+  const n = Number.parseFloat((raw ?? "").trim());
+  if (Number.isFinite(n) && n >= 0 && n <= 1) return n;
+  return isProd ? 0.1 : 1;
+}
+function parseBool(raw, fallback) {
+  const v = (raw ?? "").trim().toLowerCase();
+  if (v === "true" || v === "1") return true;
+  if (v === "false" || v === "0") return false;
+  return fallback;
+}
+let cached;
+function readTelemetryEnv() {
+  if (cached) return cached;
+  const isProd = process.env.NODE_ENV === "production";
+  const backend = parseBackend(process.env.TELEMETRY_BACKEND);
+  cached = {
+    backend,
+    enabled: backend !== "noop",
+    samplingRatio: parseSampling(process.env.TELEMETRY_SAMPLING_RATIO, isProd),
+    trustInboundTrace: parseBool(process.env.TELEMETRY_TRUST_INBOUND_TRACE, false),
+    serviceName: process.env.OTEL_SERVICE_NAME?.trim() || "open-mercato",
+    otlpEndpoint: process.env.OTEL_EXPORTER_OTLP_ENDPOINT?.trim() || void 0
+  };
+  return cached;
+}
+function resetTelemetryEnvCache() {
+  cached = void 0;
+}
+export {
+  isOtlpBackend,
+  readTelemetryEnv,
+  resetTelemetryEnvCache
+};
+//# sourceMappingURL=env.js.map

package/dist/env.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/env.ts"],
+  "sourcesContent": ["import type { TelemetryBackendName } from './types'\nimport { isTelemetryBackendEnabled } from '@open-mercato/shared/lib/telemetry/runtime'\n\n/** Backend names that resolve to the OTLP provider (vendor differs only by endpoint). */\nconst OTLP_BACKENDS: readonly TelemetryBackendName[] = ['signoz', 'newrelic', 'otlp']\nexport function isOtlpBackend(name: TelemetryBackendName): boolean {\n  return (OTLP_BACKENDS as readonly string[]).includes(name)\n}\n\nexport type TelemetryEnv = {\n  /** Active backend. Unset/unknown \u2192 'noop' (off). */\n  backend: TelemetryBackendName\n  /** True unless backend is 'noop'. */\n  enabled: boolean\n  /** 0.0\u20131.0 trace sampling ratio. */\n  samplingRatio: number\n  /**\n   * Continue the inbound HTTP trace (standard W3C extract) instead of rooting\n   * per request. Default false. Set true only when embedded behind a trusted\n   * upstream whose trace should continue.\n   */\n  trustInboundTrace: boolean\n  serviceName: string\n  /** OTLP endpoint (provider reads standard OTEL vars; surfaced here for diagnostics). */\n  otlpEndpoint?: string\n}\n\nfunction parseBackend(raw: string | undefined): TelemetryBackendName {\n  const v = (raw ?? '').trim().toLowerCase()\n  return isTelemetryBackendEnabled(v) ? (v as TelemetryBackendName) : 'noop'\n}\n\nfunction parseSampling(raw: string | undefined, isProd: boolean): number {\n  const n = Number.parseFloat((raw ?? '').trim())\n  if (Number.isFinite(n) && n >= 0 && n <= 1) return n\n  return isProd ? 0.1 : 1.0\n}\n\n/** Parse a boolean env flag; unset/unknown \u2192 `fallback`. */\nfunction parseBool(raw: string | undefined, fallback: boolean): boolean {\n  const v = (raw ?? '').trim().toLowerCase()\n  if (v === 'true' || v === '1') return true\n  if (v === 'false' || v === '0') return false\n  return fallback\n}\n\nlet cached: TelemetryEnv | undefined\n\nexport function readTelemetryEnv(): TelemetryEnv {\n  if (cached) return cached\n  const isProd = process.env.NODE_ENV === 'production'\n  const backend = parseBackend(process.env.TELEMETRY_BACKEND)\n  cached = {\n    backend,\n    enabled: backend !== 'noop',\n    samplingRatio: parseSampling(process.env.TELEMETRY_SAMPLING_RATIO, isProd),\n    trustInboundTrace: parseBool(process.env.TELEMETRY_TRUST_INBOUND_TRACE, false),\n    serviceName: process.env.OTEL_SERVICE_NAME?.trim() || 'open-mercato',\n    otlpEndpoint: process.env.OTEL_EXPORTER_OTLP_ENDPOINT?.trim() || undefined,\n  }\n  return cached\n}\n\n/**\n * Reset the memoized env snapshot. Called by `initTelemetry()` so init always\n * resolves from the fully-loaded environment (a host may import this package\n * before its `.env` is loaded \u2014 the CLI binary does), and by jest between tests.\n */\nexport function resetTelemetryEnvCache(): void {\n  cached = undefined\n}\n"],
+  "mappings": "AACA,SAAS,iCAAiC;AAG1C,MAAM,gBAAiD,CAAC,UAAU,YAAY,MAAM;AAC7E,SAAS,cAAc,MAAqC;AACjE,SAAQ,cAAoC,SAAS,IAAI;AAC3D;AAoBA,SAAS,aAAa,KAA+C;AACnE,QAAM,KAAK,OAAO,IAAI,KAAK,EAAE,YAAY;AACzC,SAAO,0BAA0B,CAAC,IAAK,IAA6B;AACtE;AAEA,SAAS,cAAc,KAAyB,QAAyB;AACvE,QAAM,IAAI,OAAO,YAAY,OAAO,IAAI,KAAK,CAAC;AAC9C,MAAI,OAAO,SAAS,CAAC,KAAK,KAAK,KAAK,KAAK,EAAG,QAAO;AACnD,SAAO,SAAS,MAAM;AACxB;AAGA,SAAS,UAAU,KAAyB,UAA4B;AACtE,QAAM,KAAK,OAAO,IAAI,KAAK,EAAE,YAAY;AACzC,MAAI,MAAM,UAAU,MAAM,IAAK,QAAO;AACtC,MAAI,MAAM,WAAW,MAAM,IAAK,QAAO;AACvC,SAAO;AACT;AAEA,IAAI;AAEG,SAAS,mBAAiC;AAC/C,MAAI,OAAQ,QAAO;AACnB,QAAM,SAAS,QAAQ,IAAI,aAAa;AACxC,QAAM,UAAU,aAAa,QAAQ,IAAI,iBAAiB;AAC1D,WAAS;AAAA,IACP;AAAA,IACA,SAAS,YAAY;AAAA,IACrB,eAAe,cAAc,QAAQ,IAAI,0BAA0B,MAAM;AAAA,IACzE,mBAAmB,UAAU,QAAQ,IAAI,+BAA+B,KAAK;AAAA,IAC7E,aAAa,QAAQ,IAAI,mBAAmB,KAAK,KAAK;AAAA,IACtD,cAAc,QAAQ,IAAI,6BAA6B,KAAK,KAAK;AAAA,EACnE;AACA,SAAO;AACT;AAOO,SAAS,yBAA+B;AAC7C,WAAS;AACX;",
+  "names": []
+}

package/dist/facade/context.js

@@ -0,0 +1,14 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+const spanStore = new AsyncLocalStorage();
+function runWithSpan(span, fn) {
+  return spanStore.run(span, fn);
+}
+function spanFromStore() {
+  return spanStore.getStore();
+}
+export {
+  runWithSpan,
+  spanFromStore,
+  spanStore
+};
+//# sourceMappingURL=context.js.map

package/dist/facade/context.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/facade/context.ts"],
+  "sourcesContent": ["import { AsyncLocalStorage } from 'node:async_hooks'\nimport type { Span } from '../types'\n\n/**\n * Carries the facade's active span across `await` boundaries for spans created\n * via `withSpan`. (OTEL auto-instrumentation spans live in OTEL's own context;\n * the OTLP provider's `activeSpan()` bridges to those \u2014 see `currentSpan`.)\n */\nexport const spanStore = new AsyncLocalStorage<Span>()\n\nexport function runWithSpan<T>(span: Span, fn: () => T): T {\n  return spanStore.run(span, fn)\n}\n\nexport function spanFromStore(): Span | undefined {\n  return spanStore.getStore()\n}\n"],
+  "mappings": "AAAA,SAAS,yBAAyB;AAQ3B,MAAM,YAAY,IAAI,kBAAwB;AAE9C,SAAS,YAAe,MAAY,IAAgB;AACzD,SAAO,UAAU,IAAI,MAAM,EAAE;AAC/B;AAEO,SAAS,gBAAkC;AAChD,SAAO,UAAU,SAAS;AAC5B;",
+  "names": []
+}

package/dist/facade/http.js

@@ -0,0 +1,18 @@
+import { histogram } from "./meter.js";
+function recordHttpDuration(method, route, status, startedAt) {
+  histogram(
+    "http.server.request.duration",
+    (Date.now() - startedAt) / 1e3,
+    {
+      "http.request.method": method,
+      "http.route": route,
+      "http.response.status_code": status,
+      "error.type": status >= 500 ? String(status) : void 0
+    },
+    "s"
+  );
+}
+export {
+  recordHttpDuration
+};
+//# sourceMappingURL=http.js.map

package/dist/facade/http.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/facade/http.ts"],
+  "sourcesContent": ["import { histogram } from './meter'\n\n/**\n * Emit the OpenTelemetry-standard HTTP server metric\n * `http.server.request.duration` (histogram, seconds) with semconv attributes.\n * `route` MUST be a low-cardinality route template, never a resolved pathname.\n */\nexport function recordHttpDuration(\n  method: string,\n  route: string,\n  status: number,\n  startedAt: number,\n): void {\n  histogram(\n    'http.server.request.duration',\n    (Date.now() - startedAt) / 1000,\n    {\n      'http.request.method': method,\n      'http.route': route,\n      'http.response.status_code': status,\n      'error.type': status >= 500 ? String(status) : undefined,\n    },\n    's',\n  )\n}\n"],
+  "mappings": "AAAA,SAAS,iBAAiB;AAOnB,SAAS,mBACd,QACA,OACA,QACA,WACM;AACN;AAAA,IACE;AAAA,KACC,KAAK,IAAI,IAAI,aAAa;AAAA,IAC3B;AAAA,MACE,uBAAuB;AAAA,MACvB,cAAc;AAAA,MACd,6BAA6B;AAAA,MAC7B,cAAc,UAAU,MAAM,OAAO,MAAM,IAAI;AAAA,IACjD;AAAA,IACA;AAAA,EACF;AACF;",
+  "names": []
+}

package/dist/facade/logger-bridge.js

@@ -0,0 +1,40 @@
+import {
+  registerLoggerExtension
+} from "@open-mercato/shared/lib/logger";
+import { redactAttributes } from "./redact.js";
+import { serializeError } from "./serialize.js";
+function toAttributes(record) {
+  const attributes = {
+    "logger.name": record.namespace
+  };
+  for (const [key, value] of Object.entries(record.fields)) {
+    if (key === "err" || value === void 0) continue;
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      attributes[key] = value;
+    }
+  }
+  return redactAttributes(attributes);
+}
+function toLogRecord(record) {
+  const error = record.fields.err === void 0 ? void 0 : serializeError(record.fields.err);
+  return {
+    level: record.level,
+    message: record.message,
+    attributes: toAttributes(record),
+    error,
+    time: record.time
+  };
+}
+function registerTelemetryLogger(provider) {
+  return registerLoggerExtension({
+    enrich: () => {
+      const context = provider.activeTraceContext();
+      return context ? { trace_id: context.traceId, span_id: context.spanId } : void 0;
+    },
+    emit: (record) => provider.emitLog(toLogRecord(record))
+  });
+}
+export {
+  registerTelemetryLogger
+};
+//# sourceMappingURL=logger-bridge.js.map

package/dist/facade/logger-bridge.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/facade/logger-bridge.ts"],
+  "sourcesContent": ["import {\n  registerLoggerExtension,\n  type LoggerExtensionRecord,\n} from '@open-mercato/shared/lib/logger'\nimport type { Attributes, LogRecord, TelemetryProvider } from '../types'\nimport { redactAttributes } from './redact'\nimport { serializeError } from './serialize'\n\nfunction toAttributes(record: LoggerExtensionRecord): Attributes {\n  const attributes: Attributes = {\n    'logger.name': record.namespace,\n  }\n  for (const [key, value] of Object.entries(record.fields)) {\n    if (key === 'err' || value === undefined) continue\n    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {\n      attributes[key] = value\n    }\n  }\n  return redactAttributes(attributes)\n}\n\nfunction toLogRecord(record: LoggerExtensionRecord): LogRecord {\n  const error = record.fields.err === undefined\n    ? undefined\n    : serializeError(record.fields.err)\n  return {\n    level: record.level,\n    message: record.message,\n    attributes: toAttributes(record),\n    error,\n    time: record.time,\n  }\n}\n\n/**\n * Extend the canonical shared logger with trace correlation + remote export.\n * The shared logger remains the sole application-facing logger and sole local\n * output path; telemetry observes the already-normalized record exactly once.\n */\nexport function registerTelemetryLogger(provider: TelemetryProvider): () => void {\n  return registerLoggerExtension({\n    enrich: () => {\n      const context = provider.activeTraceContext()\n      return context\n        ? { trace_id: context.traceId, span_id: context.spanId }\n        : undefined\n    },\n    emit: (record) => provider.emitLog(toLogRecord(record)),\n  })\n}\n"],
+  "mappings": "AAAA;AAAA,EACE;AAAA,OAEK;AAEP,SAAS,wBAAwB;AACjC,SAAS,sBAAsB;AAE/B,SAAS,aAAa,QAA2C;AAC/D,QAAM,aAAyB;AAAA,IAC7B,eAAe,OAAO;AAAA,EACxB;AACA,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,OAAO,MAAM,GAAG;AACxD,QAAI,QAAQ,SAAS,UAAU,OAAW;AAC1C,QAAI,OAAO,UAAU,YAAY,OAAO,UAAU,YAAY,OAAO,UAAU,WAAW;AACxF,iBAAW,GAAG,IAAI;AAAA,IACpB;AAAA,EACF;AACA,SAAO,iBAAiB,UAAU;AACpC;AAEA,SAAS,YAAY,QAA0C;AAC7D,QAAM,QAAQ,OAAO,OAAO,QAAQ,SAChC,SACA,eAAe,OAAO,OAAO,GAAG;AACpC,SAAO;AAAA,IACL,OAAO,OAAO;AAAA,IACd,SAAS,OAAO;AAAA,IAChB,YAAY,aAAa,MAAM;AAAA,IAC/B;AAAA,IACA,MAAM,OAAO;AAAA,EACf;AACF;AAOO,SAAS,wBAAwB,UAAyC;AAC/E,SAAO,wBAAwB;AAAA,IAC7B,QAAQ,MAAM;AACZ,YAAM,UAAU,SAAS,mBAAmB;AAC5C,aAAO,UACH,EAAE,UAAU,QAAQ,SAAS,SAAS,QAAQ,OAAO,IACrD;AAAA,IACN;AAAA,IACA,MAAM,CAAC,WAAW,SAAS,QAAQ,YAAY,MAAM,CAAC;AAAA,EACxD,CAAC;AACH;",
+  "names": []
+}

package/dist/facade/meter.js

@@ -0,0 +1,16 @@
+import { getActiveProvider } from "../provider/registry.js";
+function counter(name, value = 1, labels, unit) {
+  getActiveProvider().recordMetric({ kind: "counter", name, value, labels, unit });
+}
+function histogram(name, value, labels, unit) {
+  getActiveProvider().recordMetric({ kind: "histogram", name, value, labels, unit });
+}
+function gauge(name, value, labels, unit) {
+  getActiveProvider().recordMetric({ kind: "gauge", name, value, labels, unit });
+}
+export {
+  counter,
+  gauge,
+  histogram
+};
+//# sourceMappingURL=meter.js.map

package/dist/facade/meter.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/facade/meter.ts"],
+  "sourcesContent": ["import type { Attributes } from '../types'\nimport { getActiveProvider } from '../provider/registry'\n\n/**\n * Metric helpers. Labels MUST be low-cardinality (never tenant/org/user IDs \u2014\n * those belong on span attributes, per the telemetry spec's R4). The active\n * provider caches the underlying instrument by name; these are no-ops when\n * metrics are off.\n */\nexport function counter(name: string, value = 1, labels?: Attributes, unit?: string): void {\n  getActiveProvider().recordMetric({ kind: 'counter', name, value, labels, unit })\n}\n\nexport function histogram(name: string, value: number, labels?: Attributes, unit?: string): void {\n  getActiveProvider().recordMetric({ kind: 'histogram', name, value, labels, unit })\n}\n\nexport function gauge(name: string, value: number, labels?: Attributes, unit?: string): void {\n  getActiveProvider().recordMetric({ kind: 'gauge', name, value, labels, unit })\n}\n"],
+  "mappings": "AACA,SAAS,yBAAyB;AAQ3B,SAAS,QAAQ,MAAc,QAAQ,GAAG,QAAqB,MAAqB;AACzF,oBAAkB,EAAE,aAAa,EAAE,MAAM,WAAW,MAAM,OAAO,QAAQ,KAAK,CAAC;AACjF;AAEO,SAAS,UAAU,MAAc,OAAe,QAAqB,MAAqB;AAC/F,oBAAkB,EAAE,aAAa,EAAE,MAAM,aAAa,MAAM,OAAO,QAAQ,KAAK,CAAC;AACnF;AAEO,SAAS,MAAM,MAAc,OAAe,QAAqB,MAAqB;AAC3F,oBAAkB,EAAE,aAAa,EAAE,MAAM,SAAS,MAAM,OAAO,QAAQ,KAAK,CAAC;AAC/E;",
+  "names": []
+}

package/dist/facade/propagation.js

@@ -0,0 +1,20 @@
+import { getActiveProvider } from "../provider/registry.js";
+import { runWithSpan } from "./context.js";
+function captureTraceContext() {
+  const carrier = {};
+  getActiveProvider().inject(carrier);
+  return carrier;
+}
+function continueTrace(carrier, name, fn, options) {
+  return getActiveProvider().runInRemoteSpan(
+    carrier ?? {},
+    name,
+    options ?? {},
+    (span) => runWithSpan(span, () => fn(span))
+  );
+}
+export {
+  captureTraceContext,
+  continueTrace
+};
+//# sourceMappingURL=propagation.js.map

package/dist/facade/propagation.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/facade/propagation.ts"],
+  "sourcesContent": ["import type { Span, SpanOptions, TraceCarrier } from '../types'\nimport { getActiveProvider } from '../provider/registry'\nimport { runWithSpan } from './context'\n\n/**\n * Capture the active trace context into a fresh carrier, to embed in a queue job\n * or event payload (the queue/event bus expose no metadata channel \u2014 see the\n * telemetry spec's S5). Returns `{}` when telemetry is off.\n */\nexport function captureTraceContext(): TraceCarrier {\n  const carrier: TraceCarrier = {}\n  getActiveProvider().inject(carrier)\n  return carrier\n}\n\n/**\n * Continue a trace on the consumer side (worker / subscriber): run `fn` inside a\n * new active span named `name`, parented to the context in `carrier`. The job's\n * spans (pg, etc.) then nest under the producer's trace as one waterfall. If\n * `carrier` is empty/undefined the span simply starts a fresh root.\n */\nexport function continueTrace<T>(\n  carrier: TraceCarrier | undefined,\n  name: string,\n  fn: (span: Span) => T,\n  options?: SpanOptions,\n): T {\n  return getActiveProvider().runInRemoteSpan(carrier ?? {}, name, options ?? {}, (span) =>\n    runWithSpan(span, () => fn(span)),\n  )\n}\n"],
+  "mappings": "AACA,SAAS,yBAAyB;AAClC,SAAS,mBAAmB;AAOrB,SAAS,sBAAoC;AAClD,QAAM,UAAwB,CAAC;AAC/B,oBAAkB,EAAE,OAAO,OAAO;AAClC,SAAO;AACT;AAQO,SAAS,cACd,SACA,MACA,IACA,SACG;AACH,SAAO,kBAAkB,EAAE;AAAA,IAAgB,WAAW,CAAC;AAAA,IAAG;AAAA,IAAM,WAAW,CAAC;AAAA,IAAG,CAAC,SAC9E,YAAY,MAAM,MAAM,GAAG,IAAI,CAAC;AAAA,EAClC;AACF;",
+  "names": []
+}

package/dist/facade/redact.js

@@ -0,0 +1,21 @@
+const EMAIL_RE = /[A-Z0-9._%+-]{1,64}@[A-Z0-9.-]{1,253}\.[A-Z]{2,63}/gi;
+const SECRET_HEADER_RE = /\b(authorization|proxy-authorization|cookie|set-cookie)(\s*[:=]\s*)([^\n;,}]+)/gi;
+const AUTH_SCHEME_RE = /\b(Bearer|Basic|ApiKey)\s+[A-Za-z0-9._~+/=-]+/gi;
+function redactPii(text) {
+  return text.replace(EMAIL_RE, "[redacted-email]").replace(SECRET_HEADER_RE, (_match, name, separator) => `${name}${separator}[redacted]`).replace(AUTH_SCHEME_RE, (_match, scheme) => `${scheme} [redacted]`);
+}
+const SECRET_KEY_RE = /(authorization|cookie|password|passwd|\bpwd\b|secret|api[-_]?key|access[-_]?token|refresh[-_]?token|id[-_]?token|auth[-_]?token|^token$|\bbearer\b|private[-_]?key|credential)/i;
+function redactAttributes(attributes) {
+  const result = {};
+  for (const [key, value] of Object.entries(attributes)) {
+    if (SECRET_KEY_RE.test(key)) result[key] = "[redacted]";
+    else if (typeof value === "string") result[key] = redactPii(value);
+    else result[key] = value;
+  }
+  return result;
+}
+export {
+  redactAttributes,
+  redactPii
+};
+//# sourceMappingURL=redact.js.map

package/dist/facade/redact.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/facade/redact.ts"],
+  "sourcesContent": ["import type { Attributes } from '../types'\n\n/**\n * Active redaction backstop for telemetry (Privacy section of the telemetry spec).\n *\n * Defense-in-depth over the don't-emit posture: callers are expected not to put\n * PII or secrets into errors/logs, but error messages and stack frames can still\n * pick them up a layer down (e.g. `Error: no user for jan.kowalski@example.com`,\n * or a dumped `Authorization: Bearer \u2026` header). This scrubs the highest-signal\n * identifiers \u2014 email addresses and auth tokens \u2014 from any text that ships to the\n * backend, without touching opaque UUIDs/ids (which we keep).\n *\n * Deliberately conservative (emails + auth tokens) to preserve debuggability;\n * extend the pattern set here if a new leak vector is found.\n */\n// Bound every component both to match the practical limits from RFC 5321 and\n// to keep scanning time linear for hostile strings with long runs of email\n// punctuation (CodeQL js/polynomial-redos).\nconst EMAIL_RE = /[A-Z0-9._%+-]{1,64}@[A-Z0-9.-]{1,253}\\.[A-Z]{2,63}/gi\n// `authorization: <value>` / `cookie: <value>` header dumps embedded in free text.\n// The value runs to the next separator (`;`/`,`/`}`) or newline, so it swallows a\n// `Bearer <token>` value in one pass (before the standalone-scheme rule below).\nconst SECRET_HEADER_RE = /\\b(authorization|proxy-authorization|cookie|set-cookie)(\\s*[:=]\\s*)([^\\n;,}]+)/gi\n// `Bearer <token>` / `Basic <base64>` / `ApiKey <key>` standing alone in free text (message or stack).\nconst AUTH_SCHEME_RE = /\\b(Bearer|Basic|ApiKey)\\s+[A-Za-z0-9._~+/=-]+/gi\n\nexport function redactPii(text: string): string {\n  return text\n    .replace(EMAIL_RE, '[redacted-email]')\n    .replace(SECRET_HEADER_RE, (_match, name: string, separator: string) => `${name}${separator}[redacted]`)\n    .replace(AUTH_SCHEME_RE, (_match, scheme: string) => `${scheme} [redacted]`)\n}\n\n// Attribute KEYS whose value is a secret regardless of content. Intentionally\n// specific enough not to clobber benign fields like `token_count`, while\n// still masking the exact key `token`.\nconst SECRET_KEY_RE =\n  /(authorization|cookie|password|passwd|\\bpwd\\b|secret|api[-_]?key|access[-_]?token|refresh[-_]?token|id[-_]?token|auth[-_]?token|^token$|\\bbearer\\b|private[-_]?key|credential)/i\n\n/**\n * Redact a telemetry attribute bag before it ships: a value under a secret-looking\n * KEY (`authorization`, `set-cookie`, `client_secret`, `x-api-key`, \u2026) is masked\n * wholesale; other string values still pass through `redactPii` so an inline email\n * or auth token is caught too. Non-string values are left as-is.\n */\nexport function redactAttributes(attributes: Attributes): Attributes {\n  const result: Attributes = {}\n  for (const [key, value] of Object.entries(attributes)) {\n    if (SECRET_KEY_RE.test(key)) result[key] = '[redacted]'\n    else if (typeof value === 'string') result[key] = redactPii(value)\n    else result[key] = value\n  }\n  return result\n}\n"],
+  "mappings": "AAkBA,MAAM,WAAW;AAIjB,MAAM,mBAAmB;AAEzB,MAAM,iBAAiB;AAEhB,SAAS,UAAU,MAAsB;AAC9C,SAAO,KACJ,QAAQ,UAAU,kBAAkB,EACpC,QAAQ,kBAAkB,CAAC,QAAQ,MAAc,cAAsB,GAAG,IAAI,GAAG,SAAS,YAAY,EACtG,QAAQ,gBAAgB,CAAC,QAAQ,WAAmB,GAAG,MAAM,aAAa;AAC/E;AAKA,MAAM,gBACJ;AAQK,SAAS,iBAAiB,YAAoC;AACnE,QAAM,SAAqB,CAAC;AAC5B,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,UAAU,GAAG;AACrD,QAAI,cAAc,KAAK,GAAG,EAAG,QAAO,GAAG,IAAI;AAAA,aAClC,OAAO,UAAU,SAAU,QAAO,GAAG,IAAI,UAAU,KAAK;AAAA,QAC5D,QAAO,GAAG,IAAI;AAAA,EACrB;AACA,SAAO;AACT;",
+  "names": []
+}

package/dist/facade/report-error.js

@@ -0,0 +1,26 @@
+import { createLogger } from "@open-mercato/shared/lib/logger";
+import { currentSpan } from "./tracer.js";
+import { serializeError } from "./serialize.js";
+import { counter } from "./meter.js";
+import { redactAttributes } from "./redact.js";
+const logger = createLogger("telemetry");
+function reportError(error, ctx) {
+  const span = currentSpan();
+  if (span) {
+    span.recordException(error);
+    span.setStatus("error");
+  }
+  const serialized = serializeError(error);
+  const attributes = { ...ctx?.attributes ?? {} };
+  if (ctx?.module) attributes.module = ctx.module;
+  const safeAttributes = redactAttributes(attributes);
+  const safeError = new Error(serialized.message);
+  safeError.name = serialized.name;
+  safeError.stack = serialized.stack;
+  logger.error("Application error reported", { ...safeAttributes, err: safeError });
+  counter("om.errors", 1, ctx?.module ? { module: ctx.module } : void 0);
+}
+export {
+  reportError
+};
+//# sourceMappingURL=report-error.js.map

package/dist/facade/report-error.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/facade/report-error.ts"],
+  "sourcesContent": ["import type { Attributes } from '../types'\nimport { createLogger } from '@open-mercato/shared/lib/logger'\nimport { currentSpan } from './tracer'\nimport { serializeError } from './serialize'\nimport { counter } from './meter'\nimport { redactAttributes } from './redact'\n\nconst logger = createLogger('telemetry')\n\nexport type ReportErrorContext = {\n  /** Owning module, e.g. 'orders'. Used as the only metric label. */\n  module?: string\n  /** Low-cardinality, NO-PII attributes (ids ok, never names/content). */\n  attributes?: Attributes\n}\n\n/**\n * The error funnel. Additive \u2014 existing `console.error` calls stay valid; this\n * is the path that reaches the active backend. It:\n *   1. records the exception on the active span (errors-as-span-events),\n *   2. emits a structured error log (stack only \u2014 no PII payloads),\n *   3. increments the `om.errors` counter, labeled by `module` only.\n */\nexport function reportError(error: unknown, ctx?: ReportErrorContext): void {\n  const span = currentSpan()\n  if (span) {\n    span.recordException(error)\n    span.setStatus('error')\n  }\n\n  const serialized = serializeError(error)\n  const attributes: Attributes = { ...(ctx?.attributes ?? {}) }\n  if (ctx?.module) attributes.module = ctx.module\n  const safeAttributes = redactAttributes(attributes)\n\n  const safeError = new Error(serialized.message)\n  safeError.name = serialized.name\n  safeError.stack = serialized.stack\n  logger.error('Application error reported', { ...safeAttributes, err: safeError })\n  counter('om.errors', 1, ctx?.module ? { module: ctx.module } : undefined)\n}\n"],
+  "mappings": "AACA,SAAS,oBAAoB;AAC7B,SAAS,mBAAmB;AAC5B,SAAS,sBAAsB;AAC/B,SAAS,eAAe;AACxB,SAAS,wBAAwB;AAEjC,MAAM,SAAS,aAAa,WAAW;AAgBhC,SAAS,YAAY,OAAgB,KAAgC;AAC1E,QAAM,OAAO,YAAY;AACzB,MAAI,MAAM;AACR,SAAK,gBAAgB,KAAK;AAC1B,SAAK,UAAU,OAAO;AAAA,EACxB;AAEA,QAAM,aAAa,eAAe,KAAK;AACvC,QAAM,aAAyB,EAAE,GAAI,KAAK,cAAc,CAAC,EAAG;AAC5D,MAAI,KAAK,OAAQ,YAAW,SAAS,IAAI;AACzC,QAAM,iBAAiB,iBAAiB,UAAU;AAElD,QAAM,YAAY,IAAI,MAAM,WAAW,OAAO;AAC9C,YAAU,OAAO,WAAW;AAC5B,YAAU,QAAQ,WAAW;AAC7B,SAAO,MAAM,8BAA8B,EAAE,GAAG,gBAAgB,KAAK,UAAU,CAAC;AAChF,UAAQ,aAAa,GAAG,KAAK,SAAS,EAAE,QAAQ,IAAI,OAAO,IAAI,MAAS;AAC1E;",
+  "names": []
+}

package/dist/facade/serialize.js

@@ -0,0 +1,35 @@
+import { redactPii } from "./redact.js";
+function serializeError(error) {
+  if (error instanceof Error) {
+    return {
+      name: redactPii(error.name || "Error"),
+      message: redactPii(foldCause(error)),
+      stack: error.stack ? redactPii(error.stack) : void 0
+    };
+  }
+  return { name: "NonError", message: redactPii(safeString(error)) };
+}
+function foldCause(error, seen = /* @__PURE__ */ new WeakSet()) {
+  if (seen.has(error)) return error.message;
+  seen.add(error);
+  const cause = error.cause;
+  if (cause instanceof Error) {
+    return `${error.message} \u2014 caused by ${cause.name || "Error"}: ${foldCause(cause, seen)}`;
+  }
+  return error.message;
+}
+function safeString(value) {
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return String(value);
+  }
+  if (typeof value === "symbol") return value.description ? `Symbol(${value.description})` : "Symbol";
+  if (typeof value === "function") return "[function]";
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  return "[non-error object]";
+}
+export {
+  serializeError
+};
+//# sourceMappingURL=serialize.js.map

package/dist/facade/serialize.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/facade/serialize.ts"],
+  "sourcesContent": ["import type { LogRecord } from '../types'\nimport { redactPii } from './redact'\n\n/**\n * Serialize an error for telemetry: name, message, and stack only.\n *\n * Deliberately does NOT include arbitrary error properties (request bodies,\n * `cause` payloads, query parameters) \u2014 those can carry PII. The cause CHAIN is\n * folded into the message text (names/messages only), never its data. Message +\n * stack are run through `redactPii` so a leaked email never reaches the backend\n * (active-redaction backstop over the don't-emit posture).\n */\nexport function serializeError(error: unknown): NonNullable<LogRecord['error']> {\n  if (error instanceof Error) {\n    return {\n      name: redactPii(error.name || 'Error'),\n      message: redactPii(foldCause(error)),\n      stack: error.stack ? redactPii(error.stack) : undefined,\n    }\n  }\n  return { name: 'NonError', message: redactPii(safeString(error)) }\n}\n\nfunction foldCause(error: Error, seen = new WeakSet<object>()): string {\n  if (seen.has(error)) return error.message\n  seen.add(error)\n  const cause = (error as { cause?: unknown }).cause\n  if (cause instanceof Error) {\n    return `${error.message} \u2014 caused by ${cause.name || 'Error'}: ${foldCause(cause, seen)}`\n  }\n  return error.message\n}\n\nfunction safeString(value: unknown): string {\n  if (typeof value === 'string') return value\n  if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'bigint') {\n    return String(value)\n  }\n  if (typeof value === 'symbol') return value.description ? `Symbol(${value.description})` : 'Symbol'\n  if (typeof value === 'function') return '[function]'\n  if (value === null) return 'null'\n  if (value === undefined) return 'undefined'\n  // Never stringify arbitrary objects: request bodies, provider errors, and\n  // thrown payloads commonly contain credentials or personal data.\n  return '[non-error object]'\n}\n"],
+  "mappings": "AACA,SAAS,iBAAiB;AAWnB,SAAS,eAAe,OAAiD;AAC9E,MAAI,iBAAiB,OAAO;AAC1B,WAAO;AAAA,MACL,MAAM,UAAU,MAAM,QAAQ,OAAO;AAAA,MACrC,SAAS,UAAU,UAAU,KAAK,CAAC;AAAA,MACnC,OAAO,MAAM,QAAQ,UAAU,MAAM,KAAK,IAAI;AAAA,IAChD;AAAA,EACF;AACA,SAAO,EAAE,MAAM,YAAY,SAAS,UAAU,WAAW,KAAK,CAAC,EAAE;AACnE;AAEA,SAAS,UAAU,OAAc,OAAO,oBAAI,QAAgB,GAAW;AACrE,MAAI,KAAK,IAAI,KAAK,EAAG,QAAO,MAAM;AAClC,OAAK,IAAI,KAAK;AACd,QAAM,QAAS,MAA8B;AAC7C,MAAI,iBAAiB,OAAO;AAC1B,WAAO,GAAG,MAAM,OAAO,qBAAgB,MAAM,QAAQ,OAAO,KAAK,UAAU,OAAO,IAAI,CAAC;AAAA,EACzF;AACA,SAAO,MAAM;AACf;AAEA,SAAS,WAAW,OAAwB;AAC1C,MAAI,OAAO,UAAU,SAAU,QAAO;AACtC,MAAI,OAAO,UAAU,YAAY,OAAO,UAAU,aAAa,OAAO,UAAU,UAAU;AACxF,WAAO,OAAO,KAAK;AAAA,EACrB;AACA,MAAI,OAAO,UAAU,SAAU,QAAO,MAAM,cAAc,UAAU,MAAM,WAAW,MAAM;AAC3F,MAAI,OAAO,UAAU,WAAY,QAAO;AACxC,MAAI,UAAU,KAAM,QAAO;AAC3B,MAAI,UAAU,OAAW,QAAO;AAGhC,SAAO;AACT;",
+  "names": []
+}

package/dist/facade/tracer.js

@@ -0,0 +1,21 @@
+import { getActiveProvider } from "../provider/registry.js";
+import { runWithSpan, spanFromStore } from "./context.js";
+function withSpan(name, fn, options) {
+  return getActiveProvider().runInSpan(
+    name,
+    options ?? {},
+    (span) => runWithSpan(span, () => fn(span))
+  );
+}
+function currentSpan() {
+  return spanFromStore() ?? getActiveProvider().activeSpan();
+}
+function setAttributes(attributes) {
+  currentSpan()?.setAttributes(attributes);
+}
+export {
+  currentSpan,
+  setAttributes,
+  withSpan
+};
+//# sourceMappingURL=tracer.js.map

package/dist/facade/tracer.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/facade/tracer.ts"],
+  "sourcesContent": ["import type { Attributes, Span, SpanOptions } from '../types'\nimport { getActiveProvider } from '../provider/registry'\nimport { runWithSpan, spanFromStore } from './context'\n\n/**\n * Run `fn` inside a new span named `name`. The active provider owns span\n * creation + context, so any OTEL auto-instrumentation (pg/http) inside `fn`\n * nests under this span in the same trace. Exceptions and duration are recorded\n * automatically by the provider. No-op-cheap when telemetry is off.\n */\nexport function withSpan<T>(name: string, fn: (span: Span) => T, options?: SpanOptions): T {\n  return getActiveProvider().runInSpan(name, options ?? {}, (span) =>\n    runWithSpan(span, () => fn(span)),\n  )\n}\n\n/** The active span (facade-created or OTEL auto-instrumented), if any. */\nexport function currentSpan(): Span | undefined {\n  return spanFromStore() ?? getActiveProvider().activeSpan()\n}\n\n/** Set attributes on the active span, if any. */\nexport function setAttributes(attributes: Attributes): void {\n  currentSpan()?.setAttributes(attributes)\n}\n"],
+  "mappings": "AACA,SAAS,yBAAyB;AAClC,SAAS,aAAa,qBAAqB;AAQpC,SAAS,SAAY,MAAc,IAAuB,SAA0B;AACzF,SAAO,kBAAkB,EAAE;AAAA,IAAU;AAAA,IAAM,WAAW,CAAC;AAAA,IAAG,CAAC,SACzD,YAAY,MAAM,MAAM,GAAG,IAAI,CAAC;AAAA,EAClC;AACF;AAGO,SAAS,cAAgC;AAC9C,SAAO,cAAc,KAAK,kBAAkB,EAAE,WAAW;AAC3D;AAGO,SAAS,cAAc,YAA8B;AAC1D,cAAY,GAAG,cAAc,UAAU;AACzC;",
+  "names": []
+}