@garretapp/sdk 0.1.0

package/dist/react.d.ts

@@ -0,0 +1,128 @@
+import { G as GarretError, E as EventMap, H as HostClient, f as StreamCall } from './types-BxSYAH_H.js';
+import { G as GarretPlatform } from './platform-CZHtdUK0.js';
+export { S as SurfaceApi, a as SurfaceHandle, b as SurfaceOpenOptions, W as WindowControls } from './platform-CZHtdUK0.js';
+import { ReactNode } from 'react';
+import './protocol-Do0BJdeE.js';
+
+/**
+ * Garret widget design system — GENERIC React building blocks that emit the classes the app's shared
+ * theme styles (`<link rel="stylesheet" href="~theme.css">`). No widget-specific components: these are
+ * primitives (rows, badges, accordions, a settings-form kit) that consumers compose into their own UI.
+ * Import from `@garretapp/sdk/react`.
+ */
+type Tone = 'neutral' | 'accent' | 'success' | 'warning' | 'danger';
+/** Centered muted message (supports rich children). */
+declare function EmptyState({ children }: {
+    children: ReactNode;
+}): JSX.Element;
+/** Error message (in the danger color). */
+declare function ErrorState({ children }: {
+    children: ReactNode;
+}): JSX.Element;
+/** A scrolling content region. */
+declare function Scroll({ children }: {
+    children: ReactNode;
+}): JSX.Element;
+/** A generic list row: optional `leading` / `trailing` slots around the content. Interactive (hover +
+ *  pointer) when `onClick` is given. Renders a <button> if clickable, else a <div>. */
+declare function Item({ leading, trailing, onClick, onContextMenu, children }: {
+    leading?: ReactNode;
+    trailing?: ReactNode;
+    onClick?: () => void;
+    onContextMenu?: (e: React.MouseEvent) => void;
+    children: ReactNode;
+}): JSX.Element;
+/** A collapsible section: a header (title + optional `aside`, e.g. a count) and a rotating chevron. */
+declare function Accordion({ title, aside, defaultOpen, children }: {
+    title: ReactNode;
+    aside?: ReactNode;
+    defaultOpen?: boolean;
+    children: ReactNode;
+}): JSX.Element;
+/** A small pill; `tone` sets the color. */
+declare function Badge({ tone, children }: {
+    tone?: Tone;
+    children: ReactNode;
+}): JSX.Element;
+/** A small status dot; same tones. */
+declare function Dot({ tone, title }: {
+    tone?: Tone;
+    title?: string;
+}): JSX.Element;
+/** The container a widget renders when the host opens its settings (see `useOpenSettings`). Adds a
+ *  footer with a Done button. */
+declare function SettingsPanel({ onDone, children }: {
+    onDone: () => void;
+    children: ReactNode;
+}): JSX.Element;
+/** An inset grouped container (System-Settings style). Group related Fields; `label` is optional. */
+declare function FieldGroup({ label, children }: {
+    label?: ReactNode;
+    children: ReactNode;
+}): JSX.Element;
+declare function Field({ label, children }: {
+    label: ReactNode;
+    children: ReactNode;
+}): JSX.Element;
+/** Uncontrolled text input — commits on blur / Enter (so typing doesn't churn state per keystroke). */
+declare function TextInput({ value, placeholder, secret, onCommit }: {
+    value?: string;
+    placeholder?: string;
+    secret?: boolean;
+    onCommit: (v: string) => void;
+}): JSX.Element;
+declare function NumberInput({ value, onCommit }: {
+    value?: number;
+    onCommit: (v: number) => void;
+}): JSX.Element;
+declare function Select({ value, options, onChange }: {
+    value: string;
+    options: [value: string, label: string][];
+    onChange: (v: string) => void;
+}): JSX.Element;
+declare function Switch({ on, onChange }: {
+    on: boolean;
+    onChange: (v: boolean) => void;
+}): JSX.Element;
+
+/** Typed proxy of your host's methods. Stream-vs-Promise is inferred from each method's `Api` return
+ *  type — nothing to configure. */
+declare function useHost<Api, Events extends EventMap = EventMap>(): HostClient<Api>;
+/** Platform capabilities (storage/secrets/fetch/service/notify/…). Available in both tiers. */
+declare function useGarret(): GarretPlatform;
+/** Subscribe to a typed host event. `useHostEvent<Events, 'changed'>('changed', p => …)`. */
+declare function useHostEvent<E extends EventMap, K extends keyof E & string>(channel: K, handler: (payload: E[K]) => void, deps?: unknown[]): void;
+type StreamStatus = 'idle' | 'streaming' | 'done' | 'error';
+interface UseStreamResult<Chunk, Result> {
+    chunks: Chunk[];
+    result: Result | undefined;
+    error: GarretError | undefined;
+    status: StreamStatus;
+    cancel: () => void;
+}
+/** Consume a stream in React without manual effect+cleanup. `deps` auto-cancel + restart; pass
+ *  `{ enabled: false }` to defer (e.g. until the user triggers a run). */
+declare function useStream<Chunk, Result = void>(factory: () => StreamCall<Chunk, Result>, deps?: unknown[], opts?: {
+    enabled?: boolean;
+}): UseStreamResult<Chunk, Result>;
+/** This placement's settings. `patch` shallow-merges; `replace` overwrites. */
+declare function useConfig<T>(): [T, (patch: Partial<T>) => void, (value: T) => void];
+/** Board activity — `false` when ambient/idle. Gate polling / rAF / animations on it. */
+declare function useActive(): boolean;
+/** Run `cb` when the host (frame ⋯→Settings) asks this widget to reveal its own config UI. */
+declare function useOpenSettings(cb: () => void): void;
+/** Per-placement config backed by `g.instanceStorage` (isolated per widget instance). Loads once the
+ *  runtime binds (calls before bind reject); `set` writes through to storage + state. `loaded` gates
+ *  the first data fetch so you don't fetch with defaults before the saved config arrives. */
+declare function useInstanceConfig<T extends Record<string, unknown>>(defaults: T): {
+    cfg: T;
+    set: (patch: Partial<T>) => void;
+    loaded: boolean;
+};
+
+/** Launch props for a spawned surface window (`g.surfaces.open(..., { props })`). `{}` for the board
+ *  surface. Delivered via `onReady`'s callback (a contextBridge getter would be frozen at exposure
+ *  time), so this re-renders when the runtime binds. The `T` is an unchecked cast — validate it yourself. */
+declare function useProps<T = Record<string, unknown>>(): T;
+
+export { Accordion, Badge, Dot, EmptyState, ErrorState, Field, FieldGroup, GarretError, GarretPlatform, Item, NumberInput, Scroll, Select, SettingsPanel, type StreamStatus, Switch, TextInput, type Tone, type UseStreamResult, useActive, useConfig, useGarret, useHost, useHostEvent, useInstanceConfig, useOpenSettings, useProps, useStream };

package/dist/react.js

@@ -0,0 +1,242 @@
+import { getGarret, getRuntime, getHostTransport, createHostClient, getInstanceId } from './chunk-ZJYHRC5C.js';
+import { GarretError } from './chunk-ENIDFSMM.js';
+export { GarretError } from './chunk-ENIDFSMM.js';
+import { useState, useMemo, useEffect, useRef, useCallback } from 'react';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+
+function EmptyState({ children }) {
+  return /* @__PURE__ */ jsx("div", { className: "gx-empty", children });
+}
+function ErrorState({ children }) {
+  return /* @__PURE__ */ jsx("div", { className: "gx-error", children });
+}
+function Scroll({ children }) {
+  return /* @__PURE__ */ jsx("div", { className: "gx-scroll", children });
+}
+function Item({
+  leading,
+  trailing,
+  onClick,
+  onContextMenu,
+  children
+}) {
+  const cls = `gx-item${onClick ? " gx-item--interactive" : ""}`;
+  const inner = /* @__PURE__ */ jsxs(Fragment, { children: [
+    leading,
+    /* @__PURE__ */ jsx("span", { className: "gx-item-content", children }),
+    trailing
+  ] });
+  return onClick ? /* @__PURE__ */ jsx("button", { className: cls, onClick, onContextMenu, children: inner }) : /* @__PURE__ */ jsx("div", { className: cls, onContextMenu, children: inner });
+}
+function Accordion({
+  title,
+  aside,
+  defaultOpen = true,
+  children
+}) {
+  const [open, setOpen] = useState(defaultOpen);
+  return /* @__PURE__ */ jsxs("div", { children: [
+    /* @__PURE__ */ jsxs("button", { className: "gx-accordion-head", onClick: () => setOpen((o) => !o), children: [
+      /* @__PURE__ */ jsx(
+        "svg",
+        {
+          width: "11",
+          height: "11",
+          viewBox: "0 0 24 24",
+          fill: "none",
+          stroke: "currentColor",
+          strokeWidth: 2.5,
+          strokeLinecap: "round",
+          strokeLinejoin: "round",
+          style: { color: "var(--gx-text-3)", flexShrink: 0, transform: open ? "rotate(90deg)" : "", transition: "transform .12s" },
+          children: /* @__PURE__ */ jsx("polyline", { points: "9 6 15 12 9 18" })
+        }
+      ),
+      /* @__PURE__ */ jsx("span", { className: "gx-accordion-title", children: title }),
+      aside != null && /* @__PURE__ */ jsx("span", { className: "gx-accordion-aside", children: aside })
+    ] }),
+    open && /* @__PURE__ */ jsx("div", { children })
+  ] });
+}
+function Badge({ tone = "neutral", children }) {
+  return /* @__PURE__ */ jsx("span", { className: `gx-badge gx-badge--${tone}`, children });
+}
+function Dot({ tone = "neutral", title }) {
+  return /* @__PURE__ */ jsx("span", { className: `gx-dot gx-dot--${tone}`, title });
+}
+function SettingsPanel({ onDone, children }) {
+  return /* @__PURE__ */ jsxs("div", { className: "gx-form", children: [
+    children,
+    /* @__PURE__ */ jsxs("div", { className: "gx-form-footer", children: [
+      /* @__PURE__ */ jsx("span", { className: "gx-form-note", children: "Changes save automatically" }),
+      /* @__PURE__ */ jsx("button", { className: "gx-btn", onClick: onDone, children: "Done" })
+    ] })
+  ] });
+}
+function FieldGroup({ label, children }) {
+  return /* @__PURE__ */ jsxs("div", { className: "gx-group-wrap", children: [
+    label != null && /* @__PURE__ */ jsx("span", { className: "gx-group-label", children: label }),
+    /* @__PURE__ */ jsx("div", { className: "gx-group", children })
+  ] });
+}
+function Field({ label, children }) {
+  return /* @__PURE__ */ jsxs("div", { className: "gx-field", children: [
+    /* @__PURE__ */ jsx("label", { className: "gx-field-label", children: label }),
+    /* @__PURE__ */ jsx("div", { className: "gx-field-control", children })
+  ] });
+}
+function TextInput({
+  value,
+  placeholder,
+  secret,
+  onCommit
+}) {
+  return /* @__PURE__ */ jsx(
+    "input",
+    {
+      className: "gx-input",
+      type: secret ? "password" : "text",
+      defaultValue: value,
+      placeholder,
+      onBlur: (e) => onCommit(e.target.value),
+      onKeyDown: (e) => e.key === "Enter" && onCommit(e.target.value)
+    }
+  );
+}
+function NumberInput({ value, onCommit }) {
+  return /* @__PURE__ */ jsx(
+    "input",
+    {
+      className: "gx-input",
+      type: "number",
+      defaultValue: value == null ? "" : String(value),
+      onBlur: (e) => onCommit(Number(e.target.value) || 0)
+    }
+  );
+}
+function Select({
+  value,
+  options,
+  onChange
+}) {
+  return /* @__PURE__ */ jsx("select", { className: "gx-select", value, onChange: (e) => onChange(e.target.value), children: options.map(([v, label]) => /* @__PURE__ */ jsx("option", { value: v, children: label }, v)) });
+}
+function Switch({ on, onChange }) {
+  return /* @__PURE__ */ jsx("button", { className: `gx-switch${on ? " gx-switch--on" : ""}`, role: "switch", "aria-checked": on, onClick: () => onChange(!on), children: /* @__PURE__ */ jsx("span", { className: "gx-switch-knob" }) });
+}
+
+// src/react.ts
+var singleton;
+function hostClient() {
+  if (!singleton) {
+    const transport = getHostTransport();
+    if (!transport) throw new GarretError("UNAVAILABLE", "this extension has no host process");
+    singleton = createHostClient(transport, { instanceId: getInstanceId() });
+  }
+  return singleton;
+}
+function useHost() {
+  return useMemo(() => hostClient(), []);
+}
+function useGarret() {
+  return getGarret();
+}
+function useHostEvent(channel, handler, deps = []) {
+  useEffect(() => {
+    const off = hostClient().on(channel, handler);
+    return off;
+  }, [channel, ...deps]);
+}
+function useStream(factory, deps = [], opts) {
+  const enabled = opts?.enabled ?? true;
+  const [chunks, setChunks] = useState([]);
+  const [result, setResult] = useState(void 0);
+  const [error, setError] = useState(void 0);
+  const [status, setStatus] = useState("idle");
+  const ref = useRef(null);
+  useEffect(() => {
+    if (!enabled) {
+      setStatus("idle");
+      return;
+    }
+    setChunks([]);
+    setResult(void 0);
+    setError(void 0);
+    setStatus("streaming");
+    const call = factory();
+    ref.current = call;
+    call.onData((c) => setChunks((xs) => [...xs, c])).onEnd((r) => {
+      setResult(r);
+      setStatus("done");
+    }).onError((e) => {
+      setError(e);
+      setStatus("error");
+    });
+    return () => call.cancel();
+  }, [enabled, ...deps]);
+  const cancel = useCallback(() => ref.current?.cancel(), []);
+  return { chunks, result, error, status, cancel };
+}
+function useConfig() {
+  const rt = getRuntime();
+  const [cfg, setCfg] = useState(rt?.config.get() ?? {});
+  useEffect(() => rt?.config.subscribe((c) => setCfg(c)), [rt]);
+  const patch = useCallback((p) => rt?.config.set(p, false), [rt]);
+  const replace = useCallback((v) => rt?.config.set(v, true), [rt]);
+  return [cfg, patch, replace];
+}
+function useActive() {
+  const g = getGarret();
+  const [active, setActive] = useState(g.active);
+  useEffect(() => g.onActiveChange(setActive), [g]);
+  return active;
+}
+function useOpenSettings(cb) {
+  const g = getGarret();
+  const ref = useRef(cb);
+  ref.current = cb;
+  useEffect(() => g.onOpenSettings(() => ref.current()), [g]);
+}
+function useInstanceConfig(defaults) {
+  const g = getGarret();
+  const [cfg, setCfg] = useState(defaults);
+  const [loaded, setLoaded] = useState(false);
+  useEffect(() => {
+    let alive = true;
+    const unsub = g.onReady(() => {
+      void (async () => {
+        const saved = {};
+        await Promise.all(
+          Object.keys(defaults).map(async (k) => {
+            const v = await g.instanceStorage.get(k);
+            if (v !== void 0) saved[k] = v;
+          })
+        );
+        if (alive) {
+          setCfg({ ...defaults, ...saved });
+          setLoaded(true);
+        }
+      })();
+    });
+    return () => {
+      alive = false;
+      unsub();
+    };
+  }, []);
+  const set = useCallback(
+    (patch) => {
+      setCfg((c) => ({ ...c, ...patch }));
+      for (const [k, v] of Object.entries(patch)) void g.instanceStorage.set(k, v);
+    },
+    [g]
+  );
+  return { cfg, set, loaded };
+}
+function useProps() {
+  const g = getGarret();
+  const [props, setProps] = useState({});
+  useEffect(() => g.onReady((p) => setProps(p)), [g]);
+  return props;
+}
+
+export { Accordion, Badge, Dot, EmptyState, ErrorState, Field, FieldGroup, Item, NumberInput, Scroll, Select, SettingsPanel, Switch, TextInput, useActive, useConfig, useGarret, useHost, useHostEvent, useInstanceConfig, useOpenSettings, useProps, useStream };

package/dist/types-BxSYAH_H.d.cts

@@ -0,0 +1,88 @@
+/** Typed errors that travel across the bridge (see docs/garret.html §Errors). */
+type GarretErrorCode = 'BINARY_NOT_FOUND' | 'NOT_FOUND' | 'PERMISSION' | 'UNAVAILABLE' | 'BAD_ARGS' | 'TIMEOUT' | 'CANCELLED' | 'NETWORK' | 'INTERNAL';
+interface GarretErrorOptions {
+    /** e.g. an install command for BINARY_NOT_FOUND. */
+    hint?: string;
+}
+/**
+ * The single error type crossing the bridge. `code` lets the UI branch (offer `brew install` on
+ * BINARY_NOT_FOUND, an auth prompt on PERMISSION, …). Thrown host-side, re-thrown client-side.
+ */
+declare class GarretError extends Error {
+    readonly code: GarretErrorCode;
+    readonly hint?: string;
+    constructor(code: GarretErrorCode, message: string, options?: GarretErrorOptions);
+}
+/** Reconstruct a GarretError from a wire error frame (client side). */
+declare function garretErrorFromWire(code: string, message: string, hint?: string): GarretError;
+
+declare const STREAM_BRAND: unique symbol;
+/**
+ * Declare a streaming method in your `Api`: its return type is `Stream<Chunk, Result>`. The host
+ * produces it with `ctx.stream(...)`; the UI consumes it as a {@link StreamCall}. `Result` defaults
+ * to `void` (bounded streams may return a final value, e.g. an exit code).
+ */
+interface Stream<Chunk, Result = void> {
+    readonly [STREAM_BRAND]: [Chunk, Result];
+}
+/** The UI-side handle for a streaming method. Deliberately NOT thenable (can't await an endless
+ *  stream). Chainable. */
+interface StreamCall<Chunk, Result = void> {
+    onData(cb: (chunk: Chunk) => void): StreamCall<Chunk, Result>;
+    onEnd(cb: (result: Result) => void): StreamCall<Chunk, Result>;
+    onError(cb: (err: GarretError) => void): StreamCall<Chunk, Result>;
+    /** Abort the host's `signal` + kill any spawned children. */
+    cancel(): void;
+    /** BOUNDED streams only — resolves on end, rejects on error. Awaiting an endless stream hangs. */
+    result(): Promise<Result>;
+}
+/** Maps each Api method to its client form: `Stream<…>` → `StreamCall`, else `Promise`. */
+type HostClient<Api> = {
+    [K in keyof Api]: Api[K] extends (...args: infer A) => infer R ? R extends Stream<infer C, infer Res> ? (...args: A) => StreamCall<C, Res> : (...args: A) => Promise<Awaited<R>> : never;
+};
+/** Event payload map: `{ changed: { dir: string } }` → typed `on('changed', p => …)`. */
+type EventMap = Record<string, unknown>;
+/** Declared in the manifest; drives the tier + the main-process broker's allowlist. System caps
+ *  (`process`/`fs`/`native`) and wildcard network require a host (full-access tier). */
+type Capability = 'storage' | 'secrets' | 'notify' | 'clipboard' | 'openExternal' | `network:${string}` | `service:${string}` | 'process' | 'fs' | 'native';
+type ConfigFieldType = 'string' | 'number' | 'boolean';
+interface ConfigField {
+    type: ConfigFieldType;
+    label: string;
+    default: string | number | boolean;
+    min?: number;
+    max?: number;
+}
+type ConfigSchema = Record<string, ConfigField>;
+interface Manifest {
+    /** lowercase [a-z0-9._-], no "..". Directory + origin. */
+    id: string;
+    name: string;
+    version: string;
+    apiVersion?: number;
+    description?: string;
+    /** lucide icon name. */
+    icon?: string;
+    /** bundled preview image path. */
+    preview?: string;
+    /** built UI dir (contains index.html). Required. */
+    ui: string;
+    /** built Node host entry. Presence + a system capability ⇒ full-access tier. */
+    host?: string;
+    capabilities?: Capability[];
+    defaultSize?: {
+        w: number;
+        h: number;
+    };
+    minSize?: {
+        w: number;
+        h: number;
+    };
+    config?: ConfigSchema;
+}
+/** Identity helper for `garret.manifest.ts` — pure passthrough, just for autocomplete + checking. */
+declare function defineManifest(manifest: Manifest): Manifest;
+/** Identity helper for a config schema — infers the settings value type for `useConfig<T>()`. */
+declare function defineConfig<T extends ConfigSchema>(schema: T): T;
+
+export { type Capability as C, type EventMap as E, GarretError as G, type HostClient as H, type Manifest as M, type Stream as S, type ConfigField as a, type ConfigFieldType as b, type ConfigSchema as c, type GarretErrorCode as d, type GarretErrorOptions as e, type StreamCall as f, defineConfig as g, defineManifest as h, garretErrorFromWire as i };

package/dist/types-BxSYAH_H.d.ts

@@ -0,0 +1,88 @@
+/** Typed errors that travel across the bridge (see docs/garret.html §Errors). */
+type GarretErrorCode = 'BINARY_NOT_FOUND' | 'NOT_FOUND' | 'PERMISSION' | 'UNAVAILABLE' | 'BAD_ARGS' | 'TIMEOUT' | 'CANCELLED' | 'NETWORK' | 'INTERNAL';
+interface GarretErrorOptions {
+    /** e.g. an install command for BINARY_NOT_FOUND. */
+    hint?: string;
+}
+/**
+ * The single error type crossing the bridge. `code` lets the UI branch (offer `brew install` on
+ * BINARY_NOT_FOUND, an auth prompt on PERMISSION, …). Thrown host-side, re-thrown client-side.
+ */
+declare class GarretError extends Error {
+    readonly code: GarretErrorCode;
+    readonly hint?: string;
+    constructor(code: GarretErrorCode, message: string, options?: GarretErrorOptions);
+}
+/** Reconstruct a GarretError from a wire error frame (client side). */
+declare function garretErrorFromWire(code: string, message: string, hint?: string): GarretError;
+
+declare const STREAM_BRAND: unique symbol;
+/**
+ * Declare a streaming method in your `Api`: its return type is `Stream<Chunk, Result>`. The host
+ * produces it with `ctx.stream(...)`; the UI consumes it as a {@link StreamCall}. `Result` defaults
+ * to `void` (bounded streams may return a final value, e.g. an exit code).
+ */
+interface Stream<Chunk, Result = void> {
+    readonly [STREAM_BRAND]: [Chunk, Result];
+}
+/** The UI-side handle for a streaming method. Deliberately NOT thenable (can't await an endless
+ *  stream). Chainable. */
+interface StreamCall<Chunk, Result = void> {
+    onData(cb: (chunk: Chunk) => void): StreamCall<Chunk, Result>;
+    onEnd(cb: (result: Result) => void): StreamCall<Chunk, Result>;
+    onError(cb: (err: GarretError) => void): StreamCall<Chunk, Result>;
+    /** Abort the host's `signal` + kill any spawned children. */
+    cancel(): void;
+    /** BOUNDED streams only — resolves on end, rejects on error. Awaiting an endless stream hangs. */
+    result(): Promise<Result>;
+}
+/** Maps each Api method to its client form: `Stream<…>` → `StreamCall`, else `Promise`. */
+type HostClient<Api> = {
+    [K in keyof Api]: Api[K] extends (...args: infer A) => infer R ? R extends Stream<infer C, infer Res> ? (...args: A) => StreamCall<C, Res> : (...args: A) => Promise<Awaited<R>> : never;
+};
+/** Event payload map: `{ changed: { dir: string } }` → typed `on('changed', p => …)`. */
+type EventMap = Record<string, unknown>;
+/** Declared in the manifest; drives the tier + the main-process broker's allowlist. System caps
+ *  (`process`/`fs`/`native`) and wildcard network require a host (full-access tier). */
+type Capability = 'storage' | 'secrets' | 'notify' | 'clipboard' | 'openExternal' | `network:${string}` | `service:${string}` | 'process' | 'fs' | 'native';
+type ConfigFieldType = 'string' | 'number' | 'boolean';
+interface ConfigField {
+    type: ConfigFieldType;
+    label: string;
+    default: string | number | boolean;
+    min?: number;
+    max?: number;
+}
+type ConfigSchema = Record<string, ConfigField>;
+interface Manifest {
+    /** lowercase [a-z0-9._-], no "..". Directory + origin. */
+    id: string;
+    name: string;
+    version: string;
+    apiVersion?: number;
+    description?: string;
+    /** lucide icon name. */
+    icon?: string;
+    /** bundled preview image path. */
+    preview?: string;
+    /** built UI dir (contains index.html). Required. */
+    ui: string;
+    /** built Node host entry. Presence + a system capability ⇒ full-access tier. */
+    host?: string;
+    capabilities?: Capability[];
+    defaultSize?: {
+        w: number;
+        h: number;
+    };
+    minSize?: {
+        w: number;
+        h: number;
+    };
+    config?: ConfigSchema;
+}
+/** Identity helper for `garret.manifest.ts` — pure passthrough, just for autocomplete + checking. */
+declare function defineManifest(manifest: Manifest): Manifest;
+/** Identity helper for a config schema — infers the settings value type for `useConfig<T>()`. */
+declare function defineConfig<T extends ConfigSchema>(schema: T): T;
+
+export { type Capability as C, type EventMap as E, GarretError as G, type HostClient as H, type Manifest as M, type Stream as S, type ConfigField as a, type ConfigFieldType as b, type ConfigSchema as c, type GarretErrorCode as d, type GarretErrorOptions as e, type StreamCall as f, defineConfig as g, defineManifest as h, garretErrorFromWire as i };