spine-framework 0.1.61 → 1.0.0

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

@@ -1,172 +0,0 @@
-/**
- * @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

@@ -1 +0,0 @@
-{"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

@@ -1,140 +0,0 @@
-/**
- * @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

@@ -1 +0,0 @@
-{"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

@@ -1,81 +0,0 @@
-/**
- * @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

@@ -1 +0,0 @@
-{"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

@@ -1,57 +0,0 @@
-/**
- * @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

@@ -1 +0,0 @@
-{"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

@@ -1,48 +0,0 @@
-/**
- * @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

@@ -1 +0,0 @@
-{"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"}