@beignet/devtools 0.0.3 → 0.0.5

package/dist/ui-model.js

@@ -0,0 +1,1039 @@
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function detailsObject(event) {
+    return isRecord(event.details) ? event.details : {};
+}
+function detailValue(event, key) {
+    return detailsObject(event)[key];
+}
+function detailString(event, key) {
+    const value = detailValue(event, key);
+    return typeof value === "string" ? value : "";
+}
+function detailNumber(event, key) {
+    const value = detailValue(event, key);
+    return typeof value === "number" && Number.isFinite(value)
+        ? value
+        : undefined;
+}
+function detailBoolean(event, key) {
+    const value = detailValue(event, key);
+    return typeof value === "boolean" ? value : undefined;
+}
+function valueText(value) {
+    if (value === undefined || value === null || value === "")
+        return "";
+    if (typeof value === "string")
+        return value;
+    if (typeof value === "number" || typeof value === "boolean") {
+        return String(value);
+    }
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function jsonSearch(value) {
+    return valueText(value);
+}
+function containsText(event, text) {
+    return jsonSearch(event).toLowerCase().includes(text.toLowerCase());
+}
+export function inferDevtoolsWatcher(event) {
+    if (event.watcher)
+        return event.watcher;
+    switch (event.type) {
+        case "request":
+            return "requests";
+        case "error":
+            return "errors";
+        case "usecase":
+            return "useCases";
+        case "eventBus":
+            return "eventBus";
+        case "job":
+            return "jobs";
+        case "outbox":
+            return "outbox";
+        case "schedule":
+            return "schedules";
+        case "provider":
+            return "providers";
+        case "custom":
+            return "custom";
+        default:
+            return "";
+    }
+}
+export function devtoolsEventBadgeLabel(event) {
+    if (event.type === "custom") {
+        switch (inferDevtoolsWatcher(event)) {
+            case "auth":
+                return "auth";
+            case "audit":
+                return "audit";
+            case "cache":
+                return "cache";
+            case "db":
+                return "database";
+            case "mail":
+                return "mail";
+            case "notifications":
+                return "notifications";
+            case "rateLimit":
+                return "rate limit";
+            case "storage":
+                return "storage";
+            case "uploads":
+                return "uploads";
+            default:
+                return "custom";
+        }
+    }
+    return event.type;
+}
+export function devtoolsEventBadgeClass(event) {
+    if (event.type === "custom") {
+        switch (inferDevtoolsWatcher(event)) {
+            case "auth":
+                return "auth";
+            case "audit":
+                return "audit";
+            case "cache":
+                return "cache";
+            case "db":
+                return "db";
+            case "mail":
+                return "mail";
+            case "notifications":
+                return "notifications";
+            case "rateLimit":
+                return "rateLimit";
+            case "storage":
+                return "storage";
+            case "uploads":
+                return "uploads";
+            default:
+                return "custom";
+        }
+    }
+    return event.type;
+}
+export function summarizeDevtoolsEvent(event) {
+    switch (event.type) {
+        case "request":
+            return `${event.method || ""} ${event.path || ""}${event.status ? ` -> ${event.status}` : ""}${event.durationMs !== undefined ? ` (${event.durationMs}ms)` : ""}`;
+        case "error":
+            return event.message || "Unknown error";
+        case "usecase":
+            return `${event.name} (${event.phase})${event.durationMs !== undefined ? ` ${event.durationMs}ms` : ""}`;
+        case "eventBus":
+            return event.eventName || "Domain event";
+        case "job":
+            return `${event.jobName} -> ${event.status}`;
+        case "outbox":
+            return `${event.messageName} (${event.messageKind}) -> ${event.status}`;
+        case "schedule":
+            return `${event.scheduleName} -> ${event.status}`;
+        case "provider":
+            return `${event.providerName} -> ${event.action}`;
+        case "custom":
+            return `${event.label || event.name || "Custom event"}${event.summary ? ` - ${event.summary}` : ""}`;
+        default:
+            return "";
+    }
+}
+export function devtoolsEventDuration(event) {
+    const detailDuration = detailNumber(event, "durationMs");
+    const eventDuration = "durationMs" in event && typeof event.durationMs === "number"
+        ? event.durationMs
+        : undefined;
+    const duration = eventDuration !== undefined ? eventDuration : detailDuration;
+    return typeof duration === "number" && Number.isFinite(duration)
+        ? duration
+        : undefined;
+}
+export function devtoolsEventProvider(event) {
+    if (event.type === "provider")
+        return event.providerName;
+    const details = detailsObject(event);
+    return valueText(details.providerName ?? details.provider ?? details.portName ?? "");
+}
+export function devtoolsEventFailure(event) {
+    const details = detailsObject(event);
+    if (event.type === "error")
+        return true;
+    if ("status" in event && typeof event.status === "string") {
+        return (event.status === "failed" ||
+            event.status === "deadLettered" ||
+            event.status === "retryScheduled");
+    }
+    if (event.type === "custom" && event.name.includes("failed"))
+        return true;
+    return Boolean(details.error) || details.allowed === false;
+}
+export function hasDevtoolsRedactedValue(value) {
+    if (value === "[redacted]")
+        return true;
+    if (!isRecord(value) && !Array.isArray(value))
+        return false;
+    return Object.values(value).some(hasDevtoolsRedactedValue);
+}
+function averageDuration(events) {
+    const durations = events
+        .map(devtoolsEventDuration)
+        .filter((value) => value !== undefined);
+    if (!durations.length)
+        return "n/a";
+    const total = durations.reduce((sum, value) => sum + value, 0);
+    return `${Math.round(total / durations.length)}ms`;
+}
+function averageNumber(events, selector) {
+    const values = events
+        .map(selector)
+        .filter((value) => value !== undefined);
+    if (!values.length)
+        return "n/a";
+    const total = values.reduce((sum, value) => sum + value, 0);
+    return Math.round((total / values.length) * 10) / 10;
+}
+function sumNumber(events, selector) {
+    return events.reduce((sum, event) => sum + (selector(event) ?? 0), 0);
+}
+function distinctCount(events, selector) {
+    const values = new Set();
+    for (const event of events) {
+        const value = selector(event);
+        if (value !== undefined && value !== null && String(value) !== "") {
+            values.add(String(value));
+        }
+    }
+    return values.size;
+}
+function operationFor(event) {
+    const operation = detailString(event, "operation");
+    if (operation)
+        return operation;
+    if (event.type === "custom") {
+        const parts = event.name.split(".");
+        return parts.length > 1 ? parts.slice(1).join(".") : event.name;
+    }
+    if (event.type === "provider")
+        return event.action;
+    if ("status" in event && typeof event.status === "string") {
+        return event.status;
+    }
+    return inferDevtoolsWatcher(event);
+}
+function operationBase(event) {
+    return operationFor(event).replace(/\.failed$/, "");
+}
+function errorTextFor(event) {
+    const detailError = detailValue(event, "error");
+    if (typeof detailError === "string" && detailError)
+        return detailError;
+    if (isRecord(detailError)) {
+        if (typeof detailError.message === "string")
+            return detailError.message;
+        return jsonSearch(detailError);
+    }
+    if ("error" in event && typeof event.error === "string")
+        return event.error;
+    return "";
+}
+function queryFor(event) {
+    const query = detailString(event, "query");
+    return query || ("summary" in event && event.summary ? event.summary : "");
+}
+function dbOperationFor(event) {
+    const query = queryFor(event).trim();
+    const match = query.match(/^([a-z]+)/i);
+    return match ? match[1].toLowerCase() : "query";
+}
+function dbTargetFor(event) {
+    const query = queryFor(event);
+    const patterns = [
+        /\bfrom\s+"?([a-zA-Z0-9_]+)"?/i,
+        /\binto\s+"?([a-zA-Z0-9_]+)"?/i,
+        /\bupdate\s+"?([a-zA-Z0-9_]+)"?/i,
+        /\bdelete\s+from\s+"?([a-zA-Z0-9_]+)"?/i,
+    ];
+    for (const pattern of patterns) {
+        const match = query.match(pattern);
+        if (match)
+            return match[1] ?? "";
+    }
+    return "";
+}
+function attemptLabel(event) {
+    const attempt = detailValue(event, "attempt");
+    const max = detailValue(event, "maxAttempts");
+    if (attempt !== undefined && max !== undefined)
+        return `${attempt}/${max}`;
+    if (attempt !== undefined)
+        return `attempt ${attempt}`;
+    return "";
+}
+function retryFor(event) {
+    const retryAt = detailValue(event, "retryAt") || detailValue(event, "availableAt");
+    const retryDelayMs = detailValue(event, "retryDelayMs");
+    if (retryAt && retryDelayMs !== undefined)
+        return `${retryAt} (${retryDelayMs}ms)`;
+    return valueText(retryAt);
+}
+function channelList(event) {
+    const channels = notificationChannels(event);
+    if (channels.length)
+        return channels.join(", ");
+    return "";
+}
+function notificationChannels(event) {
+    const channels = detailValue(event, "channels");
+    if (Array.isArray(channels))
+        return channels.map(String);
+    const channel = detailValue(event, "channel");
+    if (channel)
+        return [String(channel)];
+    const results = detailValue(event, "results");
+    if (Array.isArray(results)) {
+        return results
+            .map((result) => (isRecord(result) ? valueText(result.channel) : ""))
+            .filter(Boolean);
+    }
+    return [];
+}
+function distinctNotificationChannels(events) {
+    const values = new Set();
+    for (const event of events) {
+        for (const channel of notificationChannels(event)) {
+            values.add(channel);
+        }
+    }
+    return values.size;
+}
+function recipientSummary(event) {
+    const to = detailValue(event, "to");
+    if (Array.isArray(to))
+        return `${to.length} recipient${to.length === 1 ? "" : "s"}`;
+    return valueText(to);
+}
+function actorId(event) {
+    const actor = detailValue(event, "actor");
+    return isRecord(actor) ? valueText(actor.id) : "";
+}
+function resourceId(event) {
+    const resource = detailValue(event, "resource");
+    return isRecord(resource) ? valueText(resource.id ?? resource.type) : "";
+}
+function scheduleStatus(event, status) {
+    return event.type === "schedule" && event.status === status;
+}
+function notificationFailed(event) {
+    const results = detailValue(event, "results");
+    if (Array.isArray(results)) {
+        return results.some((result) => isRecord(result) && valueText(result.status) === "failed");
+    }
+    return devtoolsEventFailure(event);
+}
+function storageMissing(event) {
+    return (detailBoolean(event, "exists") === false ||
+        detailValue(event, "object") === null ||
+        containsText(event, "missing"));
+}
+export function devtoolsPanelMeta(tabId, label = "Subsystem") {
+    switch (tabId) {
+        case "events":
+            return {
+                title: "Domain events",
+                subtitle: "Published facts and event bus activity",
+            };
+        case "jobs":
+            return { title: "Jobs", subtitle: "Background job lifecycle" };
+        case "outbox":
+            return {
+                title: "Outbox",
+                subtitle: "Durable message delivery, retries, and dead letters",
+            };
+        case "schedules":
+            return { title: "Schedules", subtitle: "Cron and schedule runs" };
+        case "db":
+            return {
+                title: "Database",
+                subtitle: "Queries and database provider diagnostics",
+            };
+        case "cache":
+            return {
+                title: "Cache",
+                subtitle: "Reads, writes, deletes, and hit rates",
+            };
+        case "storage":
+            return {
+                title: "Storage",
+                subtitle: "Object reads, writes, deletes, and public URL resolution",
+            };
+        case "uploads":
+            return {
+                title: "Uploads",
+                subtitle: "Upload preparation, signing, server upload, and completion",
+            };
+        case "mail":
+            return {
+                title: "Mail",
+                subtitle: "Delivery attempts, recipients, and provider results",
+            };
+        case "notifications":
+            return {
+                title: "Notifications",
+                subtitle: "Notification intent and per-channel delivery",
+            };
+        case "auth":
+            return { title: "Auth", subtitle: "Session and authentication activity" };
+        case "audit":
+            return {
+                title: "Audit",
+                subtitle: "Durable activity records emitted by application code",
+            };
+        case "rateLimit":
+            return {
+                title: "Rate limits",
+                subtitle: "Allowed, blocked, and failed checks",
+            };
+        default:
+            return { title: label, subtitle: "Subsystem activity" };
+    }
+}
+export function devtoolsPanelMetrics(tabId, events) {
+    switch (tabId) {
+        case "events":
+            return [
+                { label: "Events", value: events.length },
+                {
+                    label: "Names",
+                    value: distinctCount(events, (event) => event.type === "eventBus" ? event.eventName : ""),
+                },
+                {
+                    label: "Traces",
+                    value: distinctCount(events, (event) => event.traceId),
+                },
+                {
+                    label: "Requests",
+                    value: distinctCount(events, (event) => event.requestId),
+                },
+            ];
+        case "jobs":
+            return [
+                { label: "Jobs", value: events.length },
+                {
+                    label: "Scheduled",
+                    value: events.filter((event) => event.type === "job" && event.status === "scheduled").length,
+                },
+                {
+                    label: "Failed",
+                    value: events.filter((event) => event.type === "job" && event.status === "failed").length,
+                },
+                {
+                    label: "Retried",
+                    value: events.filter((event) => event.type === "job" && event.status === "retryScheduled").length,
+                },
+                {
+                    label: "Dead letters",
+                    value: events.filter((event) => event.type === "job" && event.status === "deadLettered").length,
+                },
+            ];
+        case "outbox":
+            return [
+                {
+                    label: "Delivered",
+                    value: events.filter((event) => event.type === "outbox" && event.status === "delivered").length,
+                },
+                {
+                    label: "Retried",
+                    value: events.filter((event) => event.type === "outbox" && event.status === "retryScheduled").length,
+                },
+                {
+                    label: "Dead letters",
+                    value: events.filter((event) => event.type === "outbox" && event.status === "deadLettered").length,
+                },
+                {
+                    label: "Avg attempt",
+                    value: averageNumber(events, (event) => detailNumber(event, "attempt")),
+                },
+            ];
+        case "schedules":
+            return [
+                { label: "Runs", value: events.length },
+                {
+                    label: "Completed",
+                    value: events.filter((event) => scheduleStatus(event, "completed"))
+                        .length,
+                },
+                {
+                    label: "Failed",
+                    value: events.filter((event) => scheduleStatus(event, "failed"))
+                        .length,
+                },
+                {
+                    label: "Names",
+                    value: distinctCount(events, (event) => event.type === "schedule" ? event.scheduleName : ""),
+                },
+            ];
+        case "cache":
+            return [
+                { label: "Operations", value: events.length },
+                {
+                    label: "Hits",
+                    value: events.filter((event) => detailBoolean(event, "hit") === true ||
+                        detailBoolean(event, "exists") === true).length,
+                },
+                {
+                    label: "Misses",
+                    value: events.filter((event) => detailBoolean(event, "hit") === false ||
+                        detailBoolean(event, "exists") === false).length,
+                },
+                {
+                    label: "Failures",
+                    value: events.filter(devtoolsEventFailure).length,
+                },
+            ];
+        case "db":
+            return [
+                { label: "Queries", value: events.length },
+                {
+                    label: "Failures",
+                    value: events.filter(devtoolsEventFailure).length,
+                },
+                { label: "Tables", value: distinctCount(events, dbTargetFor) },
+                {
+                    label: "Redacted",
+                    value: events.filter(hasDevtoolsRedactedValue).length,
+                },
+            ];
+        case "storage":
+            return [
+                { label: "Operations", value: events.length },
+                {
+                    label: "Writes",
+                    value: events.filter((event) => operationBase(event) === "put")
+                        .length,
+                },
+                { label: "Missing", value: events.filter(storageMissing).length },
+                {
+                    label: "Failures",
+                    value: events.filter(devtoolsEventFailure).length,
+                },
+            ];
+        case "uploads":
+            return [
+                { label: "Uploads", value: events.length },
+                {
+                    label: "Completed",
+                    value: events.filter((event) => event.type === "custom" && event.name.endsWith(".completed")).length,
+                },
+                { label: "Failed", value: events.filter(devtoolsEventFailure).length },
+                {
+                    label: "Files",
+                    value: sumNumber(events, (event) => detailNumber(event, "fileCount")),
+                },
+            ];
+        case "mail":
+            return [
+                {
+                    label: "Attempts",
+                    value: events.filter((event) => event.type === "custom" && event.name === "mail.send").length,
+                },
+                {
+                    label: "Sent",
+                    value: events.filter((event) => event.type === "custom" && event.name === "mail.sent").length,
+                },
+                { label: "Failed", value: events.filter(devtoolsEventFailure).length },
+                {
+                    label: "Providers",
+                    value: distinctCount(events, devtoolsEventProvider),
+                },
+            ];
+        case "notifications":
+            return [
+                { label: "Notifications", value: events.length },
+                {
+                    label: "Completed",
+                    value: events.filter((event) => event.type === "custom" && event.name.endsWith(".completed")).length,
+                },
+                { label: "Failed", value: events.filter(notificationFailed).length },
+                { label: "Channels", value: distinctNotificationChannels(events) },
+            ];
+        case "auth":
+            return [
+                { label: "Checks", value: events.length },
+                {
+                    label: "Signed in",
+                    value: events.filter((event) => detailBoolean(event, "authenticated") === true).length,
+                },
+                {
+                    label: "Guest",
+                    value: events.filter((event) => detailBoolean(event, "authenticated") === false &&
+                        !devtoolsEventFailure(event)).length,
+                },
+                {
+                    label: "Failures",
+                    value: events.filter(devtoolsEventFailure).length,
+                },
+            ];
+        case "audit":
+            return [
+                { label: "Entries", value: events.length },
+                {
+                    label: "Failures",
+                    value: events.filter((event) => detailValue(event, "outcome") === "failure").length,
+                },
+                { label: "Actors", value: distinctCount(events, actorId) },
+                { label: "Resources", value: distinctCount(events, resourceId) },
+            ];
+        case "rateLimit":
+            return [
+                { label: "Checks", value: events.length },
+                {
+                    label: "Allowed",
+                    value: events.filter((event) => detailBoolean(event, "allowed") === true).length,
+                },
+                {
+                    label: "Blocked",
+                    value: events.filter((event) => detailBoolean(event, "allowed") === false).length,
+                },
+                { label: "Avg", value: averageDuration(events) },
+            ];
+        default:
+            return [
+                { label: "Events", value: events.length },
+                {
+                    label: "Failures",
+                    value: events.filter(devtoolsEventFailure).length,
+                },
+                {
+                    label: "Requests",
+                    value: distinctCount(events, (event) => event.requestId),
+                },
+                { label: "Avg", value: averageDuration(events) },
+            ];
+    }
+}
+function field(label, value) {
+    return { label, value: valueText(value) };
+}
+function genericDetail(event) {
+    return {
+        fields: [
+            field("Provider", devtoolsEventProvider(event)),
+            field("Operation", operationFor(event)),
+            field("Duration", devtoolsEventDuration(event) !== undefined
+                ? `${devtoolsEventDuration(event)}ms`
+                : ""),
+            field("Request", event.requestId),
+            field("Trace", event.traceId ? event.traceId.slice(0, 12) : ""),
+            field("Error", errorTextFor(event)),
+        ],
+        note: summarizeDevtoolsEvent(event),
+    };
+}
+export function devtoolsPanelDetail(tabId, event) {
+    const details = detailsObject(event);
+    switch (tabId) {
+        case "db":
+            return {
+                fields: [
+                    field("Provider", devtoolsEventProvider(event)),
+                    field("Operation", dbOperationFor(event)),
+                    field("Table", dbTargetFor(event)),
+                    field("Port", details.portName),
+                    field("Params", details.paramsCount),
+                    field("Duration", devtoolsEventDuration(event) !== undefined
+                        ? `${devtoolsEventDuration(event)}ms`
+                        : ""),
+                    field("Request", event.requestId),
+                    field("Trace", event.traceId ? event.traceId.slice(0, 12) : ""),
+                ],
+                note: "summary" in event && event.summary
+                    ? event.summary
+                    : "Database provider activity",
+            };
+        case "outbox":
+            return {
+                fields: [
+                    field("Message", event.type === "outbox" ? event.messageName : ""),
+                    field("Kind", event.type === "outbox" ? event.messageKind : ""),
+                    field("Status", "status" in event ? event.status : ""),
+                    field("Attempt", attemptLabel(event)),
+                    field("Retry", retryFor(event)),
+                    field("Error", errorTextFor(event)),
+                    field("Request", event.requestId),
+                    field("Trace", event.traceId ? event.traceId.slice(0, 12) : ""),
+                ],
+                note: summarizeDevtoolsEvent(event),
+            };
+        case "jobs":
+            return {
+                fields: [
+                    field("Job", event.type === "job" ? event.jobName : ""),
+                    field("Status", "status" in event ? event.status : ""),
+                    field("Phase", details.phase),
+                    field("Provider", devtoolsEventProvider(event)),
+                    field("Attempt", attemptLabel(event)),
+                    field("Retry", retryFor(event)),
+                    field("Error", errorTextFor(event)),
+                    field("Request", event.requestId),
+                ],
+                note: summarizeDevtoolsEvent(event),
+            };
+        case "schedules":
+            return {
+                fields: [
+                    field("Schedule", event.type === "schedule" ? event.scheduleName : ""),
+                    field("Status", "status" in event ? event.status : ""),
+                    field("Cron", event.type === "schedule" ? event.cron : details.cron),
+                    field("Timezone", event.type === "schedule" ? event.timezone : details.timezone),
+                    field("Provider", devtoolsEventProvider(event)),
+                    field("Duration", devtoolsEventDuration(event) !== undefined
+                        ? `${devtoolsEventDuration(event)}ms`
+                        : ""),
+                    field("Error", errorTextFor(event)),
+                    field("Request", event.requestId),
+                ],
+                note: summarizeDevtoolsEvent(event),
+            };
+        case "cache":
+            return {
+                fields: [
+                    field("Operation", operationFor(event)),
+                    field("Key", details.key),
+                    field("Result", devtoolsPanelResult(event)),
+                    field("TTL", details.ttlSeconds),
+                    field("Provider", devtoolsEventProvider(event)),
+                    field("Duration", devtoolsEventDuration(event) !== undefined
+                        ? `${devtoolsEventDuration(event)}ms`
+                        : ""),
+                    field("Error", errorTextFor(event)),
+                    field("Request", event.requestId),
+                ],
+                note: summarizeDevtoolsEvent(event),
+            };
+        case "storage":
+            return {
+                fields: [
+                    field("Operation", operationFor(event)),
+                    field("Key", details.key),
+                    field("Bucket", details.bucket),
+                    field("Visibility", details.visibility),
+                    field("Provider", devtoolsEventProvider(event)),
+                    field("Duration", devtoolsEventDuration(event) !== undefined
+                        ? `${devtoolsEventDuration(event)}ms`
+                        : ""),
+                    field("Error", errorTextFor(event)),
+                    field("Request", event.requestId),
+                ],
+                note: summarizeDevtoolsEvent(event),
+            };
+        case "uploads":
+            return {
+                fields: [
+                    field("Upload", details.uploadName || ("summary" in event ? event.summary : "")),
+                    field("Operation", operationFor(event)),
+                    field("Mode", details.mode),
+                    field("Files", details.fileCount),
+                    field("Key", details.key),
+                    field("Provider", devtoolsEventProvider(event)),
+                    field("Duration", devtoolsEventDuration(event) !== undefined
+                        ? `${devtoolsEventDuration(event)}ms`
+                        : ""),
+                    field("Error", errorTextFor(event)),
+                ],
+                note: summarizeDevtoolsEvent(event),
+            };
+        case "mail":
+            return {
+                fields: [
+                    field("Subject", details.subject),
+                    field("Provider", devtoolsEventProvider(event)),
+                    field("Recipients", recipientSummary(event)),
+                    field("Message ID", details.id),
+                    field("Operation", operationFor(event)),
+                    field("Error", errorTextFor(event)),
+                    field("Request", event.requestId),
+                    field("Trace", event.traceId ? event.traceId.slice(0, 12) : ""),
+                ],
+                note: summarizeDevtoolsEvent(event),
+            };
+        case "notifications":
+            return {
+                fields: [
+                    field("Notification", details.notificationName ||
+                        ("summary" in event ? event.summary : "")),
+                    field("Channels", channelList(event)),
+                    field("Status", devtoolsPanelResult(event)),
+                    field("Provider", devtoolsEventProvider(event)),
+                    field("Error", errorTextFor(event)),
+                    field("Request", event.requestId),
+                    field("Trace", event.traceId ? event.traceId.slice(0, 12) : ""),
+                    field("Metadata", details.metadata ? "present" : ""),
+                ],
+                note: summarizeDevtoolsEvent(event),
+            };
+        case "auth":
+            return {
+                fields: [
+                    field("Operation", operationFor(event)),
+                    field("Authenticated", detailBoolean(event, "authenticated")),
+                    field("Provider", devtoolsEventProvider(event)),
+                    field("Duration", devtoolsEventDuration(event) !== undefined
+                        ? `${devtoolsEventDuration(event)}ms`
+                        : ""),
+                    field("Error", errorTextFor(event)),
+                    field("Request", event.requestId),
+                    field("Trace", event.traceId ? event.traceId.slice(0, 12) : ""),
+                    field("Result", devtoolsPanelResult(event)),
+                ],
+                note: summarizeDevtoolsEvent(event),
+            };
+        case "audit":
+            return {
+                fields: [
+                    field("Action", details.action || ("name" in event ? event.name : "")),
+                    field("Outcome", details.outcome),
+                    field("Actor", actorId(event)),
+                    field("Resource", resourceId(event)),
+                    field("Tenant", isRecord(details.tenant) ? details.tenant.id : ""),
+                    field("Occurred", details.occurredAt),
+                    field("Request", event.requestId),
+                    field("Trace", event.traceId ? event.traceId.slice(0, 12) : ""),
+                ],
+                note: valueText(details.message) || summarizeDevtoolsEvent(event),
+            };
+        case "rateLimit":
+            return {
+                fields: [
+                    field("Key", details.key),
+                    field("Allowed", detailBoolean(event, "allowed")),
+                    field("Remaining", details.remaining),
+                    field("Limit", details.limit),
+                    field("Window", details.windowSec ? `${details.windowSec}s` : ""),
+                    field("Retry after", details.retryAfterSeconds),
+                    field("Provider", devtoolsEventProvider(event)),
+                    field("Error", errorTextFor(event)),
+                ],
+                note: summarizeDevtoolsEvent(event),
+            };
+        default:
+            return genericDetail(event);
+    }
+}
+export function devtoolsPanelPrimary(tabId, event) {
+    const details = detailsObject(event);
+    switch (tabId) {
+        case "db":
+            return (dbTargetFor(event) ||
+                ("summary" in event ? event.summary : "") ||
+                "Database query");
+        case "cache":
+            return valueText(details.key) || "Cache operation";
+        case "storage":
+            return valueText(details.key) || "Storage operation";
+        case "uploads":
+            return (valueText(details.uploadName || ("summary" in event ? event.summary : "")) || "Upload");
+        case "mail":
+            return valueText(details.subject) || "Mail";
+        case "notifications":
+            return (valueText(details.notificationName || ("summary" in event ? event.summary : "")) || "Notification");
+        case "auth":
+            return operationFor(event) || "Auth";
+        case "audit":
+            return (valueText(details.action || ("name" in event ? event.name : "")) ||
+                "Audit entry");
+        case "rateLimit":
+            return valueText(details.key) || "Rate limit";
+        default:
+            switch (event.type) {
+                case "eventBus":
+                    return event.eventName || "Domain event";
+                case "job":
+                    return event.jobName || "Job";
+                case "outbox":
+                    return event.messageName || "Outbox message";
+                case "schedule":
+                    return event.scheduleName || "Schedule";
+                case "custom":
+                    return event.label || event.name || "Custom event";
+                default:
+                    return summarizeDevtoolsEvent(event);
+            }
+    }
+}
+export function devtoolsPanelSecondary(tabId, event) {
+    const details = detailsObject(event);
+    switch (tabId) {
+        case "db":
+            return ([dbOperationFor(event), details.portName].filter(Boolean).join(" / ") ||
+                "query");
+        case "cache":
+        case "storage":
+            return [operationFor(event), devtoolsEventProvider(event)]
+                .filter(Boolean)
+                .join(" / ");
+        case "uploads":
+            return [
+                operationFor(event),
+                details.mode,
+                details.fileCount ? `${details.fileCount} files` : "",
+            ]
+                .filter(Boolean)
+                .join(" / ");
+        case "mail":
+            return [devtoolsEventProvider(event), recipientSummary(event)]
+                .filter(Boolean)
+                .join(" / ");
+        case "notifications":
+            return [channelList(event), devtoolsPanelResult(event)]
+                .filter(Boolean)
+                .join(" / ");
+        case "auth":
+            return [
+                detailBoolean(event, "authenticated") === true
+                    ? "authenticated"
+                    : detailBoolean(event, "authenticated") === false
+                        ? "guest"
+                        : "",
+                devtoolsEventProvider(event),
+            ]
+                .filter(Boolean)
+                .join(" / ");
+        case "audit":
+            return [details.outcome, actorId(event), resourceId(event)]
+                .filter(Boolean)
+                .join(" / ");
+        case "rateLimit":
+            return [
+                detailBoolean(event, "allowed") === true
+                    ? "allowed"
+                    : detailBoolean(event, "allowed") === false
+                        ? "blocked"
+                        : "",
+                details.remaining !== undefined ? `${details.remaining} remaining` : "",
+            ]
+                .filter(Boolean)
+                .join(" / ");
+        default:
+            if (event.type === "provider")
+                return event.action;
+            if (event.type === "outbox")
+                return [event.messageKind, attemptLabel(event)]
+                    .filter(Boolean)
+                    .join(" / ");
+            if (event.type === "job")
+                return [event.status, details.phase, attemptLabel(event)]
+                    .filter(Boolean)
+                    .join(" / ");
+            if (event.type === "schedule")
+                return [event.status, event.cron].filter(Boolean).join(" / ");
+            if (event.type === "eventBus")
+                return event.requestId || event.traceId || "";
+            if (details.operation)
+                return valueText(details.operation);
+            if (event.type === "custom")
+                return event.name;
+            return inferDevtoolsWatcher(event);
+    }
+}
+export function devtoolsPanelResult(event) {
+    const details = detailsObject(event);
+    if (details.allowed === true)
+        return "allowed";
+    if (details.allowed === false)
+        return "blocked";
+    if (details.hit === true)
+        return "hit";
+    if (details.hit === false)
+        return "miss";
+    if (details.exists === true)
+        return "exists";
+    if (details.exists === false)
+        return "missing";
+    if (details.authenticated === true)
+        return "signed in";
+    if (details.authenticated === false)
+        return "guest";
+    if (event.type === "custom" && event.name.endsWith(".completed"))
+        return "completed";
+    if (event.type === "custom" && event.name.endsWith(".sent"))
+        return "sent";
+    if ("status" in event && typeof event.status === "string")
+        return event.status;
+    if (details.outcome)
+        return valueText(details.outcome);
+    if (details.error)
+        return "failed";
+    return devtoolsEventProvider(event) || inferDevtoolsWatcher(event);
+}
+export function createDevtoolsPanelRow(tabId, event) {
+    return {
+        primary: devtoolsPanelPrimary(tabId, event),
+        secondary: devtoolsPanelSecondary(tabId, event),
+        summary: summarizeDevtoolsEvent(event),
+        durationMs: devtoolsEventDuration(event),
+        result: devtoolsPanelResult(event),
+        detail: devtoolsPanelDetail(tabId, event),
+    };
+}
+export function devtoolsPanelModelBrowserSource() {
+    return [
+        isRecord,
+        detailsObject,
+        detailValue,
+        detailString,
+        detailNumber,
+        detailBoolean,
+        valueText,
+        jsonSearch,
+        containsText,
+        inferDevtoolsWatcher,
+        devtoolsEventBadgeLabel,
+        devtoolsEventBadgeClass,
+        summarizeDevtoolsEvent,
+        devtoolsEventDuration,
+        devtoolsEventProvider,
+        devtoolsEventFailure,
+        hasDevtoolsRedactedValue,
+        averageDuration,
+        averageNumber,
+        sumNumber,
+        distinctCount,
+        operationFor,
+        operationBase,
+        errorTextFor,
+        queryFor,
+        dbOperationFor,
+        dbTargetFor,
+        attemptLabel,
+        retryFor,
+        channelList,
+        notificationChannels,
+        distinctNotificationChannels,
+        recipientSummary,
+        actorId,
+        resourceId,
+        scheduleStatus,
+        notificationFailed,
+        storageMissing,
+        devtoolsPanelMeta,
+        devtoolsPanelMetrics,
+        field,
+        genericDetail,
+        devtoolsPanelDetail,
+        devtoolsPanelPrimary,
+        devtoolsPanelSecondary,
+        devtoolsPanelResult,
+        createDevtoolsPanelRow,
+    ]
+        .map((fn) => fn.toString())
+        .join("\n");
+}
+//# sourceMappingURL=ui-model.js.map