@happyvertical/smrt-svelte 0.30.0

package/dist/components/workspace/__tests__/typed-tool-fixture/TypedTool.svelte.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Fixture for the typed tool-component pattern documented on
+ * `ToolDef.component`. The dock erases tool-specific types at registration,
+ * but the tool component itself locally annotates `context` with the
+ * narrowed `ToolsDockContext<TData, TActions>` shape — see
+ * `register-typed-tool.ts` for the registration site that must accept this
+ * component without a cast.
+ *
+ * If any of the type assertions below fail at `svelte-check` / `tsc` time,
+ * either the `ToolDef.component` erasure relaxation or the
+ * `ToolsDockContext` action-map constraint regressed.
+ */
+import type { ToolsDockApi, ToolsDockContext } from '../../types.js';
+import type { MyActions, MyData } from './typed-tool-types.js';
+type $$ComponentProps = {
+    context: ToolsDockContext<MyData, MyActions> | null;
+    dock: ToolsDockApi;
+};
+declare const TypedTool: import("svelte").Component<$$ComponentProps, {}, "">;
+type TypedTool = ReturnType<typeof TypedTool>;
+export default TypedTool;
+//# sourceMappingURL=TypedTool.svelte.d.ts.map

package/dist/components/workspace/__tests__/typed-tool-fixture/TypedTool.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypedTool.svelte.d.ts","sourceRoot":"","sources":["../../../../../src/components/workspace/__tests__/typed-tool-fixture/TypedTool.svelte.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AACrE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAE9D,KAAK,gBAAgB,GAAI;IACxB,OAAO,EAAE,gBAAgB,CAAC,MAAM,EAAE,SAAS,CAAC,GAAG,IAAI,CAAC;IACpD,IAAI,EAAE,YAAY,CAAC;CACpB,CAAC;AA4BF,QAAA,MAAM,SAAS,sDAAwC,CAAC;AACxD,KAAK,SAAS,GAAG,UAAU,CAAC,OAAO,SAAS,CAAC,CAAC;AAC9C,eAAe,SAAS,CAAC"}

package/dist/components/workspace/__tests__/typed-tool-fixture/register-typed-tool.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Registration site for the typed-tool fixture. This file is the contract
+ * the workspace ergonomics PR (#1239) is restoring:
+ *
+ *   - `TypedTool.svelte` declares its own typed `context` prop of shape
+ *     `ToolsDockContext<MyData, MyActions> | null`.
+ *   - It must be assignable to `ToolDef.component` without a registration-
+ *     site cast — but this assertion is only meaningful under
+ *     `svelte-check`. Under `tsc --noEmit`, `.svelte` imports resolve to
+ *     `Component<any>` via the ambient `declare module '*.svelte'`
+ *     declaration, so the assignment compiles regardless of what
+ *     `ToolDef.component` is typed as. CI runs both `typecheck` and `check`
+ *     (which invokes `svelte-check`) for this reason — see the JSDoc on
+ *     `../typed-tool-fixture.test.ts` for the full split.
+ *   - `defineToolsDock<MyData, MyActions>(...)` must accept an interface
+ *     `MyActions` (no string index signature) under the factory generic.
+ *   - `dock.setContext({ actions: { triggerSave } })` must still compile
+ *     with no generic arguments (back-compat for the untyped pattern).
+ *   - The factory's `<TData, TActions>` generics must flow through to the
+ *     returned `ToolsDockInstance<TData, TActions>` — see
+ *     `_assertTypedDockFlow` below for the load-bearing assertion.
+ *
+ * If TypeScript ever rejects this file under strict checks, the regression
+ * from review thread #1239/PRRT_kwDOQDruXs6CbBcK has returned.
+ */
+import { type DefineToolsDockOptions, type ToolDef, type ToolsDockApi, type ToolsDockContext, type ToolsDockInstance } from '../../index.js';
+import type { MyActions, MyData } from './typed-tool-types.js';
+/** Type-only export: a tool registry that uses the typed component. */
+export declare const typedTool: ToolDef;
+/** Type-only export: options that pass the typed action map through. */
+export declare const typedOptions: DefineToolsDockOptions<MyData, MyActions>;
+/**
+ * Type-only export: a typed context literal. This must compile under the
+ * relaxed `TActions extends { [K in keyof TActions]: (...args: any[]) => any }`
+ * constraint — `MyActions` is an interface (no string index signature) and
+ * would fail a `Record<string, ...>` constraint.
+ */
+export declare const typedContext: ToolsDockContext<MyData, MyActions>;
+/**
+ * Type-only export: the untyped (back-compat) setContext shape — passing
+ * `actions` with no factory generic. This caught a previous regression
+ * where `TActions = Record<string, never>` defaulted the action map to
+ * "no keys", rejecting `{ triggerSave }` outright.
+ */
+export declare const untypedContext: ToolsDockContext;
+/** Type-only assertion: typed instance preserves the action shape. */
+export type _AssertTypedActions = ToolsDockApi['context'] extends infer C ? C : never;
+/**
+ * Type-only fixture: exercises the end-to-end generic flow on the public
+ * surface returned by `defineToolsDock<TData, TActions>(...)`. This is the
+ * regression Codex flagged in PR #1239 round-2 — the factory accepts the
+ * generics but erases them on the return type, so `dock.setContext(...)` and
+ * `dock.context?.data` fall back to the default-typed shape.
+ *
+ * The function below is never called at runtime. Its body has to compile,
+ * which is the load-bearing assertion: if `ToolsDockApi` / `ToolsDockInstance`
+ * ever stop parameterizing their `context` / `setContext` signatures, the
+ * lines marked TYPED below would fail to assign `MyData` / `MyActions` into
+ * the default-typed shape (no string index signature).
+ *
+ * Lives inline rather than at module scope because `defineToolsDock` calls
+ * `setContext`, which is only legal inside a component init scope.
+ */
+export declare function _assertTypedDockFlow(): ToolsDockInstance<MyData, MyActions>;
+//# sourceMappingURL=register-typed-tool.d.ts.map

package/dist/components/workspace/__tests__/typed-tool-fixture/register-typed-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register-typed-tool.d.ts","sourceRoot":"","sources":["../../../../../src/components/workspace/__tests__/typed-tool-fixture/register-typed-tool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,EACL,KAAK,sBAAsB,EAE3B,KAAK,OAAO,EACZ,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACvB,MAAM,gBAAgB,CAAC;AAExB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAE/D,uEAAuE;AACvE,eAAO,MAAM,SAAS,EAAE,OAQvB,CAAC;AAEF,wEAAwE;AACxE,eAAO,MAAM,YAAY,EAAE,sBAAsB,CAAC,MAAM,EAAE,SAAS,CAElE,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,YAAY,EAAE,gBAAgB,CAAC,MAAM,EAAE,SAAS,CAO5D,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,cAAc,EAAE,gBAK5B,CAAC;AAEF,sEAAsE;AACtE,MAAM,MAAM,mBAAmB,GAAG,YAAY,CAAC,SAAS,CAAC,SAAS,MAAM,CAAC,GACrE,CAAC,GACD,KAAK,CAAC;AAEV;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,IAAI,iBAAiB,CAAC,MAAM,EAAE,SAAS,CAAC,CAmC3E"}

package/dist/components/workspace/__tests__/typed-tool-fixture/register-typed-tool.js

@@ -0,0 +1,115 @@
+/**
+ * Registration site for the typed-tool fixture. This file is the contract
+ * the workspace ergonomics PR (#1239) is restoring:
+ *
+ *   - `TypedTool.svelte` declares its own typed `context` prop of shape
+ *     `ToolsDockContext<MyData, MyActions> | null`.
+ *   - It must be assignable to `ToolDef.component` without a registration-
+ *     site cast — but this assertion is only meaningful under
+ *     `svelte-check`. Under `tsc --noEmit`, `.svelte` imports resolve to
+ *     `Component<any>` via the ambient `declare module '*.svelte'`
+ *     declaration, so the assignment compiles regardless of what
+ *     `ToolDef.component` is typed as. CI runs both `typecheck` and `check`
+ *     (which invokes `svelte-check`) for this reason — see the JSDoc on
+ *     `../typed-tool-fixture.test.ts` for the full split.
+ *   - `defineToolsDock<MyData, MyActions>(...)` must accept an interface
+ *     `MyActions` (no string index signature) under the factory generic.
+ *   - `dock.setContext({ actions: { triggerSave } })` must still compile
+ *     with no generic arguments (back-compat for the untyped pattern).
+ *   - The factory's `<TData, TActions>` generics must flow through to the
+ *     returned `ToolsDockInstance<TData, TActions>` — see
+ *     `_assertTypedDockFlow` below for the load-bearing assertion.
+ *
+ * If TypeScript ever rejects this file under strict checks, the regression
+ * from review thread #1239/PRRT_kwDOQDruXs6CbBcK has returned.
+ */
+import { defineToolsDock, } from '../../index.js';
+import TypedTool from './TypedTool.svelte';
+/** Type-only export: a tool registry that uses the typed component. */
+export const typedTool = {
+    id: 'typed',
+    label: 'Typed',
+    // ↳ TypedTool's `context` prop is narrower than the base
+    //   `ToolsDockContext | null`. Under strict prop variance this would be
+    //   rejected if `ToolDef.component` were typed as
+    //   `Component<{ context: ToolsDockContext | null; dock: ToolsDockApi }>`.
+    component: TypedTool,
+};
+/** Type-only export: options that pass the typed action map through. */
+export const typedOptions = {
+    tools: [typedTool],
+};
+/**
+ * Type-only export: a typed context literal. This must compile under the
+ * relaxed `TActions extends { [K in keyof TActions]: (...args: any[]) => any }`
+ * constraint — `MyActions` is an interface (no string index signature) and
+ * would fail a `Record<string, ...>` constraint.
+ */
+export const typedContext = {
+    type: 'route',
+    data: { siteSlug: 'demo', contentId: 'demo-1' },
+    actions: {
+        triggerSave: () => undefined,
+        triggerReview: (_kind) => undefined,
+    },
+};
+/**
+ * Type-only export: the untyped (back-compat) setContext shape — passing
+ * `actions` with no factory generic. This caught a previous regression
+ * where `TActions = Record<string, never>` defaulted the action map to
+ * "no keys", rejecting `{ triggerSave }` outright.
+ */
+export const untypedContext = {
+    type: 'route',
+    actions: {
+        triggerSave: () => undefined,
+    },
+};
+/**
+ * Type-only fixture: exercises the end-to-end generic flow on the public
+ * surface returned by `defineToolsDock<TData, TActions>(...)`. This is the
+ * regression Codex flagged in PR #1239 round-2 — the factory accepts the
+ * generics but erases them on the return type, so `dock.setContext(...)` and
+ * `dock.context?.data` fall back to the default-typed shape.
+ *
+ * The function below is never called at runtime. Its body has to compile,
+ * which is the load-bearing assertion: if `ToolsDockApi` / `ToolsDockInstance`
+ * ever stop parameterizing their `context` / `setContext` signatures, the
+ * lines marked TYPED below would fail to assign `MyData` / `MyActions` into
+ * the default-typed shape (no string index signature).
+ *
+ * Lives inline rather than at module scope because `defineToolsDock` calls
+ * `setContext`, which is only legal inside a component init scope.
+ */
+export function _assertTypedDockFlow() {
+    const typedDock = defineToolsDock({
+        tools: [typedTool],
+        fetchAvailability: async (ctx) => {
+            // TYPED: `ctx?.data?.siteSlug` must be `string | undefined`, not
+            // `unknown`. If the factory dropped its generics on the callback
+            // signature, the next line would only compile as `unknown`.
+            const _siteSlug = ctx?.data?.siteSlug;
+            const _save = ctx?.actions?.triggerSave;
+            return [];
+        },
+    });
+    // TYPED: `setContext` accepts the narrowed context with no manual cast.
+    // Pre-fix this assignment failed because `ToolsDockApi.setContext` was
+    // typed to receive only the default-generic `ToolsDockContext`, whose
+    // `actions` slot expected `Record<string, (...args: any[]) => unknown>` —
+    // `MyActions` (an interface, no string index signature) was rejected.
+    typedDock.setContext({
+        type: 'route',
+        data: { siteSlug: 'demo', contentId: 'demo-1' },
+        actions: {
+            triggerSave: () => undefined,
+            triggerReview: (_kind) => undefined,
+        },
+    });
+    // TYPED: reading typed properties off the public `context` surface must
+    // resolve to the consumer's shapes, not `Record<string, unknown>` /
+    // `Record<string, (...args: any[]) => unknown>`.
+    const _slug = typedDock.context?.data?.siteSlug;
+    const _action = typedDock.context?.actions?.triggerSave;
+    return typedDock;
+}

package/dist/components/workspace/__tests__/typed-tool-fixture/typed-tool-types.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Type-only fixtures for the typed tool-component pattern. Lives in a
+ * `.ts` file (not `.svelte`) so the types can be imported cleanly from
+ * both the component and the registration site without relying on
+ * Svelte's `<script context="module">` re-export semantics.
+ */
+export interface MyData {
+    siteSlug: string;
+    contentId: string;
+}
+export interface MyActions {
+    triggerSave(): void;
+    triggerReview(kind: string): void;
+}
+//# sourceMappingURL=typed-tool-types.d.ts.map

package/dist/components/workspace/__tests__/typed-tool-fixture/typed-tool-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typed-tool-types.d.ts","sourceRoot":"","sources":["../../../../../src/components/workspace/__tests__/typed-tool-fixture/typed-tool-types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,WAAW,MAAM;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,SAAS;IACxB,WAAW,IAAI,IAAI,CAAC;IACpB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CACnC"}

package/dist/components/workspace/__tests__/typed-tool-fixture/typed-tool-types.js

@@ -0,0 +1,7 @@
+/**
+ * Type-only fixtures for the typed tool-component pattern. Lives in a
+ * `.ts` file (not `.svelte`) so the types can be imported cleanly from
+ * both the component and the registration site without relying on
+ * Svelte's `<script context="module">` re-export semantics.
+ */
+export {};

package/dist/components/workspace/__tests__/typed-tool-fixture.test.js

@@ -0,0 +1,115 @@
+/**
+ * Regression tests for the typed-tool component pattern documented on
+ * `ToolDef.component` and `ToolsDockContext`.
+ *
+ * The static type checks live in `typed-tool-fixture/register-typed-tool.ts`
+ * and `typed-tool-fixture/TypedTool.svelte`. They split across two checkers:
+ *
+ * - `tsc --noEmit` (the package's `typecheck` script, run in CI via
+ *   `pnpm turbo run typecheck`) catches the regressions that live in the
+ *   `.ts` files:
+ *     * The factory `<TData, TActions>` generics flow into
+ *       `ToolsDockApi.setContext` / `ToolsDockApi.context`. If they ever
+ *       erase back to the default shape, the `_assertTypedDockFlow`
+ *       function in `register-typed-tool.ts` fails to compile.
+ *     * The `TActions` constraint accepts interface-style action maps
+ *       (no string index signature). If it ever tightens back to
+ *       `Record<string, ...>`, the `typedContext` / `untypedContext`
+ *       literals fail to compile.
+ *
+ * - `svelte-check` (the package's `check` script, run in CI via
+ *   `pnpm turbo run check`) catches the regression that lives in the
+ *   `.svelte` file:
+ *     * `ToolDef.component` is typed `Component<any>` so a tool component
+ *       declaring a narrower `context` prop is assignable at registration.
+ *       Under `tsc --noEmit` alone, `.svelte` imports resolve to
+ *       `Component<any>` via the ambient `declare module '*.svelte'`
+ *       declaration — so the registration-site assertion in
+ *       `register-typed-tool.ts` would compile regardless of what
+ *       `ToolDef.component` actually demands. Only `svelte-check` actually
+ *       resolves `TypedTool.svelte`'s real prop shape and exercises the
+ *       contravariant assignment, which is why the `check` script is part
+ *       of CI alongside `typecheck`.
+ *
+ * The runtime test below guards against accidental regressions in the
+ * `ToolDef` storage shape itself (e.g. registering a component that ends
+ * up unreachable because of a runtime type assertion) and exercises the
+ * round-trip of typed / untyped context shapes through `dock.setContext`.
+ */
+import { flushSync, mount, unmount } from 'svelte';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import HostHarness from './harness.svelte';
+import { typedContext, typedOptions, untypedContext, } from './typed-tool-fixture/register-typed-tool.js';
+function mountTypedDock() {
+    const target = document.createElement('div');
+    document.body.appendChild(target);
+    const exposed = {
+        dock: undefined,
+    };
+    const component = mount(HostHarness, {
+        target,
+        props: {
+            options: typedOptions,
+            onReady: (dock) => {
+                exposed.dock = dock;
+            },
+        },
+    });
+    return {
+        dock: exposed.dock,
+        teardown: () => {
+            unmount(component);
+            target.remove();
+        },
+    };
+}
+describe('typed-tool fixture (regression guard for PR #1239 review)', () => {
+    let cleanup = [];
+    beforeEach(() => {
+        cleanup = [];
+    });
+    afterEach(() => {
+        for (const fn of cleanup.splice(0))
+            fn();
+    });
+    it('accepts a tool component with a narrowed context prop type', () => {
+        const { dock, teardown } = mountTypedDock();
+        cleanup.push(teardown);
+        // The fixture registered TypedTool, whose `context` prop is
+        // `ToolsDockContext<MyData, MyActions> | null`. If ToolDef.component's
+        // type contravariantly required the wider base context, this
+        // registration would not have compiled — which `pnpm typecheck` catches
+        // first. At runtime, we just need to confirm the tool is registered
+        // and reachable.
+        expect(dock.availableTools.map((t) => t.id)).toEqual(['typed']);
+        dock.open('typed');
+        flushSync();
+        expect(dock.isOpen).toBe(true);
+        expect(dock.activeTool).toBe('typed');
+    });
+    it('accepts the typed context shape via setContext()', () => {
+        const { dock, teardown } = mountTypedDock();
+        cleanup.push(teardown);
+        dock.setContext(typedContext);
+        flushSync();
+        // The context round-trips with the typed action shape intact at runtime
+        // (the dock erases the generic but does not mutate the value).
+        expect(dock.context?.data).toEqual({
+            siteSlug: 'demo',
+            contentId: 'demo-1',
+        });
+        // The action is callable — the runtime keeps reference identity.
+        expect(typeof dock.context?.actions?.triggerSave).toBe('function');
+    });
+    it('accepts the untyped (back-compat) context shape via setContext()', () => {
+        const { dock, teardown } = mountTypedDock();
+        cleanup.push(teardown);
+        // `untypedContext` uses the default `ToolsDockContext` (no generic
+        // arguments). If the default `TActions` were the prior
+        // `Record<string, never>`, this `actions: { triggerSave }` would have
+        // been rejected at typecheck time — the regression Copilot flagged.
+        dock.setContext(untypedContext);
+        flushSync();
+        expect(typeof dock.context?.actions?.triggerSave).toBe('function');
+    });
+});

package/dist/components/workspace/__tests__/use-harness-orphan.svelte

@@ -0,0 +1,9 @@
+<script lang="ts">
+/**
+ * Orphan consumer — calls useToolsDock with no provider in the ancestor
+ * chain. Expected to throw at construction time.
+ */
+import { useToolsDock } from '../tools-dock/use-tools-dock.js';
+
+useToolsDock();
+</script>

package/dist/components/workspace/__tests__/use-harness-orphan.svelte.d.ts

@@ -0,0 +1,19 @@
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}
+declare const UseHarnessOrphan: $$__sveltets_2_IsomorphicComponent<Record<string, never>, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+type UseHarnessOrphan = InstanceType<typeof UseHarnessOrphan>;
+export default UseHarnessOrphan;
+//# sourceMappingURL=use-harness-orphan.svelte.d.ts.map

package/dist/components/workspace/__tests__/use-harness-orphan.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-harness-orphan.svelte.d.ts","sourceRoot":"","sources":["../../../../src/components/workspace/__tests__/use-harness-orphan.svelte.ts"],"names":[],"mappings":"AAkBA,UAAU,kCAAkC,CAAC,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,GAAG,EAAE,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,GAAG,EAAE,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,GAAG,EAAE,OAAO,GAAG,EAAE,EAAE,QAAQ,GAAG,MAAM;IACpM,KAAK,OAAO,EAAE,OAAO,QAAQ,EAAE,2BAA2B,CAAC,KAAK,CAAC,GAAG,OAAO,QAAQ,EAAE,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,GAAG;QAAE,UAAU,CAAC,EAAE,QAAQ,CAAA;KAAE,GAAG,OAAO,CAAC;IACjK,CAAC,QAAQ,EAAE,OAAO,EAAE,KAAK,EAAE;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,KAAK,CAAA;KAAC,GAAG,OAAO,GAAG;QAAE,IAAI,CAAC,EAAE,GAAG,CAAC;QAAC,GAAG,CAAC,EAAE,GAAG,CAAA;KAAE,CAAC;IACtG,YAAY,CAAC,EAAE,QAAQ,CAAC;CAC3B;AAKD,QAAA,MAAM,gBAAgB;;kBAA+E,CAAC;AACpF,KAAK,gBAAgB,GAAG,YAAY,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAChE,eAAe,gBAAgB,CAAC"}

package/dist/components/workspace/__tests__/use-harness.svelte

@@ -0,0 +1,23 @@
+<script lang="ts">
+/**
+ * Provider + consumer in one component. The factory call sets context on
+ * this component; an immediate-child snippet then reads it via useToolsDock.
+ */
+import { defineToolsDock } from '../tools-dock/define-tools-dock.svelte.js';
+import { useToolsDock } from '../tools-dock/use-tools-dock.js';
+import type { ToolsDockApi } from '../types.js';
+
+interface Props {
+  onReady: (api: ToolsDockApi) => void;
+}
+
+const { onReady }: Props = $props();
+defineToolsDock({
+  tools: [{ id: 'demo', label: 'Demo', component: (() => null) as never }],
+});
+// useToolsDock reads from the same component init scope's context tree.
+const api = useToolsDock();
+// This harness intentionally snapshots the callback during setup.
+// svelte-ignore state_referenced_locally
+onReady(api);
+</script>

package/dist/components/workspace/__tests__/use-harness.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { ToolsDockApi } from '../types.js';
+interface Props {
+    onReady: (api: ToolsDockApi) => void;
+}
+declare const UseHarness: import("svelte").Component<Props, {}, "">;
+type UseHarness = ReturnType<typeof UseHarness>;
+export default UseHarness;
+//# sourceMappingURL=use-harness.svelte.d.ts.map

package/dist/components/workspace/__tests__/use-harness.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-harness.svelte.d.ts","sourceRoot":"","sources":["../../../../src/components/workspace/__tests__/use-harness.svelte.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAGhD,UAAU,KAAK;IACb,OAAO,EAAE,CAAC,GAAG,EAAE,YAAY,KAAK,IAAI,CAAC;CACtC;AAqBD,QAAA,MAAM,UAAU,2CAAwC,CAAC;AACzD,KAAK,UAAU,GAAG,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC;AAChD,eAAe,UAAU,CAAC"}

package/dist/components/workspace/__tests__/use-tools-dock.test.js

@@ -0,0 +1,33 @@
+/**
+ * Tests for useToolsDock.
+ */
+import { mount, unmount } from 'svelte';
+import { describe, expect, it } from 'vitest';
+import UseHarness from './use-harness.svelte';
+import OrphanHarness from './use-harness-orphan.svelte';
+describe('useToolsDock', () => {
+    it('returns the dock when called inside a <ToolsDock> provider', () => {
+        const target = document.createElement('div');
+        document.body.appendChild(target);
+        let observed = null;
+        const component = mount(UseHarness, {
+            target,
+            props: {
+                onReady: (api) => {
+                    observed = { isOpen: api.isOpen, activeTool: api.activeTool };
+                },
+            },
+        });
+        expect(observed).not.toBeNull();
+        expect(observed?.isOpen).toBe(false);
+        expect(observed?.activeTool).toBeNull();
+        unmount(component);
+        target.remove();
+    });
+    it('throws a clear error when called outside a provider', () => {
+        const target = document.createElement('div');
+        document.body.appendChild(target);
+        expect(() => mount(OrphanHarness, { target })).toThrow(/ToolsDock/);
+        target.remove();
+    });
+});

package/dist/components/workspace/__tests__/workspace-shell-bind-harness.svelte

@@ -0,0 +1,43 @@
+<script lang="ts">
+/**
+ * Test harness for `bind:mobileNavOpen` on `WorkspaceShell`.
+ *
+ * Exposes the bindable drawer state on the outer `state` object so tests
+ * can observe the consumer-visible value after every interaction. The
+ * `onReady` callback hands back a setter the test can use to drive the
+ * value externally — verifying the two-way binding really is two-way.
+ */
+import { createRawSnippet } from 'svelte';
+import WorkspaceShell from '../WorkspaceShell.svelte';
+
+interface Props {
+  initial?: boolean;
+  onReady?: (controls: {
+    setMobileNavOpen: (next: boolean) => void;
+    getMobileNavOpen: () => boolean;
+  }) => void;
+}
+
+const { initial = false, onReady }: Props = $props();
+
+// This harness intentionally snapshots the initial bindable value.
+// svelte-ignore state_referenced_locally
+let mobileNavOpen = $state(initial);
+
+const content = createRawSnippet(() => ({
+  render: () => '<span>content</span>',
+}));
+
+// This harness intentionally snapshots the callback during setup.
+// svelte-ignore state_referenced_locally
+onReady?.({
+  setMobileNavOpen: (next: boolean) => {
+    mobileNavOpen = next;
+  },
+  getMobileNavOpen: () => mobileNavOpen,
+});
+</script>
+
+<WorkspaceShell bind:mobileNavOpen>
+  {@render content()}
+</WorkspaceShell>

package/dist/components/workspace/__tests__/workspace-shell-bind-harness.svelte.d.ts

@@ -0,0 +1,11 @@
+interface Props {
+    initial?: boolean;
+    onReady?: (controls: {
+        setMobileNavOpen: (next: boolean) => void;
+        getMobileNavOpen: () => boolean;
+    }) => void;
+}
+declare const WorkspaceShellBindHarness: import("svelte").Component<Props, {}, "">;
+type WorkspaceShellBindHarness = ReturnType<typeof WorkspaceShellBindHarness>;
+export default WorkspaceShellBindHarness;
+//# sourceMappingURL=workspace-shell-bind-harness.svelte.d.ts.map

package/dist/components/workspace/__tests__/workspace-shell-bind-harness.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-shell-bind-harness.svelte.d.ts","sourceRoot":"","sources":["../../../../src/components/workspace/__tests__/workspace-shell-bind-harness.svelte.ts"],"names":[],"mappings":"AAeA,UAAU,KAAK;IACb,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,CAAC,QAAQ,EAAE;QACnB,gBAAgB,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;QAC1C,gBAAgB,EAAE,MAAM,OAAO,CAAC;KACjC,KAAK,IAAI,CAAC;CACZ;AAiCD,QAAA,MAAM,yBAAyB,2CAAwC,CAAC;AACxE,KAAK,yBAAyB,GAAG,UAAU,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC9E,eAAe,yBAAyB,CAAC"}

package/dist/components/workspace/breadcrumbs-helpers.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Pure helpers for breadcrumb derivation.
+ *
+ * Extracted so the path-walking logic can be unit-tested without rendering
+ * a Svelte component.
+ */
+import type { BreadcrumbItem, NavItem } from './types.js';
+/**
+ * Walk a nav tree depth-first and return the label of the item whose
+ * `href` matches exactly, or `null` if not found.
+ */
+export declare function findLabelInNav(items: NavItem[], href: string): string | null;
+/**
+ * Default label fallback for unknown segments: capitalize the first letter
+ * and turn dashes/underscores into spaces.
+ */
+export declare function capitalizeSegment(segment: string): string;
+export interface DeriveCrumbsOptions {
+    /** Optional first crumb (e.g., site identity). */
+    rootCrumb?: BreadcrumbItem;
+    /**
+     * Skip pathname segments until (and including) the given path is matched.
+     * Example: `startAfter: 'sites/foo'` ignores everything up through
+     * `/sites/foo` in the pathname.
+     */
+    startAfter?: string;
+    /** Fall back to capitalized segments for unmatched paths (default: true). */
+    capitalize?: boolean;
+}
+/**
+ * Derive a breadcrumb trail from a pathname + nav tree.
+ *
+ * Strategy:
+ *  1. Optionally prepend `rootCrumb`.
+ *  2. Split the pathname into segments.
+ *  3. If `startAfter` is set, locate its trailing segment in the
+ *     pathname and skip everything before/including it. The
+ *     `startAfter` value may include a leading slash or none and
+ *     may be a multi-segment path (e.g. `sites/foo`).
+ *  4. Walk the remaining segments, building cumulative paths; for
+ *     each, try to find a matching nav label, otherwise capitalize.
+ */
+export declare function deriveCrumbsFromNav(pathname: string, nav: NavItem[], options?: DeriveCrumbsOptions): BreadcrumbItem[];
+//# sourceMappingURL=breadcrumbs-helpers.d.ts.map

package/dist/components/workspace/breadcrumbs-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"breadcrumbs-helpers.d.ts","sourceRoot":"","sources":["../../../src/components/workspace/breadcrumbs-helpers.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE1D;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAS5E;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAIzD;AAED,MAAM,WAAW,mBAAmB;IAClC,kDAAkD;IAClD,SAAS,CAAC,EAAE,cAAc,CAAC;IAC3B;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,6EAA6E;IAC7E,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,OAAO,EAAE,EACd,OAAO,GAAE,mBAAwB,GAChC,cAAc,EAAE,CA+ClB"}