@msm-core/mini 0.8.0 → 0.9.0

package/dist/bridge/pipeline.js

@@ -14,6 +14,7 @@
  *
  * The pipeline is duck-typed — no direct import of @msm-core/pipeline.
  */
+import { BRAIN_ACTIONS } from "../core/types.js";
 // ─── Adapter ──────────────────────────────────────────────────
 /**
  * Wrap an @msm-core/pipeline as a Brain for @msm-core/mini.
@@ -57,14 +58,16 @@ export function wrapPipeline(pipeline, name = "pipeline") {
                     : {}),
             });
             const brain = result.payload.brain;
-            // Normalise action — pipeline may return arbitrary strings; mini only knows these
-            const VALID_ACTIONS = new Set([
-                "use_tool",
-                "respond",
-                "clarify",
-                "escalate",
-                "delegate",
-            ]);
+            // Normalise action — a duck-typed pipeline may return any string, and
+            // mini dispatches on four. The set is built FROM `BRAIN_ACTIONS` and is
+            // no longer a second hand-written copy of it (ر٢): a copy is how the
+            // union and this list came to disagree about a fifth action that the loop
+            // never dispatched on, and how that disagreement went unnoticed.
+            //
+            // The fallback is unchanged: an unrecognised string becomes `respond`,
+            // which is also what the loop itself does with one that arrives past this
+            // point. Two layers, one rule.
+            const VALID_ACTIONS = new Set(BRAIN_ACTIONS);
             const rawAction = brain?.action ?? "respond";
             const action = VALID_ACTIONS.has(rawAction)
                 ? rawAction

package/dist/core/types.d.ts

@@ -154,8 +154,45 @@ export interface BrainToolCall {
     name: string;
     params: Record<string, unknown>;
 }
+/**
+ * Every action the loop DISPATCHES ON — declared as data, and the only list.
+ *
+ * ── Why this is a `const` array and not an inline union (ر٢) ────────────────
+ *
+ * There were two lists. This union, and a second copy in `bridge/pipeline.ts`
+ * that normalises whatever a duck-typed pipeline hands back. Both carried a
+ * fifth member the loop never dispatched on — a routing action that was
+ * declared at the beginning, implemented nowhere, and used by nobody (measured:
+ * zero occurrences in the live consumer). It survived precisely because
+ * deleting it meant finding and agreeing two places, and س١'s lesson is that
+ * two lists of the same thing drift apart silently and are only noticed by the
+ * damage.
+ *
+ * So there is now one list. The union below is derived from it and the bridge
+ * validates against it, which means a member cannot be added to one and
+ * forgotten in the other, and a member cannot be REMOVED from one and left
+ * standing in the other. `BrainActionsAreTheFourLiveOnes` then makes growing
+ * this array a decision someone has to write down rather than one that happens
+ * by omission.
+ *
+ * **What the loop actually does with each** (`core/loop.ts`):
+ *   - `use_tool`  → the step's tool calls run, then back to the model.
+ *   - `clarify` / `escalate` → terminal, and the outcome carries that type.
+ *   - `respond`   → terminal, the text is delivered.
+ *
+ * And an action that is NONE of these — a rogue model emitting a string at
+ * runtime, where no type can stop it — takes the `respond` path: terminal,
+ * one iteration, whatever text the payload carried. That is the existing
+ * behaviour, it is fail-safe (a nonsense action never loops and never runs a
+ * tool), and it is pinned by a guard in `tests/delegate.test.ts` rather than
+ * left as an accident. The bridge's `respond` fallback for an unrecognised
+ * string is the same rule stated one layer earlier.
+ */
+export declare const BRAIN_ACTIONS: readonly ["use_tool", "respond", "clarify", "escalate"];
+/** What a model may ask the loop to do. Derived from `BRAIN_ACTIONS`. */
+export type BrainAction = (typeof BRAIN_ACTIONS)[number];
 export interface BrainOrchestration {
-    action: "use_tool" | "respond" | "clarify" | "escalate" | "delegate";
+    action: BrainAction;
     confidence: number;
     /**
      * The FIRST call of the step. Always filled whenever `tool_calls` is —

package/dist/core/types.js

@@ -4,4 +4,43 @@
  * All contracts for the lite agent runtime. Brain-agnostic, zero embedded
  * databases. Application layer owns persistence; agent owns the loop.
  */
-export {};
+/**
+ * Every action the loop DISPATCHES ON — declared as data, and the only list.
+ *
+ * ── Why this is a `const` array and not an inline union (ر٢) ────────────────
+ *
+ * There were two lists. This union, and a second copy in `bridge/pipeline.ts`
+ * that normalises whatever a duck-typed pipeline hands back. Both carried a
+ * fifth member the loop never dispatched on — a routing action that was
+ * declared at the beginning, implemented nowhere, and used by nobody (measured:
+ * zero occurrences in the live consumer). It survived precisely because
+ * deleting it meant finding and agreeing two places, and س١'s lesson is that
+ * two lists of the same thing drift apart silently and are only noticed by the
+ * damage.
+ *
+ * So there is now one list. The union below is derived from it and the bridge
+ * validates against it, which means a member cannot be added to one and
+ * forgotten in the other, and a member cannot be REMOVED from one and left
+ * standing in the other. `BrainActionsAreTheFourLiveOnes` then makes growing
+ * this array a decision someone has to write down rather than one that happens
+ * by omission.
+ *
+ * **What the loop actually does with each** (`core/loop.ts`):
+ *   - `use_tool`  → the step's tool calls run, then back to the model.
+ *   - `clarify` / `escalate` → terminal, and the outcome carries that type.
+ *   - `respond`   → terminal, the text is delivered.
+ *
+ * And an action that is NONE of these — a rogue model emitting a string at
+ * runtime, where no type can stop it — takes the `respond` path: terminal,
+ * one iteration, whatever text the payload carried. That is the existing
+ * behaviour, it is fail-safe (a nonsense action never loops and never runs a
+ * tool), and it is pinned by a guard in `tests/delegate.test.ts` rather than
+ * left as an accident. The bridge's `respond` fallback for an unrecognised
+ * string is the same rule stated one layer earlier.
+ */
+export const BRAIN_ACTIONS = [
+    "use_tool",
+    "respond",
+    "clarify",
+    "escalate",
+];

package/dist/index.d.ts

@@ -15,6 +15,8 @@ export { createAnthropicBrain } from "./brain/anthropic.js";
 export { createOllamaBrain } from "./brain/ollama.js";
 export { buildBrain } from "./brain/factory.js";
 export { parseDefinition } from "./definition/parser.js";
+export { createDelegateTool, DELEGATE_TOOL_NAME } from "./tools/delegate.js";
+export type { DelegateTool, DelegateToolOptions } from "./tools/delegate.js";
 export type { Agent, AgentConfig, AgentEvent, AgentContext, AgentDefinition, AgentHooks, BeforeToolHookResult, Brain, BrainChunk, BrainOrchestration, BrainPayload, BrainRunInput, BrainToolCall, ChunkInfo, CompactionDecision, CompactionPort, DocumentState, GateConfig, GuardConfig, GuardSignal, GuardSignalType, IterationInfo, LoopOutcome, MemoryEntry, Message, OutcomeType, OutputValidation, OutputValidator, RedisConfig, RunState, SectionInfo, SessionMetadata, SessionStore, TenantContext, Tool, ToolCallInfo, ToolDefinition, ToolMeta, ToolParameter, ToolResult, } from "./core/types.js";
 export type { ContextBudget } from "./core/context-builder.js";
 export { resolveGuards, DEFAULT_GUARDS } from "./core/guards.js";

package/dist/index.js

@@ -18,6 +18,8 @@ export { createOllamaBrain } from "./brain/ollama.js";
 export { buildBrain } from "./brain/factory.js";
 // ── Definition parser ───────────────────────────────────────────────────────
 export { parseDefinition } from "./definition/parser.js";
+// ── Delegation (ر٢) — one agent asks another, as an ordinary tool ───────────
+export { createDelegateTool, DELEGATE_TOOL_NAME } from "./tools/delegate.js";
 // ── Guard utilities ─────────────────────────────────────────────────────────
 export { resolveGuards, DEFAULT_GUARDS } from "./core/guards.js";
 // ── Quality scorer ──────────────────────────────────────────────────────────

package/dist/tools/delegate.d.ts

@@ -0,0 +1,134 @@
+/**
+ * Delegation — one agent asks another, as an ORDINARY TOOL (ر٢).
+ *
+ * ── Why a tool and not a loop action ────────────────────────────────────────
+ *
+ * `BrainOrchestration.action` used to carry a fifth member for routing work to
+ * another agent. It was declared at the beginning, dispatched on by nothing,
+ * and used by nobody — measured, not assumed: zero occurrences in the live
+ * consumer. Meanwhile that same consumer HAS been delegating in production for
+ * months, and it does it the other way round: a `call_agent` tool over an
+ * injected handle. The measurement settled the design argument, so the action
+ * was buried (`core/types.ts`) and this is the thing that replaces it.
+ *
+ * The consequence is the point of the whole exercise: **there is not one line
+ * of loop code here.** A delegation is a tool call, so it already goes through
+ * the parameter validation, the `onBeforeTool` approval gate, the dedup cache,
+ * the control-bus disable, the per-call `tool_call`/`tool_result` pair in the
+ * session log, the tool-call budget and the consecutive-failure counter —
+ * every one of them, for free, because it is not special. An action in the loop
+ * would have had to re-earn each of those, one `if` at a time, in the file
+ * every agent rides on.
+ *
+ * ── What this improves on the lifted original ───────────────────────────────
+ *
+ * Three things, each of them a rule this repo already pays for elsewhere:
+ *
+ *   1. **The child's session id is DERIVED, not random.** `parent.d.child`,
+ *      built from the parent's own id. The original minted a fresh UUID per
+ *      delegation, which is exactly the thing س٥ named the enemy of replay: an
+ *      arbitrary identifier kills every comparison that crosses a run — a tape
+ *      fingerprint, a golden log, a diff of two sessions that should be
+ *      identical. Derived, the same delegation twice is the same id twice, the
+ *      log reads `s-42.d.researcher` and says what it is, and the depth is
+ *      legible in the id instead of held in a side channel.
+ *
+ *   2. **The agent name is an `enum`, so the model cannot invent one.** The
+ *      brains forward `enum` into the provider schema (`toolParamsToJsonSchema`),
+ *      so this is a real constraint at the provider and not a hint. It is still
+ *      checked at execution — `validateParams` enforces presence and type, never
+ *      membership — and an unknown name is a NAMED failure the model can read
+ *      and correct, not a crash.
+ *
+ *   3. **The cost is visible.** The original returned the child's text and threw
+ *      the rest away, so a delegating agent's real spend was invisible to
+ *      everything that watched it. `totalCostUsd` rides back in the result.
+ *
+ * ── What is deliberately NOT here ───────────────────────────────────────────
+ *
+ *   • **The child's cost is not added to the parent's `totalCostUsd`.** It is
+ *     reported and left there. Both agents run their own budgets, and a number
+ *     counted in two places is worse than a number counted in one: it would
+ *     make the parent's cost cap fire on spend the child already paid for, and
+ *     the pair would then disagree about what the run cost. Raised for
+ *     management, not decided here.
+ *
+ *   • **No parent context is forwarded.** The child gets the message and its
+ *     tenant, and assembles its own persona, memories and tools. Handing it the
+ *     parent's `AgentContext` would make it a continuation of the parent rather
+ *     than a second agent — and `ToolMeta` does not carry one anyway.
+ */
+import type { Agent, Tool } from "../core/types.js";
+/**
+ * The tool's name, exported because consumers dispatch on it.
+ *
+ * An approval hook, an audit trail or a UI badge all need to recognise a
+ * delegation by name, and a hand-typed string in each of them is the drift س١
+ * was paid for. It is `call_agent` and not something new so that the consumer
+ * already running this pattern in production can swap its hand-rolled tool for
+ * this factory without changing a prompt, a manifest, or an approval rule.
+ */
+export declare const DELEGATE_TOOL_NAME = "call_agent";
+/** Tuning for `createDelegateTool`. Every field has a working default. */
+export interface DelegateToolOptions {
+    /**
+     * How many hops deep delegation may go. Default **1**: the agent you build
+     * may ask a delegate, and that delegate may not ask anyone.
+     *
+     * Measured off the CALLER's session id (`.d.` counted), not off a counter
+     * threaded through the call — so it cannot be lost, reset or lied about by a
+     * path that forgot to pass it on.
+     *
+     * `0` is a legitimate value and means "wired but switched off". Anything that
+     * is not a finite number ≥ 0 falls back to the default, in the spirit of
+     * `resolveGuards`: a typo must not silently remove a cap.
+     */
+    maxDepth?: number;
+    /**
+     * Stamped onto the tool, exactly as the MCP adapter stamps an MCP tool (ر١).
+     *
+     * That is the entire mechanism — there is no delegation-specific approval
+     * code, because `requiresApproval` is already a contract the executor fails
+     * closed on: set it with no `onBeforeTool` hook configured and the call is
+     * blocked before `execute` runs, which means blocked before the child agent
+     * is reached at all.
+     */
+    requiresApproval?: boolean;
+    /** Advisory metadata, mirroring `ToolDefinition`. See the note on `DelegateTool`. */
+    destructive?: boolean;
+    /** Advisory metadata, mirroring `ToolDefinition`. See the note on `DelegateTool`. */
+    category?: string;
+}
+/**
+ * A `Tool`, plus the two advisory fields mini's `Tool` does not carry.
+ *
+ * Shaped exactly like `McpTool` (ر١) and for the same reason: `ToolDefinition`
+ * declares `destructive` and `category`, `Tool` does not, and
+ * `toToolDefinitions` copies neither — so today they are carried and not yet
+ * read. That gap is already raised for management as the `toToolDefinitions`
+ * debt; this type is written to mirror the MCP stamp so that the day the debt
+ * is paid, both stamps start being read by the same change.
+ */
+export interface DelegateTool extends Tool {
+    destructive?: boolean;
+    category?: string;
+}
+/**
+ * Build the delegation tool for a set of named agents.
+ *
+ * ```ts
+ * const agent = createAgent({
+ *   definition, brain, redis,
+ *   tools: [searchTool, createDelegateTool({ researcher, drafter })],
+ * });
+ * ```
+ *
+ * The delegates are `mini` agents themselves — whatever `createAgent` returned,
+ * or anything else satisfying `Agent`. Nothing is constructed here and no
+ * connection is opened: this is a port like every other in the package, handed
+ * in at composition time.
+ *
+ * @param delegates agents this tool may call, by the name the model will use.
+ * @param opts      depth cap and the approval/metadata stamp.
+ */
+export declare function createDelegateTool(delegates: Record<string, Agent>, opts?: DelegateToolOptions): DelegateTool;

package/dist/tools/delegate.js

@@ -0,0 +1,223 @@
+/**
+ * Delegation — one agent asks another, as an ORDINARY TOOL (ر٢).
+ *
+ * ── Why a tool and not a loop action ────────────────────────────────────────
+ *
+ * `BrainOrchestration.action` used to carry a fifth member for routing work to
+ * another agent. It was declared at the beginning, dispatched on by nothing,
+ * and used by nobody — measured, not assumed: zero occurrences in the live
+ * consumer. Meanwhile that same consumer HAS been delegating in production for
+ * months, and it does it the other way round: a `call_agent` tool over an
+ * injected handle. The measurement settled the design argument, so the action
+ * was buried (`core/types.ts`) and this is the thing that replaces it.
+ *
+ * The consequence is the point of the whole exercise: **there is not one line
+ * of loop code here.** A delegation is a tool call, so it already goes through
+ * the parameter validation, the `onBeforeTool` approval gate, the dedup cache,
+ * the control-bus disable, the per-call `tool_call`/`tool_result` pair in the
+ * session log, the tool-call budget and the consecutive-failure counter —
+ * every one of them, for free, because it is not special. An action in the loop
+ * would have had to re-earn each of those, one `if` at a time, in the file
+ * every agent rides on.
+ *
+ * ── What this improves on the lifted original ───────────────────────────────
+ *
+ * Three things, each of them a rule this repo already pays for elsewhere:
+ *
+ *   1. **The child's session id is DERIVED, not random.** `parent.d.child`,
+ *      built from the parent's own id. The original minted a fresh UUID per
+ *      delegation, which is exactly the thing س٥ named the enemy of replay: an
+ *      arbitrary identifier kills every comparison that crosses a run — a tape
+ *      fingerprint, a golden log, a diff of two sessions that should be
+ *      identical. Derived, the same delegation twice is the same id twice, the
+ *      log reads `s-42.d.researcher` and says what it is, and the depth is
+ *      legible in the id instead of held in a side channel.
+ *
+ *   2. **The agent name is an `enum`, so the model cannot invent one.** The
+ *      brains forward `enum` into the provider schema (`toolParamsToJsonSchema`),
+ *      so this is a real constraint at the provider and not a hint. It is still
+ *      checked at execution — `validateParams` enforces presence and type, never
+ *      membership — and an unknown name is a NAMED failure the model can read
+ *      and correct, not a crash.
+ *
+ *   3. **The cost is visible.** The original returned the child's text and threw
+ *      the rest away, so a delegating agent's real spend was invisible to
+ *      everything that watched it. `totalCostUsd` rides back in the result.
+ *
+ * ── What is deliberately NOT here ───────────────────────────────────────────
+ *
+ *   • **The child's cost is not added to the parent's `totalCostUsd`.** It is
+ *     reported and left there. Both agents run their own budgets, and a number
+ *     counted in two places is worse than a number counted in one: it would
+ *     make the parent's cost cap fire on spend the child already paid for, and
+ *     the pair would then disagree about what the run cost. Raised for
+ *     management, not decided here.
+ *
+ *   • **No parent context is forwarded.** The child gets the message and its
+ *     tenant, and assembles its own persona, memories and tools. Handing it the
+ *     parent's `AgentContext` would make it a continuation of the parent rather
+ *     than a second agent — and `ToolMeta` does not carry one anyway.
+ */
+/**
+ * The tool's name, exported because consumers dispatch on it.
+ *
+ * An approval hook, an audit trail or a UI badge all need to recognise a
+ * delegation by name, and a hand-typed string in each of them is the drift س١
+ * was paid for. It is `call_agent` and not something new so that the consumer
+ * already running this pattern in production can swap its hand-rolled tool for
+ * this factory without changing a prompt, a manifest, or an approval rule.
+ */
+export const DELEGATE_TOOL_NAME = "call_agent";
+/**
+ * The marker that makes a delegated session id readable and countable.
+ *
+ * `parent.d.child` — one segment per hop, so the depth is `.d.` counted. It is
+ * `.d.` and not a bare `.` because a session id may legitimately contain dots,
+ * and a separator that ordinary ids collide with would count hops that never
+ * happened.
+ */
+const DEPTH_MARKER = ".d.";
+/** Delegation hops already taken to reach this session. A plain session is 0. */
+function delegationDepth(sessionId) {
+    return sessionId.split(DEPTH_MARKER).length - 1;
+}
+/** The child's session id: derived from the parent's, one hop deeper. */
+function childSessionId(parentSessionId, agentName) {
+    return `${parentSessionId}${DEPTH_MARKER}${agentName}`;
+}
+/** `maxDepth`, coerced. Non-finite or negative garbage falls back to the default. */
+function resolveMaxDepth(value) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0)
+        return 1;
+    return Math.floor(value);
+}
+/**
+ * Build the delegation tool for a set of named agents.
+ *
+ * ```ts
+ * const agent = createAgent({
+ *   definition, brain, redis,
+ *   tools: [searchTool, createDelegateTool({ researcher, drafter })],
+ * });
+ * ```
+ *
+ * The delegates are `mini` agents themselves — whatever `createAgent` returned,
+ * or anything else satisfying `Agent`. Nothing is constructed here and no
+ * connection is opened: this is a port like every other in the package, handed
+ * in at composition time.
+ *
+ * @param delegates agents this tool may call, by the name the model will use.
+ * @param opts      depth cap and the approval/metadata stamp.
+ */
+export function createDelegateTool(delegates, opts = {}) {
+    const names = Object.keys(delegates);
+    const maxDepth = resolveMaxDepth(opts.maxDepth);
+    const fail = (error) => ({
+        tool: DELEGATE_TOOL_NAME,
+        status: "failed",
+        error,
+    });
+    return {
+        name: DELEGATE_TOOL_NAME,
+        description: `Hand a subtask to another agent and get its answer back. ` +
+            `Available agents: ${names.join(", ") || "(none)"}.`,
+        parameters: {
+            agent: {
+                type: "string",
+                description: `Which agent to ask. One of: ${names.join(", ") || "(none)"}.`,
+                required: true,
+                // The list the provider itself enforces. It is also re-checked below:
+                // `validateParams` checks presence and type, never membership.
+                enum: names,
+            },
+            message: {
+                type: "string",
+                description: "The task to hand over, stated in full — the other agent sees none of this conversation.",
+                required: true,
+            },
+        },
+        ...(opts.requiresApproval !== undefined
+            ? { requiresApproval: opts.requiresApproval }
+            : {}),
+        ...(opts.destructive !== undefined ? { destructive: opts.destructive } : {}),
+        ...(opts.category !== undefined ? { category: opts.category } : {}),
+        async execute(args, meta) {
+            const agentName = String(args["agent"] ?? "");
+            const message = String(args["message"] ?? "");
+            // ── The depth cap, and it fails CLOSED ───────────────────────────────
+            //
+            // Checked before the name is even resolved, because the cheapest place to
+            // stop a runaway recursion is before it can name its next victim. The
+            // answer is a named `failed` result and not a thrown exception: a throw
+            // ends the step, while a result is something the model reads, understands
+            // and can act on — the same reasoning that makes an MCP `isError` a
+            // failed result rather than a throw.
+            //
+            // Two ways the count can read HIGH — an app whose own session ids contain
+            // `.d.`, or a delegate registered under a name containing it — and both
+            // err toward refusing to delegate. There is no input that makes it read
+            // low, which is the only direction that would matter.
+            const depth = delegationDepth(meta.sessionId);
+            if (depth >= maxDepth) {
+                return fail(`delegation depth exceeded: "${meta.sessionId}" is already ${depth} ` +
+                    `hop(s) deep and maxDepth is ${maxDepth}`);
+            }
+            // ── The name, re-checked here and not only in the schema ─────────────
+            const child = Object.prototype.hasOwnProperty.call(delegates, agentName)
+                ? delegates[agentName]
+                : undefined;
+            if (!child) {
+                return fail(`unknown agent "${agentName}" — available: ${names.join(", ") || "(none)"}`);
+            }
+            const sessionId = childSessionId(meta.sessionId, agentName);
+            // ── The child's event ────────────────────────────────────────────────
+            //
+            // The tenant rides across unchanged. "Whoever injects a store injects its
+            // isolation with it" (س١'s ruling) has a corollary here: a delegation
+            // that dropped the tenant would run the child UNSCOPED — writing to the
+            // bare prefix — and the isolation covenant would be broken by a tool
+            // rather than by a store. It is passed through exactly as received; this
+            // tool neither invents a tenant nor widens one.
+            const childEvent = {
+                sessionId,
+                message,
+                ...(meta.tenantContext ? { tenantContext: meta.tenantContext } : {}),
+            };
+            try {
+                const outcome = await child.handle(childEvent);
+                // `error` is the only outcome type that is a FAILURE of the delegation.
+                // `clarify`, `escalate` and a suppressed answer are all things the child
+                // successfully decided, and the model needs to see which one it got —
+                // hence `outcome` in the payload rather than a flattened string.
+                const failed = outcome.type === "error";
+                const result = {
+                    agent: agentName,
+                    sessionId,
+                    outcome: outcome.type,
+                    text: outcome.text ?? "",
+                    // Reported, never folded into the parent's total. See the header.
+                    totalCostUsd: outcome.metrics.totalCostUsd,
+                };
+                return {
+                    tool: DELEGATE_TOOL_NAME,
+                    status: failed ? "failed" : "ok",
+                    result,
+                    ...(failed
+                        ? {
+                            error: outcome.error ??
+                                outcome.text ??
+                                `agent "${agentName}" failed`,
+                        }
+                        : {}),
+                };
+            }
+            catch (err) {
+                // `handle` does its own catching and normally returns an error outcome
+                // rather than throwing — but it can still throw before its try block
+                // (resolving Redis, acquiring the session lock). One agent failing to
+                // start is this tool's failure, not the parent step's.
+                return fail(`agent "${agentName}" threw: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@msm-core/mini",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Portable AI agent execution loop — brain-agnostic, zero embedded databases",
   "type": "module",
   "main": "./dist/index.js",