@cuylabs/agent-core 4.9.0 → 5.0.0

package/dist/chunk-MJRZ2ZRI.js

@@ -0,0 +1,498 @@
+import {
+  accumulateUsage,
+  cloneUsage,
+  mergeAgentTurnStateProgress
+} from "./chunk-E66PKKDL.js";
+
+// src/execution/workflow/state.ts
+function cloneMessageSnapshot(message) {
+  return {
+    ...message,
+    ...message.role === "assistant" && message.toolCalls ? {
+      toolCalls: message.toolCalls.map((toolCall) => ({ ...toolCall }))
+    } : {},
+    ...message.role === "assistant" && message.tokens ? {
+      tokens: { ...message.tokens }
+    } : {},
+    ...message.role === "assistant" && message.error ? {
+      error: { ...message.error }
+    } : {},
+    ...message.role === "tool" && message.metadata ? {
+      metadata: structuredClone(message.metadata)
+    } : {},
+    ..."contextFragment" in message && message.contextFragment ? {
+      contextFragment: structuredClone(message.contextFragment)
+    } : {}
+  };
+}
+function createAgentWorkflowTurnState(options) {
+  const pendingInput = options.initialInput ? cloneMessageSnapshot(options.initialInput) : void 0;
+  return {
+    sessionId: options.sessionId,
+    turnId: options.turnId,
+    systemPrompts: [...options.systemPrompts ?? []],
+    messages: (options.initialMessages ?? []).map(cloneMessageSnapshot),
+    phase: pendingInput ? "input-commit" : "model-step",
+    ...pendingInput ? { pendingInput } : {},
+    step: options.initialStep ?? 1,
+    maxSteps: options.maxSteps,
+    replayDecisions: {},
+    startedAt: options.startedAt,
+    updatedAt: options.startedAt
+  };
+}
+function cloneAgentWorkflowTurnState(state) {
+  return {
+    ...state,
+    systemPrompts: [...state.systemPrompts],
+    messages: state.messages.map(cloneMessageSnapshot),
+    ...state.pendingInput ? {
+      pendingInput: cloneMessageSnapshot(
+        state.pendingInput
+      )
+    } : {},
+    ...state.usage ? { usage: cloneUsage(state.usage) } : {},
+    ...state.turnState ? { turnState: structuredClone(state.turnState) } : {},
+    ...state.lastModelStep ? { lastModelStep: structuredClone(state.lastModelStep) } : {},
+    ...state.lastContextCompaction ? { lastContextCompaction: structuredClone(state.lastContextCompaction) } : {},
+    replayDecisions: Object.fromEntries(
+      Object.entries(state.replayDecisions).map(([toolCallId, decision]) => [
+        toolCallId,
+        { ...decision }
+      ])
+    ),
+    ...state.pendingInterventions?.length ? {
+      pendingInterventions: state.pendingInterventions.map(
+        (intervention) => ({ ...intervention })
+      )
+    } : {},
+    ...state.queuedFollowUps?.length ? {
+      queuedFollowUps: state.queuedFollowUps.map((intervention) => ({
+        ...intervention
+      }))
+    } : {}
+  };
+}
+function applyWorkflowInterventions(state, interventions, updatedAt) {
+  if (interventions.length === 0) {
+    return state;
+  }
+  const injected = interventions.map(
+    (intervention) => ({
+      id: intervention.id,
+      role: "user",
+      createdAt: intervention.createdAt,
+      content: intervention.message
+    })
+  );
+  return {
+    ...state,
+    messages: [...state.messages, ...injected],
+    pendingInterventions: void 0,
+    updatedAt
+  };
+}
+function drainWorkflowInterventions(state, updatedAt) {
+  if (!state.pendingInterventions?.length) {
+    return state;
+  }
+  return applyWorkflowInterventions(
+    state,
+    state.pendingInterventions,
+    updatedAt
+  );
+}
+function queueWorkflowFollowUps(state, followUps, updatedAt) {
+  if (followUps.length === 0) {
+    return state;
+  }
+  return {
+    ...state,
+    queuedFollowUps: [
+      ...state.queuedFollowUps ?? [],
+      ...followUps.map((followUp) => ({ ...followUp }))
+    ],
+    updatedAt
+  };
+}
+
+// src/execution/workflow/snapshot.ts
+function snapshotAgentWorkflowMessage(message) {
+  switch (message.role) {
+    case "user":
+      return {
+        id: message.id,
+        role: "user",
+        createdAt: message.createdAt.toISOString(),
+        content: message.content,
+        ...message.contextFragment ? { contextFragment: structuredClone(message.contextFragment) } : {},
+        ...message.system ? { system: message.system } : {}
+      };
+    case "assistant":
+      return {
+        id: message.id,
+        role: "assistant",
+        createdAt: message.createdAt.toISOString(),
+        content: message.content,
+        ...message.finish ? { finish: message.finish } : {},
+        ...message.tokens ? { tokens: { ...message.tokens } } : {},
+        ...message.cost !== void 0 ? { cost: message.cost } : {},
+        ...message.error ? { error: { ...message.error } } : {},
+        ...message.toolCalls ? {
+          toolCalls: message.toolCalls.map((toolCall) => ({
+            toolCallId: toolCall.toolCallId,
+            toolName: toolCall.toolName,
+            args: toolCall.args
+          }))
+        } : {}
+      };
+    case "tool":
+      return {
+        id: message.id,
+        role: "tool",
+        createdAt: message.createdAt.toISOString(),
+        content: message.content,
+        toolCallId: message.toolCallId,
+        toolName: message.toolName,
+        result: message.result,
+        ...message.metadata ? { metadata: structuredClone(message.metadata) } : {},
+        ...message.compactedAt !== void 0 ? { compactedAt: message.compactedAt } : {}
+      };
+    case "system":
+      return {
+        id: message.id,
+        role: "system",
+        createdAt: message.createdAt.toISOString(),
+        content: message.content,
+        ...message.contextFragment ? { contextFragment: structuredClone(message.contextFragment) } : {}
+      };
+  }
+}
+function snapshotAgentWorkflowMessages(messages) {
+  return messages.map((message) => snapshotAgentWorkflowMessage(message));
+}
+function restoreAgentWorkflowMessage(snapshot) {
+  const createdAt = new Date(snapshot.createdAt);
+  switch (snapshot.role) {
+    case "user":
+      return {
+        id: snapshot.id,
+        role: "user",
+        createdAt,
+        content: snapshot.content,
+        ...snapshot.contextFragment ? { contextFragment: structuredClone(snapshot.contextFragment) } : {},
+        ...snapshot.system ? { system: snapshot.system } : {}
+      };
+    case "assistant":
+      return {
+        id: snapshot.id,
+        role: "assistant",
+        createdAt,
+        content: snapshot.content,
+        ...snapshot.finish ? { finish: snapshot.finish } : {},
+        ...snapshot.tokens ? { tokens: { ...snapshot.tokens } } : {},
+        ...snapshot.cost !== void 0 ? { cost: snapshot.cost } : {},
+        ...snapshot.error ? { error: { ...snapshot.error } } : {},
+        ...snapshot.toolCalls ? {
+          toolCalls: snapshot.toolCalls.map((toolCall) => ({
+            toolCallId: toolCall.toolCallId,
+            toolName: toolCall.toolName,
+            args: toolCall.args
+          }))
+        } : {}
+      };
+    case "tool":
+      return {
+        id: snapshot.id,
+        role: "tool",
+        createdAt,
+        content: snapshot.content,
+        toolCallId: snapshot.toolCallId,
+        toolName: snapshot.toolName,
+        result: snapshot.result,
+        ...snapshot.metadata ? { metadata: structuredClone(snapshot.metadata) } : {},
+        ...snapshot.compactedAt !== void 0 ? { compactedAt: snapshot.compactedAt } : {}
+      };
+    case "system":
+      return {
+        id: snapshot.id,
+        role: "system",
+        createdAt,
+        content: snapshot.content,
+        ...snapshot.contextFragment ? { contextFragment: structuredClone(snapshot.contextFragment) } : {}
+      };
+  }
+}
+function restoreAgentWorkflowMessages(snapshots) {
+  return snapshots.map(restoreAgentWorkflowMessage);
+}
+
+// src/execution/workflow/planner/helpers.ts
+function cloneRelevantReplayDecisions(state, snapshot) {
+  return Object.fromEntries(
+    snapshot.toolCalls.flatMap((toolCall) => {
+      const decision = state.replayDecisions[toolCall.toolCallId];
+      return decision ? [[toolCall.toolCallId, { ...decision }]] : [];
+    })
+  );
+}
+function findAllUnresolvedToolCalls(snapshot) {
+  const resolvedIds = new Set(
+    snapshot.toolResults.map((toolResult) => toolResult.toolCallId)
+  );
+  return snapshot.toolCalls.filter(
+    (toolCall) => !resolvedIds.has(toolCall.toolCallId)
+  );
+}
+
+// src/execution/workflow/planner/plan.ts
+function planNextAgentWorkflowOperation(state) {
+  switch (state.phase) {
+    case "input-commit":
+      if (!state.pendingInput) {
+        throw new Error(
+          `Workflow state for session '${state.sessionId}' is in input-commit phase without a pending input message`
+        );
+      }
+      return {
+        kind: "input-commit",
+        sessionId: state.sessionId,
+        messages: [structuredClone(state.pendingInput)]
+      };
+    case "model-step":
+      return {
+        kind: "model-step",
+        sessionId: state.sessionId,
+        turnId: state.turnId,
+        step: state.step,
+        maxSteps: state.maxSteps,
+        systemPrompts: [...state.systemPrompts],
+        messages: state.messages.map((message) => structuredClone(message)),
+        ...state.lastContextCompaction ? { contextCompaction: structuredClone(state.lastContextCompaction) } : {}
+      };
+    case "tool-batch": {
+      if (!state.lastModelStep?.stepCommit) {
+        throw new Error(
+          `Workflow state for session '${state.sessionId}' is in tool-batch phase without a stepCommit snapshot`
+        );
+      }
+      const allUnresolved = findAllUnresolvedToolCalls(
+        state.lastModelStep.stepCommit
+      );
+      if (allUnresolved.length === 0) {
+        throw new Error(
+          `Workflow state for session '${state.sessionId}' is in tool-batch phase without unresolved tool calls`
+        );
+      }
+      if (allUnresolved.length === 1) {
+        return {
+          kind: "tool-call",
+          step: state.step,
+          sessionId: state.sessionId,
+          toolCall: structuredClone(allUnresolved[0]),
+          turnState: state.turnState ? structuredClone(state.turnState) : void 0,
+          replayDecision: cloneRelevantReplayDecisions(
+            state,
+            state.lastModelStep.stepCommit
+          )[allUnresolved[0].toolCallId]
+        };
+      }
+      return {
+        kind: "tool-batch",
+        step: state.step,
+        sessionId: state.sessionId,
+        toolCalls: allUnresolved.map((tc) => structuredClone(tc)),
+        turnState: state.turnState ? structuredClone(state.turnState) : void 0,
+        replayDecisions: cloneRelevantReplayDecisions(
+          state,
+          state.lastModelStep.stepCommit
+        )
+      };
+    }
+    case "step-commit":
+      if (!state.lastModelStep?.stepCommit) {
+        throw new Error(
+          `Workflow state for session '${state.sessionId}' is in step-commit phase without a stepCommit snapshot`
+        );
+      }
+      return {
+        kind: "step-commit",
+        sessionId: state.sessionId,
+        step: state.step,
+        snapshot: structuredClone(state.lastModelStep.stepCommit)
+      };
+    case "output-commit":
+      if (!state.lastModelStep) {
+        throw new Error(
+          `Workflow state for session '${state.sessionId}' is in output-commit phase without a last model step`
+        );
+      }
+      return {
+        kind: "output-commit",
+        sessionId: state.sessionId,
+        text: state.lastModelStep.text,
+        ...state.lastModelStep.usage ? { usage: { ...state.lastModelStep.usage } } : {}
+      };
+    case "completed":
+    case "failed":
+      return void 0;
+  }
+}
+
+// src/execution/workflow/planner/apply.ts
+function applyAgentWorkflowContextCompactionResult(state, result, updatedAt) {
+  if (state.phase !== "model-step") {
+    throw new Error(
+      `Cannot apply context compaction while workflow state is in '${state.phase}' phase`
+    );
+  }
+  const next = cloneAgentWorkflowTurnState(state);
+  next.lastContextCompaction = {
+    applied: result.compacted,
+    phase: "pre-step",
+    inputTokens: result.inputTokens,
+    limit: result.limit,
+    decision: result.decision,
+    effectiveness: result.effectiveness,
+    removedCount: result.removedCount,
+    tokensRemoved: result.tokensRemoved,
+    summarized: result.summarized,
+    ...result.cutIndex !== void 0 ? { cutIndex: result.cutIndex } : {},
+    ...result.cutReason ? { cutReason: result.cutReason } : {}
+  };
+  if (result.compacted) {
+    next.messages = result.messages.map((message) => structuredClone(message));
+  }
+  next.updatedAt = updatedAt;
+  return next;
+}
+function applyAgentWorkflowModelStepResult(state, result, updatedAt) {
+  const next = cloneAgentWorkflowTurnState(state);
+  next.lastModelStep = structuredClone(result);
+  next.turnState = structuredClone(result.turnState);
+  next.usage = accumulateUsage(next.usage, result.usage);
+  next.updatedAt = updatedAt;
+  next.phase = result.finishReason === "tool-calls" ? "tool-batch" : "output-commit";
+  return next;
+}
+function applyAgentWorkflowToolBatchResult(state, result, updatedAt) {
+  if (state.phase !== "tool-batch") {
+    throw new Error(
+      `Cannot apply a tool-batch result while workflow state is in '${state.phase}' phase`
+    );
+  }
+  const next = cloneAgentWorkflowTurnState(state);
+  next.updatedAt = updatedAt;
+  next.phase = "step-commit";
+  if (!next.lastModelStep) {
+    throw new Error(
+      `Workflow state for session '${state.sessionId}' has no model step to update after tool-batch`
+    );
+  }
+  next.lastModelStep.stepCommit = structuredClone(result.stepCommit);
+  if (result.turnState) {
+    next.turnState = mergeAgentTurnStateProgress(
+      next.turnState,
+      result.turnState
+    );
+  }
+  return next;
+}
+function applyAgentWorkflowToolCallResult(state, result, updatedAt) {
+  if (state.phase !== "tool-batch") {
+    throw new Error(
+      `Cannot apply a tool-call result while workflow state is in '${state.phase}' phase`
+    );
+  }
+  if (!state.lastModelStep?.stepCommit) {
+    throw new Error(
+      `Workflow state for session '${state.sessionId}' has no stepCommit snapshot in tool-batch phase`
+    );
+  }
+  const next = cloneAgentWorkflowTurnState(state);
+  const snapshot = structuredClone(state.lastModelStep.stepCommit);
+  const existingResultIndex = snapshot.toolResults.findIndex(
+    (toolResult) => toolResult.toolCallId === result.toolResult.toolCallId
+  );
+  if (existingResultIndex >= 0) {
+    snapshot.toolResults[existingResultIndex] = structuredClone(
+      result.toolResult
+    );
+  } else {
+    snapshot.toolResults.push(structuredClone(result.toolResult));
+  }
+  next.lastModelStep = {
+    ...next.lastModelStep,
+    stepCommit: snapshot
+  };
+  next.updatedAt = updatedAt;
+  if (result.turnState) {
+    next.turnState = mergeAgentTurnStateProgress(
+      next.turnState,
+      result.turnState
+    );
+  }
+  next.phase = snapshot.toolResults.length >= snapshot.toolCalls.length ? "step-commit" : "tool-batch";
+  return next;
+}
+function applyAgentWorkflowCommitResult(state, result, updatedAt) {
+  const next = cloneAgentWorkflowTurnState(state);
+  next.messages = [
+    ...next.messages,
+    ...result.messages.map((message) => structuredClone(message))
+  ];
+  next.updatedAt = updatedAt;
+  switch (state.phase) {
+    case "input-commit":
+      next.phase = "model-step";
+      delete next.pendingInput;
+      return next;
+    case "step-commit":
+      next.step = state.step + 1;
+      next.phase = "model-step";
+      delete next.lastModelStep;
+      return next;
+    case "output-commit":
+      next.phase = "completed";
+      next.finalResponse = state.lastModelStep?.text ?? state.finalResponse;
+      delete next.lastModelStep;
+      return next;
+    default:
+      throw new Error(
+        `Cannot apply a commit result while workflow state is in '${state.phase}' phase`
+      );
+  }
+}
+function recordAgentWorkflowReplayDecision(state, decision, updatedAt) {
+  const next = cloneAgentWorkflowTurnState(state);
+  next.replayDecisions[decision.toolCallId] = { ...decision };
+  next.updatedAt = updatedAt;
+  return next;
+}
+function failAgentWorkflowTurnState(state, error, updatedAt) {
+  const next = cloneAgentWorkflowTurnState(state);
+  next.phase = "failed";
+  next.error = error.message;
+  next.updatedAt = updatedAt;
+  return next;
+}
+
+export {
+  createAgentWorkflowTurnState,
+  cloneAgentWorkflowTurnState,
+  applyWorkflowInterventions,
+  drainWorkflowInterventions,
+  queueWorkflowFollowUps,
+  snapshotAgentWorkflowMessage,
+  snapshotAgentWorkflowMessages,
+  restoreAgentWorkflowMessage,
+  restoreAgentWorkflowMessages,
+  planNextAgentWorkflowOperation,
+  applyAgentWorkflowContextCompactionResult,
+  applyAgentWorkflowModelStepResult,
+  applyAgentWorkflowToolBatchResult,
+  applyAgentWorkflowToolCallResult,
+  applyAgentWorkflowCommitResult,
+  recordAgentWorkflowReplayDecision,
+  failAgentWorkflowTurnState
+};

package/dist/{chunk-UMIVJDEJ.js → chunk-SAWRDGBE.js}

@@ -554,6 +554,35 @@ function describeFetchTarget(input, init) {
 }
 
 // src/mcp/auth.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function readOptionalString(data, key) {
+  const value = data[key];
+  return typeof value === "string" ? value : void 0;
+}
+function readOptionalNumber(data, key) {
+  const value = data[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function parseOAuthTokenResponse(data) {
+  if (!isRecord(data)) {
+    throw new Error("ClientCredentialsProvider: token response was not JSON.");
+  }
+  const accessToken = readOptionalString(data, "access_token");
+  if (!accessToken) {
+    throw new Error(
+      'ClientCredentialsProvider: token response missing "access_token".'
+    );
+  }
+  return {
+    access_token: accessToken,
+    token_type: readOptionalString(data, "token_type") ?? "bearer",
+    expires_in: readOptionalNumber(data, "expires_in"),
+    scope: readOptionalString(data, "scope"),
+    refresh_token: readOptionalString(data, "refresh_token")
+  };
+}
 var ClientCredentialsProvider = class {
   _tokens;
   _expiresAt;
@@ -658,13 +687,7 @@ var ClientCredentialsProvider = class {
       );
     }
     const json = await response.json();
-    const tokens = {
-      access_token: String(json.access_token),
-      token_type: String(json.token_type ?? "bearer"),
-      expires_in: typeof json.expires_in === "number" ? json.expires_in : void 0,
-      scope: typeof json.scope === "string" ? json.scope : void 0,
-      refresh_token: typeof json.refresh_token === "string" ? json.refresh_token : void 0
-    };
+    const tokens = parseOAuthTokenResponse(json);
     await this.saveTokens(tokens);
     return tokens;
   }

package/dist/chunk-TYQWH6XH.js

@@ -0,0 +1,88 @@
+import {
+  applyAgentContextFragmentsWithReport
+} from "./chunk-CGP6UNCQ.js";
+
+// src/context/assembly/prepare.ts
+var DEFAULT_CONTEXT_FRAGMENT_BUDGET_RATIO = 0.1;
+var DEFAULT_MAX_CONTEXT_FRAGMENT_ESTIMATED_TOKENS = 8e3;
+var DEFAULT_MIN_CONTEXT_FRAGMENT_ESTIMATED_TOKENS = 512;
+async function collectRequestedContextFragments(options) {
+  const explicitContextFragments = [...options.contextFragments ?? []];
+  const collector = options.contextFragmentCollector;
+  if (!collector || collector.hasMiddleware === false) {
+    return explicitContextFragments;
+  }
+  const collected = await collector.collectContextFragments({
+    sessionId: options.sessionId,
+    ...options.turnId ? { turnId: options.turnId } : {},
+    step: options.step,
+    cwd: options.cwd,
+    messages: options.messages,
+    toolNames: options.toolNames ?? [],
+    mcpToolNames: options.mcpToolNames ?? [],
+    ...options.abort ? { abort: options.abort } : {}
+  });
+  return [...explicitContextFragments, ...collected];
+}
+function normalizeMaxEstimatedTokens(value) {
+  if (value === void 0 || !Number.isFinite(value)) return void 0;
+  return Math.max(0, Math.floor(value));
+}
+function resolveContextFragmentBudget(options) {
+  const configuredMaxEstimatedTokens = normalizeMaxEstimatedTokens(
+    options.configured?.maxEstimatedTokens
+  );
+  if (configuredMaxEstimatedTokens !== void 0) {
+    return { maxEstimatedTokens: configuredMaxEstimatedTokens };
+  }
+  if (!options.windowBefore) return void 0;
+  const proportional = Math.floor(
+    options.windowBefore.limit * DEFAULT_CONTEXT_FRAGMENT_BUDGET_RATIO
+  );
+  return {
+    maxEstimatedTokens: Math.min(
+      DEFAULT_MAX_CONTEXT_FRAGMENT_ESTIMATED_TOKENS,
+      Math.max(DEFAULT_MIN_CONTEXT_FRAGMENT_ESTIMATED_TOKENS, proportional)
+    )
+  };
+}
+async function assembleModelContext(options) {
+  const baseMessages = [...options.messages];
+  const windowBefore = options.window?.getStats(baseMessages);
+  const requestedContextFragments = await collectRequestedContextFragments(options);
+  const contextFragmentBudget = resolveContextFragmentBudget({
+    configured: options.contextFragmentBudget,
+    windowBefore
+  });
+  const tokenEstimator = options.window?.getTokenEstimator?.();
+  const contextFragmentResult = applyAgentContextFragmentsWithReport(
+    baseMessages,
+    requestedContextFragments,
+    {
+      ...contextFragmentBudget ? { budget: contextFragmentBudget } : {},
+      ...tokenEstimator ? { tokenEstimator } : {}
+    }
+  );
+  const messages = contextFragmentResult.messages;
+  const windowAfter = options.window?.getStats(messages);
+  const report = {
+    sessionId: options.sessionId,
+    ...options.turnId ? { turnId: options.turnId } : {},
+    step: options.step,
+    messages: {
+      inputCount: baseMessages.length,
+      outputCount: messages.length
+    },
+    contextFragments: contextFragmentResult.report,
+    window: {
+      ...windowBefore ? { before: windowBefore } : {},
+      ...windowAfter ? { after: windowAfter } : {}
+    },
+    ...options.compaction ? { compaction: options.compaction } : {}
+  };
+  return { messages, report };
+}
+
+export {
+  assembleModelContext
+};

package/dist/{chunk-QJV5XPPS.js → chunk-UEEHZ4QH.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-SZ2XBPTW.js";
 import {
   Tool
-} from "./chunk-Q742PSH3.js";
+} from "./chunk-MJML3A2F.js";
 import {
   extractApprovalPatterns,
   matchApprovalPattern,

package/dist/chunk-UG5PVNZV.js

@@ -0,0 +1,53 @@
+// src/events/signal/local.ts
+var LocalSignal = class {
+  /** type → Set<handler> for typed subscriptions */
+  typed = /* @__PURE__ */ new Map();
+  /** handlers that receive every event */
+  wildcard = /* @__PURE__ */ new Set();
+  on(type, handler) {
+    let set = this.typed.get(type);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.typed.set(type, set);
+    }
+    const wrapped = (event) => {
+      handler(event);
+    };
+    set.add(wrapped);
+    return () => {
+      set.delete(wrapped);
+      if (set.size === 0) this.typed.delete(type);
+    };
+  }
+  onAny(handler) {
+    this.wildcard.add(handler);
+    return () => {
+      this.wildcard.delete(handler);
+    };
+  }
+  emit(event) {
+    const set = this.typed.get(event.type);
+    if (set) {
+      for (const fn of set) {
+        try {
+          fn(event);
+        } catch {
+        }
+      }
+    }
+    for (const fn of this.wildcard) {
+      try {
+        fn(event);
+      } catch {
+      }
+    }
+  }
+  clear() {
+    this.typed.clear();
+    this.wildcard.clear();
+  }
+};
+
+export {
+  LocalSignal
+};