@forgezero/runtime 0.1.0

package/dist/importers.js

@@ -0,0 +1,250 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/importers.ts
+function normaliseName(raw) {
+  return raw.trim().replace(/[^A-Za-z0-9]+/g, "_").replace(/^_+|_+$/g, "").replace(/_{2,}/g, "_").toUpperCase();
+}
+function dedupe(secrets) {
+  const seen = new Map;
+  const skipped = [];
+  for (const secret of secrets) {
+    const existing = seen.get(secret.name);
+    if (existing) {
+      skipped.push({
+        at: secret.source,
+        reason: `${secret.name} was already taken by ${existing.source}. The first one was kept.`
+      });
+      continue;
+    }
+    seen.set(secret.name, secret);
+  }
+  return { secrets: [...seen.values()], skipped };
+}
+function parseEnv(text) {
+  const secrets = [];
+  const skipped = [];
+  const lines = text.split(/\r?\n/);
+  for (let index = 0;index < lines.length; index += 1) {
+    const at = `line ${index + 1}`;
+    let line = lines[index].trim();
+    if (!line || line.startsWith("#"))
+      continue;
+    if (line.startsWith("export "))
+      line = line.slice(7).trim();
+    const split = line.indexOf("=");
+    if (split <= 0) {
+      skipped.push({ at, reason: "No `=`, so there is no name and value here." });
+      continue;
+    }
+    const name = normaliseName(line.slice(0, split));
+    if (!name) {
+      skipped.push({ at, reason: "The name is empty once normalised." });
+      continue;
+    }
+    let value = line.slice(split + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') && value.length >= 2 || value.startsWith("'") && value.endsWith("'") && value.length >= 2) {
+      value = value.slice(1, -1);
+    } else {
+      const comment = value.indexOf(" #");
+      if (comment >= 0)
+        value = value.slice(0, comment).trim();
+    }
+    if (!value) {
+      skipped.push({ at, reason: `${name} has no value. An empty secret is almost never intended.` });
+      continue;
+    }
+    secrets.push({ name, value, source: at });
+  }
+  const result = dedupe(secrets);
+  return { secrets: result.secrets, skipped: [...skipped, ...result.skipped] };
+}
+function parseCsvRows(text) {
+  const rows = [];
+  let row = [];
+  let field = "";
+  let quoted = false;
+  for (let index = 0;index < text.length; index += 1) {
+    const char = text[index];
+    if (quoted) {
+      if (char === '"') {
+        if (text[index + 1] === '"') {
+          field += '"';
+          index += 1;
+        } else
+          quoted = false;
+      } else
+        field += char;
+      continue;
+    }
+    if (char === '"')
+      quoted = true;
+    else if (char === ",") {
+      row.push(field);
+      field = "";
+    } else if (char === `
+`) {
+      row.push(field.replace(/\r$/, ""));
+      rows.push(row);
+      row = [];
+      field = "";
+    } else
+      field += char;
+  }
+  if (field || row.length > 0) {
+    row.push(field.replace(/\r$/, ""));
+    rows.push(row);
+  }
+  return rows.filter((entry) => entry.some((cell) => cell.trim()));
+}
+function parseCsv(text) {
+  const rows = parseCsvRows(text);
+  if (rows.length < 2)
+    return { secrets: [], skipped: [{ at: "file", reason: "No rows below the header." }] };
+  const header = rows[0].map((cell) => cell.trim().toLowerCase());
+  const nameColumn = header.findIndex((cell) => ["name", "title", "key", "label"].includes(cell));
+  const valueColumn = header.findIndex((cell) => ["password", "value", "secret", "credential"].includes(cell));
+  if (nameColumn < 0 || valueColumn < 0) {
+    return {
+      secrets: [],
+      skipped: [
+        {
+          at: "header",
+          reason: "No name and value column found. Expected a header with one of name/title/key/label and one of password/value/secret/credential."
+        }
+      ]
+    };
+  }
+  const noteColumn = header.findIndex((cell) => ["notes", "note", "comment"].includes(cell));
+  const secrets = [];
+  const skipped = [];
+  for (let index = 1;index < rows.length; index += 1) {
+    const row = rows[index];
+    const at = `row ${index + 1}`;
+    const rawName = row[nameColumn]?.trim() ?? "";
+    const value = row[valueColumn] ?? "";
+    if (!rawName) {
+      skipped.push({ at, reason: "No name." });
+      continue;
+    }
+    if (!value) {
+      skipped.push({ at, reason: `${normaliseName(rawName)} has no value.` });
+      continue;
+    }
+    secrets.push({
+      name: normaliseName(rawName),
+      value,
+      source: `${at} (${rawName})`,
+      note: noteColumn >= 0 ? row[noteColumn]?.trim() || undefined : undefined
+    });
+  }
+  const result = dedupe(secrets);
+  return { secrets: result.secrets, skipped: [...skipped, ...result.skipped] };
+}
+function parseBitwarden(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return { secrets: [], skipped: [{ at: "file", reason: "Not valid JSON." }] };
+  }
+  if (parsed.encrypted) {
+    return {
+      secrets: [],
+      skipped: [
+        {
+          at: "file",
+          reason: "This is an encrypted Bitwarden export. Export again with encryption off — importing it as-is would store ciphertext nobody can read."
+        }
+      ]
+    };
+  }
+  const items = Array.isArray(parsed.items) ? parsed.items : [];
+  const secrets = [];
+  const skipped = [];
+  for (const raw of items) {
+    const item = raw;
+    const title = item.name?.trim() ?? "";
+    const at = title || "an untitled item";
+    if (!title) {
+      skipped.push({ at, reason: "No name to import it under." });
+      continue;
+    }
+    const value = item.type === 1 ? item.login?.password : item.type === 2 ? item.notes : undefined;
+    if (!value) {
+      skipped.push({
+        at,
+        reason: item.type === 1 || item.type === 2 ? "Nothing to import — the item has no password or note." : "Not a login or a secure note. Cards and identities are not machine credentials."
+      });
+      continue;
+    }
+    secrets.push({
+      name: normaliseName(title),
+      value,
+      source: title,
+      note: item.type === 1 ? item.notes?.trim() || undefined : undefined
+    });
+  }
+  const result = dedupe(secrets);
+  return { secrets: result.secrets, skipped: [...skipped, ...result.skipped] };
+}
+function parseOnePassword(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return parseCsv(text);
+  }
+  const items = Array.isArray(parsed.items) ? parsed.items : (parsed.accounts ?? []).flatMap((account) => {
+    const vaults = account.vaults ?? [];
+    return vaults.flatMap((vault) => vault.items ?? []);
+  });
+  const secrets = [];
+  const skipped = [];
+  for (const raw of items) {
+    const item = raw;
+    const inner = item.item ?? item;
+    const title = (inner.overview?.title ?? "").trim();
+    const at = title || "an untitled item";
+    if (!title) {
+      skipped.push({ at, reason: "No name to import it under." });
+      continue;
+    }
+    const fields = inner.details?.loginFields ?? [];
+    const value = inner.details?.password ?? fields.find((field) => field.designation === "password")?.value ?? undefined;
+    if (!value) {
+      skipped.push({ at, reason: "No password field on this item." });
+      continue;
+    }
+    secrets.push({ name: normaliseName(title), value, source: title });
+  }
+  const result = dedupe(secrets);
+  return { secrets: result.secrets, skipped: [...skipped, ...result.skipped] };
+}
+var IMPORT_FORMATS = ["env", "csv", "bitwarden", "1password"];
+function parseImport(format, text) {
+  switch (format) {
+    case "env":
+      return parseEnv(text);
+    case "csv":
+      return parseCsv(text);
+    case "bitwarden":
+      return parseBitwarden(text);
+    case "1password":
+      return parseOnePassword(text);
+  }
+}
+export {
+  parseOnePassword,
+  parseImport,
+  parseEnv,
+  parseCsv,
+  parseBitwarden,
+  normaliseName,
+  IMPORT_FORMATS
+};

package/dist/jobs.d.ts

@@ -0,0 +1,171 @@
+/**
+ * Jobs — background work that does not corrupt anything when it goes wrong.
+ *
+ * ForgeZero needs session and step-up reaping, provider health probes and
+ * invoice runs. An exchange needs a deposit scanner and a withdrawal processor.
+ * They are the same machinery, and the same four mistakes sink all of them:
+ *
+ *   OVERLAP    `setInterval` fires again while the previous run is still going.
+ *              Two deposit scans reading the same block credit it twice.
+ *   CURSOR     the cursor advances past a batch that failed halfway, so the
+ *              deposits in it are never seen again and the shortfall is found
+ *              by a customer.
+ *   DUPLICATE  two processes run the same job because nothing coordinated them.
+ *   SHUTDOWN   a deploy kills a run mid-write, leaving a record half-updated.
+ *
+ * Each has a specific answer here: reschedule after completion rather than on
+ * an interval, advance only on a fully successful batch, take a fenced lock,
+ * and await in-flight work on stop.
+ *
+ * Zero dependencies. The lock and the cursor store are interfaces, so this runs
+ * against a database, Redis, or nothing at all in a test.
+ */
+/** Injected so a test does not sleep and a resumed run is reproducible. */
+export interface Clock {
+    now(): number;
+    sleep(ms: number, signal?: AbortSignal): Promise<void>;
+}
+export declare const systemClock: Clock;
+/** `30s` → 30000. Throws rather than guessing — a wrong interval is silent. */
+export declare function everyMs(interval: string | number): number;
+/**
+ * A lease, not a mutex.
+ *
+ * `until` is what makes a crash survivable: a process that dies holding a plain
+ * mutex blocks the job for ever, and somebody clears it by hand at three in the
+ * morning. A lease expires on its own.
+ *
+ * `fence` increases every time the lock is granted. A run that stalls past its
+ * lease, wakes up and tries to write finds its fence is stale and stops —
+ * without it, two processes each believing they hold the lock both write.
+ */
+export interface Lease {
+    fence: number;
+    until: number;
+}
+export interface JobLock {
+    acquire(key: string, ttlMs: number): Promise<Lease | undefined>;
+    /** Extend a lease held by this fence. False means it was lost. */
+    renew(key: string, fence: number, ttlMs: number): Promise<boolean>;
+    release(key: string, fence: number): Promise<void>;
+}
+/** Single process. Correct for one instance and honest about being no more. */
+export declare function memoryLock(clock?: Clock): JobLock;
+/**
+ * Backed by a store the caller supplies — one row per job key.
+ *
+ * The store's `claim` must be atomic. A read-then-write implementation hands
+ * the same lease to two processes under exactly the load that makes it matter.
+ */
+export interface LockStore {
+    claim(key: string, until: number, now: number): Promise<Lease | undefined>;
+    extend(key: string, fence: number, until: number): Promise<boolean>;
+    clear(key: string, fence: number): Promise<void>;
+}
+export declare function storeLock(store: LockStore, clock?: Clock): JobLock;
+export interface JobContext {
+    /** Aborted on stop. A long run should pass this to its own I/O. */
+    signal: AbortSignal;
+    /** Still ours? False means the lease was lost and the run must stop writing. */
+    holdsLock(): Promise<boolean>;
+    log(message: string, detail?: Record<string, unknown>): void;
+}
+export interface JobResult {
+    /** Anything worth showing on a status screen. Kept in the report verbatim. */
+    [key: string]: unknown;
+}
+export interface JobSpec {
+    key: string;
+    label: string;
+    /** `30s`, `5m`, or milliseconds. Omit for a job only ever run by hand. */
+    every?: string | number;
+    run(context: JobContext): Promise<JobResult | void>;
+    /**
+     * Lease length. Defaults to four intervals, so a slow run is not evicted the
+     * moment it exceeds its period — the most common cause of two runs at once.
+     */
+    leaseMs?: number;
+    /** Skip the lock. Only for work that is safe to run in every process. */
+    unlocked?: boolean;
+    /**
+     * Delay before the first run. Defaults to a per-job spread so eight processes
+     * booting together do not all hit the database in the same millisecond.
+     */
+    startDelayMs?: number;
+}
+export declare function defineJob(spec: JobSpec): JobSpec;
+export interface JobReport {
+    key: string;
+    label: string;
+    state: 'idle' | 'running' | 'paused' | 'stopped';
+    lastStartedAtMs?: number;
+    lastFinishedAtMs?: number;
+    lastDurationMs?: number;
+    lastResult?: JobResult;
+    lastError?: string;
+    consecutiveFailures: number;
+    runs: number;
+    skippedLocked: number;
+}
+export interface SchedulerOptions {
+    jobs: readonly JobSpec[];
+    lock?: JobLock;
+    clock?: Clock;
+    /** Called on every failure. Wire to telemetry; must not throw. */
+    onError?: (key: string, error: unknown) => void;
+    onLog?: (key: string, message: string, detail?: Record<string, unknown>) => void;
+}
+export declare function createScheduler(options: SchedulerOptions): {
+    start(): void;
+    /**
+     * Stop and WAIT. Returning before in-flight work settles is how a deploy
+     * leaves a record half-written — the process exits mid-transaction and the
+     * next boot finds state nothing can explain.
+     */
+    stop(): Promise<void>;
+    /** Timers stop firing; in-flight work is left to finish. */
+    pause(): void;
+    resume(): void;
+    /** Run one now, off-schedule. Still takes the lock. */
+    runNow(key: string): Promise<JobReport>;
+    status: () => readonly JobReport[];
+    report: (key: string) => JobReport | undefined;
+    isPaused: () => boolean;
+    isRunning: () => boolean;
+};
+export type Scheduler = ReturnType<typeof createScheduler>;
+export interface CursorStore {
+    read(key: string): Promise<string | undefined>;
+    /** Only ever called after a fully successful batch. */
+    write(key: string, cursor: string): Promise<void>;
+}
+export interface CursorBatch<T> {
+    items: readonly T[];
+    /** Where to resume. Written only if every item processed cleanly. */
+    next: string;
+    /** False stops this run — caught up. */
+    more?: boolean;
+}
+export interface CursorJobSpec<T> extends Omit<JobSpec, 'run'> {
+    store: CursorStore;
+    from: string;
+    fetch(cursor: string, context: JobContext): Promise<CursorBatch<T>>;
+    process(item: T, context: JobContext): Promise<void>;
+    /** Batches per run. Bounded so one run cannot hold the lease for ever. */
+    maxBatches?: number;
+}
+/**
+ * Walk forward from a stored position, advancing only on complete success.
+ *
+ * The rule that makes this safe is one line in the loop: the cursor is written
+ * AFTER every item in the batch processed, never before and never per item. If
+ * item three of ten throws, the whole batch is retried from the same cursor on
+ * the next run. That means `process` must be idempotent — items one and two will
+ * be seen again — and idempotent retries are strictly better than the
+ * alternative, which is deposits that are never seen at all.
+ *
+ * The lease is re-checked between batches. A run that stalled past its lease and
+ * woke up must not keep writing while another process is doing the same work.
+ */
+export declare function cursorJob<T>(spec: CursorJobSpec<T>): JobSpec;
+export declare const VERSION = "0.1.0";

package/dist/jobs.js

@@ -0,0 +1,250 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/jobs.ts
+var systemClock = {
+  now: () => Date.now(),
+  sleep: (ms, signal) => new Promise((resolve, reject) => {
+    if (signal?.aborted)
+      return reject(new Error("aborted"));
+    const timer = setTimeout(resolve, ms);
+    signal?.addEventListener("abort", () => {
+      clearTimeout(timer);
+      reject(new Error("aborted"));
+    });
+  })
+};
+var UNITS = { s: 1000, m: 60000, h: 3600000, d: 86400000 };
+function everyMs(interval) {
+  if (typeof interval === "number")
+    return interval;
+  const match = /^(\d+)([smhd])$/.exec(interval);
+  if (!match)
+    throw new Error(`"${interval}" is not an interval like 30s, 5m, 1h, 1d.`);
+  return Number(match[1]) * UNITS[match[2]];
+}
+function memoryLock(clock = systemClock) {
+  const held = new Map;
+  let fences = 0;
+  return {
+    async acquire(key, ttlMs) {
+      const current = held.get(key);
+      if (current && current.until > clock.now())
+        return;
+      fences += 1;
+      const lease = { fence: fences, until: clock.now() + ttlMs };
+      held.set(key, lease);
+      return lease;
+    },
+    async renew(key, fence, ttlMs) {
+      const current = held.get(key);
+      if (!current || current.fence !== fence)
+        return false;
+      current.until = clock.now() + ttlMs;
+      return true;
+    },
+    async release(key, fence) {
+      if (held.get(key)?.fence === fence)
+        held.delete(key);
+    }
+  };
+}
+function storeLock(store, clock = systemClock) {
+  return {
+    acquire: (key, ttlMs) => store.claim(key, clock.now() + ttlMs, clock.now()),
+    renew: (key, fence, ttlMs) => store.extend(key, fence, clock.now() + ttlMs),
+    release: (key, fence) => store.clear(key, fence)
+  };
+}
+function defineJob(spec) {
+  if (!spec.key.trim())
+    throw new Error("A job needs a key — it is the lock key and the report key.");
+  if (spec.every !== undefined)
+    everyMs(spec.every);
+  return spec;
+}
+function spreadOf(key, ceiling) {
+  let hash = 0;
+  for (const character of key)
+    hash = hash * 31 + character.charCodeAt(0) >>> 0;
+  return hash % Math.max(1, ceiling);
+}
+function createScheduler(options) {
+  const clock = options.clock ?? systemClock;
+  const lock = options.lock ?? memoryLock(clock);
+  const jobs = new Map(options.jobs.map((job) => [job.key, job]));
+  const reports = new Map(options.jobs.map((job) => [
+    job.key,
+    { key: job.key, label: job.label, state: "stopped", consecutiveFailures: 0, runs: 0, skippedLocked: 0 }
+  ]));
+  const timers = new Map;
+  const inFlight = new Map;
+  let controller = new AbortController;
+  let paused = false;
+  let running = false;
+  async function execute(job) {
+    const report = reports.get(job.key);
+    const leaseMs = job.leaseMs ?? (job.every ? everyMs(job.every) * 4 : 60000);
+    let lease;
+    if (!job.unlocked) {
+      lease = await lock.acquire(job.key, leaseMs);
+      if (!lease) {
+        report.skippedLocked += 1;
+        return;
+      }
+    }
+    report.state = "running";
+    report.lastStartedAtMs = clock.now();
+    const startedAt = clock.now();
+    try {
+      const result = await job.run({
+        signal: controller.signal,
+        holdsLock: async () => lease ? lock.renew(job.key, lease.fence, leaseMs) : true,
+        log: (message, detail) => options.onLog?.(job.key, message, detail)
+      });
+      report.lastResult = result ?? undefined;
+      report.lastError = undefined;
+      report.consecutiveFailures = 0;
+    } catch (error) {
+      report.lastError = error instanceof Error ? error.message : String(error);
+      report.consecutiveFailures += 1;
+      options.onError?.(job.key, error);
+    } finally {
+      report.runs += 1;
+      report.lastFinishedAtMs = clock.now();
+      report.lastDurationMs = clock.now() - startedAt;
+      report.state = paused ? "paused" : running ? "idle" : "stopped";
+      if (lease)
+        await lock.release(job.key, lease.fence).catch(() => {
+          return;
+        });
+    }
+  }
+  function schedule(job, delayMs) {
+    if (!running || job.every === undefined)
+      return;
+    timers.set(job.key, setTimeout(() => {
+      timers.delete(job.key);
+      if (!running || paused)
+        return;
+      const work = execute(job).finally(() => {
+        inFlight.delete(job.key);
+        schedule(job, everyMs(job.every));
+      });
+      inFlight.set(job.key, work);
+    }, delayMs));
+  }
+  return {
+    start() {
+      if (running)
+        return;
+      running = true;
+      paused = false;
+      controller = new AbortController;
+      for (const job of jobs.values()) {
+        reports.get(job.key).state = "idle";
+        const interval = job.every === undefined ? 0 : everyMs(job.every);
+        schedule(job, job.startDelayMs ?? spreadOf(job.key, Math.min(interval, 30000)));
+      }
+    },
+    async stop() {
+      running = false;
+      controller.abort();
+      for (const timer of timers.values())
+        clearTimeout(timer);
+      timers.clear();
+      await Promise.allSettled([...inFlight.values()]);
+      for (const report of reports.values())
+        report.state = "stopped";
+    },
+    pause() {
+      paused = true;
+      for (const timer of timers.values())
+        clearTimeout(timer);
+      timers.clear();
+      for (const report of reports.values()) {
+        if (report.state !== "running")
+          report.state = "paused";
+      }
+    },
+    resume() {
+      if (!running || !paused)
+        return;
+      paused = false;
+      for (const job of jobs.values()) {
+        reports.get(job.key).state = "idle";
+        schedule(job, 0);
+      }
+    },
+    async runNow(key) {
+      const job = jobs.get(key);
+      if (!job)
+        throw new Error(`No job named "${key}".`);
+      const existing = inFlight.get(key);
+      if (existing)
+        await existing;
+      const work = execute(job).finally(() => inFlight.delete(key));
+      inFlight.set(key, work);
+      await work;
+      return { ...reports.get(key) };
+    },
+    status: () => [...reports.values()].map((report) => ({ ...report })),
+    report: (key) => {
+      const found = reports.get(key);
+      return found ? { ...found } : undefined;
+    },
+    isPaused: () => paused,
+    isRunning: () => running
+  };
+}
+function cursorJob(spec) {
+  const maxBatches = spec.maxBatches ?? 10;
+  return defineJob({
+    key: spec.key,
+    label: spec.label,
+    every: spec.every,
+    leaseMs: spec.leaseMs,
+    unlocked: spec.unlocked,
+    startDelayMs: spec.startDelayMs,
+    async run(context) {
+      let cursor = await spec.store.read(spec.key) ?? spec.from;
+      let batches = 0;
+      let processed = 0;
+      while (batches < maxBatches) {
+        if (context.signal.aborted)
+          break;
+        if (!await context.holdsLock()) {
+          context.log("lease lost mid-run; stopping before any further write");
+          break;
+        }
+        const batch = await spec.fetch(cursor, context);
+        for (const item of batch.items) {
+          await spec.process(item, context);
+          processed += 1;
+        }
+        await spec.store.write(spec.key, batch.next);
+        cursor = batch.next;
+        batches += 1;
+        if (batch.more === false || batch.items.length === 0)
+          break;
+      }
+      return { cursor, batches, processed };
+    }
+  });
+}
+var VERSION = "0.1.0";
+export {
+  systemClock,
+  storeLock,
+  memoryLock,
+  everyMs,
+  defineJob,
+  cursorJob,
+  createScheduler,
+  VERSION
+};

package/dist/notify-templates.d.ts

@@ -0,0 +1,11 @@
+import { escapeHtml, type TemplateSpec } from './notify';
+export declare const signInCode: TemplateSpec<"code" | "minutes">;
+export declare const invitation: TemplateSpec<"link" | "inviter" | "organisation" | "days">;
+export declare const custodianEnrolment: TemplateSpec<"link" | "organisation" | "threshold" | "total">;
+export declare const ceremonyProposed: TemplateSpec<"link" | "proposer" | "change" | "needed">;
+export declare const newDevice: TemplateSpec<"at" | "device" | "location">;
+export declare const vaultLocked: TemplateSpec<"reason" | "link" | "threshold">;
+export declare const TEMPLATES: readonly [TemplateSpec<"code" | "minutes">, TemplateSpec<"link" | "inviter" | "organisation" | "days">, TemplateSpec<"link" | "organisation" | "threshold" | "total">, TemplateSpec<"link" | "proposer" | "change" | "needed">, TemplateSpec<"at" | "device" | "location">, TemplateSpec<"reason" | "link" | "threshold">];
+export type TemplateKey = (typeof TEMPLATES)[number]['key'];
+/** Escape helper re-exported so a caller building a body fragment need not import two modules. */
+export { escapeHtml };