@ltm-alpha/alpha-cs 1.6.0

package/dist/bin/command-supervision.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Process supervision for long-running CLI commands (`index` / `init --index`).
+ *
+ * Indexing a large repo can run for a while on the main thread, and #999
+ * surfaced two ways that goes wrong when nothing is watching it:
+ *
+ *   1. **Orphaned worker.** `index` runs in a child re-exec'd with
+ *      `--liftoff-only` (the WASM-flag relaunch). Its parent blocks in
+ *      `spawnSync`, so when the parent shim is killed it cannot forward the
+ *      signal — the child keeps running, now orphaned, pinning a core. The PPID
+ *      watchdog (#277) notices the parent/host went away and exits the child.
+ *   2. **Wedged indexer.** The `#850` main-thread liveness watchdog — which
+ *      SIGKILLs a process whose event loop stops turning — was wired only into
+ *      the MCP `serve` path, so a wedged `index`/`init` was never auto-killed.
+ *
+ * Both reuse the exact mechanisms `serve` already uses; this just makes them
+ * available to a one-shot command. Best-effort and self-disabling: a missing
+ * watchdog never blocks the command from running. Both honour the same env
+ * switches as `serve` (`CODEGRAPH_NO_WATCHDOG`, `CODEGRAPH_PPID_POLL_MS=0`).
+ *
+ * Unlike the daemon — whose main thread only does fast, bounded work — the
+ * `index`/`init` path runs reference resolution and dynamic-edge synthesis
+ * SYNCHRONOUSLY on this thread, and on a large repo that is legitimately many
+ * seconds of work. So those spans yield cooperatively to the event loop
+ * (`src/resolution/cooperative-yield.ts`) to keep the heartbeat alive; without
+ * that the watchdog would SIGKILL a valid, in-progress index (#1091). The
+ * distinction it must preserve — kill a TRUE wedge, spare slow-but-progressing
+ * work — is exactly what cooperative yielding buys: a genuinely stuck span never
+ * reaches its next yield, so it still trips the timeout.
+ */
+import { WatchdogOptions } from '../mcp/liveness-watchdog';
+export interface CommandSupervision {
+    /** Tear down both watchdogs. Idempotent; call when the command finishes. */
+    stop(): void;
+}
+/**
+ * Install the liveness + PPID watchdogs for the duration of a CLI command.
+ * `label` is used in the shutdown notice (e.g. `"index"`). Returns a handle
+ * whose `stop()` must be called when the command completes so neither watchdog
+ * outlives it.
+ *
+ * Pass `watchdog.progressPaths` (the project's SQLite DB + `-wal`) so the
+ * liveness watchdog can tell a slow-but-progressing store on degraded storage
+ * (files advancing) from a true wedge (they aren't) — one long synchronous
+ * SQLite statement on a 150-IOPS disk otherwise gets a healthy index
+ * SIGKILLed (#1231).
+ */
+export declare function installCommandSupervision(label: string, watchdog?: WatchdogOptions): CommandSupervision;
+//# sourceMappingURL=command-supervision.d.ts.map

package/dist/bin/command-supervision.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-supervision.d.ts","sourceRoot":"","sources":["../../src/bin/command-supervision.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,OAAO,EAA6B,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAMtF,MAAM,WAAW,kBAAkB;IACjC,4EAA4E;IAC5E,IAAI,IAAI,IAAI,CAAC;CACd;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,GAAE,eAAoB,GAAG,kBAAkB,CA0C3G"}

package/dist/bin/command-supervision.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installCommandSupervision = installCommandSupervision;
+/**
+ * Process supervision for long-running CLI commands (`index` / `init --index`).
+ *
+ * Indexing a large repo can run for a while on the main thread, and #999
+ * surfaced two ways that goes wrong when nothing is watching it:
+ *
+ *   1. **Orphaned worker.** `index` runs in a child re-exec'd with
+ *      `--liftoff-only` (the WASM-flag relaunch). Its parent blocks in
+ *      `spawnSync`, so when the parent shim is killed it cannot forward the
+ *      signal — the child keeps running, now orphaned, pinning a core. The PPID
+ *      watchdog (#277) notices the parent/host went away and exits the child.
+ *   2. **Wedged indexer.** The `#850` main-thread liveness watchdog — which
+ *      SIGKILLs a process whose event loop stops turning — was wired only into
+ *      the MCP `serve` path, so a wedged `index`/`init` was never auto-killed.
+ *
+ * Both reuse the exact mechanisms `serve` already uses; this just makes them
+ * available to a one-shot command. Best-effort and self-disabling: a missing
+ * watchdog never blocks the command from running. Both honour the same env
+ * switches as `serve` (`CODEGRAPH_NO_WATCHDOG`, `CODEGRAPH_PPID_POLL_MS=0`).
+ *
+ * Unlike the daemon — whose main thread only does fast, bounded work — the
+ * `index`/`init` path runs reference resolution and dynamic-edge synthesis
+ * SYNCHRONOUSLY on this thread, and on a large repo that is legitimately many
+ * seconds of work. So those spans yield cooperatively to the event loop
+ * (`src/resolution/cooperative-yield.ts`) to keep the heartbeat alive; without
+ * that the watchdog would SIGKILL a valid, in-progress index (#1091). The
+ * distinction it must preserve — kill a TRUE wedge, spare slow-but-progressing
+ * work — is exactly what cooperative yielding buys: a genuinely stuck span never
+ * reaches its next yield, so it still trips the timeout.
+ */
+const liveness_watchdog_1 = require("../mcp/liveness-watchdog");
+const ppid_watchdog_1 = require("../mcp/ppid-watchdog");
+const daemon_registry_1 = require("../mcp/daemon-registry");
+const early_ppid_1 = require("../mcp/early-ppid");
+const wasm_runtime_flags_1 = require("../extraction/wasm-runtime-flags");
+/**
+ * Install the liveness + PPID watchdogs for the duration of a CLI command.
+ * `label` is used in the shutdown notice (e.g. `"index"`). Returns a handle
+ * whose `stop()` must be called when the command completes so neither watchdog
+ * outlives it.
+ *
+ * Pass `watchdog.progressPaths` (the project's SQLite DB + `-wal`) so the
+ * liveness watchdog can tell a slow-but-progressing store on degraded storage
+ * (files advancing) from a true wedge (they aren't) — one long synchronous
+ * SQLite statement on a 150-IOPS disk otherwise gets a healthy index
+ * SIGKILLed (#1231).
+ */
+function installCommandSupervision(label, watchdog = {}) {
+    // Liveness watchdog: a separate process that SIGKILLs us if our event loop
+    // stops turning for too long (a wedged synchronous loop). Self-disables on
+    // CODEGRAPH_NO_WATCHDOG.
+    const liveness = (0, liveness_watchdog_1.installMainThreadWatchdog)(watchdog);
+    // PPID watchdog: detect that the parent (or the host threaded past the
+    // relaunch shim) died and we've been orphaned, then exit instead of leaking.
+    // Baseline from the CLI entry's earliest-possible capture — reading
+    // process.ppid here would miss a launcher killed during startup (#1185).
+    const originalPpid = early_ppid_1.EARLY_PPID;
+    const hostPpid = (0, ppid_watchdog_1.parseHostPpid)(process.env[wasm_runtime_flags_1.HOST_PPID_ENV]);
+    const pollMs = (0, ppid_watchdog_1.parsePpidPollMs)(process.env.CODEGRAPH_PPID_POLL_MS);
+    let ppidTimer = null;
+    if (pollMs > 0) {
+        ppidTimer = setInterval(() => {
+            const reason = (0, ppid_watchdog_1.supervisionLostReason)({
+                originalPpid,
+                currentPpid: process.ppid,
+                hostPpid,
+                isAlive: daemon_registry_1.isProcessAlive,
+            });
+            if (reason) {
+                try {
+                    process.stderr.write(`[Alpha Code Sense ${label}] Parent process exited (${reason}); aborting.\n`);
+                }
+                catch { /* stderr gone with the parent — exit anyway */ }
+                process.exit(1);
+            }
+        }, pollMs);
+        // Never let the watchdog itself keep the process alive past its real work.
+        ppidTimer.unref();
+    }
+    let stopped = false;
+    return {
+        stop() {
+            if (stopped)
+                return;
+            stopped = true;
+            if (ppidTimer)
+                clearInterval(ppidTimer);
+            liveness?.stop();
+        },
+    };
+}
+//# sourceMappingURL=command-supervision.js.map

package/dist/bin/command-supervision.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-supervision.js","sourceRoot":"","sources":["../../src/bin/command-supervision.ts"],"names":[],"mappings":";;AAqDA,8DA0CC;AA/FD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,gEAAsF;AACtF,wDAA6F;AAC7F,4DAAwD;AACxD,kDAA+C;AAC/C,yEAAiE;AAOjE;;;;;;;;;;;GAWG;AACH,SAAgB,yBAAyB,CAAC,KAAa,EAAE,WAA4B,EAAE;IACrF,2EAA2E;IAC3E,2EAA2E;IAC3E,yBAAyB;IACzB,MAAM,QAAQ,GAAG,IAAA,6CAAyB,EAAC,QAAQ,CAAC,CAAC;IAErD,uEAAuE;IACvE,6EAA6E;IAC7E,oEAAoE;IACpE,yEAAyE;IACzE,MAAM,YAAY,GAAG,uBAAU,CAAC;IAChC,MAAM,QAAQ,GAAG,IAAA,6BAAa,EAAC,OAAO,CAAC,GAAG,CAAC,kCAAa,CAAC,CAAC,CAAC;IAC3D,MAAM,MAAM,GAAG,IAAA,+BAAe,EAAC,OAAO,CAAC,GAAG,CAAC,sBAAsB,CAAC,CAAC;IACnE,IAAI,SAAS,GAA0C,IAAI,CAAC;IAC5D,IAAI,MAAM,GAAG,CAAC,EAAE,CAAC;QACf,SAAS,GAAG,WAAW,CAAC,GAAG,EAAE;YAC3B,MAAM,MAAM,GAAG,IAAA,qCAAqB,EAAC;gBACnC,YAAY;gBACZ,WAAW,EAAE,OAAO,CAAC,IAAI;gBACzB,QAAQ;gBACR,OAAO,EAAE,gCAAc;aACxB,CAAC,CAAC;YACH,IAAI,MAAM,EAAE,CAAC;gBACX,IAAI,CAAC;oBACH,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,qBAAqB,KAAK,4BAA4B,MAAM,gBAAgB,CAAC,CAAC;gBACrG,CAAC;gBAAC,MAAM,CAAC,CAAC,+CAA+C,CAAC,CAAC;gBAC3D,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YAClB,CAAC;QACH,CAAC,EAAE,MAAM,CAAC,CAAC;QACX,2EAA2E;QAC3E,SAAS,CAAC,KAAK,EAAE,CAAC;IACpB,CAAC;IAED,IAAI,OAAO,GAAG,KAAK,CAAC;IACpB,OAAO;QACL,IAAI;YACF,IAAI,OAAO;gBAAE,OAAO;YACpB,OAAO,GAAG,IAAI,CAAC;YACf,IAAI,SAAS;gBAAE,aAAa,CAAC,SAAS,CAAC,CAAC;YACxC,QAAQ,EAAE,IAAI,EAAE,CAAC;QACnB,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/bin/fatal-handler.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Render an uncaught value for the last-resort log WITHOUT triggering stack
+ * formatting. Pure and total — never throws, never touches `.stack`.
+ */
+export declare function describeFatal(value: unknown): string;
+/** Injectable seams so the wiring is testable without registering real handlers. */
+export interface FatalHandlerDeps {
+    /** Event target to attach to. Defaults to `process`. */
+    target?: NodeJS.EventEmitter;
+    /** How to terminate. Defaults to `process.exit`. */
+    exit?: (code: number) => void;
+    /** How to emit the bounded line. Defaults to a synchronous fd-2 write. */
+    write?: (line: string) => void;
+}
+/**
+ * Install the uncaught-exception / unhandled-rejection handlers. Both log a
+ * bounded line and then exit non-zero (Node's default fatal semantics).
+ */
+export declare function installFatalHandlers(deps?: FatalHandlerDeps): void;
+//# sourceMappingURL=fatal-handler.d.ts.map

package/dist/bin/fatal-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fatal-handler.d.ts","sourceRoot":"","sources":["../../src/bin/fatal-handler.ts"],"names":[],"mappings":"AAmCA;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAcpD;AAWD,oFAAoF;AACpF,MAAM,WAAW,gBAAgB;IAC/B,wDAAwD;IACxD,MAAM,CAAC,EAAE,MAAM,CAAC,YAAY,CAAC;IAC7B,oDAAoD;IACpD,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC9B,0EAA0E;IAC1E,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAChC;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,GAAE,gBAAqB,GAAG,IAAI,CActE"}

package/dist/bin/fatal-handler.js

@@ -0,0 +1,118 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeFatal = describeFatal;
+exports.installFatalHandlers = installFatalHandlers;
+/**
+ * Last-resort handlers for uncaught exceptions and unhandled rejections.
+ *
+ * Reaching one of these means a fault escaped every boundary (per-request
+ * try/catch in the MCP transport, the file watcher's own `'error'` handlers,
+ * telemetry's fail-silent contract) — i.e. the process is in an undefined
+ * state. Node's default in that case is to print and exit non-zero. The CLI
+ * previously OVERRODE that to "log the error and keep running", which is the
+ * bug behind two production incidents:
+ *
+ *   - #799 — a stdin socket `'error'` escalated here; the server logged it and
+ *     kept running, orphaning the detached MCP daemon and (on Linux) spinning a
+ *     POLLHUP fd at 100% CPU. Fixed for that one trigger by treating stdin
+ *     failure as shutdown (`src/mcp/stdin-teardown.ts`).
+ *   - #850 — a *different* uncaught exception hit the same handler. Logging it
+ *     forced V8 to lazily format the Error's `.stack`, which entered a
+ *     non-terminating source-position walk and pinned a core. Because the
+ *     handler kept the process alive, the detached daemon was left wedged: its
+ *     PPID watchdog and idle-timer (both `setInterval`s) could no longer fire,
+ *     and nothing respawned it — unrecoverable without a manual `kill`.
+ *
+ * The fix restores the safe default: log a BOUNDED, hang-proof line, then exit
+ * non-zero so a fresh daemon starts on the next connection.
+ *
+ * Two properties are load-bearing and covered by tests:
+ *   1. {@link describeFatal} never reads `error.stack` and never hands the raw
+ *      Error to `console.*`. The lazy stack getter is exactly the step that can
+ *      wedge (#850); since it would run *inside* this handler, touching it could
+ *      block the very `exit()` below. Name + message are plain string
+ *      properties and are always safe.
+ *   2. We write synchronously to fd 2 and then exit, so the message is flushed
+ *      even though `process.exit()` doesn't drain async streams.
+ */
+const fs = __importStar(require("fs"));
+/**
+ * Render an uncaught value for the last-resort log WITHOUT triggering stack
+ * formatting. Pure and total — never throws, never touches `.stack`.
+ */
+function describeFatal(value) {
+    if (value instanceof Error) {
+        const name = typeof value.name === 'string' && value.name ? value.name : 'Error';
+        // `message` is a plain own/proto string property — reading it does NOT
+        // format the stack (which is what can loop forever, #850).
+        const message = typeof value.message === 'string' ? value.message : '';
+        return message ? `${name}: ${message}` : name;
+    }
+    try {
+        return String(value);
+    }
+    catch {
+        // e.g. an object with a throwing `toString` / `Symbol.toPrimitive`.
+        return '<unstringifiable value>';
+    }
+}
+/** Best-effort synchronous stderr write that can never keep a doomed process alive. */
+function writeStderr(line) {
+    try {
+        fs.writeSync(2, line);
+    }
+    catch {
+        /* stderr closed/gone — nothing more we can safely do */
+    }
+}
+/**
+ * Install the uncaught-exception / unhandled-rejection handlers. Both log a
+ * bounded line and then exit non-zero (Node's default fatal semantics).
+ */
+function installFatalHandlers(deps = {}) {
+    const target = deps.target ?? process;
+    const exit = deps.exit ?? ((code) => process.exit(code));
+    const write = deps.write ?? writeStderr;
+    target.on('uncaughtException', (error) => {
+        write(`[Alpha Code Sense] Uncaught exception: ${describeFatal(error)}\n`);
+        exit(1);
+    });
+    target.on('unhandledRejection', (reason) => {
+        write(`[Alpha Code Sense] Unhandled rejection: ${describeFatal(reason)}\n`);
+        exit(1);
+    });
+}
+//# sourceMappingURL=fatal-handler.js.map

package/dist/bin/fatal-handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fatal-handler.js","sourceRoot":"","sources":["../../src/bin/fatal-handler.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,sCAcC;AAyBD,oDAcC;AA5FD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,uCAAyB;AAEzB;;;GAGG;AACH,SAAgB,aAAa,CAAC,KAAc;IAC1C,IAAI,KAAK,YAAY,KAAK,EAAE,CAAC;QAC3B,MAAM,IAAI,GAAG,OAAO,KAAK,CAAC,IAAI,KAAK,QAAQ,IAAI,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC;QACjF,uEAAuE;QACvE,2DAA2D;QAC3D,MAAM,OAAO,GAAG,OAAO,KAAK,CAAC,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC;QACvE,OAAO,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,KAAK,OAAO,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;IAChD,CAAC;IACD,IAAI,CAAC;QACH,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC;IACvB,CAAC;IAAC,MAAM,CAAC;QACP,oEAAoE;QACpE,OAAO,yBAAyB,CAAC;IACnC,CAAC;AACH,CAAC;AAED,uFAAuF;AACvF,SAAS,WAAW,CAAC,IAAY;IAC/B,IAAI,CAAC;QACH,EAAE,CAAC,SAAS,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;IACxB,CAAC;IAAC,MAAM,CAAC;QACP,wDAAwD;IAC1D,CAAC;AACH,CAAC;AAYD;;;GAGG;AACH,SAAgB,oBAAoB,CAAC,OAAyB,EAAE;IAC9D,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,IAAI,OAAO,CAAC;IACtC,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,IAAI,CAAC,CAAC,IAAY,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;IACjE,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,IAAI,WAAW,CAAC;IAExC,MAAM,CAAC,EAAE,CAAC,mBAAmB,EAAE,CAAC,KAAc,EAAE,EAAE;QAChD,KAAK,CAAC,0CAA0C,aAAa,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAC1E,IAAI,CAAC,CAAC,CAAC,CAAC;IACV,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,EAAE,CAAC,oBAAoB,EAAE,CAAC,MAAe,EAAE,EAAE;QAClD,KAAK,CAAC,2CAA2C,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QAC5E,IAAI,CAAC,CAAC,CAAC,CAAC;IACV,CAAC,CAAC,CAAC;AACL,CAAC"}

package/dist/bin/ltm-alpha-cs.d.ts

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+/**
+ * Alpha Code Sense CLI (deprecated alias)
+ *
+ * Command-line interface for Alpha Code Sense code intelligence.
+ *
+ * Usage:
+ *   codegraph                    Run interactive installer (when no args)
+ *   codegraph install            Run interactive installer
+ *   ltm-alpha-cs uninstall          Remove Alpha Code Sense from your agents
+ *   codegraph init [path]        Initialize Alpha Code Sense in a project
+ *   codegraph uninit [path]      Remove Alpha Code Sense from a project
+ *   codegraph index [path]       Index all files in the project
+ *   codegraph sync [path]        Sync changes since last index
+ *   ltm-alpha-cs status [path]      Show index status
+ *   codegraph query <search>     Search for symbols
+ *   codegraph files [options]    Show project file structure
+ *   codegraph context <task>     Build context for a task
+ *   codegraph callers <symbol>   Find what calls a function/method
+ *   codegraph callees <symbol>   Find what a function/method calls
+ *   codegraph impact <symbol>    Analyze what code is affected by changing a symbol
+ *   codegraph affected [files]   Find test files affected by changes
+ *   codegraph ui [path]          Open the browser viewer for an indexed project (alias: web)
+ *   ltm-alpha-cs upgrade [version]  Update Alpha Code Sense to the latest release
+ */
+import '../mcp/early-ppid';
+//# sourceMappingURL=ltm-alpha-cs.d.ts.map

package/dist/bin/ltm-alpha-cs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ltm-alpha-cs.d.ts","sourceRoot":"","sources":["../../src/bin/ltm-alpha-cs.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAKH,OAAO,mBAAmB,CAAC"}