node-type-registry 0.36.0 → 0.37.0

package/esm/conditions/trigger-condition.js

@@ -0,0 +1,94 @@
+/**
+ * Shared trigger condition schema used by any node type that creates
+ * PostgreSQL triggers with conditional WHEN clauses.
+ *
+ * Consumed by: JobTrigger, EventTracker, ProcessExtraction,
+ * ProcessImageVersions, ProcessFileEmbedding, ProcessImageEmbedding.
+ *
+ * On the SQL side, these conditions are compiled to AST via
+ * metaschema_generators.build_condition_ast().
+ */
+export const triggerConditionSchema = {
+    type: 'object',
+    description: 'A leaf condition ({field, op, value?, row?, ref?}) or a combinator ({AND, OR, NOT}).',
+    properties: {
+        field: { type: 'string', format: 'column-ref', description: 'Column name (validated against the table).' },
+        op: {
+            type: 'string',
+            enum: ['=', '!=', '>', '<', '>=', '<=', 'LIKE', 'NOT LIKE', 'IS NULL', 'IS NOT NULL', 'IS DISTINCT FROM'],
+            description: 'Comparison operator.'
+        },
+        value: { description: 'Comparison value. Type is resolved from the column definition. Omit for IS NULL, IS NOT NULL, IS DISTINCT FROM.' },
+        row: { type: 'string', enum: ['NEW', 'OLD'], default: 'NEW', description: 'Row reference (default: NEW).' },
+        ref: {
+            type: 'object',
+            description: 'Column reference for field-to-field comparison (alternative to value).',
+            properties: {
+                field: { type: 'string', format: 'column-ref' },
+                row: { type: 'string', enum: ['NEW', 'OLD'], default: 'NEW' }
+            }
+        },
+        AND: { type: 'array', description: 'Array of conditions combined with AND.', items: { $ref: '#/$defs/triggerCondition' } },
+        OR: { type: 'array', description: 'Array of conditions combined with OR.', items: { $ref: '#/$defs/triggerCondition' } },
+        NOT: { $ref: '#/$defs/triggerCondition', description: 'Negated condition.' }
+    }
+};
+/**
+ * $defs block for parameter_schema. Spread into any node that uses conditions.
+ *
+ * Usage:
+ *   parameter_schema: { type: 'object', $defs: conditionDefs, properties: { ... } }
+ */
+export const conditionDefs = {
+    triggerCondition: triggerConditionSchema
+};
+/**
+ * Common condition-related properties for trigger-based nodes.
+ * Three mutually exclusive options for WHEN clause specification.
+ *
+ * Usage:
+ *   properties: { event_name: { ... }, ...conditionProperties }
+ */
+export const conditionProperties = {
+    condition_field: {
+        type: 'string',
+        format: 'column-ref',
+        description: 'Column name for conditional WHEN clause (fires only when field equals condition_value)'
+    },
+    condition_value: {
+        type: 'string',
+        description: 'Value to compare against condition_field in WHEN clause'
+    },
+    conditions: {
+        description: 'Compound conditions for the trigger WHEN clause. Accepts a single leaf condition, an array of conditions (implicitly AND), or a nested combinator tree ({AND: [...], OR: [...], NOT: {...}}). Each leaf is {field, op, value?, row?, ref?}. Column types are resolved automatically from the table schema. Cannot be combined with condition_field or watch_fields.',
+        'x-codegen-type': 'TriggerCondition | TriggerCondition[]',
+        oneOf: [
+            { $ref: '#/$defs/triggerCondition' },
+            { type: 'array', items: { $ref: '#/$defs/triggerCondition' } }
+        ]
+    },
+    watch_fields: {
+        type: 'array',
+        items: {
+            type: 'string',
+            format: 'column-ref'
+        },
+        description: 'For UPDATE triggers, only fire when these fields change (uses DISTINCT FROM)'
+    }
+};
+/**
+ * Standalone trigger_conditions property for nodes that compose on top of
+ * JobTrigger (Process* nodes). These use trigger_conditions instead of
+ * the full condition_field/conditions/watch_fields trio because the
+ * underlying JobTrigger handles the WHEN clause; this property adds
+ * additional conditions merged via AND.
+ */
+export const triggerConditionsProperty = {
+    description: 'Additional compound conditions beyond auto-generated filtering. ' +
+        'Merged with the auto-generated conditions via AND.',
+    'x-codegen-type': 'TriggerCondition | TriggerCondition[]',
+    oneOf: [
+        { $ref: '#/$defs/triggerCondition' },
+        { type: 'array', items: { $ref: '#/$defs/triggerCondition' } }
+    ]
+};

package/esm/data/data-aggregate-limit-counter.d.ts

@@ -1,2 +1,2 @@
 import type { NodeTypeDefinition } from '../types';
-export declare const LimitAggregate: NodeTypeDefinition;
+export declare const LimitEnforceAggregate: NodeTypeDefinition;

package/esm/data/data-aggregate-limit-counter.js

@@ -1,8 +1,8 @@
-export const LimitAggregate = {
-    name: 'LimitAggregate',
-    slug: 'data_aggregate_limit_counter',
-    category: 'limit',
-    display_name: 'Aggregate Limit Counter',
+export const LimitEnforceAggregate = {
+    name: 'LimitEnforceAggregate',
+    slug: 'limit_enforce_aggregate',
+    category: 'limit_enforce',
+    display_name: 'Enforce Aggregate Counter',
     description: 'Declaratively attaches aggregate limit-tracking triggers to a table. On INSERT the named limit is incremented per entity; on DELETE it is decremented. Uses org_limit_aggregates_inc/dec for per-entity (org-level) aggregate limits rather than per-user limits. Requires a provisioned limits_module for the target database.',
     parameter_schema: {
         type: 'object',
@@ -29,5 +29,5 @@ export const LimitAggregate = {
         },
         required: ['limit_name'],
     },
-    tags: ['limits', 'triggers', 'aggregates', 'billing'],
+    tags: ['limits', 'triggers', 'aggregates', 'enforce'],
 };

package/esm/data/data-billing-meter.d.ts

@@ -1,2 +1,2 @@
 import type { NodeTypeDefinition } from '../types';
-export declare const BillingMeter: NodeTypeDefinition;
+export declare const LimitTrackUsage: NodeTypeDefinition;

package/esm/data/data-billing-meter.js

@@ -1,8 +1,8 @@
-export const BillingMeter = {
-    name: 'BillingMeter',
-    slug: 'data_billing_meter',
-    category: 'billing',
-    display_name: 'Billing Meter',
+export const LimitTrackUsage = {
+    name: 'LimitTrackUsage',
+    slug: 'limit_track_usage',
+    category: 'limit_track',
+    display_name: 'Track Usage',
     description: 'Declaratively attaches billing usage-recording triggers to a table. On INSERT the named meter is incremented via record_usage; on DELETE it is decremented (reversal). On UPDATE, if the entity_field changes, the old entity is decremented and the new entity is incremented. Requires a provisioned billing_module for the target database.',
     parameter_schema: {
         type: 'object',
@@ -34,5 +34,5 @@ export const BillingMeter = {
         },
         required: ['meter_slug'],
     },
-    tags: ['billing', 'triggers', 'metering', 'usage'],
+    tags: ['billing', 'triggers', 'metering', 'usage', 'track'],
 };

package/esm/data/data-chunks.js

@@ -63,6 +63,17 @@ export const ProcessChunks = {
                 description: 'Distance metric for the HNSW index on chunk embeddings',
                 default: 'cosine'
             },
+            // ── Model config (optional — flows into job payload) ──────────
+            embedding_model: {
+                type: 'string',
+                description: 'Embedding model identifier for per-chunk embeddings. ' +
+                    'When null, the worker falls back to runtime config (llm_module / env vars).'
+            },
+            embedding_provider: {
+                type: 'string',
+                description: 'Embedding provider name (e.g. "ollama", "openai"). ' +
+                    'When null, the worker falls back to runtime config.'
+            },
             // ── Table naming ───────────────────────────────────────────────
             chunks_table_name: {
                 type: 'string',
@@ -74,6 +85,15 @@ export const ProcessChunks = {
                 items: { type: 'string' },
                 description: 'Field names from the parent table to copy into chunk metadata'
             },
+            // ── Search indexes ───────────────────────────────────────────────
+            search_indexes: {
+                type: 'array',
+                items: { type: 'string', enum: ['fulltext', 'bm25', 'trigram'] },
+                description: 'Text search indexes to create on the chunks content column. ' +
+                    'Enables keyword-based retrieval alongside vector search for ' +
+                    'hybrid RAG workflows.',
+                default: ['fulltext']
+            },
             // ── Job trigger ────────────────────────────────────────────────
             enqueue_chunking_job: {
                 type: 'boolean',

package/esm/data/data-feature-flag.d.ts

@@ -1,2 +1,2 @@
 import type { NodeTypeDefinition } from '../types';
-export declare const LimitFeatureFlag: NodeTypeDefinition;
+export declare const LimitEnforceFeature: NodeTypeDefinition;

package/esm/data/data-feature-flag.js

@@ -1,8 +1,8 @@
-export const LimitFeatureFlag = {
-    name: 'LimitFeatureFlag',
-    slug: 'data_feature_flag',
-    category: 'limit',
-    display_name: 'Feature Flag',
+export const LimitEnforceFeature = {
+    name: 'LimitEnforceFeature',
+    slug: 'limit_enforce_feature',
+    category: 'limit_enforce',
+    display_name: 'Enforce Feature Flag',
     description: 'Gates a table behind a feature flag backed by the cap tables. Attaches a BEFORE INSERT trigger that checks whether the named feature cap value is > 0. Features are modeled as caps with max=0 (disabled) or max=1 (enabled) in limit_caps / limit_caps_defaults tables. Resolution: COALESCE(per-entity cap, scope default, 0).',
     parameter_schema: {
         type: 'object',
@@ -26,5 +26,5 @@ export const LimitFeatureFlag = {
         },
         required: ['feature_name'],
     },
-    tags: ['limits', 'triggers', 'feature-flags', 'billing', 'caps'],
+    tags: ['limits', 'triggers', 'feature-flags', 'enforce', 'caps'],
 };

package/esm/data/data-file-embedding.js

@@ -1,3 +1,4 @@
+import { conditionDefs, triggerConditionsProperty } from '../conditions';
 export const ProcessFileEmbedding = {
     name: 'ProcessFileEmbedding',
     slug: 'data_file_embedding',
@@ -12,6 +13,7 @@ export const ProcessFileEmbedding = {
         'names, and embedding strategies.',
     parameter_schema: {
         type: 'object',
+        $defs: conditionDefs,
         properties: {
             // ── Vector config (passed through to SearchVector) ─────────────
             field_name: {
@@ -42,6 +44,18 @@ export const ProcessFileEmbedding = {
                 description: 'Index-specific options. HNSW: {m, ef_construction}. IVFFlat: {lists}.',
                 default: {}
             },
+            // ── Model config (optional — flows into job payload) ──────────
+            embedding_model: {
+                type: 'string',
+                description: 'Embedding model identifier (e.g. "nomic-embed-text", "text-embedding-3-small", ' +
+                    '"clip-vit-base-patch32"). Included in the job payload so the worker knows which ' +
+                    'model to use. When null, the worker falls back to runtime config (llm_module / env vars).'
+            },
+            embedding_provider: {
+                type: 'string',
+                description: 'Embedding provider name (e.g. "ollama", "openai"). ' +
+                    'When null, the worker falls back to runtime config.'
+            },
             // ── MIME scoping ───────────────────────────────────────────────
             mime_patterns: {
                 type: 'array',
@@ -74,16 +88,7 @@ export const ProcessFileEmbedding = {
                     bucket_id: 'bucket_id'
                 }
             },
-            trigger_conditions: {
-                description: 'Additional compound conditions beyond MIME filtering. ' +
-                    'Merged with the auto-generated MIME conditions via AND. ' +
-                    'Use this to add status checks, field guards, etc.',
-                'x-codegen-type': 'TriggerCondition | TriggerCondition[]',
-                oneOf: [
-                    { $ref: '#/$defs/triggerCondition' },
-                    { type: 'array', items: { $ref: '#/$defs/triggerCondition' } }
-                ]
-            },
+            trigger_conditions: triggerConditionsProperty,
             // ── Extraction config (optional — enables extract mode) ────────
             extraction: {
                 type: 'object',
@@ -147,6 +152,13 @@ export const ProcessFileEmbedding = {
                         items: { type: 'string' },
                         description: 'Field names from parent to copy into chunk metadata'
                     },
+                    search_indexes: {
+                        type: 'array',
+                        items: { type: 'string', enum: ['fulltext', 'bm25', 'trigram'] },
+                        description: 'Text search indexes to create on the chunks content column. ' +
+                            'Enables keyword-based retrieval alongside vector search.',
+                        default: ['fulltext']
+                    },
                     enqueue_chunking_job: {
                         type: 'boolean',
                         description: 'Whether to auto-enqueue a chunking job on insert/update',

package/esm/data/data-image-embedding.js

@@ -1,3 +1,4 @@
+import { conditionDefs, triggerConditionsProperty } from '../conditions';
 /**
  * Image-specific preset of ProcessFileEmbedding.
  *
@@ -21,6 +22,7 @@ export const ProcessImageEmbedding = {
         'Accepts all ProcessFileEmbedding parameters — any overrides are forwarded through.',
     parameter_schema: {
         type: 'object',
+        $defs: conditionDefs,
         properties: {
             // ── Vector config (passed through to ProcessFileEmbedding) ──────────
             field_name: {
@@ -51,6 +53,18 @@ export const ProcessImageEmbedding = {
                 description: 'Index-specific options. HNSW: {m, ef_construction}. IVFFlat: {lists}.',
                 default: {}
             },
+            // ── Model config (optional — flows into job payload) ──────────
+            embedding_model: {
+                type: 'string',
+                description: 'Embedding model identifier (e.g. "clip-vit-base-patch32"). ' +
+                    'Included in the job payload so the worker knows which model to use. ' +
+                    'When null, the worker falls back to runtime config (llm_module / env vars).'
+            },
+            embedding_provider: {
+                type: 'string',
+                description: 'Embedding provider name (e.g. "ollama", "openai"). ' +
+                    'When null, the worker falls back to runtime config.'
+            },
             // ── MIME scoping ───────────────────────────────────────────────
             mime_patterns: {
                 type: 'array',
@@ -81,15 +95,7 @@ export const ProcessImageEmbedding = {
                     bucket_id: 'bucket_id'
                 }
             },
-            trigger_conditions: {
-                description: 'Additional compound conditions beyond MIME filtering. ' +
-                    'Merged with the auto-generated MIME conditions via AND.',
-                'x-codegen-type': 'TriggerCondition | TriggerCondition[]',
-                oneOf: [
-                    { $ref: '#/$defs/triggerCondition' },
-                    { type: 'array', items: { $ref: '#/$defs/triggerCondition' } }
-                ]
-            },
+            trigger_conditions: triggerConditionsProperty,
             // ── Extraction config (optional — enables extract mode) ────────
             extraction: {
                 type: 'object',

package/esm/data/data-job-trigger.js

@@ -1,28 +1,4 @@
-const triggerConditionSchema = {
-    type: 'object',
-    description: 'A leaf condition ({field, op, value?, row?, ref?}) or a combinator ({AND, OR, NOT}).',
-    properties: {
-        field: { type: 'string', format: 'column-ref', description: 'Column name (validated against the table).' },
-        op: {
-            type: 'string',
-            enum: ['=', '!=', '>', '<', '>=', '<=', 'LIKE', 'NOT LIKE', 'IS NULL', 'IS NOT NULL', 'IS DISTINCT FROM'],
-            description: 'Comparison operator.'
-        },
-        value: { description: 'Comparison value. Type is resolved from the column definition. Omit for IS NULL, IS NOT NULL, IS DISTINCT FROM.' },
-        row: { type: 'string', enum: ['NEW', 'OLD'], default: 'NEW', description: 'Row reference (default: NEW).' },
-        ref: {
-            type: 'object',
-            description: 'Column reference for field-to-field comparison (alternative to value).',
-            properties: {
-                field: { type: 'string', format: 'column-ref' },
-                row: { type: 'string', enum: ['NEW', 'OLD'], default: 'NEW' }
-            }
-        },
-        AND: { type: 'array', description: 'Array of conditions combined with AND.', items: { $ref: '#/$defs/triggerCondition' } },
-        OR: { type: 'array', description: 'Array of conditions combined with OR.', items: { $ref: '#/$defs/triggerCondition' } },
-        NOT: { $ref: '#/$defs/triggerCondition', description: 'Negated condition.' }
-    }
-};
+import { conditionDefs, conditionProperties } from '../conditions';
 export const JobTrigger = {
     name: 'JobTrigger',
     slug: 'data_job_trigger',
@@ -31,9 +7,7 @@ export const JobTrigger = {
     description: 'Dynamically creates PostgreSQL triggers that enqueue jobs via app_jobs.add_job() when table rows are inserted, updated, or deleted. Supports configurable payload strategies (full row, row ID, selected fields, or custom mapping), conditional firing via WHEN clauses, watched field changes, and extended job options (queue, priority, delay, max attempts).',
     parameter_schema: {
         type: 'object',
-        $defs: {
-            triggerCondition: triggerConditionSchema
-        },
+        $defs: conditionDefs,
         properties: {
             task_identifier: {
                 type: 'string',
@@ -92,31 +66,7 @@ export const JobTrigger = {
                 description: 'Include table/schema metadata in payload',
                 default: false
             },
-            condition_field: {
-                type: 'string',
-                format: 'column-ref',
-                description: 'Column name for conditional WHEN clause (fires only when field equals condition_value)'
-            },
-            condition_value: {
-                type: 'string',
-                description: 'Value to compare against condition_field in WHEN clause'
-            },
-            conditions: {
-                description: 'Compound conditions for the trigger WHEN clause. Accepts a single leaf condition, an array of conditions (implicitly AND), or a nested combinator tree ({AND: [...], OR: [...], NOT: {...}}). Each leaf is {field, op, value?, row?, ref?}. Column types are resolved automatically from the table schema. Cannot be combined with condition_field or watch_fields.',
-                'x-codegen-type': 'TriggerCondition | TriggerCondition[]',
-                oneOf: [
-                    { $ref: '#/$defs/triggerCondition' },
-                    { type: 'array', items: { $ref: '#/$defs/triggerCondition' } }
-                ]
-            },
-            watch_fields: {
-                type: 'array',
-                items: {
-                    type: 'string',
-                    format: 'column-ref'
-                },
-                description: 'For UPDATE triggers, only fire when these fields change (uses DISTINCT FROM)'
-            },
+            ...conditionProperties,
             job_key: {
                 type: 'string',
                 description: 'Static job key for upsert semantics (prevents duplicate jobs)'

package/esm/data/data-limit-counter.d.ts

@@ -1,2 +1,2 @@
 import type { NodeTypeDefinition } from '../types';
-export declare const LimitCounter: NodeTypeDefinition;
+export declare const LimitEnforceCounter: NodeTypeDefinition;

package/esm/data/data-limit-counter.js

@@ -1,8 +1,8 @@
-export const LimitCounter = {
-    name: 'LimitCounter',
-    slug: 'data_limit_counter',
-    category: 'limit',
-    display_name: 'Limit Counter',
+export const LimitEnforceCounter = {
+    name: 'LimitEnforceCounter',
+    slug: 'limit_enforce_counter',
+    category: 'limit_enforce',
+    display_name: 'Enforce Counter',
     description: 'Declaratively attaches limit-tracking triggers to a table. On INSERT the named limit is incremented; on DELETE it is decremented. Requires a provisioned limits_module for the target scope.',
     parameter_schema: {
         type: 'object',
@@ -35,5 +35,5 @@ export const LimitCounter = {
         },
         required: ['limit_name'],
     },
-    tags: ['limits', 'triggers', 'billing'],
+    tags: ['limits', 'triggers', 'enforce'],
 };

package/esm/data/data-meter-rate-limit.d.ts

@@ -0,0 +1,2 @@
+import type { NodeTypeDefinition } from '../types';
+export declare const LimitEnforceRate: NodeTypeDefinition;

package/esm/data/data-meter-rate-limit.js

@@ -0,0 +1,39 @@
+export const LimitEnforceRate = {
+    name: 'LimitEnforceRate',
+    slug: 'limit_enforce_rate',
+    category: 'limit_enforce',
+    display_name: 'Enforce Rate Limit',
+    description: 'Attaches a BEFORE trigger that calls check_rate_limit() to enforce sliding-window rate limits before allowing mutations. The function checks all three scopes (entity, actor-in-entity, actor) in a single call; which scopes are actually enforced is controlled by what rows exist in rate_window_limits (plan-based config). Requires a provisioned meter_rate_limits_module and billing_module for the target database.',
+    parameter_schema: {
+        type: 'object',
+        properties: {
+            meter_slug: {
+                type: 'string',
+                description: 'Slug of the billing meter to check rate limits against (must match a meters table entry, e.g. "messaging", "inference")',
+            },
+            entity_field: {
+                type: 'string',
+                format: 'column-ref',
+                description: 'Column on the target table that holds the entity id (org) for rate limiting',
+                default: 'entity_id',
+            },
+            actor_field: {
+                type: 'string',
+                format: 'column-ref',
+                description: 'Column on the target table that holds the actor id (user) for rate limiting',
+                default: 'owner_id',
+            },
+            events: {
+                type: 'array',
+                items: {
+                    type: 'string',
+                    enum: ['INSERT', 'UPDATE'],
+                },
+                description: 'Which DML events to enforce rate limits on (DELETE is excluded since it reduces load)',
+                default: ['INSERT'],
+            },
+        },
+        required: ['meter_slug'],
+    },
+    tags: ['rate-limits', 'triggers', 'enforce', 'metering', 'abuse-protection'],
+};

package/esm/data/event-tracker.d.ts

@@ -0,0 +1,2 @@
+import type { NodeTypeDefinition } from '../types';
+export declare const EventTracker: NodeTypeDefinition;

package/esm/data/event-tracker.js

@@ -0,0 +1,71 @@
+import { conditionDefs, conditionProperties } from '../conditions';
+export const EventTracker = {
+    name: 'EventTracker',
+    slug: 'event_tracker',
+    category: 'event',
+    display_name: 'Event Tracker',
+    description: 'Creates triggers that record events via the events module when table rows change. ' +
+        'Supports the same compound condition system as JobTrigger (condition_field, watch_fields, ' +
+        'or full AND/OR/NOT conditions). Events are recorded to app_events and aggregated ' +
+        'automatically. Use with achievements (blueprint-level) to unlock levels and grant ' +
+        'credits based on event accumulation.',
+    parameter_schema: {
+        type: 'object',
+        $defs: conditionDefs,
+        properties: {
+            event_name: {
+                type: 'string',
+                description: 'Event type name to record (e.g., "avatar_uploaded", "order_completed")'
+            },
+            events: {
+                type: 'array',
+                items: {
+                    type: 'string',
+                    enum: [
+                        'INSERT',
+                        'UPDATE',
+                        'DELETE'
+                    ]
+                },
+                description: 'DML events that trigger recording',
+                default: ['INSERT']
+            },
+            count: {
+                type: 'integer',
+                description: 'Number of events to record per trigger fire',
+                default: 1
+            },
+            toggle: {
+                type: 'boolean',
+                description: 'Toggle mode: records event when condition is met, removes when condition is unmet',
+                default: false
+            },
+            actor_field: {
+                type: 'string',
+                format: 'column-ref',
+                description: 'Column containing the actor (user) ID to attribute the event to',
+                default: 'owner_id'
+            },
+            entity_field: {
+                type: 'string',
+                format: 'column-ref',
+                description: 'Column containing the entity ID (org/group) for entity-scoped events. Omit for user-only events.'
+            },
+            auto_register_type: {
+                type: 'boolean',
+                description: 'Automatically register the event_name in event_types during provisioning',
+                default: true
+            },
+            ...conditionProperties
+        },
+        required: [
+            'event_name'
+        ]
+    },
+    tags: [
+        'events',
+        'triggers',
+        'analytics',
+        'tracking'
+    ]
+};

package/esm/data/index.d.ts

@@ -2,15 +2,16 @@ export { CheckGreaterThan } from './check-greater-than';
 export { CheckLessThan } from './check-less-than';
 export { CheckNotEqual } from './check-not-equal';
 export { CheckOneOf } from './check-one-of';
-export { LimitAggregate } from './data-aggregate-limit-counter';
-export { BillingMeter } from './data-billing-meter';
+export { LimitEnforceAggregate } from './data-aggregate-limit-counter';
+export { LimitTrackUsage } from './data-billing-meter';
 export { DataBulk } from './data-bulk';
 export { ProcessChunks } from './data-chunks';
 export { DataCompositeField } from './data-composite-field';
 export { DataDirectOwner } from './data-direct-owner';
 export { DataEntityMembership } from './data-entity-membership';
+export { EventTracker } from './event-tracker';
 export { ProcessFileEmbedding } from './data-file-embedding';
-export { LimitFeatureFlag } from './data-feature-flag';
+export { LimitEnforceFeature } from './data-feature-flag';
 export { DataForceCurrentUser } from './data-force-current-user';
 export { DataId } from './data-id';
 export { ProcessImageEmbedding } from './data-image-embedding';
@@ -18,7 +19,11 @@ export { DataImmutableFields } from './data-immutable-fields';
 export { DataInflection } from './data-inflection';
 export { DataInheritFromParent } from './data-inherit-from-parent';
 export { JobTrigger } from './data-job-trigger';
-export { LimitCounter } from './data-limit-counter';
+export { LimitEnforceCounter } from './data-limit-counter';
+export { LimitEnforceRate } from './data-meter-rate-limit';
+export { LimitWarningCounter } from './limit-warning-counter';
+export { LimitWarningAggregate } from './limit-warning-aggregate';
+export { LimitWarningRate } from './limit-warning-rate';
 export { DataJsonb } from './data-jsonb';
 export { DataOwnedFields } from './data-owned-fields';
 export { ProcessExtraction } from './process-extraction';

package/esm/data/index.js

@@ -2,15 +2,16 @@ export { CheckGreaterThan } from './check-greater-than';
 export { CheckLessThan } from './check-less-than';
 export { CheckNotEqual } from './check-not-equal';
 export { CheckOneOf } from './check-one-of';
-export { LimitAggregate } from './data-aggregate-limit-counter';
-export { BillingMeter } from './data-billing-meter';
+export { LimitEnforceAggregate } from './data-aggregate-limit-counter';
+export { LimitTrackUsage } from './data-billing-meter';
 export { DataBulk } from './data-bulk';
 export { ProcessChunks } from './data-chunks';
 export { DataCompositeField } from './data-composite-field';
 export { DataDirectOwner } from './data-direct-owner';
 export { DataEntityMembership } from './data-entity-membership';
+export { EventTracker } from './event-tracker';
 export { ProcessFileEmbedding } from './data-file-embedding';
-export { LimitFeatureFlag } from './data-feature-flag';
+export { LimitEnforceFeature } from './data-feature-flag';
 export { DataForceCurrentUser } from './data-force-current-user';
 export { DataId } from './data-id';
 export { ProcessImageEmbedding } from './data-image-embedding';
@@ -18,7 +19,11 @@ export { DataImmutableFields } from './data-immutable-fields';
 export { DataInflection } from './data-inflection';
 export { DataInheritFromParent } from './data-inherit-from-parent';
 export { JobTrigger } from './data-job-trigger';
-export { LimitCounter } from './data-limit-counter';
+export { LimitEnforceCounter } from './data-limit-counter';
+export { LimitEnforceRate } from './data-meter-rate-limit';
+export { LimitWarningCounter } from './limit-warning-counter';
+export { LimitWarningAggregate } from './limit-warning-aggregate';
+export { LimitWarningRate } from './limit-warning-rate';
 export { DataJsonb } from './data-jsonb';
 export { DataOwnedFields } from './data-owned-fields';
 export { ProcessExtraction } from './process-extraction';

package/esm/data/limit-warning-aggregate.d.ts

@@ -0,0 +1,2 @@
+import type { NodeTypeDefinition } from '../types';
+export declare const LimitWarningAggregate: NodeTypeDefinition;

package/esm/data/limit-warning-aggregate.js

@@ -0,0 +1,24 @@
+export const LimitWarningAggregate = {
+    name: 'LimitWarningAggregate',
+    slug: 'limit_warning_aggregate',
+    category: 'limit_warning',
+    display_name: 'Warning Aggregate',
+    description: 'Attaches an AFTER INSERT trigger that checks if the entity\'s aggregate usage has crossed any warning threshold configured in the limit_warnings table. If a threshold is reached for the first time, enqueues a background job (e.g. email notification). Uses limit_warning_state for one-time dedup per warning/actor/entity triple. Requires a provisioned limits_module with limit_warnings and aggregate limits enabled.',
+    parameter_schema: {
+        type: 'object',
+        properties: {
+            limit_name: {
+                type: 'string',
+                description: 'Name of the aggregate limit to watch (must match a limit_warnings.name entry, e.g. "databases", "members")',
+            },
+            entity_field: {
+                type: 'string',
+                format: 'column-ref',
+                description: 'Column on the target table that holds the entity id for aggregate limit lookup',
+                default: 'entity_id',
+            },
+        },
+        required: ['limit_name'],
+    },
+    tags: ['limits', 'triggers', 'aggregates', 'warning', 'notifications'],
+};

package/esm/data/limit-warning-counter.d.ts

@@ -0,0 +1,2 @@
+import type { NodeTypeDefinition } from '../types';
+export declare const LimitWarningCounter: NodeTypeDefinition;