@beignet/devtools 0.0.1

package/CHANGELOG.md

@@ -0,0 +1,5 @@
+# @beignet/devtools
+
+## 0.0.1
+
+- Initial Beignet release under the `@beignet` npm scope.

package/README.md

@@ -0,0 +1,464 @@
+# @beignet/devtools
+
+Development-time event timeline for Beignet apps. It records HTTP requests,
+errors, use case runs, domain events, jobs, scheduled tasks, and provider
+activity in a bounded in-memory buffer, then serves a live dashboard from your
+app.
+
+Devtools is enabled outside production by default and returns a no-op port in
+production unless you explicitly enable it.
+
+## Install
+
+```bash
+bun add @beignet/devtools
+```
+
+## Next.js setup
+
+Register the provider and server hook:
+
+```typescript
+import {
+  createDevtoolsHooks,
+  createDevtoolsProvider,
+} from "@beignet/devtools";
+import { createNextServer } from "@beignet/next";
+
+export const server = await createNextServer({
+  ports,
+  providers: [createDevtoolsProvider(), ...providers],
+  hooks: [createDevtoolsHooks()],
+  createContext: ({ req, ports }) => ({
+    requestId: req.headers.get("x-request-id") ?? crypto.randomUUID(),
+    ports,
+  }),
+});
+```
+
+Add a catch-all route:
+
+```typescript
+// app/api/devtools/[[...path]]/route.ts
+import { createDevtoolsRoute } from "@beignet/devtools";
+import { server } from "@/server";
+
+export const { GET, POST } = createDevtoolsRoute(server.ports.devtools, {
+  basePath: "/api/devtools",
+});
+```
+
+Open `/api/devtools`.
+
+The dashboard connects to the event stream with Server-Sent Events and falls
+back to polling when `EventSource` is unavailable. It includes tabs for the
+timeline, requests, use cases, errors, domain events, jobs, schedules, providers, and
+provider-owned events such as database/cache/storage/core/mail/auth/audit/rate limit
+activity, and custom events.
+Request rows expand into correlated events that share the same `traceId` or
+`requestId`.
+
+Use the toolbar to search across event summaries, paths, messages, names,
+watchers, IDs, and details. The dashboard also includes method, status, and
+watcher filters for narrowing noisy timelines.
+
+Provider-owned tabs render focused panels with subsystem metrics and rows. For
+example, database shows query/provider context, cache shows hit and failure
+counts, auth shows authenticated versus guest activity, audit shows durable
+activity records, and rate limits show allowed versus blocked checks.
+
+## Local persistence
+
+The default buffer is in memory. Enable local persistence when you want the
+timeline to survive dev server restarts:
+
+```typescript
+import {
+  createDevtoolsProvider,
+  createFileDevtoolsStore,
+} from "@beignet/devtools";
+
+createDevtoolsProvider({
+  store: createFileDevtoolsStore({
+    filePath: ".beignet/devtools/core/events.jsonl",
+  }),
+});
+```
+
+You can also enable the built-in file store through environment variables:
+
+```bash
+DEVTOOLS_PERSIST=true
+DEVTOOLS_PERSIST_PATH=.beignet/devtools/core/events.jsonl
+```
+
+The file store writes JSONL and compacts to the most recent configured events.
+`POST /api/devtools/clear` clears the in-memory buffer and the configured store.
+
+## Trace context
+
+Devtools is OpenTelemetry-compatible without depending on the OpenTelemetry SDK.
+`createDevtoolsHooks()` reads incoming W3C `traceparent` headers, creates a
+local span when one is missing, exposes the current `traceparent` response
+header, and adds trace fields to captured events.
+
+All captured events can include:
+
+- `traceId`: W3C trace ID for distributed correlation
+- `spanId`: span ID for the operation represented by the event
+- `parentSpanId`: parent span ID when the event is nested
+- `traceparent`: W3C header value for the current span
+
+For object contexts, the hook also adds these fields before the handler runs so
+use case instrumentation can attach nested spans to the request trace.
+
+## Watchers
+
+Devtools is organized around watchers. A watcher owns one category of capture
+and records typed events into the shared timeline.
+
+Built-in watchers:
+
+- `requests` records HTTP request timing and contract route activity.
+- `errors` records unhandled errors, use case failures, and devtools failures.
+- `useCases` records application command and query execution.
+- `eventBus` records domain event publishing.
+- `jobs` records background job lifecycle events.
+- `schedules` records scheduled task execution.
+- `providers` records provider setup, start, and stop activity.
+- `db` records database diagnostics from first-party providers.
+- `cache` records cache diagnostics from first-party providers.
+- `storage` records storage diagnostics from first-party providers.
+- `mail` records mail diagnostics from first-party providers.
+- `auth` records auth diagnostics from first-party providers.
+- `audit` records sanitized durable audit activity emitted by application code.
+- `rateLimit` records rate limit diagnostics from first-party providers.
+- `custom` records application and integration-specific diagnostic events.
+
+Configure watchers through the provider:
+
+```typescript
+createDevtoolsProvider({
+  watchers: {
+    requests: true,
+    useCases: true,
+    eventBus: false,
+    jobs: false,
+    schedules: true,
+    db: true,
+  },
+});
+```
+
+Disabled watchers do not store matching events. The installed watcher metadata
+is available through `ctx.ports.devtools.getWatchers()` and the dashboard API.
+
+Custom integrations can also register watcher metadata for their own event
+types. Custom watcher tabs appear in the dashboard when they own `custom`
+events:
+
+```typescript
+createDevtoolsProvider({
+  watchers: {
+    search: {
+      label: "Search",
+      description: "Search query and indexing diagnostics.",
+      eventTypes: ["custom"],
+    },
+  },
+});
+```
+
+Then record events with `watcher: "search"` so the custom watcher controls
+whether they are stored.
+
+## Use case instrumentation
+
+Bridge the application package's `onRun` hook once in your shared use case
+factory:
+
+```typescript
+import { createUseCase } from "@beignet/core/application";
+import { createDevtoolsUseCaseObserver } from "@beignet/devtools";
+
+export const useCase = createUseCase<AppContext>({
+  onRun: createDevtoolsUseCaseObserver<AppContext>(),
+});
+```
+
+The observer reads `ctx.ports.devtools`, `ctx.requestId`, and trace context
+fields by default. Use case `start`, `end`, and `error` phases share the same
+span when they run with the same request context.
+
+## Provider instrumentation
+
+First-party and app-level providers should use
+`createProviderInstrumentation()` from `@beignet/core/providers` instead of
+depending on devtools directly. The helper accepts either a ports object or an
+instrumentation port, records through `record()`, and adds provider metadata to
+custom events. `@beignet/devtools` implements that instrumentation port
+when `createDevtoolsProvider()` is registered.
+
+```typescript
+import {
+  createProvider,
+  createProviderInstrumentation,
+} from "@beignet/core/providers";
+
+export const searchProvider = createProvider({
+  name: "search",
+  setup({ ports }) {
+    const instrumentation = createProviderInstrumentation(ports, {
+      providerName: "search",
+      watcher: "custom",
+    });
+
+    return {
+      ports: {
+        search: {
+          async query(text: string) {
+            const results = await runSearch(text);
+
+            instrumentation.custom({
+              name: "search.query",
+              label: "Search query",
+              summary: `${results.length} results`,
+              details: { resultCount: results.length },
+            });
+
+            return results;
+          },
+        },
+      },
+    };
+  },
+});
+```
+
+Use a built-in watcher such as `db`, `cache`, `storage`, `mail`, `auth`,
+`audit`, `rateLimit`, or `schedules` when the provider belongs to one of those
+categories. Use `custom` or a custom watcher name for application-specific
+integrations.
+
+## Audit activity
+
+Durable audit logs should still be written through your app's `AuditLogPort`.
+Use `createDevtoolsAuditLog()` when you also want sanitized audit activity in
+the local devtools timeline:
+
+```typescript
+import { createDevtoolsAuditLog } from "@beignet/devtools";
+
+const audit = createDevtoolsAuditLog({
+  audit: durableAudit,
+  devtools: ports.devtools,
+});
+```
+
+The wrapper records the durable audit entry first, then emits a custom devtools
+event owned by the `audit` watcher. Devtools remains a local diagnostic view;
+it is not the durable audit store.
+
+When an audit port is transaction-scoped, emit the devtools mirror only after
+the transaction commits. Keeping the transaction-scoped audit port durable-only
+is preferable to showing a local audit event for work that later rolls back.
+
+## Manual events
+
+Use `record()` for application-specific events. It fills `id` and `timestamp`.
+
+```typescript
+ctx.ports.devtools.record({
+  type: "custom",
+  watcher: "search",
+  name: "search.query",
+  label: "Search query",
+  summary: "24 results in 18ms",
+  details: {
+    query,
+    resultCount: 24,
+    durationMs: 18,
+  },
+});
+```
+
+`log()` is still available when you already have a complete `DevtoolsEvent`.
+
+## Endpoints
+
+- `GET /api/devtools` serves the dashboard
+- `GET /api/devtools/core/events` returns JSON events
+- `GET /api/devtools/stream` returns a live Server-Sent Events stream
+- `POST /api/devtools/clear` clears the in-memory buffer and configured store
+
+Event list query parameters:
+
+- `type`: `request`, `error`, `usecase`, `eventBus`, `job`, `schedule`, `provider`, or `custom`
+- `requestId`: correlation ID
+- `traceId`: W3C trace ID
+- `limit`: maximum events to return, default `200`
+
+## Configuration
+
+```bash
+DEVTOOLS_ENABLED=true
+DEVTOOLS_ENABLED=false
+DEVTOOLS_MAX_EVENTS=1000
+DEVTOOLS_PERSIST=true
+DEVTOOLS_PERSIST_PATH=.beignet/devtools/core/events.jsonl
+```
+
+The default buffer keeps the latest 500 events. Persistence is opt-in and uses
+`.beignet/devtools/core/events.jsonl` by default when enabled without a custom
+path.
+
+The provider controls whether events are recorded. The HTTP route controls
+whether those events are exposed. Both default to development-only behavior.
+Route handlers return `404` when `NODE_ENV === "production"` unless explicitly
+enabled:
+
+```typescript
+export const { GET, POST } = createDevtoolsRoute(server.ports.devtools, {
+  basePath: "/api/devtools",
+  enabled: process.env.DEVTOOLS_ENABLED === "true",
+  authorize: (req: Request) =>
+    req.headers.get("x-devtools-token") === process.env.DEVTOOLS_TOKEN,
+});
+```
+
+If `authorize` returns `false`, devtools responds with `404`. If it returns a
+`Response`, that response is used, which lets applications return their own
+`403` or redirect response.
+
+## Redaction
+
+Devtools uses the shared redaction helpers from `@beignet/core/ports` before
+events are stored. Sensitive keys such as `authorization`, `cookie`,
+`set-cookie`, `x-api-key`, `token`, `password`, `secret`, and `credentials` are
+replaced with `[redacted]`.
+
+Request hooks record request headers for debugging, but do not record request or
+response bodies by default.
+
+You can add a custom redactor:
+
+```typescript
+createDevtoolsHooks({
+  redact: (event) => ({
+    ...event,
+    details: scrub(event.details),
+  }),
+});
+```
+
+The in-memory store also accepts a redactor for custom setups:
+
+```typescript
+const devtools = createInMemoryDevtools({
+  redact: (event) => event,
+});
+```
+
+## API
+
+```typescript
+interface DevtoolsPort {
+  log(event: DevtoolsEvent): void;
+  record(event: DevtoolsEventInput): DevtoolsEvent;
+  subscribe(listener: DevtoolsListener): () => void;
+  getEvents(filter?: DevtoolsFilter): DevtoolsEvent[];
+  getWatchers(): DevtoolsWatcher[];
+  isWatcherEnabled(name: DevtoolsWatcherName): boolean;
+  clear(): void | Promise<void>;
+}
+```
+
+```typescript
+function createFileDevtoolsStore(options?: {
+  filePath?: string;
+  maxEvents?: number;
+  compactEvery?: number;
+}): DevtoolsEventStore;
+```
+
+```typescript
+function createProviderInstrumentation(
+  target: ProviderInstrumentationTarget,
+  options: {
+    providerName: string;
+    watcher?: string;
+    redact?: (event: ProviderInstrumentationEventInput) => ProviderInstrumentationEventInput;
+  },
+): ProviderInstrumentation;
+```
+
+```typescript
+function createDevtoolsAuditLog(options: {
+  audit: AuditLogPort;
+  devtools?: DevtoolsPort;
+  emit?: boolean;
+  redact?: (entry: AuditLogEntry) => AuditLogEntry;
+}): AuditLogPort;
+```
+
+```typescript
+type DevtoolsEvent =
+  | RequestEvent
+  | ErrorEvent
+  | UseCaseEvent
+  | EventBusEvent
+  | JobEvent
+  | ScheduleEvent
+  | ProviderEvent
+  | CustomDevtoolsEvent;
+```
+
+All events include `id`, `timestamp`, optional `requestId`, optional `watcher`,
+optional `traceId`, optional `spanId`, optional `parentSpanId`, optional
+`traceparent`, and optional redacted `details`.
+
+`createDevtoolsHooks()` accepts:
+
+```typescript
+type DevtoolsHooksOptions<Ctx> = {
+  basePath?: string;
+  requestIdHeader?: string | false;
+  traceContextHeader?: string | false;
+  getRequestId?: (args: {
+    req: HttpRequestLike;
+    ctx?: Ctx;
+    response?: HttpResponseLike;
+  }) => string | undefined;
+  getTraceContext?: (args: {
+    req: HttpRequestLike;
+    ctx?: Ctx;
+    response?: HttpResponseLike;
+  }) => DevtoolsTraceContextInput | string | undefined;
+  redact?: DevtoolsRedactor;
+};
+```
+
+`createDevtoolsRoute()` and `handleDevtoolsRequest()` accept:
+
+```typescript
+type DevtoolsRequestOptions = {
+  basePath: string;
+  enabled?: boolean;
+  authorize?: (
+    req: Request,
+  ) => boolean | Response | Promise<boolean | Response>;
+};
+```
+
+## Production safety
+
+The HTTP handlers return `404` when `NODE_ENV === "production"` by default. The
+provider also installs a no-op devtools port in production by default so app
+code does not need null checks.
+
+Devtools can contain sensitive request, error, and domain data. Keep it on local
+development routes unless you intentionally add authentication and redaction.
+
+## License
+
+MIT

package/dist/access.d.ts

@@ -0,0 +1,21 @@
+export type DevtoolsAuthorizeResult = boolean | Response;
+export type DevtoolsAuthorize = (req: Request) => DevtoolsAuthorizeResult | Promise<DevtoolsAuthorizeResult>;
+export interface DevtoolsRouteAccessOptions {
+    /**
+     * Whether the devtools route should be exposed.
+     *
+     * @default process.env.NODE_ENV !== "production"
+     */
+    enabled?: boolean;
+    /**
+     * Optional app-owned authorization check for exposed devtools routes.
+     *
+     * Returning `false` hides devtools with a 404. Returning a `Response` lets
+     * the app provide a custom denial response.
+     */
+    authorize?: DevtoolsAuthorize;
+}
+export declare function isDevtoolsRouteEnabled(options?: DevtoolsRouteAccessOptions): boolean;
+export declare function devtoolsNotFoundResponse(): Response;
+export declare function authorizeDevtoolsRequest(req: Request, options?: DevtoolsRouteAccessOptions): Promise<Response | undefined>;
+//# sourceMappingURL=access.d.ts.map

package/dist/access.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"access.d.ts","sourceRoot":"","sources":["../src/access.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,uBAAuB,GAAG,OAAO,GAAG,QAAQ,CAAC;AAEzD,MAAM,MAAM,iBAAiB,GAAG,CAC9B,GAAG,EAAE,OAAO,KACT,uBAAuB,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAAC;AAEhE,MAAM,WAAW,0BAA0B;IACzC;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB;;;;;OAKG;IACH,SAAS,CAAC,EAAE,iBAAiB,CAAC;CAC/B;AAED,wBAAgB,sBAAsB,CACpC,OAAO,GAAE,0BAA+B,GACvC,OAAO,CAET;AAED,wBAAgB,wBAAwB,IAAI,QAAQ,CAEnD;AAED,wBAAsB,wBAAwB,CAC5C,GAAG,EAAE,OAAO,EACZ,OAAO,GAAE,0BAA+B,GACvC,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC,CAe/B"}

package/dist/access.js

@@ -0,0 +1,20 @@
+export function isDevtoolsRouteEnabled(options = {}) {
+    return options.enabled ?? process.env.NODE_ENV !== "production";
+}
+export function devtoolsNotFoundResponse() {
+    return new Response("Not Found", { status: 404 });
+}
+export async function authorizeDevtoolsRequest(req, options = {}) {
+    if (!isDevtoolsRouteEnabled(options)) {
+        return devtoolsNotFoundResponse();
+    }
+    if (!options.authorize) {
+        return undefined;
+    }
+    const result = await options.authorize(req);
+    if (result instanceof Response) {
+        return result;
+    }
+    return result ? undefined : devtoolsNotFoundResponse();
+}
+//# sourceMappingURL=access.js.map

package/dist/access.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"access.js","sourceRoot":"","sources":["../src/access.ts"],"names":[],"mappings":"AAuBA,MAAM,UAAU,sBAAsB,CACpC,UAAsC,EAAE;IAExC,OAAO,OAAO,CAAC,OAAO,IAAI,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,YAAY,CAAC;AAClE,CAAC;AAED,MAAM,UAAU,wBAAwB;IACtC,OAAO,IAAI,QAAQ,CAAC,WAAW,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC;AACpD,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,wBAAwB,CAC5C,GAAY,EACZ,UAAsC,EAAE;IAExC,IAAI,CAAC,sBAAsB,CAAC,OAAO,CAAC,EAAE,CAAC;QACrC,OAAO,wBAAwB,EAAE,CAAC;IACpC,CAAC;IAED,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,CAAC;QACvB,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;IAC5C,IAAI,MAAM,YAAY,QAAQ,EAAE,CAAC;QAC/B,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,OAAO,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,wBAAwB,EAAE,CAAC;AACzD,CAAC"}

package/dist/audit.d.ts

@@ -0,0 +1,10 @@
+import { type AuditLogEntry, type AuditLogPort } from "@beignet/core/ports";
+import type { DevtoolsPort } from "./index";
+export interface DevtoolsAuditLogOptions {
+    audit: AuditLogPort;
+    devtools?: DevtoolsPort;
+    emit?: boolean;
+    redact?: (entry: AuditLogEntry) => AuditLogEntry;
+}
+export declare function createDevtoolsAuditLog(options: DevtoolsAuditLogOptions): AuditLogPort;
+//# sourceMappingURL=audit.d.ts.map

package/dist/audit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit.d.ts","sourceRoot":"","sources":["../src/audit.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,aAAa,EAElB,KAAK,YAAY,EAGlB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE5C,MAAM,WAAW,uBAAuB;IACtC,KAAK,EAAE,YAAY,CAAC;IACpB,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,aAAa,CAAC;CAClD;AAoBD,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,uBAAuB,GAC/B,YAAY,CAkCd"}

package/dist/audit.js

@@ -0,0 +1,49 @@
+import { normalizeAuditLogEntry, redactAuditLogEntry, } from "@beignet/core/ports";
+function prepareEntry(input, redact) {
+    const redacted = redactAuditLogEntry(normalizeAuditLogEntry(input));
+    return redact ? redact(redacted) : redacted;
+}
+function auditSummary(entry) {
+    const resource = entry.resource?.id
+        ? `${entry.resource.type}:${entry.resource.id}`
+        : entry.resource?.type;
+    const outcome = entry.outcome === "failure" ? "failed" : "succeeded";
+    return resource
+        ? `${entry.action} ${outcome} for ${resource}`
+        : `${entry.action} ${outcome}`;
+}
+export function createDevtoolsAuditLog(options) {
+    return {
+        async record(input) {
+            const entry = prepareEntry(input, options.redact);
+            await options.audit.record(entry);
+            if (options.emit === false || !options.devtools)
+                return;
+            try {
+                options.devtools.record({
+                    type: "custom",
+                    watcher: "audit",
+                    name: entry.action,
+                    label: "Audit",
+                    summary: auditSummary(entry),
+                    requestId: entry.requestId,
+                    traceId: entry.traceId,
+                    details: {
+                        action: entry.action,
+                        actor: entry.actor,
+                        tenant: entry.tenant,
+                        resource: entry.resource,
+                        outcome: entry.outcome,
+                        message: entry.message,
+                        metadata: entry.metadata,
+                        occurredAt: entry.occurredAt.toISOString(),
+                    },
+                });
+            }
+            catch {
+                // Devtools is an observer; durable audit writes must not depend on it.
+            }
+        },
+    };
+}
+//# sourceMappingURL=audit.js.map

package/dist/audit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit.js","sourceRoot":"","sources":["../src/audit.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,sBAAsB,EACtB,mBAAmB,GACpB,MAAM,qBAAqB,CAAC;AAU7B,SAAS,YAAY,CACnB,KAAyB,EACzB,MAAgD;IAEhD,MAAM,QAAQ,GAAG,mBAAmB,CAAC,sBAAsB,CAAC,KAAK,CAAC,CAAC,CAAC;IACpE,OAAO,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;AAC9C,CAAC;AAED,SAAS,YAAY,CAAC,KAAoB;IACxC,MAAM,QAAQ,GAAG,KAAK,CAAC,QAAQ,EAAE,EAAE;QACjC,CAAC,CAAC,GAAG,KAAK,CAAC,QAAQ,CAAC,IAAI,IAAI,KAAK,CAAC,QAAQ,CAAC,EAAE,EAAE;QAC/C,CAAC,CAAC,KAAK,CAAC,QAAQ,EAAE,IAAI,CAAC;IACzB,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,WAAW,CAAC;IACrE,OAAO,QAAQ;QACb,CAAC,CAAC,GAAG,KAAK,CAAC,MAAM,IAAI,OAAO,QAAQ,QAAQ,EAAE;QAC9C,CAAC,CAAC,GAAG,KAAK,CAAC,MAAM,IAAI,OAAO,EAAE,CAAC;AACnC,CAAC;AAED,MAAM,UAAU,sBAAsB,CACpC,OAAgC;IAEhC,OAAO;QACL,KAAK,CAAC,MAAM,CAAC,KAAK;YAChB,MAAM,KAAK,GAAG,YAAY,CAAC,KAAK,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;YAElD,MAAM,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;YAElC,IAAI,OAAO,CAAC,IAAI,KAAK,KAAK,IAAI,CAAC,OAAO,CAAC,QAAQ;gBAAE,OAAO;YAExD,IAAI,CAAC;gBACH,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC;oBACtB,IAAI,EAAE,QAAQ;oBACd,OAAO,EAAE,OAAO;oBAChB,IAAI,EAAE,KAAK,CAAC,MAAM;oBAClB,KAAK,EAAE,OAAO;oBACd,OAAO,EAAE,YAAY,CAAC,KAAK,CAAC;oBAC5B,SAAS,EAAE,KAAK,CAAC,SAAS;oBAC1B,OAAO,EAAE,KAAK,CAAC,OAAO;oBACtB,OAAO,EAAE;wBACP,MAAM,EAAE,KAAK,CAAC,MAAM;wBACpB,KAAK,EAAE,KAAK,CAAC,KAAK;wBAClB,MAAM,EAAE,KAAK,CAAC,MAAM;wBACpB,QAAQ,EAAE,KAAK,CAAC,QAAQ;wBACxB,OAAO,EAAE,KAAK,CAAC,OAAO;wBACtB,OAAO,EAAE,KAAK,CAAC,OAAO;wBACtB,QAAQ,EAAE,KAAK,CAAC,QAAQ;wBACxB,UAAU,EAAE,KAAK,CAAC,UAAU,CAAC,WAAW,EAAE;qBAC3C;iBACF,CAAC,CAAC;YACL,CAAC;YAAC,MAAM,CAAC;gBACP,uEAAuE;YACzE,CAAC;QACH,CAAC;KACF,CAAC;AACJ,CAAC"}