@belonguniverseai/react-sdk 0.6.21 → 0.6.22

package/dist/api/goals.d.ts

@@ -0,0 +1,179 @@
+import { z } from 'zod';
+export declare const goalStatusSchema: z.ZodEnum<{
+    active: "active";
+    paused: "paused";
+    clarifying: "clarifying";
+    completion_claimed: "completion_claimed";
+    deferred: "deferred";
+    waiting_for_user: "waiting_for_user";
+    waiting_for_approval: "waiting_for_approval";
+    waiting_for_ui_action: "waiting_for_ui_action";
+    blocked: "blocked";
+    budget_limited: "budget_limited";
+    complete: "complete";
+    cleared: "cleared";
+}>;
+export type GoalStatus = z.infer<typeof goalStatusSchema>;
+/**
+ * One line of the panel's History (M6). `kind` and `actor` are OPEN strings,
+ * not enums, for the same reason `statusPartSchema.retryable` is optional in
+ * the transport: a value this dock predates must never make `safeParse` drop
+ * the whole goal view — the line falls back to a neutral label instead.
+ */
+export declare const goalJournalEntrySchema: z.ZodObject<{
+    seq: z.ZodNumber;
+    kind: z.ZodString;
+    actor: z.ZodString;
+    toStatus: z.ZodNullable<z.ZodEnum<{
+        active: "active";
+        paused: "paused";
+        clarifying: "clarifying";
+        completion_claimed: "completion_claimed";
+        deferred: "deferred";
+        waiting_for_user: "waiting_for_user";
+        waiting_for_approval: "waiting_for_approval";
+        waiting_for_ui_action: "waiting_for_ui_action";
+        blocked: "blocked";
+        budget_limited: "budget_limited";
+        complete: "complete";
+        cleared: "cleared";
+    }>>;
+    note: z.ZodNullable<z.ZodString>;
+    at: z.ZodString;
+}, z.core.$strip>;
+export type GoalJournalEntry = z.infer<typeof goalJournalEntrySchema>;
+export declare const goalViewSchema: z.ZodObject<{
+    goalId: z.ZodString;
+    status: z.ZodEnum<{
+        active: "active";
+        paused: "paused";
+        clarifying: "clarifying";
+        completion_claimed: "completion_claimed";
+        deferred: "deferred";
+        waiting_for_user: "waiting_for_user";
+        waiting_for_approval: "waiting_for_approval";
+        waiting_for_ui_action: "waiting_for_ui_action";
+        blocked: "blocked";
+        budget_limited: "budget_limited";
+        complete: "complete";
+        cleared: "cleared";
+    }>;
+    statusReason: z.ZodNullable<z.ZodString>;
+    objective: z.ZodString;
+    successCriteria: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+        status: z.ZodEnum<{
+            open: "open";
+            met: "met";
+        }>;
+        evidence: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+    constraints: z.ZodArray<z.ZodString>;
+    tokensUsed: z.ZodNumber;
+    tokenBudget: z.ZodNumber;
+    turnsUsed: z.ZodNumber;
+    maxTurns: z.ZodNumber;
+    activeSeconds: z.ZodNumber;
+    maxActiveSeconds: z.ZodNumber;
+    lastProgressNote: z.ZodNullable<z.ZodString>;
+    updatedAt: z.ZodString;
+    startedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    originatingClientMessageId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    clarifyMaxQuestions: z.ZodOptional<z.ZodNumber>;
+    judgeFeedback: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    judgeRejections: z.ZodOptional<z.ZodNumber>;
+    clarifyingTurns: z.ZodOptional<z.ZodNumber>;
+    resumeAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    journal: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        seq: z.ZodNumber;
+        kind: z.ZodString;
+        actor: z.ZodString;
+        toStatus: z.ZodNullable<z.ZodEnum<{
+            active: "active";
+            paused: "paused";
+            clarifying: "clarifying";
+            completion_claimed: "completion_claimed";
+            deferred: "deferred";
+            waiting_for_user: "waiting_for_user";
+            waiting_for_approval: "waiting_for_approval";
+            waiting_for_ui_action: "waiting_for_ui_action";
+            blocked: "blocked";
+            budget_limited: "budget_limited";
+            complete: "complete";
+            cleared: "cleared";
+        }>>;
+        note: z.ZodNullable<z.ZodString>;
+        at: z.ZodString;
+    }, z.core.$strip>>>;
+    runway: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        quick: "quick";
+        normal: "normal";
+        long: "long";
+    }>>>;
+}, z.core.$strip>;
+export type GoalView = z.infer<typeof goalViewSchema>;
+type FetchGoalOutcome = {
+    readonly status: "goal";
+    readonly goal: GoalView;
+} | {
+    readonly status: "none" | "disabled" | "error";
+};
+export type GoalActionOutcome = {
+    readonly status: "ok";
+    readonly goalStatus: GoalStatus;
+    readonly revived?: boolean;
+} | {
+    readonly status: "conflict";
+    readonly goalStatus: GoalStatus;
+} | {
+    readonly status: "not_found" | "disabled" | "error";
+};
+/**
+ * `GET /v1/sessions/:id/goal`. 404 (`goal_not_found`) means the session has
+ * no goal at all — a normal, common state, not an error — so it collapses to
+ * `{ status: "none" }` rather than `"error"`. 503 (`goals_disabled`) is the
+ * tenant-level feature flag being off.
+ */
+export declare const fetchSessionGoal: (apiBaseUrl: string, sessionId: string) => Promise<FetchGoalOutcome>;
+export declare const pauseSessionGoal: (apiBaseUrl: string, sessionId: string) => Promise<GoalActionOutcome>;
+export declare const resumeSessionGoal: (apiBaseUrl: string, sessionId: string) => Promise<GoalActionOutcome>;
+export declare const clearSessionGoal: (apiBaseUrl: string, sessionId: string) => Promise<GoalActionOutcome>;
+/**
+ * `POST /v1/sessions/:id/goal/snooze` — the footer's Snooze ▾ menu. Same
+ * 202/404/409/503 mapping as {@link goalAction} (this reuses its 202/409 body
+ * parsing exactly — the 202 shape is the same `{ status }`), except the 409
+ * conflict here is `goal_not_snoozable` (a goal that is not currently one of
+ * the four snoozable statuses — e.g. already `deferred`), which the footer
+ * shows through the same generic `failedSnooze` line rather than a
+ * status-specific one (unlike pause/resume/clear): there is exactly one
+ * snooze failure message, so every non-`ok` outcome — conflict, not found,
+ * disabled, or a plain network/parse error — reads the same way to the user.
+ */
+export declare const snoozeSessionGoal: (apiBaseUrl: string, sessionId: string, wakeAt: Date) => Promise<GoalActionOutcome>;
+/** `POST /v1/sessions/:id/goal/edit` request body — every field optional,
+ *  but the backend rejects a body with none of them set (`goal_edit_no_change`
+ *  only fires when the values match the *current* row; an empty body fails
+ *  Zod validation on the backend before it ever reaches that check). */
+export type GoalEditInput = {
+    readonly objective?: string;
+    readonly tokenBudget?: number;
+    readonly maxTurns?: number;
+};
+/**
+ * `POST /v1/sessions/:id/goal/edit`. Unlike {@link goalAction} this rides a
+ * JSON body (§4 — Content-Type required so the backend's `zValidator("json")`
+ * actually parses it instead of silently treating a missing/wrong
+ * Content-Type as `{}`). The 202 body carries `revived` — the edit raised a
+ * cap past `turns_used`/`tokens_used` and un-stalled a `budget_limited` goal
+ * — which `runGoalCommand` (chat.tsx) uses to pick between `goal.edited` and
+ * `goal.revived`. Both 409 variants the backend can return
+ * (`goal_not_editable`: the goal's current state can never be edited;
+ * `goal_edit_conflict`: a concurrent edit raced this one) collapse to the
+ * same `"conflict"` outcome — the dock has one notice for "try again",
+ * `goal.notEditable`, regardless of which race produced it.
+ */
+export declare const editSessionGoal: (apiBaseUrl: string, sessionId: string, input: GoalEditInput) => Promise<GoalActionOutcome | {
+    readonly status: "no_change";
+}>;
+export {};

package/dist/api/issue-reports.d.ts

@@ -0,0 +1,13 @@
+import { IssueReportRequest } from '../embed/issue-report-bus.ts';
+export type SubmitIssueReportResult = {
+    readonly ok: true;
+    readonly reportId: string;
+} | {
+    readonly ok: false;
+    readonly reason: "too_large" | "unsupported_media" | "request_failed";
+};
+export declare const submitIssueReport: (apiBaseUrl: string, input: {
+    readonly request: IssueReportRequest;
+    readonly message: string;
+    readonly includeScreenshot: boolean;
+}) => Promise<SubmitIssueReportResult>;

package/dist/api/query-keys.d.ts

@@ -15,7 +15,14 @@ export declare const queryKeys: {
      * `workspaceKey` is the scoped id, or "" when unconfigured.
      */
     sessionList: (workspaceKey: string, limit: number) => readonly ["belong", "sessions", "list", string, number];
+    /** Invalidation prefix for every skills-inventory read. */
     skills: readonly ["belong", "skills"];
+    /**
+     * Workspace-scoped `/` inventory (skill-library D1): library skills differ per
+     * workspace. Keeps `skills` as its prefix so existing invalidations still hit it.
+     * `workspaceKey` is the scoped id, or "" when unscoped.
+     */
+    skillsScoped: (workspaceKey: string) => readonly ["belong", "skills", string];
     workspaceFiles: readonly ["belong", "workspace-files"];
     /** Workspace-scoped Files tab / @-mention picker cache (same "" convention). */
     workspaceFilesScoped: (workspaceKey: string) => readonly ["belong", "workspace-files", string];
@@ -29,6 +36,17 @@ export declare const queryKeys: {
     prePrompts: readonly ["belong", "pre-prompts"];
     /** Workspace-scoped saved-prompt list (same "" unscoped convention). */
     prePromptList: (workspaceKey: string) => readonly ["belong", "pre-prompts", "list", string];
+    /** Invalidation prefix for every skill-library read (skill library spec §11.2). */
+    skillLibrary: readonly ["belong", "skill-library"];
+    /** Workspace-scoped library list ("" unscoped, "__missing__" never fetched). */
+    skillLibraryList: (workspaceKey: string) => readonly ["belong", "skill-library", "list", string];
+    /**
+     * UNSCOPED deployment probe: written by every list resolution, read by the
+     * rail. Whether the feature exists is a property of the CELL, not of a
+     * workspace — keying it per workspace would pop a dead rail entry back in on
+     * every host workspace switch (R61).
+     */
+    skillLibraryAvailability: readonly ["belong", "skill-library", "availability"];
     /**
      * Invalidation prefix for every custom-connector read. NOT workspace-scoped:
      * `/v1/connectors` keys off the CALLER, not a workspace — a user's connected

package/dist/api/report-client-error.d.ts

@@ -6,6 +6,9 @@
  * `POST /v1/telemetry/client` (telemetry.routes.ts) so they surface in
  * Loki/Tempo keyed by the SAME `session.id` the user copies from the dock.
  *
+ * Also feeds them into the local client-error buffer (client-error-log.ts) so
+ * an issue report can carry the tail of what already went wrong in this tab.
+ *
  * Best-effort and unobtrusive by construction:
  *  - never throws into the caller's failure path (the report rides ON a failure);
  *  - uses `navigator.sendBeacon` with a `text/plain` body so it survives a page

package/dist/api/retry-fetch.d.ts

@@ -26,6 +26,25 @@
  *
  * Time and randomness are injectable (CLAUDE.md §25/§26); production callers
  * use the exported `retryingFetch` singleton.
+ *
+ * A 429 and a 503 get one more distinction on top of the policy above
+ * (task-9 fix round 1, review finding 2; team review S-I4): an application
+ * refusal — a goal-cap 429 (`goal_cap_user` / `goal_cap_tenant`) or the
+ * `goals_disabled` 503 the feature flag answers with (`session.routes.ts`,
+ * `goal.routes.ts`) — is a business-rule decision, not an ingress
+ * scale-out reject. Every retry replays to the exact same answer, just ~9s
+ * slower, and the user watches the composer hang before the dock can show
+ * copy it already has. The infrastructure rejects those two statuses carry
+ * NO body at all (Cloud Run's ingress 429; a cold-start or rolling-deploy
+ * 503), so the two are distinguishable by content: a 429 or 503 whose body
+ * parses as JSON with a string `error.type` is treated as terminal and
+ * returned to the caller immediately; anything else (empty body, non-JSON,
+ * JSON that doesn't match) keeps the existing transient-retry behavior.
+ *
+ * 408/502/504 stay out of it deliberately: no route on this backend answers
+ * a typed refusal with one, so a typed body on those could only come from
+ * something between us and the app — and believing it would end a ladder
+ * that exists precisely for that layer.
  */
 export declare const TRANSIENT_STATUSES: ReadonlySet<number>;
 /** Total attempts including the first. 5 attempts ≈ 8–12s of cumulative

package/dist/api/skill-library.d.ts

@@ -0,0 +1,100 @@
+import { QueryClient, UseQueryResult } from '@tanstack/react-query';
+import { ApiClient } from './client.ts';
+export type SkillLibraryItem = {
+    readonly userSkillId: string;
+    readonly name: string;
+    readonly description: string;
+    readonly enabled: boolean;
+    readonly revision: number;
+    readonly hasScripts: boolean;
+    readonly filesCount: number;
+    readonly archiveSizeBytes: number;
+    readonly updatedAt: string;
+};
+export type SkillLibraryListResult = {
+    readonly status: "ready";
+    readonly skills: readonly SkillLibraryItem[];
+} | {
+    readonly status: "featureAbsent";
+};
+export type SkillLibraryAvailability = "available" | "absent";
+export type SkillNameReservedBy = "company_skill" | "dock_command" | "platform_skill" | "saved_prompt";
+export type ImportSkillInput = {
+    readonly file: File;
+    /** crypto.randomUUID(), minted when the upload dialog opens and again on every accepted file pick (a retry of the same pick reuses it). */
+    readonly clientSaveId: string;
+    readonly onNameConflict: "reject" | "replace";
+};
+export type ImportSkillOutcome = {
+    readonly status: "saved";
+    readonly outcome: "created" | "replaced" | "unchanged" | "idempotent";
+    readonly userSkillId: string;
+    readonly name: string;
+    readonly revision: number;
+    readonly hasScripts: boolean;
+} | {
+    readonly status: "name_taken";
+    readonly name: string;
+    readonly userSkillId: string;
+} | {
+    readonly status: "name_reserved";
+    readonly name: string;
+    readonly reservedBy: SkillNameReservedBy;
+} | {
+    readonly status: "content_reserved";
+} | {
+    readonly status: "invalid_skill_archive";
+    readonly reason: string;
+} | {
+    readonly status: "archive_too_large";
+    readonly maxArchiveBytes: number;
+} | {
+    readonly status: "limit_reached";
+    readonly maxCount: number;
+} | {
+    readonly status: "feature_absent";
+} | {
+    readonly status: "error";
+};
+export type SetSkillEnabledOutcome = {
+    readonly status: "updated";
+    readonly userSkillId: string;
+    readonly enabled: boolean;
+} | {
+    readonly status: "not_found";
+} | {
+    readonly status: "error";
+};
+export type DeleteSkillOutcome = {
+    readonly status: "deleted";
+} | {
+    readonly status: "not_found";
+} | {
+    readonly status: "error";
+};
+export declare const listSkillLibraryRequest: (api: ApiClient, query: {
+    readonly workspaceExternalId?: string;
+}, signal?: AbortSignal) => Promise<SkillLibraryListResult>;
+export declare const useSkillLibrary: () => UseQueryResult<SkillLibraryListResult>;
+/**
+ * Does this deployment have the skill library? FALSE until some list call has
+ * RESOLVED `featureAbsent` — while loading, on an outage, or in a missing scope
+ * before any probe resolved, the rail keeps its entry (a late pop-in reads as a
+ * glitch; an outage must not look like a feature that was never there).
+ */
+export declare const useSkillLibraryFeatureAbsent: () => boolean;
+/** Invalidates BOTH the library and the skills inventory. */
+export declare const invalidateSkillCaches: (queryClient: QueryClient) => Promise<void>;
+/**
+ * Raw `fetch` + FormData, because Hono RPC has no multipart path in the SDK
+ * (the `routes/documents.tsx` precedent). Not retried transparently; the
+ * per-pick `clientSaveId` (minted on open and on every accepted file pick)
+ * makes a manual retry of the same pick idempotent.
+ */
+export declare const useImportSkill: () => import('@tanstack/react-query').UseMutationResult<ImportSkillOutcome, Error, ImportSkillInput, unknown>;
+export declare const useSetSkillEnabled: () => import('@tanstack/react-query').UseMutationResult<SetSkillEnabledOutcome, Error, {
+    readonly userSkillId: string;
+    readonly enabled: boolean;
+}, unknown>;
+export declare const useDeleteSkill: () => import('@tanstack/react-query').UseMutationResult<DeleteSkillOutcome, Error, string, unknown>;
+export declare const skillLibraryDownloadUrl: (baseUrl: string, userSkillId: string) => string;

package/dist/api/skills.d.ts

@@ -29,5 +29,7 @@ export type SlashInventory = {
     readonly skills: readonly SkillSummary[];
     readonly commands: readonly CommandSummary[];
 };
-export declare const listSkillsRequest: (api: ApiClient) => Promise<SlashInventory>;
+export declare const listSkillsRequest: (api: ApiClient, query?: {
+    readonly workspaceExternalId?: string;
+}) => Promise<SlashInventory>;
 export declare const useSkills: () => import('@tanstack/react-query').UseQueryResult<NoInfer<SlashInventory>, Error>;

package/dist/app/dock-outlet.d.ts

@@ -1,8 +1,4 @@
-/**
- * Typed router-Outlet context for the dock's routed views (documents /
- * files / sessions / scheduled). BelongDock provides it; a routed view
- * reads it with `useDockOutlet()`.
- */
+import { GoalActionOutcome } from '../api/goals.ts';
 export type DockOutletContext = {
     /**
      * Open an existing chat session: re-points the stream store, remounts the
@@ -14,5 +10,19 @@ export type DockOutletContext = {
         readonly reconcileBackgroundRun?: boolean;
         readonly runId?: string;
     }) => void;
+    /**
+     * Run a goal lifecycle action on the ON-SCREEN session's goal and hand back
+     * the server's own outcome (§19 — a refusal is a value, not a throw). The
+     * dock owns this so the POST and the re-read that follows it are ONE path:
+     * every goal surface then shows the same server truth, and no surface can
+     * flip a status locally ahead of it (§12, §41).
+     */
+    readonly goalAction: (action: "pause" | "resume" | "clear") => Promise<GoalActionOutcome>;
+    /**
+     * Task 19 — same POST-then-RE-READ path as {@link goalAction}, for the
+     * footer's Snooze ▾ menu. A separate function (not a fourth `goalAction`
+     * case) because snooze carries a `wakeAt` argument the other three don't.
+     */
+    readonly goalSnooze: (wakeAt: Date) => Promise<GoalActionOutcome>;
 };
 export declare const useDockOutlet: () => DockOutletContext;

package/dist/browser/allowed-ops.d.ts

@@ -0,0 +1,18 @@
+import { BrowserCommand, BrowserCommandResult } from '../../../../apps/belong-cloud/src/features/browser-control/browser-control.schemas.ts';
+/** Every relay op the dock can run (the wire union). */
+export type BrowserOpName = BrowserCommand["op"];
+/**
+ * Seed the restriction from `init({ browserControl })`. Omitted = every op.
+ * Anything else the host passed was meant to RESTRICT the page, so an invalid
+ * value allows NOTHING (fail closed) and says why in the console — never throws
+ * at the host boundary.
+ */
+export declare const configureBrowserControl: (config: unknown) => void;
+/**
+ * The refusal for an op this page does not run, or null when it may run.
+ * Non-retryable by nature — the host's setting will not change mid-run — and
+ * the message says so, so the agent picks another tool instead of retrying.
+ */
+export declare const refuseUnlessAllowed: (op: BrowserOpName) => BrowserCommandResult | null;
+/** Test-only: back to "the host set no restriction". */
+export declare const __resetBrowserControlForTest: () => void;

package/dist/browser/host-mcp.d.ts

@@ -0,0 +1,31 @@
+import { BrowserCommand, BrowserCommandResult, MCP_CALL_BODY_MAX_CHARS } from '../../../../apps/belong-cloud/src/features/browser-control/browser-control.schemas.ts';
+type McpCallCommand = Extract<BrowserCommand, {
+    op: "mcp_call";
+}>;
+/**
+ * Ceiling on the raw body relayed back for one call — the cloud's
+ * `MCP_CALL_BODY_MAX_CHARS`. The SDK build resolves `@cloud/*` for TYPES only
+ * (there is no runtime alias), so the value is restated here and pinned to the
+ * cloud's literal through its type: changing the cloud ceiling fails this
+ * package's typecheck until the two agree again.
+ */
+export declare const HOST_MCP_BODY_MAX_CHARS: typeof MCP_CALL_BODY_MAX_CHARS;
+/**
+ * Seed the allowlist from `init({ hostMcp })`. Omitted = no host MCP at all.
+ * An invalid config allows NOTHING (fail closed) and says why in the console —
+ * never throws at the host boundary.
+ */
+export declare const configureHostMcp: (config: unknown) => void;
+/**
+ * Run one host-bridged `mcp_call`. Never throws: an unlisted path is
+ * `mcp_not_allowed`, a fetch that produced no HTTP answer is
+ * `mcp_fetch_failed`, and ANY HTTP answer — a 401, a 5xx, a refused redirect —
+ * is relayed raw in `value.http` for the cloud to interpret.
+ */
+export declare const runMcpCall: (cmd: McpCallCommand, deps?: {
+    readonly fetchFn?: typeof fetch;
+    readonly newId?: () => string;
+}) => Promise<BrowserCommandResult>;
+/** Test-only: back to "the host opted into nothing". */
+export declare const __resetHostMcpForTest: () => void;
+export {};

package/dist/component/{abnfDiagram-N423BO3Z-DZRUOUZQ.js → abnfDiagram-N423BO3Z-D4mVRMw9.js}

@@ -1,6 +1,6 @@
-import { g as p, r as u, d as n } from "./chunk-6Q2QTUOP-DHcoXRhe.js";
-import { p as f } from "./chunk-JWPE2WC7-ClHq4gN2.js";
-import { _ as a, l as o } from "./mermaid-GHXKKRXX-DfdCmrs3.js";
+import { g as p, r as u, d as n } from "./chunk-6Q2QTUOP-D6ec2nI7.js";
+import { p as f } from "./chunk-JWPE2WC7-CmGlHqne.js";
+import { _ as a, l as o } from "./mermaid-GHXKKRXX-aX5umm-y.js";
 import { M as c, b as g } from "./cynefin-VYW2F7L2-DAyxamLw.js";
 globalThis.process = globalThis.process || { env: {} };
 globalThis.global = globalThis.global || globalThis;
@@ -87,4 +87,4 @@ var b = g().RailroadAbnf.parser.LangiumParser, l = /* @__PURE__ */ a((e) => {
 export {
   T as diagram
 };
-//# sourceMappingURL=abnfDiagram-N423BO3Z-DZRUOUZQ.js.map
+//# sourceMappingURL=abnfDiagram-N423BO3Z-D4mVRMw9.js.map

package/dist/component/{arc-B4biduil.js → arc-GBp6w3tF.js}

@@ -1,4 +1,4 @@
-import { H as ln, I as an, J as g, K as on, M as Q, N as w, O as _, P as sn, Q as rn, S as X, T as t, V as J, W as un, X as tn, Y as fn } from "./mermaid-GHXKKRXX-DfdCmrs3.js";
+import { H as ln, I as an, J as g, K as on, M as Q, N as w, O as _, P as sn, Q as rn, S as X, T as t, V as J, W as un, X as tn, Y as fn } from "./mermaid-GHXKKRXX-aX5umm-y.js";
 globalThis.process = globalThis.process || { env: {} };
 globalThis.global = globalThis.global || globalThis;
 function cn(l) {
@@ -83,4 +83,4 @@ function xn() {
 export {
   xn as d
 };
-//# sourceMappingURL=arc-B4biduil.js.map
+//# sourceMappingURL=arc-GBp6w3tF.js.map

package/dist/component/{architectureDiagram-T3A2C74G-q8voStNN.js → architectureDiagram-T3A2C74G-Cxm-USYQ.js}

@@ -1,5 +1,5 @@
-import { p as ke } from "./chunk-JWPE2WC7-ClHq4gN2.js";
-import { ba as qe, _ as ct, G as Qe, ag as Je, l as Se, b as Ke, a as je, o as _e, p as tr, g as er, s as rr, q as ir, D as ar, z as nr, E as or, c as me, b2 as Ee, al as ve, i as sr, d as hr, r as lr, am as fr, bb as cr } from "./mermaid-GHXKKRXX-DfdCmrs3.js";
+import { p as ke } from "./chunk-JWPE2WC7-CmGlHqne.js";
+import { ba as qe, _ as ct, G as Qe, ag as Je, l as Se, b as Ke, a as je, o as _e, p as tr, g as er, s as rr, q as ir, D as ar, z as nr, E as or, c as me, b2 as Ee, al as ve, i as sr, d as hr, r as lr, am as fr, bb as cr } from "./mermaid-GHXKKRXX-aX5umm-y.js";
 import { p as gr } from "./cynefin-VYW2F7L2-DAyxamLw.js";
 import { c as Fe } from "./cytoscape.esm-C31R6JOv.js";
 globalThis.process = globalThis.process || { env: {} };
@@ -4781,4 +4781,4 @@ var Ur = /* @__PURE__ */ ct(async (w, F, M, P) => {
 export {
   zr as diagram
 };
-//# sourceMappingURL=architectureDiagram-T3A2C74G-q8voStNN.js.map
+//# sourceMappingURL=architectureDiagram-T3A2C74G-Cxm-USYQ.js.map

package/dist/component/{blockDiagram-VBNYF7ZC-C0TDyTgw.js → blockDiagram-VBNYF7ZC-BAiLpxJf.js}

@@ -1,7 +1,7 @@
-import { g as de } from "./chunk-5VM5RSS4-BweQRk7u.js";
-import { aD as pe, aE as Kt, aF as fe, aG as xe, aH as ye, aI as be, aJ as we, aK as me, aL as Se, aM as Le, aN as ke, aO as ve, aP as Ee, aQ as _e, aR as Te, aS as De, aT as Be, aU as Ne, aV as Ie, aW as Ce, aX as Oe, aY as Re, aZ as Ae, a_ as ze, a$ as Me, _ as g, z as rt, d as D, e as Pe, l as k, q as Fe, t as We, c as R, b0 as Ye, aa as He, ab as Ke, a6 as Ue, b1 as M, b2 as kt, b3 as Q, av as Xe, y as $, k as Ve, b4 as je, i as Ct, b5 as Ot, b6 as Ge } from "./mermaid-GHXKKRXX-DfdCmrs3.js";
+import { g as de } from "./chunk-5VM5RSS4-BG8q5ODa.js";
+import { aD as pe, aE as Kt, aF as fe, aG as xe, aH as ye, aI as be, aJ as we, aK as me, aL as Se, aM as Le, aN as ke, aO as ve, aP as Ee, aQ as _e, aR as Te, aS as De, aT as Be, aU as Ne, aV as Ie, aW as Ce, aX as Oe, aY as Re, aZ as Ae, a_ as ze, a$ as Me, _ as g, z as rt, d as D, e as Pe, l as k, q as Fe, t as We, c as R, b0 as Ye, aa as He, ab as Ke, a6 as Ue, b1 as M, b2 as kt, b3 as Q, av as Xe, y as $, k as Ve, b4 as je, i as Ct, b5 as Ot, b6 as Ge } from "./mermaid-GHXKKRXX-aX5umm-y.js";
 import { G as Ze } from "./graph-CWpEkm4G.js";
-import { c as qe } from "./channel-CUruDJSx.js";
+import { c as qe } from "./channel-DPbaAkCI.js";
 globalThis.process = globalThis.process || { env: {} };
 globalThis.global = globalThis.global || globalThis;
 function Je(e) {
@@ -2419,4 +2419,4 @@ var Ea = /* @__PURE__ */ g(function(e, t) {
 export {
   Ca as diagram
 };
-//# sourceMappingURL=blockDiagram-VBNYF7ZC-C0TDyTgw.js.map
+//# sourceMappingURL=blockDiagram-VBNYF7ZC-BAiLpxJf.js.map

package/dist/component/{c4Diagram-5PPSVZJV-rxRyd6rh.js → c4Diagram-5PPSVZJV-Sy6sLJOj.js}

@@ -1,5 +1,5 @@
-import { g as Oe, d as Re } from "./chunk-2GRJ4B5K-Kff5Fvbi.js";
-import { s as Se, g as De, a as Pe, b as Be, _ as y, c as Dt, d as Nt, l as he, e as Ie, f as Me, h as Tt, i as pe, j as Le, w as Ne, k as Jt, m as ue } from "./mermaid-GHXKKRXX-DfdCmrs3.js";
+import { g as Oe, d as Re } from "./chunk-2GRJ4B5K-8r8YJzCc.js";
+import { s as Se, g as De, a as Pe, b as Be, _ as y, c as Dt, d as Nt, l as he, e as Ie, f as Me, h as Tt, i as pe, j as Le, w as Ne, k as Jt, m as ue } from "./mermaid-GHXKKRXX-aX5umm-y.js";
 globalThis.process = globalThis.process || { env: {} };
 globalThis.global = globalThis.global || globalThis;
 var jt = (function() {
@@ -1583,4 +1583,4 @@ var T0 = /* @__PURE__ */ y(function(e, t, s, o) {
 export {
   P0 as diagram
 };
-//# sourceMappingURL=c4Diagram-5PPSVZJV-rxRyd6rh.js.map
+//# sourceMappingURL=c4Diagram-5PPSVZJV-Sy6sLJOj.js.map

package/dist/component/{channel-CUruDJSx.js → channel-DPbaAkCI.js}

@@ -1,8 +1,8 @@
-import { U as s, C as a } from "./mermaid-GHXKKRXX-DfdCmrs3.js";
+import { U as s, C as a } from "./mermaid-GHXKKRXX-aX5umm-y.js";
 globalThis.process = globalThis.process || { env: {} };
 globalThis.global = globalThis.global || globalThis;
 const g = (l, o) => s.lang.round(a.parse(l)[o]);
 export {
   g as c
 };
-//# sourceMappingURL=channel-CUruDJSx.js.map
+//# sourceMappingURL=channel-DPbaAkCI.js.map

package/dist/component/{chunk-2GRJ4B5K-Kff5Fvbi.js → chunk-2GRJ4B5K-8r8YJzCc.js}

@@ -1,4 +1,4 @@
-import { _ as l, d as n, n as d, j as o } from "./mermaid-GHXKKRXX-DfdCmrs3.js";
+import { _ as l, d as n, n as d, j as o } from "./mermaid-GHXKKRXX-aX5umm-y.js";
 globalThis.process = globalThis.process || { env: {} };
 globalThis.global = globalThis.global || globalThis;
 var c = /* @__PURE__ */ l((r, t) => {
@@ -68,4 +68,4 @@ export {
   m as g,
   y as h
 };
-//# sourceMappingURL=chunk-2GRJ4B5K-Kff5Fvbi.js.map
+//# sourceMappingURL=chunk-2GRJ4B5K-8r8YJzCc.js.map

package/dist/component/{chunk-2Q5K7J3B-BT3ZD31a.js → chunk-2Q5K7J3B-RZqny7-R.js}

@@ -1,4 +1,4 @@
-import { _ as t } from "./mermaid-GHXKKRXX-DfdCmrs3.js";
+import { _ as t } from "./mermaid-GHXKKRXX-aX5umm-y.js";
 globalThis.process = globalThis.process || { env: {} };
 globalThis.global = globalThis.global || globalThis;
 var a = class {
@@ -18,4 +18,4 @@ var a = class {
 export {
   a as I
 };
-//# sourceMappingURL=chunk-2Q5K7J3B-BT3ZD31a.js.map
+//# sourceMappingURL=chunk-2Q5K7J3B-RZqny7-R.js.map

package/dist/component/{chunk-5RXB4S5H-CYZ36tQD.js → chunk-5RXB4S5H-QFCY9Dtl.js}

@@ -1,7 +1,7 @@
-import { g as te } from "./chunk-XXDRQBXY-D9c0CJyR.js";
-import { s as ee } from "./chunk-KBJHAD2P-BeCfHf5W.js";
-import { _ as f, l as _, c as $, x as se, y as ie, a as re, b as ae, g as ne, s as oe, o as le, p as ce, ac as he, k as j, q as ue, d as bt, a8 as de } from "./mermaid-GHXKKRXX-DfdCmrs3.js";
-import { f as fe } from "./chunk-2GRJ4B5K-Kff5Fvbi.js";
+import { g as te } from "./chunk-XXDRQBXY-D4s0eyp4.js";
+import { s as ee } from "./chunk-KBJHAD2P-W03s7swc.js";
+import { _ as f, l as _, c as $, x as se, y as ie, a as re, b as ae, g as ne, s as oe, o as le, p as ce, ac as he, k as j, q as ue, d as bt, a8 as de } from "./mermaid-GHXKKRXX-aX5umm-y.js";
+import { f as fe } from "./chunk-2GRJ4B5K-8r8YJzCc.js";
 globalThis.process = globalThis.process || { env: {} };
 globalThis.global = globalThis.global || globalThis;
 var vt = (function() {
@@ -1414,4 +1414,4 @@ export {
   We as b,
   He as s
 };
-//# sourceMappingURL=chunk-5RXB4S5H-CYZ36tQD.js.map
+//# sourceMappingURL=chunk-5RXB4S5H-QFCY9Dtl.js.map

package/dist/component/{chunk-5VM5RSS4-BweQRk7u.js → chunk-5VM5RSS4-BG8q5ODa.js}

@@ -1,4 +1,4 @@
-import { _ as l } from "./mermaid-GHXKKRXX-DfdCmrs3.js";
+import { _ as l } from "./mermaid-GHXKKRXX-aX5umm-y.js";
 globalThis.process = globalThis.process || { env: {} };
 globalThis.global = globalThis.global || globalThis;
 var o = /* @__PURE__ */ l(() => `
@@ -19,4 +19,4 @@ var o = /* @__PURE__ */ l(() => `
 export {
   o as g
 };
-//# sourceMappingURL=chunk-5VM5RSS4-BweQRk7u.js.map
+//# sourceMappingURL=chunk-5VM5RSS4-BG8q5ODa.js.map

package/dist/component/{chunk-6Q2QTUOP-DHcoXRhe.js → chunk-6Q2QTUOP-D6ec2nI7.js}

@@ -1,4 +1,4 @@
-import { _ as p, l as w, G as L, z as E, q as I, Z as X, e as q, i as G, c as H } from "./mermaid-GHXKKRXX-DfdCmrs3.js";
+import { _ as p, l as w, G as L, z as E, q as I, Z as X, e as q, i as G, c as H } from "./mermaid-GHXKKRXX-aX5umm-y.js";
 globalThis.process = globalThis.process || { env: {} };
 globalThis.global = globalThis.global || globalThis;
 var z = "", b = "", N = "", A = [], R = /* @__PURE__ */ new Map(), k = /* @__PURE__ */ p((e) => G(e, H()), "sanitizeText"), F = /* @__PURE__ */ p((e) => {
@@ -670,4 +670,4 @@ export {
   ue as g,
   ge as r
 };
-//# sourceMappingURL=chunk-6Q2QTUOP-DHcoXRhe.js.map
+//# sourceMappingURL=chunk-6Q2QTUOP-D6ec2nI7.js.map

package/dist/component/{chunk-GF5L2VYU-DtE5ljCc.js → chunk-GF5L2VYU-D7yROYf0.js}

@@ -1,8 +1,8 @@
-import { g as tt } from "./chunk-5VM5RSS4-BweQRk7u.js";
-import { g as st } from "./chunk-XXDRQBXY-D9c0CJyR.js";
-import { s as it } from "./chunk-KBJHAD2P-BeCfHf5W.js";
-import { _ as f, l as Ie, c as F, v as at, x as nt, y as Oe, d as de, a8 as rt, b as ut, a as lt, s as ct, g as ot, o as ht, p as dt, k as I, q as pt, r as At, i as ft, a9 as G } from "./mermaid-GHXKKRXX-DfdCmrs3.js";
-import { f as gt } from "./chunk-2GRJ4B5K-Kff5Fvbi.js";
+import { g as tt } from "./chunk-5VM5RSS4-BG8q5ODa.js";
+import { g as st } from "./chunk-XXDRQBXY-D4s0eyp4.js";
+import { s as it } from "./chunk-KBJHAD2P-W03s7swc.js";
+import { _ as f, l as Ie, c as F, v as at, x as nt, y as Oe, d as de, a8 as rt, b as ut, a as lt, s as ct, g as ot, o as ht, p as dt, k as I, q as pt, r as At, i as ft, a9 as G } from "./mermaid-GHXKKRXX-aX5umm-y.js";
+import { f as gt } from "./chunk-2GRJ4B5K-8r8YJzCc.js";
 globalThis.process = globalThis.process || { env: {} };
 globalThis.global = globalThis.global || globalThis;
 var we = (function() {
@@ -1539,4 +1539,4 @@ export {
   Nt as c,
   St as s
 };
-//# sourceMappingURL=chunk-GF5L2VYU-DtE5ljCc.js.map
+//# sourceMappingURL=chunk-GF5L2VYU-D7yROYf0.js.map