svoose 0.1.0

package/README.md

@@ -0,0 +1,321 @@
+# svoose
+
+> Svelte + Goose = **svoose** — the goose that sees everything
+
+Lightweight observability + state machines for Svelte 5. Zero dependencies. Tree-shakeable. **< 3KB gzipped**.
+
+## Features
+
+- **Web Vitals** — CLS, LCP, FID, INP, FCP, TTFB (no external deps)
+- **Error Tracking** — global errors + unhandled rejections
+- **State Machines** — minimal FSM with TypeScript inference
+- **Svelte 5** — works with runes ($state)
+- **Tree-shakeable** — pay only for what you use
+
+## Installation
+
+```bash
+npm install svoose
+```
+
+## Quick Start
+
+```typescript
+import { observe, createMachine } from 'svoose';
+
+// Start collecting metrics
+observe({ endpoint: '/api/metrics' });
+
+// Create a state machine
+const auth = createMachine({
+  id: 'auth',
+  initial: 'idle',
+  context: { user: null },
+  states: {
+    idle: { on: { LOGIN: 'loading' } },
+    loading: {
+      on: {
+        SUCCESS: {
+          target: 'authenticated',
+          action: (ctx, e) => ({ user: e.user }),
+        },
+        ERROR: 'idle',
+      },
+    },
+    authenticated: { on: { LOGOUT: 'idle' } },
+  },
+  observe: true, // Track transitions
+});
+
+// Use it
+auth.send('LOGIN');
+auth.state; // 'loading'
+auth.context; // { user: null }
+```
+
+## API
+
+### `observe(options?)`
+
+Start collecting Web Vitals and errors.
+
+```typescript
+const cleanup = observe({
+  // Where to send data
+  endpoint: '/api/metrics',
+
+  // Or use custom transport
+  transport: myTransport,
+
+  // What to collect
+  vitals: true,              // or ['CLS', 'LCP', 'INP']
+  errors: true,
+
+  // Batching
+  batchSize: 10,
+  flushInterval: 5000,
+
+  // Sampling
+  sampleRate: 0.1,           // 10% of users
+
+  // Debug
+  debug: false,
+});
+
+// Stop observing
+cleanup();
+```
+
+### `createMachine(config)`
+
+Create a state machine.
+
+```typescript
+const machine = createMachine({
+  id: 'toggle',
+  initial: 'off',
+  context: { count: 0 },
+  states: {
+    off: {
+      on: { TOGGLE: 'on' },
+    },
+    on: {
+      entry: (ctx) => ({ count: ctx.count + 1 }),
+      on: { TOGGLE: 'off' },
+    },
+  },
+});
+
+// State & context (reactive in Svelte 5)
+machine.state;              // 'off'
+machine.context;            // { count: 0 }
+
+// Check state
+machine.matches('off');     // true
+machine.matchesAny('on', 'off'); // true
+
+// Check if event is valid
+machine.can('TOGGLE');      // true
+
+// Send events
+machine.send('TOGGLE');
+machine.send({ type: 'SET', value: 42 });
+
+// Cleanup
+machine.destroy();
+```
+
+### Guards & Actions
+
+```typescript
+const counter = createMachine({
+  id: 'counter',
+  initial: 'active',
+  context: { count: 0 },
+  states: {
+    active: {
+      on: {
+        INCREMENT: {
+          target: 'active',
+          guard: (ctx) => ctx.count < 10,    // Only if count < 10
+          action: (ctx) => ({ count: ctx.count + 1 }),
+        },
+        DECREMENT: {
+          target: 'active',
+          guard: (ctx) => ctx.count > 0,     // Only if count > 0
+          action: (ctx) => ({ count: ctx.count - 1 }),
+        },
+      },
+    },
+  },
+});
+```
+
+### Entry & Exit Actions
+
+```typescript
+const wizard = createMachine({
+  id: 'wizard',
+  initial: 'step1',
+  context: { data: {} },
+  states: {
+    step1: {
+      entry: (ctx) => console.log('Entered step 1'),
+      exit: (ctx) => console.log('Leaving step 1'),
+      on: { NEXT: 'step2' },
+    },
+    step2: {
+      on: { BACK: 'step1', SUBMIT: 'complete' },
+    },
+    complete: {
+      entry: (ctx) => console.log('Done!'),
+    },
+  },
+});
+```
+
+### Observability Integration
+
+Machines automatically integrate with `observe()`:
+
+```typescript
+// Errors include machine context
+observe({ errors: true });
+
+const auth = createMachine({
+  id: 'auth',
+  observe: true, // Track transitions
+  // or
+  observe: {
+    transitions: true,
+    context: true, // Include context in events
+  },
+});
+
+// When an error occurs, it includes:
+// { machineId: 'auth', machineState: 'loading', ... }
+```
+
+### Custom Transport
+
+```typescript
+import { observe, createFetchTransport, createConsoleTransport } from 'svoose';
+
+// Fetch with custom headers
+const transport = createFetchTransport('/api/metrics', {
+  headers: { 'Authorization': 'Bearer xxx' },
+  onError: (err) => console.error(err),
+});
+
+// Console (for development)
+observe({ transport: createConsoleTransport({ pretty: true }) });
+
+// Custom transport
+const myTransport = {
+  async send(events) {
+    await myApi.track(events);
+  },
+};
+```
+
+## Bundle Size
+
+| Import | Size (gzip) |
+|--------|-------------|
+| Full bundle | ~2.9 KB |
+| `observe()` only | ~2.1 KB |
+| `createMachine()` only | ~0.7 KB |
+
+## TypeScript
+
+Full TypeScript support with inference:
+
+```typescript
+type AuthEvent =
+  | { type: 'LOGIN'; email: string }
+  | { type: 'SUCCESS'; user: User }
+  | { type: 'ERROR'; message: string }
+  | { type: 'LOGOUT' };
+
+const auth = createMachine<
+  { user: User | null; error: string | null },
+  'idle' | 'loading' | 'authenticated',
+  AuthEvent
+>({
+  id: 'auth',
+  initial: 'idle',
+  context: { user: null, error: null },
+  states: {
+    // States are type-checked
+    idle: {
+      on: {
+        // Events are type-checked
+        LOGIN: 'loading',
+      },
+    },
+    loading: {
+      on: {
+        SUCCESS: {
+          target: 'authenticated',
+          // event.user is typed as User
+          action: (ctx, event) => ({ user: event.user }),
+        },
+      },
+    },
+    authenticated: {
+      on: { LOGOUT: 'idle' },
+    },
+  },
+});
+
+auth.matches('idle');     // ✓ type-checked
+auth.matches('invalid');  // ✗ TypeScript error
+auth.send('LOGOUT');      // ✓ type-checked
+auth.send('INVALID');     // ✗ TypeScript error
+```
+
+## Svelte 5 Usage
+
+```svelte
+<script lang="ts">
+  import { observe, createMachine } from 'svoose';
+  import { onMount, onDestroy } from 'svelte';
+
+  // Start observing
+  let cleanup: (() => void) | null = null;
+
+  onMount(() => {
+    cleanup = observe({ endpoint: '/api/metrics' });
+  });
+
+  onDestroy(() => cleanup?.());
+
+  // State machine
+  const toggle = createMachine({
+    id: 'toggle',
+    initial: 'off',
+    states: {
+      off: { on: { TOGGLE: 'on' } },
+      on: { on: { TOGGLE: 'off' } },
+    },
+  });
+</script>
+
+<button onclick={() => toggle.send('TOGGLE')}>
+  {toggle.state}
+</button>
+
+{#if toggle.matches('on')}
+  <p>Light is on!</p>
+{/if}
+```
+
+## Roadmap
+
+- **v0.2** — `invoke()`, `spawn()`, `after()` (delayed transitions)
+- **v0.3** — Parallel states, history states, devtools
+- **v0.4** — svelte-reactor integration, SvelteKit hooks
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 🪿 svoose - Observability + State Machines for Svelte 5
+ *
+ * @packageDocumentation
+ */
+export { observe } from './observe/index.js';
+export type { ObserveOptions } from './observe/index.js';
+export { observeErrors, registerMachineContext, unregisterMachineContext, } from './observe/index.js';
+export type { ObserveErrorEvent, ErrorEvent, UnhandledRejectionEvent, } from './observe/index.js';
+export { observeCLS, observeLCP, observeFID, observeINP, observeFCP, observeTTFB, vitalObservers, } from './observe/index.js';
+export type { Metric, MetricName, MetricRating } from './observe/index.js';
+export { createFetchTransport, createConsoleTransport } from './transport/index.js';
+export type { Transport, TransportOptions } from './transport/index.js';
+export { createMachine, createEvent } from './machine/index.js';
+export type { MachineConfig, Machine, EventObject, StateNode, TransitionConfig, InferStates, InferEvents, InferContext, } from './machine/index.js';
+export type { VitalEvent, TransitionEvent, ObserveEvent, } from './types/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAC7C,YAAY,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAKzD,OAAO,EACL,aAAa,EACb,sBAAsB,EACtB,wBAAwB,GACzB,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EACV,iBAAiB,EACjB,UAAU,EACV,uBAAuB,GACxB,MAAM,oBAAoB,CAAC;AAK5B,OAAO,EACL,UAAU,EACV,UAAU,EACV,UAAU,EACV,UAAU,EACV,UAAU,EACV,WAAW,EACX,cAAc,GACf,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAK3E,OAAO,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AACpF,YAAY,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAKxE,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAChE,YAAY,EACV,aAAa,EACb,OAAO,EACP,WAAW,EACX,SAAS,EACT,gBAAgB,EAChB,WAAW,EACX,WAAW,EACX,YAAY,GACb,MAAM,oBAAoB,CAAC;AAK5B,YAAY,EACV,UAAU,EACV,eAAe,EACf,YAAY,GACb,MAAM,kBAAkB,CAAC"}

package/dist/index.js

@@ -0,0 +1,2 @@
+import{observe as t}from"./observe/index.js";import{observeErrors as n,registerMachineContext as s,unregisterMachineContext as i}from"./observe/index.js";import{observeCLS as v,observeLCP as a,observeFID as x,observeINP as b,observeFCP as c,observeTTFB as f,vitalObservers as m}from"./observe/index.js";import{createFetchTransport as d,createConsoleTransport as C}from"./transport/index.js";import{createMachine as j,createEvent as M}from"./machine/index.js";export{C as createConsoleTransport,M as createEvent,d as createFetchTransport,j as createMachine,t as observe,v as observeCLS,n as observeErrors,c as observeFCP,x as observeFID,b as observeINP,a as observeLCP,f as observeTTFB,s as registerMachineContext,i as unregisterMachineContext,m as vitalObservers};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/index.ts"],
+  "sourcesContent": ["/**\n * \uD83E\uDEBF svoose - Observability + State Machines for Svelte 5\n *\n * @packageDocumentation\n */\n\n// ============================================\n// Core Observability\n// ============================================\nexport { observe } from './observe/index.js';\nexport type { ObserveOptions } from './observe/index.js';\n\n// ============================================\n// Error Tracking\n// ============================================\nexport {\n  observeErrors,\n  registerMachineContext,\n  unregisterMachineContext,\n} from './observe/index.js';\nexport type {\n  ObserveErrorEvent,\n  ErrorEvent,\n  UnhandledRejectionEvent,\n} from './observe/index.js';\n\n// ============================================\n// Web Vitals\n// ============================================\nexport {\n  observeCLS,\n  observeLCP,\n  observeFID,\n  observeINP,\n  observeFCP,\n  observeTTFB,\n  vitalObservers,\n} from './observe/index.js';\nexport type { Metric, MetricName, MetricRating } from './observe/index.js';\n\n// ============================================\n// Transport\n// ============================================\nexport { createFetchTransport, createConsoleTransport } from './transport/index.js';\nexport type { Transport, TransportOptions } from './transport/index.js';\n\n// ============================================\n// State Machines\n// ============================================\nexport { createMachine, createEvent } from './machine/index.js';\nexport type {\n  MachineConfig,\n  Machine,\n  EventObject,\n  StateNode,\n  TransitionConfig,\n  InferStates,\n  InferEvents,\n  InferContext,\n} from './machine/index.js';\n\n// ============================================\n// Shared Types\n// ============================================\nexport type {\n  VitalEvent,\n  TransitionEvent,\n  ObserveEvent,\n} from './types/index.js';\n"],
+  "mappings": "AASA,OAAS,WAAAA,MAAe,qBAMxB,OACE,iBAAAC,EACA,0BAAAC,EACA,4BAAAC,MACK,qBAUP,OACE,cAAAC,EACA,cAAAC,EACA,cAAAC,EACA,cAAAC,EACA,cAAAC,EACA,eAAAC,EACA,kBAAAC,MACK,qBAMP,OAAS,wBAAAC,EAAsB,0BAAAC,MAA8B,uBAM7D,OAAS,iBAAAC,EAAe,eAAAC,MAAmB",
+  "names": ["observe", "observeErrors", "registerMachineContext", "unregisterMachineContext", "observeCLS", "observeLCP", "observeFID", "observeINP", "observeFCP", "observeTTFB", "vitalObservers", "createFetchTransport", "createConsoleTransport", "createMachine", "createEvent"]
+}

package/dist/machine/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Machine module exports
+ */
+export { createMachine } from './machine.svelte.js';
+export type { MachineConfig, Machine, EventObject, StateNode, TransitionConfig, InferStates, InferEvents, InferContext, } from './types.js';
+/**
+ * Helper to create typed events
+ *
+ * @example
+ * const loginEvent = createEvent('LOGIN', { email: 'test@example.com' });
+ */
+export declare function createEvent<T extends string>(type: T): {
+    type: T;
+};
+export declare function createEvent<T extends string, P extends object>(type: T, payload: P): {
+    type: T;
+} & P;
+//# sourceMappingURL=index.d.ts.map

package/dist/machine/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/machine/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,YAAY,EACV,aAAa,EACb,OAAO,EACP,WAAW,EACX,SAAS,EACT,gBAAgB,EAChB,WAAW,EACX,WAAW,EACX,YAAY,GACb,MAAM,YAAY,CAAC;AAMpB;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG;IAAE,IAAI,EAAE,CAAC,CAAA;CAAE,CAAC;AACpE,wBAAgB,WAAW,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,EAC5D,IAAI,EAAE,CAAC,EACP,OAAO,EAAE,CAAC,GACT;IAAE,IAAI,EAAE,CAAC,CAAA;CAAE,GAAG,CAAC,CAAC"}

package/dist/machine/index.js

@@ -0,0 +1,2 @@
+import{createMachine as c}from"./machine.svelte.js";function n(e,t){return t?{type:e,...t}:{type:e}}export{n as createEvent,c as createMachine};
+//# sourceMappingURL=index.js.map

package/dist/machine/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/machine/index.ts"],
+  "sourcesContent": ["/**\n * Machine module exports\n */\n\nexport { createMachine } from './machine.svelte.js';\nexport type {\n  MachineConfig,\n  Machine,\n  EventObject,\n  StateNode,\n  TransitionConfig,\n  InferStates,\n  InferEvents,\n  InferContext,\n} from './types.js';\n\n// ============================================\n// Helper: createEvent\n// ============================================\n\n/**\n * Helper to create typed events\n *\n * @example\n * const loginEvent = createEvent('LOGIN', { email: 'test@example.com' });\n */\nexport function createEvent<T extends string>(type: T): { type: T };\nexport function createEvent<T extends string, P extends object>(\n  type: T,\n  payload: P\n): { type: T } & P;\nexport function createEvent(type: string, payload?: object) {\n  return payload ? { type, ...payload } : { type };\n}\n"],
+  "mappings": "AAIA,OAAS,iBAAAA,MAAqB,sBA2BvB,SAASC,EAAYC,EAAcC,EAAkB,CAC1D,OAAOA,EAAU,CAAE,KAAAD,EAAM,GAAGC,CAAQ,EAAI,CAAE,KAAAD,CAAK,CACjD",
+  "names": ["createMachine", "createEvent", "type", "payload"]
+}

package/dist/machine/machine.svelte.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Minimal FSM with Svelte 5 Runes support
+ *
+ * Note: When used with Svelte 5, state and context are reactive via $state.
+ * When used outside Svelte, they work as regular properties.
+ */
+import type { EventObject, MachineConfig, Machine } from './types.js';
+/**
+ * Create a state machine
+ *
+ * @example
+ * const toggle = createMachine({
+ *   id: 'toggle',
+ *   initial: 'off',
+ *   states: {
+ *     off: { on: { TOGGLE: 'on' } },
+ *     on: { on: { TOGGLE: 'off' } },
+ *   },
+ * });
+ *
+ * toggle.send('TOGGLE');
+ * console.log(toggle.state); // 'on'
+ */
+export declare function createMachine<TContext extends object, TState extends string, TEvent extends EventObject>(config: MachineConfig<TContext, TState, TEvent>): Machine<TContext, TState, TEvent>;
+export type { MachineConfig, Machine, EventObject, StateNode, TransitionConfig } from './types.js';
+//# sourceMappingURL=machine.svelte.d.ts.map

package/dist/machine/machine.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"machine.svelte.d.ts","sourceRoot":"","sources":["../../src/machine/machine.svelte.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EACV,WAAW,EACX,aAAa,EACb,OAAO,EAGR,MAAM,YAAY,CAAC;AAGpB;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,SAAS,MAAM,EACvB,MAAM,SAAS,MAAM,EACrB,MAAM,SAAS,WAAW,EAC1B,MAAM,EAAE,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,CAuKpF;AAGD,YAAY,EAAE,aAAa,EAAE,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC"}

package/dist/machine/machine.svelte.js

@@ -0,0 +1,2 @@
+import{registerMachineContext as b,unregisterMachineContext as C}from"../observe/errors.js";import{getGlobalObserver as S}from"../observe/observe.svelte.js";function j(e){let o=e.initial,n=e.context?{...e.context}:{};const T=e.observe===!0?{transitions:!0,context:!1}:e.observe===!1||e.observe===void 0?{transitions:!1,context:!1}:e.observe;b(e.id,()=>o);const c=e.states[e.initial];if(c?.entry){const t=c.entry(n);t&&Object.assign(n,t)}function f(t,i){return t.on?.[i]}function u(t){const i=e.states[o];if(!i?.on)return!1;const r=f(i,t);return r?typeof r=="string"?!0:r.guard?r.guard(n,{type:t}):!0:!1}function y(t){const i=typeof t=="string"?{type:t}:t,r=e.states[o];if(!r?.on)return;const a=f(r,i.type);if(!a)return;const d=typeof a=="string"?a:a.target;if(typeof a=="object"&&a.guard&&!a.guard(n,i))return;const x=o;if(r.exit&&r.exit(n),typeof a=="object"&&a.action){const s=a.action(n,i);s&&Object.assign(n,s)}o=d;const p=e.states[o];if(p?.entry){const s=p.entry(n);s&&Object.assign(n,s)}if(T.transitions){const s=S();if(s){const E={type:"transition",machineId:e.id,from:x,to:o,event:i.type,timestamp:Date.now(),...T.context?{context:{...n}}:{}};s(E)}}}function v(){C(e.id)}return{get state(){return o},get context(){return n},matches(t){return o===t},matchesAny(...t){return t.includes(o)},can(t){return u(t)},send:y,destroy:v}}export{j as createMachine};
+//# sourceMappingURL=machine.svelte.js.map

package/dist/machine/machine.svelte.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/machine/machine.svelte.ts"],
+  "sourcesContent": ["/**\n * Minimal FSM with Svelte 5 Runes support\n *\n * Note: When used with Svelte 5, state and context are reactive via $state.\n * When used outside Svelte, they work as regular properties.\n */\n\nimport { registerMachineContext, unregisterMachineContext } from '../observe/errors.js';\nimport { getGlobalObserver } from '../observe/observe.svelte.js';\nimport type {\n  EventObject,\n  MachineConfig,\n  Machine,\n  StateNode,\n  TransitionConfig,\n} from './types.js';\nimport type { TransitionEvent } from '../types/index.js';\n\n/**\n * Create a state machine\n *\n * @example\n * const toggle = createMachine({\n *   id: 'toggle',\n *   initial: 'off',\n *   states: {\n *     off: { on: { TOGGLE: 'on' } },\n *     on: { on: { TOGGLE: 'off' } },\n *   },\n * });\n *\n * toggle.send('TOGGLE');\n * console.log(toggle.state); // 'on'\n */\nexport function createMachine<\n  TContext extends object,\n  TState extends string,\n  TEvent extends EventObject\n>(config: MachineConfig<TContext, TState, TEvent>): Machine<TContext, TState, TEvent> {\n  // Internal state - in Svelte 5 .svelte.ts files, these become reactive\n  let _state: TState = config.initial;\n  let _context: TContext = config.context ? { ...config.context } : ({} as TContext);\n\n  // Parse observe config\n  const observeConfig =\n    config.observe === true\n      ? { transitions: true, context: false }\n      : config.observe === false || config.observe === undefined\n        ? { transitions: false, context: false }\n        : config.observe;\n\n  // Register for error context tracking\n  registerMachineContext(config.id, () => _state);\n\n  // Run entry action for initial state\n  const initialState = config.states[config.initial];\n  if (initialState?.entry) {\n    const update = initialState.entry(_context);\n    if (update) {\n      Object.assign(_context, update);\n    }\n  }\n\n  /**\n   * Get transition config for an event\n   */\n  function getTransition(\n    stateConfig: StateNode<TContext, TState, TEvent>,\n    eventType: TEvent['type']\n  ): TransitionConfig<TContext, TState, TEvent> | TState | undefined {\n    return stateConfig.on?.[eventType as keyof typeof stateConfig.on] as\n      | TransitionConfig<TContext, TState, TEvent>\n      | TState\n      | undefined;\n  }\n\n  /**\n   * Check if a transition is valid (exists and guard passes)\n   */\n  function canTransition(eventType: TEvent['type']): boolean {\n    const stateConfig = config.states[_state];\n    if (!stateConfig?.on) return false;\n\n    const transition = getTransition(stateConfig, eventType);\n    if (!transition) return false;\n\n    // If it's just a target state string, it's always valid\n    if (typeof transition === 'string') return true;\n\n    // If there's a guard, check it (with empty event for can() check)\n    if (transition.guard) {\n      return transition.guard(_context, { type: eventType } as Extract<\n        TEvent,\n        { type: typeof eventType }\n      >);\n    }\n\n    return true;\n  }\n\n  /**\n   * Send an event to the machine\n   */\n  function send(event: TEvent | TEvent['type']): void {\n    const eventObj: TEvent =\n      typeof event === 'string' ? ({ type: event } as TEvent) : event;\n\n    const stateConfig = config.states[_state];\n    if (!stateConfig?.on) return;\n\n    const transition = getTransition(stateConfig, eventObj.type);\n    if (!transition) return;\n\n    const targetState: TState =\n      typeof transition === 'string' ? transition : transition.target;\n\n    // Check guard\n    if (typeof transition === 'object' && transition.guard) {\n      if (\n        !transition.guard(\n          _context,\n          eventObj as Extract<TEvent, { type: (typeof eventObj)['type'] }>\n        )\n      ) {\n        return;\n      }\n    }\n\n    const prevState = _state;\n\n    // Run exit action\n    if (stateConfig.exit) {\n      stateConfig.exit(_context);\n    }\n\n    // Run transition action\n    if (typeof transition === 'object' && transition.action) {\n      const update = transition.action(\n        _context,\n        eventObj as Extract<TEvent, { type: (typeof eventObj)['type'] }>\n      );\n      if (update) {\n        Object.assign(_context, update);\n      }\n    }\n\n    // Update state\n    _state = targetState;\n\n    // Run entry action for new state\n    const newStateConfig = config.states[_state];\n    if (newStateConfig?.entry) {\n      const update = newStateConfig.entry(_context);\n      if (update) {\n        Object.assign(_context, update);\n      }\n    }\n\n    // Emit observation event\n    if (observeConfig.transitions) {\n      const observer = getGlobalObserver();\n      if (observer) {\n        const transitionEvent: TransitionEvent = {\n          type: 'transition',\n          machineId: config.id,\n          from: prevState,\n          to: _state,\n          event: eventObj.type,\n          timestamp: Date.now(),\n          ...(observeConfig.context\n            ? { context: { ..._context } as Record<string, unknown> }\n            : {}),\n        };\n        observer(transitionEvent);\n      }\n    }\n  }\n\n  /**\n   * Cleanup machine\n   */\n  function destroy(): void {\n    unregisterMachineContext(config.id);\n  }\n\n  // Return machine instance\n  return {\n    get state(): TState {\n      return _state;\n    },\n    get context(): TContext {\n      return _context;\n    },\n    matches(state: TState): boolean {\n      return _state === state;\n    },\n    matchesAny(...states: TState[]): boolean {\n      return states.includes(_state);\n    },\n    can(eventType: TEvent['type']): boolean {\n      return canTransition(eventType);\n    },\n    send,\n    destroy,\n  };\n}\n\n// Re-export types\nexport type { MachineConfig, Machine, EventObject, StateNode, TransitionConfig } from './types.js';\n"],
+  "mappings": "AAOA,OAAS,0BAAAA,EAAwB,4BAAAC,MAAgC,uBACjE,OAAS,qBAAAC,MAAyB,+BA0B3B,SAASC,EAIdC,EAAoF,CAEpF,IAAIC,EAAiBD,EAAO,QACxBE,EAAqBF,EAAO,QAAU,CAAE,GAAGA,EAAO,OAAQ,EAAK,CAAC,EAGpE,MAAMG,EACJH,EAAO,UAAY,GACf,CAAE,YAAa,GAAM,QAAS,EAAM,EACpCA,EAAO,UAAY,IAASA,EAAO,UAAY,OAC7C,CAAE,YAAa,GAAO,QAAS,EAAM,EACrCA,EAAO,QAGfJ,EAAuBI,EAAO,GAAI,IAAMC,CAAM,EAG9C,MAAMG,EAAeJ,EAAO,OAAOA,EAAO,OAAO,EACjD,GAAII,GAAc,MAAO,CACvB,MAAMC,EAASD,EAAa,MAAMF,CAAQ,EACtCG,GACF,OAAO,OAAOH,EAAUG,CAAM,CAElC,CAKA,SAASC,EACPC,EACAC,EACiE,CACjE,OAAOD,EAAY,KAAKC,CAAwC,CAIlE,CAKA,SAASC,EAAcD,EAAoC,CACzD,MAAMD,EAAcP,EAAO,OAAOC,CAAM,EACxC,GAAI,CAACM,GAAa,GAAI,MAAO,GAE7B,MAAMG,EAAaJ,EAAcC,EAAaC,CAAS,EACvD,OAAKE,EAGD,OAAOA,GAAe,SAAiB,GAGvCA,EAAW,MACNA,EAAW,MAAMR,EAAU,CAAE,KAAMM,CAAU,CAGnD,EAGI,GAbiB,EAc1B,CAKA,SAASG,EAAKC,EAAsC,CAClD,MAAMC,EACJ,OAAOD,GAAU,SAAY,CAAE,KAAMA,CAAM,EAAeA,EAEtDL,EAAcP,EAAO,OAAOC,CAAM,EACxC,GAAI,CAACM,GAAa,GAAI,OAEtB,MAAMG,EAAaJ,EAAcC,EAAaM,EAAS,IAAI,EAC3D,GAAI,CAACH,EAAY,OAEjB,MAAMI,EACJ,OAAOJ,GAAe,SAAWA,EAAaA,EAAW,OAG3D,GAAI,OAAOA,GAAe,UAAYA,EAAW,OAE7C,CAACA,EAAW,MACVR,EACAW,CACF,EAEA,OAIJ,MAAME,EAAYd,EAQlB,GALIM,EAAY,MACdA,EAAY,KAAKL,CAAQ,EAIvB,OAAOQ,GAAe,UAAYA,EAAW,OAAQ,CACvD,MAAML,EAASK,EAAW,OACxBR,EACAW,CACF,EACIR,GACF,OAAO,OAAOH,EAAUG,CAAM,CAElC,CAGAJ,EAASa,EAGT,MAAME,EAAiBhB,EAAO,OAAOC,CAAM,EAC3C,GAAIe,GAAgB,MAAO,CACzB,MAAMX,EAASW,EAAe,MAAMd,CAAQ,EACxCG,GACF,OAAO,OAAOH,EAAUG,CAAM,CAElC,CAGA,GAAIF,EAAc,YAAa,CAC7B,MAAMc,EAAWnB,EAAkB,EACnC,GAAImB,EAAU,CACZ,MAAMC,EAAmC,CACvC,KAAM,aACN,UAAWlB,EAAO,GAClB,KAAMe,EACN,GAAId,EACJ,MAAOY,EAAS,KAChB,UAAW,KAAK,IAAI,EACpB,GAAIV,EAAc,QACd,CAAE,QAAS,CAAE,GAAGD,CAAS,CAA6B,EACtD,CAAC,CACP,EACAe,EAASC,CAAe,CAC1B,CACF,CACF,CAKA,SAASC,GAAgB,CACvBtB,EAAyBG,EAAO,EAAE,CACpC,CAGA,MAAO,CACL,IAAI,OAAgB,CAClB,OAAOC,CACT,EACA,IAAI,SAAoB,CACtB,OAAOC,CACT,EACA,QAAQkB,EAAwB,CAC9B,OAAOnB,IAAWmB,CACpB,EACA,cAAcC,EAA2B,CACvC,OAAOA,EAAO,SAASpB,CAAM,CAC/B,EACA,IAAIO,EAAoC,CACtC,OAAOC,EAAcD,CAAS,CAChC,EACA,KAAAG,EACA,QAAAQ,CACF,CACF",
+  "names": ["registerMachineContext", "unregisterMachineContext", "getGlobalObserver", "createMachine", "config", "_state", "_context", "observeConfig", "initialState", "update", "getTransition", "stateConfig", "eventType", "canTransition", "transition", "send", "event", "eventObj", "targetState", "prevState", "newStateConfig", "observer", "transitionEvent", "destroy", "state", "states"]
+}

package/dist/machine/types.d.ts

@@ -0,0 +1,71 @@
+/**
+ * State Machine Types
+ */
+export type EventObject = {
+    type: string;
+    [key: string]: unknown;
+};
+export type Action<TContext, TEvent extends EventObject = EventObject> = (context: TContext, event?: TEvent) => Partial<TContext> | void;
+export interface TransitionConfig<TContext, TState extends string, TEvent extends EventObject, K extends TEvent['type'] = TEvent['type']> {
+    /** Target state */
+    target: TState;
+    /** Guard condition - transition only if returns true */
+    guard?: (context: TContext, event: Extract<TEvent, {
+        type: K;
+    }>) => boolean;
+    /** Action to run during transition */
+    action?: (context: TContext, event: Extract<TEvent, {
+        type: K;
+    }>) => Partial<TContext> | void;
+}
+export type Transition<TContext, TState extends string, TEvent extends EventObject, K extends TEvent['type'] = TEvent['type']> = TState | TransitionConfig<TContext, TState, TEvent, K>;
+export interface StateNode<TContext, TState extends string, TEvent extends EventObject> {
+    /** Event handlers */
+    on?: {
+        [K in TEvent['type']]?: Transition<TContext, TState, TEvent, K>;
+    };
+    /** Action to run when entering this state */
+    entry?: Action<TContext, TEvent>;
+    /** Action to run when exiting this state */
+    exit?: Action<TContext, TEvent>;
+}
+export interface MachineConfig<TContext extends object, TState extends string, TEvent extends EventObject> {
+    /** Unique machine ID */
+    id: string;
+    /** Initial state */
+    initial: TState;
+    /** Initial context */
+    context?: TContext;
+    /** State definitions */
+    states: {
+        [K in TState]: StateNode<TContext, TState, TEvent>;
+    };
+    /** Observability options */
+    observe?: boolean | {
+        transitions?: boolean;
+        context?: boolean;
+    };
+}
+export interface Machine<TContext extends object, TState extends string, TEvent extends EventObject> {
+    /** Current state (reactive in Svelte 5) */
+    readonly state: TState;
+    /** Current context (reactive in Svelte 5) */
+    readonly context: TContext;
+    /** Check if machine is in given state */
+    matches(state: TState): boolean;
+    /** Check if machine is in any of given states */
+    matchesAny(...states: TState[]): boolean;
+    /** Check if event can be sent (has valid transition) */
+    can(eventType: TEvent['type']): boolean;
+    /** Send event to machine */
+    send(event: TEvent | TEvent['type']): void;
+    /** Cleanup machine (unregister from error tracking) */
+    destroy(): void;
+}
+/** Extract states from machine config */
+export type InferStates<T> = T extends MachineConfig<object, infer S, EventObject> ? S : never;
+/** Extract events from machine config */
+export type InferEvents<T> = T extends MachineConfig<object, string, infer E> ? E : never;
+/** Extract context from machine config */
+export type InferContext<T> = T extends MachineConfig<infer C, string, EventObject> ? C : never;
+//# sourceMappingURL=types.d.ts.map

package/dist/machine/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/machine/types.ts"],"names":[],"mappings":"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"}

package/dist/machine/types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=types.js.map

package/dist/machine/types.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/observe/errors.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Error tracking - captures errors and unhandled promise rejections
+ * Integrates with state machines to include machine context in error reports
+ */
+import type { ErrorEvent, UnhandledRejectionEvent, ObserveErrorEvent } from '../types/index.js';
+/**
+ * Register a machine's context for error tracking
+ * Called internally by createMachine()
+ */
+export declare function registerMachineContext(id: string, getState: () => string): void;
+/**
+ * Unregister a machine's context
+ * Called internally when machine is destroyed
+ */
+export declare function unregisterMachineContext(id: string): void;
+/**
+ * Observe global errors and unhandled promise rejections
+ * @param callback - Called for each error event
+ * @returns Cleanup function
+ */
+export declare function observeErrors(callback: (event: ObserveErrorEvent) => void): () => void;
+export type { ErrorEvent, UnhandledRejectionEvent, ObserveErrorEvent };
+//# sourceMappingURL=errors.d.ts.map

package/dist/observe/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/observe/errors.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAKhG;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,MAAM,GAAG,IAAI,CAE/E;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAEzD;AA4BD;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,GAC3C,MAAM,IAAI,CAsDZ;AAED,YAAY,EAAE,UAAU,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,CAAC"}

package/dist/observe/errors.js

@@ -0,0 +1,2 @@
+const i=new Map;function E(e,r){i.set(e,{getState:r})}function v(e){i.delete(e)}function a(){for(const[e,r]of i)try{return{machineId:e,machineState:r.getState()}}catch{}return{}}function c(){try{return typeof location<"u"?location.href:""}catch{return""}}function g(e){if(typeof window>"u")return()=>{};const r=t=>{const n={type:"error",message:t.message||"Unknown error",stack:t.error?.stack,filename:t.filename,lineno:t.lineno,colno:t.colno,timestamp:Date.now(),url:c(),...a()};e(n)},s=t=>{const n=t.reason;let o;if(n instanceof Error)o=n.message;else if(typeof n=="string")o=n;else try{o=JSON.stringify(n)}catch{o=String(n)}const d={type:"unhandled-rejection",reason:o,timestamp:Date.now(),url:c(),...a()};e(d)};return window.addEventListener("error",r),window.addEventListener("unhandledrejection",s),()=>{window.removeEventListener("error",r),window.removeEventListener("unhandledrejection",s)}}export{g as observeErrors,E as registerMachineContext,v as unregisterMachineContext};
+//# sourceMappingURL=errors.js.map

package/dist/observe/errors.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/observe/errors.ts"],
+  "sourcesContent": ["/**\n * Error tracking - captures errors and unhandled promise rejections\n * Integrates with state machines to include machine context in error reports\n */\n\nimport type { ErrorEvent, UnhandledRejectionEvent, ObserveErrorEvent } from '../types/index.js';\n\n// Global machine context registry (populated by createMachine)\nconst machineContexts = new Map<string, { getState: () => string }>();\n\n/**\n * Register a machine's context for error tracking\n * Called internally by createMachine()\n */\nexport function registerMachineContext(id: string, getState: () => string): void {\n  machineContexts.set(id, { getState });\n}\n\n/**\n * Unregister a machine's context\n * Called internally when machine is destroyed\n */\nexport function unregisterMachineContext(id: string): void {\n  machineContexts.delete(id);\n}\n\n/**\n * Get current machine context for error reports\n * Returns first active machine (could be enhanced for multiple)\n */\nfunction getMachineContext(): { machineId?: string; machineState?: string } {\n  for (const [id, ctx] of machineContexts) {\n    try {\n      return { machineId: id, machineState: ctx.getState() };\n    } catch {\n      // Machine might be in invalid state, skip it\n    }\n  }\n  return {};\n}\n\n/**\n * Get current URL safely\n */\nfunction getCurrentUrl(): string {\n  try {\n    return typeof location !== 'undefined' ? location.href : '';\n  } catch {\n    return '';\n  }\n}\n\n/**\n * Observe global errors and unhandled promise rejections\n * @param callback - Called for each error event\n * @returns Cleanup function\n */\nexport function observeErrors(\n  callback: (event: ObserveErrorEvent) => void\n): () => void {\n  // Check if we're in a browser environment\n  if (typeof window === 'undefined') {\n    return () => {};\n  }\n\n  const errorHandler = (event: globalThis.ErrorEvent) => {\n    const errorEvent: ErrorEvent = {\n      type: 'error',\n      message: event.message || 'Unknown error',\n      stack: event.error?.stack,\n      filename: event.filename,\n      lineno: event.lineno,\n      colno: event.colno,\n      timestamp: Date.now(),\n      url: getCurrentUrl(),\n      ...getMachineContext(),\n    };\n    callback(errorEvent);\n  };\n\n  const rejectionHandler = (event: PromiseRejectionEvent) => {\n    const reason = event.reason;\n    let message: string;\n\n    if (reason instanceof Error) {\n      message = reason.message;\n    } else if (typeof reason === 'string') {\n      message = reason;\n    } else {\n      try {\n        message = JSON.stringify(reason);\n      } catch {\n        message = String(reason);\n      }\n    }\n\n    const rejectionEvent: UnhandledRejectionEvent = {\n      type: 'unhandled-rejection',\n      reason: message,\n      timestamp: Date.now(),\n      url: getCurrentUrl(),\n      ...getMachineContext(),\n    };\n    callback(rejectionEvent);\n  };\n\n  window.addEventListener('error', errorHandler);\n  window.addEventListener('unhandledrejection', rejectionHandler);\n\n  return () => {\n    window.removeEventListener('error', errorHandler);\n    window.removeEventListener('unhandledrejection', rejectionHandler);\n  };\n}\n\nexport type { ErrorEvent, UnhandledRejectionEvent, ObserveErrorEvent };\n"],
+  "mappings": "AAQA,MAAMA,EAAkB,IAAI,IAMrB,SAASC,EAAuBC,EAAYC,EAA8B,CAC/EH,EAAgB,IAAIE,EAAI,CAAE,SAAAC,CAAS,CAAC,CACtC,CAMO,SAASC,EAAyBF,EAAkB,CACzDF,EAAgB,OAAOE,CAAE,CAC3B,CAMA,SAASG,GAAmE,CAC1E,SAAW,CAACH,EAAII,CAAG,IAAKN,EACtB,GAAI,CACF,MAAO,CAAE,UAAWE,EAAI,aAAcI,EAAI,SAAS,CAAE,CACvD,MAAQ,CAER,CAEF,MAAO,CAAC,CACV,CAKA,SAASC,GAAwB,CAC/B,GAAI,CACF,OAAO,OAAO,SAAa,IAAc,SAAS,KAAO,EAC3D,MAAQ,CACN,MAAO,EACT,CACF,CAOO,SAASC,EACdC,EACY,CAEZ,GAAI,OAAO,OAAW,IACpB,MAAO,IAAM,CAAC,EAGhB,MAAMC,EAAgBC,GAAiC,CACrD,MAAMC,EAAyB,CAC7B,KAAM,QACN,QAASD,EAAM,SAAW,gBAC1B,MAAOA,EAAM,OAAO,MACpB,SAAUA,EAAM,SAChB,OAAQA,EAAM,OACd,MAAOA,EAAM,MACb,UAAW,KAAK,IAAI,EACpB,IAAKJ,EAAc,EACnB,GAAGF,EAAkB,CACvB,EACAI,EAASG,CAAU,CACrB,EAEMC,EAAoBF,GAAiC,CACzD,MAAMG,EAASH,EAAM,OACrB,IAAII,EAEJ,GAAID,aAAkB,MACpBC,EAAUD,EAAO,gBACR,OAAOA,GAAW,SAC3BC,EAAUD,MAEV,IAAI,CACFC,EAAU,KAAK,UAAUD,CAAM,CACjC,MAAQ,CACNC,EAAU,OAAOD,CAAM,CACzB,CAGF,MAAME,EAA0C,CAC9C,KAAM,sBACN,OAAQD,EACR,UAAW,KAAK,IAAI,EACpB,IAAKR,EAAc,EACnB,GAAGF,EAAkB,CACvB,EACAI,EAASO,CAAc,CACzB,EAEA,cAAO,iBAAiB,QAASN,CAAY,EAC7C,OAAO,iBAAiB,qBAAsBG,CAAgB,EAEvD,IAAM,CACX,OAAO,oBAAoB,QAASH,CAAY,EAChD,OAAO,oBAAoB,qBAAsBG,CAAgB,CACnE,CACF",
+  "names": ["machineContexts", "registerMachineContext", "id", "getState", "unregisterMachineContext", "getMachineContext", "ctx", "getCurrentUrl", "observeErrors", "callback", "errorHandler", "event", "errorEvent", "rejectionHandler", "reason", "message", "rejectionEvent"]
+}

package/dist/observe/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Observe module exports
+ */
+export { observe, setGlobalObserver, getGlobalObserver } from './observe.svelte.js';
+export type { ObserveOptions } from './observe.svelte.js';
+export { observeErrors, registerMachineContext, unregisterMachineContext } from './errors.js';
+export type { ObserveErrorEvent, ErrorEvent, UnhandledRejectionEvent } from './errors.js';
+export { vitalObservers, observeCLS, observeLCP, observeFID, observeINP, observeFCP, observeTTFB } from './vitals.js';
+export type { Metric, MetricName, MetricRating } from './vitals.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/observe/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/observe/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACpF,YAAY,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,sBAAsB,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAC;AAC9F,YAAY,EAAE,iBAAiB,EAAE,UAAU,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAC1F,OAAO,EAAE,cAAc,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AACtH,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC"}

package/dist/observe/index.js

@@ -0,0 +1,2 @@
+import{observe as o,setGlobalObserver as t,getGlobalObserver as s}from"./observe.svelte.js";import{observeErrors as b,registerMachineContext as n,unregisterMachineContext as i}from"./errors.js";import{vitalObservers as a,observeCLS as l,observeLCP as x,observeFID as m,observeINP as c,observeFCP as f,observeTTFB as E}from"./vitals.js";export{s as getGlobalObserver,o as observe,l as observeCLS,b as observeErrors,f as observeFCP,m as observeFID,c as observeINP,x as observeLCP,E as observeTTFB,n as registerMachineContext,t as setGlobalObserver,i as unregisterMachineContext,a as vitalObservers};
+//# sourceMappingURL=index.js.map

package/dist/observe/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/observe/index.ts"],
+  "sourcesContent": ["/**\n * Observe module exports\n */\n\nexport { observe, setGlobalObserver, getGlobalObserver } from './observe.svelte.js';\nexport type { ObserveOptions } from './observe.svelte.js';\nexport { observeErrors, registerMachineContext, unregisterMachineContext } from './errors.js';\nexport type { ObserveErrorEvent, ErrorEvent, UnhandledRejectionEvent } from './errors.js';\nexport { vitalObservers, observeCLS, observeLCP, observeFID, observeINP, observeFCP, observeTTFB } from './vitals.js';\nexport type { Metric, MetricName, MetricRating } from './vitals.js';\n"],
+  "mappings": "AAIA,OAAS,WAAAA,EAAS,qBAAAC,EAAmB,qBAAAC,MAAyB,sBAE9D,OAAS,iBAAAC,EAAe,0BAAAC,EAAwB,4BAAAC,MAAgC,cAEhF,OAAS,kBAAAC,EAAgB,cAAAC,EAAY,cAAAC,EAAY,cAAAC,EAAY,cAAAC,EAAY,cAAAC,EAAY,eAAAC,MAAmB",
+  "names": ["observe", "setGlobalObserver", "getGlobalObserver", "observeErrors", "registerMachineContext", "unregisterMachineContext", "vitalObservers", "observeCLS", "observeLCP", "observeFID", "observeINP", "observeFCP", "observeTTFB"]
+}