Skip to content

Open-source manufacturing ERP, MES and QMS. Quoting, MRP, inventory, shop floor, quality and lot/serial traceability on one Postgres schema, with a REST API and MCP server. Self-host or use Carbon Cloud.

27.1 KB
Raw Blame

@carbon/ee

Enterprise edition — integrations registry (incl. Ramp), accounting sync (Xero, QuickBooks Online, Rillet), plan gating, RBAC authoring (permissions), Slack, email, Jira, Linear, Onshape, the shared rules layer (storage + sales rules), the workflows engine, and SAML SSO. (Exchange rates are no longer an integration — the platform-global feed lives in @carbon/jobs update-exchange-rates. The planning engines — MRP + finite scheduling — moved OUT to the community-licensed @carbon/planning package; Material Planning is free.)

Always

  • MUST wrap provider-originated database writes in withTriggersDisabled() so SYNC subscriptions cannot echo them back to the provider.
  • MUST link external ids through createMappingService() and externalIntegrationMapping; do not add per-entity external-id columns.
  • MUST register server lifecycle hooks in src/hooks.server.ts; integration config files are shared with browser bundles.
  • MUST use the operation-specific helpers from @carbon/ee/ramp.server for Ramp state. patchRampSettings, patchRampOAuthCredentials, patchRampRefreshedTokens, patchRampConnection, patchRampWebhook, patchRampCursor, and patchRampAccountingConnectionProvider (the one helper that REMOVES its key) own disjoint paths and delegate to the atomic patchIntegrationState() RPC boundary.
  • MUST use FEATURE_PLANS for client and server plan gating. companyHasPlan() and requirePlan() intentionally allow non-Cloud editions and bypass-listed companies. For features that must be BLOCKED on the Community edition (RBAC authoring/permissions, console mode, and the entitlement-gated feature writes), use companyHasFeature/requireFeature/requireEntitlement instead — they return false/throw on Edition.Community (Enterprise/Test still pass). See .claude/rules/commercial-licensing.md.

Ask First

  • Adding a sync entity or provider — it requires an AccountingEntityType, provider syncer registration in SyncFactory, direction policy, subscriptions, and reconciler coverage.
  • Adding an integration to integrations, changing FEATURE_PLANS, or changing INTEGRATION_WHITELIST.
  • Changing Ramp state ownership or replacing upsert_company_integration_patch; concurrent settings, OAuth, webhook, token, and cursor writers depend on path-level composition.

Never

  • Never import *.server modules from integration config files; config.tsx is client-bundled.
  • Never full-replace Ramp metadata or Vault bags. Use src/ramp/lib/state.ts; stale read/merge/write loses concurrent sibling updates.
  • Never implement provider DELETE as a generic assumption. Entity adapters must explicitly support and verify their remote lifecycle.
  • Never hand-edit generated database types.

Validation Commands

pnpm --filter @carbon/ee test
pnpm --filter @carbon/ee typecheck

Key Exports

Subpath Provides
. Integration descriptors/registry, defineIntegration, and secret-resolution helpers
./accounting SyncFactory, provider adapters, mappings, posting policy, reconciliation helpers
./sync Role-agnostic sync core: SyncProviderCapabilities + resolveCapabilities (one capability surface for accounting AND spend providers), IntegrationTopology + buildIntegrationTopology (who owns each GL family, whose identifiers a target expects), applyLedgerDelegation + the branded EffectivePostingSyncSettings, and applyPartyContactRequirements / partyContactSettingsToEnable / PARTY_CONTACT_SETTING_COLUMN (the requiresPartyContactAndLocation capability that turns the party-contact company settings ON at install — the one ./sync export with a database side effect). Import-light on purpose — no @carbon/auth, so jobs and tests can use it without booting the server env
./integrations/secrets patchIntegrationState, Vault split/persist/resolve helpers, SECRET_KEYS
./ramp.server Ramp client, schemas, service operations, money/coding helpers, and key-owned state patches
./ramp/hooks.server rampOnInstall, rampOnUpdate, rampOnUninstall, rampHealthcheck
./oee Client-safe OEE provider contract (OeeProvider, OeeDevice, OeeStateChange, MachineState, OeeProviderUnavailableError — network failure, timeout or 5xx; the sync stops its run on it — and DEFAULT_MINIMUM_STATE_SECONDS), the pure attribution engine planMachineTime (LoadPeriod, BlockPeriod, RecordedInterval, MachineTimeWrite), and machineTimeRefusal(operationStatus, jobStatus) (oee/assignable.ts: "Done", "Canceled", "Locked" or null — the one "can this operation take machine time" rule for the sync, the assign write and the ERP suggestion cards)
./oee.server getOeeProvider (runtime, degrades through companyHasFeature("INTEGRATIONS"); resolves through createOeeProvider in oee/registry.ts, the one provider resolution, also behind the Sense healthcheck) and the authoring writes upsertWorkCenterDevice, deleteWorkCenterDevice, assignUnattributedMachineTime, dismissUnattributedMachineTime (each embeds requireEntitlement("INTEGRATIONS")). See .claude/rules/oee-provider.md
./sense/hooks.server senseHealthcheck, senseOnUninstall (the onUninstall hook that Settings → Integrations → Uninstall runs, registered in hooks.server.ts: ends the open sensor Machine events and running unattributed time of every Sense device of the company, under each device lock; the mappings stay)
./hooks.server getIntegrationServerHooks() registry
./approvals/document.server The document-level approval lifecycle shared by every approval document type: getDocumentApprovalState, openApprovalRequests (bulk; caller sends the notification), cancelPendingApprovals (bulk, optional requester-or-approver guard), decideApprovalRequest. Form validator: approvalDecisionValidator in ./approvals; modal: ~/components/Modals/ApprovalDecision in the ERP. Used by change notices, quality documents and suppliers; purchase orders keep their own amount-tiered flow
./plan, ./plan.server Client/server edition and feature-plan gates
./sso.server SAML connection, domain verification, session, and provisioning helpers
./rules, ./rules.server Storage- and sales-rule schemas and query services (client-safe), and the evaluators plus the entitlement-gated rule writes (server)
./workflows, ./workflows/help, ./workflows/labels The workflows engine — definition schema, normaliser, validator, generated catalog, pure runtime, and the sync.ts trigger/subscription reconciler (moved from @carbon/workflows). ./workflows/labels (WORKFLOW_LABELS) is Vite-only — the msg macro throws in plain Node
./mcp, ./mcp.server The MCP protocol engine (moved from apps/erp/.../api+/mcp+/lib). ./mcp = pure logic (catalog search, the agent's doc search createDocSearch, formatters, instructions, types) with no auth/entitlement chain — safe for tests; ./mcp.server = server.ts (serveMcpRequest, embeds requireEntitlement("MCP"), on MCP SDK v2 @modelcontextprotocol/server; serves 2025-era and 2026-07-28 clients). The dispatch + generated tool metadata stay in the app and are injected as deps
./workflows.server Workflows runtime lock: workflowsEnabledForCompany(companyId) (runtime DEGRADE — a non-entitled run settles Skipped, embedded in @carbon/jobs engine/execute.ts) and requireWorkflowsEntitlement(client, companyId) (authoring throw, embedded in the ERP's publishWorkflowVersion)
./jira, ./jira.server, ./linear, ./linear.server, ./onshape, ./paperless-parts Integration client/server seams
./onshape, ./onshape.server Onshape runtime shared by BOTH Onshape integrations — onshape (the public App Store app, client from ONSHAPE_CLIENT_*) and onshape-government (a customer-owned private OAuth app on their own tenant URL; tenant URL and client id/secret entered in settings; the tenant URL also serves OAuth, secret vaulted; always offered). Runtime code resolves the company's connection with getOnshapeIntegration rather than naming an id; getOnshapeOAuthConfig picks the client per variant; ./onshape.server (lib/index.server.ts) has beginOnshapeAuthorization / loadOnshapeOAuthConfig, the metadata patch helpers of lib/state.ts (patchOnshapeOAuthGrant, patchOnshapeSettings, …) and the panel's server-side property reads (lib/panel-properties.server.ts). externalIntegrationMapping rows stay under "onshape" for both. A company holds one active Onshape connection at a time (getConflictingOnshapeIntegration, app-level). The Onshape panel (onshape-v2, id from ./onshape/integration-id) is a third grant outside that rule, on its own Onshape app (client from ONSHAPE_V2_CLIENT_*, never ONSHAPE_CLIENT_*): panel code passes its id explicitly and keeps its own mapping namespace (.claude/rules/onshape-panel.md)
./slack.server, ./stripe-connect.server, ./xero/hooks.server, ./quickbooks/hooks.server, ./rillet/hooks.server Integration-specific server seams

Key Patterns

  • Planning — MOVED OUT of @carbon/ee. MRP + finite scheduling now live in the community-licensed @carbon/planning package (packages/planning/), so Material Planning is free/CE. See packages/planning/AGENTS.md.
  • Workflows — MOVED IN to @carbon/ee from @carbon/workflows. The whole engine (definition schema, validator, generated catalog, pure runtime, sync.ts reconciler) is now commercial under src/workflows/ — see packages/ee/src/workflows/AGENTS.md and .claude/rules/workflow-{event-catalog,matcher,engine,actions}.md. The lock is two seams in ./workflows.server: workflowsEnabledForCompany (runtime DEGRADE, embedded in @carbon/jobs engine/execute.ts) and requireWorkflowsEntitlement (authoring throw, embedded in the ERP's publishWorkflowVersion). The CE-safe wire contracts (runTriggerSchema/RunTrigger, the moment contract MOMENT_OUTPUT_KEYS/MomentKey/MomentEntityRef/MomentPayload) live in the leaf package @carbon/workflows-core (packages/workflows-core/), which @carbon/lib imports type-only — that leaf is what breaks the lib → ee → lib cycle the move would otherwise create. The engine's catalog/moments.ts keeps WORKFLOW_MOMENTS (source of truth) and re-exports the moment TYPES from the leaf; scripts/check-workflow-catalog.ts asserts the two never drift.
  • Accounting sync: class-per-entity syncers in accounting/providers/{xero,quickbooks-online,rillet}/entities/; SyncFactory.getSyncer() dispatches
  • Spend sync runs on the SAME engine, split neutral-core / provider-wire: SyncFactory is keyed on SyncProviderID (ProviderID | SpendProviderID), and SyncContext.provider is the structural SyncProvider interface rather than the AccountingProvider union — so RampProvider (ramp/lib/provider.ts, role: "spend") satisfies it without inheriting BaseProvider. src/spend/ is the provider-NEUTRAL half — SpendPushOnlyEntitySyncer, loadSpendVendorParties, loadPurchaseOrderPushSource, loadBillPushSource/loadBillPushLines, the eligibility gates.ts, and buildSpendSyncConfig (starts from everything disabled; enables only what a mode ceiling AND the stored toggles permit, the ceiling always winning). Every one is a statement about Carbon's schema or lifecycle, mirroring the accounting side's document-costing.ts / sales-invoice-source.ts / card-charge-source.ts. src/ramp/entities/ is the WIRE — payload shapes, idempotency, and rules genuinely Ramp's (its draft bill is create-once because a Ramp draft has no delete endpoint). Adding Brex/Navan means adapters only. @carbon/ee/ramp/entities must be side-effect-imported for SyncFactory registration to run
  • Subscriptions are code-derived: accounting/core/subscriptions.ts — REQUIRED_SYNC_SUBSCRIPTIONS + idempotent ensureProviderSubscriptions() (exported from ./accounting), converged from the install/onUpdate hooks and the outbound sweep — never a write-once install artifact, never a migration backfill
  • Card charges represented once: accounting/core/posting.ts and every charge syncer's shouldSync() must agree on isDocBackedCharge() so a Ramp card spend pushes as either a native charge object OR a journal entry, never both
  • 60s cooldown: SYNC_OPERATION_COOLDOWN_MS (accounting/core/operations.ts) — a just-Completed ledger op absorbs event/webhook re-enqueues for 60s. Status-transition events bypass it via the non-cooldown posting trigger: a state change is never dropped by the cooldown
  • Truthful ledger: a drain no-op with no remote copy closes Skipped via skipOperation() (reason in errorMessage), never Completed; Skipped → Pending retry is allowed
  • Rillet idempotency keys are entity-scoped: buildRilletIdempotencyKey({companyId, operation, localId}) — the payload is deliberately NOT hashed, so a crash-retry with a drifted payload cannot double-create the remote document
  • Tie-out remote reads: accounting/core/remote-journal.ts fetchRemoteJournalTotals() — provider-agnostic debit-signed per-account journal totals for the reconciliation tie-out
  • Trial balance pull: accounting/core/remote-trial-balance.ts pullTrialBalanceFromProvider(client, db, { companyId, providerId, asOfDate }) → { lines, unmapped, ambiguous } on Carbon accounts, for the accounting activation wizard. fetchRemoteTrialBalance() dispatches like fetchRemoteJournalTotals (Xero /Reports/TrialBalance YTD columns, QBO /reports/TrialBalance Debit/Credit, Rillet /reports/trial-balance from Carbon's fiscal year start (fiscalYearSettings.startMonth, fiscalYearStart) to the date in its subsidiary — Rillet closes income and expense into retained earnings at from_date, so that is the fiscal year to date; it sends credit_total negative, read as a magnitude; parseRilletTrialBalance reads ending_balance debit-signed or natural-signed by /accounts type, whichever agrees with each account's movement and totals zero, else throws). The parsers and the pure mapper mapRemoteTrialBalance (mapping by external id → mapping by code → Carbon account number; several targets = ambiguous) live in core/trial-balance.ts. Failures throw TrialBalancePullError with a reason (not_connected/unsupported/reconnect/rate_limited/failed). isTrialBalanceProvider(id) says which providers the dispatch reads (the ERP shows the Pull button by it; remote-trial-balance.test.ts pins the two together). Xero needs the accounting.reports.trialbalance.read scope; older tokens get reconnect
  • Dependency sync: transaction syncers use ensureDependencySynced() for JIT deps (e.g. push customer before invoice)
  • Master data import: ALL THREE accounting descriptors (src/{rillet,xero,quickbooks}/config.tsx) declare actions posting to /api/integrations/master-sync?provider=…&direction=…, which fires accounting-master-sync (@carbon/jobs). It is the only on-demand PULL of master data — every build*SyncConfig still forces customer/vendor push-to-accounting, and the job enqueues pull-from-accounting ledger rows by hand. Enumeration goes through provider.listRemoteEntityIds + capabilities.importableEntities (providerSupportsMasterDataImport needs both), so adding a provider needs no edit to the job. RilletCustomerSyncer/RilletVendorSyncer implement mapToLocal/upsertLocal for it and extend RilletEntitySyncer; the pull rejections now live in RilletPushOnlyEntitySyncer (item + every transaction syncer). Importing exists to write the mapping row: upsertRemote reads getRemoteId(localId) first, so a Carbon sales invoice for an imported customer PUTs the original Rillet customer instead of creating a duplicate
  • Permissions (./permissions.server, src/permissions.server.ts): the licensed RBAC-authoring logic, gated to Business via the PERMISSIONS feature. updatePermissions (builds/persists the flattened userPermission.permissions object + audit diff + claims-cache bust), updateEmployee, employee-type CRUD (insert/upsert/deleteEmployeeType, upsertEmployeeTypePermissions), and the translators (makeEmptyPermissionsFromModules, makeCompanyPermissionsFromClaims, makeCompanyPermissionsFromEmployeeType). This is the ONLY copy of updatePermissions — the @carbon/jobs carbon/update-permissions (bulk-edit) task imports it here. Server-only. The ERP authoring UI stays .ee.tsx in apps/erp (couples to ~/components/Form); routes stay in the app and gate with requireFeature({ feature: "PERMISSIONS" }). The community invite primitives (the invite permission merge, makePermissionsFromEmployeeType) deliberately stay in the app's users.service.ts. Console/kiosk mode is a sibling: ./console.server — updateConsoleSetting(client, db, companyId, enabled, userId?) → { error, pin, pinError } writes companySettings.consoleEnabled over db (a trigger refuses API-role writes) behind requireEntitlement("PERMISSIONS"), provisions the protected "Console Operator" employee type and a PIN for the enabling user (returned once as pin; pinError when it could not be created); isConsoleModeEnabledForCompany(client, companyId, { consoleEnabled? }) is the runtime DEGRADE gate (flag AND entitlement; null when the settings read failed — never tear a live console session down on null); generateConsolePin, setEmployeePin(db, …), verifyEmployeePin(db, …) → { hasPin, valid } work on the bcrypt employeePin table, reachable only over the server's Kysely connection.
  • Commercial entitlement pattern (./entitlements.server, ./plan.server, and the per-feature .server modules): requireEntitlement(client, companyId, feature) (throws EntitlementError) is embedded at the top of every commercial authoring function so the gate lives in commercial code, not a strippable open route. Feature bodies moved here with in-code gates: ./approvals (approval rules), ./rules.server (sales + storage rules), ./api-keys.server, ./webhooks.server, ./two-factor.server (the requireMfa policy), ./forecast.server (demand forecasts + projections), ./customer-portals.server, ./audit.server (the audit-log engine — enableAuditLog embeds requireEntitlement("AUDIT_LOG"), skipped under CONTROLLED_ENVIRONMENT where audit is mandatory; auditConfig/types stay client-safe in @carbon/database), ./email-notifications.server (emailNotificationsEnabled — the EMAIL notification-channel gate, runtime DEGRADE; sendEmail transactional transport stays ungated in @carbon/lib), ./backups.server (requireBackupsEntitlement(companyId) — embedded at the top of the Inngest backup/restore/import durable functions in @carbon/jobs, IS_LOCAL_DEV-exempt; the engine is Inngest-coupled and stays in jobs), plus permissions/console above. Runtime paths that must degrade (not throw) use companyHasFeature (e.g. email notifications, webhook delivery). Full rationale: .claude/rules/commercial-licensing.md.
  • Ramp state helpers: src/ramp/lib/service.ts is a compatibility facade. Put connection/auth in connection.ts, coding masters in chart-of-accounts.ts/cost-centers.ts, parties in suppliers.ts, PO/bill transport in spend.ts, confirms in sync-confirmation.ts, remote webhook lifecycle in webhooks.ts, and metadata/Vault writes in state.ts; @carbon/ee/ramp.server remains stable
  • Provider roles: every integration that participates in sync declares providerRole: "accounting" | "spend" | "oee" on its descriptor. That ONE declaration replaces the id lists that used to answer "which are accounting providers" five different ways, and the database enforces at most one ACTIVE integration per role per company (companyIntegration_single_active_role, migration 20260924133915) — except oee, which may have several active integrations at once (check_single_active_provider_role() skips it, migration 20261013030022); its one-device-per-work-center rule is UNIQUE(workCenterId, companyId) on workCenterDevice instead (.claude/rules/oee-provider.md). getIntegrationsByRole/getIntegrationIdsByRole (barrel) are the lookups; no-integration-id-branching (@carbon/checks) stops new id branching. NOTE the barrel cannot be imported from a *.service.ts (browser-bundled) or from most tests — it reaches @carbon/auth, which validates the full server env at import time; that is why ./sync takes the registry slice as an argument instead of importing it
  • Ledger delegation: when a spend provider's mode declares ownsLedgerFamilies, applyLedgerDelegation sets that family to "none" AND disables its backing entities — derived from POSTING_POLICY, never a hard-coded "bill". Each half alone is wrong (families-only leaves the document pushing; entity-only parks a DOC_SYNC_DISABLED Warning forever). getJournalPostingPolicyDecision accepts only EffectivePostingSyncSettings, so the compiler refuses a posting decision made from raw settings
  • Integration pattern: defineIntegration() → config with id, name, settings, OAuth, actions
  • Workflow integration connections: ./integrations/connections — named per-company connections to Activepieces pieces (integrationConnection table + its own connection:-prefixed vault RPCs). Distinct from ./integrations/secrets, which serves companyIntegration and allows only one row per integration per company. Tokens go to the vault, never to metadata; refresh is claimed via refreshingAt. The piece itself ships as an ORDINARY integration config (google-calendar/config.tsx, gmail/config.tsx, slack/config.tsx; id === the piece name) — the accounts list is a tab on its card, not a separate panel. Slack's Carbon Assistant (slack/lib/service.ts) is a consumer of that connection (getSlackWorkspace, oldest Active; inbound by team_id), never a second store. See .claude/rules/workflow-integrations.md
  • Internal-only integrations: internalOnly: true on a descriptor makes it installable on Carbon Cloud only by Carbon staff (isInternalEmail), in any company, and by the users the integration-early-access feature flag is on for, in the companies its rules name, or whose id is in INTEGRATION_EARLY_ACCESS_USER_IDS (a fallback until a flags source is live) (hasIntegrationEarlyAccess({ companyId, userId }), ./plan.server; evaluated on the server, so neither the rules nor the list reach the browser); everyone else sees a Coming soon card. Self-hosted editions are not gated. isIntegrationComingSoon (./plan) is the one rule; the ERP's isIntegrationInstallWithheld (modules/settings/settings.service.ts) applies it in the connect route, the install action and the onshape-v2 install route, and only to a company that does not have the integration installed. An integration with its own install route must call it there too
  • SAML SSO (./sso.server, src/sso/): isSsoEnabled() (gate.ts — Enterprise edition AND sso in AUTH_PROVIDERS) is the ONE flag; the connection lookups and admin mutations self-gate on it. provider.server.ts = GoTrue admin API wrappers + getSamlSpUrls; connections.server.ts = ssoConnection lookups (each attaches a computed domains: string[] of VERIFIED ssoDomain claims), isSsoRequiredForEmail, getSsoAwareInviteLink, upsert/requireSso/deactivate mutations, and the domain-claim flows addSsoDomain/verifySsoDomain/removeSsoDomain; verification.server.ts = the DNS TXT ownership challenge (_carbon-challenge.<domain> → carbon-domain-verification=<token>, checkDomainVerification with pinned public resolvers, one-shot manual verify — no polling or re-verification); session.server.ts = amr-based session classification (getSsoProviderIdFromSession for enforcement, never getSsoProviderIdFromUser); provisioning.server.ts = identity linking + invite-first migration + deleteJitSsoUser (full removal of a rejected throwaway JIT user — auth user AND its trigger-created user/userPermission rows, guarded on zero memberships; takes a Kysely<KyselyDatabase> param — callers pass their own db client) + the pre-seed helpers seedSsoIdentityForUser / backfillSsoIdentitiesForDomain / removeSsoIdentitiesForDomain (+ pure emailDomain / ssoProviderColumn). Pre-seeding is the account-linking fix under GOTRUE_DISABLE_SIGNUP=true: a row in auth.identities with identity_data.email = lower(email) makes GoTrue link a SAML sign-in to the existing user via its email-column fallback — provider-agnostic (works for any IdP: Okta/Entra/OneLogin/Ping/…, whose NameID shapes differ), keyed on the generated email column NOT provider_id. verifySsoDomain backfills every existing on-domain user when a domain is verified; the three account-creation flows (apps/erp/.../users.service.ts) seed newly-invited users; removeSsoDomain tears the domain's identities down. A DB guard trigger on auth.sso_domains (migration …_sso-domain-guard.sql, ssoReservedDomain table) blocks registering an unclaimed/reserved domain. Only verified domains ever reach GoTrue. Full architecture + the provider-agnostic linking rationale: .claude/rules/authentication-system.md (Enterprise SAML SSO section); design: .ai/specs/2026-08-29-saml-sso-account-linking.md
  • Onshape panel auth (./onshape/panel-session.server, src/onshape/panel/session.server.ts): the cps_ bearer credential for the Onshape iframe, which the SameSite=Lax carbon cookie cannot reach. Mints, stores (Redis panel-session:<token>, 12 h) and revokes sessions, and exports requireOnshapePanelPermissions, the panel routes' gate: the same claims check as requirePermissions, answering 401/403 with no redirect. Imports getUserClaims, userHasVerifiedTotpFactor, getUserScopedClient and hasPermission from @carbon/auth; auth never imports it back. See .claude/rules/onshape-panel.md
  • Exports: ./accounting, ./plan, ./plan.server, ./entitlements.server, ./permissions.server, ./console.server, ./approvals, ./audit.server, ./backups.server, ./email-notifications.server, ./api-keys.server, ./webhooks.server, ./two-factor.server, ./forecast.server, ./customer-portals.server, ./mcp, ./mcp.server, ./rules (client-safe storage + sales rule query services/UI), ./rules.server (both evaluators AND the entitlement-gated authoring writes — upsertEnforcementRule/deleteEnforcementRule/assign*/unassign* in rules/service.server.ts, each embedding requireEntitlement("SALES_RULES"|"STORAGE_RULES")), ./workflows, ./workflows/help, ./workflows/labels, ./workflows.server, ./slack.server, ./hooks.server, ./sso.server, ./onshape/integration-id, ./onshape/panel-session.server, ./jira, ./linear, ./rillet/hooks.server, ./xero/hooks.server, ./ramp.server, ./ramp/hooks.server, ./oee, ./oee.server, ./sense/hooks.server, etc.

Cross-References

  • .claude/rules/ramp-integration.md — Ramp OAuth, state ownership, sync families, and card posting.
  • .claude/rules/accounting-sync-handlers.md — provider sync/reconciliation architecture.
  • .claude/rules/authentication-system.md — SAML SSO and account-linking rationale.
  • .claude/rules/billing-system.md — plan and edition gating.
  • packages/jobs/src/inngest/functions/integrations/ — durable integration entry points.