@happyvertical/smrt-svelte 0.30.0

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

@@ -0,0 +1,383 @@
+/**
+ * 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

@@ -0,0 +1,78 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,104 @@
+/**
+ * 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/components/workspace/server/compose-availability.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Server-side dock availability gate composer.
+ *
+ * Consumer's `fetchAvailability` endpoint calls `composeDockAvailability`
+ * with the registered tools, a caller-supplied context, and a map of
+ * gate evaluators (typically wrapping `PermissionResolver` from
+ * smrt-users and `FeatureResolver` from smrt-features). It returns the
+ * filtered `AvailableTool[]` the dock's client-side `fetchAvailability`
+ * resolves to.
+ *
+ * Server-side by design: no Svelte / DOM imports, no client-only state.
+ * See happyvertical/smrt#1226 (Phase 4c) and #1235 for the registry
+ * audit that motivated this server-first pattern.
+ */
+import type { AvailableTool } from '../types.js';
+import type { ComposeDockAvailabilityOptions, GateEvaluationContext } from './types.js';
+/**
+ * Compose the `availableTools` list for a tools dock by evaluating each
+ * tool's `gates` against the provided evaluators. Tools where ALL gates
+ * resolve to `true` are included (AND semantics).
+ *
+ * Tools without `gates` (or with an empty `gates` array) are
+ * unconditionally included — gating is opt-in, existing tool definitions
+ * keep working.
+ *
+ * Throws if a gate's prefix doesn't match any registered evaluator —
+ * misconfiguration should fail loudly, not silently leak tools to users
+ * who shouldn't see them.
+ *
+ * Gate evaluation is parallel within a tool and across tools (`Promise.all`
+ * fan-out), so a slow evaluator on one gate doesn't block unrelated tools.
+ *
+ * @example
+ * ```ts
+ * import {
+ *   composeDockAvailability,
+ *   type GateEvaluationContext,
+ * } from '@happyvertical/smrt-svelte/workspace/server';
+ * import { PermissionResolver } from '@happyvertical/smrt-users';
+ * import { FeatureResolver } from '@happyvertical/smrt-features';
+ *
+ * // Caller narrows the context shape so evaluators get typed access
+ * // without casts:
+ * interface MyContext extends GateEvaluationContext {
+ *   userId: string;
+ *   tenantId: string;
+ * }
+ *
+ * const available = await composeDockAvailability<MyContext>({
+ *   tools: [
+ *     { id: 'governance', label: 'Claim Audit', gates: ['permission:content.governance.view'] },
+ *     { id: 'video-gen',  label: 'Video',       gates: ['feature:video-tools'] },
+ *     { id: 'chat',       label: 'Chat' }, // no gates → always visible
+ *   ],
+ *   context: { userId: 'user-1', tenantId: 'tenant-1' },
+ *   evaluators: {
+ *     permission: async (gateId, ctx) => {
+ *       const [, slug] = gateId.split(':', 2);
+ *       return permissionResolver.hasPermission(ctx.userId, ctx.tenantId, slug);
+ *     },
+ *     feature: async (gateId, ctx) => {
+ *       const [, key] = gateId.split(':', 2);
+ *       return featureResolver.isEnabled(key, { tenantId: ctx.tenantId });
+ *     },
+ *   },
+ * });
+ * // → AvailableTool[] filtered by gates
+ * ```
+ */
+export declare function composeDockAvailability<TCtx extends {
+    [K in keyof TCtx]: unknown;
+} = GateEvaluationContext>(options: ComposeDockAvailabilityOptions<TCtx>): Promise<AvailableTool[]>;
+//# sourceMappingURL=compose-availability.d.ts.map

package/dist/components/workspace/server/compose-availability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compose-availability.d.ts","sourceRoot":"","sources":["../../../../src/components/workspace/server/compose-availability.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,KAAK,EACV,8BAA8B,EAC9B,qBAAqB,EACtB,MAAM,YAAY,CAAC;AAEpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,wBAAsB,uBAAuB,CAC3C,IAAI,SAAS;KAAG,CAAC,IAAI,MAAM,IAAI,GAAG,OAAO;CAAE,GAAG,qBAAqB,EACnE,OAAO,EAAE,8BAA8B,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC,CAuDzE"}