@shaferllc/keel 0.66.0 → 0.74.0

package/dist/core/i18n.js

@@ -0,0 +1,472 @@
+/**
+ * Internationalization — translations with ICU message formatting, and the
+ * `Intl` formatters that go with them.
+ *
+ *   setTranslations({
+ *     en: { "cart.items": "{count, plural, =0 {Your cart is empty} one {# item} other {# items}}" },
+ *     fr: { "cart.items": "{count, plural, =0 {Panier vide} one {# article} other {# articles}}" },
+ *   });
+ *
+ *   t("cart.items", { count: 3 });              // "3 items" (the request's locale)
+ *   i18n("fr").t("cart.items", { count: 3 });   // "3 articles"
+ *
+ * There is **no dependency** here, and there doesn't need to be: `Intl` ships with
+ * every modern runtime — Node and Workers both carry the full ICU data — so
+ * plurals, currencies, dates, and relative times are the platform's job. What Keel
+ * adds is the message parser on top, which is the part `Intl` doesn't do.
+ *
+ * The supported ICU subset is the part people actually use: interpolation,
+ * `plural`, `selectordinal`, `select`, `number`, `date`, and `time` — nested
+ * arbitrarily deep. See the i18n guide for the grammar.
+ */
+import { getContext } from "hono/context-storage";
+import { hasApplication, emit } from "./helpers.js";
+/**
+ * Flatten nested translations to dot paths, so `{ cart: { items: "…" } }` and
+ * `{ "cart.items": "…" }` are the same thing and can be mixed freely.
+ */
+function flatten(input, prefix = "", out = {}) {
+    for (const [key, value] of Object.entries(input)) {
+        const path = prefix ? `${prefix}.${key}` : key;
+        if (value && typeof value === "object" && !Array.isArray(value)) {
+            flatten(value, path, out);
+        }
+        else if (value != null) {
+            out[path] = String(value);
+        }
+    }
+    return out;
+}
+/* ---------------------------- the ICU formatter --------------------------- */
+/**
+ * Find the index of the `}` matching the `{` at `open`. Brace-counting, because a
+ * plural branch contains whole sub-messages that have braces of their own.
+ */
+function matchBrace(message, open) {
+    let depth = 0;
+    for (let i = open; i < message.length; i++) {
+        const char = message[i];
+        if (char === "{")
+            depth++;
+        else if (char === "}") {
+            depth--;
+            if (depth === 0)
+                return i;
+        }
+    }
+    throw new Error(`i18n: unbalanced braces in message: ${message}`);
+}
+/** Split `one {# item} other {# items}` into its branches. */
+function parseBranches(style) {
+    const branches = {};
+    let i = 0;
+    while (i < style.length) {
+        // The branch key: everything up to the next `{`.
+        while (i < style.length && /\s/.test(style[i]))
+            i++;
+        const open = style.indexOf("{", i);
+        if (open === -1)
+            break;
+        const key = style.slice(i, open).trim();
+        const close = matchBrace(style, open);
+        if (key)
+            branches[key] = style.slice(open + 1, close);
+        i = close + 1;
+    }
+    return branches;
+}
+/** Split an argument's innards into `name`, `type`, and the raw `style`. */
+function parseArg(inner) {
+    const firstComma = inner.indexOf(",");
+    if (firstComma === -1)
+        return { name: inner.trim() };
+    const name = inner.slice(0, firstComma).trim();
+    const rest = inner.slice(firstComma + 1);
+    const secondComma = rest.indexOf(",");
+    if (secondComma === -1)
+        return { name, type: rest.trim() };
+    return {
+        name,
+        type: rest.slice(0, secondComma).trim(),
+        style: rest.slice(secondComma + 1).trim(),
+    };
+}
+function numberFormat(locale, style) {
+    if (!style)
+        return {};
+    if (style === "percent")
+        return { style: "percent" };
+    if (style === "integer")
+        return { maximumFractionDigits: 0 };
+    // The ICU skeleton for currency: `::currency/USD`.
+    const currency = /^::currency\/([A-Z]{3})$/.exec(style);
+    if (currency)
+        return { style: "currency", currency: currency[1] };
+    return {};
+}
+const DATE_STYLES = new Set(["full", "long", "medium", "short"]);
+function dateStyleOf(style, key) {
+    const value = style && DATE_STYLES.has(style) ? style : "medium";
+    return { [key]: value };
+}
+function toDate(value) {
+    if (value instanceof Date)
+        return value;
+    if (typeof value === "number" || typeof value === "string")
+        return new Date(value);
+    throw new Error(`i18n: expected a date, got ${typeof value}`);
+}
+/**
+ * Format an ICU message. The grammar we support:
+ *
+ *   {name}                                  interpolation
+ *   {n, number}  {n, number, percent}  {n, number, ::currency/USD}
+ *   {d, date, medium}   {d, time, short}
+ *   {c, plural, =0 {none} one {# item} other {# items}}
+ *   {c, selectordinal, one {#st} two {#nd} few {#rd} other {#th}}
+ *   {g, select, male {He} female {She} other {They}}
+ *
+ * `#` inside a plural branch becomes the formatted number. Branches are
+ * themselves messages, so they nest. `'{'` and `'}'` are literal braces.
+ */
+export function formatMessage(message, data = {}, locale = "en") {
+    let out = "";
+    let i = 0;
+    while (i < message.length) {
+        const char = message[i];
+        // ICU escaping: '{' and '}' are literal braces.
+        if (char === "'" && (message[i + 1] === "{" || message[i + 1] === "}")) {
+            const end = message.indexOf("'", i + 1);
+            if (end === -1) {
+                out += message.slice(i + 1);
+                break;
+            }
+            out += message.slice(i + 1, end);
+            i = end + 1;
+            continue;
+        }
+        if (char !== "{") {
+            out += char;
+            i++;
+            continue;
+        }
+        const close = matchBrace(message, i);
+        const { name, type, style } = parseArg(message.slice(i + 1, close));
+        const value = data[name];
+        i = close + 1;
+        if (!type) {
+            out += value == null ? "" : String(value);
+            continue;
+        }
+        switch (type) {
+            case "number":
+                out += new Intl.NumberFormat(locale, numberFormat(locale, style)).format(Number(value));
+                break;
+            case "date":
+                out += new Intl.DateTimeFormat(locale, dateStyleOf(style, "dateStyle")).format(toDate(value));
+                break;
+            case "time":
+                out += new Intl.DateTimeFormat(locale, dateStyleOf(style, "timeStyle")).format(toDate(value));
+                break;
+            case "plural":
+            case "selectordinal": {
+                const count = Number(value);
+                const branches = parseBranches(style ?? "");
+                // An exact `=N` match wins over the plural category — that's what lets
+                // "=0 {Your cart is empty}" say something other than "0 items".
+                const category = new Intl.PluralRules(locale, {
+                    type: type === "plural" ? "cardinal" : "ordinal",
+                }).select(count);
+                const branch = branches[`=${count}`] ?? branches[category] ?? branches.other ?? "";
+                const formatted = new Intl.NumberFormat(locale).format(count);
+                // `#` is the count. Recurse first, then substitute, so a nested message
+                // can't accidentally eat the marker.
+                out += formatMessage(branch, data, locale).replaceAll("#", formatted);
+                break;
+            }
+            case "select": {
+                const branches = parseBranches(style ?? "");
+                const branch = branches[String(value)] ?? branches.other ?? "";
+                out += formatMessage(branch, data, locale);
+                break;
+            }
+            default:
+                // An unknown type: fall back to interpolation rather than throwing.
+                out += value == null ? "" : String(value);
+        }
+    }
+    return out;
+}
+/* --------------------------------- locales -------------------------------- */
+/**
+ * Pick the best locale for an `Accept-Language` header.
+ *
+ *   negotiateLocale("fr-CA,fr;q=0.9,en;q=0.8", ["en", "fr"], "en")  // "fr"
+ *
+ * Exact matches win, then the language part (`fr-CA` → `fr`), in the client's
+ * order of preference. Falls back to `defaultLocale` when nothing matches.
+ */
+export function negotiateLocale(header, supported, defaultLocale) {
+    if (!header)
+        return defaultLocale;
+    const wanted = header
+        .split(",")
+        .map((part) => {
+        const [tag, ...params] = part.trim().split(";");
+        const q = params.find((p) => p.trim().startsWith("q="));
+        return { tag: (tag ?? "").trim().toLowerCase(), q: q ? Number(q.split("=")[1]) : 1 };
+    })
+        .filter((entry) => entry.tag && !Number.isNaN(entry.q))
+        .sort((a, b) => b.q - a.q);
+    const lower = new Map(supported.map((locale) => [locale.toLowerCase(), locale]));
+    for (const { tag } of wanted) {
+        const exact = lower.get(tag);
+        if (exact)
+            return exact;
+        // `fr-CA` should match a supported `fr`.
+        const language = tag.split("-")[0];
+        const partial = lower.get(language);
+        if (partial)
+            return partial;
+    }
+    return defaultLocale;
+}
+/* ---------------------------------- i18n ---------------------------------- */
+/** One locale, bound to its messages. Get one with `i18n(locale)`. */
+export class I18n {
+    locale;
+    messages;
+    manager;
+    constructor(locale, messages, manager) {
+        this.locale = locale;
+        this.messages = messages;
+        this.manager = manager;
+    }
+    /** Whether a key resolves in this locale (or its fallbacks). */
+    has(key) {
+        return this.messages[key] !== undefined;
+    }
+    /**
+     * Translate a key, formatting its ICU message with `data`.
+     *
+     *   t("cart.items", { count: 3 });   // "3 items"
+     *
+     * A missing key doesn't throw — it goes through the configured `missing`
+     * handler (which returns the key itself by default, so the page still renders
+     * and the gap is obvious) and fires an `i18n.missing` event.
+     */
+    t(key, data) {
+        const message = this.messages[key];
+        if (message === undefined)
+            return this.manager.missing(key, this.locale);
+        return formatMessage(message, data, this.locale);
+    }
+    formatNumber(value, options) {
+        return new Intl.NumberFormat(this.locale, options).format(value);
+    }
+    formatCurrency(value, currency, options) {
+        return new Intl.NumberFormat(this.locale, { ...options, style: "currency", currency }).format(value);
+    }
+    formatDate(value, options) {
+        return new Intl.DateTimeFormat(this.locale, options ?? { dateStyle: "medium" }).format(toDate(value));
+    }
+    formatTime(value, options) {
+        return new Intl.DateTimeFormat(this.locale, options ?? { timeStyle: "medium" }).format(toDate(value));
+    }
+    /**
+     * "3 days ago", "in 2 hours". With no unit, the best one is picked from the
+     * distance between `value` and now.
+     */
+    formatRelativeTime(value, unit, options) {
+        const formatter = new Intl.RelativeTimeFormat(this.locale, { numeric: "auto", ...options });
+        const deltaMs = toDate(value).getTime() - Date.now();
+        if (unit)
+            return formatter.format(Math.round(deltaMs / MS[unit]), unit);
+        // Walk from the coarsest unit down; the first one the delta clears wins.
+        for (const candidate of AUTO_UNITS) {
+            const size = MS[candidate];
+            if (Math.abs(deltaMs) >= size || candidate === "second") {
+                return formatter.format(Math.round(deltaMs / size), candidate);
+            }
+        }
+        return formatter.format(0, "second");
+    }
+    /** "a, b, and c" — or "a, b, or c" with `{ type: "disjunction" }`. */
+    formatList(items, options) {
+        return new Intl.ListFormat(this.locale, options).format(items);
+    }
+    /** The plural category for a count: "one", "other", … */
+    formatPlural(count, options) {
+        return new Intl.PluralRules(this.locale, options).select(count);
+    }
+    /** A language/region/currency code as its display name: "fr" → "French". */
+    formatDisplayName(code, type = "language") {
+        return new Intl.DisplayNames([this.locale], { type }).of(code) ?? code;
+    }
+}
+const MS = {
+    year: 31_536_000_000,
+    quarter: 7_884_000_000,
+    month: 2_628_000_000,
+    week: 604_800_000,
+    day: 86_400_000,
+    hour: 3_600_000,
+    minute: 60_000,
+    second: 1_000,
+};
+const AUTO_UNITS = [
+    "year",
+    "month",
+    "week",
+    "day",
+    "hour",
+    "minute",
+    "second",
+];
+export class I18nManager {
+    translations = new Map();
+    options;
+    constructor(options = {}) {
+        this.options = {
+            defaultLocale: options.defaultLocale ?? "en",
+            fallbackLocales: options.fallbackLocales ?? {},
+            missing: options.missing ?? ((key) => key),
+            supportedLocales: options.supportedLocales,
+        };
+    }
+    get defaultLocale() {
+        return this.options.defaultLocale;
+    }
+    /** Add translations, merging into whatever is already loaded. */
+    add(data) {
+        for (const [locale, messages] of Object.entries(data)) {
+            const existing = this.translations.get(locale) ?? {};
+            this.translations.set(locale, { ...existing, ...flatten(messages) });
+        }
+        return this;
+    }
+    /** Load from one or more loaders. */
+    async load(...loaders) {
+        for (const loader of loaders)
+            this.add(await loader.load());
+        return this;
+    }
+    /** The locales this app serves. */
+    supported() {
+        return this.options.supportedLocales ?? [...this.translations.keys()];
+    }
+    /**
+     * The chain to try for a locale: itself, its configured fallback, its language
+     * prefix (`es-MX` → `es`), then the default. That's what makes a regional
+     * locale usable with only the base language translated.
+     */
+    chain(locale) {
+        const chain = [locale];
+        const configured = this.options.fallbackLocales[locale];
+        if (configured)
+            chain.push(configured);
+        const language = locale.split("-")[0];
+        if (language !== locale)
+            chain.push(language);
+        chain.push(this.options.defaultLocale);
+        return [...new Set(chain)];
+    }
+    /** An `I18n` for a locale, with its fallback chain already flattened in. */
+    locale(code) {
+        const locale = code ?? this.options.defaultLocale;
+        // Later entries in the chain fill only the gaps the earlier ones leave.
+        const merged = {};
+        for (const candidate of this.chain(locale).reverse()) {
+            Object.assign(merged, this.translations.get(candidate) ?? {});
+        }
+        return new I18n(locale, merged, this);
+    }
+    /** What to render for a missing key — and a chance to notice it. */
+    missing(key, locale) {
+        if (hasApplication())
+            void emit("i18n.missing", { key, locale });
+        return this.options.missing(key, locale);
+    }
+}
+/* --------------------------------- global --------------------------------- */
+let manager = new I18nManager();
+/** Replace the i18n manager (options and all). */
+export function setI18n(next) {
+    manager = next;
+    return manager;
+}
+/** The active i18n manager. */
+export function getI18n() {
+    return manager;
+}
+/** Register translations on the active manager. */
+export function setTranslations(data) {
+    return manager.add(data);
+}
+/**
+ * An `I18n` for a locale — or, with no argument, the **current request's** locale
+ * (set by `detectLocale()`), falling back to the default outside a request.
+ */
+export function i18n(locale) {
+    return manager.locale(locale ?? currentLocale());
+}
+/** Translate a key in the current request's locale. */
+export function t(key, data) {
+    return i18n().t(key, data);
+}
+/** Translations from a plain object — the simplest loader. */
+export function objectLoader(data) {
+    return { load: () => data };
+}
+/* ------------------------------- the request ------------------------------ */
+/**
+ * The locale `detectLocale()` stored on this request, if we're in one. Outside a
+ * request — a CLI command, a queue worker — there's no context, and that's fine:
+ * `i18n()` falls back to the default locale.
+ */
+function currentLocale() {
+    try {
+        return getContext().get("locale");
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Work out the request's locale and stash it, so `t()` and `i18n()` pick it up
+ * anywhere in the request without threading it through.
+ *
+ *   this.use(detectLocale());                    // Accept-Language
+ *   this.use(detectLocale({ query: "lang" }));   // ?lang=fr wins
+ *
+ * Precedence: `resolve` → query → cookie → `Accept-Language` → the default. Only
+ * **supported** locales are honored, so `?lang=xx` can't put the app into a locale
+ * you have no translations for.
+ */
+export function detectLocale(options = {}) {
+    return async (c, next) => {
+        const supported = manager.supported();
+        const isSupported = (value) => value !== undefined && supported.includes(value);
+        let locale;
+        const custom = options.resolve?.(c);
+        if (isSupported(custom))
+            locale = custom;
+        if (!locale && options.query) {
+            const value = new URL(c.req.url).searchParams.get(options.query) ?? undefined;
+            if (isSupported(value))
+                locale = value;
+        }
+        if (!locale && options.cookie) {
+            const cookies = c.req.header("Cookie") ?? "";
+            const match = new RegExp(`(?:^|;\\s*)${options.cookie}=([^;]+)`).exec(cookies);
+            const value = match?.[1];
+            if (isSupported(value))
+                locale = value;
+        }
+        if (!locale && options.header !== false) {
+            locale = negotiateLocale(c.req.header("Accept-Language"), supported, manager.defaultLocale);
+        }
+        c.set("locale", locale ?? manager.defaultLocale);
+        await next();
+    };
+}

package/dist/core/index.d.ts

@@ -4,19 +4,28 @@ export type { Token, Constructor, Factory } from "./container.js";
 export { Application } from "./application.js";
 export type { BootOptions, LifecycleHook, Configurator } from "./application.js";
 export { Config, env } from "./config.js";
+export { defineEnv, envVar, EnvValidationError } from "./env.js";
+export type { EnvRule, EnvSchema, EnvValues, EnvType, DefineEnvOptions } from "./env.js";
 export { app, config, view, bind, singleton, instance, make, bound, alias, swap, restore, events, emit, listen, cache, logger, onReady, onShutdown, terminate, } from "./helpers.js";
 export { Logger } from "./logger.js";
-export type { LogLevel, LoggerOptions } from "./logger.js";
+export { consoleSink, MemorySink, setLogger, namedLogger, tapLogs } from "./logger.js";
+export type { LogLevel, LoggerOptions, LogRecord, Sink, RedactOptions } from "./logger.js";
 export { requestLogger, requestLog } from "./request-logger.js";
 export type { RequestLoggerOptions } from "./request-logger.js";
-export { Events } from "./events.js";
-export type { Listener } from "./events.js";
+export { Events, EventBuffer } from "./events.js";
+export type { Listener, AnyListener, ErrorHandler, EventsList, EventName, PayloadOf, RecordedEvent, } from "./events.js";
 export { Cache, MemoryStore } from "./cache.js";
-export type { CacheStore } from "./cache.js";
+export type { CacheStore, RememberOptions, PutOptions } from "./cache.js";
 export { serveStatic } from "./static.js";
 export type { StaticOptions } from "./static.js";
-export { Storage, MemoryDisk, storage, setDisk } from "./storage.js";
-export type { Disk, Contents } from "./storage.js";
+export { i18n, t, getI18n, setI18n, setTranslations, objectLoader, detectLocale, negotiateLocale, formatMessage, I18n, I18nManager, } from "./i18n.js";
+export type { Translations, TranslationsByLocale, TranslationLoader, I18nOptions, DetectLocaleOptions, } from "./i18n.js";
+export { lock, restoreLock, setLockStore, getLockStore, Lock, MemoryLockStore, LockNotHeldError, } from "./lock.js";
+export type { LockStore, AcquireOptions } from "./lock.js";
+export { health, healthCheck, check, Result, BaseCheck, HealthChecks, DatabaseCheck, RedisCheck, CacheCheck, } from "./health.js";
+export type { HealthStatus, HealthReport, CheckReport, HealthCheckOptions, } from "./health.js";
+export { Storage, FakeStorage, MemoryDisk, storage, setDisk, fakeDisk, restoreDisk, serveStorage, signStorageUrl, verifyStorageUrl, contentTypeFor, } from "./storage.js";
+export type { Disk, Contents, FileVisibility, WriteOptions, FileMetadata, SignedFileOptions, SignedUploadOptions, ServeStorageOptions, } from "./storage.js";
 export { dump, dd } from "./debug.js";
 export { hash, encryption, jwt } from "./crypto.js";
 export type { JwtPayload, JwtSignOptions, JwtVerifyOptions, EncryptOptions } from "./crypto.js";
@@ -28,17 +37,17 @@ export { securityHeaders } from "./shield.js";
 export type { SecurityHeadersOptions, HstsOptions } from "./shield.js";
 export { csrf, csrfToken, csrfField } from "./csrf.js";
 export type { CsrfOptions } from "./csrf.js";
-export { db, connection, setConnection, addConnection, setDefaultConnection, connectionNames, clearConnections, QueryBuilder, } from "./database.js";
-export type { Connection, ConnectionHandle, WriteResult, Row, Dialect, Operator, Paginated } from "./database.js";
+export { db, connection, getConnection, setConnection, addConnection, setDefaultConnection, connectionNames, clearConnections, transaction, inTransaction, QueryBuilder, } from "./database.js";
+export type { Connection, TransactionConnection, TransactionHandle, ConnectionHandle, WriteResult, Row, Dialect, Operator, Paginated, } from "./database.js";
 export { Model } from "./model.js";
 export type { CastType, Casts } from "./casts.js";
 export { Relation, HasOne, HasMany, BelongsTo, BelongsToMany } from "./relations.js";
 export { Faker, Factory as ModelFactory, factory, Seeder, seed } from "./factory.js";
 export type { Definition } from "./factory.js";
-export { Mailer, PendingMail, ArrayTransport, LogTransport, fetchTransport, mail, setMailer, getMailer, } from "./mail.js";
-export type { Message, Transport, MailerOptions, FetchTransportOptions } from "./mail.js";
-export { Job, Queue, SyncDriver, MemoryDriver, dispatch, work, setQueue, getQueue, } from "./queue.js";
-export type { Dispatchable, JobOptions, QueueDriver, Drainable, QueuedJob } from "./queue.js";
+export { Mailer, FakeMailer, PendingMail, BaseMail, SendMailJob, ArrayTransport, LogTransport, fetchTransport, mail, mailer, send, sendLater, setMailer, getMailer, fakeMail, restoreMail, } from "./mail.js";
+export type { Message, Transport, MailerOptions, FetchTransportOptions, Attachment, RecordedMail, } from "./mail.js";
+export { Job, Queue, FakeQueue, SyncDriver, MemoryDriver, dispatch, work, setQueue, getQueue, fakeQueue, restoreQueue, exponentialBackoff, linearBackoff, fixedBackoff, noBackoff, } from "./queue.js";
+export type { Dispatchable, JobOptions, JobContext, JobClass, QueueDriver, Drainable, QueuedJob, FailedJob, Backoff, } from "./queue.js";
 export { Scheduler, ScheduledTask, scheduler, setScheduler, schedule, cronMatches } from "./scheduler.js";
 export { MemoryBroadcaster, broadcast, setBroadcaster, getBroadcaster, channelAuth, authorizeChannel, clearChannels, } from "./broadcasting.js";
 export type { Broadcaster, Subscriber, ChannelAuthorizer } from "./broadcasting.js";
@@ -58,12 +67,29 @@ export { TemplateEngine, escapeHtml, templates, setTemplateEngine, render, } fro
 export type { Filter, RenderContext } from "./template.js";
 export { ServiceProvider } from "./provider.js";
 export type { ProviderClass } from "./provider.js";
+export { PackageProvider, MigrationRegistry, CommandRegistry, PublishRegistry, } from "./package.js";
+export type { PackageCommand, PublishEntry, PackageRouteOptions, PackageAssetOptions, PackageMiddleware, } from "./package.js";
+export { instrument, runRequest, currentRequestId, newRequestId, } from "./instrumentation.js";
+export type { QueryEvent, RequestEvent, ExceptionEvent, JobEvent, CacheEvent, NotificationEvent, ScheduleEvent, InstrumentEvent, } from "./instrumentation.js";
 export { Router, Route, RouteGroup, RouteResource, matchers } from "./http/router.js";
 export type { Ctx, RouteHandler, RouteDefinition, Method, Matcher, MiddlewareRef, UrlOptions, SignedUrlOptions, } from "./http/router.js";
 export { Inertia, inertia, inertiaPageAttr } from "./inertia.js";
 export type { InertiaPage, InertiaOptions } from "./inertia.js";
 export { HttpKernel } from "./http/kernel.js";
-export { TestClient, TestResponse, testClient } from "./testing.js";
+export { defineCommand, arg, flag, ConsoleKernel, ConsoleError, parseArgv } from "./console.js";
+export type { CommandDefinition, CommandContext, AnyCommand, ArgSpec, FlagSpec, ArgsSpec, FlagsSpec, ConsoleKernelOptions, } from "./console.js";
+export { createUi, stripAnsi } from "./console-ui.js";
+export type { Ui, UiOptions, Colors, ColorName, Table, Tasks, TaskHandle } from "./console-ui.js";
+export { createPrompt } from "./console-prompt.js";
+export type { Prompt, PromptOptions, ChoiceOptions, Choice, Trap } from "./console-prompt.js";
+export { startRepl } from "./repl.js";
+export type { ReplHelper, ReplOptions } from "./repl.js";
+export { pages, definePages, routePattern, routeName } from "./pages.js";
+export type { PageProps, PageModule, PagesOptions, RegisteredPage, PageMiddleware } from "./pages.js";
+export { TestClient, TestResponse, CommandResult, testClient, runCommand, resetState, freezeTime, timeTravel, restoreTime, timeIsFrozen, spy, spyOn, restoreSpies, truncate, assertDatabaseHas, assertDatabaseMissing, assertDatabaseCount, assertDatabaseEmpty, } from "./testing.js";
+export type { Spy } from "./testing.js";
+export { Tracer, Span, MemoryExporter, otlpExporter, consoleExporter, telemetry, setTelemetry, trace, currentSpan, setAttributes, addEvent, traceIds, flushTelemetry, tracing, parseTraceparent, traceparent, injectTraceContext, } from "./telemetry.js";
+export type { SpanContext, SpanData, SpanEvent, SpanKind, SpanStatus, SpanOptions, SpanExporter, SpanAttributes, SpanAttributeValue, TracerOptions, TracingOptions, OtlpOptions, } from "./telemetry.js";
 export { HttpException, BadRequestException, UnauthorizedException, PaymentRequiredException, ForbiddenException, NotFoundException, MethodNotAllowedException, NotAcceptableException, RequestTimeoutException, ConflictException, LengthRequiredException, ValidationException, TooManyRequestsException, ServerErrorException, NotImplementedException, BadGatewayException, ServiceUnavailableException, createError, STATUS_TEXT, } from "./exceptions.js";
 export { validate, validateRequest, validated } from "./validation.js";
 export type { Schema, RequestSchemas } from "./validation.js";

package/dist/core/index.js

@@ -2,25 +2,30 @@
 export { Container } from "./container.js";
 export { Application } from "./application.js";
 export { Config, env } from "./config.js";
+export { defineEnv, envVar, EnvValidationError } from "./env.js";
 export { app, config, view, bind, singleton, instance, make, bound, alias, swap, restore, events, emit, listen, cache, logger, onReady, onShutdown, terminate, } from "./helpers.js";
 export { Logger } from "./logger.js";
+export { consoleSink, MemorySink, setLogger, namedLogger, tapLogs } from "./logger.js";
 export { requestLogger, requestLog } from "./request-logger.js";
-export { Events } from "./events.js";
+export { Events, EventBuffer } from "./events.js";
 export { Cache, MemoryStore } from "./cache.js";
 export { serveStatic } from "./static.js";
-export { Storage, MemoryDisk, storage, setDisk } from "./storage.js";
+export { i18n, t, getI18n, setI18n, setTranslations, objectLoader, detectLocale, negotiateLocale, formatMessage, I18n, I18nManager, } from "./i18n.js";
+export { lock, restoreLock, setLockStore, getLockStore, Lock, MemoryLockStore, LockNotHeldError, } from "./lock.js";
+export { health, healthCheck, check, Result, BaseCheck, HealthChecks, DatabaseCheck, RedisCheck, CacheCheck, } from "./health.js";
+export { Storage, FakeStorage, MemoryDisk, storage, setDisk, fakeDisk, restoreDisk, serveStorage, signStorageUrl, verifyStorageUrl, contentTypeFor, } from "./storage.js";
 export { dump, dd } from "./debug.js";
 export { hash, encryption, jwt } from "./crypto.js";
 export { rateLimiter } from "./rate-limit.js";
 export { cors } from "./cors.js";
 export { securityHeaders } from "./shield.js";
 export { csrf, csrfToken, csrfField } from "./csrf.js";
-export { db, connection, setConnection, addConnection, setDefaultConnection, connectionNames, clearConnections, QueryBuilder, } from "./database.js";
+export { db, connection, getConnection, setConnection, addConnection, setDefaultConnection, connectionNames, clearConnections, transaction, inTransaction, QueryBuilder, } from "./database.js";
 export { Model } from "./model.js";
 export { Relation, HasOne, HasMany, BelongsTo, BelongsToMany } from "./relations.js";
 export { Faker, Factory as ModelFactory, factory, Seeder, seed } from "./factory.js";
-export { Mailer, PendingMail, ArrayTransport, LogTransport, fetchTransport, mail, setMailer, getMailer, } from "./mail.js";
-export { Job, Queue, SyncDriver, MemoryDriver, dispatch, work, setQueue, getQueue, } from "./queue.js";
+export { Mailer, FakeMailer, PendingMail, BaseMail, SendMailJob, ArrayTransport, LogTransport, fetchTransport, mail, mailer, send, sendLater, setMailer, getMailer, fakeMail, restoreMail, } from "./mail.js";
+export { Job, Queue, FakeQueue, SyncDriver, MemoryDriver, dispatch, work, setQueue, getQueue, fakeQueue, restoreQueue, exponentialBackoff, linearBackoff, fixedBackoff, noBackoff, } from "./queue.js";
 export { Scheduler, ScheduledTask, scheduler, setScheduler, schedule, cronMatches } from "./scheduler.js";
 export { MemoryBroadcaster, broadcast, setBroadcaster, getBroadcaster, channelAuth, authorizeChannel, clearChannels, } from "./broadcasting.js";
 export { Redis, MemoryRedis, redis, setRedis, redisStore } from "./redis.js";
@@ -31,10 +36,18 @@ export { decorateRequest, hasRequestDecorator, decorated, setRequestValue, clear
 export { View } from "./view.js";
 export { TemplateEngine, escapeHtml, templates, setTemplateEngine, render, } from "./template.js";
 export { ServiceProvider } from "./provider.js";
+export { PackageProvider, MigrationRegistry, CommandRegistry, PublishRegistry, } from "./package.js";
+export { instrument, runRequest, currentRequestId, newRequestId, } from "./instrumentation.js";
 export { Router, Route, RouteGroup, RouteResource, matchers } from "./http/router.js";
 export { Inertia, inertia, inertiaPageAttr } from "./inertia.js";
 export { HttpKernel } from "./http/kernel.js";
-export { TestClient, TestResponse, testClient } from "./testing.js";
+export { defineCommand, arg, flag, ConsoleKernel, ConsoleError, parseArgv } from "./console.js";
+export { createUi, stripAnsi } from "./console-ui.js";
+export { createPrompt } from "./console-prompt.js";
+export { startRepl } from "./repl.js";
+export { pages, definePages, routePattern, routeName } from "./pages.js";
+export { TestClient, TestResponse, CommandResult, testClient, runCommand, resetState, freezeTime, timeTravel, restoreTime, timeIsFrozen, spy, spyOn, restoreSpies, truncate, assertDatabaseHas, assertDatabaseMissing, assertDatabaseCount, assertDatabaseEmpty, } from "./testing.js";
+export { Tracer, Span, MemoryExporter, otlpExporter, consoleExporter, telemetry, setTelemetry, trace, currentSpan, setAttributes, addEvent, traceIds, flushTelemetry, tracing, parseTraceparent, traceparent, injectTraceContext, } from "./telemetry.js";
 export { HttpException, BadRequestException, UnauthorizedException, PaymentRequiredException, ForbiddenException, NotFoundException, MethodNotAllowedException, NotAcceptableException, RequestTimeoutException, ConflictException, LengthRequiredException, ValidationException, TooManyRequestsException, ServerErrorException, NotImplementedException, BadGatewayException, ServiceUnavailableException, createError, STATUS_TEXT, } from "./exceptions.js";
 export { validate, validateRequest, validated } from "./validation.js";
 export { Session, session, sessionMiddleware } from "./session.js";