@davidsouther/jiffies 2026.24.0 → 2026.24.2

package/lib/esm/server/ws/index.js

@@ -0,0 +1,68 @@
+import { encodeTextFrame, readOpcode } from "./frame.js";
+import { completeHandshake } from "./handshake.js";
+// A pong control frame: FIN + opcode 0xA, empty unmasked payload.
+const PONG_FRAME = Buffer.from([0x8a, 0x00]);
+// Inbound control-frame opcodes the hub answers (RFC 6455 section 5.5).
+const OPCODE_CLOSE = 0x8;
+const OPCODE_PING = 0x9;
+// Attaches a WebSocket hub to an existing http.Server via its 'upgrade' event.
+// Does NOT create or own the server.
+export function attachWebSocketServer(server, options) {
+    const sockets = new Set();
+    const onUpgrade = (req, socket) => {
+        const pathname = new URL(req.url ?? "/", "http://localhost").pathname;
+        if (pathname !== options.path) {
+            socket.destroy();
+            return;
+        }
+        if (!completeHandshake(req, socket)) {
+            socket.destroy();
+            return;
+        }
+        sockets.add(socket);
+        options.onConnection?.(socket);
+        socket.on("data", (chunk) => {
+            const opcode = readOpcode(chunk);
+            if (opcode === OPCODE_PING) {
+                // A pong keeps the connection alive; an unanswered ping drops it.
+                socket.write(PONG_FRAME);
+            }
+            else if (opcode === OPCODE_CLOSE) {
+                sockets.delete(socket);
+                socket.end();
+            }
+        });
+        const remove = () => {
+            sockets.delete(socket);
+        };
+        socket.on("error", remove);
+        socket.on("end", remove);
+        socket.on("close", remove);
+    };
+    server.on("upgrade", onUpgrade);
+    return {
+        broadcast(text) {
+            const frame = encodeTextFrame(text);
+            for (const socket of sockets) {
+                try {
+                    socket.write(frame);
+                }
+                catch {
+                    sockets.delete(socket);
+                }
+            }
+        },
+        get size() {
+            return sockets.size;
+        },
+        close() {
+            for (const socket of sockets) {
+                socket.end();
+            }
+            sockets.clear();
+            server.off("upgrade", onUpgrade);
+        },
+    };
+}
+export { encodeTextFrame, readOpcode } from "./frame.js";
+export { acceptKey, completeHandshake } from "./handshake.js";

package/lib/esm/ssg/bundle.d.ts

@@ -0,0 +1,14 @@
+import type { PageDescriptor } from "./ssg.ts";
+/**
+ * Bundle all distinct clientModules specifiers from `pages` using Rollup.
+ *
+ * Specifier resolution: a leading "/" is treated as relative to `rootDir`
+ * (not the filesystem root), so "/client.ts" resolves to "<rootDir>/client.ts".
+ * Relative specifiers resolve from `rootDir`. Absolute non-root paths are used
+ * as-is.
+ *
+ * Returns a map from original specifier string to the hashed asset URL
+ * ("/assets/<entry-name>-<hash>.js") so the HTML rewrite step can substitute
+ * in place.
+ */
+export declare function bundleClientModules(pages: PageDescriptor[], rootDir: string, outDir: string): Promise<Map<string, string>>;

package/lib/esm/ssg/bundle.js

@@ -0,0 +1,73 @@
+import { join, relative } from "node:path";
+import nodeResolve from "@rollup/plugin-node-resolve";
+import { rollup } from "rollup";
+import tsBlankSpace from "ts-blank-space";
+/**
+ * Bundle all distinct clientModules specifiers from `pages` using Rollup.
+ *
+ * Specifier resolution: a leading "/" is treated as relative to `rootDir`
+ * (not the filesystem root), so "/client.ts" resolves to "<rootDir>/client.ts".
+ * Relative specifiers resolve from `rootDir`. Absolute non-root paths are used
+ * as-is.
+ *
+ * Returns a map from original specifier string to the hashed asset URL
+ * ("/assets/<entry-name>-<hash>.js") so the HTML rewrite step can substitute
+ * in place.
+ */
+export async function bundleClientModules(pages, rootDir, outDir) {
+    const allSpecs = new Set();
+    for (const { module } of pages) {
+        for (const spec of module.clientModules ?? []) {
+            allSpecs.add(spec);
+        }
+    }
+    if (allSpecs.size === 0)
+        return new Map();
+    // Resolve each specifier to an absolute disk path under rootDir.
+    // A leading "/" means "relative to rootDir", not the filesystem root.
+    const specToPath = new Map();
+    for (const spec of allSpecs) {
+        specToPath.set(spec, join(rootDir, spec));
+    }
+    // Build slug -> spec mapping and Rollup input record.
+    const slugToSpec = new Map();
+    const input = {};
+    for (const [spec, diskPath] of specToPath) {
+        const rel = relative(rootDir, diskPath);
+        const slug = rel.replace(/\//g, "-").replace(/\.[^.]+$/, "");
+        slugToSpec.set(slug, spec);
+        input[slug] = diskPath;
+    }
+    const bundle = await rollup({
+        input,
+        plugins: [
+            {
+                name: "ts-strip",
+                transform(code, id) {
+                    if (id.endsWith(".ts")) {
+                        return { code: tsBlankSpace(code), map: null };
+                    }
+                    return null;
+                },
+            },
+            nodeResolve({ extensions: [".ts", ".js"] }),
+        ],
+    });
+    const assetsDir = join(outDir, "assets");
+    const { output } = await bundle.write({
+        dir: assetsDir,
+        format: "es",
+        entryFileNames: "[name]-[hash].js",
+        chunkFileNames: "[name]-[hash].js",
+    });
+    const specToUrl = new Map();
+    for (const chunk of output) {
+        if (chunk.type === "chunk" && chunk.isEntry) {
+            const spec = slugToSpec.get(chunk.name);
+            if (spec !== undefined) {
+                specToUrl.set(spec, `/assets/${chunk.fileName}`);
+            }
+        }
+    }
+    return specToUrl;
+}

package/lib/esm/ssg/copy-public.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Copy every file under `<rootDir>/<publicDir>` verbatim into `<outDir>`.
+ * Recurses into subdirectories. A missing `publicDir` is a no-op.
+ * Ensures target directory exists (recursive mkdir) before each copy.
+ */
+export declare function copyPublic(rootDir: string, publicDir: string, outDir: string): Promise<string[]>;

package/lib/esm/ssg/copy-public.js

@@ -0,0 +1,34 @@
+import { copyFile, mkdir, readdir, stat } from "node:fs/promises";
+import { join } from "node:path";
+/**
+ * Copy every file under `<rootDir>/<publicDir>` verbatim into `<outDir>`.
+ * Recurses into subdirectories. A missing `publicDir` is a no-op.
+ * Ensures target directory exists (recursive mkdir) before each copy.
+ */
+export async function copyPublic(rootDir, publicDir, outDir) {
+    const src = join(rootDir, publicDir);
+    try {
+        await stat(src);
+    }
+    catch {
+        return [];
+    }
+    const copied = [];
+    await copyDir(src, outDir, copied);
+    return copied;
+}
+async function copyDir(src, dest, copied) {
+    await mkdir(dest, { recursive: true });
+    const entries = await readdir(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = join(src, entry.name);
+        const destPath = join(dest, entry.name);
+        if (entry.isDirectory()) {
+            await copyDir(srcPath, destPath, copied);
+        }
+        else {
+            await copyFile(srcPath, destPath);
+            copied.push(destPath);
+        }
+    }
+}

package/lib/esm/ssg/discover.d.ts

@@ -0,0 +1,15 @@
+import type { PageDescriptor } from "./ssg.ts";
+/**
+ * Scan `<rootDir>/<pagesDir>` recursively for `page.ts` sentinels.
+ * Each sentinel becomes one PageDescriptor whose route is derived from the
+ * folder path by stripping (group) segments (any folder whose name is wrapped
+ * in parentheses) and treating the pages root as "/".
+ *
+ * Dynamic segments ([bracket] folders) are expanded by calling
+ * `generateStaticParams` on the module; each param set produces one concrete
+ * PageDescriptor whose `default`/`head` wrappers forward the resolved params.
+ *
+ * Throws with a message naming `pagesDir` if it does not exist or contains no
+ * sentinels. Caller should catch and exit 1.
+ */
+export declare function discoverPages(rootDir: string, pagesDir: string): Promise<PageDescriptor[]>;

package/lib/esm/ssg/discover.js

@@ -0,0 +1,117 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+const SENTINEL = "page.ts";
+const SENTINEL_SUFFIX = `/${SENTINEL}`;
+/**
+ * Scan `<rootDir>/<pagesDir>` recursively for `page.ts` sentinels.
+ * Each sentinel becomes one PageDescriptor whose route is derived from the
+ * folder path by stripping (group) segments (any folder whose name is wrapped
+ * in parentheses) and treating the pages root as "/".
+ *
+ * Dynamic segments ([bracket] folders) are expanded by calling
+ * `generateStaticParams` on the module; each param set produces one concrete
+ * PageDescriptor whose `default`/`head` wrappers forward the resolved params.
+ *
+ * Throws with a message naming `pagesDir` if it does not exist or contains no
+ * sentinels. Caller should catch and exit 1.
+ */
+export async function discoverPages(rootDir, pagesDir) {
+    const pagesRoot = join(rootDir, pagesDir);
+    const sentinels = [];
+    await scan(pagesRoot, sentinels);
+    if (sentinels.length === 0) {
+        throw new Error(`No page.ts sentinels found in ${pagesDir}`);
+    }
+    const staticSentinels = [];
+    const dynamicSentinels = [];
+    for (const path of sentinels) {
+        const relDir = path.slice(pagesRoot.length, -SENTINEL_SUFFIX.length);
+        (isDynamic(relDir) ? dynamicSentinels : staticSentinels).push({
+            path,
+            relDir,
+        });
+    }
+    const routeToPath = new Map();
+    const staticDescriptors = await Promise.all(staticSentinels.map(async ({ path: sentinelPath, relDir }) => {
+        const route = deriveRoute(relDir);
+        const prev = routeToPath.get(route);
+        if (prev !== undefined) {
+            throw new Error(`Route collision at "${route}": ${prev} and ${sentinelPath} both derive the same route`);
+        }
+        routeToPath.set(route, sentinelPath);
+        const imported = (await import(__rewriteRelativeImportExtension(sentinelPath)));
+        return { route, module: imported.default };
+    }));
+    const dynamicDescriptors = [];
+    for (const { path: sentinelPath, relDir } of dynamicSentinels) {
+        const routeTemplate = deriveRoute(relDir);
+        const imported = (await import(__rewriteRelativeImportExtension(sentinelPath)));
+        const originalModule = imported.default;
+        if (!originalModule.generateStaticParams) {
+            throw new Error(`Dynamic route "${sentinelPath}" has no generateStaticParams export`);
+        }
+        const paramSets = await originalModule.generateStaticParams();
+        if (!Array.isArray(paramSets)) {
+            throw new Error(`generateStaticParams for "${sentinelPath}" must return an array`);
+        }
+        for (const params of paramSets) {
+            const route = fillTemplate(routeTemplate, params);
+            const label = `${sentinelPath} (${Object.entries(params)
+                .map(([k, v]) => `${k}=${v}`)
+                .join(", ")})`;
+            const prev = routeToPath.get(route);
+            if (prev !== undefined) {
+                throw new Error(`Route collision at "${route}": ${prev} and ${label} both derive the same route`);
+            }
+            routeToPath.set(route, label);
+            const originalHead = originalModule.head;
+            const wrappedModule = {
+                ...originalModule,
+                default: () => originalModule.default(params),
+                ...(originalHead ? { head: () => originalHead(params) } : {}),
+            };
+            dynamicDescriptors.push({ route, module: wrappedModule });
+        }
+    }
+    return [...staticDescriptors, ...dynamicDescriptors];
+}
+function isDynamic(relDir) {
+    return relDir.split("/").some((s) => /^\[.*\]$/.test(s));
+}
+function fillTemplate(template, params) {
+    return template.replace(/\[([^\]]+)\]/g, (_match, name) => {
+        const value = params[name];
+        if (value === undefined) {
+            throw new Error(`Missing param "${name}" for template "${template}"`);
+        }
+        if (value.includes("/")) {
+            throw new Error(`Param "${name}" value "${value}" must not contain "/"`);
+        }
+        return value;
+    });
+}
+function deriveRoute(relDir) {
+    const segments = relDir.split("/").filter(Boolean);
+    const stripped = segments.filter((s) => !/^\(.*\)$/.test(s));
+    return `/${stripped.join("/")}`;
+}
+async function scan(dir, results) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            await scan(fullPath, results);
+        }
+        else if (entry.name === SENTINEL) {
+            results.push(fullPath);
+        }
+    }
+}

package/lib/esm/ssg/main.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/lib/esm/ssg/main.js

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+// CLI entry point for `ssg build`. All diagnostics go to stderr.
+// stdout is reserved exclusively for --json output.
+import { readdir, readFile, writeFile } from "node:fs/promises";
+import { join, relative, resolve } from "node:path";
+import * as process from "node:process";
+import { parseArgs } from "node:util";
+import { gzipSync } from "node:zlib";
+import { NodeFileSystem } from "../fs_node.js";
+import { bundleClientModules } from "./bundle.js";
+import { copyPublic } from "./copy-public.js";
+import { discoverPages } from "./discover.js";
+import { rewriteClientSpecifiers } from "./rewrite.js";
+import { build } from "./ssg.js";
+function htmlPathForRoute(route, outDir) {
+    const segment = route.replace(/^\//, "");
+    return segment ? `${outDir}/${segment}/index.html` : `${outDir}/index.html`;
+}
+async function sizeEntry(absPath, outDir) {
+    const content = await readFile(absPath);
+    return {
+        path: relative(outDir, absPath),
+        rawBytes: content.byteLength,
+        gzipBytes: gzipSync(content).byteLength,
+    };
+}
+function fmtBytes(n) {
+    return n >= 1024 ? `${(n / 1024).toFixed(1)} kB` : `${n} B`;
+}
+async function runBuild(values) {
+    const start = Date.now();
+    const rootDir = resolve(values.root);
+    const outDir = resolve(values.out);
+    let pages;
+    try {
+        pages = await discoverPages(rootDir, values.pages);
+    }
+    catch (e) {
+        process.stderr.write(`Error: ${e.message}\n`);
+        process.exit(1);
+    }
+    const fs = new NodeFileSystem();
+    await build({ pages, out: outDir, fs });
+    const publicPaths = await copyPublic(rootDir, values.public, outDir);
+    const specToUrl = await bundleClientModules(pages, rootDir, outDir);
+    if (specToUrl.size > 0) {
+        for (const { route, module } of pages) {
+            if (!module.clientModules?.length)
+                continue;
+            const htmlPath = htmlPathForRoute(route, outDir);
+            const original = await readFile(htmlPath, "utf-8");
+            await writeFile(htmlPath, rewriteClientSpecifiers(original, specToUrl), "utf-8");
+        }
+    }
+    // Collect sizes.
+    const htmlPaths = pages.map(({ route }) => htmlPathForRoute(route, outDir));
+    const assetsDir = join(outDir, "assets");
+    let assetFiles = [];
+    try {
+        assetFiles = (await readdir(assetsDir)).map((f) => join(assetsDir, f));
+    }
+    catch {
+        // no assets directory when no clientModules
+    }
+    const [pageEntries, assetEntries, publicEntries] = await Promise.all([
+        Promise.all(htmlPaths.map((p) => sizeEntry(p, outDir))),
+        Promise.all(assetFiles.map((p) => sizeEntry(p, outDir))),
+        Promise.all(publicPaths.map((p) => sizeEntry(p, outDir))),
+    ]);
+    const manifest = {
+        pages: pageEntries,
+        assets: assetEntries,
+        public: publicEntries,
+        durationMs: Date.now() - start,
+    };
+    if (values.json) {
+        process.stdout.write(JSON.stringify(manifest, null, 2));
+    }
+    else {
+        const all = [...pageEntries, ...assetEntries, ...publicEntries];
+        const maxPath = Math.max(...all.map((e) => e.path.length));
+        for (const entry of all) {
+            const padded = entry.path.padEnd(maxPath);
+            process.stderr.write(`${padded}  ${fmtBytes(entry.rawBytes)} │ gzip: ${fmtBytes(entry.gzipBytes)}\n`);
+        }
+        process.stderr.write(`✓ built ${pageEntries.length} pages, ${assetEntries.length} assets in ${manifest.durationMs}ms\n`);
+    }
+}
+try {
+    const { values, positionals } = parseArgs({
+        strict: true,
+        allowPositionals: true,
+        options: {
+            help: { type: "boolean", short: "h" },
+            version: { type: "boolean", short: "v" },
+            root: { type: "string", default: "." },
+            out: { type: "string", default: "dist" },
+            pages: { type: "string", default: "pages" },
+            public: { type: "string", default: "public" },
+            json: { type: "boolean", default: false },
+            "no-clean": { type: "boolean", default: false },
+        },
+    });
+    if (values.help) {
+        process.stderr.write("Usage: ssg build [--root <dir>] [--out <dir>]\n");
+        process.exit(0);
+    }
+    if (values.version) {
+        process.stderr.write("ssg 0.1.0\n");
+        process.exit(0);
+    }
+    const cmd = positionals[0];
+    if (cmd !== undefined && cmd !== "build") {
+        process.stderr.write(`Unknown command: ${cmd}\n`);
+        process.exit(1);
+    }
+    await runBuild(values);
+}
+catch (e) {
+    process.stderr.write(`${e.message ?? String(e)}\n`);
+    process.exit(1);
+}

package/lib/esm/ssg/rewrite.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Rewrite `import "<S>";` lines inside <script type="module" defer> blocks in
+ * `htmlContent`, replacing each original specifier `S` with the hashed asset URL
+ * from `specToUrl`. Lines whose specifier is not in the map are left unchanged.
+ *
+ * This is a string substitution, not DOM parsing — the exact format emitted by
+ * ssg.ts is `import "<S>";` on its own line inside the script block.
+ */
+export declare function rewriteClientSpecifiers(htmlContent: string, specToUrl: Map<string, string>): string;

package/{src/ssg/rewrite.ts → lib/esm/ssg/rewrite.js}

@@ -6,13 +6,10 @@
  * This is a string substitution, not DOM parsing — the exact format emitted by
  * ssg.ts is `import "<S>";` on its own line inside the script block.
  */
-export function rewriteClientSpecifiers(
-  htmlContent: string,
-  specToUrl: Map<string, string>,
-): string {
-  let result = htmlContent;
-  for (const [spec, url] of specToUrl) {
-    result = result.replaceAll(`import "${spec}";`, `import "${url}";`);
-  }
-  return result;
+export function rewriteClientSpecifiers(htmlContent, specToUrl) {
+    let result = htmlContent;
+    for (const [spec, url] of specToUrl) {
+        result = result.replaceAll(`import "${spec}";`, `import "${url}";`);
+    }
+    return result;
 }

package/lib/esm/ssg/ssg.d.ts

@@ -0,0 +1,26 @@
+import type { FileSystem } from "../fs.ts";
+export type HtmlAttributes = Partial<Record<"lang" | "dir" | "class" | `data-${string}`, string>>;
+/** Describes a page's default render function and optional metadata for the SSG build. */
+export interface PageModule {
+    default: (params?: Record<string, string>) => Node | Node[] | Promise<Node | Node[]>;
+    head?: (params?: Record<string, string>) => Node | Node[] | Promise<Node | Node[]>;
+    htmlAttributes?: HtmlAttributes;
+    clientModules?: string[];
+    /**
+     * Enumerate concrete param sets for dynamic route segments.
+     * Required when any path segment is a [bracket] folder.
+     */
+    generateStaticParams?: () => Promise<Record<string, string>[]>;
+}
+/** Associates a URL route with its `PageModule` for the SSG build. */
+export interface PageDescriptor {
+    route: string;
+    module: PageModule;
+}
+/** Options for a full SSG build: the set of pages to render, the output directory, and the filesystem adapter. */
+export interface BuildOptions {
+    pages: PageDescriptor[];
+    out: string;
+    fs: FileSystem;
+}
+export declare function build({ pages, out, fs }: BuildOptions): Promise<void>;

package/lib/esm/ssg/ssg.js

@@ -0,0 +1,84 @@
+import { buildPayload, captureStubSource } from "../dom/hydrate.js";
+import { renderToString } from "../dom/render.js";
+/**
+ * Walk `root` depth-first and return every element whose localName is a
+ * defined custom element, in document order including nested ones. Descends
+ * into matched elements so the full set of custom elements is returned.
+ */
+function scanAllUnits(root) {
+    const results = [];
+    const stack = [...root.children].reverse();
+    while (stack.length > 0) {
+        const el = stack.pop();
+        if (customElements.get(el.localName)) {
+            results.push(el);
+        }
+        // Always descend — nested custom elements are included in the full set.
+        for (let i = el.children.length - 1; i >= 0; i--) {
+            stack.push(el.children[i]);
+        }
+    }
+    return results;
+}
+/**
+ * Return true if el has a custom-element ancestor in the given units list.
+ */
+function isNested(el, allUnits) {
+    let parent = el.parentElement;
+    while (parent !== null) {
+        if (allUnits.includes(parent))
+            return true;
+        parent = parent.parentElement;
+    }
+    return false;
+}
+/**
+ * Extract a Record<string,unknown> from an element's attribute list.
+ */
+function attrsToProps(el) {
+    const props = {};
+    for (const attr of el.attributes) {
+        props[attr.name] = attr.value;
+    }
+    return props;
+}
+export async function build({ pages, out, fs }) {
+    for (const { route, module } of pages) {
+        const body = await module.default();
+        const head = module.head ? await module.head() : undefined;
+        let bodyStr = renderToString(body);
+        let headStr = head != null ? renderToString(head) : "";
+        const template = window.document.createElement("template");
+        template.innerHTML = bodyStr;
+        const allUnits = scanAllUnits(template.content);
+        const props = allUnits.map(attrsToProps);
+        if (props.length > 0) {
+            const payload = buildPayload(props);
+            headStr += `<script type="application/json" id="__hydration">${payload}</script>`;
+        }
+        const nestedUnits = allUnits.filter((el) => isNested(el, allUnits));
+        const nestedTagNames = [...new Set(nestedUnits.map((el) => el.localName))];
+        for (const tag of nestedTagNames) {
+            // Replace opening tags: <tag> and <tag ...> with defer-hydration inserted.
+            bodyStr = bodyStr.replace(new RegExp(`<(${tag})( |>)`, "g"), (_match, t, after) => after === ">" ? `<${t} defer-hydration>` : `<${t} defer-hydration `);
+        }
+        const clientModules = module.clientModules ?? [];
+        if (allUnits.length > 0 || clientModules.length > 0) {
+            bodyStr = `${bodyStr}<script>${captureStubSource}</script>`;
+        }
+        if (clientModules.length > 0) {
+            const imports = clientModules.map((m) => `import "${m}";`).join("\n");
+            bodyStr = `${bodyStr}<script type="module" defer>\n${imports}\n</script>`;
+        }
+        const attrs = { lang: "en", ...module.htmlAttributes };
+        const attrsStr = Object.entries(attrs)
+            .map(([k, v]) => ` ${k}="${v}"`)
+            .join("");
+        const html = `<!doctype html><html${attrsStr}><head>${headStr}</head><body>${bodyStr}</body></html>`;
+        const segment = route.replace(/^\//, "");
+        const dir = segment ? `${out}/${segment}` : out;
+        const path = `${dir}/index.html`;
+        await fs.mkdir(dir);
+        await fs.writeFile(path, html);
+    }
+}

package/lib/esm/transpile.d.mts

@@ -0,0 +1,3 @@
+export function transpile(url: string, get: () => Promise<{
+    toString(): string;
+}>): Promise<any>;

package/lib/esm/transpile.mjs

@@ -0,0 +1,12 @@
+import tsBlankSpace from "ts-blank-space";
+const tsmap = new Map();
+export async function transpile(
+/** @type string */ url, 
+/** @type {() => Promise<{toString(): string}>} */ get) {
+    if (!tsmap.has(url)) {
+        const source = (await get()).toString();
+        const js = tsBlankSpace(source);
+        tsmap.set(url, js);
+    }
+    return tsmap.get(url);
+}

package/package.json

@@ -1,25 +1,28 @@
 {
   "name": "@davidsouther/jiffies",
-  "version": "2026.24.0",
+  "version": "2026.24.2",
   "private": false,
   "displayName": "JEFRi Jiffies",
   "type": "module",
   "exports": {
-    "./*.ts": "./src/*.ts"
+    "./*.ts": {
+      "types": "./lib/esm/*.d.ts",
+      "default": "./lib/esm/*.js"
+    }
   },
   "files": [
-    "src",
-    "!src/**/*.test.ts",
+    "lib",
     "LICENSE",
     "package.json",
-    "README.md",
-    "tsconfig.json"
+    "README.md"
   ],
   "engines": {
     "node": ">=22.18.0"
   },
   "scripts": {
     "start": "node ./src/server/main.ts",
+    "build": "tsc -p tsconfig.build.json",
+    "prepublishOnly": "npm run build",
     "test": "node --test --test-reporter=tap",
     "ci": "node --test --test-reporter=junit",
     "format": "biome format --write",
@@ -27,7 +30,8 @@
     "check:format": "biome format",
     "check:lint": "biome check",
     "all": "npm run check:lint && npm run test",
-    "stamp": "node scripts/stamp.ts"
+    "prepublish": "npm run build",
+    "publish": "node scripts/stamp.ts"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.3.11",