@startsimpli/funnels 0.4.13 → 0.4.15

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@startsimpli/funnels",
-  "version": "0.4.13",
+  "version": "0.4.15",
   "description": "Brutally generic filtering pipeline package for any Simpli product",
   "type": "module",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
   "exports": {
     ".": "./src/index.ts",
+    "./page": "./src/page/index.ts",
     "./core": "./src/core/index.ts",
     "./components": "./src/components/index.ts",
     "./hooks": "./src/hooks/index.ts",
@@ -45,22 +46,11 @@
     "url": "https://github.com/qosha1/start-simpli/issues"
   },
   "homepage": "https://github.com/qosha1/start-simpli/tree/main/packages/funnels#readme",
-  "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
-    "type-check": "tsc --noEmit",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage",
-    "clean": "rm -rf dist",
-    "storybook": "storybook dev -p 6006",
-    "build-storybook": "storybook build",
-    "storybook:ci": "storybook build --test"
-  },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0",
     "react-dom": "^18.0.0 || ^19.0.0",
-    "zustand": "^4.0.0 || ^5.0.0"
+    "zustand": "^4.0.0 || ^5.0.0",
+    "@startsimpli/ui": "^0.4.125"
   },
   "devDependencies": {
     "@chromatic-com/storybook": "^5.1.2",
@@ -87,12 +77,30 @@
     "tsup": "^8.5.1",
     "typescript": "^6.0.3",
     "vitest": "^4.1.5",
-    "zustand": "^5.0.12"
+    "zustand": "^5.0.12",
+    "@startsimpli/ui": "0.4.125"
   },
   "dependencies": {
     "@dnd-kit/core": "^6.3.1",
     "@dnd-kit/sortable": "^8.0.0",
     "@dnd-kit/utilities": "^3.2.2",
     "@xyflow/react": "^12.10.2"
+  },
+  "peerDependenciesMeta": {
+    "@startsimpli/ui": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "type-check": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "clean": "rm -rf dist",
+    "storybook": "storybook dev -p 6006",
+    "build-storybook": "storybook build",
+    "storybook:ci": "storybook build --test"
   }
-}
+}

package/src/api/client.paths.test.ts

@@ -0,0 +1,175 @@
+/**
+ * FunnelApiClient against an injected path family (bd startsim-pxzlf).
+ *
+ * client.test.ts covers the default (central) family and the error handling.
+ * This file covers the part that was impossible before: pointing the SAME
+ * client at the control-plane route, a tenant proxy, or a fork's own mount.
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { FunnelApiClient } from './client';
+import { createFunnelPaths, foundryTenantFunnelPaths } from './paths';
+import type { ApiAdapter } from './adapter';
+
+class RecordingAdapter implements ApiAdapter {
+  public calls: { method: string; url: string; data?: unknown; params?: unknown }[] = [];
+  public nextResponse: unknown = {};
+
+  async get<T>(url: string, params?: Record<string, unknown>): Promise<T> {
+    this.calls.push({ method: 'GET', url, params });
+    return this.nextResponse as T;
+  }
+  async post<T>(url: string, data: unknown): Promise<T> {
+    this.calls.push({ method: 'POST', url, data });
+    return this.nextResponse as T;
+  }
+  async patch<T>(url: string, data: unknown): Promise<T> {
+    this.calls.push({ method: 'PATCH', url, data });
+    return this.nextResponse as T;
+  }
+  async delete<T>(url: string): Promise<T> {
+    this.calls.push({ method: 'DELETE', url });
+    return this.nextResponse as T;
+  }
+  get lastUrl(): string {
+    return this.calls[this.calls.length - 1]?.url ?? '';
+  }
+}
+
+describe('FunnelApiClient path injection', () => {
+  let adapter: RecordingAdapter;
+
+  beforeEach(() => {
+    adapter = new RecordingAdapter();
+  });
+
+  it('keeps the central family when no paths are injected — the old constructor still works', async () => {
+    const client = new FunnelApiClient(adapter, 'https://api.startsimpli.com');
+    await client.listFunnels();
+    expect(adapter.lastUrl).toBe('https://api.startsimpli.com/api/v1/funnels/');
+    await client.getFunnelRun('r1');
+    expect(adapter.lastUrl).toBe('https://api.startsimpli.com/api/v1/funnel-runs/r1/');
+  });
+
+  it('talks to a foundry control-plane route when given that family', async () => {
+    const client = new FunnelApiClient(adapter, '', foundryTenantFunnelPaths('acme'));
+
+    await client.listFunnels({ status: 'active' });
+    expect(adapter.lastUrl).toBe('/api/v1/foundry/tenants/acme/funnels/');
+
+    await client.getFunnel('f1');
+    expect(adapter.lastUrl).toBe('/api/v1/foundry/tenants/acme/funnels/f1/');
+
+    // Triggering is a POST to the run COLLECTION on this surface: the control
+    // plane mounts ONE `funnel_runs` action where GET lists and POST triggers.
+    await client.runFunnel('f1');
+    expect(adapter.lastUrl).toBe('/api/v1/foundry/tenants/acme/funnels/f1/runs/');
+
+    await client.getFunnelRuns('f1');
+    expect(adapter.lastUrl).toBe('/api/v1/foundry/tenants/acme/funnels/f1/runs/');
+  });
+
+  it('addresses a run on the control plane’s sibling funnel-runs collection', async () => {
+    // Corrected in bd startsim-em5mn. The action is
+    // `funnel-runs/(?P<run_id>[^/.]+)/results` — a SIBLING of `funnels/`,
+    // because `runs/` on FoundryViewSet is already the foundry's own build
+    // history. The previous `nestRuns: true` built `funnels/f1/runs/r1/…`,
+    // which resolves to no route at all (verified against prod 2026-09-18).
+    const client = new FunnelApiClient(adapter, '', foundryTenantFunnelPaths('acme'));
+    await client.getFunnelResults('r1', { funnelId: 'f1' });
+    expect(adapter.lastUrl).toBe('/api/v1/foundry/tenants/acme/funnel-runs/r1/results/');
+    // ...and the funnel id is not needed to address it.
+    await client.getFunnelResults('r1');
+    expect(adapter.lastUrl).toBe('/api/v1/foundry/tenants/acme/funnel-runs/r1/results/');
+  });
+
+  it('carries the stage-reached filter through as a query param', async () => {
+    const client = new FunnelApiClient(adapter, '', foundryTenantFunnelPaths('acme'));
+    await client.getFunnelResults('r1', { stage: 's1', matched: false, funnelId: 'f1' });
+    // `funnelId` addresses the URL and must not leak into the query string.
+    expect(adapter.calls.at(-1)!.params).toEqual({ stage: 's1', matched: false });
+  });
+
+  it('talks through a tenant proxy prefix', async () => {
+    const client = new FunnelApiClient(
+      adapter,
+      '',
+      createFunnelPaths({
+        prefix: '/central-api/api/v1/funnels',
+        runsPrefix: '/central-api/api/v1/funnel-runs',
+      })
+    );
+    await client.listFunnels();
+    expect(adapter.lastUrl).toBe('/central-api/api/v1/funnels/');
+    await client.getFunnelRun('r1');
+    expect(adapter.lastUrl).toBe('/central-api/api/v1/funnel-runs/r1/');
+  });
+
+  it('exposes the family it was built with, so a composer can tell the surfaces apart', () => {
+    const client = new FunnelApiClient(adapter, '', foundryTenantFunnelPaths('acme'));
+    expect(client.paths.prefix).toBe('/api/v1/foundry/tenants/acme/funnels');
+  });
+});
+
+describe('FunnelApiClient.getFields', () => {
+  let adapter: RecordingAdapter;
+
+  beforeEach(() => {
+    adapter = new RecordingAdapter();
+  });
+
+  it('fetches the field registry from the family it was pointed at', async () => {
+    adapter.nextResponse = { entity_type: 'contact', fields: [] };
+    const client = new FunnelApiClient(adapter, '', foundryTenantFunnelPaths('acme'));
+    await client.getFields('contact');
+    expect(adapter.lastUrl).toBe('/api/v1/foundry/tenants/acme/funnels/fields/');
+    expect(adapter.calls[0].params).toEqual({ entity_type: 'contact' });
+  });
+
+  it('normalizes the payload, whether or not the adapter camelizes it', async () => {
+    adapter.nextResponse = {
+      entity_type: 'contact',
+      fields: [
+        {
+          key: 'tag.stage_focus',
+          label: 'stage_focus',
+          category: 'Tags',
+          value_type: 'enum',
+          enum_values: ['seed'],
+          allowed_operators: ['eq', 'exists'],
+        },
+      ],
+    };
+    const client = new FunnelApiClient(adapter, '');
+    const registry = await client.getFields();
+
+    expect(registry.entityType).toBe('contact');
+    expect(registry.fields[0]).toMatchObject({
+      key: 'tag.stage_focus',
+      valueType: 'enum',
+      enumValues: ['seed'],
+      allowedOperators: ['eq', 'exists'],
+    });
+  });
+
+  it('reads a camelized payload unchanged', async () => {
+    adapter.nextResponse = {
+      entityType: 'sc_artist',
+      fields: [
+        {
+          key: 'metric.reach.followers',
+          label: 'followers',
+          category: 'Metrics',
+          valueType: 'number',
+          enumValues: [],
+          allowedOperators: ['gte', 'between'],
+        },
+      ],
+    };
+    const client = new FunnelApiClient(adapter, '');
+    const registry = await client.getFields('sc_artist');
+
+    expect(registry.entityType).toBe('sc_artist');
+    expect(registry.fields[0].allowedOperators).toEqual(['gte', 'between']);
+  });
+});

package/src/api/client.ts

@@ -8,16 +8,21 @@
  */
 
 import type { ApiAdapter } from './adapter';
+import type { FunnelPaths } from './paths';
+import { centralFunnelPaths } from './paths';
 import type {
   Funnel,
   FunnelStage,
   FunnelRun,
   FunnelResult,
+  FieldRegistry,
+  FieldDefinitionInput,
   CreateFunnelInput,
   UpdateFunnelInput,
   CreateStageInput,
   UpdateStageInput,
 } from '../types';
+import { normalizeFieldDefinition } from '../types';
 
 /**
  * List filters for funnels
@@ -89,7 +94,12 @@ export interface PreviewResult<TEntity = any> {
  * Usage:
  * ```ts
  * const adapter = new FetchAdapter({ headers: { 'Authorization': 'Bearer token' } });
- * const client = new FunnelApiClient(adapter, 'https://api.example.com');
+ *
+ * // the central API
+ * const client = new FunnelApiClient(adapter, 'https://api.startsimpli.com');
+ *
+ * // a foundry's funnels on the control plane (startsim-9xbz2)
+ * const tenant = new FunnelApiClient(adapter, '', foundryTenantFunnelPaths('acme'));
  *
  * const funnels = await client.listFunnels({ status: 'active' });
  * const funnel = await client.getFunnel('funnel-123');
@@ -97,12 +107,17 @@ export interface PreviewResult<TEntity = any> {
  * ```
  */
 export class FunnelApiClient {
+  /** The path family this client talks to. Readable, so a caller can log it. */
+  public readonly paths: FunnelPaths;
+
   constructor(
     private adapter: ApiAdapter,
-    private baseUrl: string
+    private baseUrl: string,
+    paths: FunnelPaths = centralFunnelPaths
   ) {
     // Remove trailing slash
     this.baseUrl = baseUrl.replace(/\/$/, '');
+    this.paths = paths;
   }
 
   /**
@@ -126,7 +141,7 @@ export class FunnelApiClient {
     filters?: FunnelListFilters
   ): Promise<PaginatedResponse<Funnel<TEntity>>> {
     return this.adapter.get<PaginatedResponse<Funnel<TEntity>>>(
-      this.url('/api/v1/funnels/'),
+      this.url(this.paths.list()),
       filters
     );
   }
@@ -139,7 +154,7 @@ export class FunnelApiClient {
    * @throws ApiError with status 404 if not found
    */
   async getFunnel<TEntity = any>(id: string): Promise<Funnel<TEntity>> {
-    return this.adapter.get<Funnel<TEntity>>(this.url(`/api/v1/funnels/${id}/`));
+    return this.adapter.get<Funnel<TEntity>>(this.url(this.paths.detail(id)));
   }
 
   /**
@@ -152,7 +167,7 @@ export class FunnelApiClient {
   async createFunnel<TEntity = any>(
     data: CreateFunnelInput<TEntity>
   ): Promise<Funnel<TEntity>> {
-    return this.adapter.post<Funnel<TEntity>>(this.url('/api/v1/funnels/'), data);
+    return this.adapter.post<Funnel<TEntity>>(this.url(this.paths.list()), data);
   }
 
   /**
@@ -168,7 +183,7 @@ export class FunnelApiClient {
     data: Partial<UpdateFunnelInput<TEntity>>
   ): Promise<Funnel<TEntity>> {
     return this.adapter.patch<Funnel<TEntity>>(
-      this.url(`/api/v1/funnels/${id}/`),
+      this.url(this.paths.detail(id)),
       data
     );
   }
@@ -180,7 +195,7 @@ export class FunnelApiClient {
    * @throws ApiError with status 404 if not found
    */
   async deleteFunnel(id: string): Promise<void> {
-    return this.adapter.delete<void>(this.url(`/api/v1/funnels/${id}/`));
+    return this.adapter.delete<void>(this.url(this.paths.detail(id)));
   }
 
   // ============================================================================
@@ -200,7 +215,7 @@ export class FunnelApiClient {
     data: CreateStageInput<TEntity>
   ): Promise<FunnelStage<TEntity>> {
     return this.adapter.post<FunnelStage<TEntity>>(
-      this.url(`/api/v1/funnels/${funnelId}/stages/`),
+      this.url(this.paths.stages(funnelId)),
       data
     );
   }
@@ -220,7 +235,7 @@ export class FunnelApiClient {
     data: Partial<UpdateStageInput<TEntity>>
   ): Promise<FunnelStage<TEntity>> {
     return this.adapter.patch<FunnelStage<TEntity>>(
-      this.url(`/api/v1/funnels/${funnelId}/stages/${stageId}/`),
+      this.url(this.paths.stage(funnelId, stageId)),
       data
     );
   }
@@ -234,7 +249,7 @@ export class FunnelApiClient {
    */
   async deleteStage(funnelId: string, stageId: string): Promise<void> {
     return this.adapter.delete<void>(
-      this.url(`/api/v1/funnels/${funnelId}/stages/${stageId}/`)
+      this.url(this.paths.stage(funnelId, stageId))
     );
   }
 
@@ -258,7 +273,7 @@ export class FunnelApiClient {
     }
   ): Promise<FunnelRun> {
     return this.adapter.post<FunnelRun>(
-      this.url(`/api/v1/funnels/${funnelId}/run/`),
+      this.url(this.paths.run(funnelId)),
       options || {}
     );
   }
@@ -281,7 +296,7 @@ export class FunnelApiClient {
     }
   ): Promise<PaginatedResponse<FunnelRun>> {
     return this.adapter.get<PaginatedResponse<FunnelRun>>(
-      this.url(`/api/v1/funnels/${funnelId}/runs/`),
+      this.url(this.paths.runs(funnelId)),
       filters
     );
   }
@@ -290,11 +305,13 @@ export class FunnelApiClient {
    * Get single run detail
    *
    * @param runId - Run ID
+   * @param funnelId - Required only on a path family that nests runs under
+   *   their funnel (the control plane); ignored on the central family.
    * @returns Funnel run detail
    * @throws ApiError with status 404 if not found
    */
-  async getFunnelRun(runId: string): Promise<FunnelRun> {
-    return this.adapter.get<FunnelRun>(this.url(`/api/v1/funnel-runs/${runId}/`));
+  async getFunnelRun(runId: string, funnelId?: string): Promise<FunnelRun> {
+    return this.adapter.get<FunnelRun>(this.url(this.paths.runDetail(runId, funnelId)));
   }
 
   /**
@@ -309,13 +326,22 @@ export class FunnelApiClient {
     runId: string,
     filters?: {
       matched?: boolean;
+      /**
+       * WHERE THE ENTITY STOPPED. A stage id is "excluded at that stage";
+       * the literal 'end' is "was never excluded" (bd startsim-9xbz2). Served
+       * by the control-plane results action; the central one ignores it.
+       */
+      stage?: string;
       page?: number;
       pageSize?: number;
+      /** Required only on a family that nests runs under their funnel. */
+      funnelId?: string;
     }
   ): Promise<PaginatedResponse<FunnelResult<TEntity>>> {
+    const { funnelId, ...query } = filters ?? {};
     return this.adapter.get<PaginatedResponse<FunnelResult<TEntity>>>(
-      this.url(`/api/v1/funnel-runs/${runId}/results/`),
-      filters
+      this.url(this.paths.runResults(runId, funnelId)),
+      query
     );
   }
 
@@ -326,13 +352,46 @@ export class FunnelApiClient {
    * @returns Updated run with status 'cancelled'
    * @throws ApiError with status 404 if not found, 400 if already completed
    */
-  async cancelFunnelRun(runId: string): Promise<FunnelRun> {
+  async cancelFunnelRun(runId: string, funnelId?: string): Promise<FunnelRun> {
     return this.adapter.post<FunnelRun>(
-      this.url(`/api/v1/funnel-runs/${runId}/cancel/`),
+      this.url(this.paths.runCancel(runId, funnelId)),
       {}
     );
   }
 
+  // ============================================================================
+  // Field Registry
+  // ============================================================================
+
+  /**
+   * Fetch the field registry that describes which keys a rule may name.
+   *
+   * This is what a rule editor should be driven by — the server's own resolver
+   * registry (backend/apps/funnels/resolvers/registry.py), not a hand-written
+   * per-app list that drifts from it.
+   *
+   * The payload is normalized, so the same call works whether the injected
+   * adapter camelizes keys (the @startsimpli/api FetchWrapper does) or hands
+   * back the raw snake_case body (FetchAdapter does).
+   *
+   * @param entityType - Optional: only the fields that apply to this entity type
+   */
+  async getFields(entityType?: string): Promise<FieldRegistry> {
+    const response = await this.adapter.get<{
+      entity_type?: string | null;
+      entityType?: string | null;
+      fields?: FieldDefinitionInput[];
+    }>(
+      this.url(this.paths.fields()),
+      entityType ? { entity_type: entityType } : undefined
+    );
+
+    return {
+      entityType: response.entityType ?? response.entity_type ?? null,
+      fields: (response.fields ?? []).map(normalizeFieldDefinition),
+    };
+  }
+
   // ============================================================================
   // Client-Side Preview (Local Evaluation)
   // ============================================================================
@@ -378,7 +437,7 @@ export class FunnelApiClient {
     sampleEntities: TEntity[]
   ): Promise<PreviewResult<TEntity>> {
     return this.adapter.post<PreviewResult<TEntity>>(
-      this.url(`/api/v1/funnels/${funnelId}/preview/`),
+      this.url(this.paths.preview(funnelId)),
       { entities: sampleEntities }
     );
   }

package/src/api/http-adapter.test.ts

@@ -0,0 +1,68 @@
+/**
+ * The bridge from an app's own http client to the funnel adapter
+ * (bd startsim-em5mn).
+ */
+import { describe, it, expect } from 'vitest';
+import { funnelHttpAdapter } from './http-adapter';
+import { FunnelApiClient } from './client';
+import { foundryTenantFunnelPaths } from './paths';
+
+function spy() {
+  const calls: Array<{ method: string; endpoint: string; arg?: unknown }> = [];
+  const http = {
+    get: <T,>(endpoint: string, options?: { params?: Record<string, unknown> }) => {
+      calls.push({ method: 'get', endpoint, arg: options });
+      return Promise.resolve({ results: [], count: 0 } as unknown as T);
+    },
+    post: <T,>(endpoint: string, data?: unknown) => {
+      calls.push({ method: 'post', endpoint, arg: data });
+      return Promise.resolve({} as T);
+    },
+    patch: <T,>(endpoint: string, data?: unknown) => {
+      calls.push({ method: 'patch', endpoint, arg: data });
+      return Promise.resolve({} as T);
+    },
+    delete: <T,>(endpoint: string) => {
+      calls.push({ method: 'delete', endpoint });
+      return Promise.resolve(undefined as T);
+    },
+  };
+  return { http, calls };
+}
+
+describe('funnelHttpAdapter', () => {
+  it('hands query params to the http client under `params`', async () => {
+    const { http, calls } = spy();
+    const client = new FunnelApiClient(funnelHttpAdapter(http), '', foundryTenantFunnelPaths('acme'));
+
+    await client.listFunnels({ page: 2, pageSize: 25, status: 'active' });
+
+    expect(calls[0]).toEqual({
+      method: 'get',
+      endpoint: '/api/v1/foundry/tenants/acme/funnels/',
+      // `pageSize`, NOT `page_size`: StandardPaginatedResponse reads
+      // `pageSize`. Transforming the key here would silently page at 25 forever.
+      arg: { params: { page: 2, pageSize: 25, status: 'active' } },
+    });
+  });
+
+  it('omits the options object entirely when there are no params', async () => {
+    const { http, calls } = spy();
+    const client = new FunnelApiClient(funnelHttpAdapter(http), '', foundryTenantFunnelPaths('acme'));
+
+    await client.getFunnel('f1');
+
+    expect(calls[0].arg).toBeUndefined();
+  });
+
+  it('passes a write body straight through', async () => {
+    const { http, calls } = spy();
+    const client = new FunnelApiClient(funnelHttpAdapter(http), '', foundryTenantFunnelPaths('acme'));
+
+    await client.runFunnel('f1', { triggerType: 'manual' });
+
+    expect(calls[0].method).toBe('post');
+    expect(calls[0].endpoint).toBe('/api/v1/foundry/tenants/acme/funnels/f1/runs/');
+    expect(calls[0].arg).toEqual({ triggerType: 'manual' });
+  });
+});

package/src/api/http-adapter.ts

@@ -0,0 +1,48 @@
+/**
+ * Drive FunnelApiClient with an app's OWN http client (bd startsim-em5mn).
+ *
+ * WHY THIS IS HERE AND NOT IN EACH APP. Every surface that mounts the funnels
+ * page already has a configured client — `@startsimpli/api`'s, carrying the
+ * bearer token, the 401 bounce to central auth and the snake↔camel key
+ * transform. `FetchAdapter` has none of that, so an app wiring the page with it
+ * would be signing its own requests. The three-line bridge between the two is
+ * the same three lines in foundry-web, the tenant template and market-web, so
+ * it lives here once (CLAUDE.md rule 9) — the same shape
+ * `createPlanningApi({ http: api.client })` already takes.
+ *
+ * STRUCTURAL, NOT IMPORTED. The parameter is an interface this module declares
+ * rather than `ApiClient` from `@startsimpli/api`, so `@startsimpli/funnels`
+ * gains no dependency on it: raise and market install funnels precisely because
+ * it is light, and any client with these four methods works.
+ *
+ * QUERY PARAMS ARE PASSED THROUGH UNTOUCHED, deliberately. The page sends
+ * `page` and `pageSize` because that is what the server's paginator reads
+ * (`StandardPaginatedResponse.page_size_query_param = 'pageSize'`), and
+ * `entity_type` / `stage` / `matched` because those are the filter names the
+ * funnels endpoints read. Snake-casing them here would break the first pair and
+ * camel-casing them would break the second; the caller already spells each one
+ * the way its endpoint wants it.
+ */
+import type { ApiAdapter } from './adapter';
+
+/**
+ * The slice of an http client this adapter needs. `@startsimpli/api`'s
+ * `ApiClient` satisfies it as-is.
+ */
+export interface FunnelHttpClient {
+  get<T>(endpoint: string, options?: { params?: Record<string, unknown> }): Promise<T>;
+  post<T>(endpoint: string, data?: unknown): Promise<T>;
+  patch<T>(endpoint: string, data?: unknown): Promise<T>;
+  delete<T>(endpoint: string): Promise<T>;
+}
+
+/** Wrap an app's http client as the adapter FunnelApiClient takes. */
+export function funnelHttpAdapter(http: FunnelHttpClient): ApiAdapter {
+  return {
+    get: <T,>(url: string, params?: Record<string, unknown>) =>
+      http.get<T>(url, params ? { params } : undefined),
+    post: <T,>(url: string, data: unknown) => http.post<T>(url, data),
+    patch: <T,>(url: string, data: unknown) => http.patch<T>(url, data),
+    delete: <T,>(url: string) => http.delete<T>(url),
+  };
+}

package/src/api/index.ts

@@ -15,6 +15,22 @@ export { createApiError, isApiError } from './adapter';
 export { FetchAdapter } from './default-adapter';
 export type { FetchAdapterConfig } from './default-adapter';
 
+// Bridge an app's own configured http client (auth, 401 bounce, key transform)
+// into the adapter this client takes — bd startsim-em5mn.
+export { funnelHttpAdapter } from './http-adapter';
+export type { FunnelHttpClient } from './http-adapter';
+
+// Path families — the surfaces the same client can talk to (bd startsim-pxzlf)
+export {
+  createFunnelPaths,
+  centralFunnelPaths,
+  foundryTenantFunnelPaths,
+  proxiedCentralFunnelPaths,
+  DEFAULT_FUNNEL_PATH_PREFIX,
+  DEFAULT_FUNNEL_RUNS_PATH_PREFIX,
+} from './paths';
+export type { FunnelPaths, FunnelPathsOptions } from './paths';
+
 // Client
 export { FunnelApiClient } from './client';
 export type {