onbuzz 5.3.0 → 5.4.0

package/src/tools/__tests__/userPromptTool.test.js

@@ -258,6 +258,96 @@ describe('UserPromptTool', () => {
     });
   });
 
+  describe('timeout estimation', () => {
+    test('closed (options-only) question is clamped up to the 2-min floor', () => {
+      expect(tool._estimateTimeoutMs([{ allowFreeText: false }])).toBe(2 * 60 * 1000);
+    });
+    test('open (free-text) question estimates 3 min', () => {
+      expect(tool._estimateTimeoutMs([{ message: 'Q?' }])).toBe(3 * 60 * 1000);
+      expect(tool._estimateTimeoutMs([{ allowFreeText: true }])).toBe(3 * 60 * 1000);
+    });
+    test('sums per question (2 open = 6 min)', () => {
+      expect(tool._estimateTimeoutMs([{}, {}])).toBe(6 * 60 * 1000);
+    });
+    test('mixed: one open (3) + one closed (1) = 4 min', () => {
+      expect(tool._estimateTimeoutMs([{ allowFreeText: true }, { allowFreeText: false }])).toBe(4 * 60 * 1000);
+    });
+    test('caps at 15 min for many questions', () => {
+      const many = Array.from({ length: 10 }, () => ({ allowFreeText: true }));
+      expect(tool._estimateTimeoutMs(many)).toBe(15 * 60 * 1000);
+    });
+    test('no questions → falls back to the default', () => {
+      expect(tool._estimateTimeoutMs([])).toBe(tool.timeout);
+      expect(tool._estimateTimeoutMs(undefined)).toBe(tool.timeout);
+    });
+  });
+
+  describe('timeout resolution precedence', () => {
+    const oneOpen = { questions: [{ message: 'Q?' }] };
+
+    test('explicit timeoutMs / timeout override wins', () => {
+      expect(tool._resolveTimeoutMs({ ...oneOpen, timeoutMs: 42000 })).toBe(42000);
+      expect(tool._resolveTimeoutMs({ ...oneOpen, timeout: 99000 })).toBe(99000);
+    });
+    test('config strategy "none" → null (no auto-timeout)', () => {
+      expect(tool._resolveTimeoutMs(oneOpen, { strategy: 'none' })).toBeNull();
+    });
+    test('config strategy "fixed" uses fixedMinutes', () => {
+      expect(tool._resolveTimeoutMs(oneOpen, { strategy: 'fixed', fixedMinutes: 10 })).toBe(10 * 60 * 1000);
+    });
+    test('config strategy "fixed" with a bad value → default', () => {
+      expect(tool._resolveTimeoutMs(oneOpen, { strategy: 'fixed', fixedMinutes: 'nope' })).toBe(tool.timeout);
+    });
+    test('default / "estimated" → estimate from questions', () => {
+      expect(tool._resolveTimeoutMs(oneOpen)).toBe(3 * 60 * 1000);
+      expect(tool._resolveTimeoutMs(oneOpen, { strategy: 'estimated' })).toBe(3 * 60 * 1000);
+    });
+  });
+
+  describe('execute wiring', () => {
+    function wire(agentMode = 'agent') {
+      const mockWs = { broadcastToSession: jest.fn() };
+      const mockPool = {
+        getAgent: jest.fn().mockResolvedValue({ id: 'agent-1', mode: agentMode }),
+        persistAgentState: jest.fn().mockResolvedValue(undefined),
+        addUserMessage: jest.fn().mockResolvedValue(undefined),
+      };
+      tool.setWebSocketManager(mockWs);
+      tool.setAgentPool(mockPool);
+      mockPromptService.createPromptRequest.mockReturnValue({
+        requestInfo: { requestId: 'req-1', message: null, questions: [{ message: 'Q?' }], timeoutAt: new Date().toISOString() },
+        promise: Promise.resolve({ response: { answers: [] } }),
+      });
+      return { mockPool };
+    }
+
+    test('passes the estimated timeout to createPromptRequest', async () => {
+      wire();
+      await tool.execute({ questions: [{ message: 'Q?' }] }, { agentId: 'agent-1', sessionId: 's' });
+      expect(mockPromptService.createPromptRequest).toHaveBeenCalledWith(
+        'agent-1', expect.anything(), { timeout: 3 * 60 * 1000 },
+      );
+    });
+
+    test('honors per-agent tool config (strategy none → null timeout)', async () => {
+      wire();
+      await tool.execute(
+        { questions: [{ message: 'Q?' }] },
+        { agentId: 'agent-1', sessionId: 's', toolConfig: { strategy: 'none' } },
+      );
+      expect(mockPromptService.createPromptRequest).toHaveBeenCalledWith(
+        'agent-1', expect.anything(), { timeout: null },
+      );
+    });
+
+    test('CHAT mode no longer queues a synthetic user message', async () => {
+      const { mockPool } = wire('chat');
+      const result = await tool.execute({ questions: [{ message: 'Q?' }] }, { agentId: 'agent-1', sessionId: 's' });
+      expect(result.success).toBe(true);
+      expect(mockPool.addUserMessage).not.toHaveBeenCalled();
+    });
+  });
+
   describe('setAgentPool', () => {
     test('should store agent pool', () => {
       const pool = { getAgent: jest.fn() };

package/src/tools/baseTool.js

@@ -15,6 +15,7 @@ import {
   SYSTEM_DEFAULTS
 } from '../utilities/constants.js';
 import { NATIVE_SCHEMA_TOOL_NAMES } from './openaiFunctionSchemas.js';
+import { applyMustHaveCapabilities, isMustHaveCapability } from '../utilities/mustHaveCapabilities.js';
 
 class BaseTool {
   constructor(config = {}, logger = null) {
@@ -704,12 +705,23 @@ class ToolsRegistry {
       // behaviour: include text descriptions). Old callers that don't
       // pass this option get the previous behaviour verbatim — back-compat.
       apiType = undefined,
+      // Agent mode ('agent' | 'chat'). Gates the jobdone must-have (autonomous
+      // completion is meaningless in chat). Undefined → treated as non-agent.
+      mode = undefined,
     } = options;
     const isNativeApi = apiType === 'responses';
 
+    // Force-inject the must-have tools (taskmanager always; jobdone in AGENT
+    // mode) into an explicit capability list, honoring `!cap` opt-out — same
+    // spirit as the unconditional 'help' injection below. An empty list still
+    // means "all tools", which already includes them.
+    const effectiveCaps = capabilities.length > 0
+      ? applyMustHaveCapabilities(capabilities, mode)
+      : capabilities;
+
     // Get tools to include — always inject 'help' so agents can query tool docs
-    let toolIds = capabilities.length > 0
-      ? capabilities.filter(cap => this.tools.has(cap))
+    let toolIds = effectiveCaps.length > 0
+      ? effectiveCaps.filter(cap => this.tools.has(cap))
       : Array.from(this.tools.keys());
 
     if (!toolIds.includes('help') && this.tools.has('help')) {
@@ -963,6 +975,12 @@ class ToolsRegistry {
     const tools = [];
 
     for (const [toolId, tool] of this.tools.entries()) {
+      // Must-have tools (taskmanager, jobdone) are always advertised to agents
+      // at prompt/schema build time — they are not user-selectable, so they
+      // are omitted from the UI capability selector to avoid implying they can
+      // be turned off. See utilities/mustHaveCapabilities.js.
+      if (isMustHaveCapability(toolId)) continue;
+
       const capabilities = tool.getCapabilities();
 
       // Prefer the explicit `tool.name` that every BaseTool subclass sets

package/src/tools/openaiFunctionSchemas.js

@@ -22,6 +22,8 @@
  * remains tool-agnostic.
  */
 
+import { applyMustHaveCapabilities } from '../utilities/mustHaveCapabilities.js';
+
 export const OPENAI_FUNCTION_SCHEMAS = [
   // TaskManager — actions-array with flat task fields per action.
   // Field names mirror the tool's system-prompt protocol (src/tools/taskManagerTool.js
@@ -1009,16 +1011,23 @@ export const OPENAI_FUNCTION_SCHEMAS = [
  * Keeps the model's tool list minimal — it sees only what the agent actually
  * has access to, which also reduces prompt size and ambiguity.
  *
+ * Must-have tools (taskmanager always; jobdone in AGENT mode) are force-added
+ * to any explicit capability list, mirroring how the system-prompt builder
+ * force-injects `help`. An empty list still means "full catalog" (which already
+ * contains them), so we only augment a non-empty list.
+ *
  * @param {string[]} capabilities - Agent capabilities (matches tool ids)
+ * @param {string} [mode] - Agent mode ('agent' | 'chat'); gates jobdone.
  * @returns {Array} Function schemas the agent is allowed to invoke
  */
-export function getToolSchemasForAgent(capabilities = []) {
+export function getToolSchemasForAgent(capabilities = [], mode) {
   if (!Array.isArray(capabilities) || capabilities.length === 0) {
     // Agent has no capability list — give it the full catalog rather than
     // leaving it tool-less. Matches the CLI's existing "include all" fallback.
     return OPENAI_FUNCTION_SCHEMAS;
   }
-  const allowed = new Set(capabilities.map(c => String(c).toLowerCase()));
+  const effective = applyMustHaveCapabilities(capabilities, mode);
+  const allowed = new Set(effective.map(c => String(c).toLowerCase()));
   return OPENAI_FUNCTION_SCHEMAS.filter(s => allowed.has(s.name.toLowerCase()));
 }
 

package/src/tools/userPromptTool.js

@@ -24,7 +24,58 @@ class UserPromptTool extends BaseTool {
     // Tool metadata
     this.requiresProject = false;
     this.isAsync = false; // Blocks until user responds
-    this.timeout = 5 * 60 * 1000; // 5 minute timeout
+    this.timeout = 5 * 60 * 1000; // fallback default (5 min) when estimation yields nothing
+  }
+
+  // Timeout estimation bounds (a human answering a modal). A "closed" question
+  // (options only, no free text) is quick to click; an "open" one (free text)
+  // takes longer to type. Summed, then clamped so we never nag too fast or wait
+  // absurdly long by default.
+  static TIMEOUT_CLOSED_MS = 60 * 1000;   // 1 min per closed question
+  static TIMEOUT_OPEN_MS = 3 * 60 * 1000; // 3 min per open (free-text) question
+  static TIMEOUT_FLOOR_MS = 2 * 60 * 1000;
+  static TIMEOUT_CAP_MS = 15 * 60 * 1000;
+
+  /**
+   * Estimate a timeout from the question mix: 1 min per closed question, 3 min
+   * per open (free-text) one, clamped to [floor, cap].
+   * @param {Array} questions
+   * @returns {number} milliseconds
+   */
+  _estimateTimeoutMs(questions) {
+    const list = Array.isArray(questions) ? questions : [];
+    let ms = 0;
+    for (const q of list) {
+      const isOpen = q?.allowFreeText !== false; // free text allowed => "open"
+      ms += isOpen ? UserPromptTool.TIMEOUT_OPEN_MS : UserPromptTool.TIMEOUT_CLOSED_MS;
+    }
+    if (ms <= 0) return this.timeout; // no questions parsed yet → default
+    return Math.max(UserPromptTool.TIMEOUT_FLOOR_MS, Math.min(UserPromptTool.TIMEOUT_CAP_MS, ms));
+  }
+
+  /**
+   * Resolve the effective timeout for a prompt. Precedence:
+   *   1. explicit per-call override (params.timeoutMs / params.timeout, minutes-agnostic ms)
+   *   2. per-agent tool config (context.toolConfig.userprompt-style: { strategy, fixedMinutes })
+   *   3. estimated default (1 min closed / 3 min open, clamped)
+   * Returns `null` to mean "no auto-timeout" (strategy: 'none').
+   * @param {Object} params
+   * @param {Object} [toolConfig]
+   * @returns {number|null}
+   */
+  _resolveTimeoutMs(params, toolConfig) {
+    const explicit = Number(params?.timeoutMs ?? params?.timeout);
+    if (Number.isFinite(explicit) && explicit > 0) return explicit;
+
+    const cfg = (toolConfig && typeof toolConfig === 'object') ? toolConfig : {};
+    const strategy = cfg.strategy || 'estimated';
+    if (strategy === 'none') return null;
+    if (strategy === 'fixed') {
+      const mins = Number(cfg.fixedMinutes);
+      if (Number.isFinite(mins) && mins > 0) return mins * 60 * 1000;
+      return this.timeout;
+    }
+    return this._estimateTimeoutMs(params?.questions);
   }
 
   /**
@@ -133,7 +184,10 @@ The user's responses will be returned as a formatted message containing:
 BEHAVIOR:
 - Agent execution PAUSES while waiting for user response
 - User sees a modal with the questions in the chat interface
-- Default timeout: 5 minutes (then resumes with timeout error)
+- Timeout is estimated from the questions (~1 min per options-only question,
+  ~3 min per free-text question, clamped 2-15 min) unless the agent/user
+  overrides it. Pass "timeoutMs" to set an explicit timeout; on timeout the
+  agent resumes with a timeout error.
 - Use sparingly - only when user input is truly necessary
     `;
   }
@@ -228,6 +282,9 @@ BEHAVIOR:
     const promptService = getPromptService(this.logger);
     let agent = null;
 
+    // Resolve the timeout: explicit override → per-agent tool config → estimate.
+    const resolvedTimeout = this._resolveTimeoutMs(params, context.toolConfig);
+
     try {
       // Create prompt request
       const { requestInfo, promise } = promptService.createPromptRequest(
@@ -236,7 +293,7 @@ BEHAVIOR:
           message: params.message,
           questions: params.questions
         },
-        { timeout: this.timeout }
+        { timeout: resolvedTimeout }
       );
 
       // Block scheduling while waiting for user input.
@@ -323,23 +380,12 @@ BEHAVIOR:
         result.response
       );
 
-      // CRITICAL FIX: In CHAT mode, tool results alone don't trigger processing
-      // Queue the user's response as a user message to ensure continuation
-      if (agent && this.agentPool && agent.mode === 'chat') {
-        this.logger?.info('[UserPromptTool] CHAT mode - queueing response as user message to trigger continuation', {
-          agentId,
-          mode: agent.mode
-        });
-
-        // Queue the formatted response as a user message
-        await this.agentPool.addUserMessage(agentId, {
-          role: 'user',
-          content: `[User Response to Agent Prompt]\n\n${formattedResponse}`,
-          type: 'prompt-response',
-          promptRequestId: requestInfo.requestId,
-          timestamp: new Date().toISOString()
-        });
-      }
+      // NOTE: CHAT-mode continuation used to require queueing the response as a
+      // synthetic user message, because tool results alone didn't re-schedule a
+      // CHAT agent. That's no longer needed — shouldAgentBeActive now activates
+      // CHAT agents on queued tool results, so this tool's own result continues
+      // the agent naturally (see agentActivityService.js). Returning the result
+      // is sufficient for both CHAT and AGENT modes.
 
       return {
         success: true,

package/src/utilities/__tests__/mustHaveCapabilities.test.js

@@ -0,0 +1,80 @@
+import { describe, test, expect } from '@jest/globals';
+import {
+  applyMustHaveCapabilities,
+  isMustHaveCapability,
+  ALWAYS_MUST_HAVE_CAPABILITIES,
+  AGENT_MODE_MUST_HAVE_CAPABILITIES,
+} from '../mustHaveCapabilities.js';
+
+describe('applyMustHaveCapabilities', () => {
+  test('non-array input passes through unchanged', () => {
+    expect(applyMustHaveCapabilities(undefined, 'agent')).toBeUndefined();
+    expect(applyMustHaveCapabilities(null, 'agent')).toBeNull();
+    expect(applyMustHaveCapabilities('nope', 'agent')).toBe('nope');
+  });
+
+  test('chat mode forces taskmanager but NOT jobdone', () => {
+    const out = applyMustHaveCapabilities(['web'], 'chat');
+    expect(out).toContain('web');
+    expect(out).toContain('taskmanager');
+    expect(out).not.toContain('jobdone');
+  });
+
+  test('agent mode forces both taskmanager and jobdone', () => {
+    const out = applyMustHaveCapabilities(['web'], 'agent');
+    expect(out).toEqual(['web', 'taskmanager', 'jobdone']);
+  });
+
+  test('mode is case-insensitive', () => {
+    expect(applyMustHaveCapabilities(['web'], 'AGENT')).toContain('jobdone');
+  });
+
+  test('unknown / missing mode is treated as non-agent', () => {
+    expect(applyMustHaveCapabilities(['web'])).toEqual(['web', 'taskmanager']);
+    expect(applyMustHaveCapabilities(['web'], 'weird')).not.toContain('jobdone');
+  });
+
+  test('does not duplicate an already-present must-have (case-insensitive)', () => {
+    const out = applyMustHaveCapabilities(['TaskManager', 'web'], 'agent');
+    expect(out.filter((c) => c.toLowerCase() === 'taskmanager')).toHaveLength(1);
+    // preserves the caller's original casing/position, appends only jobdone
+    expect(out).toEqual(['TaskManager', 'web', 'jobdone']);
+  });
+
+  test('de-duplicates the base list case-insensitively', () => {
+    expect(applyMustHaveCapabilities(['web', 'WEB'], 'chat')).toEqual(['web', 'taskmanager']);
+  });
+
+  test('!cap opt-out suppresses a must-have and never leaks the marker', () => {
+    const out = applyMustHaveCapabilities(['web', '!jobdone'], 'agent');
+    expect(out).toContain('taskmanager');
+    expect(out).not.toContain('jobdone');
+    expect(out).not.toContain('!jobdone');
+    expect(out).toEqual(['web', 'taskmanager']);
+  });
+
+  test('!taskmanager opts out the always-on must-have too', () => {
+    const out = applyMustHaveCapabilities(['web', '!taskmanager'], 'agent');
+    expect(out).not.toContain('taskmanager');
+    expect(out).toContain('jobdone');
+  });
+
+  test('empty list still gets must-haves (callers guard empty→full-catalog)', () => {
+    expect(applyMustHaveCapabilities([], 'agent')).toEqual(['taskmanager', 'jobdone']);
+  });
+});
+
+describe('isMustHaveCapability', () => {
+  test('true for the must-have tool ids (case-insensitive)', () => {
+    expect(isMustHaveCapability('taskmanager')).toBe(true);
+    expect(isMustHaveCapability('JobDone')).toBe(true);
+  });
+  test('false for anything else', () => {
+    expect(isMustHaveCapability('web')).toBe(false);
+    expect(isMustHaveCapability('help')).toBe(false);
+  });
+  test('exported constant shapes are stable', () => {
+    expect(ALWAYS_MUST_HAVE_CAPABILITIES).toEqual(['taskmanager']);
+    expect(AGENT_MODE_MUST_HAVE_CAPABILITIES).toEqual(['jobdone']);
+  });
+});

package/src/utilities/mustHaveCapabilities.js

@@ -0,0 +1,94 @@
+/**
+ * "Must-have" tool capabilities.
+ *
+ * A few tools are load-bearing enough that agents should always have them,
+ * rather than the user having to remember to tick a box. These are injected at
+ * tool-ADVERTISEMENT time (system-prompt build + native function schemas),
+ * exactly like `help` is force-injected — NOT baked into the stored capability
+ * list. Advertisement-time injection means the set tracks the agent's CURRENT
+ * mode, so it stays correct across chat<->agent flips.
+ *
+ *   - `taskmanager` — always (both modes). Task tracking underpins the whole
+ *     autonomous discipline and is useful in chat too.
+ *   - `jobdone`     — AGENT mode only. It exits autonomous mode, which is
+ *     meaningless for a chat agent, so we don't advertise it there.
+ *
+ * Opt-out: put a negation marker `!<cap>` in the capability list (e.g.
+ * `!jobdone`). Negation markers are control tokens — they are stripped from the
+ * effective list so they never leak into prompt text or schema filtering, and
+ * they suppress the corresponding force-injection.
+ *
+ * The UI no longer offers these as toggles (removed from the terminal
+ * AVAILABLE_TOOLS list and from getAvailableToolsForUI), so this module is the
+ * single source of truth for "these are always on unless explicitly opted out".
+ */
+
+/** Forced in every mode. */
+export const ALWAYS_MUST_HAVE_CAPABILITIES = ['taskmanager'];
+/** Forced only when the agent is in AGENT (autonomous) mode. */
+export const AGENT_MODE_MUST_HAVE_CAPABILITIES = ['jobdone'];
+
+/** The negation-marker prefix that opts a capability out of force-injection. */
+export const CAPABILITY_OPT_OUT_PREFIX = '!';
+
+/**
+ * Compute the effective capability list an agent should have ADVERTISED,
+ * augmenting the caller's list with the must-have capabilities appropriate to
+ * `mode`, honoring `!cap` opt-out markers, and de-duplicating case-insensitively.
+ *
+ * Non-array input is returned unchanged (mirrors sanitizeCapabilities), so
+ * callers can pass a possibly-missing list straight through.
+ *
+ * @param {Array<string>} capabilities  The agent's selected capability list.
+ * @param {string} [mode]  'agent' | 'chat' (case-insensitive). Others → chat-like.
+ * @returns {Array<string>} Effective capabilities (negation markers removed).
+ */
+export function applyMustHaveCapabilities(capabilities, mode) {
+  if (!Array.isArray(capabilities)) return capabilities;
+
+  const optedOut = new Set();
+  const out = [];
+  const seen = new Set();
+
+  for (const cap of capabilities) {
+    const s = String(cap);
+    if (s.startsWith(CAPABILITY_OPT_OUT_PREFIX)) {
+      // Control token: record the opt-out, but never emit it as a capability.
+      optedOut.add(s.slice(CAPABILITY_OPT_OUT_PREFIX.length).toLowerCase());
+      continue;
+    }
+    const lc = s.toLowerCase();
+    if (!seen.has(lc)) {
+      seen.add(lc);
+      out.push(cap);
+    }
+  }
+
+  const forced = [
+    ...ALWAYS_MUST_HAVE_CAPABILITIES,
+    ...(String(mode).toLowerCase() === 'agent' ? AGENT_MODE_MUST_HAVE_CAPABILITIES : []),
+  ];
+  for (const cap of forced) {
+    const lc = cap.toLowerCase();
+    if (!optedOut.has(lc) && !seen.has(lc)) {
+      seen.add(lc);
+      out.push(cap);
+    }
+  }
+
+  return out;
+}
+
+/** Is `capId` one of the must-have tools (removed from the UI selectors)? */
+export function isMustHaveCapability(capId) {
+  const lc = String(capId).toLowerCase();
+  return ALWAYS_MUST_HAVE_CAPABILITIES.includes(lc) || AGENT_MODE_MUST_HAVE_CAPABILITIES.includes(lc);
+}
+
+export default {
+  ALWAYS_MUST_HAVE_CAPABILITIES,
+  AGENT_MODE_MUST_HAVE_CAPABILITIES,
+  CAPABILITY_OPT_OUT_PREFIX,
+  applyMustHaveCapabilities,
+  isMustHaveCapability,
+};

package/web-ui/build/index.html

@@ -6,8 +6,8 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Loxia Autopilot One</title>
     <meta name="description" content="AI Agents System - No-code/vibe-code/companion-coder platform" />
-    <script type="module" crossorigin src="/static/index-BZ96dWlb.js"></script>
-    <link rel="stylesheet" crossorigin href="/static/index-CRb74OSB.css">
+    <script type="module" crossorigin src="/static/index-Z3yzqwSM.js"></script>
+    <link rel="stylesheet" crossorigin href="/static/index-DLkEZgsP.css">
   </head>
   <body>
     <div id="root"></div>

package/web-ui/build/static/1c-D_qPvB3V.js

@@ -0,0 +1,2 @@
+import{g as f}from"./index-Z3yzqwSM.js";import{r as s}from"./index-u6goNp7m.js";function i(t,n){for(var o=0;o<n.length;o++){const e=n[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const c=Object.getOwnPropertyDescriptor(e,r);c&&Object.defineProperty(t,r,c.get?c:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var a=s();const p=f(a),l=i({__proto__:null,default:p},[a]);export{l as _};
+//# sourceMappingURL=1c-D_qPvB3V.js.map

package/web-ui/build/static/1c-D_qPvB3V.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"1c-D_qPvB3V.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/web-ui/build/static/abap-CTac7GuJ.js

@@ -0,0 +1,2 @@
+import{g as s,r as f}from"./index-Z3yzqwSM.js";function c(t,n){for(var o=0;o<n.length;o++){const e=n[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const a=Object.getOwnPropertyDescriptor(e,r);a&&Object.defineProperty(t,r,a.get?a:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var p=f();const i=s(p),b=c({__proto__:null,default:i},[p]);export{b as a};
+//# sourceMappingURL=abap-CTac7GuJ.js.map

package/web-ui/build/static/abap-CTac7GuJ.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abap-CTac7GuJ.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/web-ui/build/static/abnf-B-eguyQx.js

@@ -0,0 +1,2 @@
+import{g as s}from"./index-Z3yzqwSM.js";import{a as i}from"./index-u6goNp7m.js";function c(t,n){for(var o=0;o<n.length;o++){const e=n[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const a=Object.getOwnPropertyDescriptor(e,r);a&&Object.defineProperty(t,r,a.get?a:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var f=i();const p=s(f),g=c({__proto__:null,default:p},[f]);export{g as a};
+//# sourceMappingURL=abnf-B-eguyQx.js.map

package/web-ui/build/static/abnf-B-eguyQx.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abnf-B-eguyQx.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/web-ui/build/static/abnf-DchqkIUY.js

@@ -0,0 +1,2 @@
+import{g as s,a as c}from"./index-Z3yzqwSM.js";function i(t,n){for(var o=0;o<n.length;o++){const e=n[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const a=Object.getOwnPropertyDescriptor(e,r);a&&Object.defineProperty(t,r,a.get?a:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var f=c();const p=s(f),b=i({__proto__:null,default:p},[f]);export{b as a};
+//# sourceMappingURL=abnf-DchqkIUY.js.map

package/web-ui/build/static/abnf-DchqkIUY.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abnf-DchqkIUY.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/web-ui/build/static/accesslog-Df2QXZJW.js

@@ -0,0 +1,2 @@
+import{g as n}from"./index-Z3yzqwSM.js";import{b as f}from"./index-u6goNp7m.js";function g(t,c){for(var o=0;o<c.length;o++){const e=c[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const s=Object.getOwnPropertyDescriptor(e,r);s&&Object.defineProperty(t,r,s.get?s:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var a=f();const l=n(a),u=g({__proto__:null,default:l},[a]);export{u as a};
+//# sourceMappingURL=accesslog-Df2QXZJW.js.map

package/web-ui/build/static/accesslog-Df2QXZJW.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"accesslog-Df2QXZJW.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/web-ui/build/static/actionscript-DVmdyVvT.js

@@ -0,0 +1,2 @@
+import{g as a}from"./index-Z3yzqwSM.js";import{c as s}from"./index-u6goNp7m.js";function p(r,i){for(var o=0;o<i.length;o++){const t=i[o];if(typeof t!="string"&&!Array.isArray(t)){for(const e in t)if(e!=="default"&&!(e in r)){const c=Object.getOwnPropertyDescriptor(t,e);c&&Object.defineProperty(r,e,c.get?c:{enumerable:!0,get:()=>t[e]})}}}return Object.freeze(Object.defineProperty(r,Symbol.toStringTag,{value:"Module"}))}var n=s();const f=a(n),l=p({__proto__:null,default:f},[n]);export{l as a};
+//# sourceMappingURL=actionscript-DVmdyVvT.js.map

package/web-ui/build/static/actionscript-DVmdyVvT.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"actionscript-DVmdyVvT.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/web-ui/build/static/actionscript-UYqAHsow.js

@@ -0,0 +1,2 @@
+import{g as a,b as s}from"./index-Z3yzqwSM.js";function p(r,i){for(var o=0;o<i.length;o++){const t=i[o];if(typeof t!="string"&&!Array.isArray(t)){for(const e in t)if(e!=="default"&&!(e in r)){const c=Object.getOwnPropertyDescriptor(t,e);c&&Object.defineProperty(r,e,c.get?c:{enumerable:!0,get:()=>t[e]})}}}return Object.freeze(Object.defineProperty(r,Symbol.toStringTag,{value:"Module"}))}var n=s();const f=a(n),g=p({__proto__:null,default:f},[n]);export{g as a};
+//# sourceMappingURL=actionscript-UYqAHsow.js.map

package/web-ui/build/static/actionscript-UYqAHsow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"actionscript-UYqAHsow.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/web-ui/build/static/ada-DI0WZ2bS.js

@@ -0,0 +1,2 @@
+import{g as s}from"./index-Z3yzqwSM.js";import{d as i}from"./index-u6goNp7m.js";function c(t,n){for(var o=0;o<n.length;o++){const e=n[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const a=Object.getOwnPropertyDescriptor(e,r);a&&Object.defineProperty(t,r,a.get?a:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var f=i();const p=s(f),g=c({__proto__:null,default:p},[f]);export{g as a};
+//# sourceMappingURL=ada-DI0WZ2bS.js.map

package/web-ui/build/static/ada-DI0WZ2bS.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ada-DI0WZ2bS.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/web-ui/build/static/ada-offhvrbu.js

@@ -0,0 +1,2 @@
+import{g as f,c}from"./index-Z3yzqwSM.js";function i(t,n){for(var o=0;o<n.length;o++){const e=n[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const a=Object.getOwnPropertyDescriptor(e,r);a&&Object.defineProperty(t,r,a.get?a:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var s=c();const p=f(s),d=i({__proto__:null,default:p},[s]);export{d as a};
+//# sourceMappingURL=ada-offhvrbu.js.map

package/web-ui/build/static/ada-offhvrbu.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ada-offhvrbu.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/web-ui/build/static/agda-Bhdvz1s5.js

@@ -0,0 +1,2 @@
+import{g as f,d as g}from"./index-Z3yzqwSM.js";function c(t,n){for(var o=0;o<n.length;o++){const e=n[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const a=Object.getOwnPropertyDescriptor(e,r);a&&Object.defineProperty(t,r,a.get?a:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var s=g();const i=f(s),p=c({__proto__:null,default:i},[s]);export{p as a};
+//# sourceMappingURL=agda-Bhdvz1s5.js.map

package/web-ui/build/static/agda-Bhdvz1s5.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agda-Bhdvz1s5.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/web-ui/build/static/al-BIZUcZ4_.js

@@ -0,0 +1,2 @@
+import{g as f,e as l}from"./index-Z3yzqwSM.js";function c(t,n){for(var o=0;o<n.length;o++){const e=n[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const a=Object.getOwnPropertyDescriptor(e,r);a&&Object.defineProperty(t,r,a.get?a:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var s=l();const i=f(s),u=c({__proto__:null,default:i},[s]);export{u as a};
+//# sourceMappingURL=al-BIZUcZ4_.js.map

package/web-ui/build/static/al-BIZUcZ4_.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"al-BIZUcZ4_.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/web-ui/build/static/angelscript-CKXFYEKx.js

@@ -0,0 +1,2 @@
+import{g as i}from"./index-Z3yzqwSM.js";import{e as c}from"./index-u6goNp7m.js";function p(t,a){for(var o=0;o<a.length;o++){const e=a[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const n=Object.getOwnPropertyDescriptor(e,r);n&&Object.defineProperty(t,r,n.get?n:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var s=c();const f=i(s),u=p({__proto__:null,default:f},[s]);export{u as a};
+//# sourceMappingURL=angelscript-CKXFYEKx.js.map

package/web-ui/build/static/angelscript-CKXFYEKx.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"angelscript-CKXFYEKx.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/web-ui/build/static/antlr4-CBOfHCbJ.js

@@ -0,0 +1,2 @@
+import{g as s,f as l}from"./index-Z3yzqwSM.js";function c(t,a){for(var o=0;o<a.length;o++){const e=a[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const n=Object.getOwnPropertyDescriptor(e,r);n&&Object.defineProperty(t,r,n.get?n:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var f=l();const i=s(f),u=c({__proto__:null,default:i},[f]);export{u as a};
+//# sourceMappingURL=antlr4-CBOfHCbJ.js.map

package/web-ui/build/static/antlr4-CBOfHCbJ.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"antlr4-CBOfHCbJ.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/web-ui/build/static/apache-B5MDB0nP.js

@@ -0,0 +1,2 @@
+import{g as n}from"./index-Z3yzqwSM.js";import{f as p}from"./index-u6goNp7m.js";function s(t,c){for(var o=0;o<c.length;o++){const e=c[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const a=Object.getOwnPropertyDescriptor(e,r);a&&Object.defineProperty(t,r,a.get?a:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var f=p();const i=n(f),l=s({__proto__:null,default:i},[f]);export{l as a};
+//# sourceMappingURL=apache-B5MDB0nP.js.map

package/web-ui/build/static/apache-B5MDB0nP.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"apache-B5MDB0nP.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/web-ui/build/static/apacheconf-CPiv7EUZ.js

@@ -0,0 +1,2 @@
+import{g as f,h as p}from"./index-Z3yzqwSM.js";function s(t,c){for(var o=0;o<c.length;o++){const e=c[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const a=Object.getOwnPropertyDescriptor(e,r);a&&Object.defineProperty(t,r,a.get?a:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var n=p();const i=f(n),g=s({__proto__:null,default:i},[n]);export{g as a};
+//# sourceMappingURL=apacheconf-CPiv7EUZ.js.map

package/web-ui/build/static/apacheconf-CPiv7EUZ.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"apacheconf-CPiv7EUZ.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/web-ui/build/static/apex-0ySlorg9.js

@@ -0,0 +1,2 @@
+import{g as s,j as f}from"./index-Z3yzqwSM.js";function c(t,n){for(var o=0;o<n.length;o++){const e=n[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const a=Object.getOwnPropertyDescriptor(e,r);a&&Object.defineProperty(t,r,a.get?a:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var p=f();const i=s(p),g=c({__proto__:null,default:i},[p]);export{g as a};
+//# sourceMappingURL=apex-0ySlorg9.js.map

package/web-ui/build/static/apex-0ySlorg9.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"apex-0ySlorg9.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/web-ui/build/static/apl-DmEChSCP.js

@@ -0,0 +1,2 @@
+import{g as s,k as f}from"./index-Z3yzqwSM.js";function l(t,n){for(var o=0;o<n.length;o++){const e=n[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const a=Object.getOwnPropertyDescriptor(e,r);a&&Object.defineProperty(t,r,a.get?a:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var p=f();const c=s(p),u=l({__proto__:null,default:c},[p]);export{u as a};
+//# sourceMappingURL=apl-DmEChSCP.js.map

package/web-ui/build/static/apl-DmEChSCP.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"apl-DmEChSCP.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}