@chaos-overlords/bug-reports 0.1.0

package/dist/schema.d.ts

@@ -0,0 +1,278 @@
+/**
+ * One table, in a database of its own.
+ *
+ * Bug reports do not live beside matches. They arrive unauthenticated, they are kept for far longer
+ * than a match is, and the thing that makes them worth having — an attached journal of somebody
+ * else's game — is exactly the thing a live multiplayer database should never be holding. Keeping
+ * them in a separate D1 instance (a separate SQLite file when self-hosted) means the two cannot
+ * share a lock, a retention sweep, a migration lineage, or a blast radius: a report that arrives
+ * while a turn is sealing writes to a different database entirely, and a mistake in the intake path
+ * cannot reach a match.
+ *
+ * The journal itself is usually *not* here. `body` holds the base64 archive only when it is small
+ * and the deployment has nowhere better; otherwise `blob_key` names an object in R2 (or in a
+ * directory, self-hosted) and `body` stays null. Exactly one of the two is set — see
+ * `BugReportService`.
+ */
+export declare const bugReports: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "bug_reports";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: "bug_reports";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        receivedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "received_at";
+            tableName: "bug_reports";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        message: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "message";
+            tableName: "bug_reports";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        clientVersion: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "client_version";
+            tableName: "bug_reports";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        clientPlatform: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "client_platform";
+            tableName: "bug_reports";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        context: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "context";
+            tableName: "bug_reports";
+            dataType: "json";
+            columnType: "SQLiteTextJson";
+            data: unknown;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        stateCodec: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "state_codec";
+            tableName: "bug_reports";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        stateFormatVersion: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "state_format_version";
+            tableName: "bug_reports";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        stateUncompressedBytes: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "state_uncompressed_bytes";
+            tableName: "bug_reports";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        stateCompressedBytes: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "state_compressed_bytes";
+            tableName: "bug_reports";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        stateSha256: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "state_sha256";
+            tableName: "bug_reports";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        stateAnonymized: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "state_anonymized";
+            tableName: "bug_reports";
+            dataType: "boolean";
+            columnType: "SQLiteBoolean";
+            data: boolean;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        blobKey: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "blob_key";
+            tableName: "bug_reports";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        body: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "body";
+            tableName: "bug_reports";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+    };
+    dialect: "sqlite";
+}>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8BtB,CAAA"}

package/dist/schema.js

@@ -0,0 +1,44 @@
+import { index, integer, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+/**
+ * One table, in a database of its own.
+ *
+ * Bug reports do not live beside matches. They arrive unauthenticated, they are kept for far longer
+ * than a match is, and the thing that makes them worth having — an attached journal of somebody
+ * else's game — is exactly the thing a live multiplayer database should never be holding. Keeping
+ * them in a separate D1 instance (a separate SQLite file when self-hosted) means the two cannot
+ * share a lock, a retention sweep, a migration lineage, or a blast radius: a report that arrives
+ * while a turn is sealing writes to a different database entirely, and a mistake in the intake path
+ * cannot reach a match.
+ *
+ * The journal itself is usually *not* here. `body` holds the base64 archive only when it is small
+ * and the deployment has nowhere better; otherwise `blob_key` names an object in R2 (or in a
+ * directory, self-hosted) and `body` stays null. Exactly one of the two is set — see
+ * `BugReportService`.
+ */
+export const bugReports = sqliteTable('bug_reports', {
+    id: text('id').primaryKey(),
+    receivedAt: integer('received_at', { mode: 'timestamp_ms' }).notNull(),
+    /** What the player typed, verbatim. Never parsed, never interpolated anywhere. */
+    message: text('message').notNull(),
+    clientVersion: text('client_version').notNull(),
+    clientPlatform: text('client_platform').notNull(),
+    /** The triage fields (`bugReportContextSchema`), or null when the client sent none. */
+    context: text('context', { mode: 'json' }),
+    // --- The attached journal, when there is one. -------------------------------------------
+    /** Null when no journal came with the report. */
+    stateCodec: text('state_codec'),
+    stateFormatVersion: integer('state_format_version'),
+    stateUncompressedBytes: integer('state_uncompressed_bytes'),
+    stateCompressedBytes: integer('state_compressed_bytes'),
+    /** SHA-256 of the compressed archive, lowercase hex, as the client computed it. */
+    stateSha256: text('state_sha256'),
+    stateAnonymized: integer('state_anonymized', { mode: 'boolean' }),
+    /** Object key in the blob store, when the archive was written there. */
+    blobKey: text('blob_key'),
+    /** Base64 archive, only for a small one on a deployment with no blob store. */
+    body: text('body'),
+}, (table) => [
+    // Triage reads newest-first and nothing else does a range scan over this table.
+    index('bug_reports_received_idx').on(table.receivedAt),
+]);
+//# sourceMappingURL=schema.js.map

package/dist/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,yBAAyB,CAAA;AAE3E;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,WAAW,CACnC,aAAa,EACb;IACE,EAAE,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE;IAC3B,UAAU,EAAE,OAAO,CAAC,aAAa,EAAE,EAAE,IAAI,EAAE,cAAc,EAAE,CAAC,CAAC,OAAO,EAAE;IACtE,kFAAkF;IAClF,OAAO,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE;IAClC,aAAa,EAAE,IAAI,CAAC,gBAAgB,CAAC,CAAC,OAAO,EAAE;IAC/C,cAAc,EAAE,IAAI,CAAC,iBAAiB,CAAC,CAAC,OAAO,EAAE;IACjD,uFAAuF;IACvF,OAAO,EAAE,IAAI,CAAC,SAAS,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;IAE1C,2FAA2F;IAC3F,iDAAiD;IACjD,UAAU,EAAE,IAAI,CAAC,aAAa,CAAC;IAC/B,kBAAkB,EAAE,OAAO,CAAC,sBAAsB,CAAC;IACnD,sBAAsB,EAAE,OAAO,CAAC,0BAA0B,CAAC;IAC3D,oBAAoB,EAAE,OAAO,CAAC,wBAAwB,CAAC;IACvD,mFAAmF;IACnF,WAAW,EAAE,IAAI,CAAC,cAAc,CAAC;IACjC,eAAe,EAAE,OAAO,CAAC,kBAAkB,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC;IACjE,wEAAwE;IACxE,OAAO,EAAE,IAAI,CAAC,UAAU,CAAC;IACzB,+EAA+E;IAC/E,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC;CACnB,EACD,CAAC,KAAK,EAAE,EAAE,CAAC;IACT,gFAAgF;IAChF,KAAK,CAAC,0BAA0B,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,UAAU,CAAC;CACvD,CACF,CAAA"}

package/dist/service.d.ts

@@ -0,0 +1,50 @@
+import { type BugReportReceipt, type SubmitBugReportRequest } from '@chaos-overlords/contracts';
+import { type Clock, type Logger } from '@chaos-overlords/kernel';
+import type { BlobStore, BugReportRepository, StoredBugReport } from './ports';
+export interface BugReportServiceDeps {
+    repository: BugReportRepository;
+    clock: Clock;
+    logger: Logger;
+    /**
+     * Where archives go. Omit it and a deployment keeps small ones in its database row and turns
+     * large ones away — see {@link BugReportService.submit}.
+     */
+    blobs?: BlobStore;
+}
+export interface BugReportService {
+    submit(request: SubmitBugReportRequest): Promise<BugReportReceipt>;
+    /** Triage reads. Not reachable over HTTP; an operator calls them from a script or a console. */
+    get(id: string): Promise<StoredBugReport | null>;
+    list(limit: number): Promise<StoredBugReport[]>;
+    /** The archive itself, wherever it was kept. */
+    archive(id: string): Promise<Uint8Array | null>;
+}
+/**
+ * Intake for one bug report.
+ *
+ * The interesting decision is where the attached journal goes, and it is decided by one thing:
+ * whether the deployment has a blob store.
+ *
+ * - **With one** (R2 on Cloudflare, a directory self-hosted) every archive goes to it, whatever its
+ *   size, and the row keeps only the key and the metadata. This is the configuration a public
+ *   server runs: a full-match journal is hundreds of kilobytes to a few megabytes compressed, D1
+ *   refuses a row over 2 MB outright, and even the ones that fit would make every triage query drag
+ *   megabytes of base64 through the query path to answer a question about a timestamp.
+ * - **Without one** an archive up to {@link BUG_REPORT_LIMITS.inlineStateBytes} is kept in the row,
+ *   which is what makes a `pnpm --filter node-server start` with no configuration work end to end.
+ *   A larger one is dropped and the report is still accepted, because the player's description is
+ *   worth having even when the journal is not storable — the receipt says `omitted` so they know.
+ *
+ * Nothing here decompresses or parses an archive. It is opaque bytes with a digest, and keeping it
+ * that way is what makes accepting one from an unauthenticated stranger safe.
+ */
+export declare function createBugReportService(deps: BugReportServiceDeps): BugReportService;
+/**
+ * Base64 to bytes.
+ *
+ * `atob` rather than `Buffer`, which the Workers runtime only has under `nodejs_compat`; the
+ * contract has already held the string to the standard alphabet and a length that is a multiple of
+ * four, so this cannot be handed something it has to guess about.
+ */
+export declare function decodeBase64(value: string): Uint8Array;
+//# sourceMappingURL=service.d.ts.map

package/dist/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,gBAAgB,EACrB,KAAK,sBAAsB,EAC5B,MAAM,4BAA4B,CAAA;AACnC,OAAO,EAAE,KAAK,KAAK,EAAE,KAAK,MAAM,EAA8B,MAAM,yBAAyB,CAAA;AAE7F,OAAO,KAAK,EAAE,SAAS,EAAE,mBAAmB,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAE9E,MAAM,WAAW,oBAAoB;IACnC,UAAU,EAAE,mBAAmB,CAAA;IAC/B,KAAK,EAAE,KAAK,CAAA;IACZ,MAAM,EAAE,MAAM,CAAA;IACd;;;OAGG;IACH,KAAK,CAAC,EAAE,SAAS,CAAA;CAClB;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAA;IAClE,gGAAgG;IAChG,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAAA;IAChD,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC,CAAA;IAC/C,gDAAgD;IAChD,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAAA;CAChD;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,oBAAoB,GAAG,gBAAgB,CAqHnF;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,CAKtD"}

package/dist/service.js

@@ -0,0 +1,140 @@
+import { BUG_REPORT_LIMITS, } from '@chaos-overlords/contracts';
+import { sha256Hex, ValidationError } from '@chaos-overlords/kernel';
+import { ARCHIVE_CONTENT_TYPE, archiveKey } from './blobs';
+/**
+ * Intake for one bug report.
+ *
+ * The interesting decision is where the attached journal goes, and it is decided by one thing:
+ * whether the deployment has a blob store.
+ *
+ * - **With one** (R2 on Cloudflare, a directory self-hosted) every archive goes to it, whatever its
+ *   size, and the row keeps only the key and the metadata. This is the configuration a public
+ *   server runs: a full-match journal is hundreds of kilobytes to a few megabytes compressed, D1
+ *   refuses a row over 2 MB outright, and even the ones that fit would make every triage query drag
+ *   megabytes of base64 through the query path to answer a question about a timestamp.
+ * - **Without one** an archive up to {@link BUG_REPORT_LIMITS.inlineStateBytes} is kept in the row,
+ *   which is what makes a `pnpm --filter node-server start` with no configuration work end to end.
+ *   A larger one is dropped and the report is still accepted, because the player's description is
+ *   worth having even when the journal is not storable — the receipt says `omitted` so they know.
+ *
+ * Nothing here decompresses or parses an archive. It is opaque bytes with a digest, and keeping it
+ * that way is what makes accepting one from an unauthenticated stranger safe.
+ */
+export function createBugReportService(deps) {
+    const { repository, clock, logger, blobs } = deps;
+    return {
+        async submit(request) {
+            const receivedAt = clock.now();
+            const id = crypto.randomUUID();
+            const stored = request.state
+                ? await placeArchive(id, receivedAt, request.state)
+                : { state: null, outcome: 'not_sent' };
+            const report = {
+                id,
+                receivedAt,
+                message: request.message,
+                clientVersion: request.client.version,
+                clientPlatform: request.client.platform,
+                context: request.context ?? null,
+                state: stored.state,
+            };
+            try {
+                await repository.insert(report);
+            }
+            catch (error) {
+                // The archive was written first, so a failed insert would otherwise leave an object nobody
+                // can ever find a key for. Best effort: if this fails too the object is merely orphaned,
+                // which is a cleanup job rather than a lost report.
+                if (stored.state?.blobKey)
+                    await forget(stored.state.blobKey);
+                throw error;
+            }
+            logger.info('bug report received', {
+                id,
+                bytes: stored.state?.compressedBytes ?? 0,
+                state: stored.outcome,
+            });
+            return {
+                id,
+                receivedAt: receivedAt.toISOString(),
+                stateStored: stored.outcome,
+            };
+        },
+        get: (id) => repository.get(id),
+        list: (limit) => repository.list(limit),
+        async archive(id) {
+            const report = await repository.get(id);
+            const state = report?.state;
+            if (!state)
+                return null;
+            if (state.blobKey)
+                return (await blobs?.get(state.blobKey)) ?? null;
+            return state.body === null ? null : decodeBase64(state.body);
+        },
+    };
+    /**
+     * Decodes, verifies and files the archive.
+     *
+     * The digest is checked before anything is written. The client computes it over the compressed
+     * bytes it sent, so a mismatch is a truncated or mangled upload — and an archive that does not
+     * hash to what its own report claims is worse than no archive, because somebody would spend an
+     * afternoon replaying it before finding out.
+     */
+    async function placeArchive(id, receivedAt, state) {
+        const bytes = decodeBase64(state.body);
+        const digest = await sha256Hex(bytes);
+        if (digest !== state.sha256) {
+            throw new ValidationError('The attached state does not match its declared digest', {
+                reason: 'state_digest_mismatch',
+            });
+        }
+        const common = {
+            codec: state.codec,
+            replayFormatVersion: state.replayFormatVersion,
+            uncompressedBytes: state.uncompressedBytes,
+            compressedBytes: bytes.byteLength,
+            sha256: digest,
+            anonymized: state.anonymized,
+        };
+        if (blobs) {
+            const key = archiveKey(id, receivedAt);
+            await blobs.put(key, bytes, ARCHIVE_CONTENT_TYPE);
+            return { state: { ...common, blobKey: key, body: null }, outcome: 'stored' };
+        }
+        if (bytes.byteLength > BUG_REPORT_LIMITS.inlineStateBytes) {
+            logger.warn('bug report state dropped: no blob store and the archive is too large for a row', {
+                id,
+                bytes: bytes.byteLength,
+                limit: BUG_REPORT_LIMITS.inlineStateBytes,
+            });
+            return { state: null, outcome: 'omitted' };
+        }
+        return { state: { ...common, blobKey: null, body: state.body }, outcome: 'stored' };
+    }
+    async function forget(key) {
+        try {
+            await blobs?.delete(key);
+        }
+        catch (error) {
+            logger.warn('could not remove the archive of a report that failed to store', {
+                key,
+                error: String(error),
+            });
+        }
+    }
+}
+/**
+ * Base64 to bytes.
+ *
+ * `atob` rather than `Buffer`, which the Workers runtime only has under `nodejs_compat`; the
+ * contract has already held the string to the standard alphabet and a length that is a multiple of
+ * four, so this cannot be handed something it has to guess about.
+ */
+export function decodeBase64(value) {
+    const binary = atob(value);
+    const bytes = new Uint8Array(binary.length);
+    for (let index = 0; index < binary.length; index++)
+        bytes[index] = binary.charCodeAt(index);
+    return bytes;
+}
+//# sourceMappingURL=service.js.map

package/dist/service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.js","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"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"}

package/migrations/sqlite/0000_fine_squadron_supreme.sql

@@ -0,0 +1,18 @@
+CREATE TABLE `bug_reports` (
+	`id` text PRIMARY KEY NOT NULL,
+	`received_at` integer NOT NULL,
+	`message` text NOT NULL,
+	`client_version` text NOT NULL,
+	`client_platform` text NOT NULL,
+	`context` text,
+	`state_codec` text,
+	`state_format_version` integer,
+	`state_uncompressed_bytes` integer,
+	`state_compressed_bytes` integer,
+	`state_sha256` text,
+	`state_anonymized` integer,
+	`blob_key` text,
+	`body` text
+);
+--> statement-breakpoint
+CREATE INDEX `bug_reports_received_idx` ON `bug_reports` (`received_at`);