@monoflake/sdk 0.0.0

package/dist/artifacts/src/types.d.ts

@@ -0,0 +1,396 @@
+import { LocaleCode } from "@canmi/me/locales";
+//#region artifacts/src/types.d.ts
+/** Which of the three things a text track is. WebVTT's own vocabulary, not ours. */
+export type CaptionKind = 'captions' | 'subtitles' | 'descriptions';
+export type VideoRung = {
+  src: string;
+  type: string;
+  width: number;
+  height: number;
+};
+/** One published text track, described by what the record says it is rather than by a label. */
+export type VideoTrack = {
+  src: string;
+  kind: CaptionKind;
+  language: string;
+};
+export type ArticleMeta = {
+  title: string;
+  subtitle: string;
+  description: string;
+  /** The source view's public BCP-47 language tag. */
+  lang: string;
+  created: string;
+  /** When the article went public, which is the date a reader is shown. The author's to edit. */
+  published: string;
+  lastmod: string;
+  /**
+   * Written but not published. Absent means published, so an article says nothing to stay
+   * ordinary and one word to be held back.
+   *
+   * A production build drops these before compiling them, so a draft has no page, no sitemap
+   * entry, no feed item and no search record. Every other build keeps them, which is what makes
+   * a draft previewable. See web's spec/drafts.md.
+   */
+  draft?: boolean;
+};
+export type Block = {
+  type: 'prose';
+  html: string;
+} | {
+  type: 'heading';
+  depth: number;
+  slug: string;
+  text: string;
+  /** Note numbers written into this heading. Absent from `text`, and so from the ToC. */
+  notes?: number[];
+} | {
+  type: 'code';
+  lang: string;
+  label?: string;
+  title?: string;
+  collapsible?: boolean;
+  default_expanded?: boolean;
+  html: string;
+  code: string;
+} | {
+  type: 'mermaid';
+  source: string;
+  ratio?: number;
+  description?: string;
+} | {
+  type: 'quadrant';
+  title: string;
+  description?: string;
+  /**
+   * What the figure reads as, from `local diagram`. Absent until one has been run.
+   *
+   * Not `description`, which is one line the author wrote to sit under the title. This
+   * is the whole figure said in prose, and it is translated, which is what the
+   * assembled-from-labels fallback never was.
+   */
+  reading?: string;
+  axes: Record<QuadrantDirection, string>;
+  items: QuadrantItem[];
+} | {
+  type: 'svgCanvas';
+  svg: string;
+  title: string;
+  /** What the drawing says, from `local diagram`. Absent until one has been run. */
+  description?: string;
+} | {
+  type: 'tokei';
+  source: string;
+  title: string;
+  view: TokeiView;
+} | {
+  type: 'cargo';
+  crate: CrateRecord;
+  view: CargoView;
+} | {
+  type: 'twitter';
+  tweet: TweetRecord;
+} | {
+  type: 'github';
+  repo: RepoRecord;
+  git_ref?: string;
+  title?: string;
+  align: CardAlign;
+} | {
+  type: 'linkcard';
+  src: string;
+  url: string;
+  title: string;
+  /**
+   * The site's mark, by rid, and never an address.
+   *
+   * An icon belongs to somebody else's site and is redrawn on their schedule, so what
+   * this resource currently holds is a fact about the corpus at the moment somebody
+   * asks -- not something a compiled article may carry. The whole key is absent for a
+   * site nothing has collected a mark for, and the role is spelled out so a page reads
+   * one name on every block: see `namedResources`, and spec/architecture/resource.md.
+   */
+  resources?: {
+    icon: string;
+  };
+  /** Which of that resource's files to draw. Selected at render time, not here. */
+  tone?: 'light' | 'dark';
+  width?: number;
+  height?: number;
+  preview?: string;
+  srcset?: string;
+  /** The cover's crop, defaulted like `::image`'s. See the `image` variant below. */
+  crop?: string;
+  /** `object-position` for that crop. Absent means centred. */
+  align?: string;
+  /** What the cover shows. Offered as the link's description, never as its name. */
+  description?: string;
+} | ({
+  type: 'article';
+  path: string;
+} & ArticleReference) | {
+  type: 'footnotes';
+  notes: ArticleNote[];
+} | {
+  type: 'placeholder';
+  kind: string;
+  meta: Record<string, string>;
+  /**
+   * An embed named but not yet fetched, as opposed to a stub the author wrote.
+   *
+   * The two had one shape and meant different things, which a consumer could not tell
+   * apart: `::cargo` whose record `local embed` has not filled in still says which crate
+   * the article meant, while `::placeholder` is the author asking for a gap. The feed is
+   * where it showed -- one of them belongs in a document a reader subscribes to and the
+   * other does not.
+   */
+  pending?: true;
+} | {
+  type: 'image';
+  /**
+   * The picture, by rid, and nothing derived from what it currently holds.
+   *
+   * Its ladder, its placeholder and its intrinsic box all move when the picture is
+   * encoded again, on nobody's schedule but the corpus's, so they are resolved per
+   * render and this names what they are resolved from. What is left is what the
+   * article itself decided. See spec/architecture/resource.md, "A rid is resolved
+   * three times".
+   */
+  resources: {
+    picture: string;
+  };
+  /**
+   * What the picture is called here, which is the article's to say.
+   *
+   * Baked, unlike the ladder above, because it changes on **this** repository's
+   * schedule: `local alt` writes it into a file beside the article, per locale, and a
+   * view carries the one it is written in rather than nine it is not.
+   */
+  alt: string;
+  /**
+   * A ratio to crop the displayed image to, as `16 / 9` ready for CSS.
+   *
+   * Cropping is presentation, so it is done by the browser with `object-fit` rather
+   * than by producing another object. A stored variant per ratio and alignment would
+   * multiply the bucket and, worse, make a content id mean "this image as shown here"
+   * instead of "this image".
+   */
+  crop?: string;
+  /** `object-position` for that crop. Absent means centred. */
+  align?: string;
+} | {
+  type: 'video';
+  /**
+   * The reference the article wrote, extension and all.
+   *
+   * Kept beside the resolved fields for the reason an image keeps it: an article can name
+   * a clip nothing has imported yet, and that should cost a fallback rather than a build.
+   */
+  src: string;
+  /** Every published rung, smallest first. Absent for a reference nothing resolved. */
+  rungs?: VideoRung[];
+  /** The original's dimensions, which reserve the box before anything is fetched. */
+  width?: number;
+  height?: number;
+  /** The poster image asset's own rendition, which is what `<video poster>` names. */
+  poster?: string;
+  /**
+   * What every sample of this clip is multiplied by, so two clips play at one level.
+   *
+   * Computed in the build from the loudness and true peak services/apps/local measured. `1` for
+   * a clip nothing has measured, which plays as it always did. See `assets.ts`.
+   */
+  gain?: number;
+  /** The poster's placeholder, painted under it while it arrives. */
+  preview?: string;
+  captions?: VideoTrack[];
+  /** What the clip shows. Offered as a description, never as the element's name. */
+  description?: string;
+  /** Where the clip came from, which is what the unsupported-format notice links to. */
+  source?: {
+    url: string;
+    label?: string;
+  };
+};
+/**
+ * What an `::article` card shows of the article it points at, in the view's own locale.
+ *
+ * The card reads these off the target rather than off the directive, so retitling an article
+ * retitles every card naming it and each translated view names it in its own language.
+ */
+export type ArticleReference = {
+  title: string;
+  subtitle: string;
+  /**
+   * The date the card draws, which is when the target went public and not when it was written.
+   *
+   * Named for what it holds rather than kept as `created` beside a second key: this is what a
+   * card shows, not what an article is, and a card shows one date. A record carries every fact
+   * it knows -- see `ArticleMeta` -- and a projection carries the one that is drawn.
+   */
+  published: string;
+  /** What a phone card shows instead, where the row clips. Falls back to the full form for a
+   *  view `local` has not written one for. See web's spec/i18n/prose.md. */
+  short_title: string;
+  short_subtitle: string;
+};
+/**
+ * One `:fn` note: the words it explains, the number it was given, and what it says.
+ *
+ * The phrase is carried so the collected note can name what it is about instead of asking a
+ * reader to hold the sentence they left in their head while they read it.
+ *
+ * Two notes with the same words are two notes. There is no label to say otherwise, and a reader
+ * who meets the same explanation twice was told it twice on purpose.
+ */
+export type ArticleNote = {
+  number: number;
+  phrase: string;
+  text: string;
+};
+export type TocEntry = {
+  slug: string;
+  text: string;
+  depth: number;
+};
+export type CardAlign = 'left' | 'center' | 'right';
+export type CargoView = 'treemap' | 'table';
+export type TokeiView = 'treemap' | 'bar' | 'table';
+export type QuadrantDirection = 'top' | 'right' | 'bottom' | 'left';
+export type QuadrantPosition = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+export type QuadrantItem = {
+  at: QuadrantPosition;
+  title: string;
+  note?: string;
+};
+export type Compiled = {
+  meta: ArticleMeta;
+  toc: TocEntry[];
+  blocks: Block[];
+  markdown: string;
+  text: string;
+};
+export type ArticleView = Pick<Compiled, 'meta' | 'toc' | 'blocks' | 'text'> & {
+  code: LocaleCode;
+  /**
+   * How long the article is in this view, in words.
+   *
+   * Body prose and what is inside it. Not `text`, which is every readable string on the page --
+   * a picture's description, a linkcard's title, a diagram's caption, an embedded post -- and
+   * which this used to be measured from, in characters, making a 9,102-character article read
+   * as 14,870. Those are components; a reader asking how long an article is does not mean them.
+   */
+  words: number;
+  language_tag: string;
+  canonical: string;
+  /** False when this locale is showing the complete source article as a safe fallback. */
+  translation_available: boolean;
+  /** The title and subtitle a phone card shows instead of `meta`'s, where the row clips. Falls
+   * back to the full form for a view `local` has not written one for. See web's spec/i18n/prose.md.
+   * */
+  short: {
+    title: string;
+    subtitle: string;
+  };
+  /**
+   * The title the article page shows on a phone: `meta.title` where it fits the column, and
+   * `short.title` where it does not. Decided here rather than in the browser -- the answer is a
+   * property of the string, so it cannot change between renders, and computing it at runtime
+   * would mean the first frame guessing. See web's spec/styling/phone.md.
+   */
+  phone_title: string;
+  /**
+   * What the article is about, withholding what it concludes. Written by `local summary` into a
+   * sidecar rather than into the article, so it is absent until that has been run.
+   */
+  summary?: ArticleSummary;
+};
+export type ArticleSummary = {
+  text: string;
+  provider: string;
+};
+export type CrateDep = {
+  name: string;
+  version: string;
+  kind: string;
+  optional: boolean;
+  target: string | null;
+  features: string[];
+  size: number | null;
+  depth: number;
+};
+export type CrateRecord = {
+  name: string;
+  version: string;
+  rust_version: string | null;
+  features: Record<string, string[]>;
+  deps: CrateDep[];
+  total_dep_size: number;
+};
+export type RepoRecord = {
+  full_name: string;
+  description: string | null;
+  language: string | null;
+  stars: number;
+  forks: number;
+  open_issues: number;
+  license: string | null;
+  pushed_at: string | null;
+};
+export type TweetRecord = {
+  id: string;
+  author: string;
+  text: string;
+  created: string;
+  likes: number;
+  reposts: number;
+  replies: number;
+};
+export type Alternate = {
+  code: Exclude<LocaleCode, 'mw'> | 'x-default';
+  language_tag: string;
+  href: string;
+};
+export type Article = Compiled & {
+  /** The identity: the last segment of the path, unique across the corpus. See build/slugs.ts. */
+  slug: string;
+  /** The address: the directory it currently sits in, plus that identity. */
+  path: string;
+  url: string;
+  views: Record<LocaleCode, ArticleView>;
+  canonical_urls: string[];
+  alternates: Alternate[];
+};
+export type InlineSegment = {
+  type: 'html';
+  html: string;
+} | {
+  type: 'link';
+  icon?: 'twitter' | 'github' | 'email';
+  href: string;
+  label: string;
+  new_tab: boolean;
+  /** `wide` / `narrow` from the directive, as the classes that act on them. A link is the
+   *  one run that cannot be wrapped in `:t` -- nested, it stops being a link -- so it
+   *  carries its own width the way a `:t` run carries one. See web's spec/styling/phone.md. */
+  width?: string;
+};
+export type PageBlock = {
+  type: 'p';
+  segments: InlineSegment[];
+} | {
+  type: 'html';
+  html: string;
+};
+export type CompiledPage = {
+  meta: Record<string, string>;
+  blocks: PageBlock[];
+  body: string;
+};
+export type PageView = Pick<CompiledPage, 'meta' | 'blocks'>;
+export type Page = {
+  path: string;
+  markdown: string;
+  views: Record<LocaleCode, PageView>;
+};
+//#endregion

package/dist/cache/src/index.d.ts

@@ -0,0 +1,67 @@
+//#region cache/src/index.d.ts
+/**
+ * How long an answer from this site may be kept.
+ *
+ * Publication has one delay rather than a different one per resource, so the number saying
+ * what that delay is belongs in one place rather than in each worker that stamps it -- three
+ * of them wrote it out, and two that drifted apart would be two answers to one question. See
+ * spec/architecture/delivery.md and spec/architecture/artifacts.md, "The key says what may
+ * cache it".
+ *
+ * Only the values are here. Which answer earns which lifetime stays with the worker that knows,
+ * because the three do three different jobs, and one policy deciding for all of them would be
+ * one place holding three unrelated decisions.
+ */
+/**
+ * Five minutes, in seconds. How far behind the current publication an answer may be.
+ *
+ * None of it while developing: a publication delay is a promise made to readers, and on a laptop
+ * it is only the distance between a rebuild and seeing it, which was minutes of waiting for a
+ * change nobody else was going to read.
+ */
+export declare const PUBLICATION_DELAY: number;
+/**
+ * Three hours, in seconds, for a caller that decides its answer is worth serving stale.
+ *
+ * A root that old names objects that are all still there and still immutable, so what it renders
+ * is a coherent older page rather than a broken one. Whether an answer may be served during an
+ * outage is a fact about what produced it, so that decision stays where it is made and only the
+ * window is shared.
+ */
+export declare const WHILE_UNREACHABLE = 10800;
+/**
+ * What an answer about what is published right now earns.
+ *
+ * Its key names rather than identifies, so the bytes behind it change when somebody publishes
+ * and it is held for exactly the delay publication has. Refusals included: a 404 about the
+ * corpus and a 400 about an address are both true until the next publication, and giving either
+ * a number of its own would be a second publication delay.
+ */
+export declare const PUBLISHED: string;
+/**
+ * What an answer keeps when its address names something rather than identifying it.
+ *
+ * Between the other two: what stands behind the name can change, but not on this site's
+ * publication clock -- a permanent shortcut whose target moves, somebody else's file fetched
+ * live. An hour is long enough to be worth an edge entry and short enough that a change lands
+ * the same day.
+ */
+export declare const NAMED = "public, max-age=3600";
+/**
+ * What a key whose bytes cannot change earns.
+ *
+ * Content addressing is the usual reason -- a hashed name cannot denote different bytes, so a
+ * cached copy is correct forever and needs no invalidation. It is not the only one: a Latin font
+ * subset keeps the year on a written promise that re-subsetting renames it, which is why this is
+ * named for the property rather than for the hash that normally carries it.
+ */
+export declare const UNCHANGING = "public, max-age=31536000, immutable";
+/**
+ * A name resolved to the object it stands for right now: the publication delay, and served stale
+ * through an outage, since the target is content-addressed and a stale one is still bytes.
+ *
+ * The alias layer stamps it on its redirect, and a page that follows that redirect for a browser
+ * stamps it on its own. See spec/architecture/delivery.md.
+ */
+export declare const RESOLVED: string;
+//#endregion

package/dist/cache/src/index.js

@@ -0,0 +1,58 @@
+/**
+* Five minutes, in seconds. How far behind the current publication an answer may be.
+*
+* None of it while developing: a publication delay is a promise made to readers, and on a laptop
+* it is only the distance between a rebuild and seeing it, which was minutes of waiting for a
+* change nobody else was going to read.
+*/
+const PUBLICATION_DELAY = import.meta.env?.MODE === "development" ? 0 : 300;
+/** One year, in seconds: the longest a browser honours, and what `immutable` already implies. */
+const UNCHANGING_LIFE = 31536e3;
+/** One hour, in seconds. The middle number, for an address that names rather than identifies. */
+const NAMED_LIFE = 3600;
+/**
+* Three hours, in seconds, for a caller that decides its answer is worth serving stale.
+*
+* A root that old names objects that are all still there and still immutable, so what it renders
+* is a coherent older page rather than a broken one. Whether an answer may be served during an
+* outage is a fact about what produced it, so that decision stays where it is made and only the
+* window is shared.
+*/
+const WHILE_UNREACHABLE = 10800;
+/**
+* What an answer about what is published right now earns.
+*
+* Its key names rather than identifies, so the bytes behind it change when somebody publishes
+* and it is held for exactly the delay publication has. Refusals included: a 404 about the
+* corpus and a 400 about an address are both true until the next publication, and giving either
+* a number of its own would be a second publication delay.
+*/
+const PUBLISHED = `public, max-age=${PUBLICATION_DELAY}`;
+/**
+* What an answer keeps when its address names something rather than identifying it.
+*
+* Between the other two: what stands behind the name can change, but not on this site's
+* publication clock -- a permanent shortcut whose target moves, somebody else's file fetched
+* live. An hour is long enough to be worth an edge entry and short enough that a change lands
+* the same day.
+*/
+const NAMED = `public, max-age=${NAMED_LIFE}`;
+/**
+* What a key whose bytes cannot change earns.
+*
+* Content addressing is the usual reason -- a hashed name cannot denote different bytes, so a
+* cached copy is correct forever and needs no invalidation. It is not the only one: a Latin font
+* subset keeps the year on a written promise that re-subsetting renames it, which is why this is
+* named for the property rather than for the hash that normally carries it.
+*/
+const UNCHANGING = `public, max-age=${UNCHANGING_LIFE}, immutable`;
+/**
+* A name resolved to the object it stands for right now: the publication delay, and served stale
+* through an outage, since the target is content-addressed and a stale one is still bytes.
+*
+* The alias layer stamps it on its redirect, and a page that follows that redirect for a browser
+* stamps it on its own. See spec/architecture/delivery.md.
+*/
+const RESOLVED = `${PUBLISHED}, stale-if-error=${WHILE_UNREACHABLE}`;
+//#endregion
+export { NAMED, PUBLICATION_DELAY, PUBLISHED, RESOLVED, UNCHANGING, WHILE_UNREACHABLE };

package/dist/imgsrc/src/index.d.ts

@@ -0,0 +1,16 @@
+//#region imgsrc/src/index.d.ts
+export type Options = {
+  cdnUrl?: string;
+  /**
+   * Selects the development CDN. Defaults to false, so server and browser always agree.
+   *
+   * Do not infer this from `globalThis.location`: that global is absent during SSR and
+   * present in the browser, so the same image would resolve to the production CDN on the
+   * server and the local one on the client -- a silent hydration mismatch that only appears
+   * in development. The caller knows the answer, so the caller passes it. In SvelteKit that
+   * is `dev` from `$app/environment`.
+   */
+  isDev?: boolean;
+};
+export declare function imgsrc(input: string, opts?: Options): string;
+//#endregion

package/dist/imgsrc/src/index.js

@@ -0,0 +1,89 @@
+import { URLS, pickUrls } from "../../src/index.js";
+//#region imgsrc/src/index.ts
+const GITHUB_AVATAR_SCHEME = "github:avatar:";
+const GITHUB_SCHEME = "github:";
+function imgsrc(input, opts = {}) {
+	const cdnUrl = opts.cdnUrl ?? pickUrls(opts.isDev ?? false).cdn;
+	if (input.startsWith("data:")) return input;
+	if (input.startsWith(GITHUB_AVATAR_SCHEME)) return resolveGithubAvatar(input, cdnUrl);
+	if (input.startsWith(GITHUB_SCHEME)) return resolveGithubScheme(input);
+	if (hasWebScheme(input)) return rewriteIfKnown(input, cdnUrl);
+	return `${cdnUrl}/object/${input}`;
+}
+function hostOf(url) {
+	return new URL(url).hostname;
+}
+function hasWebScheme(input) {
+	const schemeEnd = input.indexOf(":");
+	if (schemeEnd < 0) return false;
+	const scheme = input.slice(0, schemeEnd).toLowerCase();
+	return scheme === "http" || scheme === "https";
+}
+function resolveGithubAvatar(input, cdnUrl) {
+	const parsed = parseAvatarRef(input.slice(14));
+	if (!parsed) return input;
+	const query = parsed.size ? `?width=${parsed.size}` : "";
+	return `${cdnUrl}/proxy/github/avatar/${parsed.idOrName}${query}`;
+}
+function parseAvatarRef(rest) {
+	const lastAt = rest.lastIndexOf("@");
+	if (lastAt < 0) return rest ? {
+		idOrName: rest,
+		size: null
+	} : null;
+	if (lastAt === 0) {
+		const name = rest.slice(1);
+		return name ? {
+			idOrName: name,
+			size: null
+		} : null;
+	}
+	const before = rest.slice(0, lastAt);
+	const after = rest.slice(lastAt + 1);
+	if (!/^\d+$/.test(after)) return null;
+	const idOrName = before.startsWith("@") ? before.slice(1) : before;
+	return idOrName ? {
+		idOrName,
+		size: after
+	} : null;
+}
+function resolveGithubScheme(input) {
+	const rest = input.slice(7);
+	const atIdx = rest.lastIndexOf("@");
+	const pathPart = atIdx >= 0 ? rest.slice(0, atIdx) : rest;
+	const ref = atIdx >= 0 ? rest.slice(atIdx + 1) : null;
+	const [owner, repo, ...pathBits] = pathPart.split("/");
+	if (!owner || !repo || pathBits.length === 0) return input;
+	return toGithubCdn(owner, repo, ref, pathBits);
+}
+function rewriteIfKnown(input, cdnUrl) {
+	let url;
+	try {
+		url = new URL(input);
+	} catch {
+		return input;
+	}
+	if (url.hostname === hostOf(URLS.external.github.avatars)) {
+		const match = url.pathname.match(/^\/u\/(\d+)/);
+		if (match) {
+			const size = url.searchParams.get("s");
+			const query = size ? `?width=${size}` : "";
+			return `${cdnUrl}/proxy/github/avatar/${match[1]}${query}`;
+		}
+	}
+	if (url.hostname === hostOf(URLS.external.github.raw)) {
+		const [owner, repo, ref, ...pathBits] = url.pathname.split("/").filter(Boolean);
+		if (owner && repo && ref && pathBits.length > 0) return toGithubCdn(owner, repo, ref, pathBits);
+	}
+	if (url.hostname === hostOf(URLS.external.github.web)) {
+		const [owner, repo, kind, ref, ...pathBits] = url.pathname.split("/").filter(Boolean);
+		if (owner && repo && ref && pathBits.length > 0 && (kind === "raw" || kind === "blob")) return toGithubCdn(owner, repo, ref, pathBits);
+	}
+	return input;
+}
+function toGithubCdn(owner, repo, ref, pathBits) {
+	const refSuffix = ref ? `@${ref}` : "";
+	return `${URLS.external.github.cdn}/${owner}/${repo}${refSuffix}/${pathBits.join("/")}`;
+}
+//#endregion
+export { imgsrc };

package/dist/limits/src/bucket.d.ts

@@ -0,0 +1,28 @@
+//#region limits/src/bucket.d.ts
+/**
+ * A limit as a bucket: `burst` calls at once, and room coming back at `count` calls in `seconds`.
+ * Counted with GCRA, which admits exactly what a token bucket would while keeping one number per
+ * key -- the moment the next call is due. Pure, so every deployment of `quota` runs the same
+ * arithmetic. See spec/architecture/quota.md, "A limit is a bucket".
+ */
+/** How fast room comes back, and how much of it there is. */
+export interface Rate {
+  readonly count: number;
+  readonly seconds: number;
+  /** How many calls may come together; `count` when absent. */
+  readonly burst?: number;
+}
+export interface Taken {
+  readonly allowed: boolean;
+  /** Whole seconds until another call would be allowed; 0 when this one was. */
+  readonly retryAfter: number;
+}
+/**
+ * One call at `now`, in milliseconds, against a bucket whose next call was `due`, or never asked
+ * when undefined: whether it passes, and the `due` to keep after it. A refused call keeps the old
+ * `due`, so refusals spend nothing.
+ */
+export declare function take(due: number | undefined, rate: Rate, now: number): Taken & {
+  readonly due: number | undefined;
+};
+//#endregion

package/dist/limits/src/bucket.js

@@ -0,0 +1,23 @@
+//#region limits/src/bucket.ts
+/**
+* One call at `now`, in milliseconds, against a bucket whose next call was `due`, or never asked
+* when undefined: whether it passes, and the `due` to keep after it. A refused call keeps the old
+* `due`, so refusals spend nothing.
+*/
+function take(due, rate, now) {
+	const interval = rate.seconds * 1e3 / rate.count;
+	const room = (rate.burst ?? rate.count) * interval;
+	const next = Math.max(due ?? now, now) + interval;
+	if (next - now <= room) return {
+		allowed: true,
+		retryAfter: 0,
+		due: next
+	};
+	return {
+		allowed: false,
+		retryAfter: Math.max(1, Math.ceil((next - now - room) / 1e3)),
+		due
+	};
+}
+//#endregion
+export { take };