nervur 0.23.0 → 0.24.0

package/dist/browser/indexeddb-memory.d.ts

@@ -1,17 +0,0 @@
-import type { Memory, PlaceRead } from '../foundation.ts';
-export declare class IndexedDbMemory implements Memory {
-    #private;
-    private constructor();
-    /** The memory named `name`, its database made on first use. `factory` is the engine's `indexedDB` where omitted. */
-    static open(name: string, factory?: IDBFactory): Promise<IndexedDbMemory>;
-    read({ place }: {
-        place: string;
-    }): Promise<PlaceRead>;
-    list(): Promise<readonly string[]>;
-    write({ writes, expect, }: {
-        writes: Readonly<Record<string, Readonly<Record<string, Uint8Array | null>>>>;
-        expect: Readonly<Record<string, string | null>>;
-    }): Promise<Readonly<Record<string, string | null>> | null>;
-    /** The database let go. */
-    close(): void;
-}

package/dist/browser/indexeddb-memory.js

@@ -1,97 +0,0 @@
-const PLACES = 'places';
-const COUNT = 'count';
-const done = (request) => new Promise((resolve, reject) => {
-    request.onsuccess = () => resolve(request.result);
-    request.onerror = () => reject(request.error ?? new Error('IndexedDB refused the request'));
-});
-const copied = (entries) => Object.fromEntries(Object.entries(entries).map(([name, bytes]) => [name, bytes.slice()]));
-export class IndexedDbMemory {
-    #db;
-    constructor(db) {
-        this.#db = db;
-    }
-    /** The memory named `name`, its database made on first use. `factory` is the engine's `indexedDB` where omitted. */
-    static async open(name, factory = indexedDB) {
-        const opening = factory.open(name, 1);
-        opening.onupgradeneeded = () => {
-            opening.result.createObjectStore(PLACES);
-            opening.result.createObjectStore(COUNT);
-        };
-        return new IndexedDbMemory(await done(opening));
-    }
-    async read({ place }) {
-        const held = (await done(this.#db.transaction(PLACES, 'readonly').objectStore(PLACES).get(place)));
-        if (held === undefined)
-            return { entries: {}, version: null };
-        return { entries: copied(held.entries), version: String(held.version) };
-    }
-    async list() {
-        const keys = await done(this.#db.transaction(PLACES, 'readonly').objectStore(PLACES).getAllKeys());
-        return keys.map(String);
-    }
-    write({ writes, expect, }) {
-        const places = [...new Set([...Object.keys(writes), ...Object.keys(expect)])];
-        return new Promise((resolve, reject) => {
-            const transaction = this.#db.transaction([PLACES, COUNT], 'readwrite');
-            const store = transaction.objectStore(PLACES);
-            const count = transaction.objectStore(COUNT);
-            const held = new Map();
-            let versions = null;
-            let refused = false;
-            transaction.oncomplete = () => resolve(versions);
-            transaction.onabort = () => (refused ? resolve(null) : reject(transaction.error ?? new Error('IndexedDB aborted the write')));
-            // Every place and the counter are read inside the transaction, and the writes follow in the same one.
-            const counted = count.get(COUNT);
-            const land = () => {
-                if (held.size < places.length || counted.readyState !== 'done')
-                    return;
-                for (const name of places) {
-                    const version = held.get(name) === undefined ? null : String(held.get(name).version);
-                    if (!(name in expect) || expect[name] !== version) {
-                        refused = true;
-                        transaction.abort();
-                        return;
-                    }
-                }
-                let next = counted.result ?? 0;
-                const landed = {};
-                for (const [name, entries] of Object.entries(writes)) {
-                    const kept = { ...(held.get(name)?.entries ?? {}) };
-                    for (const [entry, bytes] of Object.entries(entries)) {
-                        if (bytes === null)
-                            delete kept[entry];
-                        else
-                            kept[entry] = bytes.slice();
-                    }
-                    next += 1;
-                    if (Object.keys(kept).length === 0) {
-                        store.delete(name);
-                        landed[name] = null;
-                    }
-                    else {
-                        store.put({ entries: kept, version: next }, name);
-                        landed[name] = String(next);
-                    }
-                }
-                count.put(next, COUNT);
-                versions = landed;
-            };
-            counted.onsuccess = land;
-            for (const place of places) {
-                const request = store.get(place);
-                request.onsuccess = () => {
-                    held.set(place, request.result);
-                    land();
-                };
-            }
-            if (places.length === 0)
-                counted.onsuccess = () => {
-                    versions = {};
-                };
-        });
-    }
-    /** The database let go. */
-    close() {
-        this.#db.close();
-    }
-}

package/dist/browser/locked-unlock.d.ts

@@ -1,24 +0,0 @@
-import type { Unlock } from '../ground/ground.ts';
-/** Where the unlock keeps its AES key and the sealed key: values kept as they are. */
-export interface Shelf {
-    get(key: string): Promise<unknown>;
-    set(key: string, value: unknown): Promise<void>;
-}
-/** A shelf in IndexedDB, which keeps a `CryptoKey` whole. */
-export declare class IndexedDbShelf implements Shelf {
-    #private;
-    private constructor();
-    static open(name: string, factory?: IDBFactory): Promise<IndexedDbShelf>;
-    get(key: string): Promise<unknown>;
-    set(key: string, value: unknown): Promise<void>;
-    close(): void;
-}
-export declare class LockedUnlock implements Unlock {
-    #private;
-    constructor(shelf: Shelf, subtle?: SubtleCrypto);
-    /** The unlock of the origin, on a shelf in IndexedDB named `name`. */
-    static open(name?: string, factory?: IDBFactory): Promise<LockedUnlock>;
-    /** Its shelf let go, where the shelf holds a connection. */
-    close(): void;
-    key(): Promise<string>;
-}

package/dist/browser/locked-unlock.js

@@ -1,85 +0,0 @@
-const LOCK = 'lock';
-const SEALED = 'key';
-const STORE = 'shelf';
-// The words sealed in beside the key, so no other sealed value on the shelf opens as it.
-const BOUND = new TextEncoder().encode('nervur-key');
-const done = (request) => new Promise((resolve, reject) => {
-    request.onsuccess = () => resolve(request.result);
-    request.onerror = () => reject(request.error ?? new Error('IndexedDB refused the request'));
-});
-/** A shelf in IndexedDB, which keeps a `CryptoKey` whole. */
-export class IndexedDbShelf {
-    #db;
-    constructor(db) {
-        this.#db = db;
-    }
-    static async open(name, factory = indexedDB) {
-        const opening = factory.open(name, 1);
-        opening.onupgradeneeded = () => {
-            opening.result.createObjectStore(STORE);
-        };
-        return new IndexedDbShelf(await done(opening));
-    }
-    get(key) {
-        return done(this.#db.transaction(STORE, 'readonly').objectStore(STORE).get(key));
-    }
-    async set(key, value) {
-        const transaction = this.#db.transaction(STORE, 'readwrite');
-        transaction.objectStore(STORE).put(value, key);
-        await new Promise((resolve, reject) => {
-            transaction.oncomplete = () => resolve();
-            transaction.onabort = () => reject(transaction.error ?? new Error('IndexedDB aborted the write'));
-        });
-    }
-    close() {
-        this.#db.close();
-    }
-}
-const hex = (bytes) => Array.from(bytes, (byte) => byte.toString(16).padStart(2, '0')).join('');
-export class LockedUnlock {
-    #shelf;
-    #subtle;
-    #drawn;
-    constructor(shelf, subtle = crypto.subtle) {
-        this.#shelf = shelf;
-        this.#subtle = subtle;
-    }
-    /** The unlock of the origin, on a shelf in IndexedDB named `name`. */
-    static async open(name = 'nervur-unlock', factory = indexedDB) {
-        return new LockedUnlock(await IndexedDbShelf.open(name, factory));
-    }
-    /** Its shelf let go, where the shelf holds a connection. */
-    close() {
-        this.#shelf.close?.();
-    }
-    key() {
-        // One key is drawn at a time, so two first uses never draw two.
-        this.#drawn ??= this.#key();
-        this.#drawn.catch(() => (this.#drawn = undefined));
-        return this.#drawn;
-    }
-    // The key sealed on the shelf, or a fresh one sealed there first.
-    async #key() {
-        const lock = await this.#lock();
-        let sealed = (await this.#shelf.get(SEALED));
-        if (sealed === undefined) {
-            const key = crypto.getRandomValues(new Uint8Array(32));
-            const iv = crypto.getRandomValues(new Uint8Array(12));
-            sealed = { iv, data: new Uint8Array(await this.#subtle.encrypt({ name: 'AES-GCM', iv, additionalData: BOUND }, lock, key)) };
-            key.fill(0);
-            await this.#shelf.set(SEALED, sealed);
-        }
-        const key = new Uint8Array(await this.#subtle.decrypt({ name: 'AES-GCM', iv: sealed.iv, additionalData: BOUND }, lock, sealed.data));
-        const text = hex(key);
-        key.fill(0);
-        return text;
-    }
-    async #lock() {
-        const kept = (await this.#shelf.get(LOCK));
-        if (kept !== undefined)
-            return kept;
-        const made = await this.#subtle.generateKey({ name: 'AES-GCM', length: 256 }, false, ['encrypt', 'decrypt']);
-        await this.#shelf.set(LOCK, made);
-        return made;
-    }
-}

package/dist/browser/origin-classes.d.ts

@@ -1,7 +0,0 @@
-import type { Classes } from '../foundation.ts';
-/** What loads a module by its URL: the engine's `import()` where none is handed. */
-export type Load = (href: string) => Promise<unknown>;
-export declare const OriginClasses: Readonly<{
-    /** The classes of the module at `at`, resolved against `origin`, loaded once. */
-    open(at: string, origin: string, load?: Load): Promise<Classes>;
-}>;

package/dist/browser/origin-classes.js

@@ -1,31 +0,0 @@
-var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
-    if (typeof path === "string" && /^\.\.?\//.test(path)) {
-        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
-            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
-        });
-    }
-    return path;
-};
-// SPDX-License-Identifier: Apache-2.0
-// Classes from the ground's own origin. A module at a path under the
-// origin exports `steward`, and `public` and `beings` where it has them, as
-// `ClassList` takes them. A path that resolves off the origin is refused,
-// as a folder of code on a NodeGround stays inside its folder. A service
-// worker may not `import()`, so there the worker's own build hands a
-// loader that answers the same paths from modules it imported itself.
-import { ClassList } from '../bodies/class-list.js';
-export const OriginClasses = Object.freeze({
-    /** The classes of the module at `at`, resolved against `origin`, loaded once. */
-    async open(at, origin, load = (href) => import(__rewriteRelativeImportExtension(href))) {
-        const base = new URL(origin.endsWith('/') ? origin : `${origin}/`);
-        const url = new URL(at, base);
-        if (url.origin !== base.origin || !url.href.startsWith(base.href))
-            throw new Error(`the code at ${at} stands off ${base.href}`);
-        const module = (await load(url.href));
-        if (module.steward === undefined)
-            throw new Error(`${url.href} exports no steward`);
-        if (module.beings !== undefined && !Array.isArray(module.beings))
-            throw new Error(`${url.href} exports beings that are not a list`);
-        return new ClassList({ steward: module.steward, ...(module.public === undefined ? {} : { public: module.public }), ...(module.beings === undefined ? {} : { beings: module.beings }) });
-    },
-});

package/dist/edge/durable-clock.d.ts

@@ -1,19 +0,0 @@
-import type { Clock } from '../foundation.ts';
-import type { DurableStorage } from './durable.ts';
-export declare class DurableClock implements Clock {
-    #private;
-    constructor(storage: DurableStorage);
-    now(): number;
-    wait({ id, ms }: {
-        id: string;
-        ms: number;
-    }): Promise<boolean>;
-    cancel({ id }: {
-        id: string;
-    }): void;
-    /**
-     * The object's alarm fired: every wait due ends, and the alarm is set for
-     * the next. The Durable Object's `alarm()` calls it.
-     */
-    alarm(): Promise<void>;
-}

package/dist/edge/durable-clock.js

@@ -1,61 +0,0 @@
-export class DurableClock {
-    #storage;
-    #waits = new Map();
-    // The alarm as this clock last set or read it; `undefined` until it knows.
-    #armed;
-    #turn = Promise.resolve();
-    constructor(storage) {
-        this.#storage = storage;
-    }
-    now() {
-        return Date.now();
-    }
-    wait({ id, ms }) {
-        this.cancel({ id });
-        const at = Date.now() + Math.max(0, ms);
-        const waited = new Promise((resolve) => this.#waits.set(id, { at, resolve }));
-        // Storage that refuses the alarm leaves the wait to the next wake, as an eviction would.
-        this.#arm(at).catch(() => undefined);
-        return waited;
-    }
-    cancel({ id }) {
-        const held = this.#waits.get(id);
-        if (held === undefined)
-            return;
-        this.#waits.delete(id);
-        held.resolve(false);
-    }
-    /**
-     * The object's alarm fired: every wait due ends, and the alarm is set for
-     * the next. The Durable Object's `alarm()` calls it.
-     */
-    async alarm() {
-        this.#armed = null;
-        const now = Date.now();
-        let next;
-        for (const [id, { at, resolve }] of this.#waits) {
-            if (at > now) {
-                next = next === undefined ? at : Math.min(next, at);
-                continue;
-            }
-            this.#waits.delete(id);
-            resolve(true);
-        }
-        if (next !== undefined)
-            await this.#arm(next);
-    }
-    // The alarm moved earlier where `at` comes before it, and never later: a
-    // house of an earlier wake may still be owed the time it set.
-    #arm(at) {
-        const turn = this.#turn.then(async () => {
-            if (this.#armed === undefined)
-                this.#armed = await this.#storage.getAlarm();
-            if (this.#armed !== null && this.#armed <= at)
-                return;
-            this.#armed = at;
-            await this.#storage.setAlarm(at);
-        });
-        this.#turn = turn.catch(() => undefined);
-        return turn;
-    }
-}

package/dist/edge/durable-memory.d.ts

@@ -1,5 +0,0 @@
-import { KeptMemory } from '../bodies/kept.ts';
-import { type DurableStorage } from './durable.ts';
-export declare class DurableMemory extends KeptMemory {
-    constructor(storage: DurableStorage, name: string);
-}

package/dist/edge/durable-memory.js

@@ -1,11 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// An edge's memory: Durable Object storage, one memory for each name. The
-// object runs one event at a time and a write is one transaction, so a
-// write whose places moved lands nothing.
-import { KeptMemory } from '../bodies/kept.js';
-import { durableStore } from './durable.js';
-export class DurableMemory extends KeptMemory {
-    constructor(storage, name) {
-        super(durableStore(storage), name);
-    }
-}

package/dist/edge/durable.d.ts

@@ -1,18 +0,0 @@
-import type { Store } from '../bodies/kept.ts';
-/** A transaction on Durable Object storage: every write in it lands together, or none. */
-export interface DurableTransaction {
-    get(key: string): Promise<unknown>;
-    put(entries: Record<string, unknown>): Promise<void>;
-    delete(keys: string[]): Promise<number>;
-}
-/** A Durable Object's storage: `ctx.storage` in a Worker. */
-export interface DurableStorage extends DurableTransaction {
-    list(options: {
-        prefix: string;
-    }): Promise<Map<string, unknown>>;
-    transaction<T>(closure: (transaction: DurableTransaction) => Promise<T>): Promise<T>;
-    getAlarm(): Promise<number | null>;
-    setAlarm(at: number): Promise<void>;
-}
-/** A store of text over Durable Object storage, whose swap is one transaction. */
-export declare const durableStore: (storage: DurableStorage) => Store;

package/dist/edge/durable.js

@@ -1,24 +0,0 @@
-const BATCH = 128;
-/** A store of text over Durable Object storage, whose swap is one transaction. */
-export const durableStore = (storage) => ({
-    get: async (key) => {
-        const value = await storage.get(key);
-        return typeof value === 'string' ? value : null;
-    },
-    keys: async (prefix) => [...(await storage.list({ prefix })).keys()],
-    swap: (writes, expect) => storage.transaction(async (transaction) => {
-        for (const [key, value] of Object.entries(expect)) {
-            const held = await transaction.get(key);
-            if ((typeof held === 'string' ? held : null) !== value)
-                return false;
-        }
-        const put = Object.entries(writes).filter((entry) => entry[1] !== null);
-        const gone = Object.entries(writes).flatMap(([key, value]) => (value === null ? [key] : []));
-        // The platform takes at most this many keys in one call; the transaction still lands them together.
-        for (let at = 0; at < put.length; at += BATCH)
-            await transaction.put(Object.fromEntries(put.slice(at, at + BATCH)));
-        for (let at = 0; at < gone.length; at += BATCH)
-            await transaction.delete(gone.slice(at, at + BATCH));
-        return true;
-    }),
-});

package/dist/edge/edge-ground.d.ts

@@ -1,49 +0,0 @@
-import type { BeingClass } from '../foundation.ts';
-import { type Registry } from '../ground/ground.ts';
-import type { DurableStorage } from './durable.ts';
-import { type Connect } from './socket-carry.ts';
-/** A house's code as the deploy bundles it: what a folder's entry exports. */
-export interface Code {
-    readonly steward: BeingClass;
-    readonly public?: BeingClass;
-    readonly beings?: readonly BeingClass[];
-}
-export interface EdgeGroundOptions {
-    /** The deploy's own registry, which joins the terrain's as the ladder's first rung. */
-    readonly registry?: Registry;
-    /** Each house's code by the name its entry's `bundle` body gives in `at`. */
-    readonly code?: Readonly<Record<string, Code>>;
-    /** The platform's outbound sockets, `connect` from `cloudflare:sockets`; an edge without it dials the web alone. */
-    readonly connect?: Connect;
-}
-/** What the platform hands the object: its storage, and the hibernating WebSockets it accepts. */
-export interface DurableState {
-    readonly storage: DurableStorage;
-    acceptWebSocket(socket: unknown): void;
-}
-/** The ground's Durable Object, as the platform calls it. */
-export interface EdgeObject {
-    fetch(request: Request): Promise<Response>;
-    webSocketMessage(socket: unknown, message: string | ArrayBuffer): Promise<void>;
-    webSocketClose(socket: unknown): Promise<void>;
-    webSocketError(socket: unknown): Promise<void>;
-    alarm(): Promise<void>;
-}
-export declare const EdgeGround: Readonly<{
-    /**
-     * The ground's Durable Object class, which the Worker's module exports
-     * under the name its binding gives. The Worker's environment holds what
-     * opens its drawer and its hand, and nothing else: `NERVUR_SECRET`, the
-     * ground's key, sixty-four hex digits, and `NERVUR_HAND`, the key of its
-     * hand, both set as secrets. Every other setting is an entry in the
-     * drawer.
-     */
-    object({ registry, code, connect }?: EdgeGroundOptions): new (state: DurableState, env: Readonly<Record<string, unknown>>) => EdgeObject;
-    /** The Worker: every request goes to the ground's one object, by the binding's name. */
-    worker({ binding, name }?: {
-        binding?: string;
-        name?: string;
-    }): {
-        fetch(request: Request, env: Readonly<Record<string, unknown>>): Promise<Response>;
-    };
-}>;