@observablehq/notebook-kit 1.0.1 → 1.1.0-rc.10

package/dist/src/runtime/index.d.ts

@@ -1,11 +1,110 @@
 import type { Module } from "@observablehq/runtime";
 import { Runtime } from "@observablehq/runtime";
+import type { DefineState, Definition } from "./define.js";
+import type { observe } from "./display.js";
 import { fileAttachments } from "./stdlib/fileAttachment.js";
-export * from "./define.js";
+export type { DefineState, Definition } from "./define.js";
 export * from "./display.js";
 export * from "./inspect.js";
 export * from "./stdlib/index.js";
+export type * from "./stdlib/databaseClient.js";
+export { DatabaseClient } from "./stdlib/databaseClient.js";
+export type * from "./stdlib/fileAttachment.js";
+export { FileAttachment, registerFile } from "./stdlib/fileAttachment.js";
+export declare class NotebookRuntime {
+    readonly runtime: Runtime & {
+        fileAttachments: typeof fileAttachments;
+    };
+    readonly main: Module;
+    constructor(builtins?: {
+        aapl: () => Promise<any>;
+        alphabet: () => Promise<any>;
+        cars: () => Promise<any>;
+        citywages: () => Promise<any>;
+        diamonds: () => Promise<any>;
+        flare: () => Promise<any>;
+        industries: () => Promise<any>;
+        miserables: () => Promise<any>;
+        olympians: () => Promise<any>;
+        penguins: () => Promise<any>;
+        pizza: () => Promise<any>;
+        weather: () => Promise<any>;
+        _: () => Promise<any>;
+        aq: () => Promise<any>;
+        Arrow: () => Promise<any>;
+        d3: () => Promise<any>;
+        dot: () => Promise<import("./stdlib/template.js").RawTemplateRenderer>;
+        duckdb: () => Promise<any>;
+        DuckDBClient: () => Promise<typeof import("./stdlib/duckdb.js").DuckDBClient>;
+        echarts: () => Promise<any>;
+        htl: () => Promise<any>;
+        html: () => Promise<any>;
+        svg: () => Promise<any>;
+        Inputs: () => Promise<typeof import("./stdlib/inputs.js")>;
+        L: () => Promise<typeof import("./stdlib/leaflet.js")>;
+        mapboxgl: () => Promise<any>;
+        md: () => Promise<import("./stdlib/template.js").TemplateRenderer>;
+        mermaid: () => Promise<import("./stdlib/template.js").AsyncRawTemplateRenderer>;
+        Plot: () => Promise<any>;
+        React: () => Promise<any>;
+        ReactDOM: () => Promise<any>;
+        tex: () => Promise<import("./stdlib/template.js").RawTemplateRenderer & {
+            options: (options?: any) => import("./stdlib/template.js").RawTemplateRenderer;
+            block: import("./stdlib/template.js").RawTemplateRenderer;
+        }>;
+        topojson: () => Promise<any>;
+        vl: () => Promise<any>;
+        now: () => AsyncGenerator<number, void, unknown>;
+        width: () => AsyncGenerator<number, void, unknown>;
+        DatabaseClient: () => {
+            (name: string, options?: import("./stdlib/databaseClient.js").QueryOptionsSpec): import("./stdlib/databaseClient.js").DatabaseClient;
+            revive: ({ rows, schema, date, ...meta }: import("../databases/index.js").SerializableQueryResult) => import("./stdlib/databaseClient.js").QueryResult;
+            prototype: {
+                readonly name: string;
+                readonly options: import("./stdlib/databaseClient.js").QueryOptions;
+                sql(strings: readonly string[], ...params: import("./stdlib/databaseClient.js").QueryParam[]): Promise<import("./stdlib/databaseClient.js").QueryResult>;
+                cachePath(strings: readonly string[], ...params: import("./stdlib/databaseClient.js").QueryParam[]): Promise<string>;
+            };
+        };
+        FileAttachment: () => {
+            (name: string, base?: string): import("./stdlib/fileAttachment.js").FileAttachment;
+            prototype: {
+                href: string;
+                name: string;
+                mimeType: string;
+                lastModified: number | undefined;
+                size: number | undefined;
+                url(): Promise<string>;
+                blob(): Promise<Blob>;
+                arrayBuffer(): Promise<ArrayBuffer>;
+                text(encoding?: string): Promise<string>;
+                json(): Promise<any>;
+                stream(): Promise<ReadableStream<Uint8Array<ArrayBufferLike>>>;
+                dsv({ delimiter, array, typed }?: {
+                    delimiter?: string | undefined;
+                    array?: boolean | undefined;
+                    typed?: boolean | undefined;
+                }): Promise<import("./stdlib/fileAttachment.js").DsvResult>;
+                csv(options?: Omit<import("./stdlib/fileAttachment.js").DsvOptions, "delimiter">): Promise<import("./stdlib/fileAttachment.js").DsvResult>;
+                tsv(options?: Omit<import("./stdlib/fileAttachment.js").DsvOptions, "delimiter">): Promise<import("./stdlib/fileAttachment.js").DsvResult>;
+                image(props?: Partial<HTMLImageElement>): Promise<HTMLImageElement>;
+                arrow(): Promise<any>;
+                arquero(options?: any): Promise<any>;
+                parquet(): Promise<any>;
+                xml(mimeType?: DOMParserSupportedType): Promise<Document>;
+                html(): Promise<Document>;
+            };
+        };
+        Generators: () => typeof import("./stdlib/generators/index.js");
+        Mutable: () => typeof import("./stdlib/mutable.js").Mutable;
+        DOM: () => typeof import("./stdlib/dom/index.js");
+        require: () => typeof import("./stdlib/require.js").require;
+        __ojs_observer: () => () => import("./stdlib/observer.js").Observer;
+    });
+    define(state: DefineState, definition: Definition, observer?: typeof observe): void;
+}
 export declare const runtime: Runtime & {
     fileAttachments: typeof fileAttachments;
 };
 export declare const main: Module;
+export declare const define: (state: DefineState, definition: Definition, observer?: typeof observe) => void;

package/dist/src/runtime/index.js

@@ -1,12 +1,38 @@
 import { Runtime } from "@observablehq/runtime";
+import { define as _define } from "./define.js";
 import { fileAttachments } from "./stdlib/fileAttachment.js";
 import { library } from "./stdlib/index.js";
-export * from "./define.js";
 export * from "./display.js";
 export * from "./inspect.js";
 export * from "./stdlib/index.js";
-export const runtime = Object.assign(new Runtime({ ...library, __ojs_runtime: () => runtime }), { fileAttachments });
-export const main = runtime.main = runtime.module();
+export { DatabaseClient } from "./stdlib/databaseClient.js";
+export { FileAttachment, registerFile } from "./stdlib/fileAttachment.js";
+export class NotebookRuntime {
+    constructor(builtins = library) {
+        Object.defineProperty(this, "runtime", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "main", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        const runtime = new Runtime({ ...builtins, __ojs_runtime: () => runtime });
+        this.runtime = Object.assign(runtime, { fileAttachments });
+        this.main = runtime.module();
+    }
+    define(state, definition, observer) {
+        _define(this.main, state, definition, observer);
+    }
+}
+const defaultNotebook = new NotebookRuntime();
+export const runtime = defaultNotebook.runtime;
+export const main = defaultNotebook.main;
+export const define = defaultNotebook.define.bind(defaultNotebook);
 main.constructor.prototype.defines = function (name) {
     return (this._scope.has(name) ||
         this._builtins.has(name) ||

package/dist/src/runtime/stdlib/databaseClient.d.ts

@@ -0,0 +1,45 @@
+import type { SerializableQueryResult } from "../../databases/index.js";
+/** A serializable value that can be interpolated into a query. */
+export type QueryParam = any;
+/** @see https://observablehq.com/@observablehq/database-client-specification#%C2%A71 */
+export type QueryResult = Record<string, any>[] & {
+    schema: ColumnSchema[];
+    date: Date;
+};
+/** @see https://observablehq.com/@observablehq/database-client-specification#%C2%A72.2 */
+export interface ColumnSchema {
+    /** The name of the column. */
+    name: string;
+    /** The type of the column. */
+    type: "string" | "number" | "integer" | "bigint" | "date" | "boolean" | "object" | "array" | "buffer" | "other";
+    /** If present, the nullability of the column is known. */
+    nullable?: boolean;
+}
+export interface QueryOptionsSpec {
+    /** if present, the id of the cell that owns this database client */
+    id?: number;
+    /** if present, query results are at least as fresh as the specified date */
+    since?: Date | string | number;
+}
+export interface QueryOptions extends QueryOptionsSpec {
+    since?: Date;
+}
+export interface DatabaseClient {
+    readonly name: string;
+    readonly options: QueryOptions;
+    sql(strings: readonly string[], ...params: QueryParam[]): Promise<QueryResult>;
+}
+export declare const DatabaseClient: {
+    (name: string, options?: QueryOptionsSpec): DatabaseClient;
+    revive: typeof revive;
+    prototype: DatabaseClientImpl;
+};
+declare class DatabaseClientImpl implements DatabaseClient {
+    readonly name: string;
+    readonly options: QueryOptions;
+    constructor(name: string, options: QueryOptions);
+    sql(strings: readonly string[], ...params: QueryParam[]): Promise<QueryResult>;
+    cachePath(strings: readonly string[], ...params: QueryParam[]): Promise<string>;
+}
+declare function revive({ rows, schema, date, ...meta }: SerializableQueryResult): QueryResult;
+export {};

package/dist/src/runtime/stdlib/databaseClient.js

@@ -0,0 +1,77 @@
+import { hash, nameHash } from "../../lib/hash.js";
+export const DatabaseClient = (name, options) => {
+    return new DatabaseClientImpl(name, normalizeOptions(options));
+};
+function normalizeOptions({ id, since } = {}) {
+    const options = {};
+    if (id !== undefined)
+        options.id = id;
+    if (since !== undefined)
+        options.since = new Date(since);
+    return options;
+}
+class DatabaseClientImpl {
+    constructor(name, options) {
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperties(this, {
+            name: { value: name, enumerable: true },
+            options: { value: options, enumerable: true }
+        });
+    }
+    async sql(strings, ...params) {
+        const path = await this.cachePath(strings, ...params);
+        const response = await fetch(path);
+        if (!response.ok)
+            throw new Error(`failed to fetch: ${path}`);
+        return await response.json().then(revive);
+    }
+    async cachePath(strings, ...params) {
+        return `.observable/cache/${await nameHash(this.name)}-${await hash(strings, ...params)}.json`;
+    }
+}
+function revive({ rows, schema, date, ...meta }) {
+    for (const column of schema) {
+        switch (column.type) {
+            case "bigint": {
+                const { name } = column;
+                for (const row of rows) {
+                    const value = row[name];
+                    if (value == null)
+                        continue;
+                    row[name] = Number(value); // TODO BigInt?
+                }
+                break;
+            }
+            case "date": {
+                const { name } = column;
+                for (const row of rows) {
+                    const value = row[name];
+                    if (value == null)
+                        continue;
+                    row[name] = asDate(value);
+                }
+                break;
+            }
+        }
+    }
+    if (date != null)
+        date = new Date(date);
+    return Object.assign(rows, { schema, date }, meta);
+}
+function asDate(value) {
+    return new Date(/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}(?::\d{2})?$/.test(value) ? value + "Z" : value);
+}
+DatabaseClient.revive = revive;
+DatabaseClient.prototype = DatabaseClientImpl.prototype; // instanceof
+Object.defineProperty(DatabaseClientImpl, "name", { value: "DatabaseClient" }); // prevent mangling

package/dist/src/runtime/stdlib/duckdb.js

@@ -29,12 +29,12 @@ import * as duckdb from "npm:@duckdb/duckdb-wasm";
 // POSSIBILITY OF SUCH DAMAGE.
 const bundles = {
     mvp: {
-        mainModule: "https://cdn.jsdelivr.net/npm/@duckdb/duckdb-wasm/dist/duckdb-mvp.wasm",
-        mainWorker: "https://cdn.jsdelivr.net/npm/@duckdb/duckdb-wasm/dist/duckdb-browser-mvp.worker.js"
+        mainModule: "https://cdn.jsdelivr.net/npm/@duckdb/duckdb-wasm@1.29.0/dist/duckdb-mvp.wasm",
+        mainWorker: "https://cdn.jsdelivr.net/npm/@duckdb/duckdb-wasm@1.29.0/dist/duckdb-browser-mvp.worker.js"
     },
     eh: {
-        mainModule: "https://cdn.jsdelivr.net/npm/@duckdb/duckdb-wasm/dist/duckdb-eh.wasm",
-        mainWorker: "https://cdn.jsdelivr.net/npm/@duckdb/duckdb-wasm/dist/duckdb-browser-eh.worker.js"
+        mainModule: "https://cdn.jsdelivr.net/npm/@duckdb/duckdb-wasm@1.29.0/dist/duckdb-eh.wasm",
+        mainWorker: "https://cdn.jsdelivr.net/npm/@duckdb/duckdb-wasm@1.29.0/dist/duckdb-browser-eh.worker.js"
     }
 };
 const bundle = duckdb.selectBundle(bundles);
@@ -150,6 +150,9 @@ export class DuckDBClient {
     }
     static async of(sources = {}, config = {}) {
         const db = await createDuckDB();
+        if (config.query?.castDecimalToDouble === undefined) {
+            config = { ...config, query: { ...config.query, castDecimalToDouble: true } };
+        }
         if (config.query?.castTimestampToDate === undefined) {
             config = { ...config, query: { ...config.query, castTimestampToDate: true } };
         }

package/dist/src/runtime/stdlib/fileAttachment.d.ts

@@ -3,35 +3,62 @@ export type DsvOptions = {
     array?: boolean;
     typed?: boolean;
 };
-export type DsvResult = any[] & {
+export type DsvResult = (Record<string, any>[] | any[][]) & {
     columns: string[];
 };
 export interface FileAttachment {
+    /** The URL of the file. */
+    href: string;
+    /** The name of the file (not including the path), such as "test.csv". */
     name: string;
+    /** The MIME type, such as "text/csv". */
     mimeType: string;
-    href: string;
-    lastModified: number | undefined;
-    size: number | undefined;
+    /** The time this file was most-recently modified, as milliseconds since epoch, if known. */
+    lastModified?: number;
+    /** The size of this file in bytes, if known. */
+    size?: number;
+    /** @deprecated use FileAttachment.href instead */
     url(): Promise<string>;
+    /** Returns the contents of this file as a Blob. */
     blob(): Promise<Blob>;
+    /** Returns the contents of this file as an ArrayBuffer. */
     arrayBuffer(): Promise<ArrayBuffer>;
+    /** Returns the contents of this file as a string with the given encoding. */
     text(encoding?: string): Promise<string>;
+    /** Returns the contents of this file as JSON. */
     json(): Promise<any>;
+    /** Returns a byte stream to the contents of this file. */
     stream(): Promise<ReadableStream<Uint8Array<ArrayBufferLike>>>;
+    /** Returns the contents of this file as delimiter-separated values. */
     dsv(options?: DsvOptions): Promise<DsvResult>;
-    csv(options?: Exclude<DsvOptions, "delimiter">): Promise<DsvResult>;
-    tsv(options?: Exclude<DsvOptions, "delimiter">): Promise<DsvResult>;
+    /** Returns the contents of this file as comma-separated values. */
+    csv(options?: Omit<DsvOptions, "delimiter">): Promise<DsvResult>;
+    /** Returns the contents of this file as tab-separated values. */
+    tsv(options?: Omit<DsvOptions, "delimiter">): Promise<DsvResult>;
+    /** Returns the contents of this file as an image. */
     image(props?: Partial<HTMLImageElement>): Promise<HTMLImageElement>;
+    /** Returns the contents of this Arrow IPC file as an Apache Arrow table. */
     arrow(): Promise<any>;
+    /** Returns the contents of this file as an Arquero table. */
     arquero(options?: any): Promise<any>;
+    /** Returns the contents of this Parquet file as an Apache Arrow table. */
     parquet(): Promise<any>;
+    /** Returns the contents of this file as an XML document. */
     xml(mimeType?: DOMParserSupportedType): Promise<Document>;
+    /** Returns the contents of this file as an HTML document. */
     html(): Promise<Document>;
 }
-export declare function FileAttachment(name: string, base?: string): FileAttachment;
-export declare namespace FileAttachment {
-    var prototype: FileAttachmentImpl;
+export declare const FileAttachment: {
+    (name: string, base?: string): FileAttachment;
+    prototype: FileAttachmentImpl;
+};
+export interface FileInfo {
+    path: string;
+    mimeType?: string;
+    lastModified?: number;
+    size?: number;
 }
+export declare function registerFile(name: string, info: FileInfo, base?: string | URL): FileAttachmentImpl | undefined;
 export declare abstract class AbstractFile implements FileAttachment {
     name: string;
     mimeType: string;
@@ -50,8 +77,8 @@ export declare abstract class AbstractFile implements FileAttachment {
         array?: boolean | undefined;
         typed?: boolean | undefined;
     }): Promise<DsvResult>;
-    csv(options: Exclude<DsvOptions, "delimiter">): Promise<DsvResult>;
-    tsv(options: Exclude<DsvOptions, "delimiter">): Promise<DsvResult>;
+    csv(options?: Omit<DsvOptions, "delimiter">): Promise<DsvResult>;
+    tsv(options?: Omit<DsvOptions, "delimiter">): Promise<DsvResult>;
     image(props?: Partial<HTMLImageElement>): Promise<HTMLImageElement>;
     arrow(): Promise<any>;
     arquero(options?: any): Promise<any>;

package/dist/src/runtime/stdlib/fileAttachment.js

@@ -1,8 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 const files = new Map();
-export function FileAttachment(name, base = document.baseURI) {
-    if (new.target !== undefined)
-        throw new TypeError("FileAttachment is not a constructor");
+// TODO Enforce that files have been registered; throw error if not found.
+export const FileAttachment = (name, base = document.baseURI) => {
     const href = new URL(name, base).href;
     let file = files.get(href);
     if (!file) {
@@ -10,8 +9,20 @@ export function FileAttachment(name, base = document.baseURI) {
         files.set(href, file);
     }
     return file;
+};
+export function registerFile(name, info, base = location.href) {
+    const href = new URL(name, base).href;
+    if (info == null) {
+        files.delete(href);
+    }
+    else {
+        const { path, mimeType, lastModified, size } = info;
+        const file = new FileAttachmentImpl(new URL(path, base).href, name.split("/").pop(), mimeType, lastModified, size);
+        files.set(href, file);
+        return file;
+    }
 }
-async function remote_fetch(file) {
+async function fetchFile(file) {
     const response = await fetch(file.href);
     if (!response.ok)
         throw new Error(`Unable to load file: ${file.name}`);
@@ -54,21 +65,21 @@ export class AbstractFile {
         return this.href;
     }
     async blob() {
-        return (await remote_fetch(this)).blob();
+        return (await fetchFile(this)).blob();
     }
     async arrayBuffer() {
-        return (await remote_fetch(this)).arrayBuffer();
+        return (await fetchFile(this)).arrayBuffer();
     }
     async text(encoding) {
         return encoding === undefined
-            ? (await remote_fetch(this)).text()
+            ? (await fetchFile(this)).text()
             : new TextDecoder(encoding).decode(await this.arrayBuffer());
     }
     async json() {
-        return (await remote_fetch(this)).json();
+        return (await fetchFile(this)).json();
     }
     async stream() {
-        return (await remote_fetch(this)).body;
+        return (await fetchFile(this)).body;
     }
     async dsv({ delimiter = ",", array = false, typed = false } = {}) {
         const [text, d3] = await Promise.all([this.text(), import("npm:d3-dsv")]);
@@ -95,7 +106,7 @@ export class AbstractFile {
         });
     }
     async arrow() {
-        const [Arrow, response] = await Promise.all([import("npm:apache-arrow"), remote_fetch(this)]);
+        const [Arrow, response] = await Promise.all([import("npm:apache-arrow"), fetchFile(this)]);
         return Arrow.tableFromIPC(response);
     }
     async arquero(options) {

package/dist/src/runtime/stdlib/generators/input.d.ts

@@ -1 +1 @@
-export declare function input(element: Element): AsyncGenerator<string | number | boolean | string[] | Date | File | FileList | null, void, unknown>;
+export declare function input(element: Element): AsyncGenerator<string | number | boolean | string[] | Date | FileList | File | null, void, unknown>;

package/dist/src/runtime/stdlib/index.d.ts

@@ -1,10 +1,10 @@
-import { Mutable } from "./mutable.js";
-import * as Generators from "./generators/index.js";
-import { FileAttachment } from "./fileAttachment.js";
+import { DatabaseClient } from "./databaseClient.js";
 import * as DOM from "./dom/index.js";
+import { FileAttachment } from "./fileAttachment.js";
+import * as Generators from "./generators/index.js";
+import { Mutable } from "./mutable.js";
 import { Observer } from "./observer.js";
 import { require } from "./require.js";
-import { __sql } from "./sql.js";
 export declare const root: HTMLElement;
 export declare const library: {
     aapl: () => Promise<any>;
@@ -46,11 +46,48 @@ export declare const library: {
     vl: () => Promise<any>;
     now: () => AsyncGenerator<number, void, unknown>;
     width: () => AsyncGenerator<number, void, unknown>;
-    FileAttachment: () => typeof FileAttachment;
+    DatabaseClient: () => {
+        (name: string, options?: import("./databaseClient.js").QueryOptionsSpec): DatabaseClient;
+        revive: ({ rows, schema, date, ...meta }: import("../../databases/index.js").SerializableQueryResult) => import("./databaseClient.js").QueryResult;
+        prototype: {
+            readonly name: string;
+            readonly options: import("./databaseClient.js").QueryOptions;
+            sql(strings: readonly string[], ...params: import("./databaseClient.js").QueryParam[]): Promise<import("./databaseClient.js").QueryResult>;
+            cachePath(strings: readonly string[], ...params: import("./databaseClient.js").QueryParam[]): Promise<string>;
+        };
+    };
+    FileAttachment: () => {
+        (name: string, base?: string): FileAttachment;
+        prototype: {
+            href: string;
+            name: string;
+            mimeType: string;
+            lastModified: number | undefined;
+            size: number | undefined;
+            url(): Promise<string>;
+            blob(): Promise<Blob>;
+            arrayBuffer(): Promise<ArrayBuffer>;
+            text(encoding?: string): Promise<string>;
+            json(): Promise<any>;
+            stream(): Promise<ReadableStream<Uint8Array<ArrayBufferLike>>>;
+            dsv({ delimiter, array, typed }?: {
+                delimiter?: string | undefined;
+                array?: boolean | undefined;
+                typed?: boolean | undefined;
+            }): Promise<import("./fileAttachment.js").DsvResult>;
+            csv(options?: Omit<import("./fileAttachment.js").DsvOptions, "delimiter">): Promise<import("./fileAttachment.js").DsvResult>;
+            tsv(options?: Omit<import("./fileAttachment.js").DsvOptions, "delimiter">): Promise<import("./fileAttachment.js").DsvResult>;
+            image(props?: Partial<HTMLImageElement>): Promise<HTMLImageElement>;
+            arrow(): Promise<any>;
+            arquero(options?: any): Promise<any>;
+            parquet(): Promise<any>;
+            xml(mimeType?: DOMParserSupportedType): Promise<Document>;
+            html(): Promise<Document>;
+        };
+    };
     Generators: () => typeof Generators;
     Mutable: () => typeof Mutable;
     DOM: () => typeof DOM;
     require: () => typeof require;
-    __sql: () => typeof __sql;
     __ojs_observer: () => () => Observer;
 };

package/dist/src/runtime/stdlib/index.js

@@ -1,22 +1,22 @@
-import { Mutable } from "./mutable.js";
-import * as Generators from "./generators/index.js";
-import { FileAttachment } from "./fileAttachment.js";
+import { DatabaseClient } from "./databaseClient.js";
 import * as DOM from "./dom/index.js";
+import { FileAttachment } from "./fileAttachment.js";
+import * as Generators from "./generators/index.js";
+import { Mutable } from "./mutable.js";
 import { Observer } from "./observer.js";
 import * as recommendedLibraries from "./recommendedLibraries.js";
 import { require } from "./require.js";
 import * as sampleDatasets from "./sampleDatasets.js";
-import { __sql } from "./sql.js";
 export const root = document.querySelector("main") ?? document.body;
 export const library = {
     now: () => Generators.now(),
     width: () => Generators.width(root),
+    DatabaseClient: () => DatabaseClient,
     FileAttachment: () => FileAttachment,
     Generators: () => Generators,
     Mutable: () => Mutable,
     DOM: () => DOM, // deprecated!
     require: () => require, // deprecated!
-    __sql: () => __sql,
     __ojs_observer: () => () => new Observer(),
     ...recommendedLibraries,
     ...sampleDatasets

package/dist/src/styles/global.css

@@ -17,7 +17,7 @@ html {
   -moz-osx-font-smoothing: grayscale;
   background: var(--theme-background);
   color: var(--theme-foreground);
-  margin-top: 16px;
+  margin: 16px 0;
   padding: 16px 24px;
 }
 

package/dist/src/templates/default.html

@@ -5,24 +5,24 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <style type="text/css">
       @import url("observable:styles/index.css");
-      @import "@fontsource/spline-sans-mono/400.css";
-      @import "@fontsource/spline-sans-mono/600.css";
-      @import "@fontsource/spline-sans-mono/700.css";
-      @import "@fontsource/spline-sans-mono/400-italic.css";
-      @import "@fontsource/spline-sans-mono/600-italic.css";
-      @import "@fontsource/spline-sans-mono/700-italic.css";
-      @import "@fontsource/source-serif-4/400.css";
-      @import "@fontsource/source-serif-4/700.css";
-      @import "@fontsource/source-serif-4/400-italic.css";
-      @import "@fontsource/source-serif-4/700-italic.css";
-      @import "@fontsource/inter/400.css";
-      @import "@fontsource/inter/500.css";
-      @import "@fontsource/inter/600.css";
-      @import "@fontsource/inter/700.css";
-      @import "@fontsource/inter/400-italic.css";
-      @import "@fontsource/inter/500-italic.css";
-      @import "@fontsource/inter/600-italic.css";
-      @import "@fontsource/inter/700-italic.css";
+      @import url("@fontsource/spline-sans-mono/400.css");
+      @import url("@fontsource/spline-sans-mono/600.css");
+      @import url("@fontsource/spline-sans-mono/700.css");
+      @import url("@fontsource/spline-sans-mono/400-italic.css");
+      @import url("@fontsource/spline-sans-mono/600-italic.css");
+      @import url("@fontsource/spline-sans-mono/700-italic.css");
+      @import url("@fontsource/source-serif-4/400.css");
+      @import url("@fontsource/source-serif-4/700.css");
+      @import url("@fontsource/source-serif-4/400-italic.css");
+      @import url("@fontsource/source-serif-4/700-italic.css");
+      @import url("@fontsource/inter/400.css");
+      @import url("@fontsource/inter/500.css");
+      @import url("@fontsource/inter/600.css");
+      @import url("@fontsource/inter/700.css");
+      @import url("@fontsource/inter/400-italic.css");
+      @import url("@fontsource/inter/500-italic.css");
+      @import url("@fontsource/inter/600-italic.css");
+      @import url("@fontsource/inter/700-italic.css");
     </style>
   </head>
   <body>

package/dist/src/vite/config.js

@@ -1,10 +1,12 @@
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { resolveNpmImport } from "../javascript/imports/npm.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 export function config() {
     return {
         base: "./",
+        appType: "mpa", // return 404 for missing pages
         esbuild: {
             supported: {
                 "top-level-await": true
@@ -13,8 +15,9 @@ export function config() {
         resolve: {
             alias: [
                 {
-                    find: /^npm:(.*)$/,
-                    replacement: "https://cdn.jsdelivr.net/npm/$1/+esm"
+                    find: /^(npm:.*)$/,
+                    replacement: "$1",
+                    customResolver: (source) => ({ id: resolveNpmImport(source), external: true })
                 },
                 {
                     find: /^jsr:(.*)$/,