@agent-native/core 0.138.0 → 0.140.0

package/dist/brand-kit/tokens.js

@@ -0,0 +1,280 @@
+/**
+ * `@agent-native/core/brand-kit/tokens`
+ *
+ * Pure helpers for the named-token vocabulary a Brand Kit stores alongside its
+ * seven color roles. Kept on its own subpath (no `design-token-utils` re-export)
+ * so browser code can import the CSS-safety predicates without pulling the
+ * server-side extraction stack into the bundle.
+ */
+const BRAND_KIT_TOKEN_TYPES = [
+    "color",
+    "typography",
+    "spacing",
+    "radius",
+    "shadow",
+    "other",
+];
+/**
+ * Upper bound on a single kit's stored vocabulary. Large systems legitimately
+ * define hundreds of tokens; this only stops an unbounded scrape landing in SQL.
+ */
+export const MAX_BRAND_KIT_TOKENS = 500;
+const CSS_CUSTOM_PROPERTY_NAME = /^--[-_a-zA-Z0-9]+$/;
+const COLOR_FUNCTION_OR_HEX = /^(#[0-9a-fA-F]{3,8}|rgba?\(|hsla?\(|oklch\(|color\()/i;
+const NAMED_CSS_COLORS = new Set([
+    "red",
+    "blue",
+    "green",
+    "yellow",
+    "orange",
+    "purple",
+    "pink",
+    "cyan",
+    "magenta",
+    "teal",
+    "navy",
+    "maroon",
+    "coral",
+    "salmon",
+    "gold",
+    "silver",
+    "gray",
+    "grey",
+    "indigo",
+    "violet",
+    "lime",
+    "olive",
+    "aqua",
+    "fuchsia",
+    "crimson",
+    "turquoise",
+    "ivory",
+    "beige",
+    "lavender",
+    "tan",
+    "khaki",
+    "plum",
+    "orchid",
+    "sienna",
+]);
+export function isSafeCssVarName(value) {
+    return CSS_CUSTOM_PROPERTY_NAME.test(value);
+}
+/**
+ * Token values are spliced raw into `:root { … }` declarations, so anything that
+ * could terminate a declaration or break out of a `<style>` element is unsafe.
+ */
+export function isSafeCssTokenValue(value) {
+    return (value.length > 0 &&
+        value.length <= 300 &&
+        !/[;{}<>]/.test(value) &&
+        !/\/\*/.test(value) &&
+        !/[\u0000-\u001f\u007f]/.test(value));
+}
+export function isColorTokenValue(value) {
+    const normalized = value.trim().toLowerCase();
+    return (COLOR_FUNCTION_OR_HEX.test(normalized) || NAMED_CSS_COLORS.has(normalized));
+}
+const COLOR_NAME_HINT = /color|bg|background|text|border|accent|primary|secondary|surface|muted|foreground|fill|stroke/i;
+const DIMENSION_VALUE = /^-?\d*\.?\d+(px|rem|em|ex|ch|%|vh|vw|vmin|vmax|pt|pc|cm|mm|in|s|ms|deg|fr)?$/i;
+/**
+ * Bucket a token, trusting the value's shape over the name's keywords.
+ *
+ * Name-first classification called Primer's `--text-body-size-medium: 1rem` a
+ * color because the name contains "text", which then rendered a swatch with
+ * `background: 1rem`. A dimension is never a color however the token is named.
+ */
+export function classifyBrandKitToken(name, value) {
+    const n = name.toLowerCase();
+    if (isColorTokenValue(value))
+        return "color";
+    if (/radius|rounded/i.test(n))
+        return "radius";
+    // `line-?height` and `letter` run before the spacing check so
+    // `letter-spacing` is type metrics, not layout spacing.
+    if (/font|size|leading|line-?height|letter|tracking|weight|heading|body|type/i.test(n)) {
+        return "typography";
+    }
+    if (/spacing|gap|padding|margin|space/i.test(n))
+        return "spacing";
+    if (/shadow|blur|drop/i.test(n))
+        return "shadow";
+    if (COLOR_NAME_HINT.test(n) && !DIMENSION_VALUE.test(value.trim())) {
+        return "color";
+    }
+    return "other";
+}
+/** Title-case display name derived from a CSS var, e.g. `--primary-color`. */
+export function friendlyTokenName(cssVar) {
+    return cssVar
+        .replace(/^--/, "")
+        .replace(/[-_]/g, " ")
+        .replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function readString(source, key) {
+    const value = source[key];
+    return typeof value === "string" ? value.trim() : "";
+}
+/**
+ * Coerce untrusted token JSON into storable tokens, reporting every entry it
+ * could not accept. Later duplicates of a `cssVar` win, matching the overlay
+ * order importers use.
+ */
+export function normalizeBrandKitTokens(input) {
+    if (input === undefined || input === null) {
+        return { tokens: [], rejected: [] };
+    }
+    if (!Array.isArray(input)) {
+        return { tokens: [], rejected: [{ reason: "malformed", label: "tokens" }] };
+    }
+    const byCssVar = new Map();
+    const rejected = [];
+    for (const entry of input) {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+            rejected.push({ reason: "malformed", label: String(entry) });
+            continue;
+        }
+        const record = entry;
+        const cssVar = readString(record, "cssVar");
+        const value = readString(record, "value");
+        const name = readString(record, "name") || friendlyTokenName(cssVar);
+        if (!cssVar || !isSafeCssVarName(cssVar)) {
+            rejected.push({ reason: "unsafe-css-var", label: cssVar || name });
+            continue;
+        }
+        if (!isSafeCssTokenValue(value)) {
+            rejected.push({ reason: "unsafe-value", label: cssVar });
+            continue;
+        }
+        const declaredType = readString(record, "type");
+        const group = readString(record, "group");
+        const source = readString(record, "source");
+        byCssVar.set(cssVar, {
+            name,
+            cssVar,
+            value,
+            type: BRAND_KIT_TOKEN_TYPES.includes(declaredType)
+                ? declaredType
+                : classifyBrandKitToken(cssVar, value),
+            ...(group ? { group } : {}),
+            ...(source ? { source } : {}),
+        });
+    }
+    const tokens = [...byCssVar.values()];
+    if (tokens.length > MAX_BRAND_KIT_TOKENS) {
+        for (const token of tokens.slice(MAX_BRAND_KIT_TOKENS)) {
+            rejected.push({ reason: "over-limit", label: token.cssVar });
+        }
+    }
+    return { tokens: tokens.slice(0, MAX_BRAND_KIT_TOKENS), rejected };
+}
+/** Human-readable summary of why tokens were refused, for thrown errors. */
+export function describeBrandKitTokenRejections(rejected) {
+    return rejected
+        .slice(0, 10)
+        .map((entry) => `${entry.label} (${entry.reason})`)
+        .join(", ");
+}
+/** The CSS variable each colour role is published under. */
+const BRAND_KIT_COLOR_ROLE_VARS = {
+    primary: "--color-primary",
+    secondary: "--color-secondary",
+    accent: "--color-accent",
+    background: "--color-background",
+    surface: "--color-surface",
+    text: "--color-text",
+    textMuted: "--color-text-muted",
+};
+/**
+ * The seven colour roles plus radius/spacing, as tokens. Derived from a kit's
+ * summary fields rather than named by the source system, so they carry no
+ * `group`.
+ */
+export function brandKitRoleTokens(data, source = "Brand Kit") {
+    if (!data)
+        return [];
+    const out = [];
+    const push = (cssVar, value) => {
+        if (typeof value !== "string" || !value.trim())
+            return;
+        if (!isSafeCssVarName(cssVar) || !isSafeCssTokenValue(value.trim()))
+            return;
+        out.push({
+            name: friendlyTokenName(cssVar),
+            cssVar,
+            value: value.trim(),
+            type: classifyBrandKitToken(cssVar, value.trim()),
+            source,
+        });
+    };
+    const colors = (data.colors ?? {});
+    const spacing = (data.spacing ?? {});
+    for (const [role, cssVar] of Object.entries(BRAND_KIT_COLOR_ROLE_VARS)) {
+        push(cssVar, colors[role]);
+    }
+    push("--radius", data.borders?.radius);
+    push("--spacing-element-gap", spacing.elementGap);
+    push("--spacing-page-padding", spacing.pagePadding);
+    return out;
+}
+const CSS_CUSTOM_PROPERTY_DECLARATION = /(--[-_a-zA-Z0-9]+)\s*:\s*([^;{}]+)[;}]/g;
+/**
+ * Read a kit's named tokens out of a raw CSS block. A kit's `customCSS` already
+ * spells out the source system's real token names. Declaration order wins on
+ * duplicates, matching the cascade.
+ */
+export function parseBrandKitTokensFromCss(css, source) {
+    const byCssVar = new Map();
+    for (const match of css.matchAll(CSS_CUSTOM_PROPERTY_DECLARATION)) {
+        const cssVar = match[1];
+        const value = match[2].trim();
+        if (!isSafeCssVarName(cssVar) || !isSafeCssTokenValue(value))
+            continue;
+        byCssVar.set(cssVar, {
+            name: cssVar.replace(/^--/, ""),
+            cssVar,
+            value,
+            type: classifyBrandKitToken(cssVar, value),
+            ...(source ? { source } : {}),
+        });
+    }
+    return [...byCssVar.values()].slice(0, MAX_BRAND_KIT_TOKENS);
+}
+/**
+ * The kit's named vocabulary: its stored `tokens` when it has them, else the
+ * names its `customCSS` declares. Kits predating `tokens` still carry real names
+ * in CSS, so reading only `tokens` would report them as having none.
+ */
+export function resolveBrandKitTokens(data, cssSource) {
+    if (!data)
+        return [];
+    const stored = normalizeBrandKitTokens(data.tokens).tokens;
+    if (stored.length > 0)
+        return stored;
+    return typeof data.customCSS === "string"
+        ? parseBrandKitTokensFromCss(data.customCSS, cssSource)
+        : [];
+}
+/**
+ * Group tokens for display, preserving the source's collection paths. Groups sort
+ * by token type so colors lead, then alphabetically within a type.
+ */
+export function groupBrandKitTokens(tokens) {
+    const groups = new Map();
+    for (const token of tokens) {
+        const label = token.group?.trim() || token.type;
+        const key = `${token.type}::${label}`;
+        const existing = groups.get(key);
+        if (existing) {
+            existing.tokens.push(token);
+            continue;
+        }
+        groups.set(key, { label, type: token.type, tokens: [token] });
+    }
+    return [...groups.values()].sort((a, b) => {
+        const byType = BRAND_KIT_TOKEN_TYPES.indexOf(a.type) -
+            BRAND_KIT_TOKEN_TYPES.indexOf(b.type);
+        return byType !== 0 ? byType : a.label.localeCompare(b.label);
+    });
+}
+//# sourceMappingURL=tokens.js.map

package/dist/brand-kit/types.d.ts

@@ -23,6 +23,25 @@ export interface BrandKitColors {
     text: string;
     textMuted: string;
 }
+/** Semantic category a {@link BrandKitToken} belongs to. */
+export type BrandKitTokenType = "color" | "typography" | "spacing" | "radius" | "shadow" | "other";
+/**
+ * One token under the name its source design system uses. The seven
+ * {@link BrandKitColors} roles are a summary view, not a substitute: collapsing
+ * `interactive-01` into `secondary` discards the only name the design team has.
+ */
+export interface BrandKitToken {
+    name: string;
+    /** e.g. `--cds-interactive-01`. */
+    cssVar: string;
+    /** Resolved value, e.g. a hex color or `0.5rem`. */
+    value: string;
+    type: BrandKitTokenType;
+    /** Collection path as the source organises it, e.g. `Colors/Interactive`. */
+    group?: string;
+    /** e.g. `Carbon v11` or `globals.css`. */
+    source?: string;
+}
 /** Brand typography system. */
 export interface BrandKitTypography {
     headingFont: string;
@@ -76,6 +95,12 @@ export interface BrandKitData {
     spacing: BrandKitSpacing;
     borders: BrandKitBorders;
     logos: BrandKitLogo[];
+    /**
+     * The source system's full named vocabulary. Optional because kits predating
+     * it store only the role summary — absent means "never extracted", not "the
+     * system has none".
+     */
+    tokens?: BrandKitToken[];
     imageStyle?: BrandKitImageStyle;
     customCSS?: string;
     notes?: string;

package/dist/collab/awareness.d.ts

@@ -62,11 +62,11 @@ export declare const postAwareness: import("h3").EventHandlerWithFetch<import("h
     error: string;
     states?: undefined;
 } | {
+    error?: undefined;
     states: {
         clientId: number;
         state: string;
     }[];
-    error?: undefined;
 }>>;
 /**
  * GET /_agent-native/collab/:docId/users
@@ -77,10 +77,10 @@ export declare const getActiveUsers: import("h3").EventHandlerWithFetch<import("
     error: string;
     users?: undefined;
 } | {
+    error?: undefined;
     users: {
         clientId: number;
         lastSeen: number;
     }[];
-    error?: undefined;
 }>>;
 //# sourceMappingURL=awareness.d.ts.map

package/dist/collab/routes.d.ts

@@ -26,8 +26,8 @@ export declare const getCollabState: import("h3").EventHandlerWithFetch<import("
  * Body: { update: string (base64), requestSource?: string }
  */
 export declare const postCollabUpdate: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    error: string;
     ok?: undefined;
+    error: string;
 } | {
     error?: undefined;
     ok: boolean;
@@ -41,9 +41,9 @@ export declare const postCollabUpdate: import("h3").EventHandlerWithFetch<import
  * Body: { text: string, fieldName?: string, requestSource?: string }
  */
 export declare const postCollabText: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    text?: undefined;
     ok?: undefined;
     error: string;
+    text?: undefined;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/email-catalog/actions/list-email-activity.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("../../action.js").ActionDefinition<{
+    templateId: string;
+    limit?: unknown;
+}, import("../provider-metrics.js").ProviderMetricsResult<import("../provider-metrics.js").EmailActivityEntry[]>>;
+export default _default;
+//# sourceMappingURL=list-email-activity.d.ts.map

package/dist/email-catalog/actions/list-email-activity.js

@@ -0,0 +1,15 @@
+import { z } from "zod";
+import { defineAction } from "../../action.js";
+import { authorizeTransactionalEmailRead } from "../authorize.js";
+import { fetchEmailActivity } from "../provider-metrics.js";
+export default defineAction({
+    description: "List recent provider activity for one registered transactional email in this app. Organization admin only.",
+    schema: z.object({
+        templateId: z.string().min(1),
+        limit: z.coerce.number().int().min(1).max(1000).default(50),
+    }),
+    http: { method: "GET" },
+    authorize: ({ templateId }) => authorizeTransactionalEmailRead([templateId]),
+    run: async ({ templateId, limit }) => fetchEmailActivity({ templateId, limit }),
+});
+//# sourceMappingURL=list-email-activity.js.map

package/dist/email-catalog/actions/list-email-engagement.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("../../action.js").ActionDefinition<{
+    templateIds: string[];
+    windowDays?: unknown;
+}, import("../provider-metrics.js").ProviderMetricsResult<import("../provider-metrics.js").EmailEngagement[]>>;
+export default _default;
+//# sourceMappingURL=list-email-engagement.d.ts.map

package/dist/email-catalog/actions/list-email-engagement.js

@@ -0,0 +1,15 @@
+import { z } from "zod";
+import { defineAction } from "../../action.js";
+import { authorizeTransactionalEmailRead } from "../authorize.js";
+import { fetchEmailEngagement } from "../provider-metrics.js";
+export default defineAction({
+    description: "Read provider engagement metrics for registered transactional emails in this app. Organization admin only.",
+    schema: z.object({
+        templateIds: z.array(z.string().min(1)).max(100),
+        windowDays: z.coerce.number().int().min(1).max(365).default(30),
+    }),
+    http: { method: "POST" },
+    authorize: ({ templateIds }) => authorizeTransactionalEmailRead(templateIds),
+    run: async ({ templateIds, windowDays }) => fetchEmailEngagement(templateIds, windowDays),
+});
+//# sourceMappingURL=list-email-engagement.js.map

package/dist/email-catalog/actions/list-email-log.d.ts

@@ -0,0 +1,8 @@
+declare const _default: import("../../action.js").ActionDefinition<{
+    templateId?: string;
+    limit?: unknown;
+}, {
+    entries: import("../log.js").EmailLogEntry[];
+}>;
+export default _default;
+//# sourceMappingURL=list-email-log.d.ts.map

package/dist/email-catalog/actions/list-email-log.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import { defineAction } from "../../action.js";
+import { getAppSlug } from "../../server/app-name.js";
+import { authorizeTransactionalEmailRead } from "../authorize.js";
+import { listEmailLog } from "../log.js";
+export default defineAction({
+    description: "List recent transactional email sends from this app, newest first, optionally filtered to one registered email id.",
+    schema: z.object({
+        templateId: z.string().optional(),
+        limit: z.coerce.number().int().min(1).max(500).default(100),
+    }),
+    http: { method: "GET" },
+    authorize: ({ templateId }) => authorizeTransactionalEmailRead(templateId ? [templateId] : []),
+    run: async ({ templateId, limit }) => ({
+        entries: await listEmailLog({
+            app: getAppSlug() ?? "unknown",
+            templateId,
+            limit,
+        }),
+    }),
+});
+//# sourceMappingURL=list-email-log.js.map

package/dist/email-catalog/actions/list-transactional-emails.d.ts

@@ -0,0 +1,23 @@
+declare const _default: import("../../action.js").ActionDefinition<{
+    windowDays?: unknown;
+}, {
+    app: string;
+    windowDays: number;
+    statsAvailable: boolean;
+    statsError: string;
+    emails: {
+        id: string;
+        app: string;
+        name: string;
+        trigger: string;
+        recipient: string;
+        recipientLabel: string;
+        sender: string;
+        senderLabel: string;
+        sent: number;
+        failed: number;
+        lastSentAt: number;
+    }[];
+}>;
+export default _default;
+//# sourceMappingURL=list-transactional-emails.d.ts.map

package/dist/email-catalog/actions/list-transactional-emails.js

@@ -0,0 +1,61 @@
+import { z } from "zod";
+import { defineAction } from "../../action.js";
+import { getAppSlug } from "../../server/app-name.js";
+import { getEmailSendStats } from "../log.js";
+import { listTransactionalEmails } from "../registry.js";
+import { registerCoreSystemEmails } from "../system-emails.js";
+const DEFAULT_WINDOW_DAYS = 30;
+export default defineAction({
+    description: "List the transactional emails this app can send, with the trigger, recipient and sender logic for each, plus local send counts and last-sent. Engagement metrics such as open rate are not included here — they live at the email provider.",
+    schema: z.object({
+        windowDays: z.coerce
+            .number()
+            .int()
+            .min(1)
+            .max(365)
+            .default(DEFAULT_WINDOW_DAYS)
+            .describe("How many days of send history to summarize."),
+    }),
+    http: { method: "GET" },
+    run: async ({ windowDays }) => {
+        registerCoreSystemEmails();
+        const since = Date.now() - windowDays * 24 * 60 * 60 * 1000;
+        const app = getAppSlug() ?? "unknown";
+        const definitions = listTransactionalEmails();
+        // A failed stats read must not masquerade as "no email ever sent" — the
+        // catalog is still worth returning, but the caller has to be able to tell
+        // that the numbers are missing rather than zero.
+        let statsById = null;
+        let statsError = null;
+        try {
+            const stats = await getEmailSendStats(since, app);
+            statsById = new Map(stats.map((row) => [row.templateId, row]));
+        }
+        catch (error) {
+            statsError = error instanceof Error ? error.message : String(error);
+        }
+        return {
+            app,
+            windowDays,
+            statsAvailable: statsError === null,
+            statsError,
+            emails: definitions.map((definition) => {
+                const stats = statsById?.get(definition.id);
+                return {
+                    id: definition.id,
+                    app: definition.app,
+                    name: definition.name,
+                    trigger: definition.trigger,
+                    recipient: definition.recipient,
+                    recipientLabel: definition.recipientLabel,
+                    sender: definition.sender,
+                    senderLabel: definition.senderLabel,
+                    sent: stats?.sent ?? (statsById ? 0 : null),
+                    failed: stats?.failed ?? (statsById ? 0 : null),
+                    lastSentAt: stats?.lastSentAt ?? null,
+                };
+            }),
+        };
+    },
+});
+//# sourceMappingURL=list-transactional-emails.js.map

package/dist/email-catalog/actions/render-transactional-email-preview.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("../../action.js").ActionDefinition<{
+    id: string;
+}, {
+    id: string;
+    subject: string;
+    html: string;
+    text: string;
+}>;
+export default _default;
+//# sourceMappingURL=render-transactional-email-preview.d.ts.map

package/dist/email-catalog/actions/render-transactional-email-preview.js

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import { defineAction } from "../../action.js";
+import { renderTransactionalEmailPreview } from "../registry.js";
+import { registerCoreSystemEmails } from "../system-emails.js";
+export default defineAction({
+    description: "Render one of this app's transactional emails with representative dummy data, returning the subject, HTML and plain-text bodies for preview.",
+    schema: z.object({
+        id: z
+            .string()
+            .describe("Registered email id, e.g. calendar.booking-confirmed."),
+    }),
+    http: { method: "GET" },
+    run: async ({ id }) => {
+        registerCoreSystemEmails();
+        const rendered = renderTransactionalEmailPreview(id);
+        return {
+            id,
+            subject: rendered.subject,
+            html: rendered.html,
+            text: rendered.text,
+        };
+    },
+});
+//# sourceMappingURL=render-transactional-email-preview.js.map

package/dist/email-catalog/authorize.d.ts

@@ -0,0 +1,2 @@
+export declare function authorizeTransactionalEmailRead(templateIds?: string[]): Promise<boolean>;
+//# sourceMappingURL=authorize.d.ts.map

package/dist/email-catalog/authorize.js

@@ -0,0 +1,10 @@
+import { currentRequestUserIsOrgAdmin } from "../server/org-admin.js";
+import { getTransactionalEmail } from "./registry.js";
+import { registerCoreSystemEmails } from "./system-emails.js";
+export async function authorizeTransactionalEmailRead(templateIds = []) {
+    if (!(await currentRequestUserIsOrgAdmin()))
+        return false;
+    registerCoreSystemEmails();
+    return templateIds.every((id) => Boolean(getTransactionalEmail(id)));
+}
+//# sourceMappingURL=authorize.js.map

package/dist/email-catalog/log.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Durable send log for transactional emails.
+ *
+ * Written by `sendEmail` on every attempt, successful or not. Read by Dispatch
+ * to report per-email send counts and last-sent without depending on the
+ * provider's activity retention window.
+ */
+export interface RecordEmailSendArgs {
+    templateId?: string;
+    app?: string;
+    recipient: string;
+    sender: string;
+    subject: string;
+    status: "sent" | "failed";
+    error?: string;
+    provider: string;
+}
+/**
+ * Append one send record.
+ *
+ * Callers treat logging as best-effort: a logging failure must not turn a
+ * delivered email into a thrown send. The failure is surfaced on the console
+ * rather than swallowed, so a persistently broken log is visible instead of
+ * quietly producing an empty activity view.
+ */
+export declare function recordEmailSend(args: RecordEmailSendArgs): Promise<void>;
+export interface EmailSendStats {
+    templateId: string;
+    sent: number;
+    failed: number;
+    lastSentAt: number | null;
+}
+/**
+ * Per-template send counts and last-sent, for sends at or after `since`.
+ * Templates with no rows are absent from the result — callers distinguish
+ * "never sent" from "sent zero times in window" by that absence.
+ */
+export declare function getEmailSendStats(since: number, app: string): Promise<EmailSendStats[]>;
+export interface EmailLogEntry {
+    id: string;
+    templateId: string | null;
+    app: string | null;
+    recipient: string;
+    sender: string;
+    subject: string;
+    status: string;
+    error: string | null;
+    provider: string;
+    createdAt: number;
+}
+/** Most recent sends for one app, newest first, optionally filtered to one template. */
+export declare function listEmailLog(options: {
+    app: string;
+    templateId?: string;
+    limit?: number;
+}): Promise<EmailLogEntry[]>;
+//# sourceMappingURL=log.d.ts.map