npm - @imgly/codesign-mcp - Versions diffs - 0.1.7 → 0.1.8 - Mend

@imgly/codesign-mcp 0.1.7 → 0.1.8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (104) hide show

package/assets/docs/api/index.d.ts +9 -3
package/assets/docs/guide/SKILL.md +2 -2
package/assets/docs/guide/api/node/classes/creativeengine.md +13 -13
package/assets/docs/guide/edit-image/transform/scale.md +1 -3
package/assets/docs/guide/filters-and-effects/duotone.md +1 -1
package/assets/docs/guide/get-started/bun.md +0 -2
package/assets/docs/guide/get-started/deno.md +0 -1
package/assets/docs/guide/get-started/vanilla.md +0 -2
package/assets/docs/guide/import-media/default-assets.md +20 -24
package/assets/docs/guide/plugins/print-ready-pdf.md +0 -2
package/assets/docs/guide/serve-assets.md +80 -23
package/assets/docs/handbook/SKILL.md +6 -7
package/dist/assets/inline.generated.js +12 -12
package/dist/assets/inline.generated.js.map +1 -1
package/dist/cli/http.d.ts.map +1 -1
package/dist/cli/http.js +17 -3
package/dist/cli/http.js.map +1 -1
package/dist/cli/stdio.d.ts.map +1 -1
package/dist/cli/stdio.js +44 -15
package/dist/cli/stdio.js.map +1 -1
package/dist/cli/trial-license.generated.d.ts +1 -1
package/dist/cli/trial-license.generated.js +1 -1
package/dist/cli/trial-license.generated.js.map +1 -1
package/dist/config.d.ts +6 -0
package/dist/config.d.ts.map +1 -1
package/dist/config.js +8 -0
package/dist/config.js.map +1 -1
package/dist/diagnostics/bundle.d.ts +3 -0
package/dist/diagnostics/bundle.d.ts.map +1 -1
package/dist/diagnostics/bundle.js +25 -22
package/dist/diagnostics/bundle.js.map +1 -1
package/dist/diagnostics/prompt.d.ts +3 -0
package/dist/diagnostics/prompt.d.ts.map +1 -0
package/dist/diagnostics/prompt.js +21 -0
package/dist/diagnostics/prompt.js.map +1 -0
package/dist/diagnostics/router.d.ts +12 -0
package/dist/diagnostics/router.d.ts.map +1 -0
package/dist/diagnostics/router.js +64 -0
package/dist/diagnostics/router.js.map +1 -0
package/dist/diagnostics/spa-assets.generated.d.ts +2 -0
package/dist/diagnostics/spa-assets.generated.d.ts.map +1 -0
package/dist/diagnostics/spa-assets.generated.js +1231 -0
package/dist/diagnostics/spa-assets.generated.js.map +1 -0
package/dist/diagnostics/status.d.ts +38 -0
package/dist/diagnostics/status.d.ts.map +1 -0
package/dist/diagnostics/status.js +53 -0
package/dist/diagnostics/status.js.map +1 -0
package/dist/diagnostics/summary.d.ts +48 -0
package/dist/diagnostics/summary.d.ts.map +1 -0
package/dist/diagnostics/summary.js +116 -0
package/dist/diagnostics/summary.js.map +1 -0
package/dist/diagnostics/tool.d.ts +16 -0
package/dist/diagnostics/tool.d.ts.map +1 -0
package/dist/diagnostics/tool.js +90 -0
package/dist/diagnostics/tool.js.map +1 -0
package/dist/engine/asset-sources.d.ts +8 -0
package/dist/engine/asset-sources.d.ts.map +1 -1
package/dist/engine/asset-sources.js +9 -2
package/dist/engine/asset-sources.js.map +1 -1
package/dist/engine/uri-resolver.js.map +1 -1
package/dist/server.d.ts +25 -0
package/dist/server.d.ts.map +1 -1
package/dist/server.js +24 -4
package/dist/server.js.map +1 -1
package/dist/tools/engine.d.ts +79 -14
package/dist/tools/engine.d.ts.map +1 -1
package/dist/tools/engine.js +119 -20
package/dist/tools/engine.js.map +1 -1
package/dist/tools/export.d.ts.map +1 -1
package/dist/tools/export.js +34 -4
package/dist/tools/export.js.map +1 -1
package/dist/tools/index.js +2 -2
package/dist/tools/index.js.map +1 -1
package/dist/tools/load.d.ts.map +1 -1
package/dist/tools/load.js +26 -19
package/dist/tools/load.js.map +1 -1
package/dist/tools/preview.d.ts.map +1 -1
package/dist/tools/preview.js +60 -40
package/dist/tools/preview.js.map +1 -1
package/dist/tools/{open-editor.d.ts → view.d.ts} +3 -3
package/dist/tools/view.d.ts.map +1 -0
package/dist/tools/{open-editor.js → view.js} +20 -18
package/dist/tools/view.js.map +1 -0
package/dist/viewer/listener.d.ts +2 -0
package/dist/viewer/listener.d.ts.map +1 -1
package/dist/viewer/listener.js +2 -0
package/dist/viewer/listener.js.map +1 -1
package/dist/viewer/presigned-r2-url-builder.d.ts +1 -1
package/dist/viewer/presigned-r2-url-builder.js +1 -1
package/dist/viewer/presigned-r2-url-builder.js.map +1 -1
package/dist/viewer/router.d.ts.map +1 -1
package/dist/viewer/router.js +8 -17
package/dist/viewer/router.js.map +1 -1
package/dist/viewer/session-mount.js.map +1 -1
package/dist/viewer/spa-assets.generated.d.ts.map +1 -1
package/dist/viewer/spa-assets.generated.js +750 -869
package/dist/viewer/spa-assets.generated.js.map +1 -1
package/dist/viewer/url-builder.d.ts +4 -3
package/dist/viewer/url-builder.d.ts.map +1 -1
package/dist/viewer/url-builder.js +4 -4
package/dist/viewer/url-builder.js.map +1 -1
package/package.json +6 -5
package/dist/tools/open-editor.d.ts.map +0 -1
package/dist/tools/open-editor.js.map +0 -1

package/dist/diagnostics/spa-assets.generated.js ADDED Viewed

@@ -0,0 +1,1231 @@
+// AUTO-GENERATED by scripts/generate-spa-assets.mjs. Do not edit by hand.
+export const SPA_ASSETS = {
+    "index.html": `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>codesign diagnostics</title>
+    <style>
+      :root {
+        color-scheme: light dark;
+        --c-lock_wait: #e67e22;
+        --c-workspace_read: #3498db;
+        --c-engine_scene_load: #9b59b6;
+        --c-engine_execute: #2ecc71;
+        --c-engine_scene_save: #1abc9c;
+        --c-engine_scene_thumbnail: #f39c12;
+        --c-workspace_write: #e91e63;
+        --line: #8884;
+        --line-soft: #8882;
+      }
+      * {
+        box-sizing: border-box;
+      }
+      body {
+        font:
+          14px/1.5 system-ui,
+          sans-serif;
+        margin: 0 auto;
+        padding: 1.5rem;
+        max-width: 64rem;
+      }
+      h1 {
+        font-size: 1.15rem;
+        margin: 0 0 0.25rem;
+      }
+      h2 {
+        font-size: 0.82rem;
+        text-transform: uppercase;
+        letter-spacing: 0.05em;
+        opacity: 0.7;
+        margin: 1.6rem 0 0.6rem;
+      }
+      #status {
+        font-size: 0.8rem;
+        opacity: 0.7;
+        margin-left: 0.5rem;
+        font-weight: normal;
+      }
+      #meta {
+        font-size: 0.8rem;
+        opacity: 0.75;
+        margin-bottom: 1.2rem;
+        font-variant-numeric: tabular-nums;
+      }
+      #meta .sep {
+        opacity: 0.4;
+        margin: 0 0.5rem;
+      }
+      .muted {
+        opacity: 0.6;
+      }
+      .err {
+        color: #c0392b;
+      }
+      /* Drop zone */
+      #drop-zone {
+        border: 2px dashed var(--line);
+        border-radius: 8px;
+        padding: 2rem;
+        text-align: center;
+        margin: 1rem 0 1.5rem;
+        cursor: pointer;
+      }
+      #drop-zone.over {
+        background: #3498db22;
+        border-color: #3498db;
+      }
+      #file-input {
+        display: none;
+      }
+      /* Summary cards */
+      .cards {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 0.75rem;
+        margin-bottom: 0.5rem;
+      }
+      .card {
+        border: 1px solid var(--line);
+        border-radius: 8px;
+        padding: 0.6rem 0.9rem;
+        min-width: 8rem;
+        flex: 1 1 8rem;
+      }
+      .card .label {
+        font-size: 0.7rem;
+        opacity: 0.65;
+        text-transform: uppercase;
+        letter-spacing: 0.04em;
+      }
+      .card .value {
+        font-size: 1.35rem;
+        font-variant-numeric: tabular-nums;
+        line-height: 1.3;
+      }
+      .card .sub {
+        font-size: 0.75rem;
+        opacity: 0.6;
+      }
+      /* Phase legend */
+      .legend {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 0.25rem 1rem;
+        font-size: 0.75rem;
+        opacity: 0.85;
+        margin: 0 0 0.5rem;
+      }
+      .legend span {
+        display: inline-flex;
+        align-items: center;
+        gap: 0.35rem;
+      }
+      .sw {
+        width: 0.7rem;
+        height: 0.7rem;
+        border-radius: 2px;
+        display: inline-block;
+        flex: none;
+      }
+      /* Shared stacked phase bar */
+      .phase-bar {
+        display: flex;
+        height: 1.1rem;
+        border-radius: 4px;
+        overflow: hidden;
+      }
+      .phase-seg {
+        height: 100%;
+      }
+      /* Per-tool aggregate table */
+      .table-wrap {
+        overflow-x: auto;
+      }
+      table {
+        border-collapse: collapse;
+        width: 100%;
+      }
+      th,
+      td {
+        text-align: right;
+        padding: 0.35rem 0.7rem;
+        border-bottom: 1px solid var(--line-soft);
+        font-variant-numeric: tabular-nums;
+        white-space: nowrap;
+      }
+      th {
+        font-size: 0.72rem;
+        text-transform: uppercase;
+        letter-spacing: 0.03em;
+        opacity: 0.6;
+        font-weight: 600;
+      }
+      th:first-child,
+      td:first-child {
+        text-align: left;
+      }
+      td.bar-cell {
+        width: 40%;
+        min-width: 12rem;
+      }
+      /* Tabs */
+      .tabs {
+        display: flex;
+        gap: 0.25rem;
+        border-bottom: 1px solid var(--line);
+        margin: 1.6rem 0 0.9rem;
+      }
+      .tab {
+        background: none;
+        border: none;
+        border-bottom: 2px solid transparent;
+        margin-bottom: -1px;
+        padding: 0.5rem 0.9rem;
+        font: inherit;
+        font-size: 0.85rem;
+        color: inherit;
+        opacity: 0.6;
+        cursor: pointer;
+      }
+      .tab:hover {
+        opacity: 0.9;
+      }
+      .tab.active {
+        opacity: 1;
+        font-weight: 600;
+        border-bottom-color: currentColor;
+      }
+      .tabpanel[hidden] {
+        display: none;
+      }
+      /* Per-call accordion */
+      .calls-head,
+      .call-row {
+        display: grid;
+        grid-template-columns: 5.5rem 7rem 1fr 5rem 4.5rem;
+        gap: 0.6rem;
+        align-items: center;
+      }
+      .calls-head {
+        font-size: 0.72rem;
+        text-transform: uppercase;
+        letter-spacing: 0.03em;
+        opacity: 0.6;
+        padding: 0 0.4rem 0.35rem;
+        border-bottom: 1px solid var(--line);
+      }
+      .call {
+        border-bottom: 1px solid var(--line-soft);
+      }
+      .call-row {
+        cursor: pointer;
+        list-style: none;
+        padding: 0.4rem;
+        font-size: 0.85rem;
+        font-variant-numeric: tabular-nums;
+      }
+      .call-row::-webkit-details-marker {
+        display: none;
+      }
+      .call-row:hover,
+      .call[open] .call-row {
+        background: #8881;
+      }
+      .c-time {
+        opacity: 0.6;
+      }
+      .c-tool {
+        font-weight: 600;
+        white-space: nowrap;
+        overflow: hidden;
+        text-overflow: ellipsis;
+      }
+      .call-row .phase-bar {
+        height: 0.9rem;
+      }
+      .num {
+        text-align: right;
+      }
+      .c-status {
+        display: inline-flex;
+        align-items: center;
+        gap: 0.4rem;
+        justify-content: flex-end;
+      }
+      .chevron {
+        opacity: 0.5;
+        transition: transform 0.12s ease;
+      }
+      .call[open] .chevron {
+        transform: rotate(90deg);
+      }
+      .ok-badge {
+        font-size: 0.7rem;
+        opacity: 0.5;
+      }
+      .err-badge {
+        font-size: 0.7rem;
+        background: #c0392b;
+        color: #fff;
+        border-radius: 3px;
+        padding: 0 4px;
+      }
+      .call-body {
+        padding: 0.3rem 0.6rem 0.9rem;
+      }
+      .kv-label {
+        font-size: 0.68rem;
+        text-transform: uppercase;
+        letter-spacing: 0.04em;
+        opacity: 0.55;
+        margin: 0.8rem 0 0.35rem;
+      }
+      .phase-list {
+        display: flex;
+        flex-direction: column;
+        gap: 0.15rem;
+      }
+      .pl-row {
+        display: grid;
+        grid-template-columns: 11rem 1fr 5rem;
+        gap: 0.6rem;
+        align-items: center;
+        font-size: 0.8rem;
+        font-variant-numeric: tabular-nums;
+      }
+      .pl-name {
+        display: inline-flex;
+        align-items: center;
+        gap: 0.4rem;
+        white-space: nowrap;
+        overflow: hidden;
+        text-overflow: ellipsis;
+      }
+      .pl-track {
+        background: #8882;
+        border-radius: 2px;
+        height: 0.7rem;
+        overflow: hidden;
+      }
+      .pl-fill {
+        display: block;
+        height: 100%;
+      }
+      .meta-kv {
+        opacity: 0.7;
+        font-size: 0.78rem;
+        margin-top: 0.5rem;
+      }
+      .meta-kv code {
+        font-family: monospace;
+      }
+      pre.args {
+        margin: 0;
+        padding: 0.5rem 0.6rem;
+        background: #0002;
+        border-radius: 6px;
+        max-height: 18rem;
+        overflow: auto;
+        white-space: pre-wrap;
+        word-break: break-word;
+        font-size: 0.78rem;
+        line-height: 1.45;
+      }
+      pre.args.err {
+        color: #c0392b;
+      }
+      pre.code {
+        margin: 0;
+        padding: 0.6rem 0.7rem;
+        background: #0003;
+        border-left: 3px solid var(--c-engine_execute);
+        border-radius: 4px;
+        max-height: 26rem;
+        overflow: auto;
+        white-space: pre;
+        font-size: 0.78rem;
+        line-height: 1.5;
+        tab-size: 2;
+      }
+      .result-img {
+        display: block;
+        max-width: 360px;
+        max-height: 360px;
+        margin-top: 0.5rem;
+        border: 1px solid var(--line);
+        border-radius: 6px;
+        background: repeating-conic-gradient(#8882 0 25%, #0000 0 50%) 0 / 16px
+          16px;
+      }
+      /* Timeline */
+      .timeline {
+        list-style: none;
+        padding: 0;
+        margin: 0 0 1rem;
+        max-height: 22rem;
+        overflow: auto;
+        font-variant-numeric: tabular-nums;
+      }
+      .timeline li {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 0.5rem;
+        padding: 0.2rem 0;
+        border-bottom: 1px solid var(--line-soft);
+        font-size: 0.85rem;
+      }
+      .tl-ts {
+        opacity: 0.6;
+        min-width: 5rem;
+      }
+      .tl-start {
+        font-weight: 600;
+      }
+      .tl-err {
+        color: #c0392b;
+        width: 100%;
+        padding-left: 5.5rem;
+        font-family: monospace;
+        font-size: 0.8rem;
+      }
+      /* Engine log */
+      .log-tail {
+        font-family: monospace;
+        font-size: 0.8rem;
+        max-height: 24rem;
+        overflow: auto;
+        background: #0002;
+        border-radius: 6px;
+        padding: 0.5rem;
+        margin-bottom: 1.5rem;
+      }
+      .log-line {
+        display: flex;
+        gap: 0.5rem;
+        padding: 0.05rem 0;
+      }
+      .log-text {
+        white-space: pre-wrap;
+        word-break: break-all;
+      }
+      .lvl {
+        min-width: 3.5rem;
+        font-weight: bold;
+        opacity: 0.8;
+      }
+      .lvl-warn {
+        color: #e67e22;
+      }
+      .lvl-error {
+        color: #c0392b;
+      }
+      .lvl-debug {
+        opacity: 0.5;
+      }
+      .lvl-trace {
+        opacity: 0.4;
+      }
+    </style>
+    <!-- CODE-62: served-mode injection. The MCP router replaces the whole
+         delimited placeholder with window.__DIAGNOSTICS_STREAM__/BUNDLE__
+         assignments; the standalone serve.mjs blanks it. Unreplaced (raw
+         file://) it is an empty comment — a valid no-op. -->
+    <script>
+      /*__DIAGNOSTICS_INJECT__*/
+    </script>
+  </head>
+  <body>
+    <h1>
+      codesign diagnostics
+      <span id="status">drop a bundle (.zip) or .ndjson, or use ?file=</span>
+      <a
+        id="download-zip"
+        href="#"
+        download
+        style="display: none; margin-left: 12px; font-weight: 600"
+        >⬇ Download ZIP (send to IMG.LY)</a
+      >
+    </h1>
+    <div id="meta"></div>
+    <div id="drop-zone">
+      <label for="file-input"
+        >Drop a diagnostics <b>.zip</b> (or a raw <b>.ndjson</b>) here, or
+        <u>click to browse</u></label
+      >
+      <input type="file" id="file-input" accept=".zip,.ndjson,.txt,.json" />
+    </div>
+    <div class="cards" id="cards"></div>
+    <div class="legend" id="legend"></div>
+    <h2>Per-tool</h2>
+    <div class="table-wrap">
+      <table>
+        <thead>
+          <tr>
+            <th>tool</th>
+            <th>calls</th>
+            <th>err%</th>
+            <th>mean ms</th>
+            <th>max ms</th>
+            <th>phase breakdown</th>
+          </tr>
+        </thead>
+        <tbody id="tool-agg">
+          <tr>
+            <td colspan="6" class="muted">no events loaded</td>
+          </tr>
+        </tbody>
+      </table>
+    </div>
+    <div class="tabs" role="tablist">
+      <button
+        class="tab active"
+        data-tab="calls"
+        role="tab"
+        aria-selected="true"
+      >
+        Per-call detail
+      </button>
+      <button class="tab" data-tab="timeline" role="tab" aria-selected="false">
+        Timeline
+      </button>
+      <button class="tab" data-tab="log" role="tab" aria-selected="false">
+        Engine log
+      </button>
+    </div>
+    <div class="tabpanel" id="panel-calls" role="tabpanel">
+      <div id="tool-calls"><p class="muted">no events loaded</p></div>
+    </div>
+    <div class="tabpanel" id="panel-timeline" role="tabpanel" hidden>
+      <ul class="timeline" id="timeline">
+        <li class="muted">no events loaded</li>
+      </ul>
+    </div>
+    <div class="tabpanel" id="panel-log" role="tabpanel" hidden>
+      <div class="log-tail" id="log-tail">
+        <span class="muted">no events loaded</span>
+      </div>
+    </div>
+    <script>
+      // ---- Untrusted-text hardening: escape every event/meta-derived string
+      // before it reaches innerHTML (bundles come from a user's machine).
+      const esc = (s) =>
+        String(s)
+          .replace(/&/g, '&amp;')
+          .replace(/</g, '&lt;')
+          .replace(/>/g, '&gt;')
+          .replace(/"/g, '&quot;')
+          .replace(/'/g, '&#39;');
+      const PHASE_ORDER = [
+        'lock_wait',
+        'workspace_read',
+        'engine_scene_load',
+        'engine_execute',
+        'engine_scene_save',
+        'engine_scene_thumbnail',
+        'workspace_write'
+      ];
+      const OS_NAMES = { darwin: 'macOS', linux: 'Linux', win32: 'Windows' };
+      const TAB_LABELS = {
+        calls: 'Per-call detail',
+        timeline: 'Timeline',
+        log: 'Engine log'
+      };
+      const safePhase = (p) => String(p).replace(/[^a-z0-9_]/gi, '_');
+      const fmtTs = (n) => new Date(n).toLocaleTimeString();
+      const round = (n) => Math.round(n).toLocaleString();
+      // Humanize a millisecond duration: ms → s → m → h.
+      function fmtDur(ms) {
+        if (ms == null || !isFinite(ms)) return '—';
+        if (ms < 1000) return Math.round(ms) + ' ms';
+        const s = ms / 1000;
+        if (s < 60) return s.toFixed(1) + ' s';
+        const m = s / 60;
+        if (m < 60) return m.toFixed(m < 10 ? 1 : 0) + ' m';
+        return (m / 60).toFixed(1) + ' h';
+      }
+      function setTabCount(name, n) {
+        const btn = document.querySelector('.tab[data-tab="' + name + '"]');
+        if (btn) btn.textContent = TAB_LABELS[name] + ' (' + n + ')';
+      }
+      function parseNdjson(text) {
+        const events = [];
+        for (const line of text.split('\\n')) {
+          const t = line.trim();
+          if (!t) continue;
+          try {
+            events.push(JSON.parse(t));
+          } catch {
+            /* skip malformed line */
+          }
+        }
+        return events;
+      }
+      // ---- Minimal in-browser ZIP reader for the bundles \`diagnose\` writes.
+      // Writer contract (src/diagnostics/bundle.ts): flags=0, method=8 (raw
+      // deflate), sizes in each local header — so we walk local headers in order
+      // and inflate with DecompressionStream('deflate-raw').
+      async function unzip(arrayBuffer) {
+        const dv = new DataView(arrayBuffer);
+        const bytes = new Uint8Array(arrayBuffer);
+        const td = new TextDecoder();
+        const out = {};
+        let pos = 0;
+        while (
+          pos + 4 <= dv.byteLength &&
+          dv.getUint32(pos, true) === 0x04034b50
+        ) {
+          const method = dv.getUint16(pos + 8, true);
+          const compSize = dv.getUint32(pos + 18, true);
+          const nameLen = dv.getUint16(pos + 26, true);
+          const extraLen = dv.getUint16(pos + 28, true);
+          const nameStart = pos + 30;
+          const name = td.decode(
+            bytes.subarray(nameStart, nameStart + nameLen)
+          );
+          const dataStart = nameStart + nameLen + extraLen;
+          const comp = bytes.subarray(dataStart, dataStart + compSize);
+          let content;
+          if (method === 0) {
+            content = comp.slice();
+          } else {
+            const stream = new Response(comp).body.pipeThrough(
+              new DecompressionStream('deflate-raw')
+            );
+            content = new Uint8Array(await new Response(stream).arrayBuffer());
+          }
+          out[name] = content;
+          pos = dataStart + compSize;
+        }
+        return out;
+      }
+      // ---- Derived summaries -------------------------------------------------
+      function engineVersion(meta, events) {
+        if (meta && meta.cesdkEngine && meta.cesdkEngine !== 'unknown')
+          return meta.cesdkEngine;
+        const line = events.find(
+          (e) =>
+            e.kind === 'engine_log' && /\\[CreativeEngine\\]/.test(e.text || '')
+        );
+        const m = line && (line.text || '').match(/v?(\\d+\\.\\d+\\.\\d+)/);
+        return m ? m[1] : null;
+      }
+      // Engine init ≈ time from an \`engine_init_start\` to the first "Engine has
+      // been initialized" log within that run's window. The NDJSON accumulates
+      // across restarts, so we scan runs newest-first and return the most recent
+      // one that actually completed (the newest start may have no captured
+      // completion — e.g. the still-booting server).
+      function engineInitMs(events) {
+        const starts = events
+          .filter(
+            (e) => e.kind === 'lifecycle' && e.text === 'engine_init_start'
+          )
+          .map((e) => e.timestamp)
+          .sort((a, b) => a - b);
+        if (!starts.length) return null;
+        const readies = events
+          .filter(
+            (e) =>
+              e.kind === 'engine_log' &&
+              /Engine has been initialized/i.test(e.text || '')
+          )
+          .map((e) => e.timestamp)
+          .sort((a, b) => a - b);
+        for (let i = starts.length - 1; i >= 0; i--) {
+          const start = starts[i];
+          const next = i + 1 < starts.length ? starts[i + 1] : Infinity;
+          const ready = readies.find((t) => t >= start && t < next);
+          if (ready != null) return ready - start;
+        }
+        return null;
+      }
+      function aggregateTools(events) {
+        const map = new Map();
+        for (const e of events) {
+          if (e.kind !== 'tool_call') continue;
+          let a = map.get(e.tool);
+          if (!a) {
+            a = {
+              tool: e.tool,
+              count: 0,
+              errors: 0,
+              sum: 0,
+              max: 0,
+              phases: {}
+            };
+            map.set(e.tool, a);
+          }
+          a.count++;
+          a.sum += e.totalMs || 0;
+          if ((e.totalMs || 0) > a.max) a.max = e.totalMs || 0;
+          if (e.succeeded === false) a.errors++;
+          for (const sp of e.spans || [])
+            a.phases[sp.phase] = (a.phases[sp.phase] || 0) + (sp.ms || 0);
+        }
+        return [...map.values()].sort((x, y) => y.sum - x.sum);
+      }
+      // Stacked, normalized phase bar (used by the per-tool table and each
+      // per-call summary row).
+      function phaseSegs(phaseSums) {
+        const names = Object.keys(phaseSums);
+        if (!names.length)
+          return '<div class="phase-seg" style="width:100%;background:#8884" title="no spans"></div>';
+        const ordered = PHASE_ORDER.filter((p) => phaseSums[p] != null).concat(
+          names.filter((n) => !PHASE_ORDER.includes(n))
+        );
+        const total = ordered.reduce((s, n) => s + phaseSums[n], 0) || 1;
+        return ordered
+          .map((n) => {
+            const pct = ((phaseSums[n] / total) * 100).toFixed(2);
+            return (
+              \`<div class="phase-seg" style="width:\${pct}%;\` +
+              \`background:var(--c-\${safePhase(n)},#888)" \` +
+              \`title="\${esc(n)}: \${round(phaseSums[n])}ms"></div>\`
+            );
+          })
+          .join('');
+      }
+      // Per-phase rows (one bar each) for an expanded call.
+      function phaseList(spans) {
+        if (!spans.length) return '<div class="muted">no spans</div>';
+        const total = spans.reduce((s, sp) => s + (sp.ms || 0), 0) || 1;
+        return (
+          '<div class="phase-list">' +
+          spans
+            .map((sp) => {
+              const pct = (((sp.ms || 0) / total) * 100).toFixed(1);
+              const c = 'var(--c-' + safePhase(sp.phase) + ',#888)';
+              return (
+                '<div class="pl-row">' +
+                '<span class="pl-name"><span class="sw" style="background:' +
+                c +
+                '"></span>' +
+                esc(sp.phase) +
+                '</span>' +
+                '<span class="pl-track"><span class="pl-fill" style="width:' +
+                pct +
+                '%;background:' +
+                c +
+                '"></span></span>' +
+                '<span class="num">' +
+                round(sp.ms || 0) +
+                ' ms</span>' +
+                '</div>'
+              );
+            })
+            .join('') +
+          '</div>'
+        );
+      }
+      // ---- Renderers ---------------------------------------------------------
+      function renderMeta(meta, events) {
+        const parts = [];
+        if (meta && meta.buildId) parts.push('build ' + esc(meta.buildId));
+        if (meta && meta.os)
+          parts.push(
+            esc(
+              (OS_NAMES[meta.os] || meta.os) +
+                (meta.arch ? ' ' + meta.arch : '')
+            )
+          );
+        if (meta && meta.node) parts.push('node ' + esc(meta.node));
+        const ev = engineVersion(meta, events);
+        if (ev) parts.push('engine ' + esc(ev));
+        document.getElementById('meta').innerHTML = parts.length
+          ? parts.join('<span class="sep">·</span>')
+          : '<span class="muted">no meta.json in this source</span>';
+      }
+      function card(label, value, sub) {
+        return (
+          '<div class="card"><div class="label">' +
+          esc(label) +
+          '</div><div class="value">' +
+          value +
+          '</div>' +
+          (sub ? '<div class="sub">' + sub + '</div>' : '') +
+          '</div>'
+        );
+      }
+      function renderCards(events) {
+        const calls = events.filter((e) => e.kind === 'tool_call');
+        const errors = calls.filter((e) => e.succeeded === false).length;
+        const starts = events.filter(
+          (e) => e.kind === 'lifecycle' && e.text === 'engine_init_start'
+        ).length;
+        const stamps = events.map((e) => e.timestamp).filter((n) => n != null);
+        const span = stamps.length
+          ? Math.max(...stamps) - Math.min(...stamps)
+          : null;
+        const slowest = calls.reduce(
+          (best, e) => ((e.totalMs || 0) > (best?.totalMs || 0) ? e : best),
+          null
+        );
+        const init = engineInitMs(events);
+        document.getElementById('cards').innerHTML = [
+          card('tool calls', String(calls.length)),
+          card(
+            'errors',
+            errors ? '<span class="err">' + errors + '</span>' : '0'
+          ),
+          card('server starts', String(starts)),
+          card(
+            'log span',
+            esc(fmtDur(span)),
+            starts > 1 ? esc(starts + ' runs') : ''
+          ),
+          card(
+            'engine init',
+            esc(fmtDur(init)),
+            init != null ? 'last start' : ''
+          ),
+          card(
+            'slowest call',
+            slowest ? esc(fmtDur(slowest.totalMs)) : '—',
+            slowest ? esc(slowest.tool) : ''
+          )
+        ].join('');
+      }
+      function renderLegend() {
+        document.getElementById('legend').innerHTML = PHASE_ORDER.map(
+          (p) =>
+            '<span><span class="sw" style="background:var(--c-' +
+            p +
+            ')"></span>' +
+            esc(p) +
+            '</span>'
+        ).join('');
+      }
+      function renderToolAgg(events) {
+        const rows = aggregateTools(events);
+        const el = document.getElementById('tool-agg');
+        if (!rows.length) {
+          el.innerHTML =
+            '<tr><td colspan="6" class="muted">no tool_call events</td></tr>';
+          return;
+        }
+        el.innerHTML = rows
+          .map((a) => {
+            const errPct = a.count ? Math.round((a.errors / a.count) * 100) : 0;
+            return (
+              '<tr><td>' +
+              esc(a.tool) +
+              '</td><td>' +
+              a.count +
+              '</td><td' +
+              (a.errors ? ' class="err"' : '') +
+              '>' +
+              errPct +
+              '%</td><td>' +
+              round(a.sum / a.count) +
+              '</td><td>' +
+              round(a.max) +
+              '</td><td class="bar-cell"><div class="phase-bar">' +
+              phaseSegs(a.phases) +
+              '</div></td></tr>'
+            );
+          })
+          .join('');
+      }
+      // Only these mime types are rendered as inline images; a base64 \`data\`
+      // is only trusted if it is pure base64 (defends the data: URI we build).
+      const RESULT_IMG_MIME = /^image\\/(png|webp|jpe?g|gif|avif)$/i;
+      const BASE64_RE = /^[A-Za-z0-9+/=\\s]+$/;
+      // Result content parts that carry a real, renderable base64 image.
+      function resultImages(result) {
+        if (
+          !result ||
+          typeof result !== 'object' ||
+          !Array.isArray(result.content)
+        )
+          return [];
+        return result.content.filter(
+          (p) =>
+            p &&
+            typeof p === 'object' &&
+            typeof p.mimeType === 'string' &&
+            RESULT_IMG_MIME.test(p.mimeType) &&
+            typeof p.data === 'string' &&
+            BASE64_RE.test(p.data)
+        );
+      }
+      // A copy of the result with kept base64 blobs collapsed to a marker, so
+      // the JSON dump stays readable — the image bytes render as <img> below.
+      function markerizeResult(result) {
+        if (
+          !result ||
+          typeof result !== 'object' ||
+          !Array.isArray(result.content)
+        )
+          return result;
+        const content = result.content.map((p) => {
+          if (
+            p &&
+            typeof p === 'object' &&
+            typeof p.data === 'string' &&
+            p.data.length > 256 &&
+            !/ omitted>$/.test(p.data)
+          ) {
+            const where = RESULT_IMG_MIME.test(p.mimeType || '')
+              ? 'rendered below'
+              : 'omitted';
+            return { ...p, data: \`<\${p.data.length} base64 chars — \${where}>\` };
+          }
+          return p;
+        });
+        return { ...result, content };
+      }
+      // Chronological accordion: one <details> row per call; expand for the
+      // per-phase breakdown, timestamp/revision, error, and raw arguments.
+      function callRow(e) {
+        const failed = e.succeeded === false;
+        const spans = e.spans || [];
+        const spanSums = {};
+        for (const sp of spans)
+          spanSums[sp.phase] = (spanSums[sp.phase] || 0) + (sp.ms || 0);
+        const status = failed
+          ? '<span class="err-badge">FAIL</span>'
+          : '<span class="ok-badge">ok</span>';
+        const rev = e.revision
+          ? ' · revision <code>' + esc(e.revision) + '</code>'
+          : '';
+        const errBlock = e.error
+          ? '<div class="kv-label err">error</div><pre class="args err">' +
+            esc(
+              (e.error.message || '') +
+                (e.error.stack ? '\\n' + e.error.stack : '')
+            ) +
+            '</pre>'
+          : '';
+        // \`code\` is a long multiline string — noise as escaped JSON. Redact it
+        // to a length marker in the arguments dump and render it properly in a
+        // dedicated Code section below.
+        const hasCode =
+          e.args &&
+          typeof e.args === 'object' &&
+          typeof e.args.code === 'string' &&
+          e.args.code.length > 0;
+        const argsForJson = hasCode
+          ? {
+              ...e.args,
+              code: '<' + e.args.code.length + ' chars — see Code below>'
+            }
+          : e.args;
+        const argsBlock =
+          e.args !== undefined
+            ? '<div class="kv-label">arguments</div><pre class="args">' +
+              esc(JSON.stringify(argsForJson, null, 2)) +
+              '</pre>'
+            : '<div class="kv-label">arguments</div><div class="muted">none recorded</div>';
+        const codeBlock = hasCode
+          ? '<div class="kv-label">code</div><pre class="code">' +
+            esc(e.args.code) +
+            '</pre>'
+          : '';
+        const resultImgs = resultImages(e.result)
+          .map(
+            (p) =>
+              '<img class="result-img" alt="result image" src="data:' +
+              esc(p.mimeType) +
+              ';base64,' +
+              esc(p.data.replace(/\\s+/g, '')) +
+              '">'
+          )
+          .join('');
+        const resultBlock =
+          e.result !== undefined
+            ? '<div class="kv-label">result</div><pre class="args">' +
+              esc(JSON.stringify(markerizeResult(e.result), null, 2)) +
+              '</pre>' +
+              resultImgs
+            : '';
+        return (
+          '<details class="call' +
+          (failed ? ' failed' : '') +
+          '">' +
+          '<summary class="call-row">' +
+          '<span class="c-time">' +
+          esc(fmtTs(e.timestamp)) +
+          '</span>' +
+          '<span class="c-tool">' +
+          esc(e.tool) +
+          '</span>' +
+          '<span class="phase-bar">' +
+          phaseSegs(spanSums) +
+          '</span>' +
+          '<span class="num">' +
+          round(e.totalMs || 0) +
+          ' ms</span>' +
+          '<span class="c-status">' +
+          status +
+          '<span class="chevron">▸</span></span>' +
+          '</summary>' +
+          '<div class="call-body">' +
+          '<div class="kv-label">phases</div>' +
+          phaseList(spans) +
+          '<div class="meta-kv">' +
+          esc(new Date(e.timestamp).toLocaleString()) +
+          rev +
+          '</div>' +
+          errBlock +
+          argsBlock +
+          codeBlock +
+          resultBlock +
+          '</div>' +
+          '</details>'
+        );
+      }
+      function renderPerCall(events) {
+        const calls = events
+          .filter((e) => e.kind === 'tool_call')
+          .slice()
+          .sort((a, b) => a.timestamp - b.timestamp);
+        setTabCount('calls', calls.length);
+        const el = document.getElementById('tool-calls');
+        if (!calls.length) {
+          el.innerHTML = '<p class="muted">no tool_call events</p>';
+          return;
+        }
+        el.innerHTML =
+          '<div class="calls-head"><span>time</span><span>tool</span>' +
+          '<span>phase breakdown</span><span class="num">total</span>' +
+          '<span></span></div>' +
+          calls.map(callRow).join('');
+      }
+      function renderTimeline(events) {
+        const el = document.getElementById('timeline');
+        const entries = events.filter(
+          (e) => e.kind === 'lifecycle' || (e.kind === 'tool_call' && e.error)
+        );
+        setTabCount('timeline', entries.length);
+        if (!entries.length) {
+          el.innerHTML = '<li class="muted">no lifecycle or error events</li>';
+          return;
+        }
+        el.innerHTML = entries
+          .map((e) => {
+            const ts = fmtTs(e.timestamp);
+            const isStart = e.text === 'engine_init_start';
+            const text =
+              e.text != null
+                ? e.text
+                : e.kind === 'tool_call'
+                  ? 'tool error: ' + e.tool
+                  : e.kind;
+            const errLine = e.error
+              ? \`<div class="tl-err">\${esc(e.error.message)}</div>\`
+              : '';
+            return (
+              \`<li><span class="tl-ts">\${esc(ts)}</span>\` +
+              \`<span\${isStart ? ' class="tl-start"' : ''}>\${esc(text)}</span>\${errLine}</li>\`
+            );
+          })
+          .join('');
+      }
+      function renderEngineLog(events) {
+        const el = document.getElementById('log-tail');
+        const logs = events.filter((e) => e.kind === 'engine_log');
+        setTabCount('log', logs.length);
+        const tail = logs.slice(-200);
+        if (!tail.length) {
+          el.innerHTML = '<span class="muted">no engine_log events</span>';
+          return;
+        }
+        el.innerHTML = tail
+          .map((e) => {
+            const lvl = /^[a-z]+$/i.test(String(e.level)) ? e.level : 'unknown';
+            return \`<div class="log-line"><span class="lvl lvl-\${lvl}">\${esc(e.level)}</span><span class="log-text">\${esc(e.text)}</span></div>\`;
+          })
+          .join('');
+        el.scrollTop = el.scrollHeight;
+      }
+      function render(events, meta) {
+        renderMeta(meta, events);
+        renderCards(events);
+        renderLegend();
+        renderToolAgg(events);
+        renderPerCall(events);
+        renderTimeline(events);
+        renderEngineLog(events);
+        document.getElementById('status').textContent =
+          'loaded ' + events.length + ' event(s)';
+        document.getElementById('drop-zone').style.display = 'none';
+      }
+      // ---- Tabs --------------------------------------------------------------
+      document.querySelectorAll('.tab').forEach((btn) => {
+        btn.addEventListener('click', () => {
+          const tab = btn.dataset.tab;
+          document.querySelectorAll('.tab').forEach((b) => {
+            const on = b === btn;
+            b.classList.toggle('active', on);
+            b.setAttribute('aria-selected', on ? 'true' : 'false');
+          });
+          document.querySelectorAll('.tabpanel').forEach((p) => {
+            p.hidden = p.id !== 'panel-' + tab;
+          });
+          if (tab === 'log') {
+            const el = document.getElementById('log-tail');
+            el.scrollTop = el.scrollHeight;
+          }
+        });
+      });
+      // ---- Loading -----------------------------------------------------------
+      function safeJson(text) {
+        try {
+          return JSON.parse(text);
+        } catch {
+          return null;
+        }
+      }
+      async function loadArrayBuffer(buf) {
+        const b = new Uint8Array(buf);
+        // ZIP magic 'PK\\x03\\x04' → unzip the bundle; otherwise treat as NDJSON.
+        if (b[0] === 0x50 && b[1] === 0x4b) {
+          const files = await unzip(buf);
+          const td = new TextDecoder();
+          const ndName = Object.keys(files).find((n) => /\\.ndjson$/i.test(n));
+          const text = ndName ? td.decode(files[ndName]) : '';
+          const meta = files['meta.json']
+            ? safeJson(td.decode(files['meta.json']))
+            : null;
+          render(parseNdjson(text), meta);
+        } else {
+          render(parseNdjson(new TextDecoder().decode(b)), null);
+        }
+      }
+      function readFileAsBuffer(file) {
+        const reader = new FileReader();
+        reader.onload = (e) =>
+          loadArrayBuffer(e.target.result).catch((err) => {
+            document.getElementById('status').textContent =
+              'error: ' + err.message;
+          });
+        reader.readAsArrayBuffer(file);
+      }
+      document.getElementById('file-input').addEventListener('change', (ev) => {
+        const file = ev.target.files[0];
+        if (file) readFileAsBuffer(file);
+      });
+      const zone = document.getElementById('drop-zone');
+      zone.addEventListener('dragover', (e) => {
+        e.preventDefault();
+        zone.classList.add('over');
+      });
+      zone.addEventListener('dragleave', () => zone.classList.remove('over'));
+      zone.addEventListener('drop', (e) => {
+        e.preventDefault();
+        zone.classList.remove('over');
+        const file = e.dataTransfer.files[0];
+        if (file) readFileAsBuffer(file);
+      });
+      // Served mode (CODE-62): the MCP router injects an endpoint. Auto-load the
+      // NDJSON snapshot over HTTP (no browser unzip) and reveal Download-ZIP.
+      const streamUrl = window.__DIAGNOSTICS_STREAM__;
+      const bundleUrl = window.__DIAGNOSTICS_BUNDLE__;
+      const fileParam = new URLSearchParams(location.search).get('file');
+      if (streamUrl) {
+        const dl = document.getElementById('download-zip');
+        if (bundleUrl && dl) {
+          dl.href = bundleUrl;
+          dl.style.display = '';
+        }
+        document.getElementById('status').textContent = 'loading…';
+        fetch(streamUrl, { cache: 'no-store' })
+          .then((r) => {
+            if (!r.ok) throw new Error('HTTP ' + r.status);
+            return r.text();
+          })
+          .then((text) => render(parseNdjson(text), null))
+          .catch((e) => {
+            document.getElementById('status').textContent =
+              'error: ' + e.message;
+          });
+      } else if (fileParam) {
+        document.getElementById('status').textContent = 'loading…';
+        const isZip = /\\.zip$/i.test(fileParam);
+        fetch('/_file?path=' + encodeURIComponent(fileParam), {
+          cache: 'no-store'
+        })
+          .then((r) => {
+            if (!r.ok) throw new Error('HTTP ' + r.status);
+            return r.arrayBuffer();
+          })
+          .then(async (buf) => {
+            if (isZip) return loadArrayBuffer(buf);
+            const text = new TextDecoder().decode(new Uint8Array(buf));
+            const events = parseNdjson(text);
+            const metaPath = fileParam.replace(/[^/\\\\]*$/, 'meta.json');
+            let meta = null;
+            if (metaPath !== fileParam) {
+              meta = await fetch(
+                '/_file?path=' + encodeURIComponent(metaPath),
+                {
+                  cache: 'no-store'
+                }
+              )
+                .then((r) => (r.ok ? r.text() : null))
+                .then((t) => (t ? safeJson(t) : null))
+                .catch(() => null);
+            }
+            render(events, meta);
+          })
+          .catch((e) => {
+            document.getElementById('status').textContent =
+              'error: ' + e.message;
+          });
+      }
+    </script>
+  </body>
+</html>
+`,
+};
+//# sourceMappingURL=spa-assets.generated.js.map