@primate/core 0.1.10 → 0.2.1

package/lib/private/target/web.js

@@ -0,0 +1,68 @@
+import location from "#location";
+import FileRef from "@rcompat/fs/FileRef";
+const html = /^.*.html$/ui;
+const web = {
+    name: "web",
+    runner: async (app) => {
+        const client = app.runpath(location.client);
+        const client_imports = (await client.collect())
+            .map((file, i) => {
+            const type = file.extension === ".css" ? "style" : "js";
+            const src = `/${file.debase(client).name}`;
+            const path = `./${file.debase(`${app.path.build}/`)}`;
+            return {
+                code: `await load_text(asset${i})`,
+                path,
+                src,
+                type,
+            };
+        });
+        const d = app.runpath(location.server, location.pages);
+        const pages = await Promise.all((await FileRef.collect(d, file => html.test(file.path)))
+            .map(async (file) => `${file.debase(d)}`.slice(1)));
+        const pages_str = pages.map(page => `"${page}": await load_text(import.meta.url,
+    "${FileRef.webpath(`../${location.server}/${location.pages}/${page}`)}"),`)
+            .join("\n");
+        const assets_scripts = `
+  import Loader from "primate/Loader";
+  import load_text from "primate/load-text";
+
+  ${client_imports.map(({ path }, i) => `const asset${i} = await load_text(import.meta.url, "../${path}");`)
+            .join("\n  ")}
+  const assets = [${client_imports.map(($import, i) => `{
+  src: "${$import.src}",
+  code: asset${i},
+  type: "${$import.type}",
+  inline: false,
+  }`).join(",\n  ")}];
+
+  const imports = {
+    app: "${client_imports.find(({ src }) => src.includes("app") && src.endsWith(".js")).src}"
+  };
+  // importmap
+  assets.push({
+    inline: true,
+    code: { imports },
+    type: "importmap",
+  });
+
+  const pages = {
+    ${pages_str}
+  };
+
+  export default {
+    assets,
+    loader: new Loader({
+      pages,
+      rootfile: import.meta.url,
+      static_root: "${app.config("http.static.root")}",
+    }),
+    target: "web",
+  };
+`;
+        await app.path.build.join("target.js").write(assets_scripts);
+    },
+    target: "web",
+};
+export default web;
+//# sourceMappingURL=web.js.map

package/lib/private/wasm/API.d.ts

@@ -0,0 +1,7 @@
+import type Verb from "#request/Verb";
+import type RouteHandler from "#route/Handler";
+type API = {
+    [key in Verb]?: RouteHandler;
+};
+export type { API as default };
+//# sourceMappingURL=API.d.ts.map

package/lib/private/wasm/API.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=API.js.map

package/lib/private/wasm/BufferViewSource.d.ts

@@ -0,0 +1,4 @@
+import type BufferView from "@rcompat/bufferview";
+type BufferViewSource = ConstructorParameters<typeof BufferView>;
+export type { BufferViewSource as default };
+//# sourceMappingURL=BufferViewSource.d.ts.map

package/lib/private/wasm/BufferViewSource.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=BufferViewSource.js.map

package/lib/private/wasm/Exports.d.ts

@@ -0,0 +1,23 @@
+import type Verb from "#request/Verb";
+import type I32 from "#wasm/I32";
+import type Tagged from "#wasm/Tagged";
+/** The HTTP Methods that are potentially exported by the WASM module if they
+ * are following the Primate WASM ABI convention. */
+type ExportedMethods<TRequest = I32, TResponse = I32> = {
+    [Method in Verb]?: (request: Tagged<"Request", TRequest>) => Tagged<"Response", TResponse>;
+};
+/** These functions should be exported by a WASM module to be compatible with
+ * Primate. This follows the Primate WASM ABI convention. */
+type Exports<TRequest = I32, TResponse = I32> = {
+    finalizeRequest(value: Tagged<"Request", TRequest>): void;
+    finalizeResponse(value: Tagged<"Response", TResponse>): void;
+    getStoreValueDone(): void;
+    memory: WebAssembly.Memory;
+    newRequest(): Tagged<"Request", TRequest>;
+    sendResponse(response: Tagged<"Response", TResponse>): void;
+    websocketClose(): void;
+    websocketMessage(): void;
+    websocketOpen(): void;
+} & ExportedMethods<TRequest, TResponse>;
+export type { Exports as default };
+//# sourceMappingURL=Exports.d.ts.map

package/lib/private/wasm/Exports.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Exports.js.map

package/lib/private/wasm/I32.d.ts

@@ -0,0 +1,5 @@
+/** The default request and response types, which are likely pointers into a
+ * WASM linear memory space. */
+type I32 = number;
+export type { I32 as default };
+//# sourceMappingURL=I32.d.ts.map

package/lib/private/wasm/I32.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=I32.js.map

package/lib/private/wasm/I32_SIZE.d.ts

@@ -0,0 +1,3 @@
+declare const _default: number;
+export default _default;
+//# sourceMappingURL=I32_SIZE.d.ts.map

package/lib/private/wasm/I32_SIZE.js

@@ -0,0 +1,2 @@
+export default Int32Array.BYTES_PER_ELEMENT;
+//# sourceMappingURL=I32_SIZE.js.map

package/lib/private/wasm/Instantiation.d.ts

@@ -0,0 +1,12 @@
+import type API from "#wasm/API";
+import type Exports from "#wasm/Exports";
+import type I32 from "#wasm/I32";
+type Instantiation<TRequest = I32, TResponse = I32> = {
+    api: API;
+    exports: Exports<TRequest, TResponse>;
+    memory: WebAssembly.Memory;
+    setPayload(value: Uint8Array): void;
+    sockets: Map<bigint, any>;
+};
+export type { Instantiation as default };
+//# sourceMappingURL=Instantiation.d.ts.map

package/lib/private/wasm/Instantiation.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Instantiation.js.map

package/lib/private/wasm/Tagged.d.ts

@@ -0,0 +1,7 @@
+/** A helper function to encourage type safety when working with wasm pointers,
+ * tagging them as a specific type. */
+type Tagged<Name, T> = {
+    _tag: Name;
+} & T;
+export type { Tagged as default };
+//# sourceMappingURL=Tagged.d.ts.map

package/lib/private/wasm/Tagged.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Tagged.js.map

package/lib/private/wasm/buffersize.d.ts

@@ -0,0 +1,2 @@
+export default function buffersize(buffer: Uint8Array): number;
+//# sourceMappingURL=buffersize.d.ts.map

package/lib/private/wasm/buffersize.js

@@ -0,0 +1,5 @@
+import I32_SIZE from "#wasm/I32_SIZE";
+export default function buffersize(buffer) {
+    return buffer.byteLength + I32_SIZE;
+}
+//# sourceMappingURL=buffersize.js.map

package/lib/private/wasm/decode-bytes.d.ts

@@ -0,0 +1,3 @@
+import type BufferView from "@rcompat/bufferview";
+export default function decodeBytes(source: BufferView): Uint8Array<ArrayBufferLike>;
+//# sourceMappingURL=decode-bytes.d.ts.map

package/lib/private/wasm/decode-bytes.js

@@ -0,0 +1,5 @@
+export default function decodeBytes(source) {
+    return source.readBytes(source.readU32());
+}
+;
+//# sourceMappingURL=decode-bytes.js.map

package/lib/private/wasm/decode-json.d.ts

@@ -0,0 +1,7 @@
+import BufferView from "@rcompat/bufferview";
+declare function decodeJson(view: BufferView): any;
+declare namespace decodeJson {
+    var from: (buffer: ArrayBufferLike | ArrayBufferView<ArrayBufferLike>, offset?: number | undefined, byteLength?: number | undefined) => any;
+}
+export default decodeJson;
+//# sourceMappingURL=decode-json.d.ts.map

package/lib/private/wasm/decode-json.js

@@ -0,0 +1,11 @@
+import decodeString from "#wasm/decode-string";
+import BufferView from "@rcompat/bufferview";
+function decodeJson(view) {
+    return JSON.parse(decodeString(view));
+}
+;
+decodeJson.from = (...source) => {
+    return decodeJson(new BufferView(...source));
+};
+export default decodeJson;
+//# sourceMappingURL=decode-json.js.map

package/lib/private/wasm/decode-option.d.ts

@@ -0,0 +1,5 @@
+import type BufferView from "@rcompat/bufferview";
+type Decoder<T> = (source: BufferView) => T;
+declare const decodeOption: <T>(kind: Decoder<T>, source: BufferView) => T | undefined;
+export default decodeOption;
+//# sourceMappingURL=decode-option.d.ts.map

package/lib/private/wasm/decode-option.js

@@ -0,0 +1,10 @@
+import assert from "@rcompat/assert";
+const NONE = 0;
+const SOME = 1;
+const decodeOption = (kind, source) => {
+    const option = source.readU32();
+    assert(option === NONE || option === SOME, "Error decoding option, invalid option value.");
+    return option === SOME ? kind(source) : void 0;
+};
+export default decodeOption;
+//# sourceMappingURL=decode-option.js.map

package/lib/private/wasm/decode-response.d.ts

@@ -0,0 +1,19 @@
+import type ResponseFunction from "#response/ResponseFunction";
+import type Instantiation from "#wasm/Instantiation";
+import type BufferView from "@rcompat/bufferview";
+import type Dict from "@rcompat/type/Dict";
+type DecodedResponse = {
+    callback: (api: Instantiation) => ResponseFunction;
+    type: "web_socket_upgrade";
+} | {
+    headers: Dict<string>;
+    status?: number | undefined;
+    text: string;
+    type: "text";
+} | {
+    type: "blob" | "error" | "json" | "redirect" | "uri" | "view";
+    value: any;
+};
+declare const decodeResponse: (source: BufferView) => DecodedResponse | undefined;
+export default decodeResponse;
+//# sourceMappingURL=decode-response.d.ts.map

package/lib/private/wasm/decode-response.js

@@ -0,0 +1,90 @@
+import error from "#response/error";
+import redirect from "#response/redirect";
+import view from "#response/view";
+import decodeBytes from "#wasm/decode-bytes";
+import decodeJson from "#wasm/decode-json";
+import decodeOption from "#wasm/decode-option";
+import decodeString from "#wasm/decode-string";
+import openWebsocket from "#wasm/open-websocket";
+import assert from "@rcompat/assert";
+const RESPONSE_TEXT = 0;
+const RESPONSE_JSON = 1;
+const RESPONSE_BLOB = 2;
+const RESPONSE_VIEW = 3;
+const RESPONSE_ERROR = 4;
+const RESPONSE_REDIRECT = 5;
+const RESPONSE_URI = 6;
+const RESPONSE_WEB_SOCKET_UPGRADE = 7;
+const decodeResponse = (source) => {
+    const responseKind = source.readU32();
+    assert(responseKind === RESPONSE_BLOB
+        || responseKind === RESPONSE_ERROR
+        || responseKind === RESPONSE_JSON
+        || responseKind === RESPONSE_REDIRECT
+        || responseKind === RESPONSE_TEXT
+        || responseKind === RESPONSE_URI
+        || responseKind === RESPONSE_VIEW
+        || responseKind === RESPONSE_WEB_SOCKET_UPGRADE, "Invalid response kind.");
+    switch (responseKind) {
+        case RESPONSE_TEXT: {
+            const text = decodeString(source);
+            const status = source.readU32();
+            const headers = decodeJson(source);
+            return { headers, status, text, type: "text" };
+        }
+        case RESPONSE_JSON:
+            return { type: "json", value: decodeJson(source) };
+        case RESPONSE_BLOB: {
+            const buffer = decodeBytes(source);
+            const contentType = decodeOption(decodeString, source);
+            return {
+                type: "blob",
+                value: contentType
+                    ? new Blob([buffer], { type: contentType })
+                    : new Blob([buffer]),
+            };
+        }
+        case RESPONSE_VIEW: {
+            const name = decodeString(source);
+            const props = decodeJson(source) || void 0;
+            const options = decodeJson(source) || void 0;
+            return {
+                type: "view",
+                value: view(name, props, options),
+            };
+        }
+        case RESPONSE_ERROR: {
+            const body = decodeOption(decodeString, source);
+            const status = source.readU32();
+            const page = decodeOption(decodeString, source);
+            return {
+                type: "error",
+                value: error({ body, page, status }),
+            };
+        }
+        case RESPONSE_REDIRECT: {
+            const to = decodeString(source);
+            const status = decodeOption(source => source.readU32(), source);
+            return {
+                type: "redirect",
+                value: redirect(to, status),
+            };
+        }
+        case RESPONSE_URI: {
+            const str = decodeString(source);
+            return {
+                type: "uri",
+                value: new URL(str),
+            };
+        }
+        case RESPONSE_WEB_SOCKET_UPGRADE: {
+            const id = source.readU64();
+            return {
+                callback: openWebsocket(id),
+                type: "web_socket_upgrade",
+            };
+        }
+    }
+};
+export default decodeResponse;
+//# sourceMappingURL=decode-response.js.map

package/lib/private/wasm/decode-string.d.ts

@@ -0,0 +1,3 @@
+import type BufferView from "@rcompat/bufferview";
+export default function decodeString(source: BufferView): string;
+//# sourceMappingURL=decode-string.d.ts.map

package/lib/private/wasm/decode-string.js

@@ -0,0 +1,5 @@
+export default function decodeString(source) {
+    return source.read(source.readU32());
+}
+;
+//# sourceMappingURL=decode-string.js.map

package/lib/private/wasm/decode-websocket-close.d.ts

@@ -0,0 +1,5 @@
+import type BufferViewSource from "#wasm/BufferViewSource";
+export default function decodeWebsocketClose(...source: BufferViewSource): {
+    id: bigint;
+};
+//# sourceMappingURL=decode-websocket-close.d.ts.map

package/lib/private/wasm/decode-websocket-close.js

@@ -0,0 +1,6 @@
+import BufferView from "@rcompat/bufferview";
+export default function decodeWebsocketClose(...source) {
+    return { id: new BufferView(...source).readU64() };
+}
+;
+//# sourceMappingURL=decode-websocket-close.js.map

package/lib/private/wasm/decode-websocket-send.d.ts

@@ -0,0 +1,6 @@
+import type BufferViewSource from "#wasm/BufferViewSource";
+export default function decodeWebsocketSend(...source: BufferViewSource): {
+    id: bigint;
+    message: string | Uint8Array<ArrayBufferLike>;
+};
+//# sourceMappingURL=decode-websocket-send.d.ts.map

package/lib/private/wasm/decode-websocket-send.js

@@ -0,0 +1,19 @@
+import decodeBytes from "#wasm/decode-bytes";
+import decodeString from "#wasm/decode-string";
+import assert from "@rcompat/assert";
+import BufferView from "@rcompat/bufferview";
+const WEBSOCKET_MESSAGE_KIND_STRING = 0;
+const WEBSOCKET_MESSAGE_KIND_BYTES = 1;
+export default function decodeWebsocketSend(...source) {
+    const bufferView = new BufferView(...source);
+    const id = bufferView.readU64();
+    const kind = bufferView.readU32();
+    assert(kind === WEBSOCKET_MESSAGE_KIND_STRING
+        || kind === WEBSOCKET_MESSAGE_KIND_BYTES, "Invalid websocket message kind.");
+    const message = kind === WEBSOCKET_MESSAGE_KIND_STRING
+        ? decodeString(bufferView)
+        : decodeBytes(bufferView);
+    return { id, message };
+}
+;
+//# sourceMappingURL=decode-websocket-send.js.map

package/lib/private/wasm/encode-buffer.d.ts

@@ -0,0 +1,3 @@
+import type BufferView from "@rcompat/bufferview";
+export default function encodeBuffer(buffer: Uint8Array, view: BufferView): void;
+//# sourceMappingURL=encode-buffer.d.ts.map

package/lib/private/wasm/encode-buffer.js

@@ -0,0 +1,6 @@
+export default function encodeBuffer(buffer, view) {
+    const byteLength = buffer.byteLength;
+    view.writeU32(byteLength).writeBytes(buffer);
+}
+;
+//# sourceMappingURL=encode-buffer.js.map

package/lib/private/wasm/encode-request.d.ts

@@ -0,0 +1,9 @@
+import type RequestFacade from "#request/RequestFacade";
+import BufferView from "@rcompat/bufferview";
+declare const encodeRequest: {
+    (request: RequestFacade): Promise<Uint8Array<ArrayBuffer>>;
+    sizeOf: (request: RequestFacade) => number;
+    into: (request: RequestFacade, view: BufferView) => Promise<void>;
+};
+export default encodeRequest;
+//# sourceMappingURL=encode-request.d.ts.map

package/lib/private/wasm/encode-request.js

@@ -0,0 +1,198 @@
+import encodeString from "#wasm/encode-string";
+import encodeStringMap from "#wasm/encode-string-map";
+import encodeURL from "#wasm/encode-url";
+import filesize from "#wasm/filesize";
+import I32_SIZE from "#wasm/I32_SIZE";
+import stringSize from "#wasm/stringsize";
+import urlSize from "#wasm/urlsize";
+import BufferView from "@rcompat/bufferview";
+import encodeBuffer from "./encode-buffer.js";
+const SECTION_HEADER_SIZE = I32_SIZE;
+const URL_SECTION = 0;
+const BODY_SECTION = 1;
+const PATH_SECTION = 2;
+const QUERY_SECTION = 3;
+const HEADERS_SECTION = 4;
+const COOKIES_SECTION = 5;
+const BODY_KIND_NULL = 0;
+const BODY_KIND_TEXT = 1;
+const BODY_KIND_FIELDS = 2;
+const BODY_KIND_BINARY = 3;
+const BODY_KIND_JSON = 4;
+const BODY_KIND_MAP_VALUE_STRING = 0;
+const BODY_KIND_MAP_VALUE_BLOB = 1;
+const sizeOfUrlSection = (url) => SECTION_HEADER_SIZE + urlSize(url);
+const sizeOfBodySection = (body) => {
+    let size = SECTION_HEADER_SIZE + I32_SIZE;
+    if (body.type === "none")
+        return size; // 0 kind null
+    if (body.type === "text")
+        return size + stringSize(body.text());
+    if (body.type === "fields") {
+        size += I32_SIZE; // entry count
+        const fields = body.fields();
+        for (const [key, value] of Object.entries(fields)) {
+            size += stringSize(key);
+            size += I32_SIZE // value kind
+                + (typeof value === "string"
+                    ? stringSize(value)
+                    : filesize(value));
+        }
+        return size;
+    }
+    if (body.type === "binary") {
+        const bin = body.binary();
+        size += stringSize(bin.type);
+        size += I32_SIZE + bin.size;
+        return size;
+    }
+    if (body.type === "json") {
+        const json = body.json();
+        size += stringSize(JSON.stringify(json));
+        return size;
+    }
+    throw new Error("Invalid RequestLike body");
+};
+const sizeOfMapSection = (map) => {
+    let size = SECTION_HEADER_SIZE + I32_SIZE;
+    for (const [key, value] of Object.entries(map)) {
+        if (value) {
+            size += stringSize(key) + stringSize(value);
+        }
+    }
+    return size;
+};
+/**
+ * Encode a map of Key Value pairs into a section.
+ *
+ * - [I32: header]
+ * - [I32: count]
+ * - Entries[count]:
+ *   - [String: key]
+ *   - [String: value]
+ *
+ * @param header - The header for this section.
+ * @param map - The map itself to be encoded.
+ * @param offset - The offset to encode the map at.
+ * @param view - The buffer view to encode the map into.
+ */
+const encodeMapSection = (header, map, view) => {
+    view.writeU32(header);
+    return encodeStringMap(map, view);
+};
+const encodeBlob = async (file, view) => {
+    const type = file.type;
+    const bytes = await file.bytes();
+    encodeString(type, view);
+    encodeBuffer(bytes, view);
+};
+const encodeFile = async (file, view) => {
+    const name = file.name;
+    const type = file.type;
+    const bytes = await file.bytes();
+    encodeString(name, view);
+    encodeString(type, view);
+    view.writeU32(bytes.byteLength);
+    view.writeBytes(bytes);
+};
+/**
+ * 1. Section 1: URI
+ *   - [Section Header: 0] 4 bytes
+ *   - [I32: length] 4 bytes
+ *   - [...payload] length bytes
+ */
+const encodeSectionUrl = (url, view) => {
+    view.writeU32(URL_SECTION);
+    encodeURL(url, view);
+};
+/**
+ * 2. Section 2: Body
+ *   - [Section Header: 1] 4 bytes
+ *   - [kind: I32] 4 bytes
+ *     - 0: Null
+ *       - [I32: kind = 0] 4 bytes
+ *     - 1: String
+ *       - [I32: kind = 1] 4 bytes
+ *       - [I32: length] 4 bytes
+ *       - [...payload] length bytes
+ *     - 2: Map<string, string | file>
+ *       - [I32: kind = 2] 4 bytes
+ *       - [I32: count] 4 bytes
+ *       - [String, String | FileDescriptor]
+ *         - [I32: key length]
+ *         - [...key payload]
+ *         - [I32: value kind] 4 bytes
+ *           - 0: String
+ *             - [I32: value kind = 0] 4 bytes
+ *             - [I32: value length] 4 bytes
+ *             - [...value payload] value length bytes
+ *           - 1: File
+ *             - [I32: value kind = 1] 4 bytes
+ *             - [I32: file_descriptor] 4 bytes
+ */
+const encodeSectionBody = async (body, view) => {
+    view.writeU32(BODY_SECTION);
+    if (body.type === "text") {
+        const text = body.text();
+        view.writeU32(BODY_KIND_TEXT);
+        encodeString(text, view);
+    }
+    else if (body.type === "fields") {
+        const fields = body.fields();
+        const entries = Object.entries(body.fields());
+        const entryCount = entries.length;
+        view.writeU32(BODY_KIND_FIELDS);
+        view.writeU32(entryCount);
+        for (const [key, value] of Object.entries(fields)) {
+            encodeString(key, view);
+            if (typeof value === "string") {
+                view.writeU32(BODY_KIND_MAP_VALUE_STRING);
+                encodeString(value, view);
+            }
+            else {
+                view.writeU32(BODY_KIND_MAP_VALUE_BLOB);
+                await encodeFile(value, view);
+            }
+        }
+    }
+    else if (body.type === "binary") {
+        view.writeU32(BODY_KIND_BINARY);
+        await encodeBlob(body.binary(), view);
+    }
+    else if (body.type === "json") {
+        view.writeU32(BODY_KIND_JSON);
+        const jsonText = JSON.stringify(body.json());
+        encodeString(jsonText, view);
+    }
+    else if (body.type === "none") {
+        view.writeU32(BODY_KIND_NULL);
+    }
+    else {
+        throw new Error(`Unsupported body type: ${body?.type ?? typeof body}`);
+    }
+};
+const sizeOfRequest = (request) => sizeOfUrlSection(request.url)
+    + sizeOfBodySection(request.body)
+    + sizeOfMapSection(request.path.toJSON())
+    + sizeOfMapSection(request.query.toJSON())
+    + sizeOfMapSection(request.headers.toJSON())
+    + sizeOfMapSection(request.cookies.toJSON());
+const encodeRequestInto = async (request, view) => {
+    encodeSectionUrl(request.url, view);
+    await encodeSectionBody(request.body, view);
+    encodeMapSection(PATH_SECTION, request.path.toJSON(), view);
+    encodeMapSection(QUERY_SECTION, request.query.toJSON(), view);
+    encodeMapSection(HEADERS_SECTION, request.headers.toJSON(), view);
+    encodeMapSection(COOKIES_SECTION, request.cookies.toJSON(), view);
+};
+const encodeRequest = async (request) => {
+    const size = sizeOfRequest(request);
+    const output = new Uint8Array(size);
+    const bufferView = new BufferView(output);
+    await encodeRequestInto(request, bufferView);
+    return output;
+};
+encodeRequest.sizeOf = sizeOfRequest;
+encodeRequest.into = encodeRequestInto;
+export default encodeRequest;
+//# sourceMappingURL=encode-request.js.map

package/lib/private/wasm/encode-session.d.ts

@@ -0,0 +1,3 @@
+import type SessionFacade from "#session/SessionFacade";
+export default function encodeSession(session: SessionFacade<unknown>): Uint8Array<ArrayBuffer>;
+//# sourceMappingURL=encode-session.d.ts.map

package/lib/private/wasm/encode-session.js

@@ -0,0 +1,25 @@
+import encodeString from "#wasm/encode-string";
+import I32_SIZE from "#wasm/I32_SIZE";
+import stringSize from "#wasm/stringsize";
+import BufferView from "@rcompat/bufferview";
+export default function encodeSession(session) {
+    if (session.exists) {
+        const data = JSON.stringify(session.get());
+        const dataSize = stringSize(data);
+        const idSize = stringSize(session.id ?? "");
+        const size = dataSize // data payload
+            + I32_SIZE // new flat
+            + idSize; // id payload
+        const output = new Uint8Array(size);
+        const bufferView = new BufferView(output);
+        bufferView.writeU32(1);
+        encodeString(session.id ?? "", bufferView);
+        encodeString(data, bufferView);
+        return output;
+    }
+    // does not exist (only 0s)
+    const buffer = new Uint8Array(4);
+    return buffer;
+}
+;
+//# sourceMappingURL=encode-session.js.map

package/lib/private/wasm/encode-string-map.d.ts

@@ -0,0 +1,5 @@
+import type BufferView from "@rcompat/bufferview";
+import type PartialDict from "@rcompat/type/PartialDict";
+declare const encodeStringMap: (map: PartialDict<string>, view: BufferView) => void;
+export default encodeStringMap;
+//# sourceMappingURL=encode-string-map.d.ts.map