@warmdrift/kgauto-compiler 2.0.0-alpha.7 → 2.0.0-alpha.70

package/dist/dialect.d.mts

@@ -12,8 +12,15 @@
  * The brain learns by `(archetype, model, shape)` tuples. Apps that declare
  * the same tuple inherit each other's mutations.
  *
- * v1 is intentionally small (9 archetypes, 5 shape dimensions). New entries
- * arrive in v2/v3 from real usage signals — never speculatively.
+ * v1 is intentionally small (10 archetypes, 5 shape dimensions). New entries
+ * arrive from real usage signals — never speculatively.
+ *
+ * Versioning note (alpha.62): `judge` was added as an ADDITIVE 10th entry
+ * under dialect-v1 rather than bumping to v2. Bumping the version string
+ * would fragment every existing learning key (`v1::…` → `v2::…`) for a
+ * purely additive vocabulary change; existing keys are untouched and judge
+ * keys are new, so no collision is possible. A v2 bump is reserved for
+ * changes that alter the MEANING of existing entries or the shape hash.
  */
 declare const DIALECT_VERSION: "v1";
 declare const INTENT_ARCHETYPES: {
@@ -62,6 +69,11 @@ declare const INTENT_ARCHETYPES: {
         readonly description: "Change format or style while preserving content";
         readonly examples: ["markdown → html", "formal → casual", "translate"];
     };
+    readonly judge: {
+        readonly name: "judge";
+        readonly description: "Pairwise comparison of two candidate outputs for the same input";
+        readonly examples: ["golden-set eval A/B verdict", "model-swap non-inferiority check", "response bake-off"];
+    };
 };
 type IntentArchetypeName = keyof typeof INTENT_ARCHETYPES;
 declare const ALL_ARCHETYPES: IntentArchetypeName[];
@@ -82,6 +94,32 @@ interface ShapeSignature {
     /** Whether the prompt includes few-shot examples. */
     hasExamples: boolean;
 }
+/**
+ * SINGLE source of truth for a call's output shape.
+ *
+ * Two independent expressions of this concept used to exist — `computeShape`
+ * (three-valued, feeding `compile_outcomes.shape_key`) and compile()'s Factor C
+ * screen (two-valued). They disagreed on exactly one case: tools present with
+ * no `structuredOutput`, which the shape signature calls `tool_call` and the
+ * screen called `text`. That gap let alpha.68's shape-altering discipline gates
+ * fire on tool-call surfaces — the surface class the design contract names as
+ * forbidden, because labelling claims inside a tool-call envelope manufactures
+ * the structured-output violations alpha.66 ships a retry for.
+ *
+ * A consumer `declared` value WINS over inference. The inference cannot see
+ * that an agentic surface carrying tools ultimately emits prose, so it is
+ * deliberately conservative — wrongly firing a shape-altering rule breaks a
+ * parser, wrongly withholding one only forgoes a lift. `constraints.outputMode`
+ * is the escape hatch for surfaces that know better.
+ *
+ * Takes the facts rather than a `PromptIR` so `dialect.ts` stays
+ * dependency-free (`ir.ts` imports THIS module, not the reverse).
+ */
+declare function resolveOutputMode(args: {
+    declared?: OutputMode;
+    structuredOutput?: boolean;
+    toolCount: number;
+}): OutputMode;
 declare function bucketContext(tokens: number): ContextBucket;
 declare function bucketToolCount(count: number): ToolCountBucket;
 declare function bucketHistory(turnCount: number): HistoryDepth;
@@ -96,4 +134,4 @@ declare function hashShape(s: ShapeSignature): string;
  */
 declare function learningKey(archetype: IntentArchetypeName, model: string, shape: ShapeSignature): string;
 
-export { ALL_ARCHETYPES, type ContextBucket, DIALECT_VERSION, type HistoryDepth, INTENT_ARCHETYPES, type IntentArchetypeName, type OutputMode, type ShapeSignature, type ToolCountBucket, bucketContext, bucketHistory, bucketToolCount, hashShape, isArchetype, learningKey };
+export { ALL_ARCHETYPES, type ContextBucket, DIALECT_VERSION, type HistoryDepth, INTENT_ARCHETYPES, type IntentArchetypeName, type OutputMode, type ShapeSignature, type ToolCountBucket, bucketContext, bucketHistory, bucketToolCount, hashShape, isArchetype, learningKey, resolveOutputMode };

package/dist/dialect.d.ts

@@ -12,8 +12,15 @@
  * The brain learns by `(archetype, model, shape)` tuples. Apps that declare
  * the same tuple inherit each other's mutations.
  *
- * v1 is intentionally small (9 archetypes, 5 shape dimensions). New entries
- * arrive in v2/v3 from real usage signals — never speculatively.
+ * v1 is intentionally small (10 archetypes, 5 shape dimensions). New entries
+ * arrive from real usage signals — never speculatively.
+ *
+ * Versioning note (alpha.62): `judge` was added as an ADDITIVE 10th entry
+ * under dialect-v1 rather than bumping to v2. Bumping the version string
+ * would fragment every existing learning key (`v1::…` → `v2::…`) for a
+ * purely additive vocabulary change; existing keys are untouched and judge
+ * keys are new, so no collision is possible. A v2 bump is reserved for
+ * changes that alter the MEANING of existing entries or the shape hash.
  */
 declare const DIALECT_VERSION: "v1";
 declare const INTENT_ARCHETYPES: {
@@ -62,6 +69,11 @@ declare const INTENT_ARCHETYPES: {
         readonly description: "Change format or style while preserving content";
         readonly examples: ["markdown → html", "formal → casual", "translate"];
     };
+    readonly judge: {
+        readonly name: "judge";
+        readonly description: "Pairwise comparison of two candidate outputs for the same input";
+        readonly examples: ["golden-set eval A/B verdict", "model-swap non-inferiority check", "response bake-off"];
+    };
 };
 type IntentArchetypeName = keyof typeof INTENT_ARCHETYPES;
 declare const ALL_ARCHETYPES: IntentArchetypeName[];
@@ -82,6 +94,32 @@ interface ShapeSignature {
     /** Whether the prompt includes few-shot examples. */
     hasExamples: boolean;
 }
+/**
+ * SINGLE source of truth for a call's output shape.
+ *
+ * Two independent expressions of this concept used to exist — `computeShape`
+ * (three-valued, feeding `compile_outcomes.shape_key`) and compile()'s Factor C
+ * screen (two-valued). They disagreed on exactly one case: tools present with
+ * no `structuredOutput`, which the shape signature calls `tool_call` and the
+ * screen called `text`. That gap let alpha.68's shape-altering discipline gates
+ * fire on tool-call surfaces — the surface class the design contract names as
+ * forbidden, because labelling claims inside a tool-call envelope manufactures
+ * the structured-output violations alpha.66 ships a retry for.
+ *
+ * A consumer `declared` value WINS over inference. The inference cannot see
+ * that an agentic surface carrying tools ultimately emits prose, so it is
+ * deliberately conservative — wrongly firing a shape-altering rule breaks a
+ * parser, wrongly withholding one only forgoes a lift. `constraints.outputMode`
+ * is the escape hatch for surfaces that know better.
+ *
+ * Takes the facts rather than a `PromptIR` so `dialect.ts` stays
+ * dependency-free (`ir.ts` imports THIS module, not the reverse).
+ */
+declare function resolveOutputMode(args: {
+    declared?: OutputMode;
+    structuredOutput?: boolean;
+    toolCount: number;
+}): OutputMode;
 declare function bucketContext(tokens: number): ContextBucket;
 declare function bucketToolCount(count: number): ToolCountBucket;
 declare function bucketHistory(turnCount: number): HistoryDepth;
@@ -96,4 +134,4 @@ declare function hashShape(s: ShapeSignature): string;
  */
 declare function learningKey(archetype: IntentArchetypeName, model: string, shape: ShapeSignature): string;
 
-export { ALL_ARCHETYPES, type ContextBucket, DIALECT_VERSION, type HistoryDepth, INTENT_ARCHETYPES, type IntentArchetypeName, type OutputMode, type ShapeSignature, type ToolCountBucket, bucketContext, bucketHistory, bucketToolCount, hashShape, isArchetype, learningKey };
+export { ALL_ARCHETYPES, type ContextBucket, DIALECT_VERSION, type HistoryDepth, INTENT_ARCHETYPES, type IntentArchetypeName, type OutputMode, type ShapeSignature, type ToolCountBucket, bucketContext, bucketHistory, bucketToolCount, hashShape, isArchetype, learningKey, resolveOutputMode };

package/dist/dialect.js

@@ -28,7 +28,8 @@ __export(dialect_exports, {
   bucketToolCount: () => bucketToolCount,
   hashShape: () => hashShape,
   isArchetype: () => isArchetype,
-  learningKey: () => learningKey
+  learningKey: () => learningKey,
+  resolveOutputMode: () => resolveOutputMode
 });
 module.exports = __toCommonJS(dialect_exports);
 var DIALECT_VERSION = "v1";
@@ -77,12 +78,22 @@ var INTENT_ARCHETYPES = {
     name: "transform",
     description: "Change format or style while preserving content",
     examples: ["markdown \u2192 html", "formal \u2192 casual", "translate"]
+  },
+  judge: {
+    name: "judge",
+    description: "Pairwise comparison of two candidate outputs for the same input",
+    examples: ["golden-set eval A/B verdict", "model-swap non-inferiority check", "response bake-off"]
   }
 };
 var ALL_ARCHETYPES = Object.keys(INTENT_ARCHETYPES);
 function isArchetype(name) {
   return name in INTENT_ARCHETYPES;
 }
+function resolveOutputMode(args) {
+  if (args.declared) return args.declared;
+  if (args.structuredOutput === true) return "json";
+  return args.toolCount > 0 ? "tool_call" : "text";
+}
 function bucketContext(tokens) {
   if (tokens < 1e3) return "tiny";
   if (tokens < 4e3) return "small";
@@ -123,5 +134,6 @@ function learningKey(archetype, model, shape) {
   bucketToolCount,
   hashShape,
   isArchetype,
-  learningKey
+  learningKey,
+  resolveOutputMode
 });

package/dist/dialect.mjs

@@ -7,8 +7,9 @@ import {
   bucketToolCount,
   hashShape,
   isArchetype,
-  learningKey
-} from "./chunk-5TI6PNSK.mjs";
+  learningKey,
+  resolveOutputMode
+} from "./chunk-BVEXV5KC.mjs";
 export {
   ALL_ARCHETYPES,
   DIALECT_VERSION,
@@ -18,5 +19,6 @@ export {
   bucketToolCount,
   hashShape,
   isArchetype,
-  learningKey
+  learningKey,
+  resolveOutputMode
 };

package/dist/glassbox/index.d.mts

@@ -0,0 +1,59 @@
+import { G as GlassboxEvent } from '../types-DsEq35WY.mjs';
+export { A as AdvisoryFiredData, C as CompileDoneData, a as CompileStartData, E as ExecuteAttemptData, b as ExecuteSuccessData, F as FallbackWalkedData, c as GLASSBOX_STREAM_TTL_MS, d as GlassboxEventKind, e as GlassboxPubSub } from '../types-DsEq35WY.mjs';
+import '../ir-Bqn1RVdV.mjs';
+import '../dialect.mjs';
+
+/**
+ * subscribe(traceId) — public Glass-Box subscription export.
+ *
+ * Consumer route handlers (e.g. Vercel Edge `/api/glassbox/stream`) import
+ * this and bridge the ReadableStream to SSE. The browser-side panel then
+ * renders events in real time:
+ *
+ *   import { subscribe } from '@warmdrift/kgauto-compiler/glassbox';
+ *
+ *   export async function GET(req: Request) {
+ *     const { searchParams } = new URL(req.url);
+ *     const traceId = searchParams.get('traceId');
+ *     if (!traceId) return new Response('missing traceId', { status: 400 });
+ *     const stream = subscribe(traceId);
+ *     // ... bridge ReadableStream<GlassboxEvent> → SSE here ...
+ *   }
+ *
+ * Stream behavior:
+ *   - Emits events for `traceId` as they're published.
+ *   - Closes cleanly 60s after the last event (rolling TTL).
+ *   - If no events arrive within 60s of subscription, closes empty.
+ *   - Multiple subscribers on the same traceId all fan out.
+ *
+ * No replay: subscribe() picks up only events published AFTER subscription.
+ * Replay is the brain-poll surface's job (see design doc).
+ */
+
+/**
+ * Subscribe to Glass-Box events for a traceId. Returns a ReadableStream
+ * that yields GlassboxEvent objects until the per-trace TTL elapses.
+ *
+ * Cancelling the stream (consumer disconnect, AbortController, etc.) tears
+ * down the subscription cleanly via the underlying adapter.
+ */
+declare function subscribe(traceId: string): ReadableStream<GlassboxEvent>;
+/**
+ * Subscribe to Glass-Box events for ALL traces under an appId — the
+ * "tail-all" surface (alpha.26). Backs the extension's default Live mode:
+ * rather than needing a specific traceId ahead of time, the panel sees
+ * every event for the configured consumer as calls happen.
+ *
+ * Per-app routing fires only when emit call-sites pass `appId` (the typed
+ * builders thread `ir.appId` automatically). Per-trace channel continues to
+ * fire for `subscribe(traceId)` callers — both arms are independent.
+ *
+ * Cross-tenant isolation: the consumer's `/api/glassbox/stream` uses the
+ * factory's configured appId — no caller-supplied `?appId=` URL parameter,
+ * so a consumer cannot subscribe to another consumer's stream.
+ */
+declare function subscribeApp({ appId, }: {
+    appId: string;
+}): ReadableStream<GlassboxEvent>;
+
+export { GlassboxEvent, subscribe, subscribeApp };

package/dist/glassbox/index.d.ts

@@ -0,0 +1,59 @@
+import { G as GlassboxEvent } from '../types-Bon96eyc.js';
+export { A as AdvisoryFiredData, C as CompileDoneData, a as CompileStartData, E as ExecuteAttemptData, b as ExecuteSuccessData, F as FallbackWalkedData, c as GLASSBOX_STREAM_TTL_MS, d as GlassboxEventKind, e as GlassboxPubSub } from '../types-Bon96eyc.js';
+import '../ir-Bvlkw5ja.js';
+import '../dialect.js';
+
+/**
+ * subscribe(traceId) — public Glass-Box subscription export.
+ *
+ * Consumer route handlers (e.g. Vercel Edge `/api/glassbox/stream`) import
+ * this and bridge the ReadableStream to SSE. The browser-side panel then
+ * renders events in real time:
+ *
+ *   import { subscribe } from '@warmdrift/kgauto-compiler/glassbox';
+ *
+ *   export async function GET(req: Request) {
+ *     const { searchParams } = new URL(req.url);
+ *     const traceId = searchParams.get('traceId');
+ *     if (!traceId) return new Response('missing traceId', { status: 400 });
+ *     const stream = subscribe(traceId);
+ *     // ... bridge ReadableStream<GlassboxEvent> → SSE here ...
+ *   }
+ *
+ * Stream behavior:
+ *   - Emits events for `traceId` as they're published.
+ *   - Closes cleanly 60s after the last event (rolling TTL).
+ *   - If no events arrive within 60s of subscription, closes empty.
+ *   - Multiple subscribers on the same traceId all fan out.
+ *
+ * No replay: subscribe() picks up only events published AFTER subscription.
+ * Replay is the brain-poll surface's job (see design doc).
+ */
+
+/**
+ * Subscribe to Glass-Box events for a traceId. Returns a ReadableStream
+ * that yields GlassboxEvent objects until the per-trace TTL elapses.
+ *
+ * Cancelling the stream (consumer disconnect, AbortController, etc.) tears
+ * down the subscription cleanly via the underlying adapter.
+ */
+declare function subscribe(traceId: string): ReadableStream<GlassboxEvent>;
+/**
+ * Subscribe to Glass-Box events for ALL traces under an appId — the
+ * "tail-all" surface (alpha.26). Backs the extension's default Live mode:
+ * rather than needing a specific traceId ahead of time, the panel sees
+ * every event for the configured consumer as calls happen.
+ *
+ * Per-app routing fires only when emit call-sites pass `appId` (the typed
+ * builders thread `ir.appId` automatically). Per-trace channel continues to
+ * fire for `subscribe(traceId)` callers — both arms are independent.
+ *
+ * Cross-tenant isolation: the consumer's `/api/glassbox/stream` uses the
+ * factory's configured appId — no caller-supplied `?appId=` URL parameter,
+ * so a consumer cannot subscribe to another consumer's stream.
+ */
+declare function subscribeApp({ appId, }: {
+    appId: string;
+}): ReadableStream<GlassboxEvent>;
+
+export { GlassboxEvent, subscribe, subscribeApp };

package/dist/glassbox/index.js

@@ -0,0 +1,312 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/glassbox/index.ts
+var glassbox_exports = {};
+__export(glassbox_exports, {
+  GLASSBOX_STREAM_TTL_MS: () => GLASSBOX_STREAM_TTL_MS,
+  subscribe: () => subscribe,
+  subscribeApp: () => subscribeApp
+});
+module.exports = __toCommonJS(glassbox_exports);
+
+// src/glassbox/types.ts
+var GLASSBOX_STREAM_TTL_MS = 6e4;
+
+// src/glassbox/pubsub-memory.ts
+var MemoryPubSub = class {
+  subscribers = /* @__PURE__ */ new Map();
+  async publish(channelKey, event) {
+    const subs = this.subscribers.get(channelKey);
+    if (!subs || subs.size === 0) return;
+    for (const sub of subs) {
+      if (sub.closed) continue;
+      try {
+        sub.controller.enqueue(event);
+      } catch {
+        sub.closed = true;
+        continue;
+      }
+      this.refreshTtl(channelKey, sub);
+    }
+  }
+  subscribe(channelKey) {
+    const self = this;
+    let sub;
+    return new ReadableStream({
+      start(controller) {
+        sub = {
+          controller,
+          ttlTimer: setTimeout(() => {
+            self.closeSubscriber(channelKey, sub);
+          }, GLASSBOX_STREAM_TTL_MS),
+          closed: false
+        };
+        let set = self.subscribers.get(channelKey);
+        if (!set) {
+          set = /* @__PURE__ */ new Set();
+          self.subscribers.set(channelKey, set);
+        }
+        set.add(sub);
+      },
+      cancel() {
+        if (sub) self.removeSubscriber(channelKey, sub);
+      }
+    });
+  }
+  /**
+   * Refresh the rolling TTL for a subscriber after an event lands. Replaces
+   * the existing timer with a fresh 60s one.
+   */
+  refreshTtl(channelKey, sub) {
+    clearTimeout(sub.ttlTimer);
+    sub.ttlTimer = setTimeout(() => {
+      this.closeSubscriber(channelKey, sub);
+    }, GLASSBOX_STREAM_TTL_MS);
+  }
+  /**
+   * Close the subscriber's stream cleanly and remove from the fan-out set.
+   * Idempotent — safe to call multiple times.
+   */
+  closeSubscriber(channelKey, sub) {
+    if (sub.closed) return;
+    sub.closed = true;
+    clearTimeout(sub.ttlTimer);
+    try {
+      sub.controller.close();
+    } catch {
+    }
+    this.removeSubscriber(channelKey, sub);
+  }
+  removeSubscriber(channelKey, sub) {
+    clearTimeout(sub.ttlTimer);
+    const set = this.subscribers.get(channelKey);
+    if (!set) return;
+    set.delete(sub);
+    if (set.size === 0) this.subscribers.delete(channelKey);
+  }
+  /**
+   * Test-only reset. Tears down all subscribers, clears all state. Calling
+   * outside of tests is harmless but cancels every active stream.
+   */
+  _reset() {
+    for (const [, set] of this.subscribers) {
+      for (const sub of set) {
+        this.closeSubscriber("", sub);
+      }
+    }
+    this.subscribers.clear();
+  }
+};
+
+// src/glassbox/pubsub-upstash.ts
+var UpstashPubSub = class {
+  url;
+  token;
+  fetchImpl;
+  blockMs;
+  maxLen;
+  constructor(cfg) {
+    this.url = cfg.url.replace(/\/$/, "");
+    this.token = cfg.token;
+    this.fetchImpl = cfg.fetchImpl ?? globalThis.fetch.bind(globalThis);
+    this.blockMs = cfg.blockMs ?? 100;
+    this.maxLen = cfg.maxLen ?? 100;
+  }
+  async publish(channelKey, event) {
+    const key = channelKey;
+    const payload = JSON.stringify(event);
+    await this.cmd([
+      "XADD",
+      key,
+      "MAXLEN",
+      "~",
+      String(this.maxLen),
+      "*",
+      "event",
+      payload
+    ]);
+    await this.cmd(["EXPIRE", key, String(Math.ceil(GLASSBOX_STREAM_TTL_MS / 1e3))]);
+  }
+  subscribe(channelKey) {
+    const key = channelKey;
+    const self = this;
+    let cursor = "$";
+    let cancelled = false;
+    let ttlDeadline = Date.now() + GLASSBOX_STREAM_TTL_MS;
+    return new ReadableStream({
+      async start(controller) {
+        try {
+          while (!cancelled && Date.now() < ttlDeadline) {
+            const resp = await self.cmd([
+              "XREAD",
+              "BLOCK",
+              String(self.blockMs),
+              "STREAMS",
+              key,
+              cursor
+            ]);
+            if (cancelled) break;
+            const parsed = parseXReadResult(resp.result);
+            if (parsed.entries.length === 0) {
+              continue;
+            }
+            for (const entry of parsed.entries) {
+              const evt = decodeEvent(entry.fields);
+              if (evt) {
+                try {
+                  controller.enqueue(evt);
+                } catch {
+                  cancelled = true;
+                  break;
+                }
+              }
+              cursor = entry.id;
+            }
+            ttlDeadline = Date.now() + GLASSBOX_STREAM_TTL_MS;
+          }
+        } catch (err) {
+          if (!cancelled) {
+            try {
+              controller.error(err);
+            } catch {
+            }
+            return;
+          }
+        }
+        try {
+          controller.close();
+        } catch {
+        }
+      },
+      cancel() {
+        cancelled = true;
+      }
+    });
+  }
+  async cmd(args) {
+    const res = await this.fetchImpl(this.url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(args)
+    });
+    if (!res.ok) {
+      throw new Error(`Upstash ${args[0]} failed: HTTP ${res.status}`);
+    }
+    const json = await res.json();
+    if (json.error) {
+      throw new Error(`Upstash ${args[0]} failed: ${json.error}`);
+    }
+    return json;
+  }
+};
+function traceChannel(traceId) {
+  return `glassbox:trace:${traceId}`;
+}
+function appChannel(appId) {
+  return `glassbox:app:${appId}`;
+}
+function decodeEvent(fields) {
+  const raw = fields["event"];
+  if (!raw) return void 0;
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.kind === "string" && typeof parsed.at === "number") {
+      return parsed;
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function parseXReadResult(raw) {
+  if (!Array.isArray(raw)) return { entries: [] };
+  const entries = [];
+  for (const stream of raw) {
+    if (!Array.isArray(stream) || stream.length < 2) continue;
+    const streamEntries = stream[1];
+    if (!Array.isArray(streamEntries)) continue;
+    for (const entry of streamEntries) {
+      if (!Array.isArray(entry) || entry.length < 2) continue;
+      const id = String(entry[0]);
+      const flat = entry[1];
+      if (!Array.isArray(flat)) continue;
+      const fields = {};
+      for (let i = 0; i < flat.length; i += 2) {
+        const k = flat[i];
+        const v = flat[i + 1];
+        if (typeof k === "string") fields[k] = String(v ?? "");
+      }
+      entries.push({ id, fields });
+    }
+  }
+  return { entries };
+}
+
+// src/glassbox/emit.ts
+var activePubSub;
+function getPubSub() {
+  if (activePubSub) return activePubSub;
+  const url = readEnv("UPSTASH_REDIS_URL");
+  const token = readEnv("UPSTASH_REDIS_TOKEN");
+  if (url && token) {
+    activePubSub = new UpstashPubSub({ url, token });
+  } else {
+    activePubSub = new MemoryPubSub();
+  }
+  return activePubSub;
+}
+function readEnv(key) {
+  try {
+    if (typeof process !== "undefined" && process.env) {
+      const v = process.env[key];
+      return v && v.trim() !== "" ? v : void 0;
+    }
+  } catch {
+  }
+  return void 0;
+}
+
+// src/glassbox/subscribe.ts
+function emptyStream() {
+  return new ReadableStream({
+    start(controller) {
+      controller.close();
+    }
+  });
+}
+function subscribe(traceId) {
+  if (!traceId) return emptyStream();
+  return getPubSub().subscribe(traceChannel(traceId));
+}
+function subscribeApp({
+  appId
+}) {
+  if (!appId) return emptyStream();
+  return getPubSub().subscribe(appChannel(appId));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GLASSBOX_STREAM_TTL_MS,
+  subscribe,
+  subscribeApp
+});

package/dist/glassbox/index.mjs

@@ -0,0 +1,12 @@
+import {
+  subscribe,
+  subscribeApp
+} from "../chunk-RO22VFIF.mjs";
+import {
+  GLASSBOX_STREAM_TTL_MS
+} from "../chunk-NBO4R5PC.mjs";
+export {
+  GLASSBOX_STREAM_TTL_MS,
+  subscribe,
+  subscribeApp
+};

package/dist/glassbox-routes/format.d.mts

@@ -0,0 +1,24 @@
+import { T as TraceHealth } from '../types-CwGhacGT.mjs';
+import '../ir-Bqn1RVdV.mjs';
+import '../dialect.mjs';
+
+/**
+ * Pure formatting helpers for Glass-Box trace display.
+ *
+ * Zero deps, no React, no design tokens. Safe to import from any consumer
+ * (React component, server route, CLI, Edge worker).
+ *
+ * Extracted from the alpha.32 tt-intelligence reference component port in
+ * alpha.35 so multiple consumer dashboards can render trace data with
+ * matching formatting without re-implementing each helper.
+ */
+
+declare function formatAgo(iso: string, now?: number): string;
+declare function shortTraceId(traceId: string): string;
+declare function formatCost(usd: number | undefined | null): string;
+declare function formatMs(ms: number | undefined | null): string;
+declare function formatOrDash(v: number | string | undefined | null): string;
+declare function inputRatioLabel(status: TraceHealth['inputRatioStatus']): string;
+declare function formatMutation(mutation: string): string;
+
+export { formatAgo, formatCost, formatMs, formatMutation, formatOrDash, inputRatioLabel, shortTraceId };