@volter/twin-sentry 0.1.37 → 1.0.1

package/dist/spec/sources.json

@@ -0,0 +1,76 @@
+{
+  "https://raw.githubusercontent.com/getsentry/sentry/2efdd4760a75a3d395e3534b7f66a7fbb0c3f22e/src/sentry/api/serializers/models/project_key.py": {
+    "status": 200,
+    "checked": "2026-10-03",
+    "quotes": {
+      "ProjectKeySerializerResponse": true
+    }
+  },
+  "https://raw.githubusercontent.com/getsentry/sentry/2efdd4760a75a3d395e3534b7f66a7fbb0c3f22e/src/sentry/features/permanent.py": {
+    "status": 200,
+    "checked": "2026-10-03",
+    "quotes": {
+      "organizations:advanced-search": true,
+      "organizations:change-alerts": true,
+      "organizations:crash-rate-alerts": true,
+      "organizations:custom-symbol-sources": true,
+      "organizations:data-forwarding": true,
+      "organizations:discover-basic": true,
+      "organizations:discover-query": true,
+      "organizations:event-attachments": true,
+      "organizations:integrations-alert-rule": true,
+      "organizations:integrations-chat-unfurl": true,
+      "organizations:integrations-codeowners": true,
+      "organizations:integrations-enterprise-alert-rule": true,
+      "organizations:integrations-enterprise-incident-management": true,
+      "organizations:integrations-event-hooks": true,
+      "organizations:integrations-incident-management": true,
+      "organizations:integrations-issue-basic": true,
+      "organizations:integrations-issue-sync": true,
+      "organizations:integrations-scm-multi-org": true,
+      "organizations:integrations-stacktrace-link": true,
+      "organizations:integrations-ticket-rules": true,
+      "organizations:integrations-vercel": true,
+      "organizations:performance-view": true,
+      "organizations:relay": true,
+      "organizations:sso-basic": true,
+      "organizations:sso-saml2": true,
+      "organizations:team-insights": true,
+      "organizations:team-roles": true,
+      "organizations:uptime": true
+    }
+  },
+  "https://raw.githubusercontent.com/getsentry/sentry/2efdd4760a75a3d395e3534b7f66a7fbb0c3f22e/src/sentry/features/temporary.py": {
+    "status": 200,
+    "checked": "2026-10-03",
+    "quotes": {
+      "organizations:dashboards-basic": true,
+      "organizations:dashboards-edit": true,
+      "organizations:insight-modules": true,
+      "organizations:invite-members": true,
+      "organizations:sentry-app-schema-form-migration": true,
+      "organizations:session-replay-ui": true
+    }
+  },
+  "https://raw.githubusercontent.com/getsentry/sentry/2efdd4760a75a3d395e3534b7f66a7fbb0c3f22e/src/sentry/models/projectkey.py": {
+    "status": 200,
+    "checked": "2026-10-03",
+    "quotes": {
+      "secret_key = ProjectKey.generate_api_key()": true
+    }
+  },
+  "https://raw.githubusercontent.com/getsentry/sentry/2efdd4760a75a3d395e3534b7f66a7fbb0c3f22e/src/sentry/projectoptions/defaults.py": {
+    "status": 200,
+    "checked": "2026-10-03",
+    "quotes": {
+      "sentry:default_loader_version": true
+    }
+  },
+  "https://raw.githubusercontent.com/getsentry/sentry/2efdd4760a75a3d395e3534b7f66a7fbb0c3f22e/src/sentry/utils/numbers.py": {
+    "status": 200,
+    "checked": "2026-10-03",
+    "quotes": {
+      "0123456789ABCDEFGHJKMNPQRSTVWXYZ": true
+    }
+  }
+}

package/dist/src/cli.js

@@ -1,36 +1,21 @@
 #!/usr/bin/env node
-import { keepProcessAlive } from '@volter/world-core/lifecycle';
-// world-sentry CLI: serve the Sentry API twin (ingestion + Web API), the dashboard mirror
-// UI, or run conformance. (Conformance lives in dev-tooling; cli.ts must not import it, so
-// it's loaded lazily only when the `conformance` command is invoked.)
+// world-sentry: serve the sentry twin.
 import { hasFlag, optionValue } from '@volter/world-core/args';
-import { createSentryTwinServer } from "./sentry-server.js";
-import { createSentryMirrorServer } from "./sentry-mirror-ui.js";
-import { defaultDsn } from "./sentry-ingest.js";
+import { keepProcessAlive } from '@volter/world-core/lifecycle';
+import { createSentryTwinServer } from "./server.js";
 const [cmd, ...rest] = process.argv.slice(2);
 const port = Number(optionValue(rest, '--port', '0')) || undefined;
 const root = optionValue(rest, '--root') || undefined;
-const readOnly = hasFlag(rest, '--read-only'); // a twin accepts writes/events unless read-only
-if (cmd === 'serve') {
-    const s = await createSentryTwinServer({ readOnly, ...(root ? { root } : {}), ...(port ? { port } : {}) });
-    const origin = `http://127.0.0.1:${s.port}`;
-    process.stdout.write(`sentry twin (ingest + Web API)${readOnly ? ' [read-only]' : ''} at ${origin}\n`);
-    process.stdout.write(`  point @sentry/node at DSN: ${defaultDsn(origin)}\n`);
+const readOnly = hasFlag(rest, '--read-only');
+// the selected twin's private Postgres, which the runtime binds a pack declaring managedDatabase to
+const database = optionValue(rest, '--database') || undefined;
+// the World's scenario file, for a model vendor's turns
+const scenarioPath = optionValue(rest, '--scenario') || undefined;
+if (cmd === 'serve' || cmd === undefined) {
+    const s = await createSentryTwinServer({ readOnly, ...(root ? { root } : {}), ...(port ? { port } : {}), ...(database ? { database } : {}), ...(scenarioPath ? { scenarioPath } : {}) });
+    process.stdout.write(`sentry twin${readOnly ? ' [read-only]' : ''} at http://127.0.0.1:${s.port}\n`);
     await keepProcessAlive();
 }
-else if (cmd === 'mirror') {
-    const s = await createSentryMirrorServer({ ...(root ? { root } : {}), ...(port ? { port } : {}) });
-    process.stdout.write(`sentry mirror UI (dashboard) at http://127.0.0.1:${s.port}\n`);
-    await keepProcessAlive();
-}
-else if (cmd === 'conformance') {
-    // dev-only: dynamic import so the conformance module never enters the runtime entrypoints.
-    const { checkSentryConformance } = await import("./sentry-conformance.js");
-    const report = await checkSentryConformance({ ...(root ? { root } : {}) });
-    process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
-    if (!report.ok)
-        process.exitCode = 1;
-}
 else {
-    process.stdout.write('Usage: world-sentry serve|mirror|conformance [--port N] [--root DIR] [--read-only]\n');
+    process.stdout.write('Usage: world-sentry serve [--port N] [--root DIR] [--read-only] [--database URL] [--scenario FILE]\n');
 }

package/dist/src/fetch.d.ts

@@ -0,0 +1,2 @@
+import { type DerivedFetch, type PackFetchOptions } from '@volter/world-core';
+export declare function createSentryFetch(options?: PackFetchOptions): DerivedFetch;

package/dist/src/fetch.js

@@ -0,0 +1,9 @@
+// GENERATED by scripts/create-pack.ts (--init, --index): a fixed file. The kernel serves the vendor's discovery door and
+// sends each request to the lane its manifest's routes name (architecture, "Other wires: lanes").
+import { createVendorFetch } from '@volter/world-core';
+import { manifest } from "./manifest.js";
+import { createApiLaneFetch, manifest as api_manifest } from "../api/src/index.js";
+import { createIngestLaneFetch, manifest as ingest_manifest } from "../ingest/src/index.js";
+export function createSentryFetch(options = {}) {
+    return createVendorFetch(manifest, { "api": { fetch: createApiLaneFetch(options), manifest: api_manifest }, "ingest": { fetch: createIngestLaneFetch(options), manifest: ingest_manifest } });
+}

package/dist/src/index.d.ts

@@ -1,15 +1,5 @@
-export { handleSentryTwinRequest } from './sentry-twin.js';
-export type { SentryRequest, SentryResponse } from './sentry-twin.js';
-export { createSentryTwinFetch, createSentryTwinServer, type SentryTwinFetchOptions } from './sentry-server.js';
-export { defaultDsn, DEFAULT_ORG, DEFAULT_PROJECT, DEFAULT_PROJECT_ID, DEFAULT_PUBLIC_KEY, ensureDefaultProject, envelopeEvents, eventCulprit, eventTitle, fingerprintText, hashFingerprint, ingestEvent, issueIdFor, normalizeFingerprintText, parseEnvelope, publicKeyFromAuthHeader, publicKeyFromDsn, resolveProjectKey, resolvePublicKey, } from './sentry-ingest.js';
-export type { IngestOutcome, ParsedEnvelope, ResolvedKey, SentryEventPayload, SentryExceptionValue, SentryFrame } from './sentry-ingest.js';
-export { computeSentrySignature, constructSentryWebhook, emitIssueAlert, listAlertRules, registerAlertRule, SentrySignatureVerificationError, verifySentrySignature, } from './sentry-events.js';
-export type { AlertTrigger, SentryWebhook, SentryWebhookAction, SentryWebhookDelivery } from './sentry-events.js';
-export { liveSentryExecute, mapIssue, mapProject, mapRelease, pullSentryIssues, pullSentryProjects, pullSentryReleases, pushSentryAction, sentryRequestForAction, syncSentryFromReal, } from './sentry-connector.js';
-export type { SentryExecute, LiveSentryOptions } from './sentry-connector.js';
-export { SENTRY_BUDGET_CEILING, SENTRY_BUDGET_MAX_RETRY_AFTER_S, SENTRY_BUDGET_WINDOW_MS, SENTRY_CALL_WEIGHTS, SENTRY_RATE_BUDGET, SentryBudget, SentryBudgetError, sentryBudgetPath, sentryCallWeight, } from './sentry-budget.js';
-export type { SentryBudgetErrorKind, SentryBudgetOptions, SentryBudgetReservation, SentryBudgetSnapshot } from './sentry-budget.js';
-export { buildSentryMirrorClient, createSentryMirrorServer, eventTags, formatCount, latestStacktrace, levelTone, sentryMirrorHtml, statusTone, timeAgo, } from './sentry-mirror-ui.js';
-export type { IssueRow, StackFrame } from './sentry-mirror-ui.js';
-import type { TwinPack } from '@volter/world-core';
-export declare const pack: TwinPack;
+import { manifest } from './manifest.js';
+export { createSentryFetch } from './fetch.js';
+export { createSentryTwinServer } from './server.js';
+export { manifest };
+export declare const pack: import("@volter/world-core").PackDescriptor;

package/dist/src/index.js

@@ -1,75 +1,13 @@
-// @volter/twin-sentry — the Sentry twin (one vendor, one package), built on the shared
-// @volter/world-core kernel. Two API families over local event-sourced state: INGESTION (the
-// `@sentry/node` store/envelope endpoints → grouped issues) and the WEB API (/api/0/...:
-// issues, events, projects, keys/DSN, releases, deploys, orgs, teams, alert rules), plus
-// signed alert webhooks and a React dashboard mirror. No real Sentry is ever contacted.
-// (Conformance tooling lives in @volter/world-tooling, a dev dependency — not shipped here.)
-export { handleSentryTwinRequest } from "./sentry-twin.js";
-export { createSentryTwinFetch, createSentryTwinServer } from "./sentry-server.js";
-export { defaultDsn, DEFAULT_ORG, DEFAULT_PROJECT, DEFAULT_PROJECT_ID, DEFAULT_PUBLIC_KEY, ensureDefaultProject, envelopeEvents, eventCulprit, eventTitle, fingerprintText, hashFingerprint, ingestEvent, issueIdFor, normalizeFingerprintText, parseEnvelope, publicKeyFromAuthHeader, publicKeyFromDsn, resolveProjectKey, resolvePublicKey, } from "./sentry-ingest.js";
-export { computeSentrySignature, constructSentryWebhook, emitIssueAlert, listAlertRules, registerAlertRule, SentrySignatureVerificationError, verifySentrySignature, } from "./sentry-events.js";
-export { liveSentryExecute, mapIssue, mapProject, mapRelease, pullSentryIssues, pullSentryProjects, pullSentryReleases, pushSentryAction, sentryRequestForAction, syncSentryFromReal, } from "./sentry-connector.js";
-// The client-side rate budget — the fail-closed backstop `liveSentryExecute` routes every live
-// request through. The MECHANISM is the kernel's shared, vendor-agnostic `RateBudget`; what lives
-// here is Sentry's DECLARATION (window/ceiling/per-endpoint weights) plus the vendor-bound
-// bindings. Exported so an operator can inspect spend (`snapshot`) and so a caller can catch
-// `SentryBudgetError` by type; there is deliberately no export that disables the guard.
-export { SENTRY_BUDGET_CEILING, SENTRY_BUDGET_MAX_RETRY_AFTER_S, SENTRY_BUDGET_WINDOW_MS, SENTRY_CALL_WEIGHTS, SENTRY_RATE_BUDGET, SentryBudget, SentryBudgetError, sentryBudgetPath, sentryCallWeight, } from "./sentry-budget.js";
-export { buildSentryMirrorClient, createSentryMirrorServer, eventTags, formatCount, latestStacktrace, levelTone, sentryMirrorHtml, statusTone, timeAgo, } from "./sentry-mirror-ui.js";
-import { SENTRY_RATE_BUDGET as RATE_BUDGET } from "./sentry-budget.js";
-import { performSentryAction, syncSentryFromRemote } from "./sentry-connector.js";
-export const pack = {
-    // PROTOCOL 2 (docs/contributing/architecture.md#protocol-2-the-pack-is-a-plugin): the pack is a plugin — its wire, its tree, and its half of the real
-    // state system. Moved 2026-09-08. TRIAGE is what crosses to Sentry — an issue resolved, assigned, muted;
-    // everything else this twin holds is something Sentry told it.
-    protocol: '2',
-    refresh: { every: '2m', webhook: true, onDemand: { atMost: '30s' } },
-    stateSystem: { perform: performSentryAction, refresh: syncSentryFromRemote },
-    // the round trip: an organization, then a project in it — the two things a Sentry account is made of
-    // the round trip: an organization, a team in it, then a project under that team — Sentry's own create
-    // path for a project is /teams/:org/:team/projects/, not the organization
-    roundTrip: [
-        { method: 'POST', path: '/api/0/organizations/', body: { name: 'Round Trip', slug: 'round-trip' }, headers: { authorization: 'Bearer round-trip' } },
-        { method: 'POST', path: '/api/0/organizations/round-trip/teams/', body: { name: 'Round Trip', slug: 'round-trip' }, headers: { authorization: 'Bearer round-trip' } },
-        { method: 'POST', path: '/api/0/teams/round-trip/round-trip/projects/', body: { name: 'Round Trip', platform: 'node' }, headers: { authorization: 'Bearer round-trip' } },
-        // a project's slug is unique inside its org, so the create above rightly refuses a second one on a
-        // branch that already has it — the vendor's own truth. The last write is therefore the one a world
-        // repeats freely: triage on the project's own issue stream.
-        { method: 'PUT', path: '/api/0/projects/round-trip/round-trip/', body: { platform: 'node', digestsMinDelay: 60 }, headers: { authorization: 'Bearer round-trip' } },
-    ],
-    parityOrigin: 'http://twin',
-    vendor: 'sentry',
-    // The SAME object sentry-budget.ts declares at module load — one source of truth, so registering
-    // the pack and importing the connector can never arm two different ceilings.
-    rateBudget: RATE_BUDGET,
-    transport: 'rest',
-    archetype: 'crud',
-    bin: 'world-sentry',
-    resources: ['organization', 'team', 'project', 'project_key', 'issue', 'event', 'event_attachment', 'session', 'project_ownership', 'codeowners', 'project_filter', 'release', 'release_file', 'deploy', 'alert_rule', 'metric_alert', 'org_integration'],
-    specSource: 'Sentry API reference (https://docs.sentry.io/api/) — ingest store/envelope + Web API /api/0/',
-    description: 'Sentry REST twin — SDK ingestion → grouped issues, Web API, signed alert webhooks, dashboard mirror.',
-    // Adoption + interception, moved off the central maps unchanged (descriptor-first back-migration, adding-a-twin.md §3,
-    // 2026-08-31). The four canonical clients plus the further first-party @sentry
-    // framework SDKs of the same ingest surface — battery-observed: sentry was the single
-    // most-missed vendor, 13 repos, largely via these — and the whole `@sentry/` scope so a
-    // satellite package like `@sentry/cli` still detects.
-    adoption: {
-        // Sentry's official Python SDK - the one distribution behind every Python integration.
-        pypi: ['sentry-sdk'],
-        sdks: [
-            '@sentry/node', '@sentry/browser', '@sentry/react', '@sentry/nextjs',
-            '@sentry/vue', '@sentry/sveltekit', '@sentry/astro', '@sentry/remix',
-            '@sentry/electron', '@sentry/react-native',
-        ],
-        scopes: ['@sentry/'],
-        // 'APPSMITHSENTRY' — appsmith names its DSN APPSMITH_SENTRY_DSN, an app-prefixed Sentry
-        // credential for the same ingest surface (ladder classification 2026-09-02).
-        envStems: ['SENTRY', 'APPSMITHSENTRY'],
-    },
-    // sentry.io (the web/REST API) plus the per-organization DSN ingest hosts
-    // (`o<org-id>.ingest.sentry.io`), which need the suffix form.
-    hosts: [{ host: 'sentry.io' }, { suffix: '.ingest.sentry.io' }],
-    // The @sentry/node SDK POSTs to <dsn-host>/api/:projectId/envelope/; the dashboard hits
-    // /api/0/. The dev proxy forwards both prefixes to the twin and strips the sentry.io host.
-    browserRouting: { apiPathPrefix: '/api/', loaderHost: 'https://sentry.io' },
-};
+// @volter/twin-sentry — the sentry twin (Protocol 3). A fixed file (create-pack): the descriptor is the manifest's, and the
+// kernel derives the vendor-backed half from the generated surface, unless the manifest declares none (vendorBacked.none;
+// architecture, "The real-system adapters").
+import { packOf, registerPack } from '@volter/world-core';
+import { manifest } from "./manifest.js";
+import { manifest as apiManifest } from "../api/src/manifest.js";
+import apiSurface from '../api/src/generated/surface.gen.json' with { type: 'json' };
+import { manifest as ingestManifest } from "../ingest/src/manifest.js";
+import ingestSurface from '../ingest/src/generated/surface.gen.json' with { type: 'json' };
+export { createSentryFetch } from "./fetch.js";
+export { createSentryTwinServer } from "./server.js";
+export { manifest };
+export const pack = registerPack(packOf(manifest, { "api": { manifest: apiManifest, surface: apiSurface }, "ingest": { manifest: ingestManifest, surface: ingestSurface } }));

package/dist/src/manifest.d.ts

@@ -0,0 +1,2 @@
+import type { VendorManifest } from '@volter/world-core';
+export declare const manifest: VendorManifest;

package/dist/src/manifest.js

@@ -0,0 +1,35 @@
+export const manifest = {
+    vendor: 'sentry',
+    discovery: {
+        twinOf: 'Sentry: the envelopes its SDKs send (errors, transactions, sessions, replays, profiles, cron check-ins, feedback, logs, metrics), and its web API for events, issues, releases and source maps',
+        stores: 'organizations, projects and client keys, auth tokens (by their SHA-256), events and issues, and every other envelope item; releases and artifact bundles',
+    },
+    lanes: {
+        routes: [
+            { lane: 'ingest', host: '(^|\\.)ingest(\\.[a-z]+)?\\.sentry\\.io$' },
+            { lane: 'api', host: '^([a-z]+\\.)?sentry\\.io$' },
+        ],
+        default: 'api',
+    },
+    descriptor: {
+        protocol: '3',
+        transport: 'rest',
+        archetype: 'crud',
+        bin: 'world-sentry',
+        resources: ['organization', 'project', 'project_key', 'event', 'issue', 'release', 'monitor', 'check_in'],
+        specSource: "Sentry's OpenAPI document (api/spec, sentry-api-schema 98ec014, patched with evidence) and its SDK developer documentation's envelope endpoint (ingest/spec)",
+        description: 'Sentry twin — the envelope endpoint every SDK sends to (events grouped into issues, transactions, sessions, replays, profiles, check-ins, feedback, logs, metrics), and release and source-map APIs used by Cal.com and Rallly, account project/key setup, and core vendor-backed reads.',
+        adoption: { sdks: ['@sentry/astro', '@sentry/browser', '@sentry/electron', '@sentry/nextjs', '@sentry/node', '@sentry/nestjs', '@sentry/react', '@sentry/react-native', '@sentry/remix', '@sentry/sveltekit', '@sentry/vue', '@sentry/cli'], pypi: ['sentry-sdk'], envStems: ['APPSMITHSENTRY', 'SENTRY'] },
+        hosts: [{ host: 'sentry.io' }, { host: 'us.sentry.io' }, { host: 'de.sentry.io' }, { suffix: '.ingest.sentry.io' }, { suffix: '.ingest.us.sentry.io' }, { suffix: '.ingest.de.sentry.io' }],
+        endpointEnvNone: "an SDK sends to its DSN's host and sentry-cli to SENTRY_URL (sentry.io by default); the DSN the World issues names the World's ingest host, claimed by the host rules",
+        // Bootstrap: account sign-up, first credential and the project/key named by this env, stable at every boot.
+        credentialDoor: { account: { field: 'account', tenancy: 'organization', source: 'https://docs.sentry.io/api/permissions/' },
+            deployment: { field: 'deployment', object: 'project and client key', source: 'https://docs.sentry.io/product/sentry-basics/environments/', organizationOutputs: ['SENTRY_ORG', 'SENTRY_ORGANIZATION'] },
+            path: '/_twin/app-credentials', body: {},
+            fill: {
+                SENTRY_DSN: 'dsn', NEXT_PUBLIC_SENTRY_DSN: 'dsn', NEXT_PUBLIC_SENTRY_DSN_CLIENT: 'dsn', SENTRY_FRONT_DSN: 'dsn', SENTRY_DSN_API: 'dsn', VITE_SENTRY_DSN: 'dsn', EXPO_PUBLIC_SENTRY_DSN: 'dsn',
+                SENTRY_AUTH_TOKEN: 'auth_token', SENTRY_ORG: 'org', SENTRY_ORGANIZATION: 'org', SENTRY_PROJECT: 'project',
+            },
+        },
+    },
+};

package/dist/src/semantics/shared.d.ts

@@ -0,0 +1,88 @@
+import type { HandlerContext } from '@volter/world-core';
+type Reader = Pick<HandlerContext, 'row' | 'rowsRaw' | 'own'>;
+export type Row = Record<string, unknown>;
+/** An organization, made the first time (sentry.io's sign-up names it). */
+export declare function makeOrg(ctx: HandlerContext, slug: string, name: string, owner: string): Promise<Row | Response>;
+/** A project of an organization with its default client key (the project's creation makes one). */
+export declare function makeProject(ctx: HandlerContext, org: Row, slug: string, platform: string | null): Promise<Row | Response>;
+export declare function makeClientKey(ctx: HandlerContext, org: Row, project: Row): Promise<Row>;
+/** An organization auth token, made on Settings > Auth Tokens: its value shown once. Its scopes are the organization
+ *  token's fixed set ("org:ci": releases and source maps, and reading the organization). */
+export declare function makeOrgToken(ctx: HandlerContext, org: Row, name: string, scopes?: string[]): Promise<string>;
+/** A live native auth token, reconstructed only while its stored digest still matches. */
+export declare function readToken(ctx: HandlerContext, org: Row, row: Row): Promise<string | undefined>;
+/** A personal token (User Settings > Personal Tokens): `sntryu_` and 64 hexadecimal digits, with the scopes chosen when it
+ *  is made, acting on the organizations its user belongs to (here, the one named). */
+export declare function makePersonalToken(ctx: HandlerContext, org: Row, name: string, scopes: string[]): Promise<string>;
+/** The token a request's `Authorization: Bearer` names, if the World issued it and it is not revoked. */
+export declare function bearerToken(ctx: Pick<HandlerContext, 'row' | 'crypto' | 'call'>): Row | undefined;
+/** Whether a token's scopes grant one: the scope itself, one its `org:ci` implies, or the same resource's write or
+ *  admin (a `:write` scope reads, an `:admin` one writes and reads). */
+export declare function grants(token: Row, scope: string): boolean;
+/** An event's time: its `timestamp` (RFC 3339 or seconds since the epoch), else when it was received. */
+export declare function eventTime(payload: Row, received: string): string;
+/** An event's title, culprit, location and metadata, as Sentry derives them for its kind. Where the documentation stops:
+ *  Sentry's own derivation (its event types' `get_title` and `get_location`) is code, not a page; these follow its
+ *  answers' forms: `<Type>: <value>` for an error, the message for a message event, the transaction's name for one. */
+export declare function derive(payload: Row, type: string): {
+    title: string;
+    culprit: string;
+    location: string | null;
+    metadata: Row;
+};
+/** The hash an error groups by: its fingerprint when the SDK sends one of its own, else its exception's type and its
+ *  in-app frames (or its type and value, with no stack trace), else its message. Where the documentation stops: Sentry
+ *  groups by its grouping configuration (https://docs.sentry.io/concepts/data-management/event-grouping/), whose
+ *  algorithm is not reproduced; this keeps its rule's shape: the stack trace first, then the exception, then the message. */
+export declare function groupingHash(ctx: Pick<HandlerContext, 'crypto'>, payload: Row): string;
+/** An event's tags as the API lists them: the SDK's own, and the ones Sentry derives from the event. */
+export declare function tagsOf(payload: Row): Array<{
+    key: string;
+    value: string;
+}>;
+/** An error or message event kept, grouped into its issue (made, or counted again). */
+export declare function keepEvent(ctx: HandlerContext, project: Row, payload: Row, type: string): Promise<Row>;
+/** An event as a project's event list answers it (the spec's listProjectEvents item). */
+export declare function simpleEvent(e: Row): Row;
+/** An event in full (the spec's getProjectEvent): the simple fields, its entries (the exception with its stack
+ *  traces, the breadcrumbs, the request, the message), its contexts, SDK, release and neighbours. */
+export declare function fullEvent(ctx: Reader, raw: Row): Row;
+/** An issue as the API answers it (the spec's issue schema, its common fields). */
+export declare function issueView(ctx: Reader, raw: Row): Row;
+/** Stored vendor fields, including the API's own _meta; private association/payload fields stay in the tree. */
+export declare function wire(ctx: Reader, row: Row): Row;
+export declare const ORG = "organization";
+export declare const PROJECT = "project";
+export declare const CLIENT_KEY = "project_key";
+export declare const TOKEN = "_auth_token";
+/** An id in Sentry's form: a number, as a string. Where the documentation stops: how Sentry mints its ids is not
+ *  published; ctx.mint makes hash-derived decimal ids at the declared width, the same every run. */
+export declare const orgBySlug: (ctx: Reader, ref: string) => Row | undefined;
+export declare const projectOf: (ctx: Reader, org: Row, ref: string) => Row | undefined;
+export declare const projectById: (ctx: Reader, id: string) => Row | undefined;
+/** The host a DSN names for an organization. */
+export declare const ingestHost: (org: Row) => string;
+/** A project's DSN, from its client key. */
+export declare const dsnOf: (org: Row, project: Row, key: Row) => string;
+/** A project's active client key. */
+export declare const keyOf: (ctx: Reader, project: Row) => Row | undefined;
+/** The project a DSN's public key belongs to. */
+export declare const projectByKey: (ctx: Reader, publicKey: string) => Row | undefined;
+/** The World's next number in a sequence (a project's id, a nonce): issued from the tree over the lane's declared
+ *  `_seq_<what>` (ctx.issue), never a row count. */
+export declare const next: (ctx: Pick<HandlerContext, "issue">, what: string) => Promise<number>;
+export declare const EVENT = "event";
+export declare const ISSUE = "issue";
+/** One user an issue's events came from (its `userCount` counts them): bookkeeping the vendor serves only as the count. */
+export declare const ISSUE_USER = "_issue_user";
+export declare const SESSION = "_session";
+export declare const CLIENT_REPORT = "_client_report";
+export declare const ATTACHMENT = "_attachment";
+export declare const REPLAY = "_replay";
+export declare const PROFILE = "_profile";
+export declare const MONITOR = "monitor";
+export declare const CHECK_IN = "check_in";
+export declare const LOG = "_log";
+export declare const METRIC = "_metric";
+export declare const OTHER_ITEM = "_envelope_item";
+export {};