From d7889bfba16b0eb1bc8161597a53fa9f8acd9e2f Mon Sep 17 00:00:00 2001
From: Tayeb Mokni <tayeb.mokni@gmail.com>
Date: Mon, 25 May 2026 22:11:04 +0200
Subject: [PATCH] =?UTF-8?q?feat(sdk):=20ship=20@gonext/sdk=20=E2=80=94=20s?=
 =?UTF-8?q?lug=20detection,=20REST=20shims,=20Trusted=20Types?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Replaces the package.json-only stub with a working browser-side
SDK plugin authors import via the host's import map.

Surface:
- getSlug() / setSlug() / SlugRequiredError — auto-detects the
  plugin slug from the loading import-map URL (or page <script>
  tags, the gn-plugin-context JSON block, or window.__GN_PLUGIN_SLUG__
  as fallbacks).
- host.{posts,users,media,cache} — same-origin REST shims over the
  WP-compat surface (/wp-json/wp/v2/...) and the plugin-scoped
  subtree (/api/plugins/{slug}/...). HostFetchError carries
  status + parsed body so consumers can branch on transport vs.
  server-side failures.
- defineBlock(spec) — forwards to __GN_BLOCK_REGISTRY__ (or the
  legacy BLOCK_REGISTRY) when published by the editor, else
  captures locally for later drain.
- i18n.t(key, args) / i18n.load(locale) — fetches the per-plugin
  catalogue at /api/plugins/{slug}/i18n/{locale}.json, caches by
  (slug, locale), falls back to the key on miss / error.
- setHTML(el, html) — Trusted-Types-safe innerHTML setter that
  routes through the host's gn-plugin policy when one exists.

Build pipeline (tsup):
- dist/index.mjs  (ESM, what the import map loads)
- dist/index.cjs  (CJS, Node test harnesses)
- dist/index.d.ts (rolled-up declarations)
- sideEffects: false; zero runtime dependencies.

Tests (Vitest, jsdom): 69 cases covering slug detection across
all four strategies, REST shim transport (headers, abort, errors,
204 handling, query camel→snake mapping), Trusted Types compat
(installed factory, identity fallback, createPolicy refusal),
block registry forwarding + capture, and i18n catalogue caching
with malformed-input filtering.

Refs #214.

Signed-off-by: Tayeb Mokni <tayeb.mokni@gmail.com>
---
 packages/ts/sdk/README.md                 |  67 ++++
 packages/ts/sdk/package.json              |  41 +-
 packages/ts/sdk/src/blocks.test.ts        |  87 +++++
 packages/ts/sdk/src/blocks.ts             | 168 +++++++++
 packages/ts/sdk/src/host.test.ts          | 246 ++++++++++++
 packages/ts/sdk/src/host.ts               | 431 ++++++++++++++++++++++
 packages/ts/sdk/src/i18n.test.ts          | 113 ++++++
 packages/ts/sdk/src/i18n.ts               | Bin 0 -> 7902 bytes
 packages/ts/sdk/src/index.ts              |  50 +++
 packages/ts/sdk/src/react-types.ts        |  33 ++
 packages/ts/sdk/src/slug.test.ts          | 178 +++++++++
 packages/ts/sdk/src/slug.ts               | 311 ++++++++++++++++
 packages/ts/sdk/src/trusted-types.test.ts | 122 ++++++
 packages/ts/sdk/src/trusted-types.ts      | 195 ++++++++++
 packages/ts/sdk/tsconfig.json             |  28 ++
 packages/ts/sdk/tsup.config.ts            |  53 +++
 packages/ts/sdk/vitest.config.ts          |  33 ++
 packages/ts/sdk/vitest.setup.ts           |  12 +
 pnpm-lock.yaml                            | 405 +++++++++++++++++++-
 19 files changed, 2565 insertions(+), 8 deletions(-)
 create mode 100644 packages/ts/sdk/README.md
 create mode 100644 packages/ts/sdk/src/blocks.test.ts
 create mode 100644 packages/ts/sdk/src/blocks.ts
 create mode 100644 packages/ts/sdk/src/host.test.ts
 create mode 100644 packages/ts/sdk/src/host.ts
 create mode 100644 packages/ts/sdk/src/i18n.test.ts
 create mode 100644 packages/ts/sdk/src/i18n.ts
 create mode 100644 packages/ts/sdk/src/index.ts
 create mode 100644 packages/ts/sdk/src/react-types.ts
 create mode 100644 packages/ts/sdk/src/slug.test.ts
 create mode 100644 packages/ts/sdk/src/slug.ts
 create mode 100644 packages/ts/sdk/src/trusted-types.test.ts
 create mode 100644 packages/ts/sdk/src/trusted-types.ts
 create mode 100644 packages/ts/sdk/tsconfig.json
 create mode 100644 packages/ts/sdk/tsup.config.ts
 create mode 100644 packages/ts/sdk/vitest.config.ts
 create mode 100644 packages/ts/sdk/vitest.setup.ts

diff --git a/packages/ts/sdk/README.md b/packages/ts/sdk/README.md
new file mode 100644
index 00000000..b1923ac3
--- /dev/null
+++ b/packages/ts/sdk/README.md
@@ -0,0 +1,67 @@
+# @gonext/sdk
+
+Browser-side TypeScript SDK for GoNext plugins.
+
+`@gonext/sdk` is what a plugin's browser bundle imports to talk to the GoNext
+host. It auto-detects the plugin's slug from the import-map URL, exposes
+namespaced REST shims, lets a plugin register client-side blocks, and wraps
+the host's translation endpoint.
+
+The SDK is served by the host (typically at `/_/runtime/sdk.mjs`) and pinned
+in the admin's import map under the `@gonext/sdk` specifier. Plugin authors
+never install it from npm — they import it as a bare specifier and the
+import map resolves to the host-served bundle:
+
+```ts
+import { defineBlock, host, i18n, setHTML } from '@gonext/sdk';
+
+defineBlock({
+  name: 'acme/quote',
+  title: 'Acme Quote',
+  edit: ({ attributes, setAttributes }) => {
+    const me = await host.users.me();
+    return <blockquote>{i18n.t('quote.lead', { name: me.name })}</blockquote>;
+  },
+});
+```
+
+That's the whole hello-world. The SDK figures out the plugin slug from
+the URL the host loaded the bundle from, and `host.users.me()` calls the
+same-origin REST surface with the operator's session cookie.
+
+## Module surface
+
+| Export | Purpose |
+| --- | --- |
+| `getSlug()` | Returns the auto-detected slug, or `null`. |
+| `setSlug(slug)` | Explicit override for tests / SSR. |
+| `host.posts.{list,get}` | Reads from `/wp-json/wp/v2/posts`. |
+| `host.users.{list,get,me}` | Reads from `/wp-json/wp/v2/users`. |
+| `host.media.{list,get}` | Reads from `/wp-json/wp/v2/media`. |
+| `host.cache.invalidate(tags)` | Plugin-scoped cache invalidation. |
+| `defineBlock(spec)` | Forwards to the editor's `BLOCK_REGISTRY`. |
+| `i18n.t(key, args)` | Translation lookup with `{placeholder}` interp. |
+| `i18n.load(locale)` | Preloads a catalogue. |
+| `setHTML(el, html)` | Trusted-Types-safe `innerHTML` setter. |
+
+## Trusted Types
+
+The admin enforces `require-trusted-types-for 'script'`. Every assignment
+to `innerHTML` / `outerHTML` / `script.src` would throw at runtime in
+plugin code that didn't go through a registered policy. The SDK ships a
+`setHTML(el, html)` helper that routes through the host-installed
+`gn-plugin` policy, so plugin code stays portable to environments with or
+without TT enforcement.
+
+## Build outputs
+
+`pnpm --filter @gonext/sdk run build` (via `tsup`) produces:
+
+- `dist/index.mjs` — primary ESM bundle (what the import map loads)
+- `dist/index.cjs` — CJS fallback for Node test harnesses
+- `dist/index.d.ts` — rolled-up TypeScript declarations
+
+## License
+
+Apache-2.0. Plugin authors are explicitly free to ship plugins under any
+license — the SDK does not impose viral terms.
diff --git a/packages/ts/sdk/package.json b/packages/ts/sdk/package.json
index 9d7af94b..2747be40 100644
--- a/packages/ts/sdk/package.json
+++ b/packages/ts/sdk/package.json
@@ -1,15 +1,42 @@
 {
   "name": "@gonext/sdk",
-  "version": "0.0.0",
+  "version": "0.1.0",
   "private": false,
-  "description": "Plugin SDK for GoNext. Shared between WASM plugin guests (via Javy or AssemblyScript) and frontend ES modules loaded by the host. Licensed under Apache-2.0 from day 1 so plugin authors are unencumbered.",
+  "description": "Browser-side TypeScript SDK for GoNext plugins. Auto-detects the loading plugin's slug from the import-map URL, exposes namespaced REST shims (posts, users, media, cache), block registration, and an i18n wrapper. Trusted-Types compatible by design — plays nicely with the gn-plugin policy the admin installs at boot. Apache-2.0 from day 1 so plugin authors are unencumbered.",
   "license": "Apache-2.0",
-  "main": "./src/index.ts",
-  "types": "./src/index.ts",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "src",
+    "README.md"
+  ],
   "scripts": {
-    "build": "echo '@gonext/sdk build: not yet implemented (see issue #237/#239/#242)'",
+    "build": "tsup",
+    "dev": "tsup --watch",
     "lint": "echo '@gonext/sdk lint: not yet implemented'",
-    "test": "echo '@gonext/sdk test: not yet implemented'",
-    "typecheck": "echo '@gonext/sdk typecheck: not yet implemented'"
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@gonext/test-config": "workspace:*",
+    "@vitest/coverage-v8": "^1.6.0",
+    "jsdom": "^24.0.0",
+    "tsup": "^8.3.0",
+    "typescript": "^5.6.0",
+    "vitest": "^1.6.0"
   }
 }
diff --git a/packages/ts/sdk/src/blocks.test.ts b/packages/ts/sdk/src/blocks.test.ts
new file mode 100644
index 00000000..c11ca823
--- /dev/null
+++ b/packages/ts/sdk/src/blocks.test.ts
@@ -0,0 +1,87 @@
+/**
+ * defineBlock tests.
+ *
+ * Two modes: forwarding to a registry the editor already
+ * published, and capturing into the local map when the registry
+ * has not booted yet.
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import {
+  __drainCapturedBlocks,
+  __getCapturedBlocks,
+  defineBlock,
+} from './blocks';
+
+beforeEach(() => {
+  delete (globalThis as { __GN_BLOCK_REGISTRY__?: unknown }).__GN_BLOCK_REGISTRY__;
+  delete (globalThis as { BLOCK_REGISTRY?: unknown }).BLOCK_REGISTRY;
+  __drainCapturedBlocks();
+});
+
+afterEach(() => {
+  __drainCapturedBlocks();
+});
+
+describe('defineBlock', () => {
+  it('forwards to __GN_BLOCK_REGISTRY__ when present', () => {
+    const register = vi.fn();
+    (globalThis as { __GN_BLOCK_REGISTRY__?: unknown }).__GN_BLOCK_REGISTRY__ = {
+      register,
+    };
+    defineBlock({
+      name: 'acme/hello',
+      title: 'Hello',
+      attributes: { greeting: 'Hi' },
+    });
+    expect(register).toHaveBeenCalledTimes(1);
+    expect(register.mock.calls[0]![0]).toMatchObject({ name: 'acme/hello' });
+    expect(__getCapturedBlocks()).toHaveLength(0);
+  });
+
+  it('falls back to BLOCK_REGISTRY when only that is present', () => {
+    const register = vi.fn();
+    (globalThis as { BLOCK_REGISTRY?: unknown }).BLOCK_REGISTRY = { register };
+    defineBlock({ name: 'acme/old', attributes: {} });
+    expect(register).toHaveBeenCalledTimes(1);
+  });
+
+  it('captures locally when no registry is installed yet', () => {
+    defineBlock({ name: 'acme/captured', attributes: {} });
+    expect(__getCapturedBlocks()).toHaveLength(1);
+    expect(__getCapturedBlocks()[0]!.name).toBe('acme/captured');
+  });
+
+  it('drain returns and clears the capture map', () => {
+    defineBlock({ name: 'acme/a', attributes: {} });
+    defineBlock({ name: 'acme/b', attributes: {} });
+    const drained = __drainCapturedBlocks();
+    expect(drained.map((s) => s.name)).toEqual(['acme/a', 'acme/b']);
+    expect(__getCapturedBlocks()).toHaveLength(0);
+  });
+
+  it('replaces a captured block on re-registration', () => {
+    defineBlock({ name: 'acme/dupe', title: 'First', attributes: {} });
+    defineBlock({ name: 'acme/dupe', title: 'Second', attributes: {} });
+    const captured = __getCapturedBlocks();
+    expect(captured).toHaveLength(1);
+    expect(captured[0]!.title).toBe('Second');
+  });
+
+  it('rejects an invalid name', () => {
+    expect(() =>
+      defineBlock({ name: 'BadName', attributes: {} } as never),
+    ).toThrow(TypeError);
+    expect(() =>
+      defineBlock({ name: 'no-slash', attributes: {} } as never),
+    ).toThrow(TypeError);
+    expect(() =>
+      defineBlock({ name: 'acme/Bad Slug', attributes: {} } as never),
+    ).toThrow(TypeError);
+  });
+
+  it('ignores a registry that lacks register()', () => {
+    (globalThis as { __GN_BLOCK_REGISTRY__?: unknown }).__GN_BLOCK_REGISTRY__ = {};
+    defineBlock({ name: 'acme/ok', attributes: {} });
+    expect(__getCapturedBlocks()).toHaveLength(1);
+  });
+});
diff --git a/packages/ts/sdk/src/blocks.ts b/packages/ts/sdk/src/blocks.ts
new file mode 100644
index 00000000..970515ad
--- /dev/null
+++ b/packages/ts/sdk/src/blocks.ts
@@ -0,0 +1,168 @@
+/**
+ * Client-side block registration.
+ *
+ * `defineBlock(spec)` is how a plugin's browser bundle registers a
+ * block component the editor + the public theme can render. The
+ * concrete registry — the global object the host writes blocks into
+ * — is owned by the editor package (`@gonext/blocks-editor`) and
+ * mounted on the page before plugin bundles evaluate.
+ *
+ * This module forwards to that registry when it exists, and
+ * silently captures the registration into a local Map otherwise.
+ * The capture is observable via `__getCapturedBlocks()` so tests
+ * (and the editor, once it boots) can flush the pending list.
+ *
+ * Forward-compat: the `BLOCK_REGISTRY` shape will probably grow
+ * lifecycle hooks (mount / unmount / capability gates). We pass
+ * the full spec through verbatim — the SDK does not normalize or
+ * validate beyond a name check — so a registry update doesn't
+ * require an SDK rev.
+ */
+
+import type { ComponentType } from './react-types';
+
+/**
+ * Block-spec shape. Mirrors the contract the editor's
+ * `BLOCK_REGISTRY.register` expects.
+ *
+ * `name` is the block identifier and follows the WP convention of
+ * `<namespace>/<slug>` (e.g. `acme/quote`). The SDK enforces the
+ * shape so a typo (`'quote'`) doesn't silently shadow another
+ * plugin's block.
+ *
+ * `edit` is the editor-side React component; `save` is the public
+ * theme's render component. Either or both may be omitted — server-
+ * rendered blocks have neither, and edit-only blocks have no save.
+ * The registry tolerates `undefined` for both.
+ *
+ * `attributes` is the block's attribute schema, in the same shape
+ * Gutenberg's `registerBlockType` expects. The SDK does not validate
+ * it; the editor performs full validation at registration time and
+ * surfaces errors to the developer.
+ */
+export interface BlockSpec<Attrs = Record<string, unknown>> {
+  name: string;
+  title?: string;
+  icon?: string;
+  category?: string;
+  description?: string;
+  keywords?: ReadonlyArray<string>;
+  attributes?: Attrs;
+  edit?: ComponentType<BlockProps<Attrs>>;
+  save?: ComponentType<BlockProps<Attrs>>;
+  /** Free-form pass-through for future registry fields. */
+  [extra: string]: unknown;
+}
+
+/**
+ * Props the block's `edit` and `save` components receive. The
+ * concrete shape is owned by the editor; we declare just the two
+ * fields the SDK needs to expose for type-checking.
+ */
+export interface BlockProps<Attrs = Record<string, unknown>> {
+  attributes: Attrs;
+  setAttributes?: (next: Partial<Attrs>) => void;
+}
+
+/**
+ * Shape of the global block registry the editor mounts. We declare
+ * it via an interface and treat the global at call time as
+ * potentially-undefined; the SDK is the upstream package, so it
+ * cannot statically depend on the editor exporting one.
+ */
+interface BlockRegistry {
+  register: (spec: BlockSpec<Record<string, unknown>>) => void;
+  unregister?: (name: string) => void;
+}
+
+/**
+ * Module-scoped capture for the "registry not present yet" path.
+ * Keyed by block name so a re-registration replaces the previous
+ * entry instead of stacking duplicates.
+ */
+const captured = new Map<string, BlockSpec<Record<string, unknown>>>();
+
+/**
+ * Block-name validation pattern. Lower-case namespace, slash,
+ * kebab-case slug. Matches the WP block-type rules so a plugin
+ * authored against live WP doesn't need to rename blocks.
+ */
+const BLOCK_NAME_PATTERN = /^[a-z][a-z0-9-]*\/[a-z][a-z0-9-]*$/;
+
+/**
+ * Registers a block. If the editor has already published a
+ * `window.__GN_BLOCK_REGISTRY__` (or the equivalent
+ * `globalThis.BLOCK_REGISTRY` constant the editor exposes), the
+ * call forwards directly. Otherwise the spec is captured locally
+ * and the editor will pull captured specs at boot.
+ *
+ * Throws `TypeError` for an invalid `name`. NOT thrown for missing
+ * `edit` / `save` — server-rendered blocks have neither.
+ */
+export function defineBlock<Attrs extends Record<string, unknown>>(
+  spec: BlockSpec<Attrs>,
+): void {
+  if (typeof spec.name !== 'string' || !BLOCK_NAME_PATTERN.test(spec.name)) {
+    throw new TypeError(
+      `[@gonext/sdk] defineBlock: name ${JSON.stringify(spec.name)} ` +
+        'must be "<namespace>/<slug>" with lower-case ASCII.',
+    );
+  }
+  // Cast Attrs → unknown for the registry surface. The block
+  // registry is generic-erased; we recover the type at the call
+  // sites where the component is actually rendered.
+  const registry = getBlockRegistry();
+  const erased = spec as unknown as BlockSpec<Record<string, unknown>>;
+  if (registry !== null) {
+    registry.register(erased);
+    return;
+  }
+  captured.set(spec.name, erased);
+}
+
+/**
+ * Reads the block registry off the global, if present. The editor
+ * publishes the registry under the conventional name
+ * `__GN_BLOCK_REGISTRY__`; we ALSO accept a `BLOCK_REGISTRY`
+ * camel-cased export for the very-old editor builds that shipped
+ * before the convention firmed up.
+ */
+function getBlockRegistry(): BlockRegistry | null {
+  if (typeof globalThis === 'undefined') {
+    return null;
+  }
+  const g = globalThis as {
+    __GN_BLOCK_REGISTRY__?: unknown;
+    BLOCK_REGISTRY?: unknown;
+  };
+  const candidate = g.__GN_BLOCK_REGISTRY__ ?? g.BLOCK_REGISTRY;
+  if (candidate === undefined || candidate === null) {
+    return null;
+  }
+  if (typeof (candidate as { register?: unknown }).register !== 'function') {
+    return null;
+  }
+  return candidate as BlockRegistry;
+}
+
+/**
+ * Drains captured specs. Called by the editor on boot once its
+ * registry is ready, OR by tests to assert what was registered.
+ *
+ * Returns an array of specs in insertion order. Subsequent calls
+ * see an empty list — drain is destructive on purpose so the
+ * editor doesn't double-register.
+ */
+export function __drainCapturedBlocks(): Array<BlockSpec<Record<string, unknown>>> {
+  const list = Array.from(captured.values());
+  captured.clear();
+  return list;
+}
+
+/**
+ * Read-only peek into the captured map. Distinct from `__drain`
+ * because tests often want to assert WITHOUT clearing.
+ */
+export function __getCapturedBlocks(): ReadonlyArray<BlockSpec<Record<string, unknown>>> {
+  return Array.from(captured.values());
+}
diff --git a/packages/ts/sdk/src/host.test.ts b/packages/ts/sdk/src/host.test.ts
new file mode 100644
index 00000000..0495cc46
--- /dev/null
+++ b/packages/ts/sdk/src/host.test.ts
@@ -0,0 +1,246 @@
+/**
+ * REST-shim tests.
+ *
+ * We mock `globalThis.fetch` with `vi.fn` and pin the request URL,
+ * method, headers, and the body shape we send. The response side
+ * is constructed via the real `Response` constructor so the SDK's
+ * parser exercises the same path it would in the browser.
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import {
+  HostFetchError,
+  host,
+  __test_buildQuery,
+  __test_hostFetch,
+} from './host';
+import { __resetSlugCache, setSlug, SlugRequiredError } from './slug';
+
+let fetchMock: ReturnType<typeof vi.fn>;
+
+beforeEach(() => {
+  __resetSlugCache();
+  setSlug('test-plugin');
+  fetchMock = vi.fn();
+  globalThis.fetch = fetchMock as unknown as typeof fetch;
+});
+
+afterEach(() => {
+  __resetSlugCache();
+});
+
+/**
+ * Helper: builds an okay JSON response.
+ */
+function jsonResponse(body: unknown, init: ResponseInit = {}): Response {
+  return new Response(JSON.stringify(body), {
+    status: 200,
+    headers: { 'content-type': 'application/json' },
+    ...init,
+  });
+}
+
+describe('host.posts', () => {
+  it('lists posts via GET /wp-json/wp/v2/posts', async () => {
+    fetchMock.mockResolvedValueOnce(jsonResponse([{ id: 1 }, { id: 2 }]));
+    const result = await host.posts.list();
+    expect(result).toHaveLength(2);
+    const call = fetchMock.mock.calls[0]!;
+    expect(call[0]).toBe('/wp-json/wp/v2/posts');
+    expect(call[1].method).toBe('GET');
+  });
+
+  it('forwards ListOptions as snake_case query params', async () => {
+    fetchMock.mockResolvedValueOnce(jsonResponse([]));
+    await host.posts.list({ perPage: 5, search: 'hello' });
+    const url = fetchMock.mock.calls[0]![0] as string;
+    expect(url).toContain('per_page=5');
+    expect(url).toContain('search=hello');
+  });
+
+  it('reads a single post via GET /wp-json/wp/v2/posts/{id}', async () => {
+    fetchMock.mockResolvedValueOnce(jsonResponse({ id: 42, slug: 'p' }));
+    const post = await host.posts.get(42);
+    expect(post.id).toBe(42);
+    expect(fetchMock.mock.calls[0]![0]).toBe('/wp-json/wp/v2/posts/42');
+  });
+
+  it('throws HostFetchError on a 5xx', async () => {
+    fetchMock.mockResolvedValueOnce(
+      new Response(JSON.stringify({ code: 'rest_error' }), {
+        status: 500,
+        headers: { 'content-type': 'application/json' },
+      }),
+    );
+    await expect(host.posts.get(1)).rejects.toMatchObject({
+      name: 'HostFetchError',
+      status: 500,
+    });
+  });
+
+  it('throws HostFetchError with status 0 on transport error', async () => {
+    fetchMock.mockRejectedValueOnce(new TypeError('network failed'));
+    await expect(host.posts.list()).rejects.toMatchObject({
+      name: 'HostFetchError',
+      status: 0,
+    });
+  });
+
+  it('forwards the abort signal', async () => {
+    fetchMock.mockResolvedValueOnce(jsonResponse([]));
+    const ctrl = new AbortController();
+    await host.posts.list(undefined, { signal: ctrl.signal });
+    const init = fetchMock.mock.calls[0]![1] as RequestInit;
+    expect(init.signal).toBe(ctrl.signal);
+  });
+});
+
+describe('host.users', () => {
+  it('resolves the current user via /users/me', async () => {
+    fetchMock.mockResolvedValueOnce(jsonResponse({ id: 7, name: 'Ada' }));
+    const me = await host.users.me();
+    expect(me.name).toBe('Ada');
+    expect(fetchMock.mock.calls[0]![0]).toBe('/wp-json/wp/v2/users/me');
+  });
+
+  it('lists users', async () => {
+    fetchMock.mockResolvedValueOnce(jsonResponse([{ id: 1, name: 'A' }]));
+    const users = await host.users.list({ perPage: 10 });
+    expect(users).toHaveLength(1);
+  });
+
+  it('gets a single user by id', async () => {
+    fetchMock.mockResolvedValueOnce(jsonResponse({ id: 9, name: 'X' }));
+    const u = await host.users.get(9);
+    expect(u.id).toBe(9);
+    expect(fetchMock.mock.calls[0]![0]).toBe('/wp-json/wp/v2/users/9');
+  });
+});
+
+describe('host.media', () => {
+  it('lists media', async () => {
+    fetchMock.mockResolvedValueOnce(jsonResponse([{ id: 1, mime_type: 'image/png' }]));
+    const media = await host.media.list();
+    expect(media[0]!.mime_type).toBe('image/png');
+  });
+
+  it('gets a single media item by id', async () => {
+    fetchMock.mockResolvedValueOnce(jsonResponse({ id: 5 }));
+    const m = await host.media.get(5);
+    expect(m.id).toBe(5);
+  });
+});
+
+describe('host.cache.invalidate', () => {
+  it('POSTs to /api/plugins/{slug}/cache/invalidate with the tags', async () => {
+    fetchMock.mockResolvedValueOnce(jsonResponse({ invalidated: 3 }));
+    const count = await host.cache.invalidate(['posts', 'menus']);
+    expect(count).toBe(3);
+    const call = fetchMock.mock.calls[0]!;
+    expect(call[0]).toBe('/api/plugins/test-plugin/cache/invalidate');
+    expect(call[1].method).toBe('POST');
+    const body = JSON.parse(call[1].body as string) as { tags: string[] };
+    expect(body.tags).toEqual(['posts', 'menus']);
+  });
+
+  it('accepts a single string tag', async () => {
+    fetchMock.mockResolvedValueOnce(jsonResponse({ invalidated: 1 }));
+    await host.cache.invalidate('posts');
+    const body = JSON.parse(fetchMock.mock.calls[0]![1].body as string) as {
+      tags: string[];
+    };
+    expect(body.tags).toEqual(['posts']);
+  });
+
+  it('defaults to 0 when the server omits a count', async () => {
+    fetchMock.mockResolvedValueOnce(jsonResponse({}));
+    const count = await host.cache.invalidate('posts');
+    expect(count).toBe(0);
+  });
+
+  it('rejects empty / non-string tags before fetch', async () => {
+    await expect(host.cache.invalidate('')).rejects.toThrow(TypeError);
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+
+  it('throws SlugRequiredError when slug missing', async () => {
+    setSlug(null);
+    await expect(host.cache.invalidate('posts')).rejects.toThrow(SlugRequiredError);
+  });
+
+  it('throws HostFetchError with the parsed body on 403', async () => {
+    fetchMock.mockResolvedValueOnce(
+      new Response(JSON.stringify({ code: 'forbidden' }), {
+        status: 403,
+        headers: { 'content-type': 'application/json' },
+      }),
+    );
+    try {
+      await host.cache.invalidate('posts');
+      throw new Error('expected throw');
+    } catch (err) {
+      expect(err).toBeInstanceOf(HostFetchError);
+      expect((err as HostFetchError).status).toBe(403);
+      expect((err as HostFetchError).responseBody).toEqual({ code: 'forbidden' });
+    }
+  });
+});
+
+describe('hostFetch transport', () => {
+  it('sets Accept: application/json by default', async () => {
+    fetchMock.mockResolvedValueOnce(jsonResponse({ ok: true }));
+    await __test_hostFetch('/foo', { method: 'GET' }, {});
+    const init = fetchMock.mock.calls[0]![1] as RequestInit;
+    const headers = init.headers as Headers;
+    expect(headers.get('Accept')).toBe('application/json');
+  });
+
+  it('sets Content-Type: application/json for bodied requests', async () => {
+    fetchMock.mockResolvedValueOnce(jsonResponse({ ok: true }));
+    await __test_hostFetch('/foo', { method: 'POST', body: '{}' }, {});
+    const init = fetchMock.mock.calls[0]![1] as RequestInit;
+    const headers = init.headers as Headers;
+    expect(headers.get('Content-Type')).toBe('application/json');
+  });
+
+  it('sends credentials: include', async () => {
+    fetchMock.mockResolvedValueOnce(jsonResponse({ ok: true }));
+    await __test_hostFetch('/foo', { method: 'GET' }, {});
+    const init = fetchMock.mock.calls[0]![1] as RequestInit;
+    expect(init.credentials).toBe('include');
+  });
+
+  it('parses a 204 as null', async () => {
+    fetchMock.mockResolvedValueOnce(new Response(null, { status: 204 }));
+    const out = await __test_hostFetch('/foo', { method: 'DELETE' }, {});
+    expect(out).toBeNull();
+  });
+
+  it('passes non-JSON content type through as text', async () => {
+    fetchMock.mockResolvedValueOnce(
+      new Response('hello', {
+        status: 200,
+        headers: { 'content-type': 'text/plain' },
+      }),
+    );
+    const out = await __test_hostFetch('/foo', { method: 'GET' }, {});
+    expect(out).toBe('hello');
+  });
+});
+
+describe('buildQuery', () => {
+  it('returns empty string for undefined', () => {
+    expect(__test_buildQuery(undefined)).toBe('');
+  });
+
+  it('camelCase keys become snake_case', () => {
+    expect(__test_buildQuery({ perPage: 5 })).toBe('?per_page=5');
+  });
+
+  it('skips null/undefined values', () => {
+    expect(__test_buildQuery({ a: null, b: undefined, c: 1 })).toBe('?c=1');
+  });
+
+  it('joins arrays with commas', () => {
+    expect(__test_buildQuery({ tags: ['a', 'b'] })).toBe('?tags=a%2Cb');
+  });
+});
diff --git a/packages/ts/sdk/src/host.ts b/packages/ts/sdk/src/host.ts
new file mode 100644
index 00000000..eae11573
--- /dev/null
+++ b/packages/ts/sdk/src/host.ts
@@ -0,0 +1,431 @@
+/**
+ * Browser-side host calls.
+ *
+ * The `host` object is the SDK's main namespace for plugin code that
+ * needs to talk back to the GoNext server. Each sub-namespace
+ * (`host.posts`, `host.users`, `host.media`, `host.cache`) is a thin
+ * shim over the existing REST surfaces the admin already exposes —
+ * the WP-compat read/write shim under `/wp-json/wp/v2/...` for
+ * posts, users, and media (see apps/api/internal/wprest/shim.go),
+ * and the per-plugin sub-tree under `/api/plugins/{slug}/...` for
+ * plugin-scoped endpoints like cache invalidation.
+ *
+ * Design rules:
+ *
+ *   1. Every call is `same-origin` + `credentials: 'include'`. The
+ *      admin authenticates the plugin's browser bundle the same way
+ *      it authenticates its own UI: session cookie + nonce. Plugin
+ *      code MUST NOT need to forge an Authorization header.
+ *
+ *   2. Errors throw `HostFetchError` (typed) — never silently
+ *      resolve to `undefined`. Plugin authors get a clear stack and
+ *      can `instanceof` to branch on network vs. server-side
+ *      failures.
+ *
+ *   3. No client-side state. Each method is a pure function over the
+ *      arguments; caching / invalidation is the host's job (and
+ *      `host.cache.invalidate` exists precisely so plugins can
+ *      participate in it).
+ *
+ *   4. The slug is read lazily through `requireSlug()` on the FIRST
+ *      call, not at module import. Plugins that wrap the SDK in a
+ *      lazy-initialized singleton therefore don't need to also wrap
+ *      the slug-detection bootstrap.
+ *
+ * The shims are intentionally narrow. Anything the plugin's own
+ * routes (#136) handle is out of scope here — this object exposes
+ * the COMMON host surface that nearly every plugin needs.
+ */
+
+import { requireSlug } from './slug';
+
+/**
+ * Base path for the WP-compat shim. Mirrors `wprest.BasePath` on the
+ * Go side. We avoid importing a JSON config so this single file is
+ * the wire-level contract — if the host ever moves the prefix, this
+ * is the one place to update.
+ */
+const WP_BASE = '/wp-json/wp/v2';
+
+/**
+ * Base path for plugin-scoped sub-routes. The host mounts each
+ * plugin's manifest-declared HTTP routes under
+ * `/api/plugins/{slug}/...`, and the SDK uses the same prefix for
+ * SDK-defined plugin operations (cache invalidation, …) so a future
+ * extension can land without a new prefix.
+ */
+const PLUGIN_API_BASE = '/api/plugins';
+
+/**
+ * One post in the WP REST v2 shape. Only the fields the SDK
+ * exposes are typed; the underlying payload may contain more
+ * fields, which the helpers preserve so consumers can cast.
+ */
+export interface Post {
+  id: number;
+  date: string;
+  date_gmt?: string;
+  modified?: string;
+  slug: string;
+  status: string;
+  type?: string;
+  title: { rendered: string };
+  content?: { rendered: string };
+  excerpt?: { rendered: string };
+  author?: number;
+  featured_media?: number;
+  [extra: string]: unknown;
+}
+
+/**
+ * Subset of the user shape relevant to client code. The host's
+ * `/wp-json/wp/v2/users` returns more fields, which pass through
+ * via the index signature.
+ */
+export interface User {
+  id: number;
+  name: string;
+  slug?: string;
+  description?: string;
+  avatar_urls?: Record<string, string>;
+  [extra: string]: unknown;
+}
+
+/**
+ * One media item. The shim returns the WP REST v2 attachment
+ * shape — same as live WP — so plugin authors with prior WP
+ * experience can use the existing field names directly.
+ */
+export interface Media {
+  id: number;
+  date?: string;
+  slug?: string;
+  type?: string;
+  title?: { rendered: string };
+  source_url?: string;
+  mime_type?: string;
+  [extra: string]: unknown;
+}
+
+/**
+ * Common collection-listing arguments. `perPage` maps to WP's
+ * `per_page`; we expose the camelCase form for ergonomic plugin
+ * code and translate at the wire.
+ *
+ * Any extra fields are passed through to the query string so
+ * future server-side filters work without an SDK rev.
+ */
+export interface ListOptions {
+  page?: number;
+  perPage?: number;
+  search?: string;
+  /** Free-form pass-through. Stringified into the query string. */
+  [extra: string]: unknown;
+}
+
+/**
+ * Strong-typed error thrown by every host call. `status` is `0`
+ * when the failure is a transport-level error (CORS, offline,
+ * fetch abort); otherwise it carries the HTTP status code.
+ *
+ * Plugin code branches on:
+ *
+ *   if (err instanceof HostFetchError && err.status === 0) {…}
+ *
+ * to distinguish "no network" from "server said no". The
+ * `responseBody` field is the parsed JSON body when one exists,
+ * else `null` — same shape the WP REST error envelope uses.
+ */
+export class HostFetchError extends Error {
+  override readonly name = 'HostFetchError';
+  readonly status: number;
+  readonly url: string;
+  readonly responseBody: unknown;
+  constructor(message: string, status: number, url: string, responseBody: unknown) {
+    super(message);
+    this.status = status;
+    this.url = url;
+    this.responseBody = responseBody;
+  }
+}
+
+/**
+ * Options accepted by every host-side call. Exposed so a plugin can
+ * forward an `AbortSignal` from its own component lifecycle and
+ * cancel in-flight requests on unmount.
+ */
+export interface HostCallOptions {
+  signal?: AbortSignal;
+}
+
+/**
+ * Issues a host fetch. Owns the canonical request shape — same-
+ * origin + cookies, JSON Accept, JSON Content-Type when a body is
+ * supplied, an AbortSignal forwarded from the caller.
+ *
+ * The body parsing is best-effort: a 204 / empty response resolves
+ * to `null`; a non-JSON content-type passes through the raw text
+ * (cast); a JSON body parses to whatever shape the caller's
+ * generic claims. Errors throw `HostFetchError` with the parsed
+ * body (if any) attached so callers can render server-side validation
+ * messages without re-parsing.
+ */
+async function hostFetch<T>(
+  url: string,
+  init: RequestInit,
+  callOpts: HostCallOptions,
+): Promise<T> {
+  const headers = new Headers(init.headers ?? undefined);
+  if (!headers.has('Accept')) {
+    headers.set('Accept', 'application/json');
+  }
+  if (init.body !== undefined && init.body !== null && !headers.has('Content-Type')) {
+    headers.set('Content-Type', 'application/json');
+  }
+  let response: Response;
+  try {
+    response = await fetch(url, {
+      credentials: 'include',
+      ...init,
+      headers,
+      signal: callOpts.signal,
+    });
+  } catch (err) {
+    // Network-level failure: AbortError, TypeError ("Failed to
+    // fetch"), CORS, offline. Re-raise as HostFetchError so consumers
+    // can `instanceof`-check uniformly.
+    const message = err instanceof Error ? err.message : String(err);
+    throw new HostFetchError(`network error: ${message}`, 0, url, null);
+  }
+  const parsed = await safeParseBody(response);
+  if (!response.ok) {
+    throw new HostFetchError(
+      `host call failed: ${response.status} ${response.statusText}`,
+      response.status,
+      url,
+      parsed,
+    );
+  }
+  return parsed as T;
+}
+
+/**
+ * Reads the response body without throwing on an empty / non-JSON
+ * payload. Returns `null` when there is no body.
+ */
+async function safeParseBody(response: Response): Promise<unknown> {
+  if (response.status === 204) {
+    return null;
+  }
+  const contentType = response.headers.get('content-type') ?? '';
+  // Read text first; many error envelopes from middleware (rate
+  // limit, CSP) come back as text/plain.
+  const text = await response.text();
+  if (text === '') {
+    return null;
+  }
+  if (contentType.includes('application/json')) {
+    try {
+      return JSON.parse(text) as unknown;
+    } catch {
+      return text;
+    }
+  }
+  return text;
+}
+
+/**
+ * Builds the query string from a ListOptions-like object. Returns
+ * the prefix '?' included when there is at least one parameter,
+ * otherwise an empty string. Keys map camelCase → snake_case for
+ * WP-compat; unknown keys pass through as-is.
+ *
+ * Boolean values serialize as 'true'/'false' (WP convention).
+ * Array values join with commas (WP convention).
+ * Nullable values are skipped, so callers can build an options
+ * object with conditional fields without manual cleanup.
+ */
+function buildQuery(opts: ListOptions | undefined): string {
+  if (opts === undefined) {
+    return '';
+  }
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(opts)) {
+    if (value === undefined || value === null) continue;
+    const wire = camelToSnake(key);
+    if (Array.isArray(value)) {
+      params.set(wire, value.map(String).join(','));
+      continue;
+    }
+    params.set(wire, String(value));
+  }
+  const s = params.toString();
+  return s === '' ? '' : `?${s}`;
+}
+
+/**
+ * Quick camelCase → snake_case translation. Used for query keys
+ * (`perPage` → `per_page`). Naïve on purpose; the surface is small.
+ */
+function camelToSnake(s: string): string {
+  return s.replace(/[A-Z]/g, (m) => `_${m.toLowerCase()}`);
+}
+
+/**
+ * `host.posts` — read access to published posts.
+ *
+ * Writes (create / update / delete) deliberately are NOT exposed
+ * here. Plugin browser code that needs to author content does so
+ * through the host's own admin UI components (`<PostEditor>`),
+ * which run with the operator's session cookie + nonce. Letting a
+ * plugin's browser bundle mint arbitrary posts would bypass the
+ * admin's capability checks.
+ */
+const posts = {
+  /**
+   * Lists posts. Pages and per-page caps mirror the WP REST shim.
+   * Returns the raw array — the host emits the totals via the
+   * `X-WP-Total` header which plugin code can read via the
+   * `listResponse` helper if needed.
+   */
+  list(options?: ListOptions, callOpts: HostCallOptions = {}): Promise<Post[]> {
+    const url = `${WP_BASE}/posts${buildQuery(options)}`;
+    return hostFetch<Post[]>(url, { method: 'GET' }, callOpts);
+  },
+
+  /**
+   * Reads a single post by id. The id is encoded into the path so
+   * a plugin that builds the id from user input doesn't need its
+   * own validation — the host route's `{id}` matcher rejects
+   * malformed values.
+   */
+  get(id: number, callOpts: HostCallOptions = {}): Promise<Post> {
+    const url = `${WP_BASE}/posts/${encodeURIComponent(String(id))}`;
+    return hostFetch<Post>(url, { method: 'GET' }, callOpts);
+  },
+} as const;
+
+/**
+ * `host.users` — read access to the user directory plus a special
+ * `me()` helper that resolves the currently-authenticated user.
+ *
+ * `me()` calls `/wp-json/wp/v2/users/me`, which is the same
+ * endpoint the live WP REST surface uses. It returns the calling
+ * user's profile (and only that user's; the host enforces it
+ * server-side).
+ */
+const users = {
+  list(options?: ListOptions, callOpts: HostCallOptions = {}): Promise<User[]> {
+    const url = `${WP_BASE}/users${buildQuery(options)}`;
+    return hostFetch<User[]>(url, { method: 'GET' }, callOpts);
+  },
+  get(id: number, callOpts: HostCallOptions = {}): Promise<User> {
+    const url = `${WP_BASE}/users/${encodeURIComponent(String(id))}`;
+    return hostFetch<User>(url, { method: 'GET' }, callOpts);
+  },
+  me(callOpts: HostCallOptions = {}): Promise<User> {
+    return hostFetch<User>(`${WP_BASE}/users/me`, { method: 'GET' }, callOpts);
+  },
+} as const;
+
+/**
+ * `host.media` — read access to the media library.
+ *
+ * Upload is intentionally not exposed: the WP REST media endpoint
+ * accepts multipart bodies and requires a nonce + capability check
+ * the admin UI handles via its own `<MediaUploader>`. Plugin code
+ * that wants to attach uploads should drive the admin's media
+ * picker via the (forthcoming) `host.ui` namespace.
+ */
+const media = {
+  list(options?: ListOptions, callOpts: HostCallOptions = {}): Promise<Media[]> {
+    const url = `${WP_BASE}/media${buildQuery(options)}`;
+    return hostFetch<Media[]>(url, { method: 'GET' }, callOpts);
+  },
+  get(id: number, callOpts: HostCallOptions = {}): Promise<Media> {
+    const url = `${WP_BASE}/media/${encodeURIComponent(String(id))}`;
+    return hostFetch<Media>(url, { method: 'GET' }, callOpts);
+  },
+} as const;
+
+/**
+ * `host.cache` — plugin-scoped cache invalidation.
+ *
+ * Posts under `/api/plugins/{slug}/cache/invalidate` with the
+ * supplied tag list. The host's invalidator (see
+ * packages/go/cache/invalidator) then propagates the invalidation
+ * across the cluster via the shared Redis channel.
+ *
+ * The capability gate is the same as the WASM-side
+ * `gn_cache_invalidate`: the plugin must hold the
+ * `cache.invalidate` grant. Plugins without the grant get a 403
+ * back, which surfaces as a `HostFetchError` with status 403.
+ *
+ * Tag validation is server-side; the client only checks that each
+ * tag is a string so a typo throws TYPE-side rather than HTTP-side.
+ */
+const cache = {
+  /**
+   * Invalidates one or more cache tags. The host accepts either a
+   * single string or an array; the SDK normalizes to an array on
+   * the wire so the server-side schema is unambiguous.
+   *
+   * Returns the (server-supplied) count of invalidated keys, or 0
+   * if the server didn't echo one back.
+   */
+  async invalidate(
+    tags: string | ReadonlyArray<string>,
+    callOpts: HostCallOptions = {},
+  ): Promise<number> {
+    const slug = requireSlug();
+    const tagList = Array.isArray(tags) ? Array.from(tags) : [tags as string];
+    for (const t of tagList) {
+      if (typeof t !== 'string' || t === '') {
+        throw new TypeError(
+          `[@gonext/sdk] host.cache.invalidate: tag must be a non-empty string (got ${JSON.stringify(t)})`,
+        );
+      }
+    }
+    const url = `${PLUGIN_API_BASE}/${encodeURIComponent(slug)}/cache/invalidate`;
+    const body = JSON.stringify({ tags: tagList });
+    const result = await hostFetch<{ invalidated?: number } | null>(
+      url,
+      { method: 'POST', body },
+      callOpts,
+    );
+    if (result === null || typeof result !== 'object') {
+      return 0;
+    }
+    return typeof result.invalidated === 'number' ? result.invalidated : 0;
+  },
+} as const;
+
+/**
+ * The `host` namespace. Exported as a single frozen object so
+ * plugin code that destructures (`const { posts } = host`) gets a
+ * stable reference and can't accidentally monkey-patch a method on
+ * another plugin's namespace.
+ */
+export const host = Object.freeze({
+  posts,
+  users,
+  media,
+  cache,
+}) as {
+  readonly posts: typeof posts;
+  readonly users: typeof users;
+  readonly media: typeof media;
+  readonly cache: typeof cache;
+};
+
+/**
+ * Internal hook for tests. Not exported from the public barrel.
+ * Exposes the low-level fetch helper so tests can pin transport
+ * behaviour (header set, abort plumbing, error shape) without
+ * needing to hit one of the namespace shims.
+ *
+ * @internal
+ */
+export const __test_hostFetch = hostFetch;
+/** @internal */
+export const __test_buildQuery = buildQuery;
diff --git a/packages/ts/sdk/src/i18n.test.ts b/packages/ts/sdk/src/i18n.test.ts
new file mode 100644
index 00000000..4618161a
--- /dev/null
+++ b/packages/ts/sdk/src/i18n.test.ts
@@ -0,0 +1,113 @@
+/**
+ * i18n.t / i18n.load tests.
+ *
+ * Catalogue fetch is mocked; we exercise the fallback, the
+ * interpolation, the cache reuse, and the malformed-input
+ * resilience.
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { i18n } from './i18n';
+import { __resetSlugCache, setSlug } from './slug';
+
+let fetchMock: ReturnType<typeof vi.fn>;
+
+beforeEach(() => {
+  __resetSlugCache();
+  setSlug('demo');
+  i18n.__reset();
+  fetchMock = vi.fn();
+  globalThis.fetch = fetchMock as unknown as typeof fetch;
+  document.documentElement.setAttribute('lang', 'en');
+});
+
+afterEach(() => {
+  i18n.__reset();
+  __resetSlugCache();
+});
+
+function jsonResponse(body: unknown): Response {
+  return new Response(JSON.stringify(body), {
+    status: 200,
+    headers: { 'content-type': 'application/json' },
+  });
+}
+
+describe('i18n.load', () => {
+  it('fetches the catalogue and caches the result', async () => {
+    fetchMock.mockResolvedValueOnce(jsonResponse({ 'hello.world': 'Hello!' }));
+    const cat = await i18n.load();
+    expect(cat['hello.world']).toBe('Hello!');
+    // Second call: served from cache, no second fetch.
+    await i18n.load();
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(fetchMock.mock.calls[0]![0]).toBe('/api/plugins/demo/i18n/en.json');
+  });
+
+  it('uses an explicit locale when provided', async () => {
+    fetchMock.mockResolvedValueOnce(jsonResponse({ 'hi': 'Bonjour' }));
+    await i18n.load('fr-FR');
+    expect(fetchMock.mock.calls[0]![0]).toBe('/api/plugins/demo/i18n/fr-FR.json');
+  });
+
+  it('resolves to an empty catalogue on fetch failure', async () => {
+    fetchMock.mockRejectedValueOnce(new Error('boom'));
+    const cat = await i18n.load();
+    expect(cat).toEqual({});
+  });
+
+  it('filters non-string catalogue entries', async () => {
+    fetchMock.mockResolvedValueOnce(
+      jsonResponse({ valid: 'ok', invalid: 42, also: null }),
+    );
+    const cat = await i18n.load();
+    expect(cat).toEqual({ valid: 'ok' });
+  });
+
+  it('shares the in-flight promise', async () => {
+    fetchMock.mockResolvedValueOnce(jsonResponse({ k: 'v' }));
+    const [a, b] = await Promise.all([i18n.load(), i18n.load()]);
+    expect(a).toEqual({ k: 'v' });
+    expect(b).toEqual({ k: 'v' });
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('i18n.t', () => {
+  it('returns the key while the catalogue is loading', () => {
+    fetchMock.mockResolvedValue(jsonResponse({ greeting: 'Hello' }));
+    // Synchronous call — first t() kicks off async load.
+    const out = i18n.t('greeting');
+    expect(out).toBe('greeting');
+  });
+
+  it('returns the translation once the catalogue resolves', async () => {
+    fetchMock.mockResolvedValue(jsonResponse({ greeting: 'Hello' }));
+    await i18n.load();
+    expect(i18n.t('greeting')).toBe('Hello');
+  });
+
+  it('falls back to the key when the entry is missing', async () => {
+    fetchMock.mockResolvedValue(jsonResponse({ other: 'present' }));
+    await i18n.load();
+    expect(i18n.t('missing.key')).toBe('missing.key');
+  });
+
+  it('interpolates {name} placeholders', async () => {
+    fetchMock.mockResolvedValue(jsonResponse({ welcome: 'Hi, {name}!' }));
+    await i18n.load();
+    expect(i18n.t('welcome', { name: 'Ada' })).toBe('Hi, Ada!');
+  });
+
+  it('leaves unknown placeholders intact', async () => {
+    fetchMock.mockResolvedValue(jsonResponse({ tpl: 'Hi {name} and {other}' }));
+    await i18n.load();
+    expect(i18n.t('tpl', { name: 'A' })).toBe('Hi A and {other}');
+  });
+
+  it('returns the key when no slug is detected', () => {
+    setSlug(null);
+    // No fetch should be issued because we have no slug to address.
+    expect(i18n.t('any.key')).toBe('any.key');
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+});
diff --git a/packages/ts/sdk/src/i18n.ts b/packages/ts/sdk/src/i18n.ts
new file mode 100644
index 0000000000000000000000000000000000000000..218ce36950103dcb246ef30165ee4011baa65856
GIT binary patch
literal 7902
zcmb_h+m0K@5zX^{MOzU}(pi!*5CaZnN)gsFtXPo*?HUOp3u5oENsf0oP0wX1iXz~r
zd_a(I$cOn$a!ytE%y6|5^bkEr)J%6*b=9d;ml=QY#fkaCoMoxYt6`bWok_p^Iyc+G
zZZ@tM;U(W+tejc-vg(zlDr{b6wn}|&%DPzC1Y1f|ZnCtRgyqHz&9mH8*j2jX+7+h%
z`#*j4_2ASvo2<+xtCwkR5}TXCEz`2Xg3hrN$Uj$ZSDNe8n%OdcO|4$X)iY!Bxg1ZW
zj9aG_6oWLVJj{GzGZzo}>-n>%kW|^sFKbsCTbWDmt9Y@FrrWe|r*ev&uc4lMv+*T%
zRFL70kBEoQ#&(mA^*ZHvU*cYeF*P0URg1&u=hEl1kr?p&+aJurRmn;YZ8U6@Gd_nc
zaRsBB<&p^uhV^M>pwil{eX;B6{;(2_apTOCX@v{SD1TJ-VZBphi)A^O;XHp;ntCH^
z@q#DEJES?xzwz*>s%2*TO$Mi~d^UGQd4Tc{%{nd1G+)vsW&v5HxwOfZseC-8a8+I8
zTtYW+8C>GBg&MT9YiDd}maeMY8=`3T`gI?Q{r2mB;t3HH9uO=m3)dIU&h2I9jJtL~
z<O+Y;E>6tKmU$2UbS{sl*c$FC+}!M3<Kr`!keZdiSml<xNibQ!1knqHvFCDU`t;#x
zaKK;$6pNq!W;X@_QtZS%8=Dp*^VC&aUtGZ+X;v37-nY-p(`OfE<5T!N$bj?WC4=q^
zH1pM)H)dWJ)T(uV=Iz|9?G=uiRkV&8l_&9f;<r-FPvf7O%esO=%KEZ&ztlWccL^4-
zwMbnVq4Gpx0tc2ps~Nfz$jvhN7Xoo9TOu+9@>!YyYcoaQ3;~;!B7N(`A7(c9Nxg=&
zQT*{JbMpVp=F6}_l#CEDGlvM^4K82|2Ep9pin*^Kw?Jq;OcJ-LhEK4+wo9>>SWjXb
z&LN^oUl)le;upXGylfV}04Na8d|!iS0IL`{Nmb)|0AYz3P^zE;8rY=+Tg<*$RqM=9
z>HDCQB=N-@?#Lv%#wRD~dgF`A>~ZT~YB0k&aA6K+QTVm#jmCsY@7~GDSosq$X&pI%
zR~CpTn08~J?z&v2bMxE3{>@(i;mAA(U~I-4tYP;;?*(sSahdpyle=Aic`q;}O@QNa
z2aMvfYw;btJu}-BhOoTarf@@q5ROgXVj00gyR_)C8RKbZ5}#K#%>^3c6OtURS?wV7
zEV87Tniq}+`3Bm;D5ne^{CmH>@Ogz$5;Z-pejGLMf}M}d-<_F*+p(`sOK54Xa=*=o
zZoR2?)L7u&r;;?W1CN(Akl^NwL>S{({VnK2wlbWsgLK1Fxavk^4Ae_eAmbB9264<@
z5`wNM0H8oX43{1FSB`u7=pPrISQ-$!;}hXY$##vM)Cl_%L&B=+a$<Uv;^sZ`PJiO^
z@>_%fFQ#?Kq_sDnZvd>cbPp!xx&Hd55d*UyPEO!Am`KtA{FA$_0Vy>OY8H!5_xpp^
zRnO~71huC1kgzo$tsS^>E&v1w3%?y+`kKMw4T8sS1Nvy?gshC`bGWIf5nTnGK2w$U
zrb1v$MZjzzko0h0<|SjmKRf{8q|8G2AqA*S1N!tFsXL~I=9H*1*me<$4N@Y!j9m11
z0p@6}$Q&REK>Q0ggZEF(Rhl5*`NaZf;S_`;)2=XqB1cK(25!J6KnfBUhy=-Yk)_L3
zr3m3E9ik<7GCvW70+~+rqFEdq3X`VSLc!RriabO*X1wG0Ch1Dr$&nx@#9VLXVEWOU
z-YKX@pZ1VtGC=Aun1$;s8NVRuJ7MviiMjKAiXGf=`0UQi>{6G(vom=t`|%Vu=RJPR
zB@p4=Hp`1rnOjJe!I08`2kpXmG5MpI0HNw3*J+tDH3Jh|K1YhqKwO1Eie0gsTOpm4
zFlSzYhUbMxH91!W#yCOBlSz=GWeSjgE9oGV@_K#giu*AwW2LG$h(820h%E^bNpjb2
z9&+9k$bi3`dGG*gE^M7u`i3zAgM?j-U<VYt95LdWaOxkQcC@9iTWpYxqa<?YOMvPX
zW#L~vKft8p@;-Kk+KfvMrziNk!Tj?ArnHR97Um=KW9b%k7OS98EYXot8*Wq7f6NcO
z5lFGE(HR}cGlVq&o3o@726dz5h$&xF;>PAKqthz0wRshs4Cf+`fxE?ml2<Z&iHd;X
z!IFEC7Qi9OA(R6mS;fC#nE~iWbSNpdw;|CA*O%o8PHz|6Tn|v9Z*0o-p~|`^Wr|QY
zU?!bM?(^Y-=EqGFi$Xxp&|>JQSQV(kFD(wKSzqzdMb-Nh{Qp20D~PEiyHHOYBamz~
zRf7M)?LtcZ2>jd|&8~6N2-P*K{(#YRVfxLI&!$rYYIln?ck@BGj4|CcBh6uEils4)
zwJS|zyI`78P^=NrMnI4cT+<Qwb0j6?Ir9OH8aYw*QP`ld6c5#-HQwWiQ)T%!bhVVf
zVZor&2rQNN`+(TMOz$@aVSYx*K0=A84b)!ZyPMiiTO6~9M(%4a+$fL7jlP2@5f779
zzyHbdv}QOGw?Et_4Ns8-&msf0lJ(ceZ^R1ahK$o#j5NXmg>_tUgR?GB7Yu!#p|_eB
z%uW(&Dwze%95n+622w{bWg~~99F;x^JtR3x+LmgCdY=UzlL`!`T{}CpbiJ-C=>}Q%
z^YsS30!#iB$vs^=4Qlfj;o00~aw>DpYm5!(Ph^X0k3xJe4pH5b%-KT25H~usMbit(
z?Rt$gA8O;>YNRCwY{w#_sV@L@a<C*i)Gp9b>ki0A)<I*qsoOSN6u8Iilhg&6nYEpE
zWaSDaLac2eJQO0q`dYg!>Rc`Q_~QK0lkaGua+fEo!soumZ)wbx0uk3}rn_%xV9N*X
zg`|AqDWG&WM9VaUnL#M9Dr(<G+Rf~!)EUz-EZm^*T=FSxJsz7U_U+Cv9L2Y2CFh=v
zJ5!D32o#?rc~w}etB|(fX+49Dqvktl`a%XoN1;w48l*ZTG(;3G6Dk)yKss2d*x2c^
z3t?=th-rXE3}p_D2vm)iVi2)8P}s=Hw~+XOhoHpNRUuwF<ne)E=HcWrWwKi{fSOo1
zMps2<yp{L6Tzky1=JU_ngm4?#n|JRp^U|F1-h0x-Af|(Gy|_4D0*-!!eiYRoq8or_
zM^zv=Hbshm#R3y4&129YF3`raG^gP|iOqvGu-upraQMgh4$avS-N9`Q&Ardx2W4+2
zxA(aF!*V|0>?Th{c-+R@noZOe%*bd9&LR(LOlgaBqvsSF7pp*3Wz9+B%?E9AW@Wku
z)zN-|Q1~A(-+QS~q>Ii$UwI(CXqb9DE=!J78F5x7E^Q<Qx0-WwBtu`MnD?F<&SE+I
z03VUw@-%U14rGSGGs1wGV$x)YkrX2FjOloIhNiLb87Tq_x%X2iuckmR%G>}JQ_5?&
zOn}$eR_d)7^Rd&2{|B)liLpQLbmbE3>ZrQN5RJz=-QByK>F&oDkIy`YNjV}ygbc!n
z_|^ph-(hYnUWrW&j=->NYV6jcmKW{&5RA4@{f?<8M5H$393st=te(4`dU}P)4+{SY
zdP*I(VFl*<=*VS`Kjx4c4W=MLJWd+<4B;s<NB$~CeuV_HmEpr9*5G{^Hf!#<yN5D|
ziMhLP_R*6yCdhJROLLbVW2mX=>qVN?RH6@#L3L1Ti^}U$6WxHiG_TR-fTlRE!mLc5
zvyklh%b#6R^`e?hfbj$h1~q+`X7ZiEhvv~-+YIQHhQd}ACaNH=?aE_nmm`+|)*fvR
zkL7@kC$P~7eKCp*ZG4+(1GloH;^zvB@fA8{oeU7vx*ZcrI0s!+F+iN;oPPq$=xjVD
zn<4e#)S$cVh-=vqVD9h%jJTJ`Wl7XmD89sC`1%zmiO<9)BN8zt!D7UQ!D-cC#4D}%
z^<q6{iSXk3=tVTGG0@@V)ho!prghc6v~f@zue%&^^floygIVI_1N9)<+Axej>eI<c
z974!+BGfTAM-Z^GP9MPCMGeg3>%whw2NDI~g<h1E8f@E1{G4YhEi{DCs^-|C$Ke0e
z@x<{of)?i27cpYfdJ(+MQ=&PVH5d<KBV^kr=(WTe{qaxx{!2T2`*8TrKMw!=`qdu>
zKOM%)Q_}}*Gkp5t_@~oeC?McQ5&4pD8C>e=SL!^fsg6F<Q6F^`Z2T*-TF*Dn&t*j1
zzt&*K-<Vm3Jn;hbqiG_3Ghp40$veKrVHbwIDBZr3nOgX)B;O1=bRWJVj&=Tl(2);1
zEP7F*N~J9y3xHfu8VCQ|0w2R9%X9|)(>uTY`rkVk_oL{?8Vt9j-?+rI1f|=WIUaF;
z^i6>f(%i-kPQR#h3gR0RrHC2f<W7*qduvEFroKs7J(tUnxaCT*(iHXb2R^!>M1L4<
z*za+5uOV>V+o8?oLGNRN1Ms-G>qN=KGHNH=+%omouVM;=bdh2fD+YF)Q`3x?%;0k_
tNq2~OKbWuz-&&dgl!_|OKB6ga$;FCbv2jp#c2_^X{_bx4@H(UJ{{vLhAw2*9

literal 0
HcmV?d00001

diff --git a/packages/ts/sdk/src/index.ts b/packages/ts/sdk/src/index.ts
new file mode 100644
index 00000000..6f8142da
--- /dev/null
+++ b/packages/ts/sdk/src/index.ts
@@ -0,0 +1,50 @@
+/**
+ * @gonext/sdk — browser-side SDK plugin authors import.
+ *
+ * This is the canonical bundle the host's import map (see
+ * packages/ts/plugin-frontend-host/src/import-map.ts) resolves
+ * `@gonext/sdk` to. A plugin's browser code writes:
+ *
+ *   import { host, defineBlock, getSlug, i18n, setHTML } from '@gonext/sdk';
+ *
+ * and the import map points that specifier at
+ * `/_/runtime/sdk.mjs` (the ESM emit from this package's tsup
+ * build). The host serves the file with an SRI hash pinned in
+ * the import map, so a tampered SDK bundle is rejected by the
+ * browser before any plugin code runs.
+ *
+ * Public surface:
+ *
+ *   - `getSlug()` / `setSlug()` / `SlugRequiredError` — plugin
+ *     identity, auto-detected from the import-map URL.
+ *
+ *   - `host.{posts, users, media, cache}` — REST shims over the
+ *     existing WP-compat + plugin-scoped surfaces.
+ *
+ *   - `HostFetchError` — typed error for the REST shims.
+ *
+ *   - `defineBlock(spec)` — register a client-side block;
+ *     forwards to the editor's `BLOCK_REGISTRY` when present.
+ *
+ *   - `i18n.t(key, args)` / `i18n.load(locale)` — translation
+ *     lookup against the host's per-plugin catalogue endpoint.
+ *
+ *   - `setHTML(el, html)` / `getTrustedTypesPolicy()` — Trusted
+ *     Types-safe DOM injection that re-uses the host's
+ *     `gn-plugin` policy.
+ *
+ * Stability: post-1.0 we promise backwards compatibility on every
+ * named export. Pre-1.0 (current) we may rename internals; the
+ * public surface listed above is intentionally narrow so most
+ * plugin code survives a 0.x → 1.0 bump untouched.
+ */
+
+export { getSlug, setSlug, SlugRequiredError } from './slug';
+export { host, HostFetchError } from './host';
+export type { Post, User, Media, ListOptions, HostCallOptions } from './host';
+export { defineBlock } from './blocks';
+export type { BlockSpec, BlockProps } from './blocks';
+export type { ComponentType } from './react-types';
+export { i18n } from './i18n';
+export type { Catalogue } from './i18n';
+export { setHTML, getTrustedTypesPolicy } from './trusted-types';
diff --git a/packages/ts/sdk/src/react-types.ts b/packages/ts/sdk/src/react-types.ts
new file mode 100644
index 00000000..40277796
--- /dev/null
+++ b/packages/ts/sdk/src/react-types.ts
@@ -0,0 +1,33 @@
+/**
+ * Minimal `ComponentType` declaration.
+ *
+ * The SDK exposes block specs that carry React components, but
+ * adding `@types/react` as a dependency would (a) bloat the SDK's
+ * type surface, (b) couple us to a specific React major, and (c)
+ * make the SDK harder to consume from non-React block runtimes
+ * (Preact, future Solid integration). Declaring just the
+ * `ComponentType<P>` callable shape gives plugin authors the type
+ * affordance without the runtime / peer-dep coupling.
+ *
+ * The shape mirrors React's: a function from `props` to
+ * `ReactElement | null`, plus optional `displayName`. We use
+ * `unknown` for the return type so a JSX-emitting function and a
+ * pre-rendered element factory both satisfy the contract.
+ */
+
+/**
+ * Open-typed React element. The block registry treats whatever the
+ * component returns as opaque — it's the renderer (editor or theme)
+ * that types it tightly.
+ */
+export type ReactElementLike = unknown;
+
+/**
+ * Subset of `React.ComponentType<P>` that the SDK needs. Matches
+ * the real `@types/react` declaration structurally so a plugin can
+ * pass a real React component and get the right inference.
+ */
+export interface ComponentType<P> {
+  (props: P): ReactElementLike;
+  displayName?: string;
+}
diff --git a/packages/ts/sdk/src/slug.test.ts b/packages/ts/sdk/src/slug.test.ts
new file mode 100644
index 00000000..2001795a
--- /dev/null
+++ b/packages/ts/sdk/src/slug.test.ts
@@ -0,0 +1,178 @@
+/**
+ * Slug auto-detection tests.
+ *
+ * Each strategy gets its own table-driven block. We reset the
+ * module-scoped cache in `beforeEach` so detection re-runs against
+ * the fixture state for the current test.
+ */
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import {
+  __resetSlugCache,
+  SlugRequiredError,
+  getSlug,
+  requireSlug,
+  setSlug,
+} from './slug';
+
+beforeEach(() => {
+  __resetSlugCache();
+  // Clear any global from a prior test.
+  delete (globalThis as { __GN_PLUGIN_SLUG__?: unknown }).__GN_PLUGIN_SLUG__;
+  // Strip any plugin <script> tags the previous test inserted.
+  if (typeof document !== 'undefined') {
+    const stragglers = document.querySelectorAll('script[data-gn-test]');
+    stragglers.forEach((s) => s.remove());
+    const ctx = document.getElementById('gn-plugin-context');
+    if (ctx !== null) ctx.remove();
+  }
+});
+
+afterEach(() => {
+  __resetSlugCache();
+});
+
+describe('getSlug', () => {
+  it('returns null when no signal is present', () => {
+    expect(getSlug()).toBeNull();
+  });
+
+  describe('strategy: <script src> on the page', () => {
+    it('extracts the slug from /api/plugins/<slug>/web/...', () => {
+      const tag = document.createElement('script');
+      tag.src = 'https://cms.example.com/api/plugins/seo-helper/web/main.mjs';
+      tag.setAttribute('data-gn-test', '1');
+      document.head.appendChild(tag);
+      expect(getSlug()).toBe('seo-helper');
+    });
+
+    it('rejects a malformed slug', () => {
+      const tag = document.createElement('script');
+      // Capital letters violate the slug pattern.
+      tag.src = 'https://cms.example.com/api/plugins/Bad-Slug/web/main.mjs';
+      tag.setAttribute('data-gn-test', '1');
+      document.head.appendChild(tag);
+      expect(getSlug()).toBeNull();
+    });
+
+    it('ignores scripts not under /api/plugins/.../web/', () => {
+      const tag = document.createElement('script');
+      tag.src = 'https://cdn.example.com/static/random.mjs';
+      tag.setAttribute('data-gn-test', '1');
+      document.head.appendChild(tag);
+      expect(getSlug()).toBeNull();
+    });
+
+    it('takes the first matching script', () => {
+      const a = document.createElement('script');
+      a.src = '/api/plugins/first/web/index.mjs';
+      a.setAttribute('data-gn-test', '1');
+      const b = document.createElement('script');
+      b.src = '/api/plugins/second/web/index.mjs';
+      b.setAttribute('data-gn-test', '1');
+      document.head.append(a, b);
+      expect(getSlug()).toBe('first');
+    });
+  });
+
+  describe('strategy: <script type="application/json"> context block', () => {
+    it('reads slug from gn-plugin-context', () => {
+      const el = document.createElement('script');
+      el.type = 'application/json';
+      el.id = 'gn-plugin-context';
+      el.textContent = JSON.stringify({ slug: 'context-plugin' });
+      document.head.appendChild(el);
+      expect(getSlug()).toBe('context-plugin');
+    });
+
+    it('returns null on malformed JSON', () => {
+      const el = document.createElement('script');
+      el.type = 'application/json';
+      el.id = 'gn-plugin-context';
+      el.textContent = '{not json';
+      document.head.appendChild(el);
+      expect(getSlug()).toBeNull();
+    });
+
+    it('returns null when slug fails the pattern check', () => {
+      const el = document.createElement('script');
+      el.type = 'application/json';
+      el.id = 'gn-plugin-context';
+      el.textContent = JSON.stringify({ slug: '..%2Fadmin' });
+      document.head.appendChild(el);
+      expect(getSlug()).toBeNull();
+    });
+  });
+
+  describe('strategy: window.__GN_PLUGIN_SLUG__ override', () => {
+    it('reads from the global', () => {
+      (globalThis as { __GN_PLUGIN_SLUG__?: unknown }).__GN_PLUGIN_SLUG__ =
+        'dev-plugin';
+      expect(getSlug()).toBe('dev-plugin');
+    });
+
+    it('rejects a non-string', () => {
+      (globalThis as { __GN_PLUGIN_SLUG__?: unknown }).__GN_PLUGIN_SLUG__ = 42;
+      expect(getSlug()).toBeNull();
+    });
+
+    it('rejects a slug that fails the pattern', () => {
+      (globalThis as { __GN_PLUGIN_SLUG__?: unknown }).__GN_PLUGIN_SLUG__ =
+        'WithCapitals';
+      expect(getSlug()).toBeNull();
+    });
+  });
+
+  describe('priority', () => {
+    it('prefers a <script src> over the global', () => {
+      (globalThis as { __GN_PLUGIN_SLUG__?: unknown }).__GN_PLUGIN_SLUG__ =
+        'fallback';
+      const tag = document.createElement('script');
+      tag.src = '/api/plugins/winner/web/main.mjs';
+      tag.setAttribute('data-gn-test', '1');
+      document.head.appendChild(tag);
+      expect(getSlug()).toBe('winner');
+    });
+  });
+
+  it('memoizes the detection', () => {
+    (globalThis as { __GN_PLUGIN_SLUG__?: unknown }).__GN_PLUGIN_SLUG__ =
+      'cached';
+    expect(getSlug()).toBe('cached');
+    // Mutating the global after first detection has no effect:
+    (globalThis as { __GN_PLUGIN_SLUG__?: unknown }).__GN_PLUGIN_SLUG__ =
+      'something-else';
+    expect(getSlug()).toBe('cached');
+  });
+});
+
+describe('requireSlug', () => {
+  it('returns the slug when present', () => {
+    setSlug('present');
+    expect(requireSlug()).toBe('present');
+  });
+
+  it('throws SlugRequiredError when missing', () => {
+    expect(() => requireSlug()).toThrow(SlugRequiredError);
+  });
+});
+
+describe('setSlug', () => {
+  it('accepts a valid slug', () => {
+    setSlug('valid-slug-1');
+    expect(getSlug()).toBe('valid-slug-1');
+  });
+
+  it('clears the cache on null', () => {
+    setSlug('first');
+    setSlug(null);
+    expect(getSlug()).toBeNull();
+  });
+
+  it('rejects a malformed slug', () => {
+    expect(() => setSlug('Bad Slug')).toThrow(TypeError);
+  });
+
+  it('rejects an empty slug', () => {
+    expect(() => setSlug('')).toThrow(TypeError);
+  });
+});
diff --git a/packages/ts/sdk/src/slug.ts b/packages/ts/sdk/src/slug.ts
new file mode 100644
index 00000000..4f88575b
--- /dev/null
+++ b/packages/ts/sdk/src/slug.ts
@@ -0,0 +1,311 @@
+/**
+ * Plugin-slug auto-detection.
+ *
+ * The host emits an import map that resolves `@gonext/sdk` to a single
+ * URL on the admin origin — typically `/_/runtime/sdk.mjs` — and serves
+ * each plugin's web bundle from `/api/plugins/<slug>/web/...`. When a
+ * plugin's bundle calls into the SDK at runtime, the SDK needs to know
+ * WHICH plugin is asking so the REST shims can target the right
+ * /api/plugins/{slug}/... sub-tree (see PR #136 / routes/routes.go).
+ *
+ * Strategies, in priority order, all evaluated lazily so a missing one
+ * does not throw at module load:
+ *
+ *   1. The `import.meta.url` of the CALLING module — typically the
+ *      plugin's own ES module, served from
+ *      `/api/plugins/<slug>/web/<file>.mjs`. We extract the slug from
+ *      that path. This is the strongest signal because the URL is
+ *      issued by the host's static handler and cannot be forged from
+ *      inside the page.
+ *
+ *   2. A `<script type="application/json" id="gn-plugin-context">`
+ *      block on the page. The admin renders this whenever a plugin
+ *      bundle is mounted (`apps/web/src/components/plugin-frontend-host`).
+ *      Useful when the SDK is imported BEFORE the plugin module's own
+ *      `import.meta.url` is observable (rare; happens during certain
+ *      eager-evaluated import-map paths).
+ *
+ *   3. An explicit `window.__GN_PLUGIN_SLUG__` global. This is the
+ *      developer-mode escape hatch — local dev usually serves the SDK
+ *      from a Vite dev server where `import.meta.url` does not look
+ *      like the production path. Plugin authors set the global before
+ *      importing the SDK in tests / Storybook.
+ *
+ * None of these throws when the SDK is loaded in an environment that
+ * is NOT a plugin context (e.g. when the admin imports the SDK
+ * directly for its own UI scaffolding). Instead we return `null` and
+ * let the REST shims surface a clear error if a slug-dependent
+ * operation is invoked without one.
+ *
+ * The matched slug must follow the kebab-case rules the manifest
+ * schema enforces (lower-case ASCII, digits, hyphens, length 1..64);
+ * a path that contains anything else is rejected so a maliciously
+ * crafted URL like `/api/plugins/..%2Fadmin/web/x.mjs` cannot trick
+ * the SDK into addressing routes outside the plugin namespace.
+ */
+
+/**
+ * Pattern that matches a plugin slug under the host-side static
+ * handler. The capture group is the slug; the trailing `/web/`
+ * segment is required (the host serves plugin static assets ONLY
+ * under that path), which keeps the match anchored to the well-known
+ * mount point.
+ */
+const PLUGIN_URL_PATTERN = /\/api\/plugins\/([a-z0-9][a-z0-9-]{0,63})\/web\//;
+
+/**
+ * Same shape as the manifest validator. We re-derive it here so the
+ * SDK has zero runtime dependency on the manifest package — anything
+ * we accept the host must have already approved at install time.
+ */
+const SLUG_PATTERN = /^[a-z0-9][a-z0-9-]{0,63}$/;
+
+/**
+ * Cached slug, populated lazily on the first successful detection.
+ * Subsequent calls return the cached value. The cache is reset by
+ * `__resetSlugCache()` for tests.
+ */
+let cachedSlug: string | null | undefined = undefined;
+
+/**
+ * Public surface: returns the plugin slug for the current bundle, or
+ * `null` if none of the detection strategies found one.
+ *
+ * The result is memoized; the detection pass runs at most once per
+ * page lifetime. Plugins that have a legitimate need to override the
+ * slug at runtime (development reloads, SSR-into-CSR handoff) should
+ * set `window.__GN_PLUGIN_SLUG__` and then call `__resetSlugCache()`.
+ *
+ * NEVER throws. Slug-dependent helpers (host.posts, host.users, …)
+ * throw their own typed error when called without a slug; this
+ * function staying total means a "what plugin am I?" probe is safe
+ * to call from anywhere, including module top-level evaluation.
+ */
+export function getSlug(): string | null {
+  if (cachedSlug !== undefined) {
+    return cachedSlug;
+  }
+  cachedSlug = detectSlug();
+  return cachedSlug;
+}
+
+/**
+ * Asserts a slug is available. The REST shims call this BEFORE
+ * issuing a fetch so a "no slug" condition becomes a clear typed
+ * error rather than a request to `/api/plugins//posts` that the
+ * server would silently 404.
+ *
+ * Throws a `SlugRequiredError`; callers can `catch` on the class to
+ * differentiate this from network / parse errors.
+ */
+export function requireSlug(): string {
+  const slug = getSlug();
+  if (slug === null) {
+    throw new SlugRequiredError(
+      '[@gonext/sdk] no plugin slug detected. Set window.__GN_PLUGIN_SLUG__ ' +
+        'before importing the SDK, or call setSlug() explicitly.',
+    );
+  }
+  return slug;
+}
+
+/**
+ * Explicit override for environments where auto-detection cannot
+ * succeed (Node test harnesses, Storybook, the admin's own SSR
+ * pre-render pass). Validates against the slug pattern so a typo
+ * fails loudly rather than at the first fetch.
+ *
+ * Calling `setSlug(null)` clears the cache, equivalent to
+ * `__resetSlugCache()` but exposed under the public API.
+ */
+export function setSlug(slug: string | null): void {
+  if (slug === null) {
+    cachedSlug = null;
+    return;
+  }
+  if (!SLUG_PATTERN.test(slug)) {
+    throw new TypeError(
+      `[@gonext/sdk] setSlug rejected ${JSON.stringify(slug)}; ` +
+        'slug must match /^[a-z0-9][a-z0-9-]{0,63}$/.',
+    );
+  }
+  cachedSlug = slug;
+}
+
+/**
+ * Test-only escape hatch. Resets the cache so the next `getSlug`
+ * call re-runs detection with whatever globals the test has set up.
+ * Not part of the public API — production code that wants to swap
+ * slugs uses `setSlug`.
+ */
+export function __resetSlugCache(): void {
+  cachedSlug = undefined;
+}
+
+/**
+ * Detection-error subclass. Plugin code can pattern-match on it to
+ * skip slug-dependent setup when running in a non-plugin context:
+ *
+ *   try { return host.posts.list(); }
+ *   catch (e) {
+ *     if (e instanceof SlugRequiredError) return [];
+ *     throw e;
+ *   }
+ */
+export class SlugRequiredError extends Error {
+  override readonly name = 'SlugRequiredError';
+}
+
+/**
+ * Lazy, multi-strategy detection. Each branch returns `null` instead
+ * of throwing so the next branch gets a shot.
+ */
+function detectSlug(): string | null {
+  // Strategy 1: the URL of THIS module. tsup emits `import.meta.url`
+  // verbatim into the ESM build, and the host serves the SDK from
+  // `/_/runtime/sdk.mjs` — not under `/api/plugins/…` — so this
+  // branch only ever matches when the SDK has been re-served under a
+  // plugin's own bundle path (rare, but legal: a plugin can ship a
+  // pinned SDK copy). For the common case the next branch handles
+  // it.
+  const selfURL = readImportMetaURL();
+  if (selfURL !== null) {
+    const match = PLUGIN_URL_PATTERN.exec(selfURL);
+    if (match && typeof match[1] === 'string' && SLUG_PATTERN.test(match[1])) {
+      return match[1];
+    }
+  }
+
+  // Strategy 2: a `currentScript`-style readout. When a plugin bundle
+  // is loaded the browser exposes `document.currentScript.src` to
+  // synchronous top-level code. We scan the page's <script> tags for
+  // one served from `/api/plugins/<slug>/web/…` and take its slug.
+  const scriptSlug = detectSlugFromScripts();
+  if (scriptSlug !== null) {
+    return scriptSlug;
+  }
+
+  // Strategy 3: a server-rendered JSON context block. The admin's
+  // plugin loader writes one of these to the page right before
+  // mounting the plugin's frontend bundle (see
+  // `apps/web/src/components/plugin-frontend-host`). Reading it does
+  // not require Trusted Types because we only inspect `textContent`.
+  const ctxSlug = detectSlugFromContextElement();
+  if (ctxSlug !== null) {
+    return ctxSlug;
+  }
+
+  // Strategy 4: explicit global. Dev / test escape hatch.
+  const globalSlug = detectSlugFromGlobal();
+  if (globalSlug !== null) {
+    return globalSlug;
+  }
+
+  return null;
+}
+
+/**
+ * Returns `import.meta.url` when this module was loaded as an ES
+ * module, or `null` in the CJS / pre-ESM path. We read via the
+ * indirected `getMetaURL` so the CJS build (which does not have
+ * `import.meta`) does not fail to transpile.
+ */
+function readImportMetaURL(): string | null {
+  try {
+    // The CJS bundle replaces `import.meta` with a polyfill object;
+    // the ESM bundle keeps the native one. Both shapes are safe to
+    // read.
+    const meta = (globalThis as { __gnSdkMeta?: { url?: string } }).__gnSdkMeta;
+    if (meta && typeof meta.url === 'string') {
+      return meta.url;
+    }
+  } catch {
+    // fall through
+  }
+  // The real ESM build emits `import.meta.url` directly; tsup keeps
+  // the syntax in the .mjs output. We use a `Function` constructor
+  // trick to avoid a parse error in environments that do not support
+  // `import.meta` (e.g. the CJS test path running through Node's
+  // require chain).
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-implied-eval, no-new-func
+    const get = new Function('try { return import.meta.url; } catch { return null; }');
+    const v = (get as () => unknown)();
+    if (typeof v === 'string') {
+      return v;
+    }
+  } catch {
+    // fall through
+  }
+  return null;
+}
+
+/**
+ * Scans `document.scripts` for one whose `src` matches the
+ * /api/plugins/<slug>/web/ pattern. Returns the first slug found, or
+ * `null`. We take the FIRST because the admin mounts plugin bundles
+ * one at a time and a second match would imply two plugins on one
+ * page — at which point per-call slug overrides are the right
+ * answer, not auto-detection.
+ */
+function detectSlugFromScripts(): string | null {
+  if (typeof document === 'undefined') {
+    return null;
+  }
+  const scripts = document.getElementsByTagName('script');
+  for (let i = 0; i < scripts.length; i++) {
+    const s = scripts[i];
+    if (!s) continue;
+    const src = s.src;
+    if (typeof src !== 'string' || src === '') continue;
+    const match = PLUGIN_URL_PATTERN.exec(src);
+    if (match && typeof match[1] === 'string' && SLUG_PATTERN.test(match[1])) {
+      return match[1];
+    }
+  }
+  return null;
+}
+
+/**
+ * Reads the JSON context block. The admin writes the slug under
+ * `slug` so this stays robust against the block growing other
+ * fields. A malformed JSON body returns `null` rather than throwing
+ * so SDK init never breaks on a stale element.
+ */
+function detectSlugFromContextElement(): string | null {
+  if (typeof document === 'undefined') {
+    return null;
+  }
+  const el = document.getElementById('gn-plugin-context');
+  if (el === null) {
+    return null;
+  }
+  const text = el.textContent;
+  if (text === null || text === '') {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(text) as { slug?: unknown };
+    if (typeof parsed.slug === 'string' && SLUG_PATTERN.test(parsed.slug)) {
+      return parsed.slug;
+    }
+  } catch {
+    // fall through
+  }
+  return null;
+}
+
+/**
+ * Reads the `window.__GN_PLUGIN_SLUG__` global. Validates against
+ * the slug pattern so an attacker who manages to set a window
+ * property cannot redirect the SDK at routes outside the plugin
+ * namespace.
+ */
+function detectSlugFromGlobal(): string | null {
+  const g = globalThis as { __GN_PLUGIN_SLUG__?: unknown };
+  const raw = g.__GN_PLUGIN_SLUG__;
+  if (typeof raw === 'string' && SLUG_PATTERN.test(raw)) {
+    return raw;
+  }
+  return null;
+}
diff --git a/packages/ts/sdk/src/trusted-types.test.ts b/packages/ts/sdk/src/trusted-types.test.ts
new file mode 100644
index 00000000..7f83d94d
--- /dev/null
+++ b/packages/ts/sdk/src/trusted-types.test.ts
@@ -0,0 +1,122 @@
+/**
+ * Trusted-Types compatibility smoke test.
+ *
+ * jsdom does not implement the Trusted Types API natively, so we
+ * stand up a small fake `window.trustedTypes` that mimics the
+ * `createPolicy` shape. The test verifies:
+ *
+ *   - The SDK calls `createPolicy('gn-plugin', …)` exactly once
+ *     (cache works).
+ *
+ *   - `setHTML(el, html)` routes through the policy's `createHTML`
+ *     hook before assigning to `innerHTML`.
+ *
+ *   - When the global is absent, `setHTML` still works (identity
+ *     fallback path).
+ *
+ *   - When `createPolicy` THROWS (e.g. CSP refuses a duplicate
+ *     registration), `setHTML` still works by falling through to
+ *     the identity shim.
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import {
+  __resetPolicyCache,
+  getTrustedTypesPolicy,
+  setHTML,
+} from './trusted-types';
+
+type RulesShape = { createHTML?: (input: string) => string };
+
+let createPolicySpy: ReturnType<typeof vi.fn>;
+let createHTMLSpy: ReturnType<typeof vi.fn>;
+
+beforeEach(() => {
+  __resetPolicyCache();
+  createHTMLSpy = vi.fn();
+  createHTMLSpy.mockImplementation((input: unknown) => `TRUSTED:${String(input)}`);
+  createPolicySpy = vi.fn();
+  createPolicySpy.mockImplementation((name: unknown, rules: unknown) => {
+    expect(name).toBe('gn-plugin');
+    // The SDK passes its own createHTML hook through. We ignore it
+    // in the fake (the test cares about the OUTPUT, which is the
+    // string the SDK's hook returns); we exercise OUR createHTMLSpy
+    // by returning a different policy that the SDK then uses.
+    void (rules as RulesShape);
+    return { createHTML: createHTMLSpy };
+  });
+  // Install the fake on the global.
+  (globalThis as { trustedTypes?: unknown }).trustedTypes = {
+    createPolicy: createPolicySpy,
+  };
+});
+
+afterEach(() => {
+  delete (globalThis as { trustedTypes?: unknown }).trustedTypes;
+  __resetPolicyCache();
+});
+
+describe('setHTML with a trustedTypes factory installed', () => {
+  it('routes through createHTML before assigning innerHTML', () => {
+    const el = document.createElement('div');
+    setHTML(el, '<span>hi</span>');
+    expect(createPolicySpy).toHaveBeenCalledTimes(1);
+    expect(createHTMLSpy).toHaveBeenCalledWith('<span>hi</span>');
+    // The fake policy prefixes the input with `TRUSTED:`. The browser
+    // then parses the result as HTML, so the trailing markup is real
+    // elements and the leading prefix is text. We assert the parsed
+    // shape rather than a fragile innerHTML serialization round-trip.
+    expect(el.firstChild?.textContent).toBe('TRUSTED:');
+    expect(el.querySelector('span')?.textContent).toBe('hi');
+  });
+
+  it('memoizes the policy across calls', () => {
+    const el = document.createElement('div');
+    setHTML(el, '<a>1</a>');
+    setHTML(el, '<a>2</a>');
+    expect(createPolicySpy).toHaveBeenCalledTimes(1);
+    expect(createHTMLSpy).toHaveBeenCalledTimes(2);
+  });
+
+  it('exposes the policy via getTrustedTypesPolicy', () => {
+    const policy = getTrustedTypesPolicy();
+    expect(policy.createHTML('hi')).toBe('TRUSTED:hi');
+  });
+});
+
+describe('setHTML with no trustedTypes factory', () => {
+  beforeEach(() => {
+    delete (globalThis as { trustedTypes?: unknown }).trustedTypes;
+    __resetPolicyCache();
+  });
+
+  it('falls back to identity assignment (works in SSR / dev)', () => {
+    const el = document.createElement('div');
+    setHTML(el, '<b>x</b>');
+    expect(el.innerHTML).toBe('<b>x</b>');
+  });
+});
+
+describe('setHTML when createPolicy throws', () => {
+  it('falls back to the identity shim', () => {
+    const failingSpy = vi.fn(() => {
+      throw new Error('CSP refused');
+    });
+    (globalThis as { trustedTypes?: unknown }).trustedTypes = {
+      createPolicy: failingSpy,
+    };
+    __resetPolicyCache();
+    const el = document.createElement('div');
+    setHTML(el, '<i>safe</i>');
+    expect(failingSpy).toHaveBeenCalledTimes(1);
+    expect(el.innerHTML).toBe('<i>safe</i>');
+  });
+});
+
+describe('getTrustedTypesPolicy', () => {
+  it('returns a workable policy even when no global is present', () => {
+    delete (globalThis as { trustedTypes?: unknown }).trustedTypes;
+    __resetPolicyCache();
+    const policy = getTrustedTypesPolicy();
+    expect(policy.createHTML('hello')).toBe('hello');
+  });
+});
diff --git a/packages/ts/sdk/src/trusted-types.ts b/packages/ts/sdk/src/trusted-types.ts
new file mode 100644
index 00000000..173bbd1a
--- /dev/null
+++ b/packages/ts/sdk/src/trusted-types.ts
@@ -0,0 +1,195 @@
+/**
+ * Trusted-Types compatibility shim for the @gonext/sdk runtime.
+ *
+ * The admin opts into `require-trusted-types-for 'script'` CSP (see
+ * packages/go/middleware/csp/trusted_types.go); every assignment to
+ * an injection sink — `innerHTML`, `outerHTML`, `script.src`,
+ * `document.write` — throws unless the value passed in was minted by
+ * a registered policy.
+ *
+ * @gonext/plugin-frontend-host owns the `gn-plugin` policy used by
+ * plugin browser code. The SDK does NOT install its own policy:
+ *
+ *   - In production the host has already installed `gn-plugin`
+ *     before any plugin module evaluates, so we re-use whatever is
+ *     visible on `window.trustedTypes.defaultPolicy` / the named
+ *     policy lookup.
+ *
+ *   - On the server (SSR) and in dev where Trusted Types is not
+ *     enforced, we fall back to a pass-through shim that mirrors the
+ *     same interface. This means `setHTML(el, str)` is a single
+ *     call site that works in every environment — no `if (TT)` in
+ *     plugin code.
+ *
+ * Why we don't import `@gonext/plugin-frontend-host` directly:
+ * (1) keeps the SDK zero-dep, so its SRI hash is stable; (2) avoids
+ * a circular dependency once the host package starts importing the
+ * SDK back for type-only contracts; (3) plugins authored against an
+ * older SDK still get TT-safe behaviour against a newer host policy.
+ */
+
+/**
+ * Canonical policy name. Mirrors the constant in
+ * `@gonext/plugin-frontend-host/trusted-types`. Hard-coded here
+ * because we want zero runtime dependencies — the wire-level name is
+ * a published contract anyway.
+ */
+const GN_PLUGIN_POLICY_NAME = 'gn-plugin';
+
+/**
+ * Subset of the Trusted Types policy interface this module needs.
+ * Declared inline so the SDK does not depend on the `trusted-types`
+ * types package or a `lib.dom` revision a consumer hasn't pinned.
+ */
+interface TTPolicy {
+  createHTML(input: string): string;
+}
+
+interface TTFactory {
+  createPolicy(name: string, rules: { createHTML?: (input: string) => string }): TTPolicy;
+}
+
+/**
+ * Cached policy reference. Memoized so consecutive `setHTML` calls
+ * do not re-walk the `trustedTypes` factory.
+ */
+let cachedPolicy: TTPolicy | null = null;
+
+/**
+ * Resolves the policy. In order:
+ *
+ *   1. `window.trustedTypes.policies` (Chromium-style) — read the
+ *      already-installed `gn-plugin` if the platform exposes a
+ *      lookup. Spec'd browsers do not actually expose a `policies`
+ *      map; this branch is a defensive fallback for hardened
+ *      embedders that patch one in.
+ *
+ *   2. `window.trustedTypes.createPolicy('gn-plugin', …)` with the
+ *      `allow-duplicates` keyword — the spec allows a second
+ *      `createPolicy` call iff the CSP grants it. The host CSP DOES
+ *      grant it (see `csp/trusted_types.go`) precisely so SDK
+ *      consumers can keep a local handle.
+ *
+ *   3. The pass-through shim: a plain object whose `createHTML` is
+ *      identity. Used in SSR, tests, and dev where TT is not
+ *      enforced.
+ */
+function getPolicy(): TTPolicy {
+  if (cachedPolicy !== null) {
+    return cachedPolicy;
+  }
+  const factory = readTTFactory();
+  if (factory !== null) {
+    // Defensive lookup. Some hardened embedders expose `policies` as
+    // a Map<string, TrustedTypePolicy>.
+    const policiesProp = (
+      factory as unknown as {
+        policies?: { get?: (name: string) => TTPolicy | undefined };
+      }
+    ).policies;
+    if (policiesProp && typeof policiesProp.get === 'function') {
+      const found = policiesProp.get(GN_PLUGIN_POLICY_NAME);
+      if (found !== undefined) {
+        cachedPolicy = found;
+        return cachedPolicy;
+      }
+    }
+    try {
+      cachedPolicy = factory.createPolicy(GN_PLUGIN_POLICY_NAME, {
+        createHTML(input) {
+          return input;
+        },
+      });
+      return cachedPolicy;
+    } catch {
+      // Browser refused — most likely because the policy already
+      // exists and the CSP did not grant 'allow-duplicates'. Fall
+      // through to the shim. The browser will dispatch through the
+      // EXISTING policy when the SDK assigns innerHTML with our
+      // shim's output (which is just a string the browser then
+      // routes through whichever policy is registered).
+    }
+  }
+  cachedPolicy = identityShim();
+  return cachedPolicy;
+}
+
+/**
+ * Test-only escape hatch. Resets the module-scoped cache so a test
+ * can swap the global `trustedTypes` factory between cases.
+ */
+export function __resetPolicyCache(): void {
+  cachedPolicy = null;
+}
+
+/**
+ * Reads `window.trustedTypes` defensively. Returns `null` outside
+ * the browser or when the policy API is not implemented (older
+ * Safari, jsdom without a fake).
+ */
+function readTTFactory(): TTFactory | null {
+  if (typeof globalThis === 'undefined') {
+    return null;
+  }
+  const win = globalThis as { trustedTypes?: unknown };
+  const factory = win.trustedTypes;
+  if (factory === undefined || factory === null) {
+    return null;
+  }
+  if (typeof (factory as { createPolicy?: unknown }).createPolicy !== 'function') {
+    return null;
+  }
+  return factory as TTFactory;
+}
+
+/**
+ * Returns an identity shim. Used in SSR / dev / non-TT environments.
+ * The shim is intentionally minimal — adding sanitization here would
+ * duplicate the host policy's behaviour and drift over time. The
+ * SDK's contract is "pass strings through the gn-plugin policy when
+ * it exists, otherwise just route them"; defense in depth lives in
+ * the host package, not here.
+ */
+function identityShim(): TTPolicy {
+  return {
+    createHTML(input) {
+      return input;
+    },
+  };
+}
+
+/**
+ * Trusted-Types-safe `innerHTML` setter for plugin code.
+ *
+ * Plugin authors call `setHTML(el, '<p>safe markup</p>')` instead of
+ * `el.innerHTML = '<p>…</p>'`. The string is routed through the
+ * `gn-plugin` policy when one exists, so the assignment satisfies
+ * the CSP `require-trusted-types-for 'script'` directive even on a
+ * locked-down admin page.
+ *
+ * In environments without Trusted Types enforcement the call is a
+ * plain `innerHTML = html`. The result is observable as the same
+ * markup either way.
+ */
+export function setHTML(target: Element, html: string): void {
+  const policy = getPolicy();
+  const trusted = policy.createHTML(html);
+  // The `as unknown as string` keeps the assignment type-correct
+  // regardless of whether the runtime returns a TrustedHTML (tagged
+  // string subtype in browsers that implement TT) or a plain string
+  // (SSR / shim).
+  target.innerHTML = trusted as unknown as string;
+}
+
+/**
+ * Returns the resolved policy. Exposed so block components or
+ * advanced consumers can mint a TrustedHTML for sinks the SDK does
+ * not directly wrap (e.g. assigning to a `srcdoc` iframe attribute).
+ *
+ * The return type is a structural interface, NOT the DOM's
+ * `TrustedTypePolicy` — that lets the SDK keep its `lib.dom`
+ * portability promise.
+ */
+export function getTrustedTypesPolicy(): TTPolicy {
+  return getPolicy();
+}
diff --git a/packages/ts/sdk/tsconfig.json b/packages/ts/sdk/tsconfig.json
new file mode 100644
index 00000000..6ca82cb7
--- /dev/null
+++ b/packages/ts/sdk/tsconfig.json
@@ -0,0 +1,28 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "allowImportingTsExtensions": true,
+    "strict": true,
+    "noImplicitAny": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "noEmit": true,
+    "types": ["vitest/globals"]
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist", "coverage"]
+}
diff --git a/packages/ts/sdk/tsup.config.ts b/packages/ts/sdk/tsup.config.ts
new file mode 100644
index 00000000..cbcade2e
--- /dev/null
+++ b/packages/ts/sdk/tsup.config.ts
@@ -0,0 +1,53 @@
+/**
+ * tsup build configuration for @gonext/sdk.
+ *
+ * Outputs three artifacts under ./dist:
+ *
+ *   - index.mjs  — ESM. This is the canonical bundle the admin's
+ *                  import map points at (`/_/runtime/sdk.mjs`). It is
+ *                  what plugin browser code actually resolves to when
+ *                  it writes `import { host } from '@gonext/sdk'`.
+ *
+ *   - index.cjs  — CJS. Test harnesses, Node-based codemods, and the
+ *                  occasional plugin SSR step want a `require()`-able
+ *                  form. Same source, different module emit.
+ *
+ *   - index.d.ts — Single rolled-up type declaration. Plugin authors
+ *                  get full IntelliSense without us shipping every
+ *                  internal `.d.ts` to npm.
+ *
+ * `clean: true` deletes ./dist on every build so stale outputs from a
+ * removed entry point never leak through. `sourcemap: true` keeps the
+ * SDK debuggable in the user's browser — the package is small enough
+ * that the extra bytes are worth the developer experience.
+ *
+ * `treeshake: true` + `splitting: false` keeps the ESM output a single
+ * file. The import map references one URL; splitting would force the
+ * host to learn about chunk filenames.
+ *
+ * No external dependencies — the SDK is intentionally zero-dep so it
+ * can be served with a fixed SRI hash that does not drift when an
+ * upstream patch lands. If a future feature pulls in a runtime dep,
+ * mark it `external` here and add it to the host's import-map
+ * allowlist (packages/ts/plugin-frontend-host/src/import-map.ts).
+ */
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: { index: 'src/index.ts' },
+  format: ['esm', 'cjs'],
+  outExtension({ format }) {
+    return { js: format === 'esm' ? '.mjs' : '.cjs' };
+  },
+  dts: true,
+  clean: true,
+  sourcemap: true,
+  treeshake: true,
+  splitting: false,
+  target: 'es2022',
+  platform: 'neutral',
+  // Empty external array is on purpose — the SDK has zero runtime deps
+  // and we want every helper folded into the single emitted bundle so
+  // the import-map URL resolves to one self-contained module.
+  external: [],
+});
diff --git a/packages/ts/sdk/vitest.config.ts b/packages/ts/sdk/vitest.config.ts
new file mode 100644
index 00000000..bd1288c0
--- /dev/null
+++ b/packages/ts/sdk/vitest.config.ts
@@ -0,0 +1,33 @@
+/**
+ * Vitest configuration for @gonext/sdk.
+ *
+ * Extends the shared base from `@gonext/test-config`. We run on
+ * jsdom because the SDK exercises `document`, `fetch`, and a
+ * fake `trustedTypes` shim in unit tests — a Node-only env would
+ * fail any test that touches the DOM-side branches.
+ *
+ * Coverage thresholds are set to 80% line / 80% branch. The SDK
+ * is the API contract every plugin in the ecosystem depends on;
+ * lower coverage here translates directly into breakages plugin
+ * authors will struggle to debug.
+ */
+import { defineConfig, mergeConfig } from 'vitest/config';
+import { baseConfig } from '@gonext/test-config';
+
+export default mergeConfig(
+  baseConfig,
+  defineConfig({
+    test: {
+      setupFiles: ['./vitest.setup.ts'],
+      include: ['src/**/*.{test,spec}.ts'],
+      coverage: {
+        thresholds: {
+          lines: 80,
+          functions: 80,
+          branches: 80,
+          statements: 80,
+        },
+      },
+    },
+  }),
+);
diff --git a/packages/ts/sdk/vitest.setup.ts b/packages/ts/sdk/vitest.setup.ts
new file mode 100644
index 00000000..fa1c4f55
--- /dev/null
+++ b/packages/ts/sdk/vitest.setup.ts
@@ -0,0 +1,12 @@
+/**
+ * Vitest setup for @gonext/sdk.
+ *
+ * Re-exports the shared setup module from @gonext/test-config:
+ * jest-dom-style matchers (the SDK doesn't ship React but the
+ * matchers are harmless), the loud-fetch stub (so any test that
+ * forgets to mock fetch fails noisily), and per-test cleanup.
+ *
+ * Individual tests opt into a real `fetch` mock by setting
+ * `globalThis.fetch = vi.fn(...)` in their own `beforeEach`.
+ */
+import '@gonext/test-config/setup';
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index d36d459d..294a7421 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -552,7 +552,26 @@ importers:
         specifier: ^1.6.0
         version: 1.6.1(@types/node@22.19.19)(jsdom@24.1.3)
 
-  packages/ts/sdk: {}
+  packages/ts/sdk:
+    devDependencies:
+      '@gonext/test-config':
+        specifier: workspace:*
+        version: link:../test-config
+      '@vitest/coverage-v8':
+        specifier: ^1.6.0
+        version: 1.6.1(vitest@1.6.1(@types/node@22.19.19)(jsdom@24.1.3))
+      jsdom:
+        specifier: ^24.0.0
+        version: 24.1.3
+      tsup:
+        specifier: ^8.3.0
+        version: 8.5.1(jiti@1.21.7)(postcss@8.5.14)(tsx@4.22.2)(typescript@5.9.3)
+      typescript:
+        specifier: ^5.6.0
+        version: 5.9.3
+      vitest:
+        specifier: ^1.6.0
+        version: 1.6.1(@types/node@22.19.19)(jsdom@24.1.3)
 
   packages/ts/test-config:
     devDependencies:
@@ -761,6 +780,12 @@ packages:
     cpu: [ppc64]
     os: [aix]
 
+  '@esbuild/aix-ppc64@0.27.7':
+    resolution: {integrity: sha512-EKX3Qwmhz1eMdEJokhALr0YiD0lhQNwDqkPYyPhiSwKrh7/4KRjQc04sZ8db+5DVVnZ1LmbNDI1uAMPEUBnQPg==}
+    engines: {node: '>=18'}
+    cpu: [ppc64]
+    os: [aix]
+
   '@esbuild/aix-ppc64@0.28.0':
     resolution: {integrity: sha512-lhRUCeuOyJQURhTxl4WkpFTjIsbDayJHih5kZC1giwE+MhIzAb7mEsQMqMf18rHLsrb5qI1tafG20mLxEWcWlA==}
     engines: {node: '>=18'}
@@ -773,6 +798,12 @@ packages:
     cpu: [arm64]
     os: [android]
 
+  '@esbuild/android-arm64@0.27.7':
+    resolution: {integrity: sha512-62dPZHpIXzvChfvfLJow3q5dDtiNMkwiRzPylSCfriLvZeq0a1bWChrGx/BbUbPwOrsWKMn8idSllklzBy+dgQ==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [android]
+
   '@esbuild/android-arm64@0.28.0':
     resolution: {integrity: sha512-+WzIXQOSaGs33tLEgYPYe/yQHf0WTU0X42Jca3y8NWMbUVhp7rUnw+vAsRC/QiDrdD31IszMrZy+qwPOPjd+rw==}
     engines: {node: '>=18'}
@@ -785,6 +816,12 @@ packages:
     cpu: [arm]
     os: [android]
 
+  '@esbuild/android-arm@0.27.7':
+    resolution: {integrity: sha512-jbPXvB4Yj2yBV7HUfE2KHe4GJX51QplCN1pGbYjvsyCZbQmies29EoJbkEc+vYuU5o45AfQn37vZlyXy4YJ8RQ==}
+    engines: {node: '>=18'}
+    cpu: [arm]
+    os: [android]
+
   '@esbuild/android-arm@0.28.0':
     resolution: {integrity: sha512-wqh0ByljabXLKHeWXYLqoJ5jKC4XBaw6Hk08OfMrCRd2nP2ZQ5eleDZC41XHyCNgktBGYMbqnrJKq/K/lzPMSQ==}
     engines: {node: '>=18'}
@@ -797,6 +834,12 @@ packages:
     cpu: [x64]
     os: [android]
 
+  '@esbuild/android-x64@0.27.7':
+    resolution: {integrity: sha512-x5VpMODneVDb70PYV2VQOmIUUiBtY3D3mPBG8NxVk5CogneYhkR7MmM3yR/uMdITLrC1ml/NV1rj4bMJuy9MCg==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [android]
+
   '@esbuild/android-x64@0.28.0':
     resolution: {integrity: sha512-+VJggoaKhk2VNNqVL7f6S189UzShHC/mR9EE8rDdSkdpN0KflSwWY/gWjDrNxxisg8Fp1ZCD9jLMo4m0OUfeUA==}
     engines: {node: '>=18'}
@@ -809,6 +852,12 @@ packages:
     cpu: [arm64]
     os: [darwin]
 
+  '@esbuild/darwin-arm64@0.27.7':
+    resolution: {integrity: sha512-5lckdqeuBPlKUwvoCXIgI2D9/ABmPq3Rdp7IfL70393YgaASt7tbju3Ac+ePVi3KDH6N2RqePfHnXkaDtY9fkw==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [darwin]
+
   '@esbuild/darwin-arm64@0.28.0':
     resolution: {integrity: sha512-0T+A9WZm+bZ84nZBtk1ckYsOvyA3x7e2Acj1KdVfV4/2tdG4fzUp91YHx+GArWLtwqp77pBXVCPn2We7Letr0Q==}
     engines: {node: '>=18'}
@@ -821,6 +870,12 @@ packages:
     cpu: [x64]
     os: [darwin]
 
+  '@esbuild/darwin-x64@0.27.7':
+    resolution: {integrity: sha512-rYnXrKcXuT7Z+WL5K980jVFdvVKhCHhUwid+dDYQpH+qu+TefcomiMAJpIiC2EM3Rjtq0sO3StMV/+3w3MyyqQ==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [darwin]
+
   '@esbuild/darwin-x64@0.28.0':
     resolution: {integrity: sha512-fyzLm/DLDl/84OCfp2f/XQ4flmORsjU7VKt8HLjvIXChJoFFOIL6pLJPH4Yhd1n1gGFF9mPwtlN5Wf82DZs+LQ==}
     engines: {node: '>=18'}
@@ -833,6 +888,12 @@ packages:
     cpu: [arm64]
     os: [freebsd]
 
+  '@esbuild/freebsd-arm64@0.27.7':
+    resolution: {integrity: sha512-B48PqeCsEgOtzME2GbNM2roU29AMTuOIN91dsMO30t+Ydis3z/3Ngoj5hhnsOSSwNzS+6JppqWsuhTp6E82l2w==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [freebsd]
+
   '@esbuild/freebsd-arm64@0.28.0':
     resolution: {integrity: sha512-l9GeW5UZBT9k9brBYI+0WDffcRxgHQD8ShN2Ur4xWq/NFzUKm3k5lsH4PdaRgb2w7mI9u61nr2gI2mLI27Nh3Q==}
     engines: {node: '>=18'}
@@ -845,6 +906,12 @@ packages:
     cpu: [x64]
     os: [freebsd]
 
+  '@esbuild/freebsd-x64@0.27.7':
+    resolution: {integrity: sha512-jOBDK5XEjA4m5IJK3bpAQF9/Lelu/Z9ZcdhTRLf4cajlB+8VEhFFRjWgfy3M1O4rO2GQ/b2dLwCUGpiF/eATNQ==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [freebsd]
+
   '@esbuild/freebsd-x64@0.28.0':
     resolution: {integrity: sha512-BXoQai/A0wPO6Es3yFJ7APCiKGc1tdAEOgeTNy3SsB491S3aHn4S4r3e976eUnPdU+NbdtmBuLncYir2tMU9Nw==}
     engines: {node: '>=18'}
@@ -857,6 +924,12 @@ packages:
     cpu: [arm64]
     os: [linux]
 
+  '@esbuild/linux-arm64@0.27.7':
+    resolution: {integrity: sha512-RZPHBoxXuNnPQO9rvjh5jdkRmVizktkT7TCDkDmQ0W2SwHInKCAV95GRuvdSvA7w4VMwfCjUiPwDi0ZO6Nfe9A==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [linux]
+
   '@esbuild/linux-arm64@0.28.0':
     resolution: {integrity: sha512-RVyzfb3FWsGA55n6WY0MEIEPURL1FcbhFE6BffZEMEekfCzCIMtB5yyDcFnVbTnwk+CLAgTujmV/Lgvih56W+A==}
     engines: {node: '>=18'}
@@ -869,6 +942,12 @@ packages:
     cpu: [arm]
     os: [linux]
 
+  '@esbuild/linux-arm@0.27.7':
+    resolution: {integrity: sha512-RkT/YXYBTSULo3+af8Ib0ykH8u2MBh57o7q/DAs3lTJlyVQkgQvlrPTnjIzzRPQyavxtPtfg0EopvDyIt0j1rA==}
+    engines: {node: '>=18'}
+    cpu: [arm]
+    os: [linux]
+
   '@esbuild/linux-arm@0.28.0':
     resolution: {integrity: sha512-CjaaREJagqJp7iTaNQjjidaNbCKYcd4IDkzbwwxtSvjI7NZm79qiHc8HqciMddQ6CKvJT6aBd8lO9kN/ZudLlw==}
     engines: {node: '>=18'}
@@ -881,6 +960,12 @@ packages:
     cpu: [ia32]
     os: [linux]
 
+  '@esbuild/linux-ia32@0.27.7':
+    resolution: {integrity: sha512-GA48aKNkyQDbd3KtkplYWT102C5sn/EZTY4XROkxONgruHPU72l+gW+FfF8tf2cFjeHaRbWpOYa/uRBz/Xq1Pg==}
+    engines: {node: '>=18'}
+    cpu: [ia32]
+    os: [linux]
+
   '@esbuild/linux-ia32@0.28.0':
     resolution: {integrity: sha512-KBnSTt1kxl9x70q+ydterVdl+Cn0H18ngRMRCEQfrbqdUuntQQ0LoMZv47uB97NljZFzY6HcfqEZ2SAyIUTQBQ==}
     engines: {node: '>=18'}
@@ -893,6 +978,12 @@ packages:
     cpu: [loong64]
     os: [linux]
 
+  '@esbuild/linux-loong64@0.27.7':
+    resolution: {integrity: sha512-a4POruNM2oWsD4WKvBSEKGIiWQF8fZOAsycHOt6JBpZ+JN2n2JH9WAv56SOyu9X5IqAjqSIPTaJkqN8F7XOQ5Q==}
+    engines: {node: '>=18'}
+    cpu: [loong64]
+    os: [linux]
+
   '@esbuild/linux-loong64@0.28.0':
     resolution: {integrity: sha512-zpSlUce1mnxzgBADvxKXX5sl8aYQHo2ezvMNI8I0lbblJtp8V4odlm3Yzlj7gPyt3T8ReksE6bK+pT3WD+aJRg==}
     engines: {node: '>=18'}
@@ -905,6 +996,12 @@ packages:
     cpu: [mips64el]
     os: [linux]
 
+  '@esbuild/linux-mips64el@0.27.7':
+    resolution: {integrity: sha512-KabT5I6StirGfIz0FMgl1I+R1H73Gp0ofL9A3nG3i/cYFJzKHhouBV5VWK1CSgKvVaG4q1RNpCTR2LuTVB3fIw==}
+    engines: {node: '>=18'}
+    cpu: [mips64el]
+    os: [linux]
+
   '@esbuild/linux-mips64el@0.28.0':
     resolution: {integrity: sha512-2jIfP6mmjkdmeTlsX/9vmdmhBmKADrWqN7zcdtHIeNSCH1SqIoNI63cYsjQR8J+wGa4Y5izRcSHSm8K3QWmk3w==}
     engines: {node: '>=18'}
@@ -917,6 +1014,12 @@ packages:
     cpu: [ppc64]
     os: [linux]
 
+  '@esbuild/linux-ppc64@0.27.7':
+    resolution: {integrity: sha512-gRsL4x6wsGHGRqhtI+ifpN/vpOFTQtnbsupUF5R5YTAg+y/lKelYR1hXbnBdzDjGbMYjVJLJTd2OFmMewAgwlQ==}
+    engines: {node: '>=18'}
+    cpu: [ppc64]
+    os: [linux]
+
   '@esbuild/linux-ppc64@0.28.0':
     resolution: {integrity: sha512-bc0FE9wWeC0WBm49IQMPSPILRocGTQt3j5KPCA8os6VprfuJ7KD+5PzESSrJ6GmPIPJK965ZJHTUlSA6GNYEhg==}
     engines: {node: '>=18'}
@@ -929,6 +1032,12 @@ packages:
     cpu: [riscv64]
     os: [linux]
 
+  '@esbuild/linux-riscv64@0.27.7':
+    resolution: {integrity: sha512-hL25LbxO1QOngGzu2U5xeXtxXcW+/GvMN3ejANqXkxZ/opySAZMrc+9LY/WyjAan41unrR3YrmtTsUpwT66InQ==}
+    engines: {node: '>=18'}
+    cpu: [riscv64]
+    os: [linux]
+
   '@esbuild/linux-riscv64@0.28.0':
     resolution: {integrity: sha512-SQPZOwoTTT/HXFXQJG/vBX8sOFagGqvZyXcgLA3NhIqcBv1BJU1d46c0rGcrij2B56Z2rNiSLaZOYW5cUk7yLQ==}
     engines: {node: '>=18'}
@@ -941,6 +1050,12 @@ packages:
     cpu: [s390x]
     os: [linux]
 
+  '@esbuild/linux-s390x@0.27.7':
+    resolution: {integrity: sha512-2k8go8Ycu1Kb46vEelhu1vqEP+UeRVj2zY1pSuPdgvbd5ykAw82Lrro28vXUrRmzEsUV0NzCf54yARIK8r0fdw==}
+    engines: {node: '>=18'}
+    cpu: [s390x]
+    os: [linux]
+
   '@esbuild/linux-s390x@0.28.0':
     resolution: {integrity: sha512-SCfR0HN8CEEjnYnySJTd2cw0k9OHB/YFzt5zgJEwa+wL/T/raGWYMBqwDNAC6dqFKmJYZoQBRfHjgwLHGSrn3Q==}
     engines: {node: '>=18'}
@@ -953,12 +1068,24 @@ packages:
     cpu: [x64]
     os: [linux]
 
+  '@esbuild/linux-x64@0.27.7':
+    resolution: {integrity: sha512-hzznmADPt+OmsYzw1EE33ccA+HPdIqiCRq7cQeL1Jlq2gb1+OyWBkMCrYGBJ+sxVzve2ZJEVeePbLM2iEIZSxA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [linux]
+
   '@esbuild/linux-x64@0.28.0':
     resolution: {integrity: sha512-us0dSb9iFxIi8srnpl931Nvs65it/Jd2a2K3qs7fz2WfGPHqzfzZTfec7oxZJRNPXPnNYZtanmRc4AL/JwVzHQ==}
     engines: {node: '>=18'}
     cpu: [x64]
     os: [linux]
 
+  '@esbuild/netbsd-arm64@0.27.7':
+    resolution: {integrity: sha512-b6pqtrQdigZBwZxAn1UpazEisvwaIDvdbMbmrly7cDTMFnw/+3lVxxCTGOrkPVnsYIosJJXAsILG9XcQS+Yu6w==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [netbsd]
+
   '@esbuild/netbsd-arm64@0.28.0':
     resolution: {integrity: sha512-CR/RYotgtCKwtftMwJlUU7xCVNg3lMYZ0RzTmAHSfLCXw3NtZtNpswLEj/Kkf6kEL3Gw+BpOekRX0BYCtklhUw==}
     engines: {node: '>=18'}
@@ -971,12 +1098,24 @@ packages:
     cpu: [x64]
     os: [netbsd]
 
+  '@esbuild/netbsd-x64@0.27.7':
+    resolution: {integrity: sha512-OfatkLojr6U+WN5EDYuoQhtM+1xco+/6FSzJJnuWiUw5eVcicbyK3dq5EeV/QHT1uy6GoDhGbFpprUiHUYggrw==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [netbsd]
+
   '@esbuild/netbsd-x64@0.28.0':
     resolution: {integrity: sha512-nU1yhmYutL+fQ71Kxnhg8uEOdC0pwEW9entHykTgEbna2pw2dkbFSMeqjjyHZoCmt8SBkOSvV+yNmm94aUrrqw==}
     engines: {node: '>=18'}
     cpu: [x64]
     os: [netbsd]
 
+  '@esbuild/openbsd-arm64@0.27.7':
+    resolution: {integrity: sha512-AFuojMQTxAz75Fo8idVcqoQWEHIXFRbOc1TrVcFSgCZtQfSdc1RXgB3tjOn/krRHENUB4j00bfGjyl2mJrU37A==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [openbsd]
+
   '@esbuild/openbsd-arm64@0.28.0':
     resolution: {integrity: sha512-cXb5vApOsRsxsEl4mcZ1XY3D4DzcoMxR/nnc4IyqYs0rTI8ZKmW6kyyg+11Z8yvgMfAEldKzP7AdP64HnSC/6g==}
     engines: {node: '>=18'}
@@ -989,12 +1128,24 @@ packages:
     cpu: [x64]
     os: [openbsd]
 
+  '@esbuild/openbsd-x64@0.27.7':
+    resolution: {integrity: sha512-+A1NJmfM8WNDv5CLVQYJ5PshuRm/4cI6WMZRg1by1GwPIQPCTs1GLEUHwiiQGT5zDdyLiRM/l1G0Pv54gvtKIg==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [openbsd]
+
   '@esbuild/openbsd-x64@0.28.0':
     resolution: {integrity: sha512-8wZM2qqtv9UP3mzy7HiGYNH/zjTA355mpeuA+859TyR+e+Tc08IHYpLJuMsfpDJwoLo1ikIJI8jC3GFjnRClzA==}
     engines: {node: '>=18'}
     cpu: [x64]
     os: [openbsd]
 
+  '@esbuild/openharmony-arm64@0.27.7':
+    resolution: {integrity: sha512-+KrvYb/C8zA9CU/g0sR6w2RBw7IGc5J2BPnc3dYc5VJxHCSF1yNMxTV5LQ7GuKteQXZtspjFbiuW5/dOj7H4Yw==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [openharmony]
+
   '@esbuild/openharmony-arm64@0.28.0':
     resolution: {integrity: sha512-FLGfyizszcef5C3YtoyQDACyg95+dndv79i2EekILBofh5wpCa1KuBqOWKrEHZg3zrL3t5ouE5jgr94vA+Wb2w==}
     engines: {node: '>=18'}
@@ -1007,6 +1158,12 @@ packages:
     cpu: [x64]
     os: [sunos]
 
+  '@esbuild/sunos-x64@0.27.7':
+    resolution: {integrity: sha512-ikktIhFBzQNt/QDyOL580ti9+5mL/YZeUPKU2ivGtGjdTYoqz6jObj6nOMfhASpS4GU4Q/Clh1QtxWAvcYKamA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [sunos]
+
   '@esbuild/sunos-x64@0.28.0':
     resolution: {integrity: sha512-1ZgjUoEdHZZl/YlV76TSCz9Hqj9h9YmMGAgAPYd+q4SicWNX3G5GCyx9uhQWSLcbvPW8Ni7lj4gDa1T40akdlw==}
     engines: {node: '>=18'}
@@ -1019,6 +1176,12 @@ packages:
     cpu: [arm64]
     os: [win32]
 
+  '@esbuild/win32-arm64@0.27.7':
+    resolution: {integrity: sha512-7yRhbHvPqSpRUV7Q20VuDwbjW5kIMwTHpptuUzV+AA46kiPze5Z7qgt6CLCK3pWFrHeNfDd1VKgyP4O+ng17CA==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [win32]
+
   '@esbuild/win32-arm64@0.28.0':
     resolution: {integrity: sha512-Q9StnDmQ/enxnpxCCLSg0oo4+34B9TdXpuyPeTedN/6+iXBJ4J+zwfQI28u/Jl40nOYAxGoNi7mFP40RUtkmUA==}
     engines: {node: '>=18'}
@@ -1031,6 +1194,12 @@ packages:
     cpu: [ia32]
     os: [win32]
 
+  '@esbuild/win32-ia32@0.27.7':
+    resolution: {integrity: sha512-SmwKXe6VHIyZYbBLJrhOoCJRB/Z1tckzmgTLfFYOfpMAx63BJEaL9ExI8x7v0oAO3Zh6D/Oi1gVxEYr5oUCFhw==}
+    engines: {node: '>=18'}
+    cpu: [ia32]
+    os: [win32]
+
   '@esbuild/win32-ia32@0.28.0':
     resolution: {integrity: sha512-zF3ag/gfiCe6U2iczcRzSYJKH1DCI+ByzSENHlM2FcDbEeo5Zd2C86Aq0tKUYAJJ1obRP84ymxIAksZUcdztHA==}
     engines: {node: '>=18'}
@@ -1043,6 +1212,12 @@ packages:
     cpu: [x64]
     os: [win32]
 
+  '@esbuild/win32-x64@0.27.7':
+    resolution: {integrity: sha512-56hiAJPhwQ1R4i+21FVF7V8kSD5zZTdHcVuRFMW0hn753vVfQN8xlx4uOPT4xoGH0Z/oVATuR82AiqSTDIpaHg==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [win32]
+
   '@esbuild/win32-x64@0.28.0':
     resolution: {integrity: sha512-pEl1bO9mfAmIC+tW5btTmrKaujg3zGtUmWNdCw/xs70FBjwAL3o9OEKNHvNmnyylD6ubxUERiEhdsL0xBQ9efw==}
     engines: {node: '>=18'}
@@ -2485,6 +2660,12 @@ packages:
     engines: {node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7}
     hasBin: true
 
+  bundle-require@5.1.0:
+    resolution: {integrity: sha512-3WrrOuZiyaaZPWiEt4G3+IffISVC9HYlWueJEBWED4ZH4aIAC2PnkdnuRrR94M+w6yGWn4AglWtJtBI8YqvgoA==}
+    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
+    peerDependencies:
+      esbuild: '>=0.18'
+
   cac@6.7.14:
     resolution: {integrity: sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==}
     engines: {node: '>=8'}
@@ -2546,6 +2727,10 @@ packages:
     resolution: {integrity: sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==}
     engines: {node: '>= 8.10.0'}
 
+  chokidar@4.0.3:
+    resolution: {integrity: sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA==}
+    engines: {node: '>= 14.16.0'}
+
   class-variance-authority@0.7.1:
     resolution: {integrity: sha512-Ka+9Trutv7G8M6WT6SeiRWz792K5qEqIGEGzXKhAE6xOWAY6pPH8U+9IY3oCMv6kqTmLsv7Xh/2w2RigkePMsg==}
 
@@ -2583,6 +2768,10 @@ packages:
   confbox@0.1.8:
     resolution: {integrity: sha512-RMtmw0iFkeR4YV+fUOSucriAQNb9g8zFR52MWCtl+cCZOFRNL6zeB395vPzFhEjjn4fMxXudmELnl/KF/WrK6w==}
 
+  consola@3.4.2:
+    resolution: {integrity: sha512-5IKcdX0nnYavi6G7TtOhwkYzyjfJlatbjMjuLSfE2kYT5pMDOilZ4OvMhi637CcDICTmz3wARPoyhqyX1Y+XvA==}
+    engines: {node: ^14.18.0 || >=16.10.0}
+
   cross-spawn@7.0.6:
     resolution: {integrity: sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==}
     engines: {node: '>= 8'}
@@ -2783,6 +2972,11 @@ packages:
     engines: {node: '>=12'}
     hasBin: true
 
+  esbuild@0.27.7:
+    resolution: {integrity: sha512-IxpibTjyVnmrIQo5aqNpCgoACA/dTKLTlhMHihVHhdkxKyPO1uBBthumT0rdHmcsk9uMonIWS0m4FljWzILh3w==}
+    engines: {node: '>=18'}
+    hasBin: true
+
   esbuild@0.28.0:
     resolution: {integrity: sha512-sNR9MHpXSUV/XB4zmsFKN+QgVG82Cc7+/aaxJ8Adi8hyOac+EXptIp45QBPaVyX3N70664wRbTcLTOemCAnyqw==}
     engines: {node: '>=18'}
@@ -2993,6 +3187,9 @@ packages:
     resolution: {integrity: sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==}
     engines: {node: '>=10'}
 
+  fix-dts-default-cjs-exports@1.0.1:
+    resolution: {integrity: sha512-pVIECanWFC61Hzl2+oOCtoJ3F17kglZC/6N94eRWycFgBH35hHx0Li604ZIzhseh97mf2p0cv7vVrOZGoqhlEg==}
+
   flat-cache@3.2.0:
     resolution: {integrity: sha512-CYcENa+FtcUKLmhhqyctpclsq7QF38pKjZHsGNiSQF5r4FtoKDWabFDl3hzaEQMvT1LHEysw5twgLvpYYb4vbw==}
     engines: {node: ^10.12.0 || >=12.0.0}
@@ -3388,6 +3585,10 @@ packages:
     resolution: {integrity: sha512-/imKNG4EbWNrVjoNC/1H5/9GFy+tqjGBHCaSsN+P2RnPqjsLmv6UD3Ej+Kj8nBWaRAwyk7kK5ZUc+OEatnTR3A==}
     hasBin: true
 
+  joycon@3.1.1:
+    resolution: {integrity: sha512-34wB/Y7MW7bzjKRjUKTa46I2Z7eV62Rkhva+KkopW7Qvv/OSWBqvkSY7vusOPrNuZcUG3tApvdVgNB8POj3SPw==}
+    engines: {node: '>=10'}
+
   js-tokens@4.0.0:
     resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==}
 
@@ -3473,6 +3674,10 @@ packages:
   lines-and-columns@1.2.4:
     resolution: {integrity: sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==}
 
+  load-tsconfig@0.2.5:
+    resolution: {integrity: sha512-IXO6OCs9yg8tMKzfPZ1YmheJbZCiEsnBdcB03l0OcfK9prKnJb96siuHCr5Fl37/yo9DnKU+TLpxzTUspw9shg==}
+    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
+
   local-pkg@0.5.1:
     resolution: {integrity: sha512-9rrA30MRRP3gBD3HTGnC6cDFpaE1kVDWxWgqWJUN0RvDNAo+Nz/9GxB+nHOH0ifbVFy0hSA1V6vFDvnx54lTEQ==}
     engines: {node: '>=14'}
@@ -4073,6 +4278,10 @@ packages:
     resolution: {integrity: sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==}
     engines: {node: '>=8.10.0'}
 
+  readdirp@4.1.2:
+    resolution: {integrity: sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg==}
+    engines: {node: '>= 14.18.0'}
+
   recma-build-jsx@1.0.0:
     resolution: {integrity: sha512-8GtdyqaBcDfva+GUKDr3nev3VpKAhup1+RvkMvUxURHpW7QyIvk9F5wz7Vzo06CEMSilw6uArgRqhpiUcWp8ew==}
 
@@ -4143,6 +4352,10 @@ packages:
     resolution: {integrity: sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==}
     engines: {node: '>=4'}
 
+  resolve-from@5.0.0:
+    resolution: {integrity: sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==}
+    engines: {node: '>=8'}
+
   resolve-pkg-maps@1.0.0:
     resolution: {integrity: sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==}
 
@@ -4410,6 +4623,9 @@ packages:
   tinybench@2.9.0:
     resolution: {integrity: sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==}
 
+  tinyexec@0.3.2:
+    resolution: {integrity: sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA==}
+
   tinyglobby@0.2.16:
     resolution: {integrity: sha512-pn99VhoACYR8nFHhxqix+uvsbXineAasWm5ojXoN8xEwK5Kd3/TrhNn1wByuD52UxWRLy8pu+kRMniEi6Eq9Zg==}
     engines: {node: '>=12.0.0'}
@@ -4449,6 +4665,10 @@ packages:
     resolution: {integrity: sha512-bLVMLPtstlZ4iMQHpFHTR7GAGj2jxi8Dg0s2h2MafAE4uSWF98FC/3MomU51iQAMf8/qDUbKWf5GxuvvVcXEhw==}
     engines: {node: '>=20'}
 
+  tree-kill@1.2.2:
+    resolution: {integrity: sha512-L0Orpi8qGpRG//Nd+H90vFB+3iHnue1zSSGmNOOCh1GLJ7rUKVwV2HvijphGQS2UmhUZewS9VgvxYIdgr+fG1A==}
+    hasBin: true
+
   trim-lines@3.0.1:
     resolution: {integrity: sha512-kRj8B+YHZCc9kQYdWfJB2/oUl9rA99qbowYYBtr4ui4mZyAQ2JpvVBd/6U2YloATfqBhBTSMhTpgBHtU0Mf3Rg==}
 
@@ -4470,6 +4690,25 @@ packages:
   tslib@2.8.1:
     resolution: {integrity: sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==}
 
+  tsup@8.5.1:
+    resolution: {integrity: sha512-xtgkqwdhpKWr3tKPmCkvYmS9xnQK3m3XgxZHwSUjvfTjp7YfXe5tT3GgWi0F2N+ZSMsOeWeZFh7ZZFg5iPhing==}
+    engines: {node: '>=18'}
+    hasBin: true
+    peerDependencies:
+      '@microsoft/api-extractor': ^7.36.0
+      '@swc/core': ^1
+      postcss: ^8.4.12
+      typescript: '>=4.5.0'
+    peerDependenciesMeta:
+      '@microsoft/api-extractor':
+        optional: true
+      '@swc/core':
+        optional: true
+      postcss:
+        optional: true
+      typescript:
+        optional: true
+
   tsx@4.22.2:
     resolution: {integrity: sha512-6w9FwtT8WQqRAyTNR+Z+86kghRqpmOLjXUrBlBT6T+CQGDuIMm0VmAqaFUFBIeKDTGobE6/YSigZYLeomzBaRg==}
     engines: {node: '>=18.0.0'}
@@ -4894,147 +5133,225 @@ snapshots:
   '@esbuild/aix-ppc64@0.21.5':
     optional: true
 
+  '@esbuild/aix-ppc64@0.27.7':
+    optional: true
+
   '@esbuild/aix-ppc64@0.28.0':
     optional: true
 
   '@esbuild/android-arm64@0.21.5':
     optional: true
 
+  '@esbuild/android-arm64@0.27.7':
+    optional: true
+
   '@esbuild/android-arm64@0.28.0':
     optional: true
 
   '@esbuild/android-arm@0.21.5':
     optional: true
 
+  '@esbuild/android-arm@0.27.7':
+    optional: true
+
   '@esbuild/android-arm@0.28.0':
     optional: true
 
   '@esbuild/android-x64@0.21.5':
     optional: true
 
+  '@esbuild/android-x64@0.27.7':
+    optional: true
+
   '@esbuild/android-x64@0.28.0':
     optional: true
 
   '@esbuild/darwin-arm64@0.21.5':
     optional: true
 
+  '@esbuild/darwin-arm64@0.27.7':
+    optional: true
+
   '@esbuild/darwin-arm64@0.28.0':
     optional: true
 
   '@esbuild/darwin-x64@0.21.5':
     optional: true
 
+  '@esbuild/darwin-x64@0.27.7':
+    optional: true
+
   '@esbuild/darwin-x64@0.28.0':
     optional: true
 
   '@esbuild/freebsd-arm64@0.21.5':
     optional: true
 
+  '@esbuild/freebsd-arm64@0.27.7':
+    optional: true
+
   '@esbuild/freebsd-arm64@0.28.0':
     optional: true
 
   '@esbuild/freebsd-x64@0.21.5':
     optional: true
 
+  '@esbuild/freebsd-x64@0.27.7':
+    optional: true
+
   '@esbuild/freebsd-x64@0.28.0':
     optional: true
 
   '@esbuild/linux-arm64@0.21.5':
     optional: true
 
+  '@esbuild/linux-arm64@0.27.7':
+    optional: true
+
   '@esbuild/linux-arm64@0.28.0':
     optional: true
 
   '@esbuild/linux-arm@0.21.5':
     optional: true
 
+  '@esbuild/linux-arm@0.27.7':
+    optional: true
+
   '@esbuild/linux-arm@0.28.0':
     optional: true
 
   '@esbuild/linux-ia32@0.21.5':
     optional: true
 
+  '@esbuild/linux-ia32@0.27.7':
+    optional: true
+
   '@esbuild/linux-ia32@0.28.0':
     optional: true
 
   '@esbuild/linux-loong64@0.21.5':
     optional: true
 
+  '@esbuild/linux-loong64@0.27.7':
+    optional: true
+
   '@esbuild/linux-loong64@0.28.0':
     optional: true
 
   '@esbuild/linux-mips64el@0.21.5':
     optional: true
 
+  '@esbuild/linux-mips64el@0.27.7':
+    optional: true
+
   '@esbuild/linux-mips64el@0.28.0':
     optional: true
 
   '@esbuild/linux-ppc64@0.21.5':
     optional: true
 
+  '@esbuild/linux-ppc64@0.27.7':
+    optional: true
+
   '@esbuild/linux-ppc64@0.28.0':
     optional: true
 
   '@esbuild/linux-riscv64@0.21.5':
     optional: true
 
+  '@esbuild/linux-riscv64@0.27.7':
+    optional: true
+
   '@esbuild/linux-riscv64@0.28.0':
     optional: true
 
   '@esbuild/linux-s390x@0.21.5':
     optional: true
 
+  '@esbuild/linux-s390x@0.27.7':
+    optional: true
+
   '@esbuild/linux-s390x@0.28.0':
     optional: true
 
   '@esbuild/linux-x64@0.21.5':
     optional: true
 
+  '@esbuild/linux-x64@0.27.7':
+    optional: true
+
   '@esbuild/linux-x64@0.28.0':
     optional: true
 
+  '@esbuild/netbsd-arm64@0.27.7':
+    optional: true
+
   '@esbuild/netbsd-arm64@0.28.0':
     optional: true
 
   '@esbuild/netbsd-x64@0.21.5':
     optional: true
 
+  '@esbuild/netbsd-x64@0.27.7':
+    optional: true
+
   '@esbuild/netbsd-x64@0.28.0':
     optional: true
 
+  '@esbuild/openbsd-arm64@0.27.7':
+    optional: true
+
   '@esbuild/openbsd-arm64@0.28.0':
     optional: true
 
   '@esbuild/openbsd-x64@0.21.5':
     optional: true
 
+  '@esbuild/openbsd-x64@0.27.7':
+    optional: true
+
   '@esbuild/openbsd-x64@0.28.0':
     optional: true
 
+  '@esbuild/openharmony-arm64@0.27.7':
+    optional: true
+
   '@esbuild/openharmony-arm64@0.28.0':
     optional: true
 
   '@esbuild/sunos-x64@0.21.5':
     optional: true
 
+  '@esbuild/sunos-x64@0.27.7':
+    optional: true
+
   '@esbuild/sunos-x64@0.28.0':
     optional: true
 
   '@esbuild/win32-arm64@0.21.5':
     optional: true
 
+  '@esbuild/win32-arm64@0.27.7':
+    optional: true
+
   '@esbuild/win32-arm64@0.28.0':
     optional: true
 
   '@esbuild/win32-ia32@0.21.5':
     optional: true
 
+  '@esbuild/win32-ia32@0.27.7':
+    optional: true
+
   '@esbuild/win32-ia32@0.28.0':
     optional: true
 
   '@esbuild/win32-x64@0.21.5':
     optional: true
 
+  '@esbuild/win32-x64@0.27.7':
+    optional: true
+
   '@esbuild/win32-x64@0.28.0':
     optional: true
 
@@ -6524,6 +6841,11 @@ snapshots:
       node-releases: 2.0.46
       update-browserslist-db: 1.2.3(browserslist@4.28.2)
 
+  bundle-require@5.1.0(esbuild@0.27.7):
+    dependencies:
+      esbuild: 0.27.7
+      load-tsconfig: 0.2.5
+
   cac@6.7.14: {}
 
   call-bind-apply-helpers@1.0.2:
@@ -6592,6 +6914,10 @@ snapshots:
     optionalDependencies:
       fsevents: 2.3.3
 
+  chokidar@4.0.3:
+    dependencies:
+      readdirp: 4.1.2
+
   class-variance-authority@0.7.1:
     dependencies:
       clsx: 2.1.1
@@ -6620,6 +6946,8 @@ snapshots:
 
   confbox@0.1.8: {}
 
+  consola@3.4.2: {}
+
   cross-spawn@7.0.6:
     dependencies:
       path-key: 3.1.1
@@ -6931,6 +7259,35 @@ snapshots:
       '@esbuild/win32-ia32': 0.21.5
       '@esbuild/win32-x64': 0.21.5
 
+  esbuild@0.27.7:
+    optionalDependencies:
+      '@esbuild/aix-ppc64': 0.27.7
+      '@esbuild/android-arm': 0.27.7
+      '@esbuild/android-arm64': 0.27.7
+      '@esbuild/android-x64': 0.27.7
+      '@esbuild/darwin-arm64': 0.27.7
+      '@esbuild/darwin-x64': 0.27.7
+      '@esbuild/freebsd-arm64': 0.27.7
+      '@esbuild/freebsd-x64': 0.27.7
+      '@esbuild/linux-arm': 0.27.7
+      '@esbuild/linux-arm64': 0.27.7
+      '@esbuild/linux-ia32': 0.27.7
+      '@esbuild/linux-loong64': 0.27.7
+      '@esbuild/linux-mips64el': 0.27.7
+      '@esbuild/linux-ppc64': 0.27.7
+      '@esbuild/linux-riscv64': 0.27.7
+      '@esbuild/linux-s390x': 0.27.7
+      '@esbuild/linux-x64': 0.27.7
+      '@esbuild/netbsd-arm64': 0.27.7
+      '@esbuild/netbsd-x64': 0.27.7
+      '@esbuild/openbsd-arm64': 0.27.7
+      '@esbuild/openbsd-x64': 0.27.7
+      '@esbuild/openharmony-arm64': 0.27.7
+      '@esbuild/sunos-x64': 0.27.7
+      '@esbuild/win32-arm64': 0.27.7
+      '@esbuild/win32-ia32': 0.27.7
+      '@esbuild/win32-x64': 0.27.7
+
   esbuild@0.28.0:
     optionalDependencies:
       '@esbuild/aix-ppc64': 0.28.0
@@ -7262,6 +7619,12 @@ snapshots:
       locate-path: 6.0.0
       path-exists: 4.0.0
 
+  fix-dts-default-cjs-exports@1.0.1:
+    dependencies:
+      magic-string: 0.30.21
+      mlly: 1.8.2
+      rollup: 4.60.4
+
   flat-cache@3.2.0:
     dependencies:
       flatted: 3.4.2
@@ -7722,6 +8085,8 @@ snapshots:
 
   jiti@1.21.7: {}
 
+  joycon@3.1.1: {}
+
   js-tokens@4.0.0: {}
 
   js-tokens@9.0.1: {}
@@ -7835,6 +8200,8 @@ snapshots:
 
   lines-and-columns@1.2.4: {}
 
+  load-tsconfig@0.2.5: {}
+
   local-pkg@0.5.1:
     dependencies:
       mlly: 1.8.2
@@ -8684,6 +9051,8 @@ snapshots:
     dependencies:
       picomatch: 2.3.2
 
+  readdirp@4.1.2: {}
+
   recma-build-jsx@1.0.0:
     dependencies:
       '@types/estree': 1.0.9
@@ -8821,6 +9190,8 @@ snapshots:
 
   resolve-from@4.0.0: {}
 
+  resolve-from@5.0.0: {}
+
   resolve-pkg-maps@1.0.0: {}
 
   resolve@1.22.12:
@@ -9201,6 +9572,8 @@ snapshots:
 
   tinybench@2.9.0: {}
 
+  tinyexec@0.3.2: {}
+
   tinyglobby@0.2.16:
     dependencies:
       fdir: 6.5.0(picomatch@4.0.4)
@@ -9239,6 +9612,8 @@ snapshots:
     dependencies:
       punycode: 2.3.1
 
+  tree-kill@1.2.2: {}
+
   trim-lines@3.0.1: {}
 
   trough@2.2.0: {}
@@ -9258,6 +9633,34 @@ snapshots:
 
   tslib@2.8.1: {}
 
+  tsup@8.5.1(jiti@1.21.7)(postcss@8.5.14)(tsx@4.22.2)(typescript@5.9.3):
+    dependencies:
+      bundle-require: 5.1.0(esbuild@0.27.7)
+      cac: 6.7.14
+      chokidar: 4.0.3
+      consola: 3.4.2
+      debug: 4.4.3
+      esbuild: 0.27.7
+      fix-dts-default-cjs-exports: 1.0.1
+      joycon: 3.1.1
+      picocolors: 1.1.1
+      postcss-load-config: 6.0.1(jiti@1.21.7)(postcss@8.5.14)(tsx@4.22.2)
+      resolve-from: 5.0.0
+      rollup: 4.60.4
+      source-map: 0.7.6
+      sucrase: 3.35.1
+      tinyexec: 0.3.2
+      tinyglobby: 0.2.16
+      tree-kill: 1.2.2
+    optionalDependencies:
+      postcss: 8.5.14
+      typescript: 5.9.3
+    transitivePeerDependencies:
+      - jiti
+      - supports-color
+      - tsx
+      - yaml
+
   tsx@4.22.2:
     dependencies:
       esbuild: 0.28.0