@roackb2/heddle 0.0.7 → 0.0.9

package/README.md

@@ -1,10 +1,14 @@
 # Heddle
 
-Heddle is a terminal coding agent runtime and CLI.
+Heddle is a terminal coding agent runtime and CLI with optional semantic drift detection.
 
 It is built to feel like a terminal partner that understands your project, keeps continuity across real work, and becomes more useful over time.
 
-It is open source, provider-agnostic, supports OpenAI and Anthropic models, and can build memory across sessions.
+It is open source, provider-agnostic, supports OpenAI and Anthropic models, and can build memory across sessions. For agentic-system builders, Heddle also exposes heartbeat primitives for autonomous wake cycles, checkpointing, and long-running background work.
+
+Heddle is designed to make live agent runs more observable, not just easier to launch. With optional semantic drift detection, Heddle can show whether an agent appears to be going off track based on its recent trajectory, surface `drift=unknown|low|medium|high` in chat, and write drift annotations into saved traces instead of leaving you to infer that only from token usage and tool calls.
+
+If you are interested in the underlying methodology, Heddle's drift telemetry is powered by [CyberLoop on npm](https://www.npmjs.com/package/cyberloop). See the [CyberLoop repository](https://github.com/roackb2/cyberloop) and [paper](https://zenodo.org/records/18138161) for the geometric-control and trajectory-based details.
 
 ## How Heddle Helps
 
@@ -17,7 +21,12 @@ It is open source, provider-agnostic, supports OpenAI and Anthropic models, and
 
 ## Advanced Capabilities
 
+- optional CyberLoop-powered semantic drift detection in chat and traces with `/drift on`
 - provider-agnostic model support across OpenAI and Anthropic
+- embeddable `runAgentLoop` API for building non-CLI agent hosts
+- `runAgentHeartbeat` for scheduler-driven autonomous wake cycles without chat by default
+- serializable checkpoints for resume, background execution, and hosted workers
+- CyberLoop-compatible observer hooks for host-side runtime instrumentation
 - provider-backed hosted web search through `web_search`
 - local image viewing from referenced file paths through `view_image`
 - inline `@file` mentions that tell the agent which workspace files to inspect first
@@ -44,6 +53,22 @@ npx @roackb2/heddle
 
 The installed CLI command remains `heddle`.
 
+If you want optional CyberLoop drift telemetry in chat with `/drift on`, or you want to import `cyberloop/advanced` in your own host, install `cyberloop` in the same environment as Heddle:
+
+```bash
+npm install -g cyberloop
+# or for project-local usage
+npm install cyberloop
+```
+
+The plain `npx @roackb2/heddle` path does not include optional peer dependencies. For one-off drift-enabled usage, install both packages locally or run:
+
+```bash
+npx -p @roackb2/heddle -p cyberloop heddle
+```
+
+If you are developing inside the Heddle repo itself, `yarn install` also installs `cyberloop` through `devDependencies`, so `yarn chat:dev` can use the published package path without extra setup.
+
 ## Quick Start
 
 1. Set an API key for a supported provider.
@@ -85,6 +110,10 @@ Heddle currently supports:
 - automatic conversation compaction so longer chats preserve context instead of growing unbounded
 - manual `/compact` to shrink the current session transcript on demand
 - persistent workspace memory notes under `.heddle/memory/`
+- autonomous heartbeat wake cycles through `runAgentHeartbeat`
+- serializable run checkpoints for programmatic hosts and later continuation
+- passive CyberLoop-compatible observation through `createCyberLoopObserver`
+- optional chat-mode CyberLoop semantic drift telemetry with `/drift on`
 - short working-plan support through `update_plan` for substantial multi-step tasks
 - remembered per-project approvals for repeated commands and edits
 - interrupt and resume support for longer-running coding workflows
@@ -98,6 +127,51 @@ The planning workflow is also intentionally lightweight: Heddle does not force a
 
 The web-search workflow is provider-backed rather than crawler-backed: OpenAI models use OpenAI-hosted web search, and Anthropic models use Anthropic-hosted web search when available through the selected model/tool path.
 
+The CyberLoop workflow is observe-only. When `/drift on` is enabled, Heddle loads real [CyberLoop](https://www.npmjs.com/package/cyberloop) kinematics middleware, embeds runtime frames with OpenAI embeddings, shows `drift=unknown|low|medium|high` in the footer, and writes `cyberloop.annotation` events into saved traces. The toggle is saved on the active chat session, and `/drift` reports the last unavailable reason if the middleware or embeddings fail. Heddle does not calculate semantic drift itself. For the underlying methodology, see the [CyberLoop repository](https://github.com/roackb2/cyberloop) and [paper](https://zenodo.org/records/18138161).
+
+## Heartbeat
+
+Heddle exposes `runAgentHeartbeat` for autonomous, scheduler-driven agent work.
+
+Heartbeat is not an interactive chat mode. It is a host/runtime primitive for systems that want to wake an agent periodically, let it work within budget and approval limits, checkpoint the result, and decide what should happen next.
+
+A heartbeat wake cycle:
+
+- loads a durable task plus an optional checkpoint
+- resumes prior transcript state if available
+- lets the agent do bounded useful work without a human prompt
+- checkpoints the new state
+- returns a decision: `continue`, `pause`, `complete`, or `escalate`
+
+This is intended for hosted workers, local schedulers, long-running agents, and systems like agent social platforms where agents need to keep working over time without staying in a live chat session.
+
+Heartbeat uses a larger default step budget than ordinary short chat runs so a wake cycle has room to inspect, act, and checkpoint. Hosts can still pass `maxSteps` when they need stricter control.
+
+Try a small local heartbeat example:
+
+```bash
+export OPENAI_API_KEY=your_key_here
+yarn example:heartbeat
+```
+
+The example stores its checkpoint at `.heddle/examples/heartbeat-demo-checkpoint.json`, so running it again resumes from the previous wake cycle.
+
+For hosts that want storage handled by Heddle, use `runStoredHeartbeat` with a checkpoint store:
+
+```ts
+import { createFileHeartbeatCheckpointStore, runStoredHeartbeat } from '@roackb2/heddle'
+
+const result = await runStoredHeartbeat({
+  task: 'Keep this project moving when safe autonomous progress is available',
+  store: createFileHeartbeatCheckpointStore({
+    path: '.heddle/heartbeat/project-maintenance.json',
+  }),
+})
+
+// result.nextDelayMs is a scheduling hint. The host still owns the timer,
+// cron job, queue, worker, or hosted scheduler that wakes the agent again.
+```
+
 ## Knowledge Persistence
 
 Heddle can maintain durable workspace knowledge under `.heddle/memory/`.
@@ -180,6 +254,9 @@ Useful chat commands:
 - `/session close <id>`: remove a saved session
 - `/clear`: clear the current transcript
 - `/compact`: compact older session history immediately
+- `/drift`: show CyberLoop semantic drift detection status
+- `/drift on`: enable observe-only CyberLoop kinematics telemetry for chat runs
+- `/drift off`: disable CyberLoop semantic drift detection
 - `!<command>`: run a shell command directly in chat
 
 Direct shell in chat:
@@ -194,6 +271,14 @@ Read-oriented commands stay in inspect mode when possible. Workspace-changing or
 
 Chat state is stored under `.heddle/`, including saved sessions, traces, approvals, and memory notes. The footer context indicator is an estimate of total request input against the active model's context window, not only the raw chat history length.
 
+For local development against the sibling CyberLoop repo, run chat with the middleware module path:
+
+```bash
+HEDDLE_CYBERLOOP_ADVANCED_MODULE=/Users/roackb2/Studio/projects/CyberLoop/src/advanced/kinematics-middleware.ts yarn chat:dev:openai
+```
+
+Then use `/drift on` before asking Heddle to do real work. For installed usage, install the optional `cyberloop` peer dependency in the same environment as Heddle so it can dynamically import `cyberloop/advanced`.
+
 ## CLI Usage
 
 Supported commands:
@@ -274,9 +359,102 @@ Field notes:
 
 ## Programmatic Use
 
-The npm package also exports the core runtime pieces for programmatic use, including:
+The npm package exports a programmatic execution loop for building other agent hosts on top of Heddle.
+
+Use `runAgentLoop` when you want Heddle to assemble the model adapter, default tool bundle, memory tools, and event stream:
+
+```ts
+import { runAgentLoop } from '@roackb2/heddle'
+
+const result = await runAgentLoop({
+  goal: 'Inspect this repo and summarize the main architecture',
+  model: 'gpt-5.1-codex',
+  workspaceRoot: process.cwd(),
+  onEvent(event) {
+    // Render progress, persist traces, feed middleware, or bridge into another app.
+    console.log(event.type)
+  },
+})
+```
+
+Persist `result.state` or wrap it with `createAgentLoopCheckpoint(result.state)` when another host needs to continue later:
+
+```ts
+import { createAgentLoopCheckpoint, runAgentLoop } from '@roackb2/heddle'
+
+const checkpoint = createAgentLoopCheckpoint(result.state)
+
+await runAgentLoop({
+  goal: 'Continue from the prior run and identify the next action',
+  resumeFrom: checkpoint,
+})
+```
+
+The loop emits structured events for:
+
+- loop start and finish
+- assistant streaming updates
+- trace events such as tool calls, tool results, approvals, and final outcome
+
+The returned result also includes a serializable `state` object with the model, provider, workspace root, outcome, transcript, trace, usage, and timestamps. This is the boundary future hosts can persist for background execution, dashboards, middleware, or heartbeat-style continuation.
+
+For passive semantic-drift experiments, `createCyberLoopObserver` can consume Heddle's event stream and run CyberLoop-compatible middleware over normalized runtime frames:
+
+```ts
+import {
+  createCyberLoopObserver,
+  createRuntimeFrameEmbedder,
+  runAgentLoop,
+} from '@roackb2/heddle'
+import { kinematicsMiddleware } from 'cyberloop/advanced'
+
+const frameEmbedder = createRuntimeFrameEmbedder({
+  async embedText(text) {
+    return embedWithYourProvider(text)
+  },
+})
+
+const observer = createCyberLoopObserver({
+  middleware: [
+    kinematicsMiddleware({
+      embedder: frameEmbedder,
+      goalEmbedding: await embedWithYourProvider('Investigate this repo'),
+    }),
+  ],
+  onAnnotation(annotation) {
+    console.log(annotation.driftLevel, annotation.frame.kind)
+  },
+})
+
+await runAgentLoop({
+  goal: 'Investigate this repo',
+  onEvent: observer.handleEvent,
+})
+await observer.flush()
+```
+
+This is intentionally observe-only. Heddle still owns execution, tools, approvals, and checkpoints; CyberLoop-style middleware can annotate the run without steering or halting it. Heddle does not calculate semantic drift itself; actual drift signals should come from CyberLoop metadata such as kinematics, manifold, or Grassmannian channels.
+
+For autonomous background work, `runAgentHeartbeat` runs one wake cycle from a durable task and optional checkpoint:
+
+```ts
+import { runAgentHeartbeat } from '@roackb2/heddle'
+
+const heartbeat = await runAgentHeartbeat({
+  task: 'Check whether there is safe maintenance work to do for this project',
+  checkpoint,
+  maxSteps: 8,
+})
+
+// Persist heartbeat.checkpoint, then schedule the next wake based on heartbeat.decision.
+```
+
+Heartbeat is not chat by default. It is meant for scheduler-driven agents that wake up, reload state, do bounded autonomous work, checkpoint, and either continue, pause, complete, or escalate.
+
+Lower-level pieces are still exported for custom hosts, including:
 
 - `runAgent`
+- `createDefaultAgentTools`
 - LLM adapter helpers
 - built-in tools
 - trace utilities
@@ -287,6 +465,32 @@ Install as a dependency with:
 npm install @roackb2/heddle
 ```
 
+If you want CyberLoop middleware examples or chat drift telemetry, install the optional peer dependency in the same project:
+
+```bash
+npm install cyberloop
+```
+
+For a small real-LLM example of embedding the loop with a custom host tool:
+
+```bash
+export OPENAI_API_KEY=your_key_here
+yarn example:programmatic
+```
+
+To try the same example with Claude:
+
+```bash
+export ANTHROPIC_API_KEY=your_key_here
+HEDDLE_EXAMPLE_MODEL=claude-3-5-haiku-latest yarn example:programmatic
+```
+
+For a small no-network observer example:
+
+```bash
+yarn example:cyberloop-observer
+```
+
 The public API lives in [src/index.ts](/Users/roackb2/Studio/projects/ProjectHeddle/heddle/src/index.ts).
 
 ## Design Direction

package/dist/examples/cyberloop-observer.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cyberloop-observer.d.ts.map

package/dist/examples/cyberloop-observer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cyberloop-observer.d.ts","sourceRoot":"","sources":["../../examples/cyberloop-observer.ts"],"names":[],"mappings":""}

package/dist/examples/cyberloop-observer.js

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+import { createCyberLoopObserver, runAgentLoop, } from '../src/index.js';
+const createMockLlm = () => {
+    let turn = 0;
+    return {
+        info: {
+            provider: 'openai',
+            model: 'gpt-demo',
+            capabilities: {
+                toolCalls: true,
+                systemMessages: true,
+                reasoningSummaries: false,
+                parallelToolCalls: true,
+            },
+        },
+        async chat() {
+            turn++;
+            if (turn === 1) {
+                return {
+                    content: 'I will inspect the project before answering.',
+                    toolCalls: [{ id: 'call-1', tool: 'inspect', input: { target: 'README.md' } }],
+                };
+            }
+            return { content: 'The project is a terminal coding agent runtime.' };
+        },
+    };
+};
+const inspectTool = {
+    name: 'inspect',
+    description: 'Demo inspection tool.',
+    parameters: {
+        type: 'object',
+        properties: { target: { type: 'string' } },
+        required: ['target'],
+    },
+    async execute(input) {
+        return { ok: true, output: `inspected ${JSON.stringify(input)}` };
+    },
+};
+/**
+ * This is intentionally only CyberLoop-compatible. In a real integration,
+ * callers can pass actual middleware from `cyberloop` or `cyberloop/advanced`.
+ */
+const demoDriftMiddleware = {
+    name: 'demo-drift',
+    async beforeStep(ctx) {
+        const isToolFailure = ctx.state.kind === 'tool' && ctx.state.ok === false;
+        return {
+            ...ctx,
+            metadata: {
+                ...ctx.metadata,
+                kinematics: {
+                    isStable: !isToolFailure,
+                    correctionMagnitude: isToolFailure ? 1 : 0,
+                },
+            },
+        };
+    },
+};
+async function main() {
+    const observer = createCyberLoopObserver({
+        middleware: [demoDriftMiddleware],
+        onAnnotation(annotation) {
+            console.log(`[cyberloop] step=${annotation.step} kind=${annotation.frame.kind} drift=${annotation.driftLevel}`);
+        },
+    });
+    const result = await runAgentLoop({
+        goal: 'What does this project do?',
+        llm: createMockLlm(),
+        tools: [inspectTool],
+        includeDefaultTools: false,
+        maxSteps: 3,
+        onEvent: observer.handleEvent,
+    });
+    await observer.flush();
+    console.log(`\nFinal answer:\n${result.summary}`);
+}
+await main();
+//# sourceMappingURL=cyberloop-observer.js.map

package/dist/examples/cyberloop-observer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cyberloop-observer.js","sourceRoot":"","sources":["../../examples/cyberloop-observer.ts"],"names":[],"mappings":";AACA,OAAO,EACL,uBAAuB,EACvB,YAAY,GAMb,MAAM,iBAAiB,CAAC;AAEzB,MAAM,aAAa,GAAG,GAAe,EAAE;IACrC,IAAI,IAAI,GAAG,CAAC,CAAC;IACb,OAAO;QACL,IAAI,EAAE;YACJ,QAAQ,EAAE,QAAQ;YAClB,KAAK,EAAE,UAAU;YACjB,YAAY,EAAE;gBACZ,SAAS,EAAE,IAAI;gBACf,cAAc,EAAE,IAAI;gBACpB,kBAAkB,EAAE,KAAK;gBACzB,iBAAiB,EAAE,IAAI;aACxB;SACF;QACD,KAAK,CAAC,IAAI;YACR,IAAI,EAAE,CAAC;YACP,IAAI,IAAI,KAAK,CAAC,EAAE,CAAC;gBACf,OAAO;oBACL,OAAO,EAAE,8CAA8C;oBACvD,SAAS,EAAE,CAAC,EAAE,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,EAAE,MAAM,EAAE,WAAW,EAAE,EAAE,CAAC;iBAC/E,CAAC;YACJ,CAAC;YACD,OAAO,EAAE,OAAO,EAAE,iDAAiD,EAAE,CAAC;QACxE,CAAC;KACF,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,WAAW,GAAmB;IAClC,IAAI,EAAE,SAAS;IACf,WAAW,EAAE,uBAAuB;IACpC,UAAU,EAAE;QACV,IAAI,EAAE,QAAQ;QACd,UAAU,EAAE,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE;QAC1C,QAAQ,EAAE,CAAC,QAAQ,CAAC;KACrB;IACD,KAAK,CAAC,OAAO,CAAC,KAAK;QACjB,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,aAAa,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,EAAE,CAAC;IACpE,CAAC;CACF,CAAC;AAEF;;;GAGG;AACH,MAAM,mBAAmB,GAAsD;IAC7E,IAAI,EAAE,YAAY;IAClB,KAAK,CAAC,UAAU,CAAC,GAAG;QAClB,MAAM,aAAa,GAAG,GAAG,CAAC,KAAK,CAAC,IAAI,KAAK,MAAM,IAAI,GAAG,CAAC,KAAK,CAAC,EAAE,KAAK,KAAK,CAAC;QAC1E,OAAO;YACL,GAAG,GAAG;YACN,QAAQ,EAAE;gBACR,GAAG,GAAG,CAAC,QAAQ;gBACf,UAAU,EAAE;oBACV,QAAQ,EAAE,CAAC,aAAa;oBACxB,mBAAmB,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;iBAC3C;aACF;SACF,CAAC;IACJ,CAAC;CACF,CAAC;AAEF,KAAK,UAAU,IAAI;IACjB,MAAM,QAAQ,GAAG,uBAAuB,CAAC;QACvC,UAAU,EAAE,CAAC,mBAAmB,CAAC;QACjC,YAAY,CAAC,UAAU;YACrB,OAAO,CAAC,GAAG,CAAC,oBAAoB,UAAU,CAAC,IAAI,SAAS,UAAU,CAAC,KAAK,CAAC,IAAI,UAAU,UAAU,CAAC,UAAU,EAAE,CAAC,CAAC;QAClH,CAAC;KACF,CAAC,CAAC;IAEH,MAAM,MAAM,GAAG,MAAM,YAAY,CAAC;QAChC,IAAI,EAAE,4BAA4B;QAClC,GAAG,EAAE,aAAa,EAAE;QACpB,KAAK,EAAE,CAAC,WAAW,CAAC;QACpB,mBAAmB,EAAE,KAAK;QAC1B,QAAQ,EAAE,CAAC;QACX,OAAO,EAAE,QAAQ,CAAC,WAAW;KAC9B,CAAC,CAAC;IACH,MAAM,QAAQ,CAAC,KAAK,EAAE,CAAC;IAEvB,OAAO,CAAC,GAAG,CAAC,oBAAoB,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC;AACpD,CAAC;AAED,MAAM,IAAI,EAAE,CAAC"}

package/dist/examples/heartbeat.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=heartbeat.d.ts.map

package/dist/examples/heartbeat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"heartbeat.d.ts","sourceRoot":"","sources":["../../examples/heartbeat.ts"],"names":[],"mappings":""}

package/dist/examples/heartbeat.js

@@ -0,0 +1,61 @@
+// ---------------------------------------------------------------------------
+// Example: Heartbeat
+//
+// Usage:
+//   OPENAI_API_KEY=sk-... yarn example:heartbeat
+//
+// Optional:
+//   HEDDLE_EXAMPLE_MODEL=claude-3-5-haiku-latest ANTHROPIC_API_KEY=sk-ant-... yarn example:heartbeat
+//
+// This demonstrates one scheduler-style heartbeat wake cycle. It loads a local
+// checkpoint if one exists, wakes the agent without a chat message, lets it work
+// within a small step budget, then persists the next checkpoint.
+// ---------------------------------------------------------------------------
+import { join } from 'node:path';
+import { inferProviderFromModel } from '../src/llm/providers.js';
+import { resolveProviderApiKey } from '../src/runtime/api-keys.js';
+import { createFileHeartbeatCheckpointStore, runStoredHeartbeat } from '../src/runtime/heartbeat-store.js';
+const DEFAULT_EXAMPLE_MODEL = 'gpt-5.1-codex-mini';
+const CHECKPOINT_PATH = join(process.cwd(), '.heddle', 'examples', 'heartbeat-demo-checkpoint.json');
+async function main() {
+    const model = process.env.HEDDLE_EXAMPLE_MODEL ?? process.env.OPENAI_MODEL ?? DEFAULT_EXAMPLE_MODEL;
+    const provider = inferProviderFromModel(model);
+    const apiKey = resolveProviderApiKey(provider);
+    if (!apiKey) {
+        throw new Error(`Missing API key for ${provider}. ` +
+            'Set OPENAI_API_KEY for OpenAI models or ANTHROPIC_API_KEY for Claude models before running this example.');
+    }
+    const store = createFileHeartbeatCheckpointStore({ path: CHECKPOINT_PATH });
+    const result = await runStoredHeartbeat({
+        store,
+        task: 'Check whether there is useful autonomous work to do for this demo. No tools are available in this demo wake cycle. If no external task is available, explain that this wake cycle should pause.',
+        model,
+        apiKey,
+        tools: [],
+        includeDefaultTools: false,
+        workspaceRoot: process.cwd(),
+        onEvent(event) {
+            if (event.type === 'loop.started') {
+                console.log(`[event] heartbeat.started model=${event.model} provider=${event.provider}`);
+            }
+            if (event.type === 'trace' && event.event.type === 'tool.call') {
+                console.log(`[trace] tool.call step=${event.event.step} tool=${event.event.call.tool}`);
+            }
+            if (event.type === 'loop.finished') {
+                console.log(`[event] heartbeat.finished outcome=${event.outcome} trace=${event.state.trace.length}`);
+            }
+        },
+    });
+    console.log('\nHeartbeat result:\n');
+    console.log(`loadedCheckpoint=${result.loadedCheckpoint}`);
+    console.log(`decision=${result.decision}`);
+    console.log(`nextDelayMs=${result.nextDelayMs ?? 'none'}`);
+    console.log(`summary=${result.summary}`);
+    console.log(`checkpoint=${CHECKPOINT_PATH}`);
+    process.exit(0);
+}
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});
+//# sourceMappingURL=heartbeat.js.map

package/dist/examples/heartbeat.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"heartbeat.js","sourceRoot":"","sources":["../../examples/heartbeat.ts"],"names":[],"mappings":"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"}

package/dist/examples/host-events.d.ts

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+/**
+ * Host Events Example
+ *
+ * Demonstrates how to consume Heddle's structured event stream for:
+ * - Real-time progress monitoring
+ * - Tool execution tracking
+ * - Checkpoint persistence
+ * - Escalation routing (for CyberLoop/Lucid integration)
+ *
+ * Usage:
+ *   HEDDLE_EXAMPLE_MODEL=gpt-5.1-codex-mini npx tsx examples/host-events.ts
+ */
+export {};
+//# sourceMappingURL=host-events.d.ts.map

package/dist/examples/host-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"host-events.d.ts","sourceRoot":"","sources":["../../examples/host-events.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;GAWG"}