agenticreplay 0.1.0 → 0.1.2

package/node_modules/@agenticreplay/viewer/dist/css.js

@@ -0,0 +1,410 @@
+/**
+ * The whole stylesheet, inlined into every export. No webfonts, no imports, no URLs:
+ * an export has to open from file:// on a machine that has never heard of this project.
+ *
+ * Monochrome and counter-shaded — a dark plane above, light below. State is carried by
+ * FORM (fill, weight, hairline), never by hue: exports get screenshotted into issues,
+ * printed, pasted into dark-mode Slack, and read by people who do not separate red from
+ * green. Form survives all four.
+ */
+export const VIEWER_CSS = `
+:root {
+  --ground: #F3F5F5;
+  --paper: #FFFFFF;
+  --sunk: #EAEEEE;
+  --ink: #0A0C0D;
+  --ink-2: #555D60;
+  --ink-3: #868F92;
+  --rule: #DCE1E2;
+  --rule-2: #BFC7C8;
+  --band: #08090A;
+  --band-fg: #E8ECEC;
+  --band-2: #9AA4A7;
+  --band-dim: #6B7578;
+  --band-rule: #1F2426;
+  color-scheme: light;
+}
+
+@media (prefers-color-scheme: dark) {
+  :root:not([data-theme="light"]) {
+    --ground: #111517;
+    --paper: #171B1D;
+    --sunk: #0C1011;
+    --ink: #E9EDED;
+    --ink-2: #98A2A5;
+    --ink-3: #6C7679;
+    --rule: #252C2E;
+    --rule-2: #374043;
+    --band: #08090A;
+    --band-fg: #E8ECEC;
+    --band-2: #9AA4A7;
+    --band-dim: #6B7578;
+    --band-rule: #1F2426;
+    color-scheme: dark;
+  }
+}
+
+:root[data-theme="dark"] {
+  --ground: #111517;
+  --paper: #171B1D;
+  --sunk: #0C1011;
+  --ink: #E9EDED;
+  --ink-2: #98A2A5;
+  --ink-3: #6C7679;
+  --rule: #252C2E;
+  --rule-2: #374043;
+  --band: #08090A;
+  --band-fg: #E8ECEC;
+  --band-2: #9AA4A7;
+  --band-dim: #6B7578;
+  --band-rule: #1F2426;
+  color-scheme: dark;
+}
+
+*, *::before, *::after { box-sizing: border-box; }
+[hidden] { display: none !important; }
+
+body {
+  margin: 0;
+  height: 100vh;
+  height: 100dvh;
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+  background: var(--ground);
+  color: var(--ink);
+  font-family: system-ui, -apple-system, "Segoe UI", Helvetica, Arial, sans-serif;
+  font-size: 14px;
+  line-height: 1.45;
+  -webkit-text-size-adjust: 100%;
+}
+
+.mono, .row, .seq, .chip, .stat dt, .stat dd, .kv dt, .kv dd, pre, code,
+input, button, .pane-title, .sub, footer, .finding {
+  font-family: ui-monospace, "SF Mono", Menlo, Consolas, monospace;
+}
+
+:focus-visible { outline: 2px solid var(--ink); outline-offset: 1px; }
+
+/* ---- band: the dark plane above ---- */
+.band {
+  flex: none;
+  background: var(--band);
+  color: var(--band-fg);
+  border-bottom: 1px solid var(--band-rule);
+  padding: .6rem .9rem .55rem;
+  display: flex;
+  flex-wrap: wrap;
+  align-items: baseline;
+  gap: .35rem 1.4rem;
+}
+.band :focus-visible { outline-color: var(--band-fg); }
+.band h1 {
+  margin: 0;
+  font-size: .8125rem;
+  font-weight: 600;
+  letter-spacing: .02em;
+  font-family: ui-monospace, "SF Mono", Menlo, Consolas, monospace;
+}
+.band .sub { color: var(--band-2); font-size: .6875rem; }
+.stats { display: flex; flex-wrap: wrap; gap: .1rem 1.1rem; margin: 0 0 0 auto; padding: 0; }
+.stat { display: flex; align-items: baseline; gap: .4rem; margin: 0; }
+.stat dt {
+  margin: 0;
+  font-size: .625rem;
+  letter-spacing: .1em;
+  text-transform: uppercase;
+  color: var(--band-dim);
+}
+.stat dd { margin: 0; font-size: .75rem; color: var(--band-fg); font-variant-numeric: tabular-nums; }
+.stat dd.flag { font-weight: 700; }
+#agenticreplay-theme {
+  background: transparent;
+  border: 1px solid var(--band-rule);
+  border-radius: 2px;
+  color: var(--band-2);
+  font-size: .625rem;
+  letter-spacing: .1em;
+  text-transform: uppercase;
+  padding: .15rem .4rem;
+  cursor: pointer;
+}
+#agenticreplay-theme:hover { color: var(--band-fg); border-color: var(--band-dim); }
+
+/* ---- findings strip ---- */
+.findings { flex: none; border-bottom: 1px solid var(--rule); background: var(--sunk); }
+.finding {
+  display: flex;
+  align-items: baseline;
+  gap: .5rem;
+  padding: .35rem .9rem;
+  font-size: .6875rem;
+  color: var(--ink-2);
+}
+.finding + .finding { border-top: 1px solid var(--rule); }
+
+/* ---- split ---- */
+/* minmax(0, 1fr) on the row and min-height: 0 on both items, for the same reason each time: a
+   grid item defaults to min-height auto and grows to its content, which silently unbounds the
+   scroll container inside it. The rows list then reports nothing to scroll and paints over into
+   the body's overflow:hidden, where it is clipped — so on any trace taller than the viewport,
+   every event past the fold becomes unreachable. Measured before this fix: the last row of a
+   42-event trace sat at y=1228 in a 900px viewport with no way to scroll to it. */
+.split {
+  flex: 1;
+  min-height: 0;
+  display: grid;
+  grid-template-columns: minmax(20rem, 38%) 1fr;
+  grid-template-rows: minmax(0, 1fr);
+}
+.list {
+  min-width: 0;
+  min-height: 0;
+  display: flex;
+  flex-direction: column;
+  border-right: 1px solid var(--rule);
+}
+.pane-col { min-width: 0; min-height: 0; overflow: auto; background: var(--paper); }
+
+.filterbar {
+  flex: none;
+  display: flex;
+  align-items: center;
+  gap: .6rem;
+  padding: .45rem .75rem;
+  border-bottom: 1px solid var(--rule);
+}
+#agenticreplay-filter {
+  flex: 1;
+  min-width: 0;
+  background: var(--sunk);
+  border: 1px solid var(--rule-2);
+  border-radius: 2px;
+  color: var(--ink);
+  font-size: .75rem;
+  padding: .25rem .4rem;
+}
+#agenticreplay-filter::placeholder { color: var(--ink-3); }
+#agenticreplay-count { font-size: .625rem; letter-spacing: .08em; text-transform: uppercase; color: var(--ink-3); }
+
+.rows { flex: 1; min-height: 0; overflow: auto; }
+.row {
+  display: grid;
+  grid-template-columns: 3rem 4.5rem minmax(0, 1fr) auto;
+  align-items: baseline;
+  gap: .55rem;
+  width: 100%;
+  margin: 0;
+  padding: .32rem .75rem .32rem .5rem;
+  background: transparent;
+  border: 0;
+  border-left: 3px solid transparent;
+  border-bottom: 1px solid var(--rule);
+  color: var(--ink-2);
+  font-size: .75rem;
+  text-align: left;
+  cursor: pointer;
+}
+.row[data-turn-start="true"] { border-top: 1px solid var(--rule-2); }
+.row:hover { background: var(--sunk); }
+.row[aria-selected="true"] { background: var(--paper); border-left-color: var(--ink); color: var(--ink); }
+.row:focus-visible { outline: 2px solid var(--ink); outline-offset: -2px; }
+.seq { color: var(--ink-3); text-align: right; font-variant-numeric: tabular-nums; font-size: .6875rem; }
+.text { min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.label { color: var(--ink); }
+.row[data-tone="attention"] .label { font-weight: 700; }
+.row[data-tone="quiet"] .label { color: var(--ink-3); }
+.detail { color: var(--ink-3); }
+.meta { color: var(--ink-3); font-size: .6875rem; font-variant-numeric: tabular-nums; white-space: nowrap; }
+
+.chip {
+  display: inline-block;
+  padding: .05rem .3rem;
+  border-radius: 2px;
+  font-size: .625rem;
+  letter-spacing: .1em;
+  text-transform: uppercase;
+  white-space: nowrap;
+}
+.chip.attention { background: var(--ink); color: var(--ground); }
+.chip.normal { border: 1px solid var(--rule-2); color: var(--ink-2); }
+.chip.quiet { border: 1px solid var(--rule); color: var(--ink-3); }
+
+/* ---- detail pane ---- */
+.pane { padding: 1rem 1.25rem 3rem; max-width: 62rem; }
+.pane-title { display: flex; align-items: baseline; gap: .5rem; margin: 0 0 .9rem; font-size: .875rem; font-weight: 600; }
+.pane-title .name { min-width: 0; overflow-wrap: anywhere; }
+.pane h3 {
+  margin: 1.4rem 0 .5rem;
+  padding-bottom: .25rem;
+  border-bottom: 1px solid var(--rule);
+  font-family: ui-monospace, "SF Mono", Menlo, Consolas, monospace;
+  font-size: .625rem;
+  font-weight: 600;
+  letter-spacing: .1em;
+  text-transform: uppercase;
+  color: var(--ink-3);
+}
+.kv { display: grid; grid-template-columns: 8rem minmax(0, 1fr); gap: .2rem .9rem; margin: 0; }
+.kv dt { margin: 0; font-size: .625rem; letter-spacing: .1em; text-transform: uppercase; color: var(--ink-3); }
+.kv dd { margin: 0; font-size: .75rem; overflow-wrap: anywhere; }
+.muted { color: var(--ink-3); font-size: .75rem; }
+.download { display: inline-block; margin-top: .45rem; color: var(--band-fg); font-size: .75rem; }
+.scroll { overflow-x: auto; margin: 0; }
+pre {
+  margin: 0;
+  padding: .5rem 0 .5rem .75rem;
+  border-left: 2px solid var(--rule-2);
+  background: var(--sunk);
+  font-size: .75rem;
+  line-height: 1.5;
+}
+.diff span { display: block; }
+.diff .add { display: block; color: var(--ink); font-weight: 700; }
+.diff .del { display: block; color: var(--ink-3); }
+.diff .hunk { display: block; color: var(--ink-2); }
+.empty { padding: 2rem .75rem; color: var(--ink-3); font-size: .75rem; text-align: center; }
+
+footer {
+  flex: none;
+  border-top: 1px solid var(--rule);
+  padding: .45rem .9rem;
+  background: var(--ground);
+  color: var(--ink-3);
+  font-size: .6875rem;
+  letter-spacing: .02em;
+}
+
+@media (max-width: 52rem) {
+  .split { grid-template-columns: 1fr; grid-template-rows: minmax(0, 45%) minmax(0, 55%); }
+  .list { border-right: 0; border-bottom: 1px solid var(--rule); }
+  .stats { margin-left: 0; }
+}
+
+
+/* ── Motion ──────────────────────────────────────────────────────────────
+   A debugger is read mid-incident, so motion here is functional or absent.
+   Playback exists because this is a replay tool: the recorded gaps are the
+   only thing it adds over pressing j, so they are preserved and compressed.
+   The playhead slides to give that a physical position. Everything animates
+   transform/opacity only, so nothing reflows on a large trace. */
+
+.rows { position: relative; }
+
+.playhead {
+  position: absolute;
+  left: 0;
+  top: 0;
+  width: 2px;
+  height: 0;
+  background: var(--ink);
+  transform: translateY(0);
+  transition: transform 160ms cubic-bezier(0.2, 0, 0, 1), height 160ms cubic-bezier(0.2, 0, 0, 1);
+  pointer-events: none;
+  opacity: 0;
+}
+.playhead[data-on='true'] { opacity: 1; }
+
+.progress {
+  height: 2px;
+  background: var(--rule);
+  overflow: hidden;
+}
+.progress > span {
+  display: block;
+  height: 100%;
+  background: var(--ink);
+  transform: scaleX(0);
+  transform-origin: left center;
+  transition: transform 160ms linear;
+}
+
+#agenticreplay-play .glyph {
+  display: block;
+  width: 0;
+  height: 0;
+  /* A play triangle and a pause bar from one element: no icon font, no SVG, no second asset. */
+  border-style: solid;
+  border-width: 5px 0 5px 8px;
+  border-color: transparent transparent transparent currentColor;
+  transition: border-width 120ms ease, border-color 120ms ease;
+}
+#agenticreplay-play[aria-pressed='true'] .glyph {
+  border-width: 5px 0 5px 8px;
+  border-color: transparent transparent transparent currentColor;
+  border-left-style: double;
+  border-left-width: 8px;
+}
+
+/* Direction of travel: forward enters from below, backward from above. Tells you which way you
+   moved without a label, which matters when playback is stepping for you. */
+@keyframes agenticreplay-enter-down {
+  from { opacity: 0; transform: translateY(4px); }
+  to { opacity: 1; transform: translateY(0); }
+}
+@keyframes agenticreplay-enter-up {
+  from { opacity: 0; transform: translateY(-4px); }
+  to { opacity: 1; transform: translateY(0); }
+}
+.pane[data-dir='down'] { animation: agenticreplay-enter-down 130ms cubic-bezier(0.2, 0, 0, 1); }
+.pane[data-dir='up'] { animation: agenticreplay-enter-up 130ms cubic-bezier(0.2, 0, 0, 1); }
+
+/* A row that needs attention is a band: the ground and the ink trade places. Keyed on data-tone,
+   which is what the row *is*, rather than on data-pulse, which only says playback happened to land
+   here — two failures otherwise render differently depending on how far someone pressed play.
+
+   Every state that the rest of the table carries in background has to be restated here, because a
+   band already owns that channel: selection moves to the rail, hover lifts the band rather than
+   replacing it, and the wash inverts. Leaving any of them out makes the row that matters most the
+   one you cannot tell anything about. */
+.row { position: relative; }
+.row[data-tone='attention'] { background: var(--ink); }
+.row[data-tone='attention'],
+.row[data-tone='attention'] .label,
+.row[data-tone='attention'] .detail,
+.row[data-tone='attention'] .meta,
+.row[data-tone='attention'] .seq { color: var(--ground); }
+/* The chip is already inverted against the paper, so on a band it inverts back. */
+.row[data-tone='attention'] .chip.attention { background: var(--ground); color: var(--ink); }
+.row[data-tone='attention'] .chip.normal,
+.row[data-tone='attention'] .chip.quiet { border-color: var(--ink-3); color: var(--ground); }
+
+/* Selection: the rail, not the ground. --ink on --ink is invisible. */
+.row[data-tone='attention'][aria-selected='true'] {
+  background: var(--ink);
+  border-left-color: var(--ground);
+  color: var(--ground);
+}
+/* Hover lifts the band instead of replacing it with --sunk, which would read as un-erroring it. */
+.row[data-tone='attention']:hover { background: var(--ink-2); }
+.row[data-tone='attention']:focus-visible { outline-color: var(--ground); }
+
+/* The playback wash, inverted so it reads on a band as it does on paper. No shadow — the design
+   system uses hairlines and weight, never depth — and no hue, since state here is carried by form.
+   An overlay whose opacity animates stays on the compositor and never repaints the row.
+
+   opacity:0 is the base and it is load-bearing: without it the element inherits the default of 1
+   and the only thing holding it invisible is an animation that has not finished, so the wash goes
+   solid the moment the animation ends and stays there, because data-pulse is never removed. */
+.row[data-pulse='true']::after {
+  content: '';
+  position: absolute;
+  inset: 0;
+  background: var(--ink);
+  opacity: 0;
+  pointer-events: none;
+  animation: agenticreplay-attention 420ms ease-out;
+}
+.row[data-tone='attention'][data-pulse='true']::after { background: var(--ground); }
+@keyframes agenticreplay-attention {
+  from { opacity: 0.14; }
+  to { opacity: 0; }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  * { animation: none !important; transition: none !important; scroll-behavior: auto !important; }
+  /* Playback still works — it just steps instantly instead of gliding. */
+  .playhead, .progress > span { transition: none !important; }
+}
+`;
+//# sourceMappingURL=css.js.map

package/node_modules/@agenticreplay/viewer/dist/css.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"css.js","sourceRoot":"","sources":["../src/css.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+YzB,CAAC"}

package/node_modules/@agenticreplay/viewer/dist/export.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Writes one run directory out as a single HTML file — the artefact you attach to an issue.
+ */
+import { type ReadTraceOptions } from './trace-dir.js';
+export interface ExportOptions extends ReadTraceOptions {
+    /** Client runtime to inline; pass `await bundleViewerScript()` for a smaller file. */
+    script?: string;
+    maxInlineChars?: number;
+}
+export interface ExportResult {
+    bytes: number;
+    path: string;
+}
+/**
+ * Reads `runDir` (manifest.json + events.jsonl + blobs/) and writes a self-contained document
+ * to `outPath`. Text blobs are included in full by default; the HTML preview still truncates long
+ * values and offers a download link for the complete redacted body. Pass `maxBlobBytes` explicitly
+ * when a bounded export is required.
+ */
+export declare function exportTraceHtml(runDir: string, outPath: string, options?: ExportOptions): Promise<ExportResult>;
+//# sourceMappingURL=export.d.ts.map

package/node_modules/@agenticreplay/viewer/dist/export.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export.d.ts","sourceRoot":"","sources":["../src/export.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,OAAO,EAAgB,KAAK,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAErE,MAAM,WAAW,aAAc,SAAQ,gBAAgB;IACrD,sFAAsF;IACtF,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;GAKG;AACH,wBAAsB,eAAe,CACnC,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC,YAAY,CAAC,CAOvB"}

package/node_modules/@agenticreplay/viewer/dist/export.js

@@ -0,0 +1,22 @@
+/**
+ * Writes one run directory out as a single HTML file — the artefact you attach to an issue.
+ */
+import { mkdir, writeFile } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import { renderTraceHtml } from './html.js';
+import { readTraceDir } from './trace-dir.js';
+/**
+ * Reads `runDir` (manifest.json + events.jsonl + blobs/) and writes a self-contained document
+ * to `outPath`. Text blobs are included in full by default; the HTML preview still truncates long
+ * values and offers a download link for the complete redacted body. Pass `maxBlobBytes` explicitly
+ * when a bounded export is required.
+ */
+export async function exportTraceHtml(runDir, outPath, options = {}) {
+    const { manifest, events, blobs } = await readTraceDir(runDir, options);
+    const html = renderTraceHtml({ manifest, events, blobs }, options);
+    const target = resolve(outPath);
+    await mkdir(dirname(target), { recursive: true });
+    await writeFile(target, html, 'utf8');
+    return { bytes: Buffer.byteLength(html, 'utf8'), path: target };
+}
+//# sourceMappingURL=export.js.map

package/node_modules/@agenticreplay/viewer/dist/export.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"export.js","sourceRoot":"","sources":["../src/export.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAC5C,OAAO,EAAE,YAAY,EAAyB,MAAM,gBAAgB,CAAC;AAarE;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe,CACnC,MAAc,EACd,OAAe,EACf,UAAyB,EAAE;IAE3B,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,YAAY,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACxE,MAAM,IAAI,GAAG,eAAe,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,EAAE,OAAO,CAAC,CAAC;IACnE,MAAM,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAChC,MAAM,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAClD,MAAM,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;IACtC,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,MAAM,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;AAClE,CAAC"}

package/node_modules/@agenticreplay/viewer/dist/html.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Renders a whole trace into ONE self-contained HTML document.
+ *
+ * The document opens from file:// with no network: the stylesheet and the client runtime are
+ * inlined, there are no webfonts, no images and no external references of any kind. That is the
+ * point of the package — someone attaches an export to an issue and the reader sees the full UI
+ * without installing anything.
+ *
+ * A trace is untrusted input (spec §5 calls it sensitive material; it is also *foreign*
+ * material). Every byte that comes from the trace goes through `escapeHtml`, and the client
+ * script never turns a string into markup, so the escape function is the entire XSS surface.
+ */
+import type { Manifest, TraceEvent } from '@agenticreplay/schema';
+export interface RenderInput {
+    manifest: Manifest;
+    events: TraceEvent[];
+    /** Blob contents by `$blob` reference (or bare digest). Anything absent renders as omitted. */
+    blobs?: Record<string, string>;
+}
+export interface RenderOptions {
+    /** Client runtime to inline. Defaults to the readable source; pass a minified bundle. */
+    script?: string;
+    /** Per-payload character cap, so one huge blob cannot dominate the file. */
+    maxInlineChars?: number;
+    /** Loopback blob endpoint used by the live viewer; exports leave this unset and embed bodies. */
+    blobDownloadBaseUrl?: string;
+}
+/** The one place trace content becomes markup-safe. Used on every single interpolation. */
+export declare function escapeHtml(value: unknown): string;
+/** Renders a complete, standalone HTML document for one run. */
+export declare function renderTraceHtml(input: RenderInput, options?: RenderOptions): string;
+//# sourceMappingURL=html.d.ts.map

package/node_modules/@agenticreplay/viewer/dist/html.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"html.d.ts","sourceRoot":"","sources":["../src/html.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAW,QAAQ,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAgB3E,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,QAAQ,CAAC;IACnB,MAAM,EAAE,UAAU,EAAE,CAAC;IACrB,+FAA+F;IAC/F,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAChC;AAED,MAAM,WAAW,aAAa;IAC5B,yFAAyF;IACzF,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,4EAA4E;IAC5E,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,iGAAiG;IACjG,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAYD,2FAA2F;AAC3F,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAGjD;AAmMD,gEAAgE;AAChE,wBAAgB,eAAe,CAAC,KAAK,EAAE,WAAW,EAAE,OAAO,GAAE,aAAkB,GAAG,MAAM,CAoGvF"}