@inkandswitch/patchwork-bootloader 0.0.2 → 0.0.3

package/dist/externals.d.ts

@@ -0,0 +1,5 @@
+/**
+ * these dependencies will be built into the outdir, and injected into the importmap
+ */
+declare const externals: string[];
+export default externals;

package/dist/externals.js

@@ -0,0 +1,20 @@
+/**
+ * these dependencies will be built into the outdir, and injected into the importmap
+ */
+const externals = [
+    "@automerge/automerge",
+    "@automerge/automerge/slim",
+    "@automerge/automerge-repo",
+    "@automerge/automerge-repo/slim",
+    "@automerge/automerge-repo-keyhive",
+    "@keyhive/keyhive",
+    "@keyhive/keyhive/slim",
+    "@inkandswitch/patchwork-bootloader",
+    "@inkandswitch/patchwork-elements",
+    "@inkandswitch/patchwork-filesystem",
+    "@inkandswitch/patchwork-plugins",
+    // sad
+    "@codemirror/state",
+    "@codemirror/view",
+];
+export default externals;

package/dist/generate.d.ts

@@ -0,0 +1,170 @@
+import * as esbuild from "esbuild";
+export type ContextOptions = {
+    keyhiveEnabled: boolean;
+    syncServerUrl: string;
+    syncServerStorageId: string;
+    outdir?: string;
+    serviceWorkerPath?: string;
+    serviceWorkerType?: WorkerType;
+};
+export declare function getBuildOptions({ keyhiveEnabled, syncServerUrl: syncServer, syncServerStorageId: storageId, outdir, serviceWorkerPath, serviceWorkerType, }: ContextOptions): esbuild.BuildOptions;
+export default function createContext(contextOptions: ContextOptions): Promise<{
+    sw: esbuild.BuildContext<{
+        entryPoints: string[];
+        bundle: boolean;
+        format: "esm" | "iife";
+        sourcemap: false;
+        minify: true;
+        splitting?: boolean;
+        preserveSymlinks?: boolean;
+        outfile?: string;
+        metafile?: boolean;
+        outdir?: string;
+        outbase?: string;
+        external?: string[];
+        packages?: "bundle" | "external";
+        alias?: Record<string, string>;
+        loader?: {
+            [ext: string]: esbuild.Loader;
+        };
+        resolveExtensions?: string[];
+        mainFields?: string[];
+        conditions?: string[];
+        write?: boolean;
+        allowOverwrite?: boolean;
+        tsconfig?: string;
+        outExtension?: {
+            [ext: string]: string;
+        };
+        publicPath?: string;
+        entryNames?: string;
+        chunkNames?: string;
+        assetNames?: string;
+        inject?: string[];
+        banner?: {
+            [type: string]: string;
+        };
+        footer?: {
+            [type: string]: string;
+        };
+        stdin?: esbuild.StdinOptions;
+        plugins?: esbuild.Plugin[];
+        absWorkingDir?: string;
+        nodePaths?: string[];
+        legalComments?: "none" | "inline" | "eof" | "linked" | "external";
+        sourceRoot?: string;
+        sourcesContent?: boolean;
+        globalName?: string;
+        target?: string | string[];
+        supported?: Record<string, boolean>;
+        platform?: esbuild.Platform;
+        mangleProps?: RegExp;
+        reserveProps?: RegExp;
+        mangleQuoted?: boolean;
+        mangleCache?: Record<string, string | false>;
+        drop?: esbuild.Drop[];
+        dropLabels?: string[];
+        minifyWhitespace?: boolean;
+        minifyIdentifiers?: boolean;
+        minifySyntax?: boolean;
+        lineLimit?: number;
+        charset?: esbuild.Charset;
+        treeShaking?: boolean;
+        ignoreAnnotations?: boolean;
+        jsx?: "transform" | "preserve" | "automatic";
+        jsxFactory?: string;
+        jsxFragment?: string;
+        jsxImportSource?: string;
+        jsxDev?: boolean;
+        jsxSideEffects?: boolean;
+        define?: {
+            [key: string]: string;
+        };
+        pure?: string[];
+        keepNames?: boolean;
+        color?: boolean;
+        logLevel?: esbuild.LogLevel;
+        logLimit?: number;
+        logOverride?: Record<string, esbuild.LogLevel>;
+        tsconfigRaw?: string | esbuild.TsconfigRaw;
+    }>;
+    setup: esbuild.BuildContext<{
+        entryPoints: string[];
+        format: "esm";
+        bundle: false;
+        splitting?: boolean;
+        preserveSymlinks?: boolean;
+        outfile?: string;
+        metafile?: boolean;
+        outdir?: string;
+        outbase?: string;
+        external?: string[];
+        packages?: "bundle" | "external";
+        alias?: Record<string, string>;
+        loader?: {
+            [ext: string]: esbuild.Loader;
+        };
+        resolveExtensions?: string[];
+        mainFields?: string[];
+        conditions?: string[];
+        write?: boolean;
+        allowOverwrite?: boolean;
+        tsconfig?: string;
+        outExtension?: {
+            [ext: string]: string;
+        };
+        publicPath?: string;
+        entryNames?: string;
+        chunkNames?: string;
+        assetNames?: string;
+        inject?: string[];
+        banner?: {
+            [type: string]: string;
+        };
+        footer?: {
+            [type: string]: string;
+        };
+        stdin?: esbuild.StdinOptions;
+        plugins?: esbuild.Plugin[];
+        absWorkingDir?: string;
+        nodePaths?: string[];
+        sourcemap?: boolean | "linked" | "inline" | "external" | "both";
+        legalComments?: "none" | "inline" | "eof" | "linked" | "external";
+        sourceRoot?: string;
+        sourcesContent?: boolean;
+        globalName?: string;
+        target?: string | string[];
+        supported?: Record<string, boolean>;
+        platform?: esbuild.Platform;
+        mangleProps?: RegExp;
+        reserveProps?: RegExp;
+        mangleQuoted?: boolean;
+        mangleCache?: Record<string, string | false>;
+        drop?: esbuild.Drop[];
+        dropLabels?: string[];
+        minify?: boolean;
+        minifyWhitespace?: boolean;
+        minifyIdentifiers?: boolean;
+        minifySyntax?: boolean;
+        lineLimit?: number;
+        charset?: esbuild.Charset;
+        treeShaking?: boolean;
+        ignoreAnnotations?: boolean;
+        jsx?: "transform" | "preserve" | "automatic";
+        jsxFactory?: string;
+        jsxFragment?: string;
+        jsxImportSource?: string;
+        jsxDev?: boolean;
+        jsxSideEffects?: boolean;
+        define?: {
+            [key: string]: string;
+        };
+        pure?: string[];
+        keepNames?: boolean;
+        color?: boolean;
+        logLevel?: esbuild.LogLevel;
+        logLimit?: number;
+        logOverride?: Record<string, esbuild.LogLevel>;
+        tsconfigRaw?: string | esbuild.TsconfigRaw;
+    }>;
+}>;

package/dist/generate.js

@@ -0,0 +1,83 @@
+import * as esbuild from "esbuild";
+export function getBuildOptions({ keyhiveEnabled, syncServerUrl: syncServer, syncServerStorageId: storageId, outdir, serviceWorkerPath, serviceWorkerType, }) {
+    serviceWorkerType ||= "classic";
+    return {
+        absWorkingDir: import.meta.dirname,
+        outdir,
+        define: {
+            __CACHE_VERSION__: JSON.stringify(`cache-${new Date().toISOString()}`),
+            __SYNC_SERVER_URL__: JSON.stringify(syncServer),
+            __SYNC_SERVER_STORAGE_ID__: JSON.stringify(storageId),
+            __SERVICE_WORKER_PATH__: JSON.stringify(serviceWorkerPath || "/service-worker.js"),
+            __SERVICE_WORKER_TYPE__: JSON.stringify(serviceWorkerType),
+            __KEYHIVE_ENABLED__: `${keyhiveEnabled}`,
+        },
+    };
+}
+export default async function createContext(contextOptions) {
+    const sharedOptions = getBuildOptions(contextOptions);
+    const sw = await esbuild.context({
+        ...sharedOptions,
+        entryPoints: ["../template/service-worker/service-worker.ts"],
+        bundle: contextOptions.serviceWorkerType != "module",
+        format: contextOptions.serviceWorkerType == "module" ? "esm" : "iife",
+        sourcemap: false,
+        minify: true,
+    });
+    const setup = await esbuild.context({
+        ...sharedOptions,
+        entryPoints: ["../template/client/setup.ts"],
+        format: "esm",
+        bundle: false,
+    });
+    return { sw, setup };
+}
+if (import.meta.main) {
+    const { parseArgs } = await import("node:util");
+    const { values: { keyhive, "sync-server": syncServer, "storage-id": storageId, outdir, watch, }, } = parseArgs({
+        args: process.argv.slice(2),
+        options: {
+            keyhive: {
+                type: "boolean",
+                default: false,
+                short: "k",
+            },
+            "sync-server": {
+                type: "string",
+            },
+            "storage-id": {
+                type: "string",
+            },
+            outdir: {
+                type: "string",
+                default: process.cwd(),
+                short: "o",
+            },
+            watch: {
+                type: "boolean",
+                default: false,
+                short: "w",
+            },
+        },
+    });
+    if (!syncServer || !storageId) {
+        throw new Error("--sync-server and --storage-id are required args");
+    }
+    const { sw, setup } = await createContext({
+        keyhiveEnabled: keyhive,
+        syncServerUrl: syncServer,
+        syncServerStorageId: storageId,
+        outdir,
+        serviceWorkerPath: "service-worker.js",
+    });
+    if (watch) {
+        await sw.watch();
+        await setup.watch();
+    }
+    else {
+        await sw.rebuild();
+        await setup.rebuild();
+        await sw.dispose();
+        await setup.dispose();
+    }
+}

package/dist/patchwork-vite-plugin.d.ts

@@ -0,0 +1,40 @@
+import type { Plugin } from "vite";
+type Imports = {
+    [name: string]: string;
+};
+type ImportMap = {
+    imports: Imports;
+    scopes?: {
+        [scope: string]: Imports;
+    };
+};
+export interface PatchworkVitePluginOptions {
+    /** the wss:// syncServer URL that'll be connected to in the service-worker */
+    syncServerUrl: string;
+    /** the storage id for the syncServer, subscribed to in the main thread */
+    syncServerStorageId: string;
+    /** extra importmap to be merged into the index.html */
+    importmap?: ImportMap;
+    extraBuiltins?: Record<string, string>;
+    /** currently unused */
+    serviceWorkerType?: "classic" | "module";
+    /** currently unused */
+    keyhiveEnabled?: boolean;
+}
+export default function patchwork(options: PatchworkVitePluginOptions): Plugin<any>[];
+/**
+ * these dependencies will be built into the outdir, and injected into the importmap
+ */
+export declare const defaultBuiltins: {
+    "@automerge/automerge": string;
+    "@automerge/automerge/slim": string;
+    "@automerge/automerge-repo": string;
+    "@automerge/automerge-repo/slim": string;
+    "@automerge/vanillajs": string;
+    "@automerge/vanillajs/slim": string;
+    "@keyhive/keyhive": string;
+    "@keyhive/keyhive/slim": string;
+    "@keyhive/keyhive/keyhive_wasm.base64.js": string;
+};
+export declare function plugin(options: PatchworkVitePluginOptions): Plugin;
+export {};

package/dist/patchwork-vite-plugin.js

@@ -0,0 +1,192 @@
+import * as esbuild from "esbuild";
+import { getBuildOptions } from "./generate.js";
+import * as path from "node:path";
+import { createReadStream } from "node:fs";
+export default function patchwork(options) {
+    return [plugin(options)];
+}
+/**
+ * these dependencies will be built into the outdir, and injected into the importmap
+ */
+export const defaultBuiltins = {
+    "@automerge/automerge": "/packages/@automerge/automerge/index.js",
+    "@automerge/automerge/slim": "/packages/@automerge/automerge/slim.js",
+    "@automerge/automerge-repo": "/packages/@automerge/automerge-repo/index.js",
+    "@automerge/automerge-repo/slim": "/packages/@automerge/automerge-repo/slim.js",
+    "@automerge/vanillajs": "/packages/@automerge/vanillajs/index.js",
+    "@automerge/vanillajs/slim": "/packages/@automerge/vanillajs/slim.js",
+    "@keyhive/keyhive": "/packages/@keyhive/keyhive/index.js",
+    "@keyhive/keyhive/slim": "/packages/@keyhive/keyhive/slim.js",
+    "@keyhive/keyhive/keyhive_wasm.base64.js": "/packages/@keyhive/keyhive/keyhive_wasm.base64.js",
+};
+async function generateJavaScript(options) {
+    const rb = await esbuild.build({
+        ...options,
+        write: false,
+        outdir: ".",
+    });
+    const code = rb.outputFiles?.find((x) => x.path.endsWith(".js"))?.text;
+    if (code)
+        return {
+            code,
+            map: ["external", false, undefined].includes(options.sourcemap)
+                ? // force vite not to generate a sourcemap for the service worker to reduce size
+                    { mappings: "", names: [], sources: [], version: 0 }
+                : undefined,
+        };
+}
+/**
+ * merge the importmap option with our builtins
+ */
+function createImportMap(options) {
+    const builtins = Object.assign({}, defaultBuiltins, options.extraBuiltins ?? {});
+    const importmap = structuredClone(options.importmap ?? { imports: {}, scopes: {} });
+    importmap.imports ??= {};
+    importmap.scopes ??= {};
+    Object.assign(importmap.imports, builtins);
+    return { importmap, builtins };
+}
+export function plugin(options) {
+    const { importmap, builtins } = createImportMap(options);
+    const serviceWorkerModuleId = "service-worker.js";
+    const serviceWorkerSource = path.resolve(import.meta.dirname, "../template/service-worker/service-worker.ts");
+    const automergeWasmSource = path.resolve(import.meta.dirname, "../node_modules/@automerge/automerge/dist/automerge.wasm");
+    // https://vite.dev/guide/api-plugin.html#importing-a-virtual-file
+    const patchworkSetupModuleId = "virtual:patchwork/setup";
+    const resolvedPatchworkSetupModuleId = "\0" + patchworkSetupModuleId;
+    const patchworkSetupSource = path.resolve(import.meta.dirname, "../template/client/setup.ts");
+    const sharedOptions = getBuildOptions({
+        keyhiveEnabled: Boolean(options.keyhiveEnabled),
+        syncServerStorageId: options.syncServerStorageId,
+        syncServerUrl: options.syncServerUrl,
+        serviceWorkerPath: serviceWorkerModuleId,
+    });
+    const serviceWorkerBuildOptions = {
+        ...sharedOptions,
+        entryPoints: [serviceWorkerSource],
+        bundle: options.serviceWorkerType != "module",
+        format: options.serviceWorkerType == "module" ? "esm" : "iife",
+        minify: true,
+        sourcemap: "external",
+    };
+    const patchworkSetupBuildOptions = {
+        ...sharedOptions,
+        format: "esm",
+        entryPoints: [patchworkSetupSource],
+        bundle: false,
+        sourcemap: true,
+    };
+    let viteBuildInfo;
+    function shouldPlaceholdKeyhive(id) {
+        // if keyhive is disabled,
+        // but the setup code is still importing keyhive,
+        // then we should emit an empty keyhive file so the build works
+        return ((!options.keyhiveEnabled && id.startsWith("@keyhive/")) ||
+            [
+                "@automerge/automerge-keyhive-network-adapter",
+                "@automerge/automerge-repo-keyhive",
+            ].includes(id));
+    }
+    return {
+        name: "@patchwork/vite",
+        async buildStart() {
+            if (this.environment.mode == "build") {
+                for (const [id, fileName] of Object.entries(builtins)) {
+                    if (shouldPlaceholdKeyhive(id)) {
+                        continue;
+                    }
+                    this.emitFile({
+                        type: "chunk",
+                        fileName: fileName.slice(1),
+                        id,
+                        preserveSignature: "strict",
+                    });
+                }
+                this.emitFile({
+                    type: "asset",
+                    fileName: "automerge.wasm",
+                    source: await this.fs.readFile(automergeWasmSource),
+                });
+            }
+        },
+        resolveId(id) {
+            if (id == `/${serviceWorkerModuleId}` || id == serviceWorkerModuleId) {
+                return serviceWorkerModuleId;
+            }
+            else if (id == patchworkSetupModuleId) {
+                return resolvedPatchworkSetupModuleId;
+            }
+            else if (shouldPlaceholdKeyhive(id)) {
+                return id;
+            }
+            else if (id in importmap.imports && !(id in builtins)) {
+                return { id: importmap.imports[id], external: true };
+            }
+        },
+        async load(id) {
+            if (id == resolvedPatchworkSetupModuleId) {
+                return generateJavaScript(patchworkSetupBuildOptions);
+            }
+            else if (id == serviceWorkerModuleId) {
+                return generateJavaScript(serviceWorkerBuildOptions);
+            }
+            else if (shouldPlaceholdKeyhive(id)) {
+                return "export default {}";
+            }
+        },
+        transformIndexHtml: {
+            order: "pre",
+            handler(html, ctx) {
+                const map = structuredClone(importmap);
+                if (ctx.server) {
+                    // serve builtins from dev server in dev
+                    // mode
+                    for (const id of Object.keys(builtins)) {
+                        map.imports[id] = `/@id/${id}`;
+                    }
+                }
+                return {
+                    html,
+                    tags: [
+                        {
+                            tag: "script",
+                            attrs: { type: "importmap" },
+                            children: JSON.stringify(map, null, 2),
+                        },
+                    ],
+                };
+            },
+        },
+        configResolved(config) {
+            viteBuildInfo = config.build;
+        },
+        configureServer: {
+            handler(server) {
+                server.middlewares.use((request, response, next) => {
+                    const url = new URL(request.url, "http://example.com");
+                    if (url.pathname == "/automerge.wasm") {
+                        response.setHeaders(new Headers({
+                            "content-type": "application/wasm",
+                        }));
+                        createReadStream(automergeWasmSource).pipe(response);
+                    }
+                    else {
+                        next();
+                    }
+                });
+            },
+        },
+        closeBundle: {
+            sequential: true,
+            async handler(error) {
+                if (error) {
+                    throw error;
+                }
+                await esbuild.build({
+                    ...serviceWorkerBuildOptions,
+                    outfile: path.resolve(viteBuildInfo.outDir, "service-worker.js"),
+                });
+            },
+        },
+    };
+}

package/dist/service-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/service-worker.js

@@ -0,0 +1,164 @@
+/// <reference types="service-worker-types" />
+let cachename = "default";
+let debugging = false;
+function log(...args) {
+    if (!debugging)
+        return;
+    console.log.call(console, `%cpatchwork:serviceworker%c\n`, `color: #00ffcc; font-weight: bold`, "color: inherit", ...args);
+}
+self.addEventListener("install", () => self.skipWaiting());
+async function clearOldCaches() {
+    const cacheWhitelist = [cachename];
+    const cacheNames = await caches.keys();
+    const deletePromises = cacheNames.map((cacheName) => {
+        if (!cacheWhitelist.includes(cacheName)) {
+            return caches.delete(cacheName);
+        }
+    });
+    await Promise.all(deletePromises);
+}
+self.addEventListener("activate", async () => {
+    await clearOldCaches();
+    clients.claim();
+});
+// a map of response promises by their id
+const responseResolvers = new Map();
+function accept(message) {
+    const responseItem = responseResolvers.get(message.id);
+    if (!responseItem) {
+        return console.warn(`No read response found for id ${message.id}`);
+    }
+    return responseItem.resolve(message.response);
+}
+const bc = new BroadcastChannel("@patchwork/handoff");
+bc.addEventListener("message", (event) => {
+    if (event.data.type == "response")
+        accept(event.data);
+});
+// when we receive a `response` req, we resolve the promise with that id
+self.addEventListener("message", async (event) => {
+    if (event.data.type == "response") {
+        accept(event.data);
+    }
+    else if (event.data.type == "port") {
+        log("recieved messagechannel");
+        const [port] = event.ports;
+        port.addEventListener("message", (event) => {
+            if (event.data.type == "response") {
+                accept(event.data);
+            }
+        });
+    }
+    else if (event.data.type == "cachename") {
+        const nextCachename = event.data.cachename;
+        if (cachename == nextCachename) {
+            return;
+        }
+        console.info(`deleting ${cachename} and setting cache name to ${nextCachename}`);
+        caches.delete(cachename);
+        cachename = nextCachename;
+    }
+    else if (event.data.type == "debug") {
+        debugging = event.data.debug;
+        log("serviceworker debugging enabled");
+    }
+});
+// request ids are kept in a counter
+let reqcount = 0;
+self.addEventListener("fetch", async (fetchEvent) => {
+    const request = fetchEvent.request;
+    if (request.method !== "GET")
+        return fetchEvent.respondWith(fetch(request));
+    const url = new URL(fetchEvent.request.url);
+    let handoffURL;
+    if (url.hostname == self.location.hostname &&
+        url.port == self.location.port &&
+        url.protocol == self.location.protocol) {
+        try {
+            // trap any request like /url e.g. /automerge%3Awhatever or /http%3A%2F%2Fsomething.com
+            // URI encoded so we can include hashes etc
+            handoffURL = new URL(decodeURIComponent(url.pathname.slice(1)));
+            log(`received handoff request ${handoffURL}`);
+        }
+        catch { }
+    }
+    fetchEvent.respondWith((async () => {
+        const cache = await caches.open(cachename);
+        const match = await cache.match(request);
+        try {
+            if (handoffURL) {
+                // cache-first strategy for handoff requests
+                if (match)
+                    return match;
+                const client = await self.clients.get(fetchEvent.clientId);
+                // set up a request id
+                const reqid = reqcount++;
+                // create a place for the response event handler to put the response
+                const resolvers = Promise.withResolvers();
+                responseResolvers.set(reqid, resolvers);
+                // i don't think this can happen
+                if (!client) {
+                    throw new Error(`the client has gone missing!!! ${fetchEvent.clientId}. i have NO IDEA what to do`);
+                }
+                const message = {
+                    id: reqid,
+                    type: "request",
+                    cache: cachename,
+                    request: {
+                        url: handoffURL.href,
+                        headers: Object.fromEntries(request.headers.entries()),
+                        method: request.method,
+                        destination: request.destination,
+                        referrer: request.referrer,
+                    },
+                };
+                log("sending handoff request", message);
+                // send request event to main thread to ask them how to handle it
+                client.postMessage(message);
+                // this'll finish when the main thread gets back to us
+                fetchEvent.waitUntil(resolvers.promise);
+                const handoffResponse = await resolvers.promise;
+                log("received handoff response", handoffResponse);
+                if (handoffResponse) {
+                    const response = new Response(handoffResponse.body, {
+                        status: handoffResponse.status,
+                        headers: handoffResponse.headers,
+                    });
+                    if (handoffResponse.cache !== false) {
+                        log(`caching ${handoffURL}`);
+                        await cache.put(request, response.clone());
+                    }
+                    else {
+                        log(`caching disabled on ${handoffURL}`);
+                    }
+                    return response;
+                }
+                // no idea what's going on now i'm a teapot i'm a teapot
+                return new Response("handler returned nothing", {
+                    status: 418,
+                });
+            }
+            else {
+                // network first strategy for external requests
+                const response = await fetch(request);
+                if (response) {
+                    if (response.ok && response.url.match(/^https?\:/)) {
+                        await cache.put(request, response.clone());
+                    }
+                    return response;
+                }
+                if (match)
+                    return match;
+                return new Response("couldnt fetch and no stale", { status: 503 });
+            }
+        }
+        catch (error) {
+            if (match)
+                return match;
+            // if something fucked up happens, serve a stale thing if there is one
+            // probably can do better error messaging here based on what was caught
+            return new Response(`yikes: ${error}`, { status: 555 });
+        }
+    })());
+});
+export {};

package/dist/setup.d.ts

@@ -0,0 +1,3 @@
+import type { HandoffHandler, SetupServiceWorkerOptions } from "./types.js";
+export declare function bumpServiceWorkerCache(sw?: ServiceWorker | null): void;
+export default function setupServiceWorker(handler: HandoffHandler, options?: SetupServiceWorkerOptions): Promise<ServiceWorker | undefined>;

package/dist/setup.js

@@ -0,0 +1,81 @@
+import debug from "debug";
+const debugging = debug.enabled("patchwork:serviceworker");
+const key = "patchworkServiceWorkerCacheVersion";
+function bumpServiceWorkerCacheVersion() {
+    const version = new Date().valueOf().toString(36);
+    localStorage.setItem(key, version);
+    return getServiceWorkerCacheVersion();
+}
+function getServiceWorkerCacheVersion() {
+    return localStorage.getItem(key);
+}
+function getOrCreateServiceWorkerCacheVersion() {
+    const existing = getServiceWorkerCacheVersion();
+    if (existing)
+        return existing;
+    return bumpServiceWorkerCacheVersion();
+}
+function setServiceWorkerCacheName(sw) {
+    if (!sw) {
+        throw new Error("no service worker!");
+    }
+    sw.postMessage({
+        type: "cachename",
+        cachename: getOrCreateServiceWorkerCacheVersion(),
+    });
+}
+export function bumpServiceWorkerCache(sw = navigator.serviceWorker.controller) {
+    bumpServiceWorkerCacheVersion();
+    setServiceWorkerCacheName(sw);
+}
+export default async function setupServiceWorker(handler, options) {
+    navigator.serviceWorker.addEventListener("controllerchange", function () {
+        console.log("%cnew service worker, reloading", "color: pink; font-weight: bold");
+        bumpServiceWorkerCache(navigator.serviceWorker.controller);
+        location.reload();
+    });
+    navigator.serviceWorker.addEventListener("message", async (event) => {
+        if (event.data.type == "request") {
+            const requestMessage = event.data;
+            const source = event.source;
+            if (!source) {
+                throw new TypeError("can't operate without a source");
+            }
+            async function send(response, transfer) {
+                source.postMessage({
+                    id: requestMessage.id,
+                    type: "response",
+                    response,
+                }, { transfer });
+            }
+            const handoffResponse = await handler(requestMessage.request.url, requestMessage.request);
+            if (!handoffResponse) {
+                return source?.postMessage({ id: requestMessage.id, type: "response" });
+            }
+            if (typeof handoffResponse == "string") {
+                return send({ body: handoffResponse }, [handoffResponse]);
+            }
+            if (handoffResponse instanceof Uint8Array) {
+                return send({ body: handoffResponse }, [handoffResponse.buffer]);
+            }
+            const { body: handoffBody, headers, status, cache } = handoffResponse;
+            const body = handoffBody;
+            send({ body, headers, status, cache }, body instanceof Uint8Array ? [body.buffer] : undefined);
+        }
+    });
+    const existingSw = await navigator.serviceWorker.getRegistration();
+    return navigator.serviceWorker
+        .register(options?.path ?? "/service-worker.js")
+        .then(async (sw) => {
+        sw.active?.postMessage({
+            type: "debug",
+            debug: debugging,
+        });
+        if (!existingSw?.active) {
+            bumpServiceWorkerCache(sw.installing);
+            queueMicrotask(() => location.reload());
+            return sw.active;
+        }
+        console.log("service worker alive, loading %c patchwork system ", "background: #fff8f0; border: 1px solid; border-radius: 4px");
+    });
+}

package/dist/types.d.ts

@@ -0,0 +1,34 @@
+export interface HandoffRequest {
+    url: string;
+    headers: Record<string, string>;
+    method: string;
+    destination: RequestDestination;
+    referrer: string;
+}
+export interface HandoffResponse {
+    body?: string | Uint8Array<ArrayBuffer> | ReadableStream;
+    /** defaults to 200 */
+    status?: number;
+    headers?: [string, string][] | Record<string, string>;
+    cache?: boolean;
+}
+export interface HandoffRequestMessage {
+    id: number;
+    type: "request";
+    /** the current name of the service worker cache */
+    cachename: string;
+    request: HandoffRequest;
+}
+export interface HandoffResponseMessage {
+    id: number;
+    type: "response";
+    response: HandoffResponse;
+}
+export type HandoffHandler = (href: string, request: HandoffRequest) => Promise<HandoffResponse | void | string | Uint8Array<ArrayBuffer>>;
+export type SetupServiceWorkerOptions = {
+    /**
+     * The public path to the service worker file.
+     * Defaults to `/service-worker.js`
+     */
+    path?: string;
+};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/vite/importmap-plugin.d.ts

@@ -0,0 +1,4 @@
+import type { Plugin } from "vite";
+import type { PatchworkVitePluginOptions } from "./patchwork-plugin.js";
+export declare const builtins: Record<string, string>;
+export declare function importmap(options?: PatchworkVitePluginOptions): Plugin;

package/dist/vite/importmap-plugin.js

@@ -0,0 +1,61 @@
+/**
+ * these dependencies will be built into the outdir,
+ * and injected into the importmap
+ */
+import externals from "../externals.js";
+export const builtins = externals.reduce((builtins, name) => ((builtins[name] = `/packages/${name}.js`), builtins), {});
+/**
+ * merge the importmap option with our builtins
+ */
+function createImportMap(options) {
+    const importmap = structuredClone(options?.importmap ?? { imports: {}, scopes: {} });
+    importmap.imports ??= {};
+    importmap.scopes ??= {};
+    Object.assign(importmap.imports, builtins);
+    return { importmap, builtins };
+}
+export function importmap(options) {
+    const { importmap, builtins } = createImportMap(options);
+    return {
+        name: "@patchwork/vite",
+        async buildStart() {
+            if (this.environment.mode == "build") {
+                for (const [id, fileName] of Object.entries(builtins)) {
+                    this.emitFile({
+                        type: "chunk",
+                        fileName: fileName.slice(1),
+                        id,
+                        preserveSignature: "strict",
+                    });
+                }
+            }
+        },
+        resolveId(id) {
+            if (id in importmap.imports && !(id in builtins)) {
+                return { id: importmap.imports[id], external: true };
+            }
+        },
+        transformIndexHtml: {
+            order: "pre",
+            handler(html, ctx) {
+                const map = structuredClone(importmap);
+                if (ctx.server) {
+                    // serve builtins from dev server in dev mode
+                    for (const id of Object.keys(builtins)) {
+                        map.imports[id] = `/@id/${id}`;
+                    }
+                }
+                return {
+                    html,
+                    tags: [
+                        {
+                            tag: "script",
+                            attrs: { type: "importmap" },
+                            children: JSON.stringify(map, null, 2),
+                        },
+                    ],
+                };
+            },
+        },
+    };
+}

package/dist/vite/patchwork-plugin.d.ts

@@ -0,0 +1,14 @@
+export default function patchwork(options?: PatchworkVitePluginOptions): import("vite").Plugin<any>[];
+type Imports = {
+    [name: string]: string;
+};
+export type ImportMap = {
+    imports: Imports;
+    scopes?: {
+        [scope: string]: Imports;
+    };
+};
+export interface PatchworkVitePluginOptions {
+    importmap?: ImportMap;
+}
+export {};

package/dist/vite/patchwork-plugin.js

@@ -0,0 +1,8 @@
+// todo this is now not patchwork-specific, it's just a fun little importmap thing
+// and a separate thing that returns the service worker which doesn't really
+// need to be a plugin at all
+import { importmap } from "./importmap-plugin.js";
+import { serviceworker } from "./service-worker-plugin.js";
+export default function patchwork(options) {
+    return [importmap(options), serviceworker()];
+}

package/dist/vite/service-worker-plugin.d.ts

@@ -0,0 +1,2 @@
+import { type Plugin } from "vite";
+export declare function serviceworker(): Plugin;

package/dist/vite/service-worker-plugin.js

@@ -0,0 +1,39 @@
+import { transformWithEsbuild } from "vite";
+export function serviceworker() {
+    const moduleId = "service-worker.js";
+    const path = `/${moduleId}`;
+    const ids = [moduleId, path];
+    const serviceWorkerExport = "@inkandswitch/patchwork-bootloader/service-worker";
+    async function transform(resolve, fs) {
+        const exportPath = await resolve(serviceWorkerExport);
+        const file = await fs.readFile(exportPath.id, {
+            encoding: "utf8",
+        });
+        const transformation = await transformWithEsbuild(file, serviceWorkerExport, { format: "iife" });
+        return transformation;
+    }
+    return {
+        name: "@patchwork/vite",
+        async buildStart() {
+            if (this.environment.mode == "build") {
+                const trans = await transform(this.resolve.bind(this), this.fs);
+                this.emitFile({
+                    type: "prebuilt-chunk",
+                    fileName: path.slice(1),
+                    code: trans.code,
+                    map: trans.map,
+                });
+            }
+        },
+        resolveId(id) {
+            if (ids.includes(id)) {
+                return moduleId;
+            }
+        },
+        async load(id) {
+            if (ids.includes(id)) {
+                return transform(this.resolve.bind(this), this.fs);
+            }
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inkandswitch/patchwork-bootloader",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "author": "chee",
   "type": "module",
   "license": "MIT",