@statewalker/webrun-files-sqlite 0.10.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022-2026 statewalker
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,212 @@
+# @statewalker/webrun-files-sqlite
+
+Two `FilesApi` implementations over SQLite, sharing one small SQL port with drivers for
+`node:sqlite`, Cloudflare Durable Object storage and Cloudflare D1.
+
+| | `SqliteFilesApi` | `SqlarFilesApi` |
+| --- | --- | --- |
+| Storage | paths → contents → blocks of ≤ 1 MiB | one row per file, [SQLite Archive](https://sqlite.org/sqlar.html) format |
+| File size | unbounded; streamed block by block | one blob, read and written whole |
+| Durable Objects / D1 | yes — every row stays under the 2 MB limit | only files whose stored row is under 2 MB |
+| Readable by `sqlite3 -A` | no | yes |
+| Identical content | stored once, shared by every path | stored per path |
+
+Use `SqliteFilesApi` by default, and `SqlarFilesApi` where the archive must be portable to other
+SQLAR tools, in a runtime without a row limit (Node, Deno, Bun, a browser SQLite).
+
+## Installation
+
+```bash
+npm install @statewalker/webrun-files-sqlite @statewalker/webrun-files
+```
+
+`pako` is not a dependency: pass the module to `pakoCodec` / `pakoDeflateCodec` if you use them.
+
+## Drivers
+
+Both implementations take a `SqlDriver`. The package imports none of the handles below — they are
+passed in — so it bundles for any runtime.
+
+```typescript
+import { D1SqlDriver, DoSqlDriver, NodeSqlDriver } from "@statewalker/webrun-files-sqlite";
+
+new NodeSqlDriver(new DatabaseSync("files.db")); // node:sqlite
+new DoSqlDriver(this.ctx.storage); // inside a Durable Object: ctx.storage, not ctx.storage.sql
+new D1SqlDriver(env.DB); // a D1 binding
+```
+
+Any other SQLite binding works by implementing the port:
+
+```typescript
+interface SqlStatement {
+  sql: string;
+  params?: unknown[];
+}
+
+interface SqlDriver {
+  /** Rows as objects keyed by column name. */
+  all<T>(sql: string, ...params: unknown[]): T[] | Promise<T[]>;
+  /** One statement, for its effect. */
+  run(sql: string, ...params: unknown[]): void | Promise<void>;
+  /**
+   * The statements in order, as one transaction: all apply or none do. Returns the number of rows
+   * each statement changed. No statement may depend on another's result.
+   */
+  transaction(statements: SqlStatement[]): number[] | Promise<number[]>;
+}
+```
+
+The built-in drivers implement `transaction` with `BEGIN IMMEDIATE … COMMIT` (node:sqlite),
+`ctx.storage.transactionSync` (Durable Objects, where `sql.exec` rejects `BEGIN`) and `batch()` (D1).
+Blobs come back as `Uint8Array`, `ArrayBuffer` or `number[]` depending on the runtime; both
+implementations accept all three.
+
+## SqliteFilesApi
+
+```typescript
+import { DatabaseSync } from "node:sqlite";
+import { NodeSqlDriver, SqliteFilesApi } from "@statewalker/webrun-files-sqlite";
+
+const files = new SqliteFilesApi(new NodeSqlDriver(new DatabaseSync("files.db")));
+await files.init(); // creates fs_paths, fs_files and fs_blocks if missing
+
+await files.write("/video.mp4", response.body); // any Iterable or AsyncIterable of Uint8Array
+for await (const chunk of files.read("/video.mp4", { start: 10_000_000, length: 65_536 })) {
+  // only the block holding this range is fetched and inflated
+}
+```
+
+`init()` creates the tables and indexes if they are missing; await it before any other call.
+
+### How content is stored
+
+- `fs_paths(pid, path UNIQUE, fid, mtime)` — a path points at a content, or is a directory (`fid` NULL).
+- `fs_files(fid, size, compression, block_size, hash, updated)` — an immutable content: its
+  uncompressed size, `"none"` or `"deflate"`, the block size it was written with, the SHA-256 of its
+  bytes, and when it last changed (`size` and `hash` are NULL while it is being written).
+- `fs_blocks(fid, shift, block)`, keyed by `(fid, shift)` — the content cut into blocks of
+  `block_size` uncompressed bytes (only the last one shorter); `shift` is the block's offset in the
+  uncompressed content, always a multiple of `block_size`. Each block of a `deflate` content is its
+  own zlib stream, so a range read fetches and inflates exactly the blocks the range touches, found
+  by key.
+
+`copy` adds path rows pointing at the same content; a write whose bytes match an existing content
+(same SHA-256, size, compression and block size) shares it too. A content and its blocks are deleted when the
+last path pointing at it is removed or overwritten.
+
+### Streaming
+
+`write` pulls the source only while it builds the current block and stores each block before
+pulling for the next; `read` fetches a block only when its consumer asks for bytes beyond the
+previous one. Memory is bounded by one block plus one source chunk, and the tests measure both
+bounds. An `AbortSignal` passed to `read` is checked before every block.
+
+`list` is streamed too: it reads `fs_paths` in pages of 256 by key, in the index's order — which is
+the path order every `FilesApi` lists in — and `{ after }` is simply where the first page starts.
+
+### Options
+
+| Option | Default | |
+| --- | --- | --- |
+| `compression` | `webDeflateCodec()` where `CompressionStream` exists, else none | `null` stores uncompressed; `pakoDeflateCodec(pako)` for runtimes without Compression Streams |
+| `tablePrefix` | `"fs_"` | several file systems in one database |
+| `blockSize` | 1 MiB | uncompressed bytes per block for new writes, 1 to 1.5 MiB (the cap keeps a deflated block under the 2 MB row limit). Larger means fewer rows — better where statements are costly, as on D1; smaller means cheaper small range reads. Each content records its own size, so changing this never affects existing files. |
+
+### Semantics worth knowing
+
+- `copy` and `move` replace the target's subtree rather than merging into it, and throw when one
+  path contains the other.
+- A write is invisible until complete: if it fails for any reason, the path keeps its previous
+  content and the partly written content is deleted.
+- A read whose content is removed underneath it throws `changed during read`. A block whose
+  uncompressed length is not what its position implies throws `block at <shift> holds … bytes`,
+  before any wrong byte reaches the reader.
+
+### Interruptions and `sweep`
+
+Streaming happens outside transactions; every step that changes what a path shows is one
+transaction (`BEGIN IMMEDIATE` on node:sqlite, `transactionSync` on Durable Objects, `batch()` on D1):
+storing each block, finishing a write, `remove`, `copy` and `move`. A failure inside any of them
+leaves the database exactly as it was — `move` onto an existing target never loses the target.
+
+A write stays invisible until it finishes. If the process dies mid-stream, the partly written
+content is left behind unreferenced; remove such leftovers with
+
+```typescript
+const removed = await files.sweep({ olderThan: 60 * 60_000 }); // contents untouched for an hour
+```
+
+`sweep` deletes contents that no path references and that have not been updated for `olderThan`
+milliseconds, with their blocks. A write refreshes its content with every block, so only a write
+stalled longer than `olderThan` can be swept — and it then fails rather than creating a broken path.
+Choose a threshold above the longest pause a source may take. `sweep` never runs on its own.
+
+## SqlarFilesApi
+
+```typescript
+import { DatabaseSync } from "node:sqlite";
+import { readText, writeText } from "@statewalker/webrun-files";
+import { NodeSqlDriver, SqlarFilesApi } from "@statewalker/webrun-files-sqlite";
+
+const files = new SqlarFilesApi(new NodeSqlDriver(new DatabaseSync("site.sqlar")));
+await files.init(); // creates the sqlar table if missing — await before anything else
+
+await writeText(files, "/docs/index.md", "# Hello");
+console.log(await readText(files, "/docs/index.md"));
+```
+
+It takes the same drivers (see *Drivers*), subject to the row limit below.
+
+### Compression codecs
+
+| Codec | Uses | When |
+| --- | --- | --- |
+| `webCodec()` | `CompressionStream("deflate")` | Default wherever `CompressionStream` exists |
+| `pakoCodec(pako, { level })` | an injected `pako` module | Runtimes without Compression Streams |
+| `rawCodec()` | nothing | Default elsewhere; never compresses, and refuses to read compressed rows |
+
+```typescript
+import * as pako from "pako";
+const files = new SqlarFilesApi(driver, { codec: pakoCodec(pako) });
+```
+
+All codecs read and write the same zlib format, so an archive written with one is read by another.
+Inputs shorter than `minSize` (64 bytes by default) are stored without attempting compression.
+
+### How entries are stored
+
+| Entry | `name` | `sz` | `data` |
+| --- | --- | --- | --- |
+| File | `docs/index.md` (no leading slash) | byte length | plaintext, or deflated when strictly shorter |
+| Empty file | | `0` | zero-length blob |
+| Directory | | `0` | `NULL` |
+| Symlink | | `-1` | target as text |
+
+`mtime` is stored in seconds; `lastModified` reports it in milliseconds. Archives written by other
+tools without directory rows still behave as trees: a path that is only a prefix of other names is a
+directory.
+
+#### Symlinks
+
+`FileKind` has no symlink, so `stats`, `exists`, `read` and `list` follow links the way POSIX
+`stat()` does. A dangling link, or a chain of more than 8, behaves as a missing path. `remove`,
+`copy` and `move` act on the link itself. Two extension methods give access to links:
+
+```typescript
+await files.symlink("/latest.js", "./v2/index.js");
+await files.readlink("/latest.js"); // "./v2/index.js"
+```
+
+### Limitations
+
+- A file is one blob: `write` buffers its content, `read` inflates it whole and yields one chunk.
+- On Durable Objects and D1 a row may not exceed 2 MB, so the *stored* (possibly compressed) size
+  of one file is capped there. Use `SqliteFilesApi` in those runtimes.
+- Multi-row mutations (`copy`, `move`, `remove` of a tree) are not wrapped in a transaction.
+- Only the final path component is resolved through symlinks.
+- `list` loads every row under the directory, then sorts the entries into path order (implicit
+  directories and resolved links do not sit where the rows do) before applying `after`.
+
+## License
+
+MIT

package/dist/blocks/byte-reader.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Pull bytes from a chunk source in bounded pieces.
+ *
+ * `read(max)` hands out at most `max` bytes as a zero-copy view of the current
+ * source chunk, and pulls the next chunk only when the current one is spent.
+ * The source is therefore never read ahead of its consumer: this is the
+ * backpressure boundary between a caller's stream and block storage.
+ */
+export declare class ByteReader {
+    #private;
+    constructor(source: Iterable<Uint8Array> | AsyncIterable<Uint8Array>);
+    /** At most `max` bytes, or `undefined` once the source is exhausted. */
+    read(max: number): Promise<Uint8Array | undefined>;
+    /** Release the source early, as `break` in a `for await` would. */
+    close(): Promise<void>;
+}
+/** One Uint8Array from a stream's chunks — only ever used on a single block's worth. */
+export declare function collectBlock(chunks: AsyncIterable<Uint8Array>): Promise<Uint8Array>;
+//# sourceMappingURL=byte-reader.d.ts.map

package/dist/blocks/byte-reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"byte-reader.d.ts","sourceRoot":"","sources":["../../src/blocks/byte-reader.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,qBAAa,UAAU;;IAKrB,YAAY,MAAM,EAAE,QAAQ,CAAC,UAAU,CAAC,GAAG,aAAa,CAAC,UAAU,CAAC,EAKnE;IAED,wEAAwE;IAClE,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAcvD;IAED,mEAAmE;IAC7D,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAK3B;CACF;AAED,wFAAwF;AACxF,wBAAsB,YAAY,CAAC,MAAM,EAAE,aAAa,CAAC,UAAU,CAAC,GAAG,OAAO,CAAC,UAAU,CAAC,CAgBzF"}

package/dist/blocks/sha256.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Incremental SHA-256 (FIPS 180-4). WebCrypto only hashes a whole buffer, and
+ * content here arrives as a stream it must never be collected from.
+ */
+export declare class Sha256 {
+    #private;
+    update(bytes: Uint8Array): this;
+    /** Finalises the hash; the instance cannot be used afterwards. */
+    digestHex(): string;
+}
+//# sourceMappingURL=sha256.d.ts.map

package/dist/blocks/sha256.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sha256.d.ts","sourceRoot":"","sources":["../../src/blocks/sha256.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAaH,qBAAa,MAAM;;IAUjB,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI,CAmB9B;IAED,kEAAkE;IAClE,SAAS,IAAI,MAAM,CAalB;CAsDF"}

package/dist/blocks/sqlite-files-api.d.ts

@@ -0,0 +1,61 @@
+import type { FileInfo, FileStats, FilesApi, ListOptions, ReadOptions } from "@statewalker/webrun-files";
+import type { SqlDriver } from "../sql.types.js";
+import { type StreamCodec } from "./stream-codec.js";
+export interface SqliteFilesApiOptions {
+    /** Prefix of the three table names. Defaults to "fs_". */
+    tablePrefix?: string;
+    /**
+     * Codec for new writes; `null` stores content uncompressed. Defaults to
+     * {@link webDeflateCodec} where Compression Streams exist, uncompressed elsewhere.
+     */
+    compression?: StreamCodec | null;
+    /**
+     * Uncompressed bytes per block for new writes; only a file's last block is
+     * shorter. An integer from 1 to 1.5 MiB, default 1 MiB. Each content records
+     * the size it was written with, so changing this never affects existing files.
+     */
+    blockSize?: number;
+}
+/**
+ * A FilesApi over three SQLite tables: paths point at immutable contents, and
+ * a content is a sequence of bounded, optionally compressed blocks. Reads and
+ * writes stream one block at a time, so no file is ever held whole and no row
+ * outgrows the 2 MB limit of Durable Objects and D1.
+ *
+ * Streaming happens outside transactions; every step that changes what a path
+ * shows is one transaction, so an interruption leaves at most an unreferenced
+ * content, which {@link sweep} removes.
+ */
+export declare class SqliteFilesApi implements FilesApi {
+    #private;
+    constructor(sql: SqlDriver, opts?: SqliteFilesApiOptions);
+    /** Creates the tables and indexes if missing. Await it before any other call. */
+    init(): Promise<void>;
+    read(path: string, options?: ReadOptions): AsyncIterable<Uint8Array>;
+    /**
+     * Streams the content into a new, invisible content row, one block per
+     * transaction, then points the path at it in one transaction. Any failure
+     * removes the pending content; a crash leaves it for {@link sweep}.
+     */
+    write(path: string, content: Iterable<Uint8Array> | AsyncIterable<Uint8Array>): Promise<void>;
+    mkdir(path: string): Promise<void>;
+    stats(path: string): Promise<FileStats | undefined>;
+    exists(path: string): Promise<boolean>;
+    list(path: string, options?: ListOptions): AsyncIterable<FileInfo>;
+    remove(path: string): Promise<boolean>;
+    copy(source: string, target: string): Promise<boolean>;
+    move(source: string, target: string): Promise<boolean>;
+    /**
+     * Deletes, in one transaction, every content not updated for `olderThan`
+     * milliseconds that is still pending or that no path references, with its
+     * blocks. Returns how many contents were deleted.
+     *
+     * A write refreshes its pending content with every block, so only a write
+     * stalled longer than `olderThan` can be swept — and it then fails instead of
+     * pointing a path at missing content. Never runs on its own.
+     */
+    sweep(options: {
+        olderThan: number;
+    }): Promise<number>;
+}
+//# sourceMappingURL=sqlite-files-api.d.ts.map

package/dist/blocks/sqlite-files-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-files-api.d.ts","sourceRoot":"","sources":["../../src/blocks/sqlite-files-api.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EACR,SAAS,EACT,QAAQ,EACR,WAAW,EACX,WAAW,EACZ,MAAM,2BAA2B,CAAC;AAGnC,OAAO,KAAK,EAAE,SAAS,EAAgB,MAAM,iBAAiB,CAAC;AAG/D,OAAO,EAAE,KAAK,WAAW,EAAmB,MAAM,mBAAmB,CAAC;AAOtE,MAAM,WAAW,qBAAqB;IACpC,0DAA0D;IAC1D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,WAAW,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;IACjC;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAcD;;;;;;;;;GASG;AACH,qBAAa,cAAe,YAAW,QAAQ;;IAS7C,YAAY,GAAG,EAAE,SAAS,EAAE,IAAI,GAAE,qBAA0B,EAqB3D;IAED,iFAAiF;IAC3E,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CA0B1B;IAIM,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,WAAgB,GAAG,aAAa,CAAC,UAAU,CAAC,CA8C9E;IAID;;;;OAIG;IACG,KAAK,CACT,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,QAAQ,CAAC,UAAU,CAAC,GAAG,aAAa,CAAC,UAAU,CAAC,GACxD,OAAO,CAAC,IAAI,CAAC,CAmEf;IA8CK,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CASvC;IAIK,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC,CAKxD;IAEK,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAE3C;IAEM,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,WAAgB,GAAG,aAAa,CAAC,QAAQ,CAAC,CA4B5E;IAIK,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAG3C;IAgCK,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAE3D;IAEK,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAE3D;IA6CD;;;;;;;;OAQG;IACG,KAAK,CAAC,OAAO,EAAE;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAqB3D;CAiEF"}

package/dist/blocks/stream-codec.d.ts

@@ -0,0 +1,40 @@
+/**
+ * A streaming compression format. Pulled, never pushed: `compress` and
+ * `decompress` read their input only as their output is consumed.
+ */
+export interface StreamCodec {
+    /** Stored in `fs_files.compression`. Implementations of one format share the name. */
+    name: string;
+    compress(input: AsyncIterable<Uint8Array>): AsyncIterable<Uint8Array>;
+    decompress(input: AsyncIterable<Uint8Array>): AsyncIterable<Uint8Array>;
+}
+/**
+ * zlib-wrapped Deflate over Compression Streams — browsers, Node, Deno, Bun,
+ * Workers. The source is wrapped in a pull-only ReadableStream, so the
+ * transform asks for input only when it has room, and cancelling the output
+ * closes the source.
+ */
+export declare function webDeflateCodec(): StreamCodec;
+/** The part of the `pako` module the streaming codec uses. */
+export interface PakoStreamModule {
+    Deflate: new (options?: {
+        level?: number;
+    }) => PakoStream;
+    Inflate: new () => PakoStream;
+}
+interface PakoStream {
+    push(data: Uint8Array, flush?: boolean): boolean;
+    onData(chunk: Uint8Array): void;
+    err: number;
+    msg: string;
+    ended?: boolean;
+}
+/**
+ * zlib-wrapped Deflate through pako's incremental classes, for runtimes without
+ * Compression Streams. The module is injected, not imported.
+ */
+export declare function pakoDeflateCodec(pako: PakoStreamModule, opts?: {
+    level?: number;
+}): StreamCodec;
+export {};
+//# sourceMappingURL=stream-codec.d.ts.map

package/dist/blocks/stream-codec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-codec.d.ts","sourceRoot":"","sources":["../../src/blocks/stream-codec.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B,sFAAsF;IACtF,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,UAAU,CAAC,GAAG,aAAa,CAAC,UAAU,CAAC,CAAC;IACtE,UAAU,CAAC,KAAK,EAAE,aAAa,CAAC,UAAU,CAAC,GAAG,aAAa,CAAC,UAAU,CAAC,CAAC;CACzE;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,IAAI,WAAW,CAW7C;AAED,8DAA8D;AAC9D,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,KAAK,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,UAAU,CAAC;IAC1D,OAAO,EAAE,UAAU,UAAU,CAAC;CAC/B;AAED,UAAU,UAAU;IAClB,IAAI,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC;IACjD,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI,CAAC;IAChC,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,gBAAgB,EACtB,IAAI,GAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAO,GAC5B,WAAW,CAOb"}

package/dist/bytes.d.ts

@@ -0,0 +1,3 @@
+/** Blobs arrive as Uint8Array (node:sqlite), ArrayBuffer (Durable Objects) or number[] (D1). */
+export declare function toBytes(value: unknown): Uint8Array;
+//# sourceMappingURL=bytes.d.ts.map

package/dist/bytes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytes.d.ts","sourceRoot":"","sources":["../src/bytes.ts"],"names":[],"mappings":"AAAA,gGAAgG;AAChG,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,UAAU,CAMlD"}