@stringsync/splates 0.0.61 → 1.13.3

package/vendor/core/log/composite-logger.d.ts

@@ -0,0 +1,7 @@
+import type { Logger } from "./logger";
+export declare class CompositeLogger implements Logger {
+    private loggers;
+    constructor(loggers: [Logger, ...Logger[]]);
+    info(message: unknown, ...optionalParams: unknown[]): void;
+    error(message: unknown, ...optionalParams: unknown[]): void;
+}

package/vendor/core/log/console-logger.d.ts

@@ -0,0 +1,6 @@
+import type { Logger } from "./logger";
+/** Writes straight to the process's own console: stdout for info, stderr for errors. */
+export declare class ConsoleLogger implements Logger {
+    info(message: unknown, ...optionalParams: unknown[]): void;
+    error(message: unknown, ...optionalParams: unknown[]): void;
+}

package/vendor/core/log/index.d.ts

@@ -0,0 +1,8 @@
+export { color } from "./color";
+export { CompositeLogger } from "./composite-logger";
+export { ConsoleLogger } from "./console-logger";
+export { LevelPrefixLogger, type LevelPrefixLoggerOptions, } from "./level-prefix-logger";
+export type { LogEntry, Logger, LogLevel } from "./logger";
+export { MdcLogger, type MdcLoggerOptions } from "./mdc-logger";
+export { MemoryLogger } from "./memory-logger";
+export { PrefixLogger, type PrefixLoggerOptions } from "./prefix-logger";

package/vendor/core/log/index.js

@@ -0,0 +1,154 @@
+// log/color.ts
+var ESC = "\x1B";
+var FG_RESET = "39";
+var INTENSITY_RESET = "22";
+
+class color {
+  constructor() {
+    throw new Error("color is a static-only class and cannot be instantiated.");
+  }
+  static red(value) {
+    return color.wrap("31", FG_RESET, value);
+  }
+  static yellow(value) {
+    return color.wrap("33", FG_RESET, value);
+  }
+  static green(value) {
+    return color.wrap("32", FG_RESET, value);
+  }
+  static blue(value) {
+    return color.wrap("34", FG_RESET, value);
+  }
+  static magenta(value) {
+    return color.wrap("35", FG_RESET, value);
+  }
+  static dim(value) {
+    return color.wrap("2", INTENSITY_RESET, value);
+  }
+  static bold(value) {
+    return color.wrap("1", INTENSITY_RESET, value);
+  }
+  static gray(value) {
+    return color.wrap("90", FG_RESET, value);
+  }
+  static strip(value) {
+    return String(value).replaceAll(new RegExp(`${ESC}\\[\\d+m`, "g"), "");
+  }
+  static wrap(code, reset, value) {
+    if (process.env.NO_COLOR) {
+      return String(value);
+    }
+    return `${ESC}[${code}m${String(value)}${ESC}[${reset}m`;
+  }
+}
+// log/composite-logger.ts
+class CompositeLogger {
+  loggers;
+  constructor(loggers) {
+    this.loggers = loggers;
+  }
+  info(message, ...optionalParams) {
+    for (const logger of this.loggers) {
+      logger.info(message, ...optionalParams);
+    }
+  }
+  error(message, ...optionalParams) {
+    for (const logger of this.loggers) {
+      logger.error(message, ...optionalParams);
+    }
+  }
+}
+// log/console-logger.ts
+import { format } from "node:util";
+
+class ConsoleLogger {
+  info(message, ...optionalParams) {
+    console.log(message, ...optionalParams);
+  }
+  error(message, ...optionalParams) {
+    process.stderr.write(`${format(message, ...optionalParams)}
+`);
+  }
+}
+// log/prefix-logger.ts
+class PrefixLogger {
+  prefix;
+  log;
+  constructor(prefix, opts = {}) {
+    this.prefix = prefix;
+    this.log = opts.log ?? new ConsoleLogger;
+  }
+  info(message, ...optionalParams) {
+    this.log.info(`${this.prefix} ${message}`, ...optionalParams);
+  }
+  error(message, ...optionalParams) {
+    this.log.error(`${this.prefix} ${message}`, ...optionalParams);
+  }
+}
+
+// log/level-prefix-logger.ts
+class LevelPrefixLogger {
+  infoLogger;
+  errorLogger;
+  constructor(opts = {}) {
+    const log = opts.log ?? new ConsoleLogger;
+    this.infoLogger = new PrefixLogger("[INFO]", { log });
+    this.errorLogger = new PrefixLogger("[ERROR]", { log });
+  }
+  info(message, ...optionalParams) {
+    this.infoLogger.info(message, ...optionalParams);
+  }
+  error(message, ...optionalParams) {
+    this.errorLogger.error(message, ...optionalParams);
+  }
+}
+// log/mdc-logger.ts
+class MdcLogger {
+  context;
+  log;
+  constructor(context, opts = {}) {
+    this.context = context;
+    this.log = opts.log ?? new ConsoleLogger;
+  }
+  info(message, ...optionalParams) {
+    this.log.info(this.withMdcPrefix(message), ...optionalParams);
+  }
+  error(message, ...optionalParams) {
+    this.log.error(this.withMdcPrefix(message), ...optionalParams);
+  }
+  withContext(context) {
+    return new MdcLogger({ ...this.context, ...context }, { log: this.log });
+  }
+  withMdcPrefix(message) {
+    const prefix = Object.entries(this.context).map(([key, value]) => `[${key}=${String(value)}]`).join(" ");
+    if (prefix.length === 0) {
+      return `${message}`;
+    }
+    return `${prefix} ${message}`;
+  }
+}
+// log/memory-logger.ts
+class MemoryLogger {
+  entries = [];
+  info(message, ...optionalParams) {
+    this.entries.push(this.createEntry("info", message, optionalParams));
+  }
+  error(message, ...optionalParams) {
+    this.entries.push(this.createEntry("error", message, optionalParams));
+  }
+  clear() {
+    this.entries.length = 0;
+  }
+  createEntry(level, message, optionalParams) {
+    return { level, message, optionalParams, timestamp: new Date };
+  }
+}
+export {
+  CompositeLogger,
+  ConsoleLogger,
+  LevelPrefixLogger,
+  MdcLogger,
+  MemoryLogger,
+  PrefixLogger,
+  color
+};

package/vendor/core/log/level-prefix-logger.d.ts

@@ -0,0 +1,12 @@
+import type { Logger } from "./logger";
+/** What a `LevelPrefixLogger` writes through; the console by default. */
+export interface LevelPrefixLoggerOptions {
+    log?: Logger;
+}
+export declare class LevelPrefixLogger implements Logger {
+    private infoLogger;
+    private errorLogger;
+    constructor(opts?: LevelPrefixLoggerOptions);
+    info(message: unknown, ...optionalParams: unknown[]): void;
+    error(message: unknown, ...optionalParams: unknown[]): void;
+}

package/vendor/core/log/logger.d.ts

@@ -0,0 +1,12 @@
+/** The logging seam. Typically assigned the variable name `log`. */
+export interface Logger {
+    info(message: unknown, ...optionalParams: unknown[]): void;
+    error(message: unknown, ...optionalParams: unknown[]): void;
+}
+export type LogLevel = "info" | "error";
+export interface LogEntry {
+    level: LogLevel;
+    message: unknown;
+    optionalParams: unknown[];
+    timestamp: Date;
+}

package/vendor/core/log/mdc-logger.d.ts

@@ -0,0 +1,14 @@
+import type { Logger } from "./logger";
+/** What an `MdcLogger` writes through; the console by default. */
+export interface MdcLoggerOptions {
+    log?: Logger;
+}
+export declare class MdcLogger implements Logger {
+    private context;
+    private log;
+    constructor(context: Record<string, unknown>, opts?: MdcLoggerOptions);
+    info(message: unknown, ...optionalParams: unknown[]): void;
+    error(message: unknown, ...optionalParams: unknown[]): void;
+    withContext(context: Record<string, unknown>): MdcLogger;
+    private withMdcPrefix;
+}

package/vendor/core/log/memory-logger.d.ts

@@ -0,0 +1,8 @@
+import type { LogEntry, Logger } from "./logger";
+export declare class MemoryLogger implements Logger {
+    readonly entries: LogEntry[];
+    info(message: unknown, ...optionalParams: unknown[]): void;
+    error(message: unknown, ...optionalParams: unknown[]): void;
+    clear(): void;
+    private createEntry;
+}

package/vendor/core/log/prefix-logger.d.ts

@@ -0,0 +1,12 @@
+import type { Logger } from "./logger";
+/** What a `PrefixLogger` writes through; the console by default. */
+export interface PrefixLoggerOptions {
+    log?: Logger;
+}
+export declare class PrefixLogger implements Logger {
+    private prefix;
+    private log;
+    constructor(prefix: string, opts?: PrefixLoggerOptions);
+    info(message: unknown, ...optionalParams: unknown[]): void;
+    error(message: unknown, ...optionalParams: unknown[]): void;
+}

package/vendor/core/md/index.d.ts

@@ -0,0 +1,2 @@
+export { type CodeBlock, Markdown, MarkdownError, Section, } from "./markdown";
+export { MarkdownWriter } from "./writer";

package/vendor/core/md/index.js

@@ -0,0 +1,182 @@
+// md/markdown.ts
+class Markdown {
+  text;
+  fields;
+  body;
+  sections;
+  constructor(text, fields, body, sections) {
+    this.text = text;
+    this.fields = fields;
+    this.body = body;
+    this.sections = sections;
+  }
+  static parse(text) {
+    const { fields, body, offset } = frontmatter(text);
+    return new Markdown(text, fields, body, sections(body, offset));
+  }
+  get title() {
+    return this.sections.find((section) => section.level === 1)?.heading ?? null;
+  }
+  field(name) {
+    const value = this.fields[name];
+    if (value === undefined) {
+      throw new MarkdownError(`no field "${name}" (have: ${Object.keys(this.fields).join(", ") || "none"})`);
+    }
+    return value;
+  }
+  has(heading) {
+    return this.find(heading) !== undefined;
+  }
+  section(heading) {
+    const found = this.find(heading);
+    if (!found) {
+      throw new MarkdownError(`no section "${heading}" (have: ${this.sections.map((section) => section.heading).join(", ") || "none"})`);
+    }
+    return found;
+  }
+  find(heading) {
+    const want = heading.toLowerCase();
+    return this.sections.find((section) => section.heading.toLowerCase() === want);
+  }
+}
+
+class MarkdownError extends Error {
+}
+
+class Section {
+  heading;
+  level;
+  line;
+  body;
+  lead;
+  constructor(heading, level, line, body, lead) {
+    this.heading = heading;
+    this.level = level;
+    this.line = line;
+    this.body = body;
+    this.lead = lead;
+  }
+  codeBlocks(scope = "body") {
+    const blocks = [];
+    let fence = null;
+    for (const line of this[scope].split(`
+`)) {
+      const open = line.match(/^(```+|~~~+)\s*(\S*)/);
+      if (fence === null && open) {
+        fence = { mark: open[1] ?? "`", lang: open[2] ?? "", code: [] };
+      } else if (fence !== null && open && open[2] === "" && open[1]?.[0] === fence.mark[0]) {
+        blocks.push({ lang: fence.lang, code: fence.code.join(`
+`) });
+        fence = null;
+      } else if (fence !== null) {
+        fence.code.push(line);
+      }
+    }
+    return blocks;
+  }
+}
+function frontmatter(text) {
+  const match = text.match(/^---\n([\s\S]*?)\n---(?:\n|$)/);
+  if (!match) {
+    return { fields: {}, body: text, offset: 0 };
+  }
+  const fields = {};
+  for (const line of (match[1] ?? "").split(`
+`)) {
+    const kv = line.match(/^(\S+):\s*(.*)$/);
+    if (kv?.[1]) {
+      fields[kv[1]] = (kv[2] ?? "").trim().replace(/^(["'])(.*)\1$/, "$2");
+    }
+  }
+  return {
+    fields,
+    body: text.slice(match[0].length),
+    offset: match[0].split(`
+`).length - 1
+  };
+}
+function sections(body, offset) {
+  const lines = body.split(`
+`);
+  const heads = [];
+  let fence = null;
+  for (const [index, line] of lines.entries()) {
+    const mark = line.match(/^(```+|~~~+)/)?.[1];
+    if (mark) {
+      fence = fence === null ? mark : fence[0] === mark[0] ? null : fence;
+      continue;
+    }
+    const head = fence === null && line.match(/^(#{1,6})\s+(.*)$/);
+    if (head) {
+      heads.push({
+        heading: (head[2] ?? "").trim(),
+        level: (head[1] ?? "#").length,
+        index
+      });
+    }
+  }
+  return heads.map(({ heading, level, index }, i) => {
+    const next = heads.slice(i + 1);
+    const end = next.find((later) => later.level <= level)?.index ?? lines.length;
+    const child = next.find((later) => later.index < end)?.index ?? end;
+    return new Section(heading, level, index + offset + 1, lines.slice(index + 1, end).join(`
+`).trim(), lines.slice(index + 1, child).join(`
+`).trim());
+  });
+}
+// md/writer.ts
+class MarkdownWriter {
+  fields = new Map;
+  blocks = [];
+  field(name, value) {
+    this.fields.set(name, value);
+    return this;
+  }
+  heading(level, text) {
+    this.blocks.push(`${"#".repeat(level)} ${text}`);
+    return this;
+  }
+  text(prose) {
+    this.blocks.push(prose);
+    return this;
+  }
+  list(...items) {
+    if (items.length > 0) {
+      this.blocks.push(items.map((item) => `- ${item}`).join(`
+`));
+    }
+    return this;
+  }
+  checklist(...items) {
+    return this.list(...items.map((item) => `[ ] ${item}`));
+  }
+  code(lang, code) {
+    const runs = code.match(/`+/g) ?? [];
+    const mark = "`".repeat(Math.max(3, ...runs.map((run) => run.length + 1)));
+    this.blocks.push(`${mark}${lang}
+${code}
+${mark}`);
+    return this;
+  }
+  toString() {
+    const front = this.fields.size > 0 ? [
+      "---",
+      ...[...this.fields].map(([key, value]) => `${key}: ${value}`),
+      "---",
+      ""
+    ] : [];
+    return [...front, this.blocks.join(`
+
+`), ""].join(`
+`);
+  }
+  toMarkdown() {
+    return Markdown.parse(this.toString());
+  }
+}
+export {
+  Markdown,
+  MarkdownError,
+  MarkdownWriter,
+  Section
+};

package/vendor/core/md/markdown.d.ts

@@ -0,0 +1,56 @@
+/**
+ * A markdown document you can pull data out of: frontmatter fields, sections
+ * by heading, fenced code. Markdown is the glue language between humans and
+ * agents, so the accessors are strict: asking for a field or section that is
+ * not there throws rather than returning undefined, which is what lets a
+ * caller treat a document as a data source instead of hand-rolling regexes.
+ */
+export declare class Markdown {
+    /** The full source text, verbatim. */
+    readonly text: string;
+    /** Frontmatter key/values. Empty object when there is no frontmatter. */
+    readonly fields: Record<string, string>;
+    /** The text after the frontmatter. */
+    readonly body: string;
+    /** Every heading in the document, in order, all levels. */
+    readonly sections: Section[];
+    private constructor();
+    static parse(text: string): Markdown;
+    /** First level-1 heading, or null when the document has none. */
+    get title(): string | null;
+    /** Throws when the field is absent. */
+    field(name: string): string;
+    has(heading: string): boolean;
+    /** The section under `heading` (case-insensitive). Throws when absent. */
+    section(heading: string): Section;
+    private find;
+}
+/** Thrown when an accessor is asked for something the document does not have. */
+export declare class MarkdownError extends Error {
+}
+export interface CodeBlock {
+    /** The fence's info string, e.g. "ts". Empty when the fence has none. */
+    lang: string;
+    code: string;
+}
+/**
+ * One heading and everything under it. `body` runs until the next heading of
+ * the same or a higher level, so subsections are included; `lead` stops at the
+ * first child heading, so it is the section's own prose.
+ */
+export declare class Section {
+    readonly heading: string;
+    readonly level: number;
+    /** 1-based line of the heading in the source document. */
+    readonly line: number;
+    readonly body: string;
+    readonly lead: string;
+    constructor(heading: string, level: number, 
+    /** 1-based line of the heading in the source document. */
+    line: number, body: string, lead: string);
+    /**
+     * Fenced code blocks, in `body` (subsections included, the default) or
+     * just this section's own `lead`.
+     */
+    codeBlocks(scope?: "body" | "lead"): CodeBlock[];
+}

package/vendor/core/md/writer.d.ts

@@ -0,0 +1,22 @@
+import { Markdown } from "./markdown";
+/**
+ * Composes a markdown document block by block: the write half of `Markdown`.
+ * Fields render as frontmatter at the top no matter when they are set, so call
+ * order carries no traps; everything else appends in order.
+ */
+export declare class MarkdownWriter {
+    private fields;
+    private blocks;
+    field(name: string, value: string): this;
+    heading(level: number, text: string): this;
+    text(prose: string): this;
+    /** A bullet list, one item per line. No items writes nothing. */
+    list(...items: string[]): this;
+    /** A bullet list of unchecked task items, `- [ ]` apiece. */
+    checklist(...items: string[]): this;
+    /** A fenced block. The fence outruns any backtick run in the code. */
+    code(lang: string, code: string): this;
+    toString(): string;
+    /** The document, parsed back, handy when the caller wants accessors. */
+    toMarkdown(): Markdown;
+}

package/vendor/core/push/base64url.d.ts

@@ -0,0 +1,2 @@
+export declare function base64url(bytes: Uint8Array): string;
+export declare function bytesOf(text: string): Uint8Array<ArrayBuffer>;

package/vendor/core/push/encrypt.d.ts

@@ -0,0 +1,12 @@
+import type { Subscription } from "./pusher";
+/** What a test fixes to check against a known vector; random otherwise. */
+export interface Ephemeral {
+    keys: CryptoKeyPair;
+    salt: Uint8Array<ArrayBuffer>;
+}
+/**
+ * Encrypts `payload` to `subscription` as an `aes128gcm` body (RFC 8291):
+ * a header carrying the salt and this message's public key, then the one
+ * record, which only the browser that subscribed can open.
+ */
+export declare function encrypt(subscription: Subscription, payload: Uint8Array, ephemeral?: Ephemeral): Promise<Uint8Array<ArrayBuffer>>;

package/vendor/core/push/index.d.ts

@@ -0,0 +1,4 @@
+export { PushFailure } from "./push-failure";
+export type { Pusher, PushOptions, Subscription } from "./pusher";
+export { generateVapidKeys, type VapidKeys, vapidAuthorization, } from "./vapid";
+export { WebPusher, type WebPusherOptions } from "./web-pusher";

package/vendor/core/push/index.js

@@ -0,0 +1,137 @@
+// push/push-failure.ts
+class PushFailure extends Error {
+  status;
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+    this.name = "PushFailure";
+  }
+  get gone() {
+    return this.status === 404 || this.status === 410;
+  }
+}
+// push/base64url.ts
+function base64url(bytes) {
+  return bytes.toBase64({ alphabet: "base64url", omitPadding: true });
+}
+function bytesOf(text) {
+  return Uint8Array.fromBase64(text, { alphabet: "base64url" });
+}
+
+// push/vapid.ts
+async function generateVapidKeys() {
+  const pair = await crypto.subtle.generateKey({ name: "ECDSA", namedCurve: "P-256" }, true, ["sign", "verify"]);
+  const raw = await crypto.subtle.exportKey("raw", pair.publicKey);
+  const { d } = await crypto.subtle.exportKey("jwk", pair.privateKey);
+  if (d === undefined) {
+    throw new Error("the private key exported without its scalar");
+  }
+  return { publicKey: base64url(new Uint8Array(raw)), privateKey: d };
+}
+async function vapidAuthorization(keys, endpoint, subject, expiresAt) {
+  const encode = (value) => base64url(new TextEncoder().encode(JSON.stringify(value)));
+  const unsigned = `${encode({ typ: "JWT", alg: "ES256" })}.${encode({
+    aud: new URL(endpoint).origin,
+    exp: Math.floor(expiresAt / 1000),
+    sub: subject
+  })}`;
+  const point = bytesOf(keys.publicKey);
+  const key = await crypto.subtle.importKey("jwk", {
+    kty: "EC",
+    crv: "P-256",
+    x: base64url(point.slice(1, 33)),
+    y: base64url(point.slice(33, 65)),
+    d: keys.privateKey
+  }, { name: "ECDSA", namedCurve: "P-256" }, false, ["sign"]);
+  const signature = await crypto.subtle.sign({ name: "ECDSA", hash: "SHA-256" }, key, new TextEncoder().encode(unsigned));
+  return `vapid t=${unsigned}.${base64url(new Uint8Array(signature))}, k=${keys.publicKey}`;
+}
+// push/web-pusher.ts
+import { SystemWallClock } from "../time/index.js";
+
+// push/encrypt.ts
+var RECORD_SIZE = 4096;
+async function encrypt(subscription, payload, ephemeral) {
+  const browserKey = bytesOf(subscription.keys.p256dh);
+  const auth = bytesOf(subscription.keys.auth);
+  const { keys, salt } = ephemeral ?? {
+    keys: await crypto.subtle.generateKey({ name: "ECDH", namedCurve: "P-256" }, true, ["deriveBits"]),
+    salt: crypto.getRandomValues(new Uint8Array(16))
+  };
+  const serverKey = new Uint8Array(await crypto.subtle.exportKey("raw", keys.publicKey));
+  const shared = await crypto.subtle.deriveBits({
+    name: "ECDH",
+    public: await crypto.subtle.importKey("raw", browserKey, { name: "ECDH", namedCurve: "P-256" }, false, [])
+  }, keys.privateKey, 256);
+  const ikm = await hkdf(auth, new Uint8Array(shared), concat(text("WebPush: info\x00"), browserKey, serverKey), 32);
+  const cek = await hkdf(salt, ikm, text("Content-Encoding: aes128gcm\x00"), 16);
+  const nonce = await hkdf(salt, ikm, text("Content-Encoding: nonce\x00"), 12);
+  const sealed = await crypto.subtle.encrypt({ name: "AES-GCM", iv: nonce }, await crypto.subtle.importKey("raw", cek, "AES-GCM", false, ["encrypt"]), concat(payload, new Uint8Array([2])));
+  const size = new Uint8Array(4);
+  new DataView(size.buffer).setUint32(0, RECORD_SIZE);
+  return concat(salt, size, new Uint8Array([serverKey.length]), serverKey, new Uint8Array(sealed));
+}
+async function hkdf(salt, ikm, info, length) {
+  const key = await crypto.subtle.importKey("raw", ikm, "HKDF", false, [
+    "deriveBits"
+  ]);
+  return new Uint8Array(await crypto.subtle.deriveBits({ name: "HKDF", hash: "SHA-256", salt, info }, key, length * 8));
+}
+function text(value) {
+  return new TextEncoder().encode(value);
+}
+function concat(...parts) {
+  const joined = new Uint8Array(parts.reduce((sum, part) => sum + part.length, 0));
+  let at = 0;
+  for (const part of parts) {
+    joined.set(part, at);
+    at += part.length;
+  }
+  return joined;
+}
+
+// push/web-pusher.ts
+var SIGNED_FOR_MS = 12 * 60 * 60 * 1000;
+var DAY_SECS = 24 * 60 * 60;
+
+class WebPusher {
+  keys;
+  subject;
+  fetcher;
+  clock;
+  constructor(keys, subject, opts = {}) {
+    this.keys = keys;
+    this.subject = subject;
+    this.fetcher = opts.fetch ?? fetch;
+    this.clock = opts.clock ?? new SystemWallClock;
+  }
+  async push(subscription, payload, opts = {}) {
+    const headers = {
+      authorization: await vapidAuthorization(this.keys, subscription.endpoint, this.subject, this.clock.now() + SIGNED_FOR_MS),
+      "content-encoding": "aes128gcm",
+      "content-type": "application/octet-stream",
+      ttl: String(opts.ttlSecs ?? DAY_SECS)
+    };
+    if (opts.urgency !== undefined) {
+      headers.urgency = opts.urgency;
+    }
+    if (opts.topic !== undefined) {
+      headers.topic = opts.topic;
+    }
+    const response = await this.fetcher(subscription.endpoint, {
+      method: "POST",
+      headers,
+      body: await encrypt(subscription, new TextEncoder().encode(payload))
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      throw new PushFailure(`${new URL(subscription.endpoint).origin} answered ${response.status}: ${text.slice(0, 300)}`, response.status);
+    }
+  }
+}
+export {
+  PushFailure,
+  WebPusher,
+  generateVapidKeys,
+  vapidAuthorization
+};

package/vendor/core/push/push-failure.d.ts

@@ -0,0 +1,7 @@
+/** A push service refused a message; `status` is its HTTP status. */
+export declare class PushFailure extends Error {
+    readonly status: number;
+    constructor(message: string, status: number);
+    /** Whether the subscription is gone for good, so it should be forgotten. */
+    get gone(): boolean;
+}