@proveanything/smartlinks 2.1.13 → 2.1.15

package/dist/api/integrations.d.ts

@@ -105,4 +105,32 @@ export declare namespace integrations {
     function runConnectorStep<T = unknown>(collectionId: string, appId: string, step: ConnectorConsoleStep, input?: Record<string, unknown> & {
         flowId?: string;
     }): Promise<T>;
+    /**
+     * Invoke a connector ACTION from the console (any visibility): redeem, enrol, adjust points, issue a
+     * coupon… The connector's function runs with its own credentials and is told who asked.
+     * POST /integrations/connectors/:appId/actions/:action { input }
+     */
+    function runConnectorAction<T = unknown>(collectionId: string, appId: string, action: string, input?: Record<string, unknown>): Promise<T>;
+    /**
+     * PUBLIC (the Hub, a site): the connector actions the caller may invoke — those declared `public`,
+     * plus `member` ones when signed in.
+     * GET /public/collection/:collectionId/connectors/:appId/actions
+     */
+    function listConnectorActions(collectionId: string, appId: string): Promise<{
+        actions: Array<{
+            name: string;
+            title: string;
+            description?: string;
+            visibility: 'public' | 'member' | 'admin';
+            input?: Record<string, unknown>;
+            output?: Record<string, unknown>;
+        }>;
+    }>;
+    /**
+     * PUBLIC (the Hub, a site): invoke a connector action — e.g. redeem a reward for the signed-in member.
+     * 401 SIGN_IN_REQUIRED for a `member` action without a session; 403 for an admin-only one;
+     * 400 with `missing[]` when a required input is absent.
+     * POST /public/collection/:collectionId/connectors/:appId/actions/:action { input }
+     */
+    function callConnectorAction<T = unknown>(collectionId: string, appId: string, action: string, input?: Record<string, unknown>): Promise<T>;
 }

package/dist/api/integrations.js

@@ -200,4 +200,32 @@ export var integrations;
         return post(`${connectorsBase(collectionId)}/${enc(appId)}/steps/${enc(step)}`, input);
     }
     integrations.runConnectorStep = runConnectorStep;
+    /**
+     * Invoke a connector ACTION from the console (any visibility): redeem, enrol, adjust points, issue a
+     * coupon… The connector's function runs with its own credentials and is told who asked.
+     * POST /integrations/connectors/:appId/actions/:action { input }
+     */
+    async function runConnectorAction(collectionId, appId, action, input = {}) {
+        return post(`${connectorsBase(collectionId)}/${enc(appId)}/actions/${enc(action)}`, { input });
+    }
+    integrations.runConnectorAction = runConnectorAction;
+    /**
+     * PUBLIC (the Hub, a site): the connector actions the caller may invoke — those declared `public`,
+     * plus `member` ones when signed in.
+     * GET /public/collection/:collectionId/connectors/:appId/actions
+     */
+    async function listConnectorActions(collectionId, appId) {
+        return request(`/public/collection/${enc(collectionId)}/connectors/${enc(appId)}/actions`);
+    }
+    integrations.listConnectorActions = listConnectorActions;
+    /**
+     * PUBLIC (the Hub, a site): invoke a connector action — e.g. redeem a reward for the signed-in member.
+     * 401 SIGN_IN_REQUIRED for a `member` action without a session; 403 for an admin-only one;
+     * 400 with `missing[]` when a required input is absent.
+     * POST /public/collection/:collectionId/connectors/:appId/actions/:action { input }
+     */
+    async function callConnectorAction(collectionId, appId, action, input = {}) {
+        return post(`/public/collection/${enc(collectionId)}/connectors/${enc(appId)}/actions/${enc(action)}`, { input });
+    }
+    integrations.callConnectorAction = callConnectorAction;
 })(integrations || (integrations = {}));

package/dist/docs/API_SUMMARY.md

@@ -1,6 +1,6 @@
 # Smartlinks API Summary
 
-Version: 2.1.13  |  Generated: 2026-11-09T11:51:55.948Z
+Version: 2.1.15  |  Generated: 2026-11-09T15:17:42.472Z
 
 This is a concise summary of all available API functions and types.
 
@@ -64,8 +64,9 @@ For detailed guides on specific features:
 - **[Analytics](analytics.md)** - Web analytics, link-click tracking, QR/tag scan telemetry, and event reporting
 - **[Analytics Metadata Conventions](analytics-metadata-conventions.md)** - Standard recommended keys and conventions for analytics metadata fields
 - **[Loyalty: Points, Members & Earning Rules](loyalty.md)** - Loyalty schemes, automatic point earning via interaction rules, member balances, transaction history, and manual adjustments
-- **[Integrations](integrations.md)** - Inbound/outbound integration flows + the sealed-secret store; triggers (manual/event/schedule), field mappings, and the Syndigo/Event Hub outbound path
-- **[Connectors](connectors.md)** - Connector apps (adapters for one external provider): a manifest `connector` block + server functions (testConnection/describeTarget/sample/fetch/shape/serialize/send); core does the mapping
+- **[Integrations](integrations.md)** - Inbound/outbound integration flows + the sealed-secret store; triggers (manual/event/schedule), event patterns, the event envelope (interaction/contact/event sources), identity policy, event mapping, signed deliveries, contact as a target, field mappings
+- **[Connectors](connectors.md)** - Connector apps (adapters for one external provider): a manifest `connector` block + server functions (testConnection/describeTarget/sample/fetch/shape/serialize/send/describeEvents/lookup); loyalty and CRM connectors; actions (provider operations on demand); core does the mapping
+- **[Entitlements](entitlements.md)** - "Is this person gold or above?" answered on demand from signed claims, a connector lookup (cached), or the contact — never a mirrored member base; gates on interaction types and in server functions
 - **[AI Tools & Skills](ai-tools-and-skills.md)** - The AI capability catalog: skills apps invoke by name (e.g. research.brand), the tools the AI reaches for (web fetch/screenshot/brand assets/image gen), the agent loop, and how apps discover them
 - **[Deep Link Discovery](deep-link-discovery.md)** - Registering and discovering navigable app states for portal menus and AI orchestration
 - **[AI Guide Template](ai-guide-template.md)** - A sample for an app on how to build an AI setup guide
@@ -3111,6 +3112,19 @@ interface ConnectorPanel {
 }
 ```
 
+**ConnectorAction** (interface)
+```typescript
+interface ConnectorAction {
+  name: string
+  title?: string
+  description?: string
+  function: string
+  visibility?: 'admin' | 'member' | 'public'
+  input?: Record<string, unknown>
+  output?: Record<string, unknown>
+}
+```
+
 **AppConnectorDeclaration** (interface)
 ```typescript
 interface AppConnectorDeclaration {
@@ -3129,11 +3143,14 @@ interface AppConnectorDeclaration {
   serialize?: string
   send?: string
   fetch?: string
+  describeEvents?: string
+  lookup?: string
   }
   panels?: ConnectorPanel[]
+  actions?: ConnectorAction[]
   aiGuide?: string
   recordId?: string
-  limits?: { requestsPerSecond?: number }
+  limits?: { requestsPerSecond?: number; maxEvents?: number; maxAttributes?: number }
 }
 ```
 
@@ -7953,9 +7970,31 @@ interface FlowConnectorRef {
 }
 ```
 
+**EventMappingRule** (interface)
+```typescript
+interface EventMappingRule {
+  id?: string
+  match?: { types?: string[]; interactionIds?: string[]; outcomes?: string[]; appIds?: string[] }
+  event: string
+  attributes?: Record<string, string | number | boolean | { path: string; default?: unknown } | { value: unknown }>
+}
+```
+
+**EventMapping** (interface)
+```typescript
+interface EventMapping {
+  rules: EventMappingRule[]
+  unmatched?: 'skip' | 'passthrough'
+}
+```
+
 **IntegrationFlowConfig** (interface)
 ```typescript
 interface IntegrationFlowConfig {
+  signing?: { credentialRef: string; previousCredentialRef?: string }
+  identity?: { policy?: IdentityPolicy; hashKeyCredentialRef?: string }
+  eventMapping?: EventMapping
+  envelopeFormat?: 'cloudevents'
   connection?: FlowConnection
   fieldMappings?: FieldMapping[]
   connector?: FlowConnectorRef
@@ -7975,8 +8014,8 @@ interface IntegrationFlow {
   status: FlowStatus
   eventTypes: string[]
   schedule: string | null
-  sourceEntity: string | null
-  targetEntity: string | null
+  sourceEntity: FlowSourceEntity | string | null
+  targetEntity: FlowTargetEntity | string | null
   config: IntegrationFlowConfig
   createdBy: string | null
   createdAt: string
@@ -8165,6 +8204,70 @@ interface SaveConnectorInstallationInput {
 }
 ```
 
+**ConnectorEventsSchema** (interface)
+```typescript
+interface ConnectorEventsSchema {
+  events: Array<{ name: string; title?: string; attributes?: Array<{ name: string; type?: string; required?: boolean }> }>
+  limits?: { maxEvents?: number; maxAttributes?: number }
+}
+```
+
+**ConnectorLookupInput** (interface)
+```typescript
+interface ConnectorLookupInput {
+  installation: ConnectorInstallation
+  identity: { externalId?: string | null; email?: string | null; phone?: string | null; emailHash?: string | null; phoneHash?: string | null; contactId?: string | null }
+  want?: string[]
+}
+```
+
+**ConnectorLookupResult** (interface)
+```typescript
+interface ConnectorLookupResult {
+  found: boolean
+  memberId?: string | null
+  tier?: string | null
+  points?: number | null
+  status?: string | null
+  attributes?: Record<string, unknown>
+  asOf?: string | null
+}
+```
+
+**EventEnvelope** (interface)
+```typescript
+interface EventEnvelope {
+  specVersion: number
+  id: string
+  type: string
+  entityType: string | null
+  entityId: string | null
+  occurredAt: string
+  collectionId: string
+  orgId: string
+  appId: string | null
+  identity: {
+  contactId: string | null
+  userId: string | null
+  externalIds: Record<string, string>
+  anonymousId: string | null
+  sessionId: string | null
+  emailHash?: string | null
+  phoneHash?: string | null
+  hashAlgorithm?: 'hmac-sha256' | null
+  email?: string | null
+  phone?: string | null
+  }
+  identityPolicy: IdentityPolicy
+  product: { id: string; name?: string | null; sku?: string | null; gtin?: string | null; variantId?: string | null; batchId?: string | null } | null
+  proof: { id: string } | null
+  consent: { channels: Record<'email' | 'sms' | 'push' | 'whatsapp', 'opted_in' | 'opted_out' | 'suppressed' | 'unknown'>; topics: Record<string, boolean>; updatedAt: string | null } | null
+  subject: Record<string, unknown>
+  event?: { name: string; attributes: Record<string, unknown>; rule: string | null }
+  attributes: Record<string, unknown>
+}
+```
+
 **CapturedRequest** (interface)
 ```typescript
 interface CapturedRequest {
@@ -8367,9 +8470,15 @@ interface RecordTypesResponse {
 
 **FlowAuthMethod** = `'api_key' | 'bearer' | 'basic' | 'webhook' | 'oauth2' | 'none'`
 
+**IdentityPolicy** = `'externalIds' | 'hashed' | 'raw'`
+
+**FlowSourceEntity** = `'product' | 'interaction' | 'contact' | 'event'`
+
+**FlowTargetEntity** = `'product' | 'contact'`
+
 **UpdateFlowInput** = `Partial<Omit<CreateFlowInput, 'direction'>> & {`
 
-**ConnectorConsoleStep** = `'testConnection' | 'describeTarget' | 'sample' | 'shape' | 'serialize'`
+**ConnectorConsoleStep** = `'testConnection' | 'describeTarget' | 'sample' | 'shape' | 'serialize' | 'describeEvents' | 'lookup'`
 
 **RunTrigger** = `'manual' | 'event' | 'schedule' | 'test'`
 
@@ -12894,6 +13003,22 @@ Save a connector's non-secret Connect-form values and/or settings. PUT /integrat
     input: Record<string, unknown> & { flowId?: string } = {}) → `Promise<T>`
 Run a connector step from the console: `testConnection` → ConnectorTestResult, `describeTarget` → ConnectorTargetSchema, `sample` → ConnectorRecords, and dry runs of `shape` ({ records }) → ConnectorShapeResult and `serialize` ({ documents }) → ConnectorSerializeResult. The server adds the installation; pass `flowId` to layer that flow's settings. POST /integrations/connectors/:appId/steps/:step
 
+**runConnectorAction**(collectionId: string,
+    appId: string,
+    action: string,
+    input: Record<string, unknown> = {}) → `Promise<T>`
+Invoke a connector ACTION from the console (any visibility): redeem, enrol, adjust points, issue a coupon… The connector's function runs with its own credentials and is told who asked. POST /integrations/connectors/:appId/actions/:action { input }
+
+**listConnectorActions**(collectionId: string,
+    appId: string) → `Promise<`
+PUBLIC (the Hub, a site): the connector actions the caller may invoke — those declared `public`, plus `member` ones when signed in. GET /public/collection/:collectionId/connectors/:appId/actions
+
+**callConnectorAction**(collectionId: string,
+    appId: string,
+    action: string,
+    input: Record<string, unknown> = {}) → `Promise<T>`
+PUBLIC (the Hub, a site): invoke a connector action — e.g. redeem a reward for the signed-in member. 401 SIGN_IN_REQUIRED for a `member` action without a session; 403 for an admin-only one; 400 with `missing[]` when a required input is absent. POST /public/collection/:collectionId/connectors/:appId/actions/:action { input }
+
 ### interactions
 
 **query**(collectionId: string,

package/dist/docs/connectors.md

@@ -1,7 +1,7 @@
 # Integration connectors
 
 A **connector** is an app that knows one external provider (a PIM, a content network, a shop
-platform…). It is installed on a collection like any app, versioned and released like any app, and
+platform, a loyalty or CRM system…). It is installed on a collection like any app, versioned and released like any app, and
 it adds a manifest `connector` block plus a handful of [server functions](server-functions.md) the
 integration engine and the integrations console call by convention.
 
@@ -83,7 +83,7 @@ Types: `AppConnectorDeclaration` and friends in `@proveanything/smartlinks` (`sr
 | `provider` | Stable provider key (`syndigo`, `oneworldsync`). |
 | `title` | Provider display name; defaults to the app name. |
 | `directions` | `inbound` (provider → SmartLinks), `outbound` (SmartLinks → provider), or both. |
-| `entities` | SmartLinks entities it maps, e.g. `["product"]`. |
+| `entities` | SmartLinks entities it maps: `product`, and for people-shaped providers `interaction`, `contact`, `event` (see [Loyalty and CRM connectors](#loyalty-and-crm-connectors)). |
 | `connection.fields[]` | The console's **Connect** form. A field with `secret` is stored as this app's secret of that name on the collection (write-only; never returned to the browser). Other fields are saved in the installation's connection settings. |
 | `settings` | JSON Schema for installation settings; the console renders it as a form. |
 | `presets[]` | Ready-made flows ("Products → provider"). A preset's `flow.config.fieldMappings` is a **suggested** mapping: the connector's knowledge of the provider, which the customer accepts or edits in core. |
@@ -91,7 +91,8 @@ Types: `AppConnectorDeclaration` and friends in `@proveanything/smartlinks` (`sr
 | `panels[]` | Provider-specific screens the console mounts (an API explorer, a status page). |
 | `aiGuide` | A guide the mapping assistant reads: the provider's quirks, required fields, good defaults. |
 | `recordId` | Path of the provider's own id in a fetched record (e.g. `gtin`). Inbound records are landed and matched by it, so a re-import updates the same product instead of creating another. Default `id`; a flow can override it (`config.upsert.externalIdPath`). |
-| `limits` | `{ requestsPerSecond }` toward the provider, enforced across every SmartLinks worker. |
+| `limits` | `{ requestsPerSecond }` toward the provider, enforced across every SmartLinks worker; `{ maxEvents, maxAttributes }` when the provider caps registered events — a flow's `eventMapping` is checked against them when saved. |
+| `actions[]` | Provider operations invoked on demand (redeem, enrol, issue…): name, title, function, `visibility`, input schema. See [Actions](#actions-provider-operations-on-demand). |
 
 ---
 
@@ -111,7 +112,9 @@ declare the provider's hosts (`network:<host>`) and the secrets it reads (`secre
 | `fetch` | Every inbound run | `ConnectorFetchInput` `{ installation, cursor, limit }` | `ConnectorRecords` `{ records, nextCursor }`: one page per call |
 | `shape` | Every inbound run (and sample dry runs) | `ConnectorShapeInput` `{ installation, records }` | `ConnectorShapeResult` `{ documents, skipped }`: one provider-neutral document per record, same order; `null` skips one |
 | `serialize` | Every outbound run | `ConnectorSerializeInput` `{ installation, documents, entities, targetOptions, eventType? }`: documents core mapped to `describeTarget` paths; `entities` = the SmartLinks record each came from (id, name); `targetOptions` = per-field options the mapping carries (e.g. locale, unit); a deletion arrives as `{ id, _deleted: true }` | `ConnectorSerializeResult` `{ payloads, skipped }`: one provider payload per document, same order; `null` skips one |
-| `send` | Every outbound run | `ConnectorSendInput` `{ installation, payloads }` | `ConnectorSendResult` `{ results: [{ index, ok, status, error, externalId }] }` |
+| `send` | Every outbound run | `ConnectorSendInput` `{ installation, payloads, eventType? }` | `ConnectorSendResult` `{ results: [{ index, ok, status, error, externalId, retryable?, retryAfterSeconds? }] }` — `retryable: false` for a provider validation error (dead at once), `true` / a 5xx or 429 status for anything worth retrying |
+| `describeEvents` | Mapper opens; a flow with an `eventMapping` is saved | `{ installation }` | `ConnectorEventsSchema` `{ events: [{ name, title, attributes: [{ name, type, required }] }], limits: { maxEvents, maxAttributes } }`: the event names the provider has registered for this customer |
+| `lookup` | An entitlement check (`docs/entitlements.md`) | `ConnectorLookupInput` `{ installation, identity: { externalId, email, phone } \| { externalId, emailHash, phoneHash }, want }` | `ConnectorLookupResult` `{ found, memberId, tier, points, status, attributes, asOf }`. Throw for an outage — never `found: false` |
 
 **How a run flows:**
 - **Inbound:** `fetch` (paged; every record is landed as received) → `shape` → core maps the documents
@@ -182,6 +185,96 @@ export async function shape(_ctx: any, event: any): Promise<ConnectorShapeResult
 
 ---
 
+## Loyalty and CRM connectors
+
+A provider that is about **people** rather than products uses the same contract with three more
+pieces; nothing provider-specific lives in core. Full contract: `loyalty-connector-authoring.md` in the
+platform's design docs; the shapes are in [integrations.md](integrations.md#event-sourced-flows-and-the-envelope).
+
+| Flow | What core does | What the connector does |
+|---|---|---|
+| **Earn** (us → them) | an outbound flow with `sourceEntity: 'interaction' \| 'contact' \| 'event'` sends one **envelope** per event, through the flow's identity policy and `eventMapping`, signed, with retries and a run log | `describeEvents` (what the provider has registered), `serialize` (envelope → the provider's event payload), `send` if the generic HTTP destination can't make the call |
+| **Profile** (them → us) | `ctx.sl.members.apply(document)` matches the contact and writes member id, tier, points, tags, external ids; or an inbound flow with `targetEntity: 'contact'` | an **HTTP-trigger function** receiving the provider's member webhook (verify their signature, then apply); or `fetch` + `shape` for a poll |
+| **Gate / display** (on demand) | `entitlements.check` — claims → cached `lookup` → the contact's own loyalty fields → fallback; Valkey cache keyed on an identity hash, brand-set TTL | `lookup`: one identity → tier / points / status |
+
+```ts
+// A member webhook: the provider tells us about a person; we land it on the contact.
+export default async function memberWebhook(event: any, ctx: any) {
+  verifyProviderSignature(event, await ctx.secrets.get('webhookSecret'))
+  const m = event.body
+  return ctx.sl.members.apply({
+    identity: { externalId: m.memberId, email: m.email },
+    contact:  { firstName: m.firstName, lastName: m.lastName },        // fills empty fields only
+    loyalty:  { memberId: m.memberId, tier: m.tier, points: m.points, status: m.status, asOf: m.updatedAt },
+    tags:     { add: [`tier:${m.tier}`] },
+  }, { provider: 'acme-loyalty' })                                     // → { contactId, op: 'created' | 'updated' | 'unchanged' }
+}
+```
+
+Declare it `{ "trigger": { "type": "http" }, "capabilities": ["sl:members:write", "secrets:webhookSecret"] }`;
+`sl:members:write` is approved by the admin on install. The envelope's `identity.externalIds[<provider>]`
+is the member id this wrote back, so **Earn** can address the member by the provider's own id.
+
+A connector should ship an `eventMapping` **preset** with the provider's standard event names and an
+`aiGuide` paragraph, so the console's assistant proposes a customer's mapping in the provider's terms.
+
+---
+
+## Actions: provider operations on demand
+
+Steps are called by the engine. **Actions** are called when someone asks: redeem a reward, enrol a
+member, issue a coupon, raise a ticket, send a receipt, check a balance. A connector declares them in
+the manifest and implements each as a server function; the platform decides who may call them and
+runs them with the connector's credentials, telling the function who asked.
+
+```jsonc
+"connector": {
+  "actions": [
+    { "name": "redeem", "title": "Redeem a reward", "function": "redeemReward", "visibility": "member",
+      "input": { "type": "object", "required": ["rewardId"], "properties": { "rewardId": { "type": "string" } } } },
+    { "name": "enrol", "title": "Join the programme", "function": "enrolMember", "visibility": "member" },
+    { "name": "coupon-status", "title": "Coupon status", "function": "couponStatus", "visibility": "public" },
+    { "name": "adjust-points", "title": "Adjust points", "function": "adjustPoints" }     // admin only (the default)
+  ]
+}
+```
+
+| `visibility` | Who may invoke it |
+|---|---|
+| `admin` (default) | the console and admin API; any app function |
+| `member` | also a signed-in person through the Hub / a site |
+| `public` | also anyone |
+
+The function receives `event.body = { input, installation, caller: { userId, contactId, role, surface } }`
+and returns JSON (or a `Response`). `input.required` fields from the declared schema are checked before
+the function runs (400 with `missing[]`); fuller validation is the connector's job.
+
+```ts
+export async function redeemReward(ctx: any, event: any) {
+  const { input, caller } = event.body
+  if (!caller.contactId) return new Response(JSON.stringify({ error: 'no_contact' }), { status: 400 })
+  const memberId = (await ctx.sl.contacts.forCaller())?.customFields?.loyaltyMemberId   // written by Profile
+  const res = await ctx.fetch(`${api}/members/${memberId}/redemptions`, { method: 'POST', headers: auth(await ctx.secrets.get('apiKey')), body: JSON.stringify({ reward: input.rewardId }) })
+  return res.json()
+}
+```
+
+Calling an action:
+
+```ts
+// From the Hub or a site (visibility public / member):
+const { actions } = await integrations.listConnectorActions(collectionId, 'acme-loyalty')
+const out = await integrations.callConnectorAction(collectionId, 'acme-loyalty', 'redeem', { rewardId: 'R-5' })
+
+// From another app's server function (any visibility; needs sl:connectors:write):
+const out = await ctx.sl.connectors.call('acme-loyalty', 'redeem', { rewardId: 'R-5' })
+
+// From the console (any visibility):
+await integrations.runConnectorAction(collectionId, 'acme-loyalty', 'adjust-points', { memberId, delta: 100 })
+```
+
+---
+
 ## Where configuration lives
 
 | What | Where |
@@ -220,6 +313,7 @@ await secrets.put(collectionId, 'provider-key', value, { appId })              /
 await integrations.saveConnectorInstallation(collectionId, appId, { connection: { environment: 'production' } })
 const test = await integrations.runConnectorStep(collectionId, appId, 'testConnection')
 const target = await integrations.runConnectorStep(collectionId, appId, 'describeTarget')
+const events = await integrations.runConnectorStep(collectionId, appId, 'describeEvents')   // loyalty / engagement providers
 const { records } = await integrations.runConnectorStep(collectionId, appId, 'sample', { limit: 5 })
 const shaped = await integrations.runConnectorStep(collectionId, appId, 'shape', { records })      // dry run
 const wire = await integrations.runConnectorStep(collectionId, appId, 'serialize', { documents })  // dry run

package/dist/docs/entitlements.md

@@ -0,0 +1,90 @@
+# Entitlements: "can this person do this?" without a mirror of their member base
+
+A brand with twenty million members wants a game only Gold members can play. SmartLinks never copies
+the member base to find out. A **gate** says what it needs — a predicate such as `tier>=gold` — and the
+platform asks the collection's configured **sources**, in order, stopping at the first that answers.
+The brand's system stays the record of truth; every answer says where it came from (`basis`) and how
+old it is (`asOf`).
+
+| Source | Data kept here | When it fits |
+|---|---|---|
+| **claims** | none | the brand's SSO or app issues a short-lived signed token carrying the tier; the caller presents it |
+| **lookup** | a hashed key → a small answer, for minutes | the loyalty connector's `lookup` step answers for one person; cached in Valkey under an HMAC of the identity for the TTL the brand sets (default 15 min; "not a member" 5 min); one in-flight lookup per key; the connector's own rate limit applies |
+| **contact** | what the contact already holds | `customFields.loyalty` / `loyaltyTier` written by the connector's member webhook (`ctx.sl.members.apply`) |
+| **fallback** | — | when nothing answered: `deny` (default), `allow`, or `degrade` (allow, flagged `degraded: true`) |
+
+Every decision is one structured log line — gate, predicate, allowed, basis, age, an identity **hash**
+— and never an identifier. A caller sees `attributes` (tier, points, status, member) and never a member
+id.
+
+## Predicates
+
+```
+'tier>=gold'   'tier=silver'   'tier in gold,platinum'   'points>=500'   'member'
+{ tier: { gte: 'gold' } }   { tier: { in: ['gold', 'platinum'] } }   { member: true }
+{ attribute: { path: 'status', eq: 'active' } }
+{ all: [p1, p2] }   { any: [p1, p2] }   { not: p }
+```
+
+Tier comparisons use the collection's ordered `tiers` list (lowest first); a tier the list doesn't know
+never satisfies an ordered comparison. A malformed predicate is a configuration error (`BAD_PREDICATE`),
+never a silent denial.
+
+## Where gates live
+
+**An interaction type** — the public submit route checks it; the caller may present a claim:
+
+```ts
+await SL.interactions.updateInteraction(collectionId, appId, typeId, {
+  permissions: { allowPublicSubmit: true, requires: { entitlement: 'tier>=gold', fallback: 'deny' } },
+})
+// A refused submit: 403 { error: 'FORBIDDEN', reason: 'entitlement_denied' }
+// With a claim: body.entitlementToken = '<jwt>'  or header X-SmartLinks-Entitlement: <jwt>
+```
+
+**A server function** — for the signed-in caller by default:
+
+```ts
+const d = await ctx.sl.entitlements.check('tier>=gold')          // needs sl:entitlements:read
+// → { allowed: true, basis: 'lookup-cache', asOf: '2026-11-08T09:00:00.000Z', attributes: { tier: 'gold', points: 1500, member: true } }
+if (!d.allowed) return new Response(JSON.stringify({ error: 'gold_only' }), { status: 403 })
+// Someone else, or a presented claim:
+await ctx.sl.entitlements.check({ points: { gte: 500 } }, { identity: { email }, token, fallback: 'degrade' })
+```
+
+## Configuring a collection
+
+The `entitlements` setting group (`settings.set(collectionId, 'entitlements', {...})`):
+
+```jsonc
+{
+  "sources": ["claims", "lookup", "contact"],        // tried in this order
+  "fallback": "deny",
+  "tiers": ["bronze", "silver", "gold", "platinum"], // lowest first
+  "claims": {
+    "secretRef": "sec_brand_sso",                     // HS256 shared secret in the secret store …
+    "publicKeyPem": "-----BEGIN PUBLIC KEY-----…",     // … or an RS256 / ES256 public key
+    "issuer": "https://login.brand.example", "audience": "smartlinks",
+    "tierClaim": "tier", "memberIdClaim": "sub", "attributesClaim": "entitlements", "maxAgeSec": 900
+  },
+  "lookup": {
+    "connectorAppId": "acme-loyalty", "provider": "acme-loyalty",
+    "ttlSec": 900, "negativeTtlSec": 300,
+    "identity": "raw",                                // what the connector's lookup receives: 'raw' (email/phone) or 'hashed'
+    "want": ["tier", "points", "status"]
+  }
+}
+```
+
+The connector side (`lookup`) is one step: one identity in, `{ found, memberId, tier, points, status,
+asOf }` out; throw on an outage so the next source is tried — see
+[connectors.md](connectors.md#loyalty-and-crm-connectors).
+
+## What a brand can be told
+
+- We never need a copy of your member base: claims and lookups hold nothing, or a minutes-old answer per
+  active person.
+- Where you want a local copy, it holds no identifiers (the HMAC mirror — on request).
+- Your system remains the record of truth: every answer carries `asOf` and `basis`; TTLs are yours to set.
+- You see every call: the connector's calls are rate-limited, logged, and leave from a fixed egress IP.
+- Nothing leaves without a policy: the envelope's identity policy per flow.