@hanzo/event 0.3.32 → 0.3.34

package/src/stack.ts

@@ -0,0 +1,144 @@
+// Pure error parsing: coerce an unknown throwable into {name, message, stack},
+// and parse a browser stack string into structured frames. No I/O, no globals —
+// core.ts wires these to identity and transport.
+//
+// These frames ride the error Event to POST /v1/event so the warehouse stores
+// WHERE a crash happened, not just that one did. Nothing here talks to Sentry:
+// the client has one door and one credential. The frame shape is deliberately the
+// conventional one (function/filename/abs_path/lineno/colno/in_app) because it is
+// what every stack tool already speaks — including a future grouper built over
+// the warehouse.
+
+/** Max frames kept — well under the server's cap, plenty to identify a crash. */
+const MAX_FRAMES = 50
+/** Max stack lines examined, and max length of a line worth examining. Guards the
+ *  frame regexes against a hostile `stack` string (see framesFromStack). */
+const MAX_LINES = 500
+const MAX_LINE_LEN = 2048
+
+/** One parsed stack frame. */
+export interface Frame {
+  filename?: string
+  function?: string
+  abs_path?: string
+  lineno?: number
+  colno?: number
+  /** The app's own code, as opposed to vendor/runtime — the useful default filter. */
+  in_app?: boolean
+}
+
+const V8_FRAME = /^\s*at\s+(?:(.+?)\s+\()?(?:(.+?):(\d+):(\d+)|([^)]+))\)?\s*$/
+const MOZ_FRAME = /^\s*(?:(.*?)@)?(.+?):(\d+):(\d+)\s*$/
+
+/** inApp marks a frame as the app's own code (vs vendor/runtime). */
+function inApp(file: string): boolean {
+  if (!file) return false
+  return !(
+    file.includes('node_modules') ||
+    file.startsWith('webpack-internal') ||
+    file.startsWith('webpack://') ||
+    file.startsWith('chrome-extension://') ||
+    file.startsWith('moz-extension://')
+  )
+}
+
+/**
+ * framesFromStack parses a browser Error.stack into frames, OLDEST-FIRST (caller
+ * → callee, so the crash site is LAST). Handles both V8 ("at fn (file:li:co)")
+ * and Firefox/Safari ("fn@file:li:co"). Unparseable lines are skipped.
+ */
+export function framesFromStack(stack: string | undefined): Frame[] {
+  if (!stack) return []
+  // Both frame regexes use lazy nested quantifiers, which backtrack badly on a
+  // long line that never matches. A stack is attacker-influenced (a thrown value
+  // can carry any `stack` string), so bound the work: skip absurd lines and stop
+  // after MAX_LINES. Only the innermost MAX_FRAMES are kept anyway.
+  const lines = stack.split('\n', MAX_LINES)
+  const frames: Frame[] = []
+  for (const raw of lines) {
+    if (raw.length > MAX_LINE_LEN) continue
+    const line = raw.trimEnd()
+    if (!line) continue
+    // Header lines like "TypeError: x is not a function" match neither frame
+    // regex (no "at " prefix, no trailing :line:col) and are skipped naturally.
+    let fn: string | undefined
+    let file = ''
+    let lineno = 0
+    let colno = 0
+    const v = V8_FRAME.exec(line)
+    if (v) {
+      fn = v[1]
+      if (v[2]) {
+        file = v[2]
+        lineno = Number(v[3]) || 0
+        colno = Number(v[4]) || 0
+      } else {
+        file = (v[5] || '').trim()
+      }
+    } else {
+      const f = MOZ_FRAME.exec(line)
+      if (!f) continue
+      fn = f[1]
+      file = f[2]
+      lineno = Number(f[3]) || 0
+      colno = Number(f[4]) || 0
+    }
+    if (!file && !fn) continue
+    frames.push({
+      function: fn || '<anonymous>',
+      filename: file,
+      abs_path: file,
+      lineno,
+      colno,
+      in_app: inApp(file),
+    })
+  }
+  // Reverse to oldest-first and cap to the innermost MAX_FRAMES.
+  frames.reverse()
+  if (frames.length > MAX_FRAMES) return frames.slice(frames.length - MAX_FRAMES)
+  return frames
+}
+
+/** read pulls a property off a value that may be hostile — `name`, `message` and
+ *  `stack` are ordinary getters that a thrown object is free to define as
+ *  throwing. The thrown value is the least trustworthy input this library
+ *  handles; losing the whole report to one of them is not acceptable. */
+function read(o: unknown, k: string): unknown {
+  try {
+    return (o as Record<string, unknown>)[k]
+  } catch {
+    return undefined
+  }
+}
+
+/** str coerces to a string without letting a throwing toString/Symbol.toPrimitive
+ *  escape. */
+function str(v: unknown): string {
+  try {
+    return String(v)
+  } catch {
+    return '[unstringifiable]'
+  }
+}
+
+/** normalizeError coerces an unknown throwable into {name, message, stack}.
+ *  TOTAL: it returns a usable record for ANY input, including an object
+ *  engineered to throw on property access. */
+export function normalizeError(err: unknown): { name: string; message: string; stack?: string } {
+  if (err instanceof Error) {
+    const name = read(err, 'name')
+    const message = read(err, 'message')
+    const stack = read(err, 'stack')
+    return {
+      name: typeof name === 'string' && name ? name : 'Error',
+      message: typeof message === 'string' && message ? message : str(err),
+      stack: typeof stack === 'string' ? stack : undefined,
+    }
+  }
+  if (typeof err === 'string') return { name: 'Error', message: err }
+  try {
+    return { name: 'Error', message: JSON.stringify(err) ?? str(err) }
+  } catch {
+    return { name: 'Error', message: str(err) }
+  }
+}

package/src/storage.test.ts

@@ -8,7 +8,7 @@
 
 import { describe, it, expect, vi } from 'vitest'
 
-const ANON = 'hz_anon_id'
+const ANON = 'iam-anon-id'
 const LEGACY = '01920000-0000-7000-8000-0000000000aa'
 const OTHER = '01920000-0000-7000-8000-0000000000bb'
 
@@ -113,8 +113,8 @@ describe('anonId', () => {
     }
   })
 
-  it("adopts hz.js's `hz_id` when there is no canonical id to find", async () => {
-    // The no-build tag minted into a key of its own, so a browser that met hz.js
+  it("adopts a legacy `hz_id` when there is no canonical id to find", async () => {
+    // A no-build tag once minted into a key of its own, so a browser that met it
     // first already carries an identity — under a different name. Minting here
     // would make that visitor a stranger the moment they reach a bundled surface,
     // which is precisely the split this migration closes.

package/src/storage.ts

@@ -30,7 +30,7 @@ function ls(): Storage | undefined {
 
 /**
  * Stable anonymous id, shared by every *.hanzo.ai surface AND by every Hanzo
- * client on the page — the npm client, hz.js and the hosted tag all run the one
+ * client on the page — the npm client and the hosted tag both run the one
  * chain in ./anon.js, so which snippet a surface loaded no longer decides who the
  * visitor is.
  *

package/src/uid.ts

@@ -2,7 +2,7 @@
 //
 // The implementation is `hzUuidv7` in ./anon.js and this file only re-exports it.
 // It lives there because the anonymous-id chain has to mint too, and that chain is
-// inlined verbatim by two distributions that have no bundler (hz.js, and the tag
+// inlined verbatim by the distribution that has no bundler (the tag
 // the door hosts) — a minter here as well would be a second implementation, and
 // the version nibble it produces is exactly the thing that must never diverge.
 //

package/src/version.ts

@@ -1,4 +1,4 @@
 // The library version, stamped on every event (`libraryVersion`) and on the
 // Sentry `sdk` block. It lives alone so `sentry.ts` can read it without importing
 // `core.ts` — core imports sentry, so the reverse would be an import cycle.
-export const VERSION = '0.3.32'
+export const VERSION = '0.3.34'