@inkandswitch/patchwork 0.0.1

package/dist/repo.js

@@ -0,0 +1,108 @@
+import { initializeWasm, Repo, } from "@automerge/vanillajs/slim";
+import { IndexedDBWorkerStorageAdapter } from "@automerge/automerge-repo-storage-indexeddb/IndexedDBWorkerStorageAdapter";
+import { initKeyhiveWasm, initializeAutomergeRepoKeyhiveWithRepo, } from "@automerge/automerge-repo-keyhive";
+// eslint-disable-next-line
+// @ts-ignore — initSync is a wasm-bindgen runtime helper not in the .d.ts
+import { initSync as initSubductionSync } from "@automerge/automerge-subduction/slim";
+import { MemorySigner } from "@automerge/automerge-subduction/slim";
+import debug from "debug";
+const log = debug("patchwork:setup:repo");
+const useKeyhiveSyncServer = typeof __KEYHIVE_SYNC_SERVER__ !== "undefined" && __KEYHIVE_SYNC_SERVER__;
+// Fetch and initialize automerge + subduction wasm. Memoized: the fetches start
+// on the first call and every later caller awaits the same init. Skipped
+// entirely when the site brings its own Repo (it did this itself).
+let wasmReady;
+export function initWasm() {
+    if (!wasmReady) {
+        wasmReady = (async () => {
+            const [automergeWasm, subductionWasm] = await Promise.all([
+                fetch("/automerge.wasm").then((r) => r.bytes()),
+                fetch("/subduction.wasm").then((r) => r.bytes()),
+            ]);
+            await initializeWasm(automergeWasm);
+            initSubductionSync(subductionWasm);
+        })();
+    }
+    return wasmReady;
+}
+export async function createRepo(config, siteName, workerAdapter) {
+    if (config.keyhive) {
+        log("setting up keyhive");
+        initKeyhiveWasm();
+        const { hive, repo } = await initializeAutomergeRepoKeyhiveWithRepo({
+            createRepo: (repoConfig) => new Repo(repoConfig),
+            storage: new IndexedDBWorkerStorageAdapter(`${siteName}-keyhive`),
+            peerIdSuffix: siteName + Math.random().toString(36).slice(2),
+            networkAdapter: workerAdapter,
+            automaticArchiveIngestion: true,
+            cachingMode: "periodic",
+            onlyShareWithHardcodedServerPeerId: false,
+            // ARK selects the relay via `syncServer`, defaulting to "subduction".
+            ...(useKeyhiveSyncServer ? { syncServer: "keyhive" } : {}),
+            repo: {
+                storage: new IndexedDBWorkerStorageAdapter(),
+                enableRemoteHeadsGossiping: true,
+            },
+        });
+        log("keyhive setup complete");
+        return { repo, hive };
+    }
+    // An explicit signer, rather than the Repo's internal default, so the tab's
+    // identity can be exposed on window.patchwork. The tab never connects via
+    // Subduction, so this id never goes on the wire.
+    const signer = new MemorySigner();
+    const repo = new Repo({
+        network: [workerAdapter],
+        storage: new IndexedDBWorkerStorageAdapter(),
+        signer,
+        async sharePolicy(peerId) {
+            return peerId.includes("automerge-worker");
+        },
+        enableRemoteHeadsGossiping: true,
+        peerId: `${siteName}-tab-${crypto.randomUUID()}`,
+    });
+    const signerIdentity = {
+        peerId: signer.peerId().toString(),
+        verifyingKey: signer.verifyingKey().toHex(),
+    };
+    log("repo created, tab subduction identity:", signerIdentity);
+    return { repo, signerIdentity };
+}
+/**
+ * Resolve with the first repo port the worker delivers, calling `onRenewed` for
+ * every later one.
+ *
+ * subscribeToRepoChannel is deliberately not awaited: it resolves only after
+ * the boot channel's port-ready handshake, which can take its full 30s timeout
+ * against a stranded worker connection. Boot blocks on the first *delivered*
+ * port instead — if the boot channel stalls, worker recovery hands the listener
+ * a good port long before that timeout.
+ */
+export function firstRepoPort(sw, onRenewed) {
+    return new Promise((resolve) => {
+        let seen = false;
+        void sw.subscribeToRepoChannel((port) => {
+            if (seen)
+                return onRenewed(port);
+            seen = true;
+            resolve(port);
+        });
+    });
+}
+/** Drop the adapter sitting on the dead worker port, leaving `keep` in place. */
+export function removeAdapterFor(repo, stale, keep) {
+    for (const adapter of [...repo.networkSubsystem.adapters]) {
+        if (adapter === keep)
+            continue;
+        // The keyhive wrapper keeps the wrapped adapter on `.networkAdapter`.
+        const base = adapter.networkAdapter ?? adapter;
+        if (base !== stale)
+            continue;
+        try {
+            repo.networkSubsystem.removeNetworkAdapter(adapter);
+        }
+        catch (err) {
+            console.error("failed to remove stale worker network adapter", err);
+        }
+    }
+}

package/dist/router.d.ts

@@ -0,0 +1,18 @@
+import { type AutomergeUrl, type DocHandle, type Repo } from "@automerge/vanillajs/slim";
+import { type AccountDoc } from "@inkandswitch/patchwork-plugins";
+/**
+ * Coerce a `doc=` hash param to a full automerge URL. Accepts a full URL
+ * (`automerge:<id>[#heads]`) or a bare document id, for older links.
+ */
+export declare function docParamToUrl(docParam: string | null): AutomergeUrl | undefined;
+export interface RouterParams {
+    rootElement: HTMLElement;
+    repo: Repo;
+    accountDocHandle: DocHandle<AccountDoc>;
+    siteName: string;
+}
+export interface Router {
+    /** Apply `location.hash` to the view. */
+    route(): Promise<void>;
+}
+export declare function createRouter({ rootElement, repo, accountDocHandle, siteName, }: RouterParams): Router;

package/dist/router.js

@@ -0,0 +1,132 @@
+import { isValidAutomergeUrl, isValidDocumentId, stringifyAutomergeUrl, } from "@automerge/vanillajs/slim";
+import { openDocument } from "@inkandswitch/patchwork-elements";
+import { getRegistry, } from "@inkandswitch/patchwork-plugins";
+// Legacy big-patchwork hash shape: `<slug>--<documentId>[?…]`. The slug can
+// contain characters we don't otherwise permit (e.g. `drawing-(branch-1)`), so
+// anchor on the `--` before the base58 document id rather than a strict slug
+// charset.
+const BIG_PATCHWORK_HASH_REGEX = /^(?<title>[^=&?/#]*)--(?<docId>[1-9A-HJ-NP-Za-km-z]+)/;
+// The `doc=` value is an automerge URL, kept literal rather than
+// percent-encoded so links stay readable.
+const RAW_HASH_KEYS = new Set(["doc"]);
+// A stable order means re-serializing the same logical params is
+// byte-identical, avoiding spurious `hashchange` round-trips.
+const HASH_KEY_ORDER = ["doc", "tool", "type", "title", "frame"];
+function serializeHashParams(params) {
+    const keys = [...HASH_KEY_ORDER, ...params.keys()];
+    const parts = [];
+    const emitted = new Set();
+    for (const key of keys) {
+        if (emitted.has(key))
+            continue;
+        const value = params.get(key);
+        if (!value)
+            continue;
+        emitted.add(key);
+        parts.push(`${key}=${RAW_HASH_KEYS.has(key) ? value : encodeURIComponent(value)}`);
+    }
+    return parts.join("&");
+}
+/**
+ * Coerce a `doc=` hash param to a full automerge URL. Accepts a full URL
+ * (`automerge:<id>[#heads]`) or a bare document id, for older links.
+ */
+export function docParamToUrl(docParam) {
+    if (!docParam)
+        return undefined;
+    if (isValidAutomergeUrl(docParam)) {
+        return docParam;
+    }
+    const documentId = docParam.replace(/^automerge:/, "");
+    if (!isValidDocumentId(documentId))
+        return undefined;
+    return stringifyAutomergeUrl({ documentId: documentId });
+}
+export function createRouter({ rootElement, repo, accountDocHandle, siteName, }) {
+    const route = async () => {
+        // The first call seeds the root view's tool/doc so it can mount; later
+        // calls reconcile the mounted view with the hash.
+        if (!rootElement.hasAttribute("tool-id")) {
+            const params = new URLSearchParams(location.hash.slice(1));
+            const frame = params.get("frame");
+            rootElement.setAttribute("tool-id", frame ?? accountDocHandle.doc().frameToolId);
+            rootElement.setAttribute("doc-url", (frame && docParamToUrl(params.get("doc"))) || accountDocHandle.url);
+            return;
+        }
+        const hash = window.location.hash.slice(1);
+        // Legacy big-patchwork link: normalize to `#doc=automerge:<docId>` and let
+        // routing re-run on the resulting hashchange.
+        const legacyDocId = BIG_PATCHWORK_HASH_REGEX.exec(hash)?.groups?.docId;
+        if (legacyDocId && isValidDocumentId(legacyDocId)) {
+            window.location.hash = serializeHashParams(new URLSearchParams({
+                doc: stringifyAutomergeUrl({ documentId: legacyDocId }),
+            }));
+            return;
+        }
+        // Bare automerge URL: /#automerge:<documentId>
+        if (isValidAutomergeUrl(hash)) {
+            window.location.hash = "";
+            openDocument(rootElement, hash);
+            return;
+        }
+        const params = new URLSearchParams(hash);
+        const docUrl = docParamToUrl(params.get("doc"));
+        const frame = params.get("frame");
+        if (frame) {
+            const frameDocUrl = docUrl ?? accountDocHandle.url;
+            if (rootElement.getAttribute("tool-id") !== frame ||
+                rootElement.getAttribute("doc-url") !== frameDocUrl) {
+                rootElement.setAttribute("tool-id", frame);
+                rootElement.setAttribute("doc-url", frameDocUrl);
+            }
+        }
+        if (docUrl) {
+            rootElement.dispatchEvent(new CustomEvent("patchwork:open-document", {
+                detail: {
+                    url: docUrl,
+                    toolId: params.get("tool"),
+                    title: params.get("title"),
+                    type: params.get("type"),
+                },
+            }));
+        }
+    };
+    rootElement.addEventListener("patchwork:open-document", async (event) => {
+        const { url, toolId, type, title } = event.detail;
+        const params = new URLSearchParams(window.location.hash.slice(1));
+        // `doc` is the full automerge URL, so heads live inside it and the separate
+        // `heads=` param is gone.
+        params.delete("heads");
+        params.set("doc", url);
+        for (const [key, value] of [
+            ["tool", toolId],
+            ["title", title],
+            ["type", type],
+        ]) {
+            if (value)
+                params.set(key, value);
+            else
+                params.delete(key);
+        }
+        window.location.hash = serializeHashParams(params);
+        try {
+            const docHandle = await repo.find(url);
+            const doc = docHandle.doc();
+            const docType = type || doc?.["@patchwork"]?.type;
+            if (!docType)
+                return;
+            const datatype = await getRegistry("patchwork:datatype").load(docType);
+            if (!datatype)
+                return;
+            const docTitle = datatype.module.getTitle(doc);
+            if (docTitle)
+                document.title = `${docTitle} | ${siteName}`;
+        }
+        catch (e) {
+            console.error("Failed to update document title", e);
+        }
+    });
+    window.addEventListener("hashchange", route);
+    void route();
+    return { route };
+}

package/dist/site-kit/html.d.ts

@@ -0,0 +1,4 @@
+import type { PatchworkSiteOptions } from "./options.js";
+export declare function escapeHtml(value: string): string;
+/** Builds the generated index.html as a plain string — no bundler involved. */
+export declare function buildHtml(options: PatchworkSiteOptions): string;

package/dist/site-kit/html.js

@@ -0,0 +1,70 @@
+import { resolveSyncServers, PRELOAD_WASM_ASSETS } from "./sync-servers.js";
+import { ICON_SPECS } from "./icons.js";
+const HTML_ESCAPES = {
+    "&": "&",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#39;",
+};
+export function escapeHtml(value) {
+    return value.replace(/[&<>"']/g, (char) => HTML_ESCAPES[char]);
+}
+/** Builds the generated index.html as a plain string — no bundler involved. */
+export function buildHtml(options) {
+    const title = options.title ?? options.siteName ?? "Patchwork";
+    const lang = (options.html && options.html.lang) || "en";
+    const entry = options.entry ?? "/src/main.ts";
+    const syncServers = resolveSyncServers(options);
+    const head = [
+        `<meta charset="UTF-8" />`,
+        `<meta name="viewport" content="width=device-width, initial-scale=1.0" />`,
+        `<title>${escapeHtml(title)}</title>`,
+        `<link rel="stylesheet" href="@inkandswitch/patchwork/global.css" />`,
+    ];
+    if (options.description) {
+        head.push(`<meta name="description" content="${escapeHtml(options.description)}" />`);
+    }
+    if (options.icons) {
+        for (const spec of ICON_SPECS) {
+            if (spec.fileName === "apple-touch-icon.png") {
+                head.push(`<link rel="apple-touch-icon" sizes="${spec.size}x${spec.size}" href="/${spec.fileName}" />`);
+            }
+            else if (spec.fileName.startsWith("favicon-")) {
+                head.push(`<link rel="icon" type="image/png" sizes="${spec.size}x${spec.size}" href="/${spec.fileName}" />`);
+            }
+        }
+        if (options.icons?.maskIcon) {
+            head.push(`<link rel="mask-icon" href="${options.icons.maskIcon}" color="${options.icons.maskIconColor ?? "#000000"}" />`);
+        }
+    }
+    if (typeof options.themeColor === "string") {
+        head.push(`<meta name="theme-color" content="${options.themeColor}" />`);
+    }
+    else if (options.themeColor) {
+        head.push(`<meta name="theme-color" content="${options.themeColor.light}" media="(prefers-color-scheme: light)" />`, `<meta name="theme-color" content="${options.themeColor.dark}" media="(prefers-color-scheme: dark)" />`);
+    }
+    head.push(`<meta name="apple-mobile-web-app-capable" content="yes" />`, `<meta name="apple-mobile-web-app-status-bar-style" content="default" />`, `<meta name="apple-mobile-web-app-title" content="${escapeHtml(title)}" />`);
+    if (options.manifest !== false) {
+        head.push(`<link rel="manifest" href="/manifest.webmanifest" />`);
+    }
+    for (const server of syncServers) {
+        head.push(`<link rel="preconnect" href="${server}" />`);
+    }
+    for (const server of syncServers) {
+        head.push(`<link rel="dns-prefetch" href="${server}" />`);
+    }
+    for (const asset of PRELOAD_WASM_ASSETS) {
+        head.push(`<link rel="preload" href="/${asset}" as="fetch" crossorigin />`);
+    }
+    if (options.html && options.html.extraHead) {
+        head.push(options.html.extraHead);
+    }
+    return `<!doctype html>
+<html lang="${lang}">
+${head.join("\n")}
+<repo-provider><patchwork-view id="root"></patchwork-view></repo-provider>
+<script type="module" src="${entry}"></script>
+</html>
+`;
+}

package/dist/site-kit/icons.d.ts

@@ -0,0 +1,9 @@
+export interface IconSpec {
+    fileName: string;
+    size: number;
+    /** Included in the generated manifest.webmanifest icons array when set. */
+    manifestPurpose?: string;
+}
+export declare const ICON_SPECS: IconSpec[];
+/** Renders every icon size from a single source image (svg or raster), cached by source path. */
+export declare function getIcons(source: string): Promise<Map<string, Buffer>>;

package/dist/site-kit/icons.js

@@ -0,0 +1,36 @@
+import sharp from "sharp";
+import { readFile } from "node:fs/promises";
+// apple-touch-icon at 180 matches iOS's expected size; 192/512 are the
+// standard PWA manifest sizes; 16/32 cover browser tab favicons.
+export const ICON_SPECS = [
+    { fileName: "favicon-16x16.png", size: 16 },
+    { fileName: "favicon-32x32.png", size: 32 },
+    { fileName: "apple-touch-icon.png", size: 180 },
+    { fileName: "icon-192x192.png", size: 192, manifestPurpose: "any maskable" },
+    { fileName: "icon-512x512.png", size: 512, manifestPurpose: "any maskable" },
+];
+const cache = new Map();
+async function renderIcons(source) {
+    const input = await readFile(source);
+    const rendered = new Map();
+    await Promise.all(ICON_SPECS.map(async (spec) => {
+        const buffer = await sharp(input)
+            .resize(spec.size, spec.size, { fit: "cover" })
+            .png()
+            .toBuffer();
+        rendered.set(spec.fileName, buffer);
+    }));
+    return rendered;
+}
+/** Renders every icon size from a single source image (svg or raster), cached by source path. */
+export function getIcons(source) {
+    let promise = cache.get(source);
+    if (!promise) {
+        promise = renderIcons(source).catch((error) => {
+            cache.delete(source);
+            throw error;
+        });
+        cache.set(source, promise);
+    }
+    return promise;
+}

package/dist/site-kit/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The bundler-agnostic parts of building a Patchwork site's static assets —
+ * icon rendering, and the index.html/manifest.webmanifest/Netlify _headers
+ * content builders. No `vite` import anywhere in this directory: a
+ * different bundler adapter (esbuild, webpack, or a plain pre-build script)
+ * can reuse these directly. `../vite/*` is the vite-specific adapter that
+ * wires these into vite's plugin hooks (dev middleware, emitFile, virtual
+ * modules, config()).
+ */
+export type { PatchworkSiteOptions, PatchworkIconsOptions, PatchworkHtmlOptions, PatchworkNetlifyOptions, PatchworkSyncServersOptions, } from "./options.js";
+export { resolveSyncServers, PRELOAD_WASM_ASSETS } from "./sync-servers.js";
+export { getIcons, ICON_SPECS, type IconSpec } from "./icons.js";
+export { buildHtml, escapeHtml } from "./html.js";
+export { buildManifest } from "./manifest.js";
+export { buildHeaders, REDIRECTS } from "./netlify.js";

package/dist/site-kit/index.js

@@ -0,0 +1,5 @@
+export { resolveSyncServers, PRELOAD_WASM_ASSETS } from "./sync-servers.js";
+export { getIcons, ICON_SPECS } from "./icons.js";
+export { buildHtml, escapeHtml } from "./html.js";
+export { buildManifest } from "./manifest.js";
+export { buildHeaders, REDIRECTS } from "./netlify.js";

package/dist/site-kit/manifest.d.ts

@@ -0,0 +1,3 @@
+import type { PatchworkSiteOptions } from "./options.js";
+/** Builds the generated manifest.webmanifest object — no bundler involved. */
+export declare function buildManifest(options: PatchworkSiteOptions): Record<string, unknown>;

package/dist/site-kit/manifest.js

@@ -0,0 +1,29 @@
+import { ICON_SPECS } from "./icons.js";
+/** Builds the generated manifest.webmanifest object — no bundler involved. */
+export function buildManifest(options) {
+    const title = options.title ?? options.siteName ?? "Patchwork";
+    const icons = !options.icons
+        ? []
+        : ICON_SPECS.filter((spec) => spec.fileName === "apple-touch-icon.png" || spec.manifestPurpose).map((spec) => ({
+            src: `/${spec.fileName}`,
+            sizes: `${spec.size}x${spec.size}`,
+            type: "image/png",
+            ...(spec.manifestPurpose ? { purpose: spec.manifestPurpose } : {}),
+        }));
+    const manifest = {
+        name: title,
+        short_name: options.shortName ?? title,
+        description: options.description,
+        start_url: "/",
+        display: "standalone",
+        display_override: ["window-controls-overlay", "standalone"],
+        background_color: options.backgroundColor ?? "#ffffff",
+        theme_color: (typeof options.themeColor === "string"
+            ? options.themeColor
+            : options.themeColor?.light) ??
+            options.backgroundColor ??
+            "#ffffff",
+        icons,
+    };
+    return { ...manifest, ...options.manifest };
+}

package/dist/site-kit/netlify.d.ts

@@ -0,0 +1,5 @@
+import type { PatchworkSiteOptions } from "./options.js";
+/** Builds the generated Netlify _headers file content — no bundler involved. */
+export declare function buildHeaders(options: PatchworkSiteOptions): string;
+/** The generated Netlify _redirects file content — always the same SPA fallback. */
+export declare const REDIRECTS = "/* /index.html 200\n";

package/dist/site-kit/netlify.js

@@ -0,0 +1,27 @@
+import { resolveSyncServers, PRELOAD_WASM_ASSETS } from "./sync-servers.js";
+function buildLinkHeader(syncServers) {
+    const parts = PRELOAD_WASM_ASSETS.map((asset) => `</${asset}>; rel=preload; as=fetch; crossorigin`);
+    for (const server of syncServers) {
+        parts.push(`<${server}>; rel=preconnect`);
+    }
+    for (const server of syncServers) {
+        parts.push(`<${server}>; rel=dns-prefetch`);
+    }
+    return parts.join(", ");
+}
+/** Builds the generated Netlify _headers file content — no bundler involved. */
+export function buildHeaders(options) {
+    const syncServers = resolveSyncServers(options);
+    const immutableAssets = options.netlify === false || options.netlify?.immutableAssets === false
+        ? null
+        : "/assets/*\n  Cache-Control: public, max-age=31536000, immutable\n";
+    return [
+        "/*\n  Access-Control-Allow-Origin: *",
+        immutableAssets,
+        `/\n  Link: ${buildLinkHeader(syncServers)}`,
+    ]
+        .filter(Boolean)
+        .join("\n");
+}
+/** The generated Netlify _redirects file content — always the same SPA fallback. */
+export const REDIRECTS = "/* /index.html 200\n";

package/dist/site-kit/options.d.ts

@@ -0,0 +1,67 @@
+/**
+ * The bundler-agnostic option shape for a Patchwork site's generated
+ * static assets (icons, index.html, manifest.webmanifest, Netlify config).
+ * `../vite/patchwork-plugin.ts` extends this with vite-only config
+ * (importmap, server/preview/worker/build) — a different bundler adapter
+ * can reuse this same shape and the pure builders in this directory without
+ * pulling in anything vite-specific.
+ */
+export interface PatchworkIconsOptions {
+    /** Path (relative to the site root) to a source svg or raster image. Every icon size is rendered from it via sharp. */
+    source: string;
+    /** Path to a monochrome svg for Safari's pinned-tab mask icon. Omitted entirely if not set. */
+    maskIcon?: string;
+    maskIconColor?: string;
+}
+export interface PatchworkHtmlOptions {
+    lang?: string;
+    /** Raw HTML appended just before </html> — e.g. extra <link>/<meta> tags. */
+    extraHead?: string;
+}
+export interface PatchworkNetlifyOptions {
+    /** Cache-Control: immutable on /assets/*. Default true. */
+    immutableAssets?: boolean;
+}
+export interface PatchworkSyncServersOptions {
+    /** wss:// URL for the legacy automerge-repo sync-server channel (connected on demand via connectClassicSync). Default: wss://sync3.automerge.org. Pass false to skip its preconnect hint. */
+    classic?: string | false;
+    /** wss:// URL for subduction sync — live when keyhiveSyncServer is false. Default: wss://subduction.sync.inkandswitch.com */
+    subduction?: string;
+    /** wss:// URL for keyhive sync — live when keyhiveSyncServer is true. Default: wss://keyhive.sync.automerge.org */
+    keyhive?: string;
+}
+export interface PatchworkSiteOptions {
+    /** -> __SITE_NAME__ define */
+    siteName?: string;
+    /** <title>, apple-mobile-web-app-title, manifest name */
+    title?: string;
+    /** manifest short_name (defaults to title) */
+    shortName?: string;
+    /** manifest description, <meta name=description> */
+    description?: string;
+    /** default "/src/main.ts" — must be root-absolute, since the generated index.html doesn't live at the project root */
+    entry?: string;
+    /** -> __KEYHIVE__ define */
+    keyhive?: boolean;
+    /** -> __KEYHIVE_SYNC_SERVER__ define */
+    keyhiveSyncServer?: boolean;
+    themeColor?: string | {
+        light: string;
+        dark: string;
+    };
+    /** manifest background_color */
+    backgroundColor?: string;
+    /**
+     * Which sync-server hosts to preconnect/dns-prefetch from the html and
+     * list in the Netlify Link header. Only the channel actually live for
+     * this build is included — subduction xor keyhive, picked by
+     * `keyhiveSyncServer`, matching automerge-worker.ts's own selection —
+     * plus `classic` (on-demand, but cheap to hint) unless set to `false`.
+     * Pass `false` to skip all sync-server hints.
+     */
+    syncServers?: false | PatchworkSyncServersOptions;
+    icons?: false | PatchworkIconsOptions;
+    html?: false | PatchworkHtmlOptions;
+    manifest?: false | Record<string, unknown>;
+    netlify?: false | PatchworkNetlifyOptions;
+}

package/dist/site-kit/options.js

@@ -0,0 +1,9 @@
+/**
+ * The bundler-agnostic option shape for a Patchwork site's generated
+ * static assets (icons, index.html, manifest.webmanifest, Netlify config).
+ * `../vite/patchwork-plugin.ts` extends this with vite-only config
+ * (importmap, server/preview/worker/build) — a different bundler adapter
+ * can reuse this same shape and the pure builders in this directory without
+ * pulling in anything vite-specific.
+ */
+export {};

package/dist/site-kit/sync-servers.d.ts

@@ -0,0 +1,11 @@
+import type { PatchworkSiteOptions } from "./options.js";
+/**
+ * Resolves which sync-server origins are actually live for this build: the
+ * channel that's live is subduction xor keyhive (picked by
+ * `keyhiveSyncServer`, matching automerge-worker.ts's own selection) plus
+ * classic (on-demand, but still worth a preconnect hint) unless disabled.
+ * A flat list would drift from `keyhiveSyncServer` — e.g. always hinting
+ * subduction even on a build that actually connects to keyhive.
+ */
+export declare function resolveSyncServers(options: PatchworkSiteOptions): string[];
+export declare const PRELOAD_WASM_ASSETS: string[];

package/dist/site-kit/sync-servers.js

@@ -0,0 +1,36 @@
+// Mirrors core/bootloader/src/sync-config.ts's DEFAULT_CLASSIC_SYNC_SERVER
+// and automerge-worker.ts's SUBDUCTION_SYNC_URL selection — kept here as
+// plain constants (rather than importing those runtime modules) since this
+// only needs the hostnames, not the browser-only logic that reads them.
+const DEFAULT_SYNC_SERVERS = {
+    classic: "wss://sync3.automerge.org",
+    subduction: "wss://subduction.sync.inkandswitch.com",
+    keyhive: "wss://keyhive.sync.automerge.org",
+};
+function wsToHttpOrigin(wsUrl) {
+    return wsUrl.replace(/^ws/, "http");
+}
+/**
+ * Resolves which sync-server origins are actually live for this build: the
+ * channel that's live is subduction xor keyhive (picked by
+ * `keyhiveSyncServer`, matching automerge-worker.ts's own selection) plus
+ * classic (on-demand, but still worth a preconnect hint) unless disabled.
+ * A flat list would drift from `keyhiveSyncServer` — e.g. always hinting
+ * subduction even on a build that actually connects to keyhive.
+ */
+export function resolveSyncServers(options) {
+    if (options.syncServers === false)
+        return [];
+    const servers = { ...DEFAULT_SYNC_SERVERS, ...options.syncServers };
+    const origins = [];
+    const primary = options.keyhiveSyncServer
+        ? servers.keyhive
+        : servers.subduction;
+    origins.push(primary);
+    if (servers.classic)
+        origins.push(servers.classic);
+    return origins.map(wsToHttpOrigin);
+}
+// Emitted by importmap-plugin.ts. keyhive_wasm.wasm is loaded lazily (only
+// when keyhive is actually enabled), so it isn't worth an eager preload.
+export const PRELOAD_WASM_ASSETS = ["automerge.wasm", "subduction.wasm"];