tapimo 0.0.2 → 0.2.0

package/src/Client.test-d.ts

@@ -1,19 +1,21 @@
-import { Client } from 'cadent'
+import { Client } from 'tapimo'
 import type * as z from 'zod/mini'
 
-import * as Activities from './apps/activities.js'
-import * as Balances from './apps/balances.js'
-import * as Blocks from './apps/blocks.js'
-import * as Exchanges from './apps/exchanges.js'
-import * as FeeAmm from './apps/fee-amm.js'
-import * as Indexer from './apps/indexer.js'
-import * as Receipts from './apps/receipts.js'
-import * as Rpc from './apps/rpc.js'
-import * as Tokens from './apps/tokens.js'
-import * as Transactions from './apps/transactions.js'
-import * as Transfers from './apps/transfers.js'
-import * as VerifiedTokens from './apps/verified-tokens.js'
-import * as Webhooks from './apps/webhooks.js'
+import * as Activities from './apps/data/routes/activities.js'
+import * as Balances from './apps/data/routes/balances.js'
+import * as Blocks from './apps/data/routes/blocks.js'
+import * as Exchanges from './apps/data/routes/exchanges.js'
+import * as FeeAmm from './apps/data/routes/fee-amm.js'
+import * as Indexer from './apps/data/routes/indexer.js'
+import * as Me from './apps/platform/routes/me.js'
+import * as Orgs from './apps/platform/routes/orgs.js'
+import * as Receipts from './apps/data/routes/receipts.js'
+import * as Rpc from './apps/data/routes/rpc.js'
+import * as Tokens from './apps/data/routes/tokens.js'
+import * as Transactions from './apps/data/routes/transactions.js'
+import * as Transfers from './apps/data/routes/transfers.js'
+import * as VerifiedTokens from './apps/data/routes/verified-tokens.js'
+import * as Webhooks from './apps/data/routes/webhooks.js'
 
 type Access400<code extends string> = code | 'api_key_malformed'
 type PaidAccessStatus = PublicAccessStatus | 402
@@ -97,6 +99,295 @@ describe('narrows responses by status', () => {
     }
   })
 
+  test('GET /v1/me', async () => {
+    const client = Client.create()
+    const res = await client.v1.me.$get()
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 404 | 502>()
+
+    switch (res.status) {
+      case 200: {
+        const json = await res.json()
+        expectTypeOf(json.id).toEqualTypeOf<z.output<typeof Me.schema.User>['id']>()
+        void json
+        return
+      }
+      case 403: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'forbidden'>()
+        void json
+        return
+      }
+      case 404: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'user_not_found'>()
+        void json
+        return
+      }
+    }
+  })
+
+  test('POST /v1/orgs', async () => {
+    const client = Client.create()
+    const res = await client.v1.orgs.$post({ json: { name: 'Acme' } })
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 502>()
+
+    switch (res.status) {
+      case 200: {
+        const json = await res.json()
+        expectTypeOf(json.id).toEqualTypeOf<z.output<typeof Orgs.schema.Organization>['id']>()
+        void json
+        return
+      }
+      case 403: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'forbidden'>()
+        void json
+        return
+      }
+    }
+  })
+
+  test('GET /v1/orgs/:orgId', async () => {
+    const client = Client.create()
+    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].$get({
+      param: { orgId: 'org_test' },
+    })
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 404>()
+
+    switch (res.status) {
+      case 200: {
+        const json = await res.json()
+        expectTypeOf(json.name).toEqualTypeOf<string>()
+        void json
+        return
+      }
+      case 404: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'organization_not_found'>()
+        void json
+        return
+      }
+    }
+  })
+
+  test('DELETE /v1/orgs/:orgId', async () => {
+    const client = Client.create()
+    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].$delete({
+      param: { orgId: 'org_test' },
+    })
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 404 | 502>()
+
+    switch (res.status) {
+      case 200: {
+        const json = await res.json()
+        expectTypeOf(json.id).toEqualTypeOf<string>()
+        void json
+        return
+      }
+      case 404: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'organization_not_found'>()
+        void json
+        return
+      }
+    }
+  })
+
+  test('GET /v1/orgs/:orgId/projects/:projectId', async () => {
+    const client = Client.create()
+    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].projects[
+      ':projectId{prj_[A-Za-z0-9_-]+}'
+    ].$get({ param: { orgId: 'org_test', projectId: 'prj_test' } })
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 404>()
+
+    switch (res.status) {
+      case 200: {
+        const json = await res.json()
+        expectTypeOf(json.environments[0]).toEqualTypeOf<'production' | 'sandbox' | undefined>()
+        void json
+        return
+      }
+      case 404: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<
+          'organization_not_found' | 'project_not_found'
+        >()
+        void json
+        return
+      }
+    }
+  })
+
+  test('DELETE /v1/orgs/:orgId/projects/:projectId', async () => {
+    const client = Client.create()
+    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].projects[
+      ':projectId{prj_[A-Za-z0-9_-]+}'
+    ].$delete({ param: { orgId: 'org_test', projectId: 'prj_test' } })
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 404 | 502>()
+
+    switch (res.status) {
+      case 200: {
+        const json = await res.json()
+        expectTypeOf(json.id).toEqualTypeOf<string>()
+        void json
+        return
+      }
+      case 404: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<
+          'organization_not_found' | 'project_not_found'
+        >()
+        void json
+        return
+      }
+    }
+  })
+
+  test('POST /v1/orgs/:orgId/projects/:projectId/api-keys', async () => {
+    const client = Client.create()
+    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].projects[
+      ':projectId{prj_[A-Za-z0-9_-]+}'
+    ]['api-keys'].$post({
+      json: { scopes: ['data:read'] },
+      param: { orgId: 'org_test', projectId: 'prj_test' },
+    })
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 404 | 502>()
+
+    switch (res.status) {
+      case 200: {
+        const json = await res.json()
+        expectTypeOf(json.token).toEqualTypeOf<string>()
+        expectTypeOf(json.id).toEqualTypeOf<string>()
+        void json
+        return
+      }
+    }
+  })
+
+  test('DELETE /v1/orgs/:orgId/projects/:projectId/api-keys/:keyId', async () => {
+    const client = Client.create()
+    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].projects[
+      ':projectId{prj_[A-Za-z0-9_-]+}'
+    ]['api-keys'][':keyId{key_[A-Za-z0-9_-]+}'].$delete({
+      param: { keyId: 'key_test', orgId: 'org_test', projectId: 'prj_test' },
+    })
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 404 | 502>()
+
+    switch (res.status) {
+      case 404: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<
+          | 'api_key_not_found'
+          | 'api_keys_not_enabled'
+          | 'organization_not_found'
+          | 'project_not_found'
+        >()
+        void json
+        return
+      }
+    }
+  })
+
+  test('GET /v1/orgs/:orgId/members', async () => {
+    const client = Client.create()
+    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].members.$get({
+      param: { orgId: 'org_test' },
+    })
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 404 | 502>()
+
+    switch (res.status) {
+      case 200: {
+        const json = await res.json()
+        expectTypeOf(json.data[0]!.role).toEqualTypeOf<'admin' | 'member' | 'owner'>()
+        void json
+        return
+      }
+    }
+  })
+
+  test('PATCH /v1/orgs/:orgId/members/:userId', async () => {
+    const client = Client.create()
+    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].members[
+      ':userId{usr_[A-Za-z0-9_-]+}'
+    ].$patch({ json: { role: 'admin' }, param: { orgId: 'org_test', userId: 'usr_test' } })
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 404 | 409 | 502>()
+
+    switch (res.status) {
+      case 409: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'last_owner'>()
+        void json
+        return
+      }
+    }
+  })
+
+  test('POST /v1/invitations/:invitationId/accept', async () => {
+    const client = Client.create()
+    const res = await client.v1.invitations[':invitationId{inv_[A-Za-z0-9_-]+}'].accept.$post({
+      param: { invitationId: 'inv_test' },
+    })
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 404 | 502>()
+
+    switch (res.status) {
+      case 200: {
+        const json = await res.json()
+        expectTypeOf(json.role).toEqualTypeOf<'admin' | 'member' | 'owner'>()
+        void json
+        return
+      }
+      case 404: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'invitation_not_found'>()
+        void json
+        return
+      }
+    }
+  })
+
+  test('GET /v1/orgs', async () => {
+    const client = Client.create()
+    const res = await client.v1.orgs.$get()
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 502>()
+
+    switch (res.status) {
+      case 200: {
+        const json = await res.json()
+        expectTypeOf(json.data[0]!.id).toEqualTypeOf<
+          z.output<typeof Orgs.schema.listOrganizations.Response>['data'][number]['id']
+        >()
+        void json
+        return
+      }
+      case 403: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'forbidden'>()
+        expectTypeOf(json.error.message).toEqualTypeOf<string>()
+        void json
+        return
+      }
+      case 502: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
+        expectTypeOf(json.error.message).toEqualTypeOf<string>()
+        void json
+        return
+      }
+    }
+  })
+
   test('GET /v1/blocks/:block', async () => {
     const client = Client.create()
     const res = await client.v1.blocks[':block'].$get({ param: { block: '1' } })
@@ -1176,7 +1467,7 @@ describe('narrows responses by status', () => {
 
   test('POST /rpc/:chain', async () => {
     const client = Client.create()
-    const res = await client.rpc[':chain{mainnet|testnet|[0-9]+}?'].$post({
+    const res = await client.rpc[':chain{(mainnet|testnet|[0-9]+)}?'].$post({
       param: { chain: undefined },
     })
 
@@ -1208,7 +1499,7 @@ describe('narrows responses by status', () => {
 
   test('POST /rpc/:chain testnet shortcut', async () => {
     const client = Client.create()
-    const res = await client.rpc[':chain{mainnet|testnet|[0-9]+}?'].$post({
+    const res = await client.rpc[':chain{(mainnet|testnet|[0-9]+)}?'].$post({
       param: { chain: 'testnet' },
     })
 

package/src/Handler.ts

@@ -0,0 +1,154 @@
+import { Hono } from 'hono'
+import type { ExtractSchema, MergeSchemaPath, Schema } from 'hono/types'
+
+import type { UnionToIntersection } from './handlers/internal/types.js'
+import * as RequestListener from './handlers/internal/requestListener.js'
+
+export { relay } from './handlers/relay.js'
+export * as Multisig from './handlers/internal/multisig.js'
+
+/**
+ * A request handler. Generic over the underlying Hono app shape so chained
+ * route definitions (`.post`, `.get`, …) can flow their type information
+ * through to consumers — most notably for Hono's typed RPC client
+ * (`hc<typeof handler>`).
+ */
+export type Handler<app extends Hono<any, any, any> = Hono> = app & {
+  listener: (req: any, res: any) => void
+}
+
+/**
+ * Merges the route schemas of every sub-handler into a single Hono schema,
+ * prefixing each route key with `path`. Used by `compose()` to preserve
+ * typed routes for Hono's RPC client (`hc`).
+ */
+export type ComposedSchema<subs extends readonly unknown[], path extends string> =
+  UnionToIntersection<
+    subs[number] extends infer sub
+      ? sub extends unknown
+        ? MergeSchemaPath<Extract<ExtractSchema<sub>, Schema>, path>
+        : never
+      : never
+  > extends infer schema extends Schema
+    ? schema
+    : never
+
+/**
+ * Mounts each sub-handler onto a fresh Hono app at `path` (default `/`) and
+ * returns a single composed handler. Routes are dispatched by Hono's trie
+ * — a deterministic match per path — instead of the older "try each handler
+ * in order until one returns non-404" loop.
+ *
+ * The returned handler preserves each sub-handler's route schema so the
+ * composed app stays usable from Hono's typed RPC client:
+ *
+ * ```ts
+ * import { hc } from 'hono/client'
+ *
+ * const app = Handler.compose(
+ *   [Handler.exchange(), Handler.codeAuth({ store })],
+ *   { path: '/api' },
+ * )
+ * type App = typeof app
+ *
+ * const client = hc<App>('https://wallet.example.com')
+ * await client.api.exchange.quote.$post({ json: { ... } }) // typed
+ * ```
+ */
+export function compose<const subs extends readonly Handler[], const path extends string = '/'>(
+  handlers: subs,
+  options: compose.Options & { path?: path } = {},
+): Handler<Hono<{}, ComposedSchema<subs, path>, '/'>> {
+  const mountPath = (options.path ?? '/') as path
+
+  const app = from(options) as unknown as Hono
+  for (const sub of handlers) app.route(mountPath, sub)
+  app.notFound(() => new Response('Not Found', { status: 404 }))
+
+  return app as never
+}
+
+export declare namespace compose {
+  export type Options = from.Options & {
+    /** The path to use for the handler. */
+    path?: string | undefined
+  }
+}
+
+/**
+ * Instantiates a new request handler.
+ *
+ * @param options - constructor options
+ * @returns Handler instance
+ */
+export function from(options: from.Options = {}): Handler {
+  const corsHeaders = corsToHeaders(options.cors)
+  const mergedHeaders = new Headers(corsHeaders)
+  for (const [key, value] of normalizeHeaders(options.headers).entries())
+    mergedHeaders.set(key, value)
+
+  const app = new Hono()
+
+  app.use(async (c, next) => {
+    if (c.req.method === 'OPTIONS') return new Response(null, { headers: mergedHeaders })
+    await next()
+    for (const [key, value] of mergedHeaders.entries()) c.res.headers.set(key, value)
+    return undefined
+  })
+
+  return Object.assign(app, {
+    listener: RequestListener.fromFetchHandler((request) => app.fetch(request)),
+  }) as never
+}
+
+export declare namespace from {
+  export type Options = {
+    /**
+     * CORS configuration.
+     * - `true` (default): Allow all origins with default methods/headers
+     * - `false`: Disable CORS headers
+     * - Object: Custom CORS configuration
+     */
+    cors?: boolean | Cors | undefined
+    /** Headers to add to the response. */
+    headers?: Headers | Record<string, string> | undefined
+  }
+
+  export type Cors = {
+    /** Allowed origins. Defaults to `'*'`. */
+    origin?: string | string[] | undefined
+    /** Allowed methods. Defaults to `'GET, POST, PUT, DELETE, OPTIONS'`. */
+    methods?: string | undefined
+    /** Allowed headers. Defaults to `'Content-Type'`. */
+    headers?: string | undefined
+    /** Whether to allow credentials. */
+    credentials?: boolean | undefined
+    /** Headers to expose to the browser. */
+    exposeHeaders?: string | undefined
+    /** Max age for preflight cache in seconds. */
+    maxAge?: number | undefined
+  }
+}
+
+function normalizeHeaders(headers?: Headers | Record<string, string>): Headers {
+  if (!headers) return new Headers()
+  if (headers instanceof Headers) return headers
+  return new Headers(headers)
+}
+
+function corsToHeaders(cors?: boolean | from.Cors): Headers {
+  if (cors === false) return new Headers()
+
+  const config = cors === true || cors === undefined ? {} : cors
+
+  const headers = new Headers()
+  const origin = Array.isArray(config.origin) ? config.origin.join(', ') : (config.origin ?? '*')
+  headers.set('Access-Control-Allow-Origin', origin)
+  headers.set('Access-Control-Allow-Methods', config.methods ?? 'GET, POST, PUT, DELETE, OPTIONS')
+  headers.set('Access-Control-Allow-Headers', config.headers ?? 'Content-Type')
+  if (config.credentials) headers.set('Access-Control-Allow-Credentials', 'true')
+  if (config.exposeHeaders) headers.set('Access-Control-Expose-Headers', config.exposeHeaders)
+  if (config.maxAge !== undefined) headers.set('Access-Control-Max-Age', String(config.maxAge))
+
+  return headers
+}

package/src/Scope.ts

@@ -1,9 +1,8 @@
 /**
  * The issuable API-key scope vocabulary: the single source of truth for the
- * `/scopes` catalog, for key minting (`ApiKeySource.Source.mint`), and for the scopes
- * required by route policies (`Auth.policy`). Exposing it publicly lets operator
- * tooling (e.g. the provisioning CLI) validate scopes against the same list the
- * server enforces.
+ * `/scopes` catalog, for key minting (`ApiKeys.mint`), and for the scopes
+ * required by route policies (`Auth.policy`). Exposing it publicly lets super
+ * admin tooling validate scopes against the same list the server enforces.
  */
 
 /**
@@ -36,6 +35,14 @@ export const catalog = [
     description: 'Run ad-hoc queries against the raw indexer passthrough.',
     scope: 'indexer:query',
   },
+  {
+    description: 'Fill and submit transactions through the relay.',
+    scope: 'rpc-relay:read',
+  },
+  {
+    description: 'Sponsor transaction fees through the relay as the managed fee payer.',
+    scope: 'rpc-relay:sponsor',
+  },
   {
     description: 'Read webhook subscriptions.',
     scope: 'webhooks:read',
@@ -48,3 +55,9 @@ export const catalog = [
 
 /** Issuable API-key scope identifier — the union of every {@link catalog} entry. */
 export type Id = (typeof catalog)[number]['scope']
+
+/**
+ * Scopes a session may self-mint through the developer platform. Empty: every
+ * scope requires super admin issuance.
+ */
+export const selfServe: readonly Id[] = []

package/src/Webhooks.test.ts

@@ -1,4 +1,5 @@
-import { Store, Webhooks } from 'cadent'
+import { Webhooks } from 'tapimo'
+import * as TestApp from '../test/App.js'
 
 describe('createPoller', () => {
   /** Decodes the opaque `(block, index)` keyset cursor the poller stores. */
@@ -8,9 +9,9 @@ describe('createPoller', () => {
     return JSON.parse(json) as [number, number]
   }
 
-  test('binds a state store and runs a tick at an injected head', async () => {
-    const store = Store.memory()
-    const subscription = await Webhooks.createSubscription(store, {
+  test('binds a database and runs a tick at an injected head', async () => {
+    const db = TestApp.database()
+    const subscription = await Webhooks.createSubscription(db, {
       chainId: 42431,
       destination: { type: 'url', url: 'https://hooks.example.com/x' },
       eventType: 'token:transfer',
@@ -18,12 +19,12 @@ describe('createPoller', () => {
     })
 
     const poller = Webhooks.createPoller({
+      db,
       defaultChainId: 42431,
-      webhook: { store },
     })
 
     // A brand-new subscription anchors at the confirmed head on its first tick
-    // (no backfill), so this exercises the createPoller → poll wiring (store
+    // (no backfill), so this exercises the createPoller → poll wiring (db
     // binding, default chain id, injected head, result shape) without touching
     // TIDX. Detailed poll/getIndexedHead behavior lives in
     // src/apps/webhooks.test.ts.
@@ -39,7 +40,7 @@ describe('createPoller', () => {
         "subscriptions": 1,
       }
     `)
-    expect(decodeCursor(await Webhooks.getCursor(store, subscription.id))).toMatchInlineSnapshot(`
+    expect(decodeCursor(await Webhooks.getCursor(db, subscription.id))).toMatchInlineSnapshot(`
       [
         198,
         2147483647,

package/src/Webhooks.ts

@@ -1,6 +1,7 @@
-import * as AppWebhooks from './apps/webhooks.js'
+import * as AppWebhooks from './apps/data/routes/webhooks.js'
+import * as Db from './db/Db.js'
 import * as MetricSink from './internal/MetricSink.js'
-import type * as Store from './internal/Store.js'
+import * as Store from './internal/Store.js'
 import type * as Metrics from './Metrics.js'
 import * as Tidx from './internal/Tidx.js'
 import * as Viem from './internal/Viem.js'
@@ -15,7 +16,7 @@ export * from './internal/Webhooks.js'
 // type delivery bodies: `Webhooks.schema.Envelope` (a discriminated union on
 // `type`), plus the per-event `TransferEvent` / `TransactionEvent` / `PingEvent`
 // payloads. Infer a type with `z.infer<typeof Webhooks.schema.Envelope>`.
-export { eventTypes, schema } from './apps/webhooks.js'
+export { eventTypes, schema } from './apps/data/routes/webhooks.js'
 
 /**
  * Builds a scheduled webhook poller bound to a state store and chain config.
@@ -35,7 +36,9 @@ export { eventTypes, schema } from './apps/webhooks.js'
  * request state.
  */
 export function createPoller(options: createPoller.Options): createPoller.Poller {
-  const { store } = options.webhook
+  // Persistent memoize cache for token metadata, shared across ticks (the
+  // webhook state store used to double-duty as this cache).
+  const cache = Store.memory()
   const getTidx = options.tidx
     ? Tidx.createGetClient({ defaultChainId: options.defaultChainId, tidx: options.tidx })
     : undefined
@@ -80,9 +83,13 @@ export function createPoller(options: createPoller.Options): createPoller.Poller
       try {
         const result = await AppWebhooks.poll({
           batchSize: input.batchSize ?? options.batchSize,
+          cache,
           chainId,
           client: getClient(chainId),
           confirmations: input.confirmations ?? options.confirmations,
+          // Resolve per tick so Workers factories build a fresh
+          // Hyperdrive-pooled connection each run.
+          db: Db.get(options.db),
           dispatch,
           eventTypes: input.eventTypes ?? options.eventTypes,
           ...(input.headBlockNumber === undefined
@@ -90,7 +97,6 @@ export function createPoller(options: createPoller.Options): createPoller.Poller
             : { headBlockNumber: input.headBlockNumber }),
           maxBlocks: input.maxBlocks ?? options.maxBlocks,
           now: input.now ?? options.now,
-          store,
           ...(getTidx ? { tidx: getTidx(chainId) } : {}),
         })
         metrics?.record({
@@ -144,6 +150,8 @@ export declare namespace createPoller {
 
   /** Options for {@link createPoller}. */
   type Options = Defaults & {
+    /** Database holding subscriptions + cursors, or a factory resolved per tick (Workers/Hyperdrive). */
+    db: Db.Source
     /** Tempo chain id polled when a tick omits one. */
     defaultChainId?: Viem.ChainId | undefined
     /** Metrics backend; emits `webhook:tick` per tick and `webhook:enqueue` per dispatch. */
@@ -152,8 +160,6 @@ export declare namespace createPoller {
     rpc?: Viem.getClient.Rpc | undefined
     /** TIDX query client options for the legacy `token:transfer` type. */
     tidx?: Tidx.getClient.Tidx | undefined
-    /** Webhook state store (subscriptions + cursors). */
-    webhook: { store: Store.State }
   }
 
   /** Per-tick overrides; falls back to the {@link Options} defaults. */

package/src/admin/Access.ts

@@ -29,10 +29,8 @@ const cookieName = 'CF_Authorization'
  * ```ts
  * import { App, Access } from 'tapimo/admin'
  *
- * const source = {} as App.create.Options['apiKey']['source']
- *
  * App.create({
- *   apiKey: { source },
+ *   // ...
  *   identify: Access.cloudflareAccess({
  *     teamDomain: 'https://tempo.cloudflareaccess.com',
  *   }),