@happyvertical/smrt-svelte 0.53.1 → 0.53.3

package/dist/components/workspace/server/__tests__/compose-availability.test.js

@@ -1,383 +0,0 @@
-/**
- * Tests for the server-side dock availability gate composer
- * (happyvertical/smrt#1226 Phase 4c).
- *
- * Covers:
- *  - tools without `gates` are unconditionally included (back-compat)
- *  - single passing / failing gate
- *  - AND semantics across multiple gates
- *  - sync and async evaluators
- *  - unknown-prefix error message (loud-fail)
- *  - context pass-through
- *  - edge cases (empty arrays / maps)
- *  - label / badge passthrough into AvailableTool
- */
-import { describe, expect, it, vi } from 'vitest';
-import { composeDockAvailability } from '../compose-availability.js';
-const alwaysTrue = () => true;
-const alwaysFalse = () => false;
-const asyncTrue = async () => true;
-const asyncFalse = async () => false;
-describe('composeDockAvailability', () => {
-    it('includes tools without a `gates` field unconditionally', async () => {
-        const result = await composeDockAvailability({
-            tools: [{ id: 'chat', label: 'Chat' }],
-            context: {},
-            evaluators: {},
-        });
-        expect(result).toHaveLength(1);
-        expect(result[0]?.id).toBe('chat');
-    });
-    it('includes tools with an empty `gates` array unconditionally', async () => {
-        const result = await composeDockAvailability({
-            tools: [{ id: 'chat', label: 'Chat', gates: [] }],
-            context: {},
-            evaluators: {},
-        });
-        expect(result).toHaveLength(1);
-        expect(result[0]?.id).toBe('chat');
-    });
-    it('includes a tool whose single gate evaluates to true', async () => {
-        const result = await composeDockAvailability({
-            tools: [{ id: 'video', label: 'Video', gates: ['feature:video-tools'] }],
-            context: {},
-            evaluators: { feature: alwaysTrue },
-        });
-        expect(result).toHaveLength(1);
-        expect(result[0]?.id).toBe('video');
-    });
-    it('excludes a tool whose single gate evaluates to false', async () => {
-        const result = await composeDockAvailability({
-            tools: [{ id: 'video', label: 'Video', gates: ['feature:video-tools'] }],
-            context: {},
-            evaluators: { feature: alwaysFalse },
-        });
-        expect(result).toEqual([]);
-    });
-    it('requires ALL gates to pass (AND semantics)', async () => {
-        const result = await composeDockAvailability({
-            tools: [
-                {
-                    id: 'restricted',
-                    label: 'Restricted',
-                    gates: ['permission:foo', 'feature:bar'],
-                },
-            ],
-            context: {},
-            evaluators: { permission: alwaysTrue, feature: alwaysFalse },
-        });
-        expect(result).toEqual([]);
-    });
-    it('includes a tool only when EVERY gate passes', async () => {
-        const result = await composeDockAvailability({
-            tools: [
-                {
-                    id: 'allowed',
-                    label: 'Allowed',
-                    gates: ['permission:foo', 'feature:bar'],
-                },
-            ],
-            context: {},
-            evaluators: { permission: alwaysTrue, feature: asyncTrue },
-        });
-        expect(result).toHaveLength(1);
-        expect(result[0]?.id).toBe('allowed');
-    });
-    it('accepts sync evaluators that return a plain boolean', async () => {
-        const result = await composeDockAvailability({
-            tools: [{ id: 't', label: 'T', gates: ['x:y'] }],
-            context: {},
-            evaluators: { x: (_id, _ctx) => true },
-        });
-        expect(result).toHaveLength(1);
-    });
-    it('accepts async evaluators that return a Promise<boolean>', async () => {
-        const result = await composeDockAvailability({
-            tools: [{ id: 't', label: 'T', gates: ['x:y'] }],
-            context: {},
-            evaluators: { x: async () => true },
-        });
-        expect(result).toHaveLength(1);
-    });
-    it('throws with a clear message when a gate prefix has no evaluator', async () => {
-        await expect(composeDockAvailability({
-            tools: [
-                { id: 'video', label: 'Video', gates: ['feature:video-tools'] },
-            ],
-            context: {},
-            evaluators: { permission: alwaysTrue },
-        })).rejects.toThrow(/No evaluator registered for gate prefix "feature".*tool "video".*gate "feature:video-tools".*Available prefixes: permission/);
-    });
-    it('reports `(none)` for available prefixes when the evaluators map is empty', async () => {
-        await expect(composeDockAvailability({
-            tools: [
-                { id: 'video', label: 'Video', gates: ['feature:video-tools'] },
-            ],
-            context: {},
-            evaluators: {},
-        })).rejects.toThrow(/Available prefixes: \(none\)/);
-    });
-    it('passes the supplied `context` through to each evaluator', async () => {
-        const ctx = { userId: 'u-1', tenantId: 't-1' };
-        const permission = vi.fn(() => true);
-        const feature = vi.fn(() => true);
-        await composeDockAvailability({
-            tools: [
-                {
-                    id: 'tool',
-                    label: 'Tool',
-                    gates: ['permission:articles.publish', 'feature:video-tools'],
-                },
-            ],
-            context: ctx,
-            evaluators: { permission, feature },
-        });
-        expect(permission).toHaveBeenCalledWith('permission:articles.publish', ctx);
-        expect(feature).toHaveBeenCalledWith('feature:video-tools', ctx);
-    });
-    it('returns an empty array for an empty `tools` input', async () => {
-        const result = await composeDockAvailability({
-            tools: [],
-            context: {},
-            evaluators: {},
-        });
-        expect(result).toEqual([]);
-    });
-    it('handles an empty `evaluators` map fine when no tools have gates', async () => {
-        const result = await composeDockAvailability({
-            tools: [
-                { id: 'a', label: 'A' },
-                { id: 'b', label: 'B' },
-            ],
-            context: {},
-            evaluators: {},
-        });
-        expect(result.map((t) => t.id)).toEqual(['a', 'b']);
-    });
-    it('passes through `label` and `badge` from the tool def to AvailableTool', async () => {
-        const tools = [
-            { id: 'inbox', label: 'Inbox', badge: 3 },
-            { id: 'tasks', label: 'Tasks', badge: 'new' },
-            { id: 'plain', label: 'Plain' }, // no badge → omitted in output
-        ];
-        const result = await composeDockAvailability({
-            tools,
-            context: {},
-            evaluators: {},
-        });
-        expect(result).toEqual([
-            { id: 'inbox', label: 'Inbox', badge: 3 },
-            { id: 'tasks', label: 'Tasks', badge: 'new' },
-            { id: 'plain', label: 'Plain' },
-        ]);
-    });
-    it('omits a missing `label` from the AvailableTool result (lets the dock fall back)', async () => {
-        const result = await composeDockAvailability({
-            tools: [{ id: 'no-label' }],
-            context: {},
-            evaluators: {},
-        });
-        // No `label` key at all — `defineToolsDock.applyAvailability` falls
-        // back to the registered ToolDef metadata.
-        expect(result[0]).toEqual({ id: 'no-label' });
-        expect(result[0]).not.toHaveProperty('label');
-        expect(result[0]).not.toHaveProperty('badge');
-    });
-    it('omits `badge` when the tool def has no badge (no implicit clear)', async () => {
-        const result = await composeDockAvailability({
-            tools: [{ id: 'chat', label: 'Chat', gates: [] }],
-            context: {},
-            evaluators: {},
-        });
-        // The dock treats `badge: null` as an explicit clear of the
-        // registered default badge. Absence must remain absence.
-        expect(result[0]).toEqual({ id: 'chat', label: 'Chat' });
-        expect(result[0]).not.toHaveProperty('badge');
-    });
-    it('preserves explicit `badge: null` when the caller does set it', async () => {
-        const result = await composeDockAvailability({
-            tools: [{ id: 'reset', label: 'Reset', badge: null }],
-            context: {},
-            evaluators: {},
-        });
-        expect(result[0]).toEqual({ id: 'reset', label: 'Reset', badge: null });
-    });
-    it('filters a mixed input correctly (gated + ungated, pass + fail)', async () => {
-        const result = await composeDockAvailability({
-            tools: [
-                { id: 'always', label: 'Always' },
-                { id: 'allowed', label: 'Allowed', gates: ['permission:foo'] },
-                { id: 'denied', label: 'Denied', gates: ['permission:bar'] },
-                { id: 'flagged', label: 'Flagged', gates: ['feature:on'] },
-            ],
-            context: { userId: 'u-1' },
-            evaluators: {
-                permission: async (id) => id === 'permission:foo',
-                feature: asyncTrue,
-            },
-        });
-        expect(result.map((t) => t.id)).toEqual(['always', 'allowed', 'flagged']);
-    });
-    it('still throws on unknown prefix even when other gates on the same tool would have passed', async () => {
-        await expect(composeDockAvailability({
-            tools: [
-                {
-                    id: 'mixed',
-                    label: 'Mixed',
-                    gates: ['permission:ok', 'mystery:??'],
-                },
-            ],
-            context: {},
-            evaluators: { permission: alwaysTrue },
-        })).rejects.toThrow(/gate "mystery:\?\?"/);
-    });
-    it('treats async evaluator rejections as errors (does not swallow)', async () => {
-        await expect(composeDockAvailability({
-            tools: [{ id: 't', label: 'T', gates: ['boom:bar'] }],
-            context: {},
-            evaluators: {
-                boom: async () => {
-                    throw new Error('evaluator exploded');
-                },
-            },
-        })).rejects.toThrow('evaluator exploded');
-    });
-    it('respects falsy results from async evaluators (excludes the tool)', async () => {
-        const result = await composeDockAvailability({
-            tools: [{ id: 't', label: 'T', gates: ['x:y'] }],
-            context: {},
-            evaluators: { x: asyncFalse },
-        });
-        expect(result).toEqual([]);
-    });
-    // Regression: a gate prefix that names an inherited `Object.prototype`
-    // property (e.g. `constructor`, `toString`, `hasOwnProperty`, `valueOf`,
-    // `__proto__`) MUST NOT bypass the unknown-prefix fail-loud path. Prior
-    // to the fix, `evaluators[prefix]` resolved to a built-in function and
-    // got invoked, returning a truthy value and silently passing the gate.
-    it('throws on prototype-key gate prefixes (constructor, toString, hasOwnProperty, valueOf, __proto__)', async () => {
-        const evaluators = { permission: () => true };
-        for (const prefix of [
-            'constructor',
-            'toString',
-            'hasOwnProperty',
-            'valueOf',
-            '__proto__',
-        ]) {
-            await expect(composeDockAvailability({
-                tools: [{ id: 'x', label: 'X', gates: [`${prefix}:any`] }],
-                context: {},
-                evaluators,
-            })).rejects.toThrow(/No evaluator registered for gate prefix/);
-        }
-    });
-    it('throws when an evaluator entry is not a function', async () => {
-        await expect(composeDockAvailability({
-            tools: [{ id: 'x', label: 'X', gates: ['permission:any'] }],
-            context: {},
-            evaluators: {
-                // Intentional non-function evaluator — should fail loud.
-                permission: 'not-a-function',
-            },
-        })).rejects.toThrow(/No evaluator registered/);
-    });
-    // Regression for the TCtx generic parameterization (issue 1242 fix #5).
-    // Verifies the typed-context flow compiles end-to-end: the evaluator
-    // receives a typed `ctx` (string fields, not `unknown`) without a cast.
-    it('preserves the caller-supplied context type through to evaluators (TCtx generic)', async () => {
-        let observedUserId;
-        let observedTenantId;
-        const result = await composeDockAvailability({
-            tools: [{ id: 't', label: 'T', gates: ['permission:articles.publish'] }],
-            context: { userId: 'u-1', tenantId: 't-1' },
-            evaluators: {
-                permission: (gateId, ctx) => {
-                    // No cast required — ctx.userId and ctx.tenantId are typed string.
-                    observedUserId = ctx.userId;
-                    observedTenantId = ctx.tenantId;
-                    const [, slug] = gateId.split(':', 2);
-                    return slug === 'articles.publish';
-                },
-            },
-        });
-        expect(result).toHaveLength(1);
-        expect(observedUserId).toBe('u-1');
-        expect(observedTenantId).toBe('t-1');
-    });
-    // Regression: an interface-style context (no string index signature) must
-    // be accepted by `TCtx`. The round-1 fixup parameterized
-    // `TCtx extends Record<string, unknown>`, which rejected interfaces under
-    // strict TS — the same trap we hit with `TActions` in #1239. The
-    // self-mapped constraint `{ [K in keyof TCtx]: unknown }` accepts
-    // interfaces without forcing the consumer to add an index signature.
-    //
-    // The compile-time guard lives in
-    // `./__tests__/typed-context-fixture/typed-context.ts` — see the JSDoc
-    // there. The runtime check below confirms the same interface-style
-    // context round-trips through evaluators at runtime.
-    it('accepts an interface-style TCtx (no string index signature)', async () => {
-        let observedUserId;
-        const result = await composeDockAvailability({
-            tools: [{ id: 't', label: 'T', gates: ['permission:any'] }],
-            context: { userId: 'u-1', tenantId: 't-1' },
-            evaluators: {
-                permission: (_gateId, ctx) => {
-                    // No cast — ctx.userId is typed string.
-                    observedUserId = ctx.userId;
-                    return true;
-                },
-            },
-        });
-        expect(result).toHaveLength(1);
-        expect(observedUserId).toBe('u-1');
-    });
-    // Regression for fix #2 of round-3: `.every(Boolean)` fails OPEN for
-    // truthy non-booleans. `Boolean('false')`, `Boolean({})`, `Boolean([])`
-    // are all true, so an untyped evaluator returning a wrapped object, a
-    // sentinel string, or a number would silently grant access. The composer
-    // now uses strict `=== true`.
-    it('fails closed on truthy non-boolean evaluator returns', async () => {
-        // Evaluators MUST return boolean per the type, but consumers in plain
-        // JS or with untyped wrappers can slip non-boolean returns through.
-        // Verify that truthy non-booleans don't grant access.
-        const cases = [
-            {
-                id: 'string-true',
-                evaluator: () => 'true',
-            },
-            {
-                id: 'object',
-                evaluator: () => ({ allowed: false }),
-            },
-            {
-                id: 'array',
-                evaluator: () => [],
-            },
-            {
-                id: 'number-1',
-                evaluator: () => 1,
-            },
-            {
-                id: 'falsestring',
-                evaluator: () => 'false',
-            },
-        ];
-        for (const { id, evaluator } of cases) {
-            const result = await composeDockAvailability({
-                tools: [{ id, label: id, gates: ['permission:any'] }],
-                context: {},
-                evaluators: { permission: evaluator },
-            });
-            // fail-closed: gate doesn't pass
-            expect(result).toEqual([]);
-        }
-    });
-    it('passes only on literal `true` (not truthy values)', async () => {
-        const result = await composeDockAvailability({
-            tools: [{ id: 'pass-true', label: 'Pass', gates: ['permission:any'] }],
-            context: {},
-            evaluators: { permission: () => true },
-        });
-        expect(result).toEqual([{ id: 'pass-true', label: 'Pass' }]);
-    });
-});

package/dist/components/workspace/server/__tests__/typed-context-fixture.d.ts

@@ -1,78 +0,0 @@
-/**
- * Compile-time regression fixture for the `TCtx` generic on
- * `composeDockAvailability` / `ComposeDockAvailabilityOptions` /
- * `GateEvaluator`.
- *
- * This is the contract round-3 of PR #1242 is restoring:
- *
- *   - `TCtx` must accept an INTERFACE (no string index signature). The
- *     round-1 fixup tightened the constraint to
- *     `TCtx extends Record<string, unknown>`, which silently rejected
- *     interface-style contexts — the same trap Copilot caught with
- *     `TActions` in PR #1239. The constraint is now a self-mapped
- *     `{ [K in keyof TCtx]: unknown }` (matching the `TActions` pattern in
- *     `../../types.ts`).
- *
- *   - The default `TCtx = GateEvaluationContext` must keep existing
- *     untyped call sites compiling unchanged.
- *
- *   - The factory's `<TCtx>` generic must flow through to each evaluator
- *     so `ctx.fieldName` is typed without a cast at the evaluator call
- *     site.
- *
- * Lives in a `.ts` file (NOT `.test.ts`) so:
- *   - `tsc --noEmit` (the package's `typecheck` script, run in CI via
- *     `pnpm turbo run typecheck`) does include it — the package's
- *     `tsconfig.svelte.json` includes `src/** /*.ts` and excludes only
- *     `**\/*.test.ts` and `**\/*.spec.ts`.
- *   - Vitest does NOT execute it (no `.test.ts` suffix), so the
- *     `_assertInterfaceTCtx*` symbols below never run — their bodies must
- *     just compile.
- *
- * Mirrors the same pattern as
- * `../../__tests__/typed-tool-fixture/register-typed-tool.ts` (PR #1239).
- */
-import type { ComposeDockAvailabilityOptions, GateEvaluator } from '../types.js';
-/**
- * Interface-style context — no string index signature. Under a bare
- * `Record<string, unknown>` constraint this fails to satisfy `TCtx`
- * (TS2344). Under the self-mapped `{ [K in keyof TCtx]: unknown }`
- * constraint it's accepted.
- */
-interface MyInterfaceContext {
-    userId: string;
-    tenantId: string;
-}
-/**
- * Type-only assertion: an `Options` literal parameterized over an
- * interface-style context must compile, and the evaluator must receive a
- * typed `ctx` (no cast) with the consumer's field types.
- *
- * If `TCtx` ever tightens back to `Record<string, unknown>`, this
- * declaration fails with TS2344 ("Type 'MyInterfaceContext' does not
- * satisfy the constraint 'Record<string, unknown>'").
- */
-export declare const _assertInterfaceTCtxOptions: ComposeDockAvailabilityOptions<MyInterfaceContext>;
-/**
- * Type-only assertion: `GateEvaluator<MyInterfaceContext>` accepts an
- * interface. Same regression as above, but exercised through the
- * `GateEvaluator` alias directly (which `ComposeDockAvailabilityOptions`
- * indexes into via `evaluators`).
- */
-export declare const _assertInterfaceTCtxEvaluator: GateEvaluator<MyInterfaceContext>;
-/**
- * Type-only assertion: the `composeDockAvailability<TCtx>` factory
- * accepts an interface-style `TCtx` and threads it through to evaluators
- * without erasure. Never called at runtime — its body just has to
- * compile.
- */
-export declare function _assertInterfaceTCtxFactoryFlow(): Promise<void>;
-/**
- * Type-only assertion: the untyped (back-compat) call site must still
- * compile with no generic argument and resolve `TCtx` to the default
- * `GateEvaluationContext` (`Record<string, unknown>`). If the default
- * ever drifted, every existing untyped consumer would break.
- */
-export declare function _assertUntypedDefaultTCtx(): Promise<void>;
-export {};
-//# sourceMappingURL=typed-context-fixture.d.ts.map

package/dist/components/workspace/server/__tests__/typed-context-fixture.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"typed-context-fixture.d.ts","sourceRoot":"","sources":["../../../../../src/components/workspace/server/__tests__/typed-context-fixture.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAGH,OAAO,KAAK,EACV,8BAA8B,EAG9B,aAAa,EACd,MAAM,aAAa,CAAC;AAErB;;;;;GAKG;AACH,UAAU,kBAAkB;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,2BAA2B,EAAE,8BAA8B,CAAC,kBAAkB,CAYxF,CAAC;AAEJ;;;;;GAKG;AACH,eAAO,MAAM,6BAA6B,EAAE,aAAa,CACvD,kBAAkB,CAInB,CAAC;AAEF;;;;;GAKG;AACH,wBAAsB,+BAA+B,IAAI,OAAO,CAAC,IAAI,CAAC,CAiBrE;AAED;;;;;GAKG;AACH,wBAAsB,yBAAyB,IAAI,OAAO,CAAC,IAAI,CAAC,CAO/D"}

package/dist/components/workspace/server/__tests__/typed-context-fixture.js

@@ -1,104 +0,0 @@
-/**
- * Compile-time regression fixture for the `TCtx` generic on
- * `composeDockAvailability` / `ComposeDockAvailabilityOptions` /
- * `GateEvaluator`.
- *
- * This is the contract round-3 of PR #1242 is restoring:
- *
- *   - `TCtx` must accept an INTERFACE (no string index signature). The
- *     round-1 fixup tightened the constraint to
- *     `TCtx extends Record<string, unknown>`, which silently rejected
- *     interface-style contexts — the same trap Copilot caught with
- *     `TActions` in PR #1239. The constraint is now a self-mapped
- *     `{ [K in keyof TCtx]: unknown }` (matching the `TActions` pattern in
- *     `../../types.ts`).
- *
- *   - The default `TCtx = GateEvaluationContext` must keep existing
- *     untyped call sites compiling unchanged.
- *
- *   - The factory's `<TCtx>` generic must flow through to each evaluator
- *     so `ctx.fieldName` is typed without a cast at the evaluator call
- *     site.
- *
- * Lives in a `.ts` file (NOT `.test.ts`) so:
- *   - `tsc --noEmit` (the package's `typecheck` script, run in CI via
- *     `pnpm turbo run typecheck`) does include it — the package's
- *     `tsconfig.svelte.json` includes `src/** /*.ts` and excludes only
- *     `**\/*.test.ts` and `**\/*.spec.ts`.
- *   - Vitest does NOT execute it (no `.test.ts` suffix), so the
- *     `_assertInterfaceTCtx*` symbols below never run — their bodies must
- *     just compile.
- *
- * Mirrors the same pattern as
- * `../../__tests__/typed-tool-fixture/register-typed-tool.ts` (PR #1239).
- */
-import { composeDockAvailability } from '../compose-availability.js';
-/**
- * Type-only assertion: an `Options` literal parameterized over an
- * interface-style context must compile, and the evaluator must receive a
- * typed `ctx` (no cast) with the consumer's field types.
- *
- * If `TCtx` ever tightens back to `Record<string, unknown>`, this
- * declaration fails with TS2344 ("Type 'MyInterfaceContext' does not
- * satisfy the constraint 'Record<string, unknown>'").
- */
-export const _assertInterfaceTCtxOptions = {
-    tools: [],
-    context: { userId: 'u-1', tenantId: 't-1' },
-    evaluators: {
-        permission: (gateId, ctx) => {
-            // No cast required — ctx.userId / ctx.tenantId are typed `string`.
-            const _userId = ctx.userId;
-            const _tenantId = ctx.tenantId;
-            return gateId.startsWith('permission:');
-        },
-    },
-};
-/**
- * Type-only assertion: `GateEvaluator<MyInterfaceContext>` accepts an
- * interface. Same regression as above, but exercised through the
- * `GateEvaluator` alias directly (which `ComposeDockAvailabilityOptions`
- * indexes into via `evaluators`).
- */
-export const _assertInterfaceTCtxEvaluator = (gateId, ctx) => {
-    const _ = ctx.userId;
-    return gateId === 'permission:any';
-};
-/**
- * Type-only assertion: the `composeDockAvailability<TCtx>` factory
- * accepts an interface-style `TCtx` and threads it through to evaluators
- * without erasure. Never called at runtime — its body just has to
- * compile.
- */
-export async function _assertInterfaceTCtxFactoryFlow() {
-    const tools = [
-        { id: 't', label: 'T', gates: ['permission:any'] },
-    ];
-    await composeDockAvailability({
-        tools,
-        context: { userId: 'u-1', tenantId: 't-1' },
-        evaluators: {
-            permission: (_gateId, ctx) => {
-                // TYPED: ctx.userId is `string`, not `unknown`. If the factory
-                // dropped its generic on the evaluator signature, the next line
-                // would only compile as `unknown`.
-                const _userId = ctx.userId;
-                return true;
-            },
-        },
-    });
-}
-/**
- * Type-only assertion: the untyped (back-compat) call site must still
- * compile with no generic argument and resolve `TCtx` to the default
- * `GateEvaluationContext` (`Record<string, unknown>`). If the default
- * ever drifted, every existing untyped consumer would break.
- */
-export async function _assertUntypedDefaultTCtx() {
-    const ctx = { foo: 'bar' };
-    await composeDockAvailability({
-        tools: [{ id: 't', label: 'T' }],
-        context: ctx,
-        evaluators: {},
-    });
-}

package/dist/hooks/__tests__/stt-consumer.fixture.svelte

@@ -1,25 +0,0 @@
-<script lang="ts">
-/**
- * Test consumer that calls the real `useSTT()` hook so its `onDestroy`
- * per-hook ownership logic (R4) runs when this component unmounts.
- */
-import { type UseSTTReturn, useSTT } from '../useSTT.svelte.js';
-
-interface Props {
-  /** Hand the live hook back to the test so it can call start()/stop(). */
-  onReady?: (stt: UseSTTReturn) => void;
-  /** If true, start a listening session as soon as this consumer mounts. */
-  autoStart?: boolean;
-}
-
-const { onReady, autoStart = false }: Props = $props();
-
-const stt = useSTT();
-// This fixture intentionally snapshots props during setup (test-only).
-// svelte-ignore state_referenced_locally
-onReady?.(stt);
-// svelte-ignore state_referenced_locally
-if (autoStart) {
-  void stt.start();
-}
-</script>

package/dist/hooks/__tests__/stt-consumer.fixture.svelte.d.ts

@@ -1,15 +0,0 @@
-/**
- * Test consumer that calls the real `useSTT()` hook so its `onDestroy`
- * per-hook ownership logic (R4) runs when this component unmounts.
- */
-import { type UseSTTReturn } from '../useSTT.svelte.js';
-interface Props {
-    /** Hand the live hook back to the test so it can call start()/stop(). */
-    onReady?: (stt: UseSTTReturn) => void;
-    /** If true, start a listening session as soon as this consumer mounts. */
-    autoStart?: boolean;
-}
-declare const SttConsumer: import("svelte").Component<Props, {}, "">;
-type SttConsumer = ReturnType<typeof SttConsumer>;
-export default SttConsumer;
-//# sourceMappingURL=stt-consumer.fixture.svelte.d.ts.map

package/dist/hooks/__tests__/stt-consumer.fixture.svelte.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stt-consumer.fixture.svelte.d.ts","sourceRoot":"","sources":["../../../src/hooks/__tests__/stt-consumer.fixture.svelte.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,OAAO,EAAE,KAAK,YAAY,EAAU,MAAM,qBAAqB,CAAC;AAGhE,UAAU,KAAK;IACb,yEAAyE;IACzE,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,YAAY,KAAK,IAAI,CAAC;IACtC,0EAA0E;IAC1E,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAoBD,QAAA,MAAM,WAAW,2CAAwC,CAAC;AAC1D,KAAK,WAAW,GAAG,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC;AAClD,eAAe,WAAW,CAAC"}

package/dist/hooks/__tests__/stt-ownership-harness.svelte

@@ -1,42 +0,0 @@
-<script lang="ts">
-/**
- * R4 harness: sets a fake app-state manager on context, then mounts/unmounts
- * `useSTT()` consumers so the test can prove per-hook ownership — unmounting a
- * consumer that did NOT start listening must not stop the shared singleton.
- */
-import type { SmrtAppStateManager } from '../../state/app-state.svelte.js';
-import { setAppStateContext } from '../../state/context.js';
-import type { UseSTTReturn } from '../useSTT.svelte.js';
-import SttConsumer from './stt-consumer.fixture.svelte';
-
-interface Props {
-  manager: SmrtAppStateManager;
-  showA?: boolean;
-  showB?: boolean;
-  onReadyA?: (stt: UseSTTReturn) => void;
-  onReadyB?: (stt: UseSTTReturn) => void;
-  autoStartA?: boolean;
-  autoStartB?: boolean;
-}
-
-const {
-  manager,
-  showA = true,
-  showB = true,
-  onReadyA,
-  onReadyB,
-  autoStartA = false,
-  autoStartB = false,
-}: Props = $props();
-
-// Context is set once during setup with the initial manager (test-only).
-// svelte-ignore state_referenced_locally
-setAppStateContext(manager);
-</script>
-
-{#if showA}
-  <SttConsumer onReady={onReadyA} autoStart={autoStartA} />
-{/if}
-{#if showB}
-  <SttConsumer onReady={onReadyB} autoStart={autoStartB} />
-{/if}

package/dist/hooks/__tests__/stt-ownership-harness.svelte.d.ts

@@ -1,20 +0,0 @@
-/**
- * R4 harness: sets a fake app-state manager on context, then mounts/unmounts
- * `useSTT()` consumers so the test can prove per-hook ownership — unmounting a
- * consumer that did NOT start listening must not stop the shared singleton.
- */
-import type { SmrtAppStateManager } from '../../state/app-state.svelte.js';
-import type { UseSTTReturn } from '../useSTT.svelte.js';
-interface Props {
-    manager: SmrtAppStateManager;
-    showA?: boolean;
-    showB?: boolean;
-    onReadyA?: (stt: UseSTTReturn) => void;
-    onReadyB?: (stt: UseSTTReturn) => void;
-    autoStartA?: boolean;
-    autoStartB?: boolean;
-}
-declare const SttOwnershipHarness: import("svelte").Component<Props, {}, "">;
-type SttOwnershipHarness = ReturnType<typeof SttOwnershipHarness>;
-export default SttOwnershipHarness;
-//# sourceMappingURL=stt-ownership-harness.svelte.d.ts.map