@fayz-ai/core 0.9.0 → 0.11.0

package/src/search/text.ts

@@ -1,206 +0,0 @@
-// Text folding + ranking for global search. The same folding must exist in SQL
-// as public.fayz_norm() (@fayz-ai/db 018_global_search.sql), or server and
-// client disagree on what matched.
-
-const COMBINING_MARKS = /[\u0300-\u036f]/g
-
-/** Strip diacritics, lowercase, collapse non-alphanumerics to single spaces. */
-export function foldText(value: unknown): string {
-  if (typeof value !== 'string' || value === '') return ''
-  return value
-    .normalize('NFD')
-    .replace(COMBINING_MARKS, '')
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, ' ')
-    .trim()
-}
-
-/** Fold, keeping each folded char's index in the source — used for highlighting. */
-export function foldWithMap(value: string): { folded: string; map: number[] } {
-  const out: string[] = []
-  const map: number[] = []
-  let pendingSpace = false
-  for (let i = 0; i < value.length; i++) {
-    const ch = value[i]!
-    const folded = ch.normalize('NFD').replace(COMBINING_MARKS, '').toLowerCase()
-    for (const f of folded) {
-      const alnum = (f >= 'a' && f <= 'z') || (f >= '0' && f <= '9')
-      if (!alnum) { pendingSpace = out.length > 0; continue }
-      if (pendingSpace) { out.push(' '); map.push(i); pendingSpace = false }
-      out.push(f)
-      map.push(i)
-    }
-  }
-  return { folded: out.join(''), map }
-}
-
-/** Digits only — phone numbers, CPF/CNPJ, SKUs typed with separators. */
-export function digitsOf(value: unknown): string {
-  return typeof value === 'string' ? value.replace(/\D+/g, '') : ''
-}
-
-export interface NormalizedQuery {
-  /** What the user typed, untouched. */
-  raw: string
-  /** Folded form of the whole query — the "phrase". */
-  folded: string
-  /** Folded query split on whitespace. */
-  tokens: string[]
-  /** Digits the user typed, when they typed enough of them to mean a number. */
-  digits: string
-  /** The longest token — the most selective thing to send to a `%LIKE%` backend. */
-  anchor: string
-}
-
-/** Below this a phone/document lookup is indistinguishable from noise. */
-const MIN_DIGIT_QUERY = 4
-
-export function normalizeQuery(raw: string): NormalizedQuery {
-  const folded = foldText(raw)
-  const tokens = folded ? folded.split(' ').filter(Boolean) : []
-  const digits = raw.replace(/\D+/g, '')
-  let anchor = ''
-  for (const token of tokens) if (token.length > anchor.length) anchor = token
-  return {
-    raw,
-    folded,
-    tokens,
-    digits: digits.length >= MIN_DIGIT_QUERY ? digits : '',
-    anchor,
-  }
-}
-
-// Fuzzy similarity — Sørensen–Dice over bigrams. Same family as pg_trgm's
-// similarity(), so both sides rank near-misses the same way.
-
-function bigrams(value: string): string[] {
-  if (value.length < 2) return value ? [value] : []
-  const out: string[] = []
-  for (let i = 0; i < value.length - 1; i++) out.push(value.slice(i, i + 2))
-  return out
-}
-
-/** 0 (nothing in common) … 1 (identical). Both inputs must already be folded. */
-export function similarity(a: string, b: string): number {
-  if (!a || !b) return 0
-  if (a === b) return 1
-  const left = bigrams(a)
-  const right = bigrams(b)
-  if (left.length === 0 || right.length === 0) return 0
-  const pool = new Map<string, number>()
-  for (const g of left) pool.set(g, (pool.get(g) ?? 0) + 1)
-  let shared = 0
-  for (const g of right) {
-    const count = pool.get(g)
-    if (count) { shared++; pool.set(g, count - 1) }
-  }
-  return (2 * shared) / (left.length + right.length)
-}
-
-/** Best similarity between the query token and any single word of the text. */
-function wordSimilarity(text: string, token: string): number {
-  let best = similarity(text, token)
-  for (const word of text.split(' ')) {
-    if (!word) continue
-    const s = similarity(word, token)
-    if (s > best) best = s
-  }
-  return best
-}
-
-// ---------------------------------------------------------------------------
-// Ranking
-// ---------------------------------------------------------------------------
-
-export interface RankCandidate {
-  /** Folded display name — what the user is most likely aiming at. */
-  title: string
-  /** Folded concatenation of every searchable value on the record. */
-  haystack: string
-  /** Digits of every phone/document-ish value on the record. */
-  digits?: string
-}
-
-/** A fuzzy word has to be at least this close before it counts as a match. */
-const FUZZY_FLOOR = 0.62
-
-/** Score a candidate 0…1. Zero means "not a match" — the score is also the filter. */
-export function scoreCandidate(query: NormalizedQuery, candidate: RankCandidate): number {
-  const { folded, tokens } = query
-  if (!folded || tokens.length === 0) return 0
-  const title = candidate.title
-  const haystack = candidate.haystack || title
-
-  // Phrase: the query as one string.
-  let phrase = 0
-  if (title === folded) phrase = 1
-  else if (title.startsWith(folded)) phrase = 0.94
-  else if (title.includes(' ' + folded)) phrase = 0.88
-  else if (title.includes(folded)) phrase = 0.76
-  else if (haystack.startsWith(folded) || haystack.includes(' ' + folded)) phrase = 0.7
-  else if (haystack.includes(folded)) phrase = 0.62
-
-  // Tokens: every word must land somewhere ("maria silva" → "Maria da Silva").
-  let tokenTotal = 0
-  let fuzzyUsed = false
-  for (const token of tokens) {
-    let best = 0
-    if (title.startsWith(token)) best = 0.95
-    else if (title.includes(' ' + token)) best = 0.85
-    else if (title.includes(token)) best = 0.7
-    else if (haystack.startsWith(token) || haystack.includes(' ' + token)) best = 0.6
-    else if (haystack.includes(token)) best = 0.5
-    else {
-      const sim = wordSimilarity(title, token)
-      if (sim >= FUZZY_FLOOR) { best = 0.45 * sim; fuzzyUsed = true }
-    }
-    if (best === 0) return phrase > 0 ? phrase : 0
-    tokenTotal += best
-  }
-  let tokenScore = tokenTotal / tokens.length
-  // A typo-only match must never outrank a literal one.
-  if (fuzzyUsed) tokenScore *= 0.8
-
-  let score = Math.max(phrase, tokenScore)
-
-  // Digits: a phone number has no words to match.
-  if (query.digits && candidate.digits && candidate.digits.includes(query.digits)) {
-    score = Math.max(score, 0.72 + Math.min(0.2, query.digits.length / 50))
-  }
-
-  if (score === 0) return 0
-
-  // Tie-break: shorter title wins ("Ana" over "Ana Beatriz" for "ana").
-  const brevity = 1 / (1 + Math.max(0, title.length - folded.length) / 40)
-  return score * 0.97 + brevity * 0.03
-}
-
-/** Ranges in the ORIGINAL text covered by the query, merged and sorted. */
-export function highlightRanges(text: string, query: NormalizedQuery): Array<[number, number]> {
-  if (!text || query.tokens.length === 0) return []
-  const { folded, map } = foldWithMap(text)
-  if (!folded) return []
-  const spans: Array<[number, number]> = []
-  const needles = query.tokens.length > 1 ? [query.folded, ...query.tokens] : [query.folded]
-  for (const needle of needles) {
-    if (!needle) continue
-    let from = 0
-    for (;;) {
-      const at = folded.indexOf(needle, from)
-      if (at === -1) break
-      const start = map[at]
-      const endChar = map[at + needle.length - 1]
-      if (start !== undefined && endChar !== undefined) spans.push([start, endChar + 1])
-      from = at + needle.length
-    }
-  }
-  if (spans.length === 0) return []
-  spans.sort((a, b) => a[0] - b[0])
-  const merged: Array<[number, number]> = [spans[0]!]
-  for (const span of spans.slice(1)) {
-    const last = merged[merged.length - 1]!
-    if (span[0] <= last[1]) last[1] = Math.max(last[1], span[1])
-    else merged.push(span)
-  }
-  return merged
-}

package/src/search/types.ts

@@ -1,75 +0,0 @@
-import type { EntityDef } from '../types/crud'
-
-/** One searchable thing — declaring an entity is all it takes to be findable. */
-export interface SearchTarget {
-  /** Stable entity key (`deriveEntityKey`): 'person:client', 'product', … */
-  key: string
-  /** Plural human label; becomes the result group heading. */
-  label: string
-  icon?: string
-  entity: EntityDef
-  mockData?: Array<{ id: string }>
-  /** Multiplies the final score. Default 1. */
-  boost?: number
-}
-
-export interface SearchHit {
-  /** `${target.key}:${record id}` — stable across both search paths. */
-  uid: string
-  id: string
-  /** Target key this record came from. */
-  key: string
-  /** Group heading (the target's plural label). */
-  group: string
-  icon?: string
-  title: string
-  subtitle?: string
-  /** 0 … 1 (times the target boost). Higher is better. */
-  score: number
-  archetype?: string
-  archetypeKind?: string
-  table?: string
-  /** The row, when the path that found it had one. The index path returns
-   *  titles only. */
-  record?: Record<string, unknown>
-}
-
-export interface SearchGroup {
-  key: string
-  label: string
-  icon?: string
-  hits: SearchHit[]
-  /** True when this group hit its per-target cap — more matches exist. */
-  hasMore: boolean
-}
-
-export type SearchPath = 'index' | 'scan' | 'cache'
-
-export interface GlobalSearchResult {
-  query: string
-  hits: SearchHit[]
-  groups: SearchGroup[]
-  /** Which path produced this result — surfaced for diagnostics, not for UI. */
-  via: SearchPath
-  /** Targets whose query failed. Never fatal: a broken table cannot blind the box. */
-  failed: string[]
-  /** Wall-clock milliseconds. */
-  elapsedMs: number
-  /** True while a better (network) answer is still on its way. */
-  partial: boolean
-}
-
-export interface SearchOptions {
-  /** Permission filtering is the caller's job — the engine searches what it's handed. */
-  targets: SearchTarget[]
-  /** Max hits returned overall. Default 30. */
-  limit?: number
-  /** Max hits per target. Default 5. */
-  perTarget?: number
-  /** Fired with early/partial answers before the authoritative one resolves. */
-  onPartial?: (result: GlobalSearchResult) => void
-  /** Discard the result if this aborts. */
-  signal?: AbortSignal
-  /** Skip the server index and force the per-entity scan (tests, diagnostics). */
-  forceScan?: boolean
-}

package/src/seo/index.ts

@@ -1,128 +0,0 @@
-import { useEffect } from 'react'
-
-// ---------------------------------------------------------------------------
-// Generic, domain-agnostic SEO / structured-data head manager (SDK-level).
-// ANY surface (blog, booking, reviews, product, landing) uses `useSeo` to set
-// <title>, meta description, canonical, OpenGraph/Twitter cards and JSON-LD per
-// route. Domain plugins build their own schema.org objects (BlogPosting,
-// Product, Event…) and pass them via `jsonLd` — the mechanics live here once.
-//
-// NOTE: a SPA still benefits from SSR/prerendering for the strongest SEO — that
-// is the real upgrade; this covers everything achievable client-side.
-// ---------------------------------------------------------------------------
-
-const MANAGED = 'data-fayz-seo'
-
-export interface SeoConfig {
-  title: string
-  description?: string
-  canonical?: string
-  image?: string
-  type?: 'website' | 'article' | (string & {})
-  siteName?: string
-  /** One or more JSON-LD objects injected as <script type="application/ld+json">. */
-  jsonLd?: Array<Record<string, unknown>>
-}
-
-/** Current page origin (empty during SSR). */
-export function seoOrigin(): string {
-  return typeof window !== 'undefined' ? window.location.origin : ''
-}
-
-/** Build an absolute URL from a path, using the current origin. */
-export function absoluteUrl(path: string): string {
-  return `${seoOrigin()}${path.startsWith('/') ? path : `/${path}`}`
-}
-
-function upsertMeta(attr: 'name' | 'property', key: string, content: string) {
-  if (!content) return
-  let el = document.head.querySelector<HTMLMetaElement>(`meta[${attr}="${key}"]`)
-  if (!el) {
-    el = document.createElement('meta')
-    el.setAttribute(attr, key)
-    el.setAttribute(MANAGED, '')
-    document.head.appendChild(el)
-  }
-  el.setAttribute('content', content)
-}
-
-function upsertLink(rel: string, href: string) {
-  if (!href) return
-  let el = document.head.querySelector<HTMLLinkElement>(`link[rel="${rel}"]`)
-  if (!el) {
-    el = document.createElement('link')
-    el.setAttribute('rel', rel)
-    el.setAttribute(MANAGED, '')
-    document.head.appendChild(el)
-  }
-  el.setAttribute('href', href)
-}
-
-function clearManaged() {
-  document.head.querySelectorAll(`[${MANAGED}]`).forEach((el) => el.remove())
-}
-
-/** Imperatively apply SEO tags (used by useSeo; exported for non-React callers). */
-export function applySeo(config: SeoConfig): void {
-  if (typeof document === 'undefined') return
-  clearManaged()
-  document.title = config.title
-  upsertMeta('name', 'description', config.description ?? '')
-  if (config.canonical) upsertLink('canonical', config.canonical)
-
-  upsertMeta('property', 'og:title', config.title)
-  upsertMeta('property', 'og:description', config.description ?? '')
-  upsertMeta('property', 'og:type', config.type === 'article' ? 'article' : 'website')
-  if (config.canonical) upsertMeta('property', 'og:url', config.canonical)
-  if (config.image) upsertMeta('property', 'og:image', config.image)
-  if (config.siteName) upsertMeta('property', 'og:site_name', config.siteName)
-
-  upsertMeta('name', 'twitter:card', config.image ? 'summary_large_image' : 'summary')
-  upsertMeta('name', 'twitter:title', config.title)
-  upsertMeta('name', 'twitter:description', config.description ?? '')
-  if (config.image) upsertMeta('name', 'twitter:image', config.image)
-
-  for (const obj of config.jsonLd ?? []) {
-    const script = document.createElement('script')
-    script.type = 'application/ld+json'
-    script.setAttribute(MANAGED, '')
-    script.text = JSON.stringify(obj)
-    document.head.appendChild(script)
-  }
-}
-
-/** Apply SEO head tags for the current route; cleans up on unmount. */
-export function useSeo(config: SeoConfig): void {
-  const key = JSON.stringify(config)
-  useEffect(() => {
-    applySeo(config)
-    return () => clearManaged()
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [key])
-}
-
-// --- Generic schema.org builders (reusable across plugins) -----------------
-
-export interface BreadcrumbItem {
-  name: string
-  url: string
-}
-
-/** schema.org BreadcrumbList from an ordered list of crumbs. */
-export function breadcrumbJsonLd(items: BreadcrumbItem[]): Record<string, unknown> {
-  return {
-    '@context': 'https://schema.org',
-    '@type': 'BreadcrumbList',
-    itemListElement: items.map((c, i) => ({
-      '@type': 'ListItem',
-      position: i + 1,
-      name: c.name,
-      item: c.url,
-    })),
-  }
-}
-
-/** schema.org Organization publisher block. */
-export function organizationJsonLd(name: string, extra?: Record<string, unknown>): Record<string, unknown> {
-  return { '@type': 'Organization', name, ...extra }
-}

package/src/tenant/index.ts

@@ -1,38 +0,0 @@
-// Active tenant context — a global accessor the data layer reads for tenant
-// scoping and cache keying. The host (saas shell / app) sets it from its org
-// store via setActiveTenantId; the data providers stay decoupled from any
-// specific org-store implementation (runtime DI).
-import * as React from 'react'
-import { clearGlobalCache } from '../lib/cache'
-
-let _activeTenantId: string | undefined
-const listeners = new Set<() => void>()
-
-export function setActiveTenantId(id: string | undefined): void {
-  if (id !== _activeTenantId) {
-    _activeTenantId = id
-    clearGlobalCache()
-    for (const l of listeners) l()
-  }
-}
-
-export function getActiveTenantId(): string | undefined {
-  return _activeTenantId
-}
-
-/**
- * Subscribes to tenant changes. A getter alone makes every read a race with the
- * shell: a view that mounts before the org store resolves reads `undefined`,
- * and a tenant-scoped fetch that answers "no tenant" looks exactly like "no
- * rows" — it never retries and the screen stays empty until a remount.
- */
-export function subscribeActiveTenant(listener: () => void): () => void {
-  listeners.add(listener)
-  return () => { listeners.delete(listener) }
-}
-
-/** The active tenant, re-rendering when it resolves or changes. Use this to key
- *  effects that fetch tenant-scoped data. */
-export function useActiveTenantId(): string | undefined {
-  return React.useSyncExternalStore(subscribeActiveTenant, getActiveTenantId, getActiveTenantId)
-}

package/src/testing/index.ts

@@ -1,116 +0,0 @@
-// ---------------------------------------------------------------------------
-// Plugin contract assertions — the integrity half of the deploy gate.
-// ---------------------------------------------------------------------------
-// Framework-agnostic runtime checks (no test-runner dependency) that any
-// plugin's *.test.ts calls to prove its manifest/connector conform to the
-// platform contract BEFORE it can ship. A plugin that fails these would break
-// the host app at mount time (missing route component, duplicate ids, malformed
-// settings tab). Pair with a capability test (does the plugin do its job?) — see
-// docs/PLUGIN-PATTERNS.md → capability anatomy. These throw on the first violation.
-import type { PluginManifest } from '../types/plugins'
-import type { Connector } from '../integrations'
-
-export class PluginContractError extends Error {
-  constructor(message: string) {
-    super(message)
-    this.name = 'PluginContractError'
-  }
-}
-
-function fail(scope: string, msg: string): never {
-  throw new PluginContractError(`[${scope}] ${msg}`)
-}
-
-function nonEmptyString(v: unknown): v is string {
-  return typeof v === 'string' && v.trim().length > 0
-}
-
-/**
- * Assert a PluginManifest is structurally sound enough to mount safely.
- * Checks identity, navigation/route wiring, settings tabs, declared features,
- * and id uniqueness. Throws PluginContractError on the first problem.
- */
-export function assertPluginManifestContract(manifest: PluginManifest): void {
-  const id = manifest?.id
-  const scope = nonEmptyString(id) ? id : '<unknown plugin>'
-
-  for (const field of ['id', 'name', 'icon', 'version'] as const) {
-    if (!nonEmptyString(manifest?.[field])) fail(scope, `manifest.${field} must be a non-empty string`)
-  }
-
-  if (!Array.isArray(manifest.navigation)) fail(scope, 'manifest.navigation must be an array (use [] for settings-only plugins)')
-  if (!Array.isArray(manifest.routes)) fail(scope, 'manifest.routes must be an array (use [] for settings-only plugins)')
-
-  // Every nav entry must point at a route; every route needs a path + component.
-  for (const [i, nav] of manifest.navigation.entries()) {
-    if (!nonEmptyString((nav as any)?.route)) fail(scope, `navigation[${i}].route must be a non-empty string`)
-  }
-  const routePaths = new Set<string>()
-  for (const [i, route] of manifest.routes.entries()) {
-    if (!nonEmptyString((route as any)?.path)) fail(scope, `routes[${i}].path must be a non-empty string`)
-    if (typeof (route as any)?.component !== 'function') fail(scope, `routes[${i}].component must be a component`)
-    if (routePaths.has((route as any).path)) fail(scope, `duplicate route path "${(route as any).path}"`)
-    routePaths.add((route as any).path)
-  }
-  // A nav entry that links to a route the plugin doesn't declare is dead UI.
-  for (const [i, nav] of manifest.navigation.entries()) {
-    const r = (nav as any).route
-    if (routePaths.size > 0 && !routePaths.has(r)) {
-      fail(scope, `navigation[${i}].route "${r}" has no matching route in manifest.routes`)
-    }
-  }
-
-  // Settings tabs (the only UI surface integrations need) must be renderable.
-  const settingIds = new Set<string>()
-  for (const [i, tab] of (manifest.settings ?? []).entries()) {
-    if (!nonEmptyString((tab as any)?.id)) fail(scope, `settings[${i}].id must be a non-empty string`)
-    if (!nonEmptyString((tab as any)?.label)) fail(scope, `settings[${i}].label must be a non-empty string`)
-    if (typeof (tab as any)?.component !== 'function') fail(scope, `settings[${i}].component must be a component`)
-    if (settingIds.has((tab as any).id)) fail(scope, `duplicate settings tab id "${(tab as any).id}"`)
-    settingIds.add((tab as any).id)
-  }
-
-  for (const [i, feat] of (manifest.declaredFeatures ?? []).entries()) {
-    if (!nonEmptyString((feat as any)?.id)) fail(scope, `declaredFeatures[${i}].id must be a non-empty string`)
-  }
-
-  // A plugin that contributes nothing mountable is almost always a mistake.
-  // (Connector-only addon plugins contribute via `connectors` instead.)
-  if (
-    manifest.navigation.length === 0 &&
-    manifest.routes.length === 0 &&
-    (manifest.settings ?? []).length === 0 &&
-    (manifest.connectors ?? []).length === 0
-  ) {
-    fail(scope, 'plugin contributes no navigation, routes, settings, or connectors — it would mount but do nothing')
-  }
-}
-
-const AUTH_KINDS = new Set(['oauth', 'api-key', 'mtls'])
-const DIRECTIONS = new Set(['inbound', 'outbound', 'bidirectional'])
-const TRIGGERS = new Set(['on-write', 'scheduled', 'manual', 'webhook'])
-
-/**
- * Assert an integration Connector descriptor is well-formed: identity present,
- * a known auth kind, and at least one capability with a valid direction +
- * trigger set. This is the contract a connector must satisfy BEFORE its
- * data-plane (edge function) exists — the TDD anchor for an integration.
- */
-export function assertConnectorContract(connector: Connector): void {
-  const scope = nonEmptyString(connector?.id) ? `connector:${connector.id}` : '<unknown connector>'
-  for (const field of ['id', 'provider', 'pluginId'] as const) {
-    if (!nonEmptyString(connector?.[field])) fail(scope, `connector.${field} must be a non-empty string`)
-  }
-  if (!AUTH_KINDS.has(connector.authKind)) fail(scope, `connector.authKind "${connector.authKind}" is not one of ${[...AUTH_KINDS].join(', ')}`)
-  if (!Array.isArray(connector.capabilities) || connector.capabilities.length === 0) {
-    fail(scope, 'connector.capabilities must list at least one capability')
-  }
-  for (const [i, cap] of connector.capabilities.entries()) {
-    if (!nonEmptyString(cap?.entity)) fail(scope, `capabilities[${i}].entity must be a non-empty string`)
-    if (!DIRECTIONS.has(cap.direction)) fail(scope, `capabilities[${i}].direction "${cap.direction}" is invalid`)
-    if (!Array.isArray(cap.triggers) || cap.triggers.length === 0) fail(scope, `capabilities[${i}].triggers must be non-empty`)
-    for (const trig of cap.triggers) {
-      if (!TRIGGERS.has(trig)) fail(scope, `capabilities[${i}] has unknown trigger "${trig}"`)
-    }
-  }
-}

package/src/types/auth.ts

@@ -1,41 +0,0 @@
-export type AuthProvider = 'google' | 'github' | 'apple' | 'facebook' | (string & {})
-
-export interface AuthUser {
-  id: string
-  email: string
-  fullName?: string
-  avatarUrl?: string
-  role?: string
-  /** Set on users created by an invite (magic link, no password). The shell shows
-   *  the set-password screen until they choose one — otherwise the only way back
-   *  in is another magic link. */
-  mustSetPassword?: boolean
-}
-
-export interface AuthSession {
-  user: AuthUser
-  accessToken: string
-  refreshToken?: string
-  expiresAt?: number
-}
-
-export interface AuthAdapter {
-  getSession(): Promise<{ user: AuthUser; session: AuthSession } | null>
-  onAuthStateChange(cb: (user: AuthUser | null) => void): () => void
-  signIn(email: string, password: string): Promise<AuthSession>
-  signUp(email: string, password: string, fullName: string): Promise<AuthSession>
-  signOut(): Promise<void>
-  signInWithOAuth(provider: AuthProvider): Promise<void>
-  resetPassword(email: string, options?: { redirectTo?: string }): Promise<void>
-  updatePassword?(password: string): Promise<AuthSession | void>
-  handleCallback?(url?: string): Promise<AuthSession | null>
-  /**
-   * Invite a user by e-mail via the provider's admin invite endpoint (e.g. Supabase
-   * GoTrue `auth.admin.inviteUserByEmail`). Creates the auth user in an "invited"
-   * state and sends the invite e-mail. `data` is written to the user's metadata so
-   * an accept-time trigger can provision membership (tenant_id/role). Requires a
-   * privileged path (service-role edge function) — not callable from the anon client.
-   * Optional: adapters without an admin path (mock) may omit it.
-   */
-  inviteUser?(email: string, options?: { redirectTo?: string; data?: Record<string, unknown> }): Promise<void>
-}

package/src/types/billing.ts

@@ -1,39 +0,0 @@
-import type { PlanEntitlements } from './entitlements'
-
-export interface Plan {
-  id: string
-  name: string
-  description?: string
-  price: number
-  currency: string
-  interval: 'month' | 'year'
-  /** Marketing bullets shown on the pricing page (display only). */
-  features: string[]
-  highlighted?: boolean
-  stripePriceId?: string
-  /**
-   * Structured access grants for this plan (feature gates + quantity caps). This
-   * is the enforcement source of truth — distinct from `features` (display
-   * bullets). See {@link PlanEntitlements}.
-   */
-  entitlements?: PlanEntitlements
-}
-
-/**
- * Signature of the checkout seam. When `BillingConfig.onCheckout` is defined the
- * shell's Subscription page calls it (passing the target plan id) INSTEAD of
- * writing `plan` straight onto the org via `adapter.updateOrg`. This is where a
- * real payment gateway (Stripe Checkout, Pix, Mercado Pago, …) plugs in: return
- * once the user is redirected / the intent is created, and let the webhook be the
- * source of truth for the persisted plan. Left undefined, the shell mutates the
- * plan optimistically (dev / self-serve / free-tier flows).
- */
-export type BillingCheckoutFn = (planId: string) => Promise<void> | void
-
-export interface BillingConfig {
-  plans: Plan[]
-  stripePublishableKey?: string
-  portalUrl?: string
-  /** Payment-gateway seam — see {@link BillingCheckoutFn}. */
-  onCheckout?: BillingCheckoutFn
-}