@dvmkit/sdk 0.3.0-rc.9 → 0.3.2-rc.10

package/dist/chunk-D42FMCLJ.js

@@ -0,0 +1,1423 @@
+// src/observability/projection.ts
+import { isIP } from "net";
+
+// src/observability/diagnostic-catalogue-v1.json
+var diagnostic_catalogue_v1_default = {
+  version: 1,
+  events: [
+    "abuse_signal_record_failed",
+    "abuse_signal_report_failed",
+    "abuse_signal_volume_check",
+    "accepted",
+    "accumulator_mode_missing_config",
+    "accumulator_table_init_failed",
+    "admin.destroy",
+    "admin.dvm_edit_status",
+    "admin.dvm_transfer",
+    "admin.dvm_un_destroy",
+    "admin.org_destroy",
+    "admin.org_member_add",
+    "admin.org_member_remove",
+    "admin.org_member_role",
+    "admin.org_resume",
+    "admin.org_set_operator",
+    "admin.org_set_plan",
+    "admin.org_suspend",
+    "admin.resume",
+    "admin.set_operator",
+    "admin.set_plan",
+    "admin.suspend",
+    "admin_cashu_nonce_store_in_memory",
+    "admin_lock_state_unavailable",
+    "admin_lock_table_init_failed",
+    "admin_surface_missing_config",
+    "api_5xx_rate_check",
+    "api_resolved",
+    "audit_backlog_check",
+    "audit_backlog_recovery_failed",
+    "audit_outbox_completion_failed",
+    "audit_outbox_drain",
+    "audit_outbox_projection_failed",
+    "audit_outbox_retry_write_failed",
+    "auth_reverify_failed",
+    "backup_alert_report_failed",
+    "backup_failure_check",
+    "backup_failure_record_failed",
+    "backup_retired",
+    "backup_sanitized",
+    "body",
+    "btc_rate_stale_fallback",
+    "btc_rate_stale_refused",
+    "builder_identity_key_loose_mode",
+    "building_deploy_reaped",
+    "caller_data_retention.swept",
+    "caller_data_retention_failed",
+    "capability_gap_alert_error",
+    "cashu-mint-audit.tick",
+    "cashu-mint-health-cron.tick",
+    "cashu.get_wallet",
+    "cashu_audit_persist_failed",
+    "cashu_audit_recovery_failed",
+    "cashu_credential_rejected",
+    "cashu_mint_audit",
+    "cashu_mint_audit_endpoint_failed",
+    "cashu_mint_boot_health",
+    "cashu_mint_event_persist_failed",
+    "cashu_mint_health_check",
+    "cashu_mint_health_endpoint_failed",
+    "cashu_mint_nut_incompatible",
+    "cashu_mint_recovery_failed",
+    "cashu_mint_runtime_recovered",
+    "cashu_mint_runtime_sick",
+    "cashu_opts_env_ignored",
+    "cashu_refund_amount_unreported",
+    "ci_lane_report",
+    "ci_lane_report_unconfigured",
+    "complete",
+    "consumed_credential_store_in_memory",
+    "create",
+    "credit_deposit_record_failed",
+    "credit_drain_record_failed",
+    "credit_draw_fiat_at_par",
+    "credit_draw_reconcile_failed",
+    "credit_draw_reconciled",
+    "credit_draw_release_record_failed",
+    "credit_expiry_release_record_failed",
+    "credit_expiry_released",
+    "credit_expiry_sweep_failed",
+    "credit_funding_lot_backfill",
+    "credit_funding_unrecorded",
+    "credit_id",
+    "credit_job_row_recovered",
+    "credit_job_row_retry",
+    "credit_job_row_unwritten",
+    "credit_menu_bounds_unavailable",
+    "credit_menu_lightning_floor_unavailable",
+    "credit_menu_suppressed_non_durable",
+    "credit_rejected",
+    "credit_resolve_failed",
+    "credit_resolve_state_mismatch",
+    "credit_topup_over_ask",
+    "credit_topup_skipped",
+    "credit_topup_stale_rate",
+    "credit_topup_unbound",
+    "cron_fleet_drift_check",
+    "cron_fleet_drift_check_failed",
+    "deploy_archive_cleanup_failed",
+    "deploy_archive_rejected",
+    "deploy_failed_alert_error",
+    "deploy_probe_alert_error",
+    "deploy_reaped",
+    "deploy_reaper_fly_destroy_failed",
+    "deploy_reaper_pg_destroy_failed",
+    "deploy_reconciler_boot",
+    "deploy_reconciler_tick",
+    "diagnostic.message",
+    "diagnostic.unknown",
+    "domain-verify-backoff-cron.tick",
+    "domain_verify_backoff_check",
+    "domain_verify_backoff_endpoint_failed",
+    "draw_pool_unpriced",
+    "drawn_job_recovery_refused",
+    "dvm-stats-rollup-cron.tick",
+    "dvm.ask_pin_lost",
+    "dvm.ask_pin_stale_rate",
+    "dvm.auth.verify",
+    "dvm.credit.fund",
+    "dvm.fetch",
+    "dvm.handler",
+    "dvm.input.validate",
+    "dvm.kv.delete",
+    "dvm.kv.list",
+    "dvm.kv.read",
+    "dvm.kv.write",
+    "dvm.payment.validate",
+    "dvm.quote",
+    "dvm.request",
+    "dvm.topup_cap_absent",
+    "dvm.topup_cap_unenforceable",
+    "dvm.withdrawal_deleted",
+    "dvm.withdrawal_held",
+    "dvm.withdrawal_notice_failed",
+    "dvm.withdrawal_notice_undelivered",
+    "dvm.withdrawal_scale_down_failed",
+    "dvm.withdrawal_started",
+    "dvm.withdrawal_sweep_failed",
+    "dvm.withdrawal_swept",
+    "dvm_boot_phase_timings",
+    "dvm_failed_cleanup",
+    "dvm_failed_cleanup.fly_unavailable",
+    "dvm_failed_cleanup.kept_database",
+    "dvm_failed_cleanup.swept",
+    "dvm_failed_cleanup.teardown_pending",
+    "dvm_fly_health_check",
+    "dvm_fly_health_check_failed",
+    "dvm_fly_health_recovery_failed",
+    "dvm_stats_rollup_failed",
+    "dvms_listen_connect_failed",
+    "dvms_listen_lost",
+    "enforce-cron.tick",
+    "error",
+    "failed-dvm-cleanup-cron.tick",
+    "failed_dvm_cleanup_failed",
+    "fetch",
+    "fetch_complete",
+    "fetch_failed",
+    "fleet_drift_check",
+    "fleet_drift_check_failed",
+    "fly_app_anomaly_check",
+    "fly_app_anomaly_check_failed",
+    "fx-rate-refresh-cron.tick",
+    "fx_rate_attempt_failed",
+    "fx_rate_cold_start_failed",
+    "fx_rate_cold_start_synchronous_fetch",
+    "fx_rate_endpoint_failed",
+    "fx_rate_fetch_failed",
+    "fx_rate_fetch_ok",
+    "fx_rate_gap_fill",
+    "fx_rate_persist_failed",
+    "fx_rate_refresh_started",
+    "fx_rate_stale_warning",
+    "fx_rates_partial",
+    "fx_snapshot_endpoint_failed",
+    "fx_snapshot_stale",
+    "fx_staleness_check",
+    "groq_transcribe_failed",
+    "heartbeat_coverage_check",
+    "heartbeat_coverage_check_failed",
+    "hosting_teardown.replay_failed",
+    "hosting_teardown.unresolved",
+    "idle_suspend",
+    "ingest_staging_expired",
+    "isolate_background_invoke_failed",
+    "isolate_callback_ignored_terminal",
+    "isolate_invoke_state_ignored_cancelled",
+    "isolate_job_save_rejected_terminal",
+    "isolate_job_terminal_elsewhere",
+    "isolate_stale_job_reap_page_full",
+    "isolate_stale_job_reaped",
+    "isolate_stale_job_sweep_clock_skew",
+    "job_cost_record_failed",
+    "job_event_dropped",
+    "job_event_parse_error",
+    "job_heartbeat_failed",
+    "job_id",
+    "job_message_append_failed",
+    "job_messages_listen_connect_failed",
+    "job_messages_listen_lost",
+    "job_retention_alert_failed",
+    "job_retention_candidate_failed",
+    "job_retention_recovery_alert_failed",
+    "job_retention_report_failed",
+    "job_retention_store_unsupported",
+    "job_retention_sweep_failed",
+    "job_retention_swept",
+    "job_revenue_record_failed",
+    "job_save_rejected_terminal",
+    "job_status_watch_check_failed",
+    "job_status_watch_subscribe_failed",
+    "job_terminal_elsewhere",
+    "kind",
+    "kv_store_in_memory",
+    "lightning.get_balance",
+    "lightning.get_balance.result",
+    "lightning.get_info",
+    "lightning.get_info.result",
+    "lightning.list_transactions",
+    "lightning.list_transactions.result",
+    "lightning.lookup_invoice",
+    "lightning.make_invoice",
+    "lightning.make_invoice.result",
+    "lightning.pay_invoice",
+    "lightning.pay_invoice.reconciled",
+    "lightning.pay_invoice.republish",
+    "lightning_invoice_issue_failed",
+    "lightning_invoice_written_off",
+    "lightning_rail_health_fallback",
+    "lightning_rail_health_stale_observation",
+    "lightning_rail_health_staleness_ceiling",
+    "lightning_rail_health_unavailable",
+    "lightning_receive_permission_refused",
+    "lightning_receive_unreachable",
+    "lightning_settlement_blocked",
+    "lightning_settlement_check_failed",
+    "lock_pubkey_grace_seconds_invalid",
+    "log",
+    "melter_previous_run_read_failed",
+    "melter_report_unconfigured",
+    "melter_run_report",
+    "melter_run_write_failed",
+    "melter_runs_read_failed",
+    "melter_staleness_check",
+    "message",
+    "mpp_rapid_rotation_detected",
+    "nwc-float-health-cron.tick",
+    "nwc_balance_capacity_skipped",
+    "nwc_balance_ceiling_failed",
+    "nwc_balance_ceiling_unconfigured",
+    "nwc_balance_tiers_inverted",
+    "nwc_float_health_check",
+    "nwc_float_health_endpoint_failed",
+    "nwc_probe_persist_failed",
+    "nwc_probe_recovery_failed",
+    "nwc_probe_target_skipped",
+    "operator_alert",
+    "operator_alert_dedup_write_failed",
+    "operator_alert_email_failed",
+    "operator_alert_no_transport",
+    "operator_alert_recovery",
+    "operator_alert_webhook_failed",
+    "orphan_draw_release_failed",
+    "orphan_draw_released",
+    "orphan_draw_sweep_failed",
+    "orphan_draw_sweep_no_progress",
+    "orphan_draw_sweep_truncated",
+    "paid_job_death_check",
+    "paid_job_death_record_failed",
+    "paid_job_death_report_failed",
+    "paid_submit_replay_refused",
+    "parked",
+    "payment_mode",
+    "payout_amount_conflict",
+    "payout_batch_empty",
+    "payout_batch_raced",
+    "payout_batch_track_failed",
+    "payout_batch_untracked",
+    "payout_flush_failed",
+    "payout_pending_record_failed",
+    "payout_pending_report_failed",
+    "payout_pending_snapshot_failed",
+    "payout_record_failed",
+    "payout_report_failed",
+    "pg_notify_failed",
+    "phase",
+    "pinned",
+    "platform-db-health-cron.tick",
+    "platform.auth.verify_token",
+    "platform.builder.credit",
+    "platform.credit_expiry_release.record",
+    "platform.deposit.record",
+    "platform.drain.record",
+    "platform.draw_release.record",
+    "platform.fee.calculate",
+    "platform.invoice.create",
+    "platform.invoice.finalize",
+    "platform.payment.validate",
+    "platform.payout.record",
+    "platform.payout_pending.record",
+    "platform.revenue.record",
+    "platform.route.handle",
+    "platform_db_health_check",
+    "platform_db_health_check_failed",
+    "platform_db_health_endpoint_failed",
+    "platform_db_health_recovery_failed",
+    "platform_hosted_test_mint_allowed",
+    "postgres_transport_recovery",
+    "queued",
+    "receipt_issue_failed",
+    "receipts_disabled_store_unsupported",
+    "report_instant_out_of_range",
+    "reputation_flag",
+    "reputation_pruned_stale",
+    "request_acceptance_recovered",
+    "request_acceptance_recovery_refused",
+    "retention.swept",
+    "revenue-backlog-cron.tick",
+    "revenue_backlog_check",
+    "revenue_backlog_endpoint_failed",
+    "revenue_backlog_recovery_failed",
+    "revenue_deadletter_bump_failed",
+    "revenue_deadletter_drain",
+    "revenue_deadletter_enqueue_failed",
+    "revenue_reporter_abandoned",
+    "revenue_skipped_no_rail",
+    "revenue_skipped_no_rail_check",
+    "revenue_skipped_no_rail_record_failed",
+    "revenue_skipped_no_rail_report_failed",
+    "revenue_skipped_unsettled_draw",
+    "rollback",
+    "router.proxy",
+    "scrape_cache_touch_failed",
+    "scrape_cache_write_failed",
+    "scrape_card_segmentation_failed",
+    "scrape_event_write_failed",
+    "scrape_extract_cache_touch_failed",
+    "scrape_extract_cache_write_failed",
+    "scrape_extract_provenance_failed",
+    "scrape_job_cancelled",
+    "scrape_pagination_detection_failed",
+    "scrape_polish_cache_touch_failed",
+    "scrape_polish_cache_write_failed",
+    "scrape_rows_normalize_failed",
+    "scribe_job_cancelled",
+    "secp256k1_auth_replay_store_in_memory",
+    "sent",
+    "signed_request_replay_store_saturated",
+    "span_buffer_drop",
+    "span_dimension_oversized",
+    "span_flush_failed",
+    "span_ingestion_identity_resolution_failed",
+    "span_ingestion_insert_failed",
+    "span_truncated",
+    "spans-retention-cron.tick",
+    "spans_pipeline_check",
+    "spans_pipeline_recovery_failed",
+    "spans_retention_failed",
+    "stale_job_cancelled",
+    "stale_job_failed",
+    "stale_job_sweep_clock_skew",
+    "stale_job_sweep_failed",
+    "stripe.create_checkout_session",
+    "stripe.create_portal_session",
+    "stripe.get_or_create_customer",
+    "stripe.get_or_create_customer.result",
+    "stripe.handle_webhook",
+    "stripe.handle_webhook.verified",
+    "stripe.on_checkout_completed",
+    "stripe.on_checkout_completed.customer_deleted",
+    "stripe.on_checkout_completed.metadata_mismatch_bound",
+    "stripe.on_checkout_completed.metadata_mismatch_first_bind",
+    "stripe.on_invoice_created",
+    "stripe.on_invoice_paid",
+    "stripe.process_event",
+    "stripe_webhook_error_rate_check",
+    "stripe_webhook_gap_check",
+    "substrate_escalation",
+    "tempo.issue_challenges",
+    "tempo.verify_credential",
+    "tempo_channel_binding_malformed",
+    "tempo_channel_binding_missing",
+    "tempo_channel_binding_unavailable",
+    "tempo_channel_escrow_changed",
+    "tempo_channel_owner_conflict",
+    "tempo_channel_registration_failed",
+    "tempo_charge_replay_store_in_memory",
+    "tempo_close_credential_refresh_required",
+    "tempo_close_credential_wrong_channel",
+    "tempo_close_delivery_configuration_error",
+    "tempo_close_event",
+    "tempo_close_events_rearmed",
+    "tempo_close_finalized_before_protection",
+    "tempo_close_health_check",
+    "tempo_close_observer_tick",
+    "tempo_credential_rejected",
+    "tempo_deposit_registration_alert_failed",
+    "tempo_drain_refund_below_debit",
+    "tempo_drain_refund_forecast_below_debit",
+    "tempo_drain_refund_forecast_unavailable",
+    "tempo_drain_written_off",
+    "tempo_observer_health_unavailable",
+    "tempo_observer_scan_failed",
+    "tempo_refund_amount_unreported",
+    "tempo_routine_sweep",
+    "tempo_routine_sweep_failed",
+    "tempo_session_advertised_refresh_failed",
+    "tempo_session_close_challenge_failed",
+    "tempo_session_close_failed",
+    "tempo_session_close_failure_reconcile_failed",
+    "tempo_session_close_recovery_failed",
+    "tempo_session_open_refused",
+    "tempo_session_settled",
+    "tempo_session_withheld",
+    "tempo_settlement_balance_alert_failed",
+    "tempo_settlement_failure_alert_failed",
+    "tempo_settlement_fee_balance",
+    "tempo_settlement_fee_balance_failed",
+    "tempo_settlement_insufficient_funds",
+    "tempo_settlement_readiness_report_failed",
+    "tempo_settlement_readiness_state_failed",
+    "terminal_cost_handoff_retry_scheduled",
+    "terminal_cost_recovery_complete",
+    "terminal_cost_recovery_failed",
+    "terminal_cost_recovery_truncated",
+    "transcriber_fallback",
+    "update",
+    "upgrade_prompt_evaluation_failed",
+    "wallet_accumulator_batch_expired",
+    "wallet_accumulator_batch_expiring_soon",
+    "wallet_accumulator_batch_orphan_lock_pubkey",
+    "wallet_accumulator_batch_retired_lock_pubkey",
+    "wallet_accumulator_lock_pubkey_prune_failed",
+    "wallet_accumulator_monitor_start_failed",
+    "wallet_accumulator_reaped_expired_keyset",
+    "wallet_accumulator_tick_error",
+    "warning",
+    "x402.settle_with_facilitator",
+    "x402.settle_with_facilitator.result",
+    "x402.verify_payment",
+    "x402.verify_payment.result",
+    "x402.verify_with_facilitator",
+    "x402.verify_with_facilitator.result",
+    "x402_claim_ceiling_unbound",
+    "x402_claim_ceiling_unresolved",
+    "x402_credential_rejected",
+    "x402_facilitator_capability_degraded",
+    "x402_facilitator_fallback",
+    "x402_facilitator_staleness_ceiling",
+    "x402_facilitator_unavailable",
+    "x402_network_unsupported",
+    "x402_refund_amount_unreported",
+    "x402_repair_channel_state_stale",
+    "x402_repair_write_off_restore_failed",
+    "x402_self_relay_gas_alert_failed",
+    "x402_self_relay_gas_balance",
+    "x402_self_relay_gas_balance_failed",
+    "x402_self_relay_gas_balance_report_failed",
+    "x402_self_relay_rpc_alert_failed",
+    "x402_self_relay_rpc_failed",
+    "x402_self_relay_rpc_health_report_failed",
+    "x402_self_relay_submission_lock_timeout",
+    "x402_self_relay_unserialized",
+    "x402_settlement_reconciliation_chain_unreachable",
+    "x402_settlement_reconciliation_facilitator_unavailable",
+    "x402_settlement_submission_failed",
+    "x402_settlement_written_off"
+  ],
+  routeTemplates: [
+    "/",
+    "/_dev",
+    "/_internal/abuse-signal",
+    "/_internal/backup-alert",
+    "/_internal/cashu-mint-audit",
+    "/_internal/cashu-mint-health",
+    "/_internal/cast/backup",
+    "/_internal/cast/cleanup",
+    "/_internal/cast/repair-durations",
+    "/_internal/ci-lane-report",
+    "/_internal/credit-deposit",
+    "/_internal/credit-drain",
+    "/_internal/credit-draw-release",
+    "/_internal/credit-expiry-release",
+    "/_internal/domain-verify-backoff",
+    "/_internal/dvm-stats-rollup",
+    "/_internal/enforce",
+    "/_internal/failed-dvm-cleanup",
+    "/_internal/fx",
+    "/_internal/fx-rates/refresh",
+    "/_internal/job-cost",
+    "/_internal/job-retention",
+    "/_internal/job-revenue",
+    "/_internal/job-terminal",
+    "/_internal/lightning-rail-health",
+    "/_internal/liveness-probe",
+    "/_internal/melter-report",
+    "/_internal/nwc-float-health",
+    "/_internal/paid-job-death",
+    "/_internal/payout",
+    "/_internal/payout-pending",
+    "/_internal/platform-db-health",
+    "/_internal/registry",
+    "/_internal/registry-ranking",
+    "/_internal/revalidate",
+    "/_internal/revenue-backlog",
+    "/_internal/revenue-skipped-no-rail",
+    "/_internal/scribe/cleanup",
+    "/_internal/spans",
+    "/_internal/spans-retention",
+    "/_internal/tempo-close-event",
+    "/_internal/tempo-observer-health",
+    "/_internal/tempo-settlement-balance",
+    "/_internal/tempo-settlement-failure",
+    "/_internal/x402-self-relay-gas-balance",
+    "/_internal/x402-self-relay-rpc-health",
+    "/_isolate/info",
+    "/_isolate/invoke",
+    "/admin/cashu/mark-melted",
+    "/admin/cashu/pending-batches",
+    "/admin/cashu/restart-failed",
+    "/admin/cashu/rotate-lock-pubkey",
+    "/admin/credit/bitcoin-liability",
+    "/admin/credit/blocked-invoices",
+    "/admin/credit/mark-drain-sent",
+    "/admin/credit/park-drain",
+    "/admin/credit/pending-drains",
+    "/admin/credit/reconcile-invoice",
+    "/admin/credit/reconcile-tempo-drain",
+    "/admin/credit/reconcile-x402-exact-settlement",
+    "/admin/credit/reconcile-x402-settlement",
+    "/admin/credit/tempo-drains",
+    "/admin/credit/tempo-losses",
+    "/admin/credit/write-off-invoice",
+    "/admin/credit/write-off-tempo-drain",
+    "/admin/credit/write-off-x402-settlement",
+    "/admin/credit/x402-exact-settlements",
+    "/admin/credit/x402-settlements",
+    "/api-keys",
+    "/api-keys/:id",
+    "/api-keys/:id/rotate",
+    "/api/activity",
+    "/api/builders",
+    "/api/builders/:id",
+    "/api/deploys",
+    "/api/dvms",
+    "/api/dvms/:id",
+    "/api/dvms/:id/resume",
+    "/api/dvms/:id/suspend",
+    "/api/health",
+    "/api/jobs",
+    "/api/metrics",
+    "/api/revenue",
+    "/api/stats",
+    "/api/v1/billing/capabilities",
+    "/api/v1/billing/plans/public",
+    "/api/v1/cli-auth/:session",
+    "/api/v1/cli-auth/:session/cancel",
+    "/api/v1/feedback",
+    "/api/v1/github/installation-callback",
+    "/api/v1/github/webhook",
+    "/api/v1/handle/check/:handle",
+    "/api/v1/invites/:token",
+    "/api/v1/invites/pending",
+    "/api/v1/mint-health",
+    "/api/v1/profiles/:handle",
+    "/api/v1/profiles/:handle/dvms/:slug",
+    "/api/v1/public/explore",
+    "/api/v1/wallet-pairings",
+    "/api/v1/wallet-pairings/:session",
+    "/api/v1/wallet-pairings/:session/manifest",
+    "/api/v1/wallet-pairings/:session/submission",
+    "/api/v1/wallet-pairings/:session/submission/:event",
+    "/api/v1/webhooks/stripe",
+    "/auth/me",
+    "/billing",
+    "/billing/checkout",
+    "/billing/compute",
+    "/billing/egress",
+    "/billing/invoices",
+    "/billing/invoices/:id",
+    "/billing/lightning/checkout",
+    "/billing/lightning/invoice/:id",
+    "/billing/plan-change/:id",
+    "/billing/plan-change/:id/purchase",
+    "/billing/plan-change/:id/renew-with-credit",
+    "/billing/plan-change/:id/schedule",
+    "/billing/plan-change/quote",
+    "/billing/plans",
+    "/billing/portal",
+    "/billing/revenue",
+    "/billing/revenue/events",
+    "/billing/subscription/renew-current-with-credit",
+    "/billing/usage",
+    "/builders/me/base",
+    "/builders/me/billing-vat",
+    "/builders/me/tempo",
+    "/builders/me/terms",
+    "/deploy",
+    "/deploy/local",
+    "/deploys/:id",
+    "/deploys/:id/logs",
+    "/deploys/recent",
+    "/dvms",
+    "/dvms/:dvmId",
+    "/dvms/:dvmId/committed",
+    "/dvms/:dvmId/db-tunnel",
+    "/dvms/:dvmId/deploy-identity",
+    "/dvms/:dvmId/deploys",
+    "/dvms/:dvmId/deposits",
+    "/dvms/:dvmId/domains",
+    "/dvms/:dvmId/domains/:domain",
+    "/dvms/:dvmId/domains/:domain/verify",
+    "/dvms/:dvmId/earnings",
+    "/dvms/:dvmId/env",
+    "/dvms/:dvmId/events",
+    "/dvms/:dvmId/exec",
+    "/dvms/:dvmId/git/link",
+    "/dvms/:dvmId/jobs/:jobId/artifact",
+    "/dvms/:dvmId/jobs/:jobId/complete",
+    "/dvms/:dvmId/jobs/:jobId/cost",
+    "/dvms/:dvmId/jobs/:jobId/fail",
+    "/dvms/:dvmId/jobs/:jobId/message",
+    "/dvms/:dvmId/jobs/:jobId/payment-request",
+    "/dvms/:dvmId/jobs/:jobId/progress",
+    "/dvms/:dvmId/jobs/:jobId/prompt",
+    "/dvms/:dvmId/jobs/:jobId/status",
+    "/dvms/:dvmId/jobs/:jobId/step-result",
+    "/dvms/:dvmId/jobs/:jobId/text",
+    "/dvms/:dvmId/jobs/:jobId/working",
+    "/dvms/:dvmId/kv",
+    "/dvms/:dvmId/kv/:key",
+    "/dvms/:dvmId/lock-pubkey",
+    "/dvms/:dvmId/logs",
+    "/dvms/:dvmId/metrics",
+    "/dvms/:dvmId/pause",
+    "/dvms/:dvmId/redeploy",
+    "/dvms/:dvmId/restart",
+    "/dvms/:dvmId/resume",
+    "/dvms/:dvmId/rollback",
+    "/dvms/:dvmId/rotate-lock-pubkey",
+    "/dvms/:dvmId/scale",
+    "/dvms/:dvmId/secret-recovery",
+    "/dvms/:dvmId/secrets",
+    "/dvms/:dvmId/settings",
+    "/dvms/:dvmId/ssh",
+    "/dvms/:dvmId/stats",
+    "/dvms/:dvmId/status",
+    "/dvms/:dvmId/storefront",
+    "/dvms/:dvmId/transfer",
+    "/dvms/:dvmId/visibility",
+    "/dvms/refresh-meta",
+    "/events",
+    "/feedback",
+    "/feeds/:owner/:slug",
+    "/github/app-info",
+    "/github/install-intent",
+    "/github/installations",
+    "/github/installations/:id/repos",
+    "/handle",
+    "/health",
+    "/healthz",
+    "/hosting/capacity/accounts/:accountId",
+    "/hosting/capacity/accounts/:accountId/exemption",
+    "/hosting/capacity/accounts/:accountId/operations/:operationId/release",
+    "/hosting/capacity/accounts/:accountId/override",
+    "/hosting/storage/inventory",
+    "/invites/:token/accept",
+    "/me",
+    "/metrics/summary",
+    "/notifications",
+    "/notifications/preferences",
+    "/notifications/read",
+    "/notifications/unread-count",
+    "/orgs",
+    "/orgs/:handle",
+    "/orgs/:handle/avatar",
+    "/orgs/:handle/base",
+    "/orgs/:handle/billing",
+    "/orgs/:handle/billing-vat",
+    "/orgs/:handle/billing/checkout",
+    "/orgs/:handle/billing/compute",
+    "/orgs/:handle/billing/egress",
+    "/orgs/:handle/billing/invoices",
+    "/orgs/:handle/billing/portal",
+    "/orgs/:handle/billing/usage",
+    "/orgs/:handle/committed",
+    "/orgs/:handle/credits",
+    "/orgs/:handle/dvms",
+    "/orgs/:handle/earnings",
+    "/orgs/:handle/events",
+    "/orgs/:handle/feed",
+    "/orgs/:handle/invites",
+    "/orgs/:handle/invites/:id",
+    "/orgs/:handle/keys",
+    "/orgs/:handle/keys/:hash",
+    "/orgs/:handle/members",
+    "/orgs/:handle/members/:bh",
+    "/orgs/:handle/members/:bh/role",
+    "/orgs/:handle/members/history",
+    "/orgs/:handle/metrics/summary",
+    "/orgs/:handle/notification-preferences",
+    "/orgs/:handle/payout-pending",
+    "/orgs/:handle/payout-routing",
+    "/orgs/:handle/payouts",
+    "/orgs/:handle/payouts/csv",
+    "/orgs/:handle/revenue/csv",
+    "/orgs/:handle/revenue/events",
+    "/orgs/:handle/revenue/series",
+    "/orgs/:handle/settlements",
+    "/orgs/:handle/settlements/csv",
+    "/orgs/:handle/stats",
+    "/orgs/:handle/tempo",
+    "/orgs/:handle/transfer",
+    "/profile",
+    "/profile/avatar",
+    "/revenue/csv",
+    "/revenue/events",
+    "/revenue/series",
+    "/spans",
+    "/traces",
+    "/traces/:trace_id",
+    "/traces/aggregate",
+    "/v1/credit",
+    "/v1/info",
+    "/v1/ingest/audio",
+    "/v1/ingest/image",
+    "/v1/job",
+    "/v1/job/:id",
+    "/v1/job/:id/messages",
+    "/v1/quote",
+    "/v1/request-result/:requestId",
+    "/v1/request-resume/:requestId"
+  ],
+  errorCodes: [
+    "app_shell_detected",
+    "audio_source_required",
+    "auth_error",
+    "auth_required",
+    "bytes_cap",
+    "capability_required",
+    "captcha_unsolved",
+    "cloudflare_unsolved",
+    "content_rejected",
+    "cover_invalid",
+    "credit_fund_failed",
+    "css_selector_for_requested_content",
+    "decoder_failed",
+    "decoder_unavailable",
+    "diarise_failed",
+    "display",
+    "dns_failed",
+    "duration_exceeds_cap",
+    "empty_body",
+    "episode_not_found",
+    "extract_input_too_large",
+    "extract_llm_failed",
+    "extract_schema_invalid",
+    "extract_validation_failed",
+    "feed_full",
+    "feed_not_found",
+    "feed_path_invalid",
+    "fetch_blocked",
+    "fetch_timeout",
+    "forbidden",
+    "format_unsupported",
+    "function",
+    "fx_rate_unavailable",
+    "geo_blocked",
+    "hardened",
+    "head_status",
+    "hint",
+    "ingest_concurrency",
+    "ingest_global_concurrency",
+    "ingest_ip_concurrency",
+    "inline_too_large",
+    "insecure_scheme",
+    "internal_error",
+    "invalid_input",
+    "invalid_menu",
+    "invalid_payment",
+    "invalid_quote_data",
+    "invalid_url",
+    "job_failed",
+    "job_timeout",
+    "login_wall_detected",
+    "message",
+    "milliseconds",
+    "network_error",
+    "no_diariser",
+    "no_premium_substrate",
+    "none",
+    "not_found",
+    "object",
+    "output_delivery_failed",
+    "oversize",
+    "owner_short_collision",
+    "page_too_large",
+    "path_not_found",
+    "payment_invalid",
+    "payment_required",
+    "paywall_detected",
+    "polish_input_too_large",
+    "polish_llm_failed",
+    "presign_failed",
+    "private_address",
+    "probe_failed",
+    "provider",
+    "provider_allowance_exhausted",
+    "provider_error",
+    "provider_failed",
+    "provider_invalid_response",
+    "provider_network",
+    "provider_rate_limit",
+    "provider_rejected",
+    "provider_rejected_audio",
+    "provider_timeout",
+    "provider_unavailable",
+    "quota_exceeded",
+    "rate_limited",
+    "rate_limited_by_target",
+    "replay_detected",
+    "request_integrity_failed",
+    "retry_hardened",
+    "retry_with_bounded_wait",
+    "retry_with_content_selector",
+    "seconds_cap",
+    "selector",
+    "server_error",
+    "sha256_mismatch",
+    "signature_invalid",
+    "size_mismatch",
+    "source_unreachable",
+    "ssrf_blocked",
+    "string",
+    "substrate_unavailable",
+    "timeout",
+    "timestamp_drift",
+    "torn_upload",
+    "transcribe_failed",
+    "unauthorized",
+    "unexpected",
+    "unexpected_status",
+    "unknown_error",
+    "unsafe_url",
+    "upload_failed",
+    "upload_handle_expired",
+    "upload_handle_not_found",
+    "upload_handle_not_owner",
+    "upload_kind_mismatch",
+    "upstream",
+    "upstream_network",
+    "upstream_status",
+    "upstream_timeout",
+    "use_alternative_source",
+    "wait_for_selector",
+    "wait_too_long",
+    "wrong_content_type"
+  ],
+  datasets: [
+    "platform",
+    "cashu",
+    "lightning",
+    "stripe",
+    "x402",
+    "tempo",
+    "isolate",
+    "audit",
+    "cron"
+  ],
+  levels: [
+    "info",
+    "warn",
+    "error"
+  ],
+  statuses: [
+    "ok",
+    "error"
+  ],
+  methods: [
+    "GET",
+    "POST",
+    "PUT",
+    "PATCH",
+    "DELETE",
+    "HEAD",
+    "OPTIONS"
+  ],
+  rails: [
+    "cashu",
+    "lightning",
+    "x402",
+    "tempo"
+  ],
+  stages: [
+    "input",
+    "quote"
+  ],
+  handlers: [
+    "job",
+    "quote"
+  ],
+  currencyTokens: [
+    "BTC",
+    "SAT",
+    "SATS",
+    "MSAT",
+    "MSATS",
+    "USD",
+    "EUR",
+    "GBP",
+    "USDC",
+    "AlphaUSD",
+    "BetaUSD",
+    "pathUSD",
+    "btc",
+    "sat",
+    "sats",
+    "msat",
+    "msats",
+    "usd",
+    "eur",
+    "gbp",
+    "usdc"
+  ],
+  booleanFields: [
+    "client.capabilities_valid",
+    "client.protocol_version_valid",
+    "client.version_valid",
+    "http.probe",
+    "is_valid",
+    "rate_carried_forward",
+    "republished",
+    "storefront_probe",
+    "success",
+    "verified",
+    "wallet_reported_budget"
+  ],
+  integerFields: [
+    "ageMs",
+    "age_ms",
+    "amount_micro",
+    "amount_msats",
+    "ask_msats",
+    "asked_topup_micro",
+    "attempt",
+    "balance_msats",
+    "batch_size",
+    "buffer_size",
+    "count",
+    "cutoff_ms",
+    "durationMs",
+    "duration_ms",
+    "elapsedMs",
+    "elapsed_ms",
+    "latencyMs",
+    "latency_ms",
+    "method_count",
+    "proofAmount",
+    "required_msats",
+    "required_usdc_micro",
+    "retention_days",
+    "retry_count",
+    "rows_deleted",
+    "skewMs",
+    "skew_ms",
+    "timeout_ms",
+    "totalSats",
+    "transaction_count",
+    "value_size_bytes"
+  ],
+  tokenFields: [],
+  hashFields: [
+    "key_hash",
+    "prefix_hash"
+  ],
+  urlFields: [
+    "url",
+    "facilitator_url",
+    "mint_url"
+  ],
+  identityFields: [
+    "dvm_id",
+    "dvm_slug",
+    "builder_id"
+  ],
+  capabilityFields: [
+    "capability"
+  ],
+  clientProtocolVersions: [
+    1
+  ],
+  clientVersionFields: [
+    "client.version"
+  ]
+};
+
+// src/observability/projection.ts
+var DIAGNOSTIC_CATALOGUE_VERSION = diagnostic_catalogue_v1_default.version;
+var EVENTS = new Set(diagnostic_catalogue_v1_default.events);
+var ROUTE_TEMPLATES = new Set(diagnostic_catalogue_v1_default.routeTemplates);
+var ERROR_CODES = new Set(diagnostic_catalogue_v1_default.errorCodes);
+var DATASETS = new Set(diagnostic_catalogue_v1_default.datasets);
+var LEVELS = new Set(diagnostic_catalogue_v1_default.levels);
+var STATUSES = new Set(diagnostic_catalogue_v1_default.statuses);
+var METHODS = new Set(diagnostic_catalogue_v1_default.methods);
+var RAILS = new Set(diagnostic_catalogue_v1_default.rails);
+var STAGES = new Set(diagnostic_catalogue_v1_default.stages);
+var HANDLERS = new Set(diagnostic_catalogue_v1_default.handlers);
+var CURRENCIES = new Set(diagnostic_catalogue_v1_default.currencyTokens);
+var BOOLEAN_FIELDS = new Set(diagnostic_catalogue_v1_default.booleanFields);
+var INTEGER_FIELDS = new Set(diagnostic_catalogue_v1_default.integerFields);
+var TOKEN_FIELDS = new Set(diagnostic_catalogue_v1_default.tokenFields);
+var HASH_FIELDS = new Set(diagnostic_catalogue_v1_default.hashFields);
+var URL_FIELDS = new Set(diagnostic_catalogue_v1_default.urlFields);
+var IDENTITY_FIELDS = new Set(diagnostic_catalogue_v1_default.identityFields);
+var CAPABILITY_FIELDS = new Set(diagnostic_catalogue_v1_default.capabilityFields);
+var CLIENT_PROTOCOL_VERSIONS = new Set(
+  diagnostic_catalogue_v1_default.clientProtocolVersions
+);
+var CLIENT_VERSION_FIELDS = new Set(diagnostic_catalogue_v1_default.clientVersionFields);
+var SPAN_ID_RE = /^(?!0{16}$)[0-9a-f]{16}$/;
+var TRACE_ID_RE = /^(?!0{32}$)[0-9a-f]{32}$/;
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var SLUG_RE = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
+var MACHINE_ID_RE = /^[0-9a-f]{12,32}$/;
+var RELEASE_RE = /^(?:v?\d+\.\d+\.\d+(?:-rc\.\d+)?|[0-9a-f]{7,40}|dev|test|unknown)$/;
+var CAPABILITY_RE = /^[a-z][a-z0-9_-]{0,47}$/;
+var CLIENT_VERSION_RE = /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-rc\.(?:0|[1-9]\d*))?$/;
+var HASH_RE = /^(?:[0-9a-f]{16}|[0-9a-f]{64})$/i;
+var DECIMAL_RE = /^(?:0|[1-9]\d{0,77})$/;
+var STRIPE_EVENT_RE = /^evt_[A-Za-z0-9]{1,64}$/;
+var SERVICE_NAMES = /* @__PURE__ */ new Set([
+  "platform-api",
+  "router",
+  "dvmadmin",
+  "admin",
+  "unknown"
+]);
+var AUTHORITY_CAPABILITIES = /* @__PURE__ */ new WeakMap();
+var VALUE_AUTHORITIES = /* @__PURE__ */ new WeakMap();
+var AUTHORITY_IDENTITIES = /* @__PURE__ */ new WeakMap();
+var VALUE_IDENTITY_AUTHORITIES = /* @__PURE__ */ new WeakMap();
+function createDiagnosticCapabilityAuthority(capabilityNames) {
+  const allowed = new Set(
+    capabilityNames.filter(
+      (name) => typeof name === "string" && CAPABILITY_RE.test(name)
+    )
+  );
+  const authority = Object.freeze({});
+  AUTHORITY_CAPABILITIES.set(authority, allowed);
+  return authority;
+}
+function bindDiagnosticCapabilityAuthority(value, authority) {
+  if (authority && AUTHORITY_CAPABILITIES.has(authority)) {
+    VALUE_AUTHORITIES.set(value, authority);
+  }
+  return value;
+}
+function extendDiagnosticIdentityAuthority(authority, key, value) {
+  if (!IDENTITY_FIELDS.has(key)) return authority;
+  const projected = validateIdentity(key, value);
+  if (projected === void 0) return authority;
+  const identities = {
+    ...authority && AUTHORITY_IDENTITIES.get(authority),
+    [key]: projected
+  };
+  const next = Object.freeze({});
+  AUTHORITY_IDENTITIES.set(next, Object.freeze(identities));
+  return next;
+}
+function bindDiagnosticIdentityAuthority(value, authority) {
+  if (authority && AUTHORITY_IDENTITIES.has(authority)) {
+    VALUE_IDENTITY_AUTHORITIES.set(value, authority);
+  }
+  return value;
+}
+function projectSpanRow(input) {
+  try {
+    if (!isObject(input)) return { ok: false, code: "invalid_span" };
+    const authority = VALUE_AUTHORITIES.get(input);
+    const identityAuthority = VALUE_IDENTITY_AUTHORITIES.get(input);
+    const spanId = ownValue(input, "span_id");
+    if (typeof spanId !== "string" || !SPAN_ID_RE.test(spanId)) {
+      return { ok: false, code: "invalid_span_id" };
+    }
+    const traceId = ownValue(input, "trace_id");
+    if (typeof traceId !== "string" || !TRACE_ID_RE.test(traceId)) {
+      return { ok: false, code: "invalid_trace_id" };
+    }
+    const parentSpanId = ownValue(input, "parent_span_id");
+    if (parentSpanId !== null && (typeof parentSpanId !== "string" || !SPAN_ID_RE.test(parentSpanId))) {
+      return { ok: false, code: "invalid_parent_span_id" };
+    }
+    const dataset = ownValue(input, "dataset");
+    if (typeof dataset !== "string" || !DATASETS.has(dataset)) {
+      return { ok: false, code: "invalid_dataset" };
+    }
+    const level = ownValue(input, "level");
+    if (typeof level !== "string" || !LEVELS.has(level)) {
+      return { ok: false, code: "invalid_level" };
+    }
+    const status = ownValue(input, "status");
+    if (typeof status !== "string" || !STATUSES.has(status)) {
+      return { ok: false, code: "invalid_status" };
+    }
+    const startedAtMs = ownValue(input, "started_at_ms");
+    const endedAtMs = ownValue(input, "ended_at_ms");
+    if (!isEpochMs(startedAtMs) || !isEpochMs(endedAtMs) || endedAtMs < startedAtMs) {
+      return { ok: false, code: "invalid_timestamp" };
+    }
+    const sampleRate = ownValue(input, "sample_rate");
+    const pid = ownValue(input, "pid");
+    const rawName = ownValue(input, "name");
+    const row = {
+      span_id: spanId,
+      trace_id: traceId,
+      parent_span_id: parentSpanId,
+      dataset,
+      name: typeof rawName === "string" && EVENTS.has(rawName) ? rawName : "diagnostic.unknown",
+      level,
+      status,
+      started_at_ms: startedAtMs,
+      ended_at_ms: endedAtMs,
+      service: projectService(ownValue(input, "service")),
+      service_version: projectServiceVersion(
+        ownValue(input, "service_version")
+      ),
+      host: projectHost(ownValue(input, "host")),
+      pid: Number.isInteger(pid) && pid >= 1 && pid <= 2147483647 ? pid : null,
+      dimensions: projectFields(
+        ownValue(input, "dimensions"),
+        dataset,
+        authority,
+        identityAuthority
+      ),
+      attributes: projectFields(
+        ownValue(input, "attributes"),
+        dataset,
+        authority,
+        identityAuthority
+      ),
+      error_message: null,
+      error_stack: null,
+      sample_rate: typeof sampleRate === "number" && Number.isFinite(sampleRate) && sampleRate > 0 && sampleRate <= 1 ? sampleRate : 1
+    };
+    bindDiagnosticCapabilityAuthority(row, authority);
+    bindDiagnosticIdentityAuthority(row, identityAuthority);
+    return {
+      ok: true,
+      row
+    };
+  } catch {
+    return { ok: false, code: "invalid_span" };
+  }
+}
+function projectDiagnosticFields(input, dataset, authority, identityAuthority) {
+  try {
+    const inheritedAuthority = isObject(input) ? VALUE_AUTHORITIES.get(input) : void 0;
+    const effectiveAuthority = validAuthority(authority) ?? inheritedAuthority;
+    const inheritedIdentityAuthority = isObject(input) ? VALUE_IDENTITY_AUTHORITIES.get(input) : void 0;
+    const effectiveIdentityAuthority = validIdentityAuthority(identityAuthority) ?? inheritedIdentityAuthority;
+    const output = projectFields(
+      input,
+      dataset,
+      effectiveAuthority,
+      effectiveIdentityAuthority
+    );
+    bindDiagnosticCapabilityAuthority(output, effectiveAuthority);
+    bindDiagnosticIdentityAuthority(output, effectiveIdentityAuthority);
+    return output;
+  } catch {
+    return {};
+  }
+}
+function projectEventName(input, fallback = "diagnostic.unknown") {
+  return typeof input === "string" && EVENTS.has(input) ? input : fallback;
+}
+function projectFields(input, dataset, authority, identityAuthority) {
+  if (!isObject(input)) return {};
+  const output = {};
+  for (const [key, value] of ownDataEntries(input, 64)) {
+    if (key.length > 64) continue;
+    const projected = projectField(
+      key,
+      value,
+      dataset,
+      authority,
+      identityAuthority
+    );
+    if (projected !== void 0) output[key] = projected;
+  }
+  return output;
+}
+function projectField(key, value, dataset, authority, identityAuthority) {
+  if (BOOLEAN_FIELDS.has(key))
+    return typeof value === "boolean" ? value : void 0;
+  if (INTEGER_FIELDS.has(key))
+    return isNonnegativeSafeInteger(value) ? value : void 0;
+  if (HASH_FIELDS.has(key))
+    return typeof value === "string" && HASH_RE.test(value) ? value : void 0;
+  if (URL_FIELDS.has(key)) return projectOrigin(value);
+  if (IDENTITY_FIELDS.has(key)) return projectIdentity(key, identityAuthority);
+  if (TOKEN_FIELDS.has(key)) return void 0;
+  if (CAPABILITY_FIELDS.has(key)) return projectCapability(value, authority);
+  if (CLIENT_VERSION_FIELDS.has(key)) return projectClientVersion(value);
+  if (key === "client.protocol_version")
+    return typeof value === "number" && CLIENT_PROTOCOL_VERSIONS.has(value) ? value : void 0;
+  if (key === "route" || key === "http.route" || key === "resource_path")
+    return projectRoute(value);
+  if (key === "status_code" || key === "http.status_code") {
+    return Number.isInteger(value) && value >= 100 && value <= 599 ? value : void 0;
+  }
+  if (key === "method" || key === "http.method") {
+    if (typeof value !== "string") return void 0;
+    if (METHODS.has(value)) return value;
+    return key === "method" && dataset === "tempo" && (value === "charge" || value === "session") ? value : void 0;
+  }
+  if (key === "rail")
+    return typeof value === "string" && RAILS.has(value) ? value : void 0;
+  if (key === "stage")
+    return typeof value === "string" && STAGES.has(value) ? value : void 0;
+  if (key === "handler")
+    return typeof value === "string" && HANDLERS.has(value) ? value : void 0;
+  if (key === "dataset")
+    return typeof value === "string" && DATASETS.has(value) ? value : void 0;
+  if (key === "error.code" || key === "error_code" || key === "code") {
+    if (typeof value !== "string") return void 0;
+    return ERROR_CODES.has(value) ? value : key === "error.code" || key === "error_code" ? "unknown_error" : void 0;
+  }
+  if (key === "currency" || key === "ask_currency" || key === "asked_topup_currency") {
+    return typeof value === "string" && CURRENCIES.has(value) ? value : void 0;
+  }
+  if (key === "amount") {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= Number.MAX_SAFE_INTEGER ? value : void 0;
+  }
+  if (key === "forecast.refund_native" || key === "drain.native") {
+    if (isNonnegativeSafeInteger(value)) return value;
+    return typeof value === "string" && DECIMAL_RE.test(value) ? value : void 0;
+  }
+  if (key === "event_id")
+    return typeof value === "string" && STRIPE_EVENT_RE.test(value) ? value : void 0;
+  if (key === "reject_reason")
+    return value === "scanner_probe" ? value : void 0;
+  return void 0;
+}
+function projectService(value) {
+  if (typeof value !== "string") return "unknown";
+  if (SERVICE_NAMES.has(value)) return value;
+  if (value.startsWith("isolate-") && SLUG_RE.test(value.slice(8)))
+    return value;
+  return "unknown";
+}
+function projectServiceVersion(value) {
+  return typeof value === "string" && value.length <= 64 && RELEASE_RE.test(value) ? value : "unknown";
+}
+function projectHost(value) {
+  if (value === "localhost") return value;
+  return typeof value === "string" && MACHINE_ID_RE.test(value) ? value : null;
+}
+function validateIdentity(key, value) {
+  if (typeof value !== "string") return void 0;
+  if (key === "dvm_slug") return SLUG_RE.test(value) ? value : void 0;
+  return value.length <= 36 && UUID_RE.test(value) ? value : void 0;
+}
+function projectIdentity(key, authority) {
+  return authority && AUTHORITY_IDENTITIES.get(authority)?.[key];
+}
+function projectCapability(value, authority) {
+  if (typeof value !== "string" || !CAPABILITY_RE.test(value)) return void 0;
+  const allowed = authority && AUTHORITY_CAPABILITIES.get(authority);
+  return allowed?.has(value) ? value : void 0;
+}
+function projectClientVersion(value) {
+  return typeof value === "string" && value.length <= 64 && CLIENT_VERSION_RE.test(value) ? value : void 0;
+}
+function validAuthority(authority) {
+  return authority && AUTHORITY_CAPABILITIES.has(authority) ? authority : void 0;
+}
+function validIdentityAuthority(authority) {
+  return authority && AUTHORITY_IDENTITIES.has(authority) ? authority : void 0;
+}
+function projectOrigin(value) {
+  if (typeof value !== "string" || value.length > 2048) return void 0;
+  try {
+    const parsed = new URL(value);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:" || parsed.username || parsed.password)
+      return void 0;
+    const hostname = parsed.hostname.toLowerCase();
+    if (isIP(hostname) !== 0 || !isDnsName(hostname)) return void 0;
+    return `${parsed.protocol}//${hostname}`;
+  } catch {
+    return void 0;
+  }
+}
+function projectRoute(value) {
+  if (typeof value !== "string" || value.length > 512 || /[?#@]/.test(value) || !value.startsWith("/"))
+    return void 0;
+  const normalized = value.length > 1 ? value.replace(/\/+$/, "") : value;
+  if (ROUTE_TEMPLATES.has(normalized)) return normalized;
+  const candidateSegments = normalized.split("/");
+  for (const template of ROUTE_TEMPLATES) {
+    const templateSegments = template.split("/");
+    if (candidateSegments.length !== templateSegments.length) continue;
+    if (templateSegments.every(
+      (part, index) => part.startsWith(":") ? validRouteSegment(candidateSegments[index]) : part === candidateSegments[index]
+    )) {
+      return template;
+    }
+  }
+  return void 0;
+}
+function validRouteSegment(segment) {
+  return segment.length > 0 && segment.length <= 128 && !/[/?#@]/.test(segment);
+}
+function isDnsName(value) {
+  return value.length <= 253 && value.split(".").every((label) => SLUG_RE.test(label));
+}
+function isEpochMs(value) {
+  return isNonnegativeSafeInteger(value);
+}
+function isNonnegativeSafeInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null || typeof value === "function";
+}
+function ownValue(input, key) {
+  const descriptor = Object.getOwnPropertyDescriptor(input, key);
+  return descriptor && "value" in descriptor ? descriptor.value : void 0;
+}
+function ownDataEntries(input, limit) {
+  const entries = [];
+  for (const key of Reflect.ownKeys(input)) {
+    if (typeof key !== "string") continue;
+    const descriptor = Object.getOwnPropertyDescriptor(input, key);
+    if (!descriptor || !("value" in descriptor)) continue;
+    entries.push([key, descriptor.value]);
+    if (entries.length >= limit) break;
+  }
+  return entries;
+}
+
+// src/observability/diagnostic-console.ts
+var diagnosticConsole = {
+  debug: (...values) => emit("debug", values),
+  info: (...values) => emit("info", values),
+  warn: (...values) => emit("warn", values),
+  error: (...values) => emit("error", values),
+  log: (...values) => emit("log", values)
+};
+function emitDiagnostic(level, event, fields, dataset) {
+  writeDiagnostic(level, event, fields, dataset);
+}
+function writeDiagnostic(sinkLevel, event, fields, dataset, severityOverride) {
+  try {
+    const defaultSeverity = sinkLevel === "debug" || sinkLevel === "log" ? "info" : sinkLevel;
+    const severity = severityOverride === "info" || severityOverride === "warn" || severityOverride === "error" ? severityOverride : defaultSeverity;
+    const record = {
+      event: projectEventName(event),
+      level: severity,
+      ...projectDiagnosticFields(fields, dataset)
+    };
+    const sink = sinkLevel === "log" ? console.log : console[sinkLevel];
+    sink(JSON.stringify(record));
+  } catch {
+  }
+}
+function emit(level, values) {
+  const parsed = values.length === 1 ? parseStructuredValue(values[0]) : void 0;
+  if (parsed) {
+    const event = ownValue2(parsed, "event");
+    const legacyEvent = ownValue2(parsed, "level");
+    const dataset = ownValue2(parsed, "dataset");
+    writeDiagnostic(
+      level,
+      event ?? legacyEvent,
+      parsed,
+      typeof dataset === "string" ? dataset : void 0,
+      legacyEvent
+    );
+    return;
+  }
+  emitDiagnostic(level, "diagnostic.message");
+}
+function parseStructuredValue(value) {
+  if (typeof value === "object" && value !== null) return value;
+  if (typeof value !== "string" || value.length > 64 * 1024 || !value.startsWith("{"))
+    return void 0;
+  try {
+    const parsed = JSON.parse(value);
+    return typeof parsed === "object" && parsed !== null ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function ownValue2(input, key) {
+  try {
+    const descriptor = Object.getOwnPropertyDescriptor(input, key);
+    return descriptor && "value" in descriptor ? descriptor.value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+export {
+  DIAGNOSTIC_CATALOGUE_VERSION,
+  createDiagnosticCapabilityAuthority,
+  bindDiagnosticCapabilityAuthority,
+  extendDiagnosticIdentityAuthority,
+  bindDiagnosticIdentityAuthority,
+  projectSpanRow,
+  projectDiagnosticFields,
+  projectEventName,
+  diagnosticConsole,
+  emitDiagnostic
+};