spine-framework 0.1.0

package/dist/functions/_shared/testing.d.ts

@@ -0,0 +1,172 @@
+/**
+ * @module testing
+ * @audience custom-developer
+ * @layer shared-util
+ * @stability evolving
+ *
+ * Testing utilities for custom code developers.
+ * Use these to test your custom functions without full deployment.
+ *
+ * **Usage in custom function tests:**
+ * ```ts
+ * import { makeTestContext, mockPrincipal, cleanup } from '@core/testing'
+ *
+ * describe('My Custom Handler', () => {
+ *   it('should process items', async () => {
+ *     const ctx = makeTestContext({
+ *       principal: mockPrincipal({ roles: ['member'] }),
+ *       accountId: 'test-account'
+ *     })
+ *
+ *     const result = await myHandler(mockEvent, ctx)
+ *     expect(result.status).toBe('success')
+ *
+ *     cleanup()
+ *   })
+ * })
+ * ```
+ *
+ * @seeAlso .framework/tests/unit/core-isolation.test.ts (examples)
+ */
+import { adminDb } from './db';
+export interface TestContext {
+    db: typeof adminDb;
+    principal: TestPrincipal;
+    logger: TestLogger;
+    accountId: string;
+}
+export interface TestPrincipal {
+    id: string;
+    account_id: string;
+    roles: string[];
+    permissions: Record<string, any>;
+    email?: string;
+}
+export interface TestLogger {
+    info: (msg: string, meta?: any) => void;
+    warn: (msg: string, meta?: any) => void;
+    error: (msg: string, meta?: any) => void;
+    debug: (msg: string, meta?: any) => void;
+}
+/**
+ * Creates a mock principal for testing.
+ *
+ * @param overrides - Override default principal properties
+ * @returns Mock principal object
+ *
+ * @example
+ * ```ts
+ * const admin = mockPrincipal({
+ *   roles: ['system_admin'],
+ *   permissions: { all: true }
+ * })
+ * ```
+ */
+export declare function mockPrincipal(overrides?: Partial<TestPrincipal>): TestPrincipal;
+/**
+ * Creates a mock logger that captures logs for assertions.
+ *
+ * @returns TestLogger with log capture
+ *
+ * @example
+ * ```ts
+ * const logger = mockLogger()
+ * await myFunction(logger)
+ * expect(logger.getLogs()).toContain('Processing started')
+ * ```
+ */
+export declare function mockLogger(): TestLogger & {
+    getLogs: () => string[];
+};
+/**
+ * Creates a test context for handler testing.
+ *
+ * @param options - Test context configuration
+ * @returns TestContext ready for handler
+ *
+ * @example
+ * ```ts
+ * const ctx = makeTestContext({
+ *   principal: mockPrincipal({ roles: ['operator'] }),
+ *   accountId: 'my-account'
+ * })
+ *
+ * const result = await handler(mockEvent, ctx)
+ * ```
+ */
+export declare function makeTestContext(options?: {
+    principal?: TestPrincipal;
+    accountId?: string;
+    logger?: TestLogger;
+}): TestContext;
+/**
+ * Creates a mock API Gateway event.
+ *
+ * @param overrides - Override default event properties
+ * @returns Mock event object
+ *
+ * @example
+ * ```ts
+ * const event = mockEvent({
+ *   httpMethod: 'POST',
+ *   body: JSON.stringify({ item_id: '123' })
+ * })
+ * ```
+ */
+export declare function mockEvent(overrides?: any): any;
+/**
+ * Creates a mock Netlify function context.
+ *
+ * @returns Mock context object
+ */
+export declare function mockNetlifyContext(): any;
+/**
+ * Cleanup function for tests.
+ * Clears caches and resets state.
+ */
+export declare function cleanup(): void;
+/**
+ * Setup helper for test files.
+ * Returns utilities commonly needed in tests.
+ *
+ * @example
+ * ```ts
+ * import { setupTests } from '@core/testing'
+ *
+ * const { makeTestContext, mockPrincipal, cleanup } = setupTests()
+ *
+ * describe('My Tests', () => {
+ *   afterEach(cleanup)
+ *   // ... tests
+ * })
+ * ```
+ */
+export declare function setupTests(): {
+    makeTestContext: typeof makeTestContext;
+    mockPrincipal: typeof mockPrincipal;
+    mockLogger: typeof mockLogger;
+    mockEvent: typeof mockEvent;
+    mockNetlifyContext: typeof mockNetlifyContext;
+    cleanup: typeof cleanup;
+};
+/**
+ * Asserts that a handler response matches expected structure.
+ *
+ * @param response - Handler response
+ * @param expectedStatus - Expected status code
+ */
+export declare function expectSuccessResponse(response: {
+    statusCode?: number;
+    body?: string;
+}, expectedStatus?: number): void;
+/**
+ * Asserts that a handler returned an error.
+ *
+ * @param response - Handler response
+ * @param expectedStatus - Expected error status code
+ */
+export declare function expectErrorResponse(response: {
+    statusCode?: number;
+    body?: string;
+}, expectedStatus?: number): void;
+//# sourceMappingURL=testing.d.ts.map

package/dist/functions/_shared/testing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../../../.framework/functions/_shared/testing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAE9B,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,OAAO,OAAO,CAAA;IAClB,SAAS,EAAE,aAAa,CAAA;IACxB,MAAM,EAAE,UAAU,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAA;IACV,UAAU,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE,MAAM,EAAE,CAAA;IACf,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IAChC,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,KAAK,IAAI,CAAA;IACvC,IAAI,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,KAAK,IAAI,CAAA;IACvC,KAAK,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,KAAK,IAAI,CAAA;IACxC,KAAK,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,KAAK,IAAI,CAAA;CACzC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAC,SAAS,GAAE,OAAO,CAAC,aAAa,CAAM,GAAG,aAAa,CASnF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,IAAI,UAAU,GAAG;IAAE,OAAO,EAAE,MAAM,MAAM,EAAE,CAAA;CAAE,CAsBrE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAAC,OAAO,GAAE;IACvC,SAAS,CAAC,EAAE,aAAa,CAAA;IACzB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,MAAM,CAAC,EAAE,UAAU,CAAA;CACf,GAAG,WAAW,CAOnB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CAAC,SAAS,GAAE,GAAQ,GAAG,GAAG,CASlD;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,IAAI,GAAG,CASxC;AAED;;;GAGG;AACH,wBAAgB,OAAO,IAAI,IAAI,CAI9B;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,UAAU;;;;;;;EASzB;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE;IAAE,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,EAChD,cAAc,GAAE,MAAY,GAC3B,IAAI,CAON;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE;IAAE,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,EAChD,cAAc,GAAE,MAAY,GAC3B,IAAI,CAON"}

package/dist/functions/_shared/trigger-engine.d.ts

@@ -0,0 +1,140 @@
+/**
+ * @module trigger-engine
+ * @audience both
+ * @layer shared-core
+ * @stability stable
+ *
+ * Event-driven trigger dispatch system. API handlers call `fire*Triggers` after
+ * a successful write to check whether any active triggers should fire. Matching
+ * triggers cause `runPipeline` to be invoked with structured `triggerData`.
+ *
+ * Public surface:
+ *   - `checkAndFireTriggers` — full trigger evaluation and firing loop
+ *   - `fireCreateTriggers` — convenience wrapper for `*_created` events
+ *   - `fireUpdateTriggers` — convenience wrapper for `*_updated` events
+ *   - `fireDeleteTriggers` — convenience wrapper for `*_deleted` events
+ *
+ * Trigger condition evaluation (in order, all must pass):
+ *   1. `config.entity_type` — exact match on entityType param
+ *   2. `config.type_slug` — match on `entityData.type_slug` (items only)
+ *   3. `config.filters` — field-level predicates with operators
+ *      (`$eq`, `$ne`, `$gt`, `$gte`, `$lt`, `$lte`, `$in`, `$nin`, `$exists`)
+ *
+ * INVARIANT: trigger evaluation and firing errors are caught per-trigger —
+ *   a single failing trigger never prevents other triggers from firing.
+ * INVARIANT: `checkAndFireTriggers` never throws — all errors are caught
+ *   and logged. Callers do not need to wrap in try/catch.
+ * INVARIANT: `adminDb` (service role) is used for trigger lookups and stats
+ *   updates; `runPipeline` then uses the passed `ctx` for stage execution.
+ *
+ * @seeAlso pipeline-runner.ts (runPipeline — called when a trigger fires)
+ * @seeAlso audit.ts (emitAudit for trigger.fired / trigger.failed)
+ * @seeAlso index.ts (fire*Triggers re-exported for v2-custom/ and CLI)
+ */
+import { CoreContext } from './middleware';
+/**
+ * All entity lifecycle event types that triggers can subscribe to.
+ *
+ * Format: `<entity>_<lifecycle>` where entity is one of:
+ * `item | account | person | thread | message | attachment | link`
+ * and lifecycle is `created | updated | deleted`.
+ *
+ * @calledBy checkAndFireTriggers, fireCreateTriggers, fireUpdateTriggers,
+ *   fireDeleteTriggers, all API handlers that write to these entity tables
+ */
+export type EventType = 'item_created' | 'item_updated' | 'item_deleted' | 'account_created' | 'account_updated' | 'account_deleted' | 'person_created' | 'person_updated' | 'person_deleted' | 'thread_created' | 'thread_updated' | 'thread_deleted' | 'message_created' | 'message_updated' | 'message_deleted' | 'attachment_created' | 'attachment_updated' | 'attachment_deleted' | 'link_created' | 'link_updated' | 'link_deleted';
+/**
+ * Queries active triggers for `eventType`, evaluates each against the entity
+ * data, and fires the associated pipeline for every matching trigger.
+ *
+ * Execution per trigger:
+ *   1. `evaluateTriggerConditions` — all conditions must pass
+ *   2. `runPipeline(trigger.pipeline_id, triggerData, ctx)` — fire pipeline
+ *   3. Update `triggers.last_triggered` and increment `trigger_count` via RPC
+ *   4. Emit `trigger.fired` audit log (or `trigger.failed` on error)
+ *
+ * `triggerData` passed to the pipeline:
+ * ```json
+ * {
+ *   "event": "item_updated",
+ *   "entity": { "type": "item", "id": "<uuid>", "data": {...} },
+ *   "trigger": { "id": "<uuid>", "name": "My Trigger" },
+ *   "fired_at": "2024-01-15T10:00:00.000Z"
+ * }
+ * ```
+ *
+ * @param eventType - The lifecycle event (e.g. 'item_updated')
+ * @param entityType - The entity table name (e.g. 'item', 'person')
+ * @param entityId - UUID of the entity that changed
+ * @param entityData - Full record data for condition evaluation
+ * @param ctx - CoreContext with requestId, accountId, and principal
+ * @returns Promise<void> — always resolves; never throws
+ * @throws never — all errors are caught per-trigger and logged
+ * @inputSpec eventType: EventType — must be one of the 21 defined event types
+ * @inputSpec entityId: string — UUID of the changed entity
+ * @inputSpec entityData: any — full record (used for condition evaluation)
+ * @outputSpec void
+ * @sideEffects DB read: triggers table
+ * @sideEffects DB write (per matching trigger): triggers.last_triggered, trigger_count
+ * @sideEffects Calls runPipeline (per matching trigger) — which writes pipeline_executions
+ * @sideEffects DB write: emitAudit (trigger.fired or trigger.failed per trigger)
+ * @calledBy All API handlers after successful create/update/delete writes
+ * @calledBy fireCreateTriggers, fireUpdateTriggers, fireDeleteTriggers
+ * @calls evaluateTriggerConditions, runPipeline, emitAudit
+ * @testUnit tests/unit/trigger-engine.test.ts
+ * @testIntegration tests/integration/trigger-engine.test.ts
+ *
+ * @example
+ * ```ts
+ * // In an API handler after a successful item update:
+ * await fireUpdateTriggers('item', updatedItem.id, updatedItem, ctx)
+ * ```
+ */
+export declare function checkAndFireTriggers(eventType: EventType, entityType: string, entityId: string, entityData: any, ctx: CoreContext): Promise<void>;
+/**
+ * Fires `<entityType>_created` triggers. Thin wrapper around
+ * `checkAndFireTriggers` that constructs the correct EventType.
+ *
+ * @param entityType - Entity table name (e.g. 'item', 'person')
+ * @param entityId - UUID of the newly created entity
+ * @param entityData - The created record (for condition evaluation)
+ * @param ctx - CoreContext
+ * @returns Promise<void> — always resolves
+ * @throws never
+ * @sideEffects same as checkAndFireTriggers
+ * @calledBy Any API handler's create path (e.g. items.ts, people.ts)
+ * @calls checkAndFireTriggers
+ * @testUnit tests/unit/trigger-engine.test.ts — 'fireCreateTriggers'
+ */
+export declare function fireCreateTriggers(entityType: string, entityId: string, entityData: any, ctx: CoreContext): Promise<void>;
+/**
+ * Fires `<entityType>_updated` triggers. Thin wrapper around
+ * `checkAndFireTriggers` that constructs the correct EventType.
+ *
+ * @param entityType - Entity table name (e.g. 'item', 'person')
+ * @param entityId - UUID of the updated entity
+ * @param entityData - The updated record (for condition evaluation)
+ * @param ctx - CoreContext
+ * @returns Promise<void> — always resolves
+ * @throws never
+ * @sideEffects same as checkAndFireTriggers
+ * @calledBy Any API handler's update path
+ * @calls checkAndFireTriggers
+ */
+export declare function fireUpdateTriggers(entityType: string, entityId: string, entityData: any, ctx: CoreContext): Promise<void>;
+/**
+ * Fires `<entityType>_deleted` triggers. Thin wrapper around
+ * `checkAndFireTriggers` that constructs the correct EventType.
+ *
+ * @param entityType - Entity table name (e.g. 'item', 'person')
+ * @param entityId - UUID of the deleted entity
+ * @param entityData - The record snapshot before deletion (for condition evaluation)
+ * @param ctx - CoreContext
+ * @returns Promise<void> — always resolves
+ * @throws never
+ * @sideEffects same as checkAndFireTriggers
+ * @calledBy Any API handler's delete path
+ * @calls checkAndFireTriggers
+ */
+export declare function fireDeleteTriggers(entityType: string, entityId: string, entityData: any, ctx: CoreContext): Promise<void>;
+//# sourceMappingURL=trigger-engine.d.ts.map

package/dist/functions/_shared/trigger-engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trigger-engine.d.ts","sourceRoot":"","sources":["../../../.framework/functions/_shared/trigger-engine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAO1C;;;;;;;;;GASG;AACH,MAAM,MAAM,SAAS,GACjB,cAAc,GAAG,cAAc,GAAG,cAAc,GAChD,iBAAiB,GAAG,iBAAiB,GAAG,iBAAiB,GACzD,gBAAgB,GAAG,gBAAgB,GAAG,gBAAgB,GACtD,gBAAgB,GAAG,gBAAgB,GAAG,gBAAgB,GACtD,iBAAiB,GAAG,iBAAiB,GAAG,iBAAiB,GACzD,oBAAoB,GAAG,oBAAoB,GAAG,oBAAoB,GAClE,cAAc,GAAG,cAAc,GAAG,cAAc,CAAA;AA0BpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,wBAAsB,oBAAoB,CACxC,SAAS,EAAE,SAAS,EACpB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,GAAG,EACf,GAAG,EAAE,WAAW,GACf,OAAO,CAAC,IAAI,CAAC,CAgFf;AAwID;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,kBAAkB,CACtC,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,GAAG,EACf,GAAG,EAAE,WAAW,GACf,OAAO,CAAC,IAAI,CAAC,CAGf;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,kBAAkB,CACtC,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,GAAG,EACf,GAAG,EAAE,WAAW,GACf,OAAO,CAAC,IAAI,CAAC,CAGf;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,kBAAkB,CACtC,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,GAAG,EACf,GAAG,EAAE,WAAW,GACf,OAAO,CAAC,IAAI,CAAC,CAGf"}

package/dist/functions/_shared/webhook-registration.d.ts

@@ -0,0 +1,81 @@
+/**
+ * @module webhook-registration
+ * @audience custom-developer
+ * @layer shared-util
+ * @stability stable
+ *
+ * Helper utilities for custom webhook handlers to self-register.
+ * Use this in your custom Netlify functions to register as webhook handlers.
+ *
+ * **Usage in a custom function:**
+ * ```ts
+ * import { createHandler } from '../_shared/middleware'
+ * import { registerWebhookHandler } from '../_shared/webhook-registration'
+ * import { adminDb } from '../_shared/db'
+ *
+ * export const handler = createHandler(async (event, ctx) => {
+ *   // Your webhook logic here
+ * })
+ *
+ * // Self-register on first load (idempotent)
+ * registerWebhookHandler({
+ *   name: 'my-custom-handler',
+ *   functionName: 'custom_my-webhook',
+ *   description: 'Handles my custom integration events',
+ *   events: ['user.created', 'item.updated'],
+ *   db: adminDb
+ * }).catch(console.error)
+ * ```
+ *
+ * @seeAlso webhook-registry.ts (core lookup service)
+ * @seeAlso 014_webhook_registry.sql (database table)
+ */
+import { adminDb } from './db';
+export interface WebhookHandlerRegistration {
+    /** Unique handler identifier (e.g., 'cortex-handler') */
+    name: string;
+    /** Netlify function name (e.g., 'custom_cortex-handler') */
+    functionName: string;
+    /** Human-readable description */
+    description?: string;
+    /** Events this handler subscribes to */
+    events?: string[];
+    /** Account ID (null for system handlers) */
+    accountId?: string | null;
+    /** Database client (defaults to adminDb) */
+    db?: typeof adminDb;
+}
+/**
+ * Registers a webhook handler in the database registry.
+ * Idempotent - safe to call multiple times.
+ *
+ * @param config - Handler registration configuration
+ * @returns Promise that resolves when registration completes
+ *
+ * @example
+ * ```ts
+ * await registerWebhookHandler({
+ *   name: 'slack-webhook',
+ *   functionName: 'custom_slack-integration',
+ *   description: 'Posts notifications to Slack',
+ *   events: ['item.created', 'item.updated']
+ * })
+ * ```
+ */
+export declare function registerWebhookHandler(config: WebhookHandlerRegistration): Promise<void>;
+/**
+ * Deregisters a webhook handler (soft delete).
+ *
+ * @param name - Handler identifier to deregister
+ * @param db - Optional database client
+ */
+export declare function deregisterWebhookHandler(name: string, db?: typeof adminDb): Promise<void>;
+/**
+ * Checks if a handler is registered.
+ *
+ * @param name - Handler identifier to check
+ * @param db - Optional database client
+ * @returns True if handler exists and is active
+ */
+export declare function isHandlerRegistered(name: string, db?: typeof adminDb): Promise<boolean>;
+//# sourceMappingURL=webhook-registration.d.ts.map

package/dist/functions/_shared/webhook-registration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhook-registration.d.ts","sourceRoot":"","sources":["../../../.framework/functions/_shared/webhook-registration.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAE9B,MAAM,WAAW,0BAA0B;IACzC,yDAAyD;IACzD,IAAI,EAAE,MAAM,CAAA;IAEZ,4DAA4D;IAC5D,YAAY,EAAE,MAAM,CAAA;IAEpB,iCAAiC;IACjC,WAAW,CAAC,EAAE,MAAM,CAAA;IAEpB,wCAAwC;IACxC,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;IAEjB,4CAA4C;IAC5C,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAEzB,4CAA4C;IAC5C,EAAE,CAAC,EAAE,OAAO,OAAO,CAAA;CACpB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,0BAA0B,GACjC,OAAO,CAAC,IAAI,CAAC,CA6Bf;AAED;;;;;GAKG;AACH,wBAAsB,wBAAwB,CAC5C,IAAI,EAAE,MAAM,EACZ,EAAE,GAAE,OAAO,OAAiB,GAC3B,OAAO,CAAC,IAAI,CAAC,CAqBf;AAED;;;;;;GAMG;AACH,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,MAAM,EACZ,EAAE,GAAE,OAAO,OAAiB,GAC3B,OAAO,CAAC,OAAO,CAAC,CAoBlB"}

package/dist/functions/_shared/webhook-registry.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @module webhook-registry
+ * @audience core-contributor
+ * @layer shared-service
+ * @stability stable
+ *
+ * Dynamic webhook handler registry for runtime handler resolution.
+ * Replaces static imports with database-driven handler lookups.
+ *
+ * **Pattern:**
+ * 1. Custom handlers self-register via `integrations` table or `webhook_handlers` table
+ * 2. Core looks up handler by name at runtime
+ * 3. Dynamic import loads the handler function
+ *
+ * **Benefits:**
+ * - Core has zero hardcoded dependencies on custom handlers
+ * - Handlers can be added/removed without core code changes
+ * - Multi-tenancy: different tenants can have different handlers
+ *
+ * @seeAlso integration-routes.ts (uses this registry)
+ * @seeAlso webhook-registration.ts (self-registration helper for custom handlers)
+ */
+/**
+ * Looks up a webhook handler in the database registry.
+ * Returns the function name to dynamically import.
+ *
+ * @param handlerName - The handler identifier (e.g., "cortex-handler")
+ * @returns Handler metadata or null if not found
+ */
+export declare function lookupHandler(handlerName: string): Promise<{
+    functionName: string;
+} | null>;
+/**
+ * Loads a webhook handler function dynamically.
+ * Uses dynamic import to avoid static dependencies.
+ *
+ * @param functionName - The Netlify function name (e.g., "custom_cortex-handler")
+ * @returns The handler function or null if not found
+ */
+export declare function loadHandler(functionName: string): Promise<Function | null>;
+/**
+ * Resolves a webhook handler by name.
+ * Combines lookup + load for convenience.
+ *
+ * @param handlerName - The handler identifier
+ * @returns The handler function or null
+ */
+export declare function resolveHandler(handlerName: string): Promise<Function | null>;
+/**
+ * Clears the handler cache. Useful for testing or after deployments.
+ */
+export declare function clearHandlerCache(): void;
+/**
+ * Lists all registered handlers (for debugging/admin).
+ */
+export declare function listRegisteredHandlers(): Promise<string[]>;
+//# sourceMappingURL=webhook-registry.d.ts.map

package/dist/functions/_shared/webhook-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhook-registry.d.ts","sourceRoot":"","sources":["../../../.framework/functions/_shared/webhook-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAOH;;;;;;GAMG;AACH,wBAAsB,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC;IAAE,YAAY,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAAC,CA2BjG;AAED;;;;;;GAMG;AACH,wBAAsB,WAAW,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,CAmBhF;AAED;;;;;;GAMG;AACH,wBAAsB,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,CAKlF;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,IAAI,CAExC;AAED;;GAEG;AACH,wBAAsB,sBAAsB,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAYhE"}

package/dist/functions/account-nodes.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @module account-nodes
+ * @audience core-contributor
+ * @layer api-handler
+ * @stability stable
+ *
+ * Account hierarchy traversal endpoint. Given a single `node_id`, returns
+ * the target account record plus three relational views:
+ * - **ancestors** — all nodes from root to this node (via `get_account_ancestors` RPC)
+ * - **children** — direct active children ordered by `display_name`
+ * - **descendants** — all active nodes in the subtree (via `get_account_descendants` RPC)
+ *
+ * **Routed by:** `GET /.netlify/functions/account-nodes`
+ *
+ * **Authorization:** Uses `ctx.db` (RLS-scoped). Only accounts visible to
+ * the authenticated principal are returned. Inactive accounts are excluded
+ * (`is_active = true` filter on node + children queries).
+ *
+ * **Response shape:**
+ * ```ts
+ * {
+ *   node: Account & { type: TypeRecord }
+ *   ancestors: AccountAncestorRow[]
+ *   children: Array<Account & { type: TypeRecord }>
+ *   descendants: AccountDescendantRow[]
+ * }
+ * ```
+ *
+ * @seeAlso auth.ts (context handler also calls get_account_hierarchy RPC)
+ * @seeAlso accounts.ts (CRUD; creates the account nodes)
+ * @seeAlso _shared/db.ts (get_account_ancestors / get_account_descendants RPCs)
+ */
+/**
+ * @chunk-id    ACCOUNT_NODES_HANDLER_1_0_0
+ * @version     1.0.0
+ * @hash        0778bcec10cfbe1a79177e4352706270194cf80cd0baa39c6ed615c73c7c7695
+ * @macro       Account Hierarchy Handler
+ * @micro       Returns account node with ancestors, children, and descendants
+ * @inputs      ctx: CoreContext — Request context with principal and database
+ * @inputs      body: any — Request body (unused for GET)
+ * @outputs     {node, ancestors, children, descendants} — Complete hierarchy data
+ * @depends-on  [createHandler, get_account_ancestors, get_account_descendants]
+ * @depended-by [Netlify function routing]
+ * @side-effects [DB queries, RPC calls]
+ * @tags        account, hierarchy, netlify-function, api
+ */
+export declare const handler: (event: any, context: any) => Promise<any>;
+//# sourceMappingURL=account-nodes.d.ts.map

package/dist/functions/account-nodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"account-nodes.d.ts","sourceRoot":"","sources":["../../.framework/functions/account-nodes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAKH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,OAAO,4CA2DlB,CAAA"}