@playgenx/components 0.1.0 → 0.2.1

package/bin/state-cli.mjs

@@ -0,0 +1,196 @@
+#!/usr/bin/env node
+// SPDX-License-Identifier: MIT
+/**
+ * playgenx-state — CLI for inspecting and operating on
+ * PlaygroundState snapshots.
+ *
+ * Pure ESM, no extra deps. Reads JSON from stdin (or argv),
+ * writes JSON to stdout.
+ *
+ * Subcommands:
+ *
+ *   snapshot    Pretty-print a snapshot in the v1 envelope format.
+ *               Accepts a JSON object on stdin (the snapshot you
+ *               captured from `state.snapshot()` or a DebugSurface).
+ *
+ *   validate    Validate one or more stateKey strings from stdin.
+ *               Reads a JSON array of strings, returns the per-key
+ *               verdict.
+ *
+ *   diff        Diff two snapshots. Reads `{prev, next}` from stdin
+ *               and returns the structured {added, changed, removed}
+ *               diff (or null when equal).
+ *
+ *   keys        List the sorted keys of a snapshot from stdin.
+ *
+ *   count       Count the keys in a snapshot from stdin.
+ *
+ * Usage examples (run from the components package root):
+ *
+ *   echo '{"volume": 5}' | node bin/state-cli.mjs snapshot
+ *   echo '["volume","user.name","bad key"]' | node bin/state-cli.mjs validate
+ *   echo '{"prev":{"a":1},"next":{"a":2,"b":3}}' | node bin/state-cli.mjs diff
+ *
+ * Exit codes:
+ *
+ *   0  success
+ *   1  bad subcommand
+ *   2  bad input (not parseable as JSON, wrong shape, etc.)
+ *   3  validation failure (one or more keys rejected)
+ *
+ * @packageDocumentation
+ */
+
+import {
+  dumpState,
+  diffSnapshots,
+  validateStateKey,
+} from '../dist/index.mjs';
+
+/**
+ * Read all of stdin into a string. Node-only.
+ */
+async function readStdin() {
+  if (process.stdin.isTTY) {
+    // Interactive / no pipe — return empty; the caller will treat
+    // this as "no input" and print usage.
+    return '';
+  }
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(typeof chunk === 'string' ? Buffer.from(chunk) : chunk);
+  }
+  return Buffer.concat(chunks).toString('utf8');
+}
+
+function usage() {
+  return [
+    'Usage: playgenx-state <subcommand> [input]',
+    '',
+    'Subcommands:',
+    '  snapshot    Pretty-print a state snapshot (JSON on stdin)',
+    '  validate    Validate an array of stateKey strings (JSON array on stdin)',
+    '  diff        Diff two snapshots ({prev, next} on stdin)',
+    '  keys        List sorted keys of a snapshot (JSON on stdin)',
+    '  count       Count keys in a snapshot (JSON on stdin)',
+    '',
+    'Reads from stdin when no arg is given.',
+  ].join('\n');
+}
+
+function ok(payload) {
+  process.stdout.write(JSON.stringify(payload, null, 2) + '\n');
+}
+
+function fail(code, msg) {
+  process.stderr.write(`error: ${msg}\n`);
+  process.exit(code);
+}
+
+/**
+ * Convert an arbitrary snapshot to the StateEnvelope shape. The
+ * input is whatever the caller passed; we expect a plain object.
+ */
+function envelope(input) {
+  const keys = Object.keys(input).sort();
+  return { version: 1, keys, values: { ...input } };
+}
+
+async function main(argv) {
+  const sub = argv[0];
+  if (!sub || sub === '-h' || sub === '--help') {
+    process.stdout.write(usage() + '\n');
+    return 0;
+  }
+  const stdinPayload = (await readStdin()).trim();
+  const argPayload = argv[1];
+
+  switch (sub) {
+    case 'snapshot': {
+      const input = parseObject(argPayload ?? stdinPayload);
+      // Re-use the library's envelope so the CLI output matches the
+      // canonical dumpState shape. (We don't have a real store to
+      // pass to dumpState; envelope() builds the same structure.)
+      const env = envelope(input);
+      process.stdout.write(JSON.stringify(env, null, 2) + '\n');
+      // Reference dumpState so it's not tree-shaken — the import
+      // is documented as the canonical envelope producer.
+      void dumpState;
+      return 0;
+    }
+
+    case 'validate': {
+      const input = parseArray(argPayload ?? stdinPayload);
+      const results = input.map((k) => {
+        if (typeof k !== 'string') {
+          return { key: String(k), ok: false, error: 'must be a string' };
+        }
+        const err = validateStateKey(k);
+        return err === null
+          ? { key: k, ok: true }
+          : { key: k, ok: false, error: err };
+      });
+      const anyFailed = results.some((r) => !r.ok);
+      ok(results);
+      return anyFailed ? 3 : 0;
+    }
+
+    case 'diff': {
+      const input = parseObject(argPayload ?? stdinPayload);
+      if (!('prev' in input) || !('next' in input)) {
+        fail(2, 'diff expects {prev, next}');
+      }
+      const prev = input.prev;
+      const next = input.next;
+      if (typeof prev !== 'object' || prev === null) fail(2, 'prev must be an object');
+      if (typeof next !== 'object' || next === null) fail(2, 'next must be an object');
+      const d = diffSnapshots(prev, next);
+      ok(d);
+      return 0;
+    }
+
+    case 'keys': {
+      const input = parseObject(argPayload ?? stdinPayload);
+      ok(Object.keys(input).sort());
+      return 0;
+    }
+
+    case 'count': {
+      const input = parseObject(argPayload ?? stdinPayload);
+      ok({ keys: Object.keys(input).length });
+      return 0;
+    }
+
+    default:
+      process.stderr.write(usage() + '\n');
+      return 1;
+  }
+}
+
+function parseObject(raw) {
+  if (raw === '') fail(2, 'expected a JSON object on stdin or as argv[1]');
+  try {
+    const v = JSON.parse(raw);
+    if (typeof v !== 'object' || v === null || Array.isArray(v)) {
+      fail(2, 'expected a JSON object');
+    }
+    return v;
+  } catch (err) {
+    fail(2, `JSON parse error: ${err.message}`);
+  }
+}
+
+function parseArray(raw) {
+  if (raw === '') fail(2, 'expected a JSON array on stdin or as argv[1]');
+  try {
+    const v = JSON.parse(raw);
+    if (!Array.isArray(v)) fail(2, 'expected a JSON array');
+    return v;
+  } catch (err) {
+    fail(2, `JSON parse error: ${err.message}`);
+  }
+}
+
+main(process.argv.slice(2))
+  .then((code) => process.exit(code))
+  .catch((err) => fail(2, err.message ?? String(err)));

package/dist/index.d.mts

@@ -54,12 +54,37 @@ interface SliderProps {
   step?: number;
   /** Optional caption rendered above the slider. */
   label?: string;
+  /**
+   * When set, the slider is "bound" to the playground state: initial
+   * value comes from state.get(stateKey), onChange writes state.set.
+   * `value` prop is ignored when stateKey is present.
+   */
+  stateKey?: string;
 }
 /**
- * Range input. State: internal `value` mirrors props.value if present
- * (otherwise uncontrolled); clamps to [min, max].
+ * Range input. Three operating modes:
+ *
+ *  1. **Uncontrolled** (no `value`, no `stateKey`): the slider owns
+ *     its value as local React state. The onChange mutates that state.
+ *     Use this when nothing else needs to observe the value.
+ *
+ *  2. **Controlled by `value` prop**: the slider is read-only —
+ *     user input is ignored because there is no `onChange` callback
+ *     wired by the deterministic renderer. Use this for "static"
+ *     sliders in artifacts. (If you want fully interactive control,
+ *     use mode 3.)
+ *
+ *  3. **Bound to PlaygroundState via `stateKey`**: the slider reads
+ *     its value from the nearest Provider's store (initial: either
+ *     the store's current value OR `value` prop, whichever is
+ *     present; the live store wins when bound). On change, the
+ *     slider writes to the store. Other components can subscribe
+ *     to the same key.
+ *
+ * In all modes the displayed value is clamped to `[min, max]`. NaN
+ * inputs clamp to `min`. When `min === max` the input is disabled.
  */
-declare function Slider({ min, max, value, step, label }: SliderProps): React.JSX.Element;
+declare function Slider({ min, max, value, step, label, stateKey }: SliderProps): React.JSX.Element;
 //#endregion
 //#region src/Chart.d.ts
 type ChartKind = 'bar' | 'line' | 'pie';
@@ -176,23 +201,310 @@ interface ListProps {
  */
 declare function List({ items, ordered, children }: ListProps): React.JSX.Element;
 //#endregion
-//#region src/registry.d.ts
+//#region src/state.d.ts
+/**
+ * Per-render state store. Components read/write values keyed by string.
+ * One store per Provider instance; nested Providers create nested scopes.
+ */
+interface PlaygroundState {
+  /** Read a value by key. Returns undefined if unset. */
+  get<T = unknown>(key: string): T | undefined;
+  /**
+   * Set a value. Triggers re-render of subscribers. No-op if the new
+   * value is `===` to the current value.
+   */
+  set<T = unknown>(key: string, value: T): void;
+  /**
+   * Subscribe to changes on a single key. The callback fires on every
+   * `set(key, ...)` with a different value. Returns an unsubscribe
+   * function. Non-React callers can use this directly.
+   */
+  subscribe(key: string, cb: (value: unknown) => void): () => void;
+  /**
+   * Bulk-read: returns a shallow snapshot of all keys. Useful for
+   * snapshotting state at a moment in time (e.g., for undo).
+   */
+  snapshot(): Readonly<Record<string, unknown>>;
+  /** Bulk-write: replace all values. Subscribers fire for changed keys. */
+  replaceAll(values: Record<string, unknown>): void;
+}
+/**
+ * Create a fresh state store. Public so PlaygroundStateProvider can
+ * construct one, but consumers should use Provider/usePlaygroundState
+ * to access stores (not direct construction).
+ *
+ * The optional type parameter is the "shape" of values you intend to
+ * store. It's purely a documentation convenience — the store does
+ * not enforce it (so you can store heterogeneous values for
+ * playgrounds that mix kinds), but `get<T>()` and `set<T>()` will
+ * infer correctly when you pass it here.
+ */
+declare function createPlaygroundState<T = unknown>(initial?: Record<string, T>): PlaygroundState;
+interface PlaygroundStateProviderProps {
+  /** Initial state values keyed by name. */
+  initial?: Record<string, unknown>;
+  /**
+   * Optional pre-existing state. If supplied, `initial` is merged on
+   * top (initial wins for overlapping keys). Use this for SSR
+   * rehydration or seeded values.
+   */
+  seed?: Record<string, unknown>;
+  children: React.ReactNode;
+}
+/**
+ * Provide a PlaygroundState scope to descendant components.
+ *
+ * Each Provider instance has its own store; nested Providers create
+ * independent scopes. Components rendered outside any Provider will
+ * throw a clear error if they call usePlaygroundState.
+ */
+declare function PlaygroundStateProvider(props: PlaygroundStateProviderProps): React.JSX.Element;
+/**
+ * Hook to access the nearest PlaygroundState store. Throws a clear
+ * error if called outside a Provider so consumers get a usable
+ * diagnostic instead of a `Cannot read properties of undefined`.
+ *
+ * Note for @playgenx/renderer users: the renderer's `renderBody`
+ * does NOT yet auto-wrap with a PlaygroundStateProvider. You'll
+ * need to wrap your own tree with `<PlaygroundStateProvider>` (or
+ * use the lower-level `renderNodes` API) before state-bound
+ * components can resolve. The `withState` option on `renderBody`
+ * is planned for a future renderer release (tracked in v0.6.0).
+ */
+declare function usePlaygroundState(): PlaygroundState;
+/**
+ * Optional helper for binding a component prop to a state key. Returns
+ * the live value (re-renders subscribers on change) and a setter. Pass
+ * `undefined` for `key` to disable the binding — the component behaves
+ * as if it had no stateKey, and `set` becomes a no-op. Safe to call
+ * outside a Provider.
+ *
+ * Implementation note: this hook ALWAYS calls the same number of
+ * React hooks regardless of whether `key` is set or a Provider is in
+ * scope. The "no binding" / "no Provider" branch uses dummy local
+ * state so the hook count stays aligned across renders. That means a
+ * component can flip `stateKey` from defined to undefined (or move in
+ * or out of a Provider) without crashing with a hooks-order error.
+ *
+ * Components that accept a `stateKey` prop should call this internally
+ * and use the returned tuple as a drop-in for the underlying
+ * value/onChange pair. The return type widens to `readonly [...] | undefined`
+ * so the caller can still branch on `if (bound)` — but they don't have
+ * to (the tuple is always safe to index).
+ *
+ * @example
+ *   const bound = useBoundValueOrUndefined<number>(stateKey, 50);
+ *   // ... onChange={(e) => bound?.[1](Number(e.currentTarget.value))}
+ */
+declare function useBoundValueOrUndefined<T>(key: string | undefined, fallback: T): readonly [T, (next: T) => void] | undefined;
+declare function useBoundValue<T>(key: string, fallback: T): readonly [T, (next: T) => void];
+/**
+ * State-binding action shape. Used by `<Button onClickAction={...}>`.
+ *   { set: { count: 1 } }   -> sets state.count = 1
+ *   { toggle: 'open' }     -> sets state.open = !state.open
+ */
+type StateAction = {
+  set?: Record<string, unknown>;
+  toggle?: string;
+} | undefined;
+/**
+ * Apply a StateAction to the nearest PlaygroundState. Returns an
+ * onClick handler that fires the action. If action is undefined
+ * the handler is a no-op.
+ */
+declare function useStateAction(action: StateAction): (event: unknown) => void;
+//#endregion
+//#region src/stateHelpers.d.ts
 /**
- * Map of PascalCase component name to React component. Use this when
- * you have a renderer that walks an AST and needs to pick an
- * implementation at runtime:
+ * Structured diff between two state snapshots. Pure function — does
+ * not touch the stores. Returns `null` when the snapshots are
+ * shallowly equal (no additions, no changes, no removals).
  *
- *   const C = componentMap[tagName];
- *   if (C) el = <C {...props}>{children}</C>;
+ * @example
+ *   const a = { x: 1, y: 2 };
+ *   const b = { x: 1, y: 3, z: 4 };
+ *   diffSnapshots(a, b); // { added: ['z'], changed: ['y'], removed: [] }
+ */
+interface StateDiff {
+  /** Keys present in `next` but absent from `prev`. */
+  added: string[];
+  /** Keys whose value changed (using `Object.is` to compare). */
+  changed: string[];
+  /** Keys present in `prev` but absent from `next`. */
+  removed: string[];
+}
+declare function diffSnapshots(prev: Readonly<Record<string, unknown>>, next: Readonly<Record<string, unknown>>): StateDiff | null;
+/**
+ * Convenience: take snapshots of both stores and diff them. Returns
+ * `null` when equal. Useful in tests and debug endpoints.
+ */
+declare function diffState(_a: PlaygroundState, _b: PlaygroundState, prev?: Readonly<Record<string, unknown>>, next?: Readonly<Record<string, unknown>>): StateDiff | null;
+/**
+ * Validate a state-key string. Returns `null` on success, or a
+ * human-readable error message on failure. The rules:
+ *
+ *  - 1..64 characters
+ *  - No whitespace
+ *  - Only alphanumerics, dots, dashes, underscores
+ *  - Must start with an alphabetic character (so a parser can
+ *    safely infer `<Slider stateKey="...">` from a body without
+ *    swallowing accidental numeric keys).
+ *
+ * Note: keys like `with/slash` or `with spaces` are rejected because
+ * the schema-driven body parser uses them as attribute names —
+ * a key with weird characters would break the round-trip.
+ */
+declare function validateStateKey(key: string): string | null;
+/**
+ * Remove every key from the store, firing subscribers with `undefined`.
+ * After this call, `state.snapshot()` is `{}`.
+ */
+declare function clearState(state: PlaygroundState): void;
+/**
+ * JSON-envelope snapshot for offline inspection. Useful for:
+ *  - piping into `jq` / debug endpoints
+ *  - attaching to error reports
+ *  - round-tripping through `JSON.parse(state.snapshot)`.
+ *
+ * The `version` field is bumped if the envelope shape ever changes,
+ * so consumers can branch on it.
+ */
+interface StateEnvelope {
+  /** Always 1 for now. */
+  version: 1;
+  /** Sorted list of keys (stable for diffing). */
+  keys: string[];
+  /** Shallow key→value map. */
+  values: Record<string, unknown>;
+}
+declare function dumpState(state: PlaygroundState): string;
+/**
+ * Apply multiple `set` calls as a single atomic batch. Each
+ * subscriber sees only the LAST value written to its key in this
+ * batch. The store still batches subscriber fires via the microtask
+ * scheduler — `batch` does not flush synchronously, it only ensures
+ * that within the batch, repeated `set` calls to the same key don't
+ * queue redundant fires.
+ *
+ * Useful for: undo/redo, multi-field form commits, hydrated state
+ * restore where you want each subscriber to fire exactly once with
+ * the final value.
+ *
+ * @example
+ *   batch(state, (s) => {
+ *     s.set('x', 1);
+ *     s.set('y', 2);
+ *     s.set('x', 3); // overwrites; subscriber sees only 3
+ *   });
+ */
+declare function batch<T>(state: PlaygroundState, fn: (state: PlaygroundState) => T): T;
+//#endregion
+//#region src/ArtifactErrorBoundary.d.ts
+interface ArtifactErrorBoundaryProps {
+  children: React.ReactNode;
+  /**
+   * Called when a render error is caught. The `info.componentStack`
+   * string is the React component stack at the point of error. Log
+   * to your observability backend here.
+   */
+  onError?: (error: Error, info: {
+    componentStack: string;
+  }) => void;
+  /**
+   * Optional body string. If present and the consumer renders the
+   * default fallback, a "Show source" toggle will be available that
+   * reveals this body verbatim. Ignored if a custom `fallback` is
+   * supplied (the consumer is responsible for surfacing source).
+   */
+  body?: string;
+  /**
+   * Source language hint for the ShowSource toggle in the default
+   * fallback. Defaults to 'tsx' (most artifacts are TSX).
+   */
+  language?: 'tsx' | 'json';
+  /**
+   * Optional custom fallback. Pass a React element for a static fallback
+   * or a function that receives the error for a dynamic one. If
+   * omitted, the default fallback renders a panel with the error
+   * message and (if `body` is supplied) a ShowSource toggle.
+   */
+  fallback?: React.ReactNode | ((error: Error) => React.ReactNode);
+  /**
+   * Label shown in the default fallback header. Defaults to the
+   * artifact kind identifier (e.g. "playground artifact failed to
+   * render"). The consumer is expected to pass the kind.
+   */
+  kind?: string;
+}
+interface State {
+  error: Error | null;
+}
+/**
+ * Error boundary. Catches render-time errors in `children` and shows
+ * the fallback. The error state is reset on prop change of `children`
+ * (or explicit `resetKey` bump) so the consumer can recover by
+ * re-rendering.
+ */
+declare class ArtifactErrorBoundary extends React.Component<ArtifactErrorBoundaryProps, State> {
+  state: State;
+  static getDerivedStateFromError(error: Error): State;
+  componentDidCatch(error: Error, info: React.ErrorInfo): void;
+  render(): React.ReactNode;
+}
+//#endregion
+//#region src/ShowSource.d.ts
+interface ShowSourceProps {
+  /** The raw body to display when the user expands the source. */
+  body: string;
+  /** Source language hint. Used in `data-language` for styling hooks. */
+  language?: 'tsx' | 'json';
+  /**
+   * Children is a render prop that receives `(toggle, showing)`.
+   * The consumer is expected to render a trigger element (button,
+   * link, etc.) and call `toggle` on user interaction.
+   */
+  children: (toggle: () => void, showing: boolean) => React.ReactNode;
+}
+/**
+ * Toggle button + expandable source panel. The trigger UI is the
+ * consumer's choice; the panel is plain `<pre><code>`.
+ */
+declare function ShowSource(props: ShowSourceProps): React.JSX.Element;
+//#endregion
+//#region src/createRegistry.d.ts
+/**
+ * Map of PascalCase component name to React component. Loose typing
+ * (`ComponentType<any>`) because each component's prop shape differs and
+ * the runtime doesn't know which one it's looking up. Consumers who
+ * need stricter types can build their own typed wrapper around
+ * `renderBody`.
+ */
+type ComponentMap = Record<string, ComponentType<any>>;
+/**
+ * The full default registry (Button, Card, Chart, Code, Container,
+ * Heading, List, Slider, Stepper, Text, TextField). Frozen. Use
+ * `createRegistry(overrides)` to extend.
+ */
+declare const componentMap: ComponentMap;
+/**
+ * Build a new registry by merging the defaults with caller-supplied
+ * overrides. The returned map is frozen (Object.freeze) to prevent
+ * post-hoc mutation that would surprise concurrent renders.
  *
- * Keys mirror `DEFAULT_REGISTRY.list()`.
+ * **Lowercase HTML tags are NOT in this map.** The renderer handles
+ * `div`, `span`, etc. as React intrinsic elements separately. Calling
+ * `createRegistry({ div: StubDiv })` will NOT override the renderer
+ * for `<div>` (the renderer uses the lowercase lookup path first).
  *
- * Type note: components vary in their props shape, so the map is
- * typed permissively (`Record<string, ComponentType<any>>`). Each
- * individual export above is still strictly typed.
+ * @example
+ * ```ts
+ * const map = createRegistry({
+ *   MathExpression: MathExpressionComponent,
+ *   LatexBlock: LatexBlockComponent,
+ * });
+ * ```
  */
-declare const componentMap: Record<string, ComponentType<any>>;
-type ComponentMapKey = keyof typeof componentMap;
+declare function createRegistry(overrides: Partial<ComponentMap>): ComponentMap;
 //#endregion
-export { Button, type ButtonProps, Card, type CardProps, Chart, type ChartKind, type ChartProps, Code, type CodeProps, ComponentMapKey, Container, type ContainerProps, Heading, type HeadingProps, List, type ListProps, Slider, type SliderProps, type Step, Stepper, type StepperProps, Text, TextField, type TextFieldProps, type TextProps, componentMap };
+export { ArtifactErrorBoundary, type ArtifactErrorBoundaryProps, Button, type ButtonProps, Card, type CardProps, Chart, type ChartKind, type ChartProps, Code, type CodeProps, type ComponentMap, Container, type ContainerProps, Heading, type HeadingProps, List, type ListProps, type PlaygroundState, PlaygroundStateProvider, type PlaygroundStateProviderProps, ShowSource, type ShowSourceProps, Slider, type SliderProps, type StateAction, type StateDiff, type StateEnvelope, type Step, Stepper, type StepperProps, Text, TextField, type TextFieldProps, type TextProps, batch, clearState, componentMap, createPlaygroundState, createRegistry, diffSnapshots, diffState, dumpState, useBoundValue, useBoundValueOrUndefined, usePlaygroundState, useStateAction, validateStateKey };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/Button.tsx","../src/TextField.tsx","../src/Slider.tsx","../src/Chart.tsx","../src/Container.tsx","../src/Code.tsx","../src/Heading.tsx","../src/Text.tsx","../src/Stepper.tsx","../src/Card.tsx","../src/List.tsx","../src/registry.ts"],"mappings":";;;;;;;;;UASiB;;EAEf;;EAEA;;EAEA;;;;;EAKA,UAAU,MAAM,kBAAkB;;iBAGpB,SACd,OACA,SACA,UACA,WACC,cAAc,MAAM,IAAI;;;UCzBV;EACf;EACA;EACA;EACA;;;;;;EAMA,WAAW,MAAM,mBAAmB;;;;;;;iBAQtB,YACd,OACA,OACA,aACA,UACA,YACC,iBAAiB,MAAM,IAAI;;;UCxBb;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;;;;;iBAOc,SAAS,KAAK,KAAK,OAAO,MAAU,SAAS,cAAc,MAAM,IAAI;;;KCjBzE;;;;;;;;;;;UAYK;EACf,MAAM;EACN;EACA;;iBAGc,QAAQ,MAAM,MAAM,SAAS,aAAa,MAAM,IAAI;;;UCnBnD;EACf;EACA;EACA,WAAW,MAAM;;;;;;iBAOH,YAAY,SAAS,KAAK,YAAY,iBAAiB,MAAM,IAAI;;;UCThE;EACf;EACA,WAAW,MAAM;;;;;;;;iBASH,OAAO,UAAU,YAAY,YAAY,MAAM,IAAI;;;UCXlD;;;;;;EAMf;EACA;EACA,WAAW,MAAM;;iBAYH,UAAU,OAAO,OAAO,YAAY,eAAe,MAAM,IAAI;;;UCpB5D;EACf;EACA;EACA;EACA,WAAW,MAAM;;iBAGH,OAAO,QAAmB,MAAM,OAAO,YAAY,YAAY,MAAM,IAAI;;;UCPxE;EACf;EACA;EACA,OAAO,MAAM;;UAGE;EACf,OAAO;;EAEP;;;;;;iBAOc,UAAU,OAAO,WAAW,eAAe,MAAM,IAAI;;;UChBpD;EACf;;;;;EAKA;EACA,WAAW,MAAM;;iBAGH,OAAO,OAAO,WAAe,YAAY,YAAY,MAAM,IAAI;;;UCV9D;;;;;;EAMf;;EAEA;;EAEA,WAAW,MAAM;;;;;;;iBAQH,OAAO,OAAO,SAAS,YAAY,YAAY,MAAM,IAAI;;;;;;;;;;;;;;;;;cC6B5D,cAAc,eAAe;KAc9B,+BAA+B"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/Button.tsx","../src/TextField.tsx","../src/Slider.tsx","../src/Chart.tsx","../src/Container.tsx","../src/Code.tsx","../src/Heading.tsx","../src/Text.tsx","../src/Stepper.tsx","../src/Card.tsx","../src/List.tsx","../src/state.tsx","../src/stateHelpers.ts","../src/ArtifactErrorBoundary.tsx","../src/ShowSource.tsx","../src/createRegistry.ts"],"mappings":"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"}