node-type-registry 0.36.0 → 0.38.0

package/esm/codegen/generate-types.js

@@ -480,7 +480,8 @@ function buildBlueprintBucketSeed() {
  */
 function buildBlueprintStorageConfig() {
     return addJSDoc(exportInterface('BlueprintStorageConfig', [
-        addJSDoc(optionalProp('buckets', t.tsArrayType(t.tsTypeReference(t.identifier('BlueprintBucketSeed')))), 'Initial bucket seed entries. Each creates a row in {prefix}_buckets during provisioning. Only used for app-level storage (not entity-scoped).'),
+        addJSDoc(optionalProp('storage_key', t.tsStringKeyword()), 'Discriminator for multi-module storage. Defaults to "default" (omitted from table names). Non-default keys appear as an infix: {prefix}_{storage_key}_buckets. Max 16 chars, lowercase snake_case.'),
+        addJSDoc(optionalProp('buckets', t.tsArrayType(t.tsTypeReference(t.identifier('BlueprintBucketSeed')))), 'Initial bucket seed entries. Each creates a row in {prefix}_buckets during provisioning.'),
         addJSDoc(optionalProp('upload_url_expiry_seconds', t.tsNumberKeyword()), 'Override for presigned upload URL expiry time in seconds.'),
         addJSDoc(optionalProp('download_url_expiry_seconds', t.tsNumberKeyword()), 'Override for presigned download URL expiry time in seconds.'),
         addJSDoc(optionalProp('default_max_file_size', t.tsNumberKeyword()), 'Default maximum file size in bytes for the storage module.'),
@@ -493,6 +494,37 @@ function buildBlueprintStorageConfig() {
         ])), 'Per-table overrides for storage tables. Each key targets a specific storage table (files, buckets) and uses the same shape as table_provision: { nodes, fields, grants, use_rls, policies }. Fanned out to secure_table_provision targeting the corresponding table. When a key includes policies[], those REPLACE the default storage policies for that table; tables without a key still get defaults.')
     ]), 'Storage configuration for an entity type. Seeds initial buckets, overrides module-level settings (expiry times, file size limits, CORS), and provides per-table provisioning overrides via provisions.');
 }
+// ---------------------------------------------------------------------------
+// Achievement types
+// ---------------------------------------------------------------------------
+function buildBlueprintAchievementRequirement() {
+    return addJSDoc(exportInterface('BlueprintAchievementRequirement', [
+        addJSDoc(requiredProp('event_name', t.tsStringKeyword()), 'Name identifier matching an event_type or step name.'),
+        addJSDoc(requiredProp('count', t.tsNumberKeyword()), 'Number of events needed to satisfy this requirement.'),
+        addJSDoc(optionalProp('description', t.tsStringKeyword()), 'Human-readable description of what this requirement entails.')
+    ]), 'A requirement entry within a blueprint achievement. Defines what events must occur to earn the achievement.');
+}
+function buildBlueprintAchievementReward() {
+    return addJSDoc(exportInterface('BlueprintAchievementReward', [
+        addJSDoc(requiredProp('reward_type', t.tsUnionType([
+            t.tsLiteralType(t.stringLiteral('limit_credit')),
+            t.tsLiteralType(t.stringLiteral('meter_credit'))
+        ])), 'Type of reward: limit_credit (grants limit credits) or meter_credit (grants meter credits).'),
+        addJSDoc(requiredProp('target_name', t.tsStringKeyword()), 'Target limit name or meter slug for the credit grant.'),
+        addJSDoc(requiredProp('amount', t.tsNumberKeyword()), 'Number of credits to grant.'),
+        addJSDoc(optionalProp('credit_type', t.tsStringKeyword()), 'Credit type: permanent, expiring, etc. Defaults to "permanent".')
+    ]), 'A reward entry within a blueprint achievement. Defines credits granted when the achievement is earned.');
+}
+function buildBlueprintAchievement() {
+    return addJSDoc(exportInterface('BlueprintAchievement', [
+        addJSDoc(requiredProp('name', t.tsStringKeyword()), 'Unique name for the achievement level.'),
+        addJSDoc(optionalProp('description', t.tsStringKeyword()), 'Human-readable description of this achievement.'),
+        addJSDoc(optionalProp('priority', t.tsNumberKeyword()), 'Display ordering priority; lower values appear first. Defaults to 100.'),
+        addJSDoc(requiredProp('requirements', t.tsArrayType(t.tsTypeReference(t.identifier('BlueprintAchievementRequirement')))), 'Requirements that must be met to earn this achievement.'),
+        addJSDoc(optionalProp('rewards', t.tsArrayType(t.tsTypeReference(t.identifier('BlueprintAchievementReward')))), 'Rewards granted when the achievement is earned.'),
+        addJSDoc(optionalProp('entity_prefix', t.tsStringKeyword()), 'Entity prefix to scope this achievement to (e.g., "org", "app"). Used to resolve the correct events_module. Defaults to "app".')
+    ]), 'An achievement entry for the blueprint achievements[] section. Creates a level with requirements and optional rewards in the events_module. Requires events_module to be provisioned (e.g., via entity_types[].has_levels = true or modules includes events_module).');
+}
 function buildBlueprintEntityTableProvision() {
     return addJSDoc(exportInterface('BlueprintEntityTableProvision', [
         addJSDoc(optionalProp('use_rls', t.tsBooleanKeyword()), 'Whether to enable RLS on the entity table. Forwarded to secure_table_provision. Defaults to true.'),
@@ -516,11 +548,11 @@ function buildBlueprintEntityType() {
         addJSDoc(optionalProp('has_limits', t.tsBooleanKeyword()), 'Whether to provision a limits module for this entity type. Defaults to false.'),
         addJSDoc(optionalProp('has_profiles', t.tsBooleanKeyword()), 'Whether to provision a profiles module for this entity type. Defaults to false.'),
         addJSDoc(optionalProp('has_levels', t.tsBooleanKeyword()), 'Whether to provision a levels module for this entity type. Defaults to false.'),
-        addJSDoc(optionalProp('has_storage', t.tsBooleanKeyword()), 'Whether to provision a storage module (buckets, files tables) for this entity type. Defaults to false.'),
         addJSDoc(optionalProp('has_invites', t.tsBooleanKeyword()), 'Whether to provision entity-scoped invite tables ({prefix}_invites, {prefix}_claimed_invites) and a submit_{prefix}_invite_code() function. Defaults to false.'),
+        addJSDoc(optionalProp('has_invite_achievements', t.tsBooleanKeyword()), "Whether to auto-attach an EventTracker to the claimed_invites table for invite-based achievements. Requires has_invites=true AND has_levels=true. When true, records 'invite_claimed' events credited to the sender (inviter) on each claimed invite. Defaults to false."),
         addJSDoc(optionalProp('skip_entity_policies', t.tsBooleanKeyword()), 'Escape hatch: when true AND table_provision is NULL, zero policies are provisioned on the entity table. Defaults to false.'),
         addJSDoc(optionalProp('table_provision', t.tsTypeReference(t.identifier('BlueprintEntityTableProvision'))), 'Override for the entity table. Shape mirrors BlueprintTable / secure_table_provision vocabulary. When supplied, its policies[] replaces the five default entity-table policies; is_visible becomes a no-op. When NULL (default), the five default policies are applied (gated by is_visible).'),
-        addJSDoc(optionalProp('storage', t.tsTypeReference(t.identifier('BlueprintStorageConfig'))), 'Storage configuration. Only used when has_storage is true. Controls RLS policies on storage tables, seeds initial buckets, and overrides module-level settings (expiry times, file size limits, CORS).')
+        addJSDoc(optionalProp('storage', t.tsArrayType(t.tsTypeReference(t.identifier('BlueprintStorageConfig')))), 'Storage module configuration array. Each entry provisions a separate storage module with its own tables, RLS, and settings. When non-empty, has_storage is derived as true. Each entry may specify a storage_key for multi-module support (defaults to "default").')
     ]), 'An entity type entry for Phase 0 of construct_blueprint(). Provisions a full entity type with its own entity table, membership modules, and security policies via entity_type_provision.');
 }
 function buildBlueprintTable() {
@@ -548,7 +580,8 @@ function buildBlueprintDefinition() {
         addJSDoc(optionalProp('full_text_searches', t.tsArrayType(t.tsTypeReference(t.identifier('BlueprintFullTextSearch')))), 'Full-text search configurations.'),
         addJSDoc(optionalProp('unique_constraints', t.tsArrayType(t.tsTypeReference(t.identifier('BlueprintUniqueConstraint')))), 'Unique constraints on table columns.'),
         addJSDoc(optionalProp('entity_types', t.tsArrayType(t.tsTypeReference(t.identifier('BlueprintEntityType')))), 'Entity types to provision in Phase 0 (before tables). Each entry creates an entity table with membership modules and security.'),
-        addJSDoc(optionalProp('storage', t.tsTypeReference(t.identifier('BlueprintStorageConfig'))), 'App-level storage configuration. Creates a storage_module (membership_type = NULL), seeds initial buckets, and overrides module-level settings (expiry times, file size limits, CORS). Use provisions for per-table policy overrides. For entity-scoped storage, use entity_types[].has_storage + entity_types[].storage instead.')
+        addJSDoc(optionalProp('storage', t.tsArrayType(t.tsTypeReference(t.identifier('BlueprintStorageConfig')))), 'App-level storage configuration array. Each entry creates a storage_module (membership_type = NULL) with its own tables and settings. For entity-scoped storage, use entity_types[].storage instead.'),
+        addJSDoc(optionalProp('achievements', t.tsArrayType(t.tsTypeReference(t.identifier('BlueprintAchievement')))), 'Achievement definitions. Each entry creates a level with requirements and optional rewards in the events_module. Requires events_module to be provisioned (e.g., via entity_types[].has_levels = true or modules includes events_module).')
     ]), 'The complete blueprint definition -- the JSONB shape accepted by construct_blueprint().');
 }
 // ---------------------------------------------------------------------------
@@ -607,6 +640,9 @@ function buildProgram(meta) {
     statements.push(buildBlueprintTableUniqueConstraint());
     statements.push(buildBlueprintBucketSeed());
     statements.push(buildBlueprintStorageConfig());
+    statements.push(buildBlueprintAchievementRequirement());
+    statements.push(buildBlueprintAchievementReward());
+    statements.push(buildBlueprintAchievement());
     statements.push(buildBlueprintEntityTableProvision());
     statements.push(buildBlueprintEntityType());
     // -- Node types discriminated union --

package/esm/conditions/index.d.ts

@@ -0,0 +1 @@
+export { conditionDefs, conditionProperties, triggerConditionSchema, triggerConditionsProperty } from './trigger-condition';

package/esm/conditions/index.js

@@ -0,0 +1 @@
+export { conditionDefs, conditionProperties, triggerConditionSchema, triggerConditionsProperty } from './trigger-condition';

package/esm/conditions/trigger-condition.d.ts

@@ -0,0 +1,35 @@
+import type { JSONSchema } from '../types';
+/**
+ * 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 declare const triggerConditionSchema: JSONSchema;
+/**
+ * $defs block for parameter_schema. Spread into any node that uses conditions.
+ *
+ * Usage:
+ *   parameter_schema: { type: 'object', $defs: conditionDefs, properties: { ... } }
+ */
+export declare const conditionDefs: Record<string, JSONSchema>;
+/**
+ * Common condition-related properties for trigger-based nodes.
+ * Three mutually exclusive options for WHEN clause specification.
+ *
+ * Usage:
+ *   properties: { event_name: { ... }, ...conditionProperties }
+ */
+export declare const conditionProperties: Record<string, JSONSchema>;
+/**
+ * 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 declare const triggerConditionsProperty: JSONSchema;

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/index.d.ts

@@ -2,27 +2,17 @@ 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 { 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 { ProcessFileEmbedding } from './data-file-embedding';
-export { LimitFeatureFlag } from './data-feature-flag';
 export { DataForceCurrentUser } from './data-force-current-user';
 export { DataId } from './data-id';
-export { ProcessImageEmbedding } from './data-image-embedding';
 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 { DataJsonb } from './data-jsonb';
 export { DataOwnedFields } from './data-owned-fields';
-export { ProcessExtraction } from './process-extraction';
-export { ProcessImageVersions } from './process-image-versions';
 export { DataOwnershipInEntity } from './data-ownership-in-entity';
 export { DataPeoplestamps } from './data-peoplestamps';
 export { DataPublishable } from './data-publishable';

package/esm/data/index.js

@@ -2,27 +2,17 @@ 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 { 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 { ProcessFileEmbedding } from './data-file-embedding';
-export { LimitFeatureFlag } from './data-feature-flag';
 export { DataForceCurrentUser } from './data-force-current-user';
 export { DataId } from './data-id';
-export { ProcessImageEmbedding } from './data-image-embedding';
 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 { DataJsonb } from './data-jsonb';
 export { DataOwnedFields } from './data-owned-fields';
-export { ProcessExtraction } from './process-extraction';
-export { ProcessImageVersions } from './process-image-versions';
 export { DataOwnershipInEntity } from './data-ownership-in-entity';
 export { DataPeoplestamps } from './data-peoplestamps';
 export { DataPublishable } from './data-publishable';

package/esm/data/search-unified.js

@@ -108,6 +108,14 @@ export const SearchUnified = {
                             format: 'column-ref'
                         }
                     },
+                    embedding_model: {
+                        type: 'string',
+                        description: 'Embedding model identifier. When null, the worker falls back to runtime config.'
+                    },
+                    embedding_provider: {
+                        type: 'string',
+                        description: 'Embedding provider name. When null, the worker falls back to runtime config.'
+                    },
                     search_score_weight: {
                         type: 'number',
                         default: 1

package/esm/data/search-vector.js

@@ -50,6 +50,18 @@ export const SearchVector = {
                 },
                 description: 'Column names that feed the embedding. Used by stale trigger to detect content changes.'
             },
+            // ── Model config (optional — flows into job payload) ──────────
+            embedding_model: {
+                type: 'string',
+                description: 'Embedding model identifier (e.g. "nomic-embed-text", "text-embedding-3-small"). ' +
+                    '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.'
+            },
             enqueue_job: {
                 type: 'boolean',
                 description: 'Auto-create trigger that enqueues embedding generation jobs',

package/esm/event/index.d.ts

@@ -0,0 +1,2 @@
+export { EventReferral } from './referral';
+export { EventTracker } from './tracker';

package/esm/event/index.js

@@ -0,0 +1,2 @@
+export { EventReferral } from './referral';
+export { EventTracker } from './tracker';

package/esm/event/referral.d.ts

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

package/esm/event/referral.js

@@ -0,0 +1,62 @@
+import { conditionDefs, conditionProperties } from '../conditions';
+export const EventReferral = {
+    name: 'EventReferral',
+    slug: 'event_referral',
+    category: 'event',
+    display_name: 'Event Referral',
+    description: 'Creates triggers that record events for the referrer (inviter) when their ' +
+        'invitees perform actions on a watched table. Resolves the referrer automatically ' +
+        'via the invites module\'s claimed_invites table using the membership_type context. ' +
+        'Supports the same compound condition system as EventTracker. Use with achievements ' +
+        'to unlock levels and grant credits based on invitee activity.',
+    parameter_schema: {
+        type: 'object',
+        $defs: conditionDefs,
+        properties: {
+            event_name: {
+                type: 'string',
+                description: 'Event type name to record for the referrer (e.g., "invitee_uploaded_avatar", "invitee_completed_onboarding")'
+            },
+            events: {
+                type: 'array',
+                items: {
+                    type: 'string',
+                    enum: [
+                        'INSERT',
+                        'UPDATE',
+                        'DELETE'
+                    ]
+                },
+                description: 'DML events that trigger recording',
+                default: ['INSERT']
+            },
+            actor_field: {
+                type: 'string',
+                format: 'column-ref',
+                description: 'Column containing the invitee (actor) ID on the source table — used to look up the referrer via claimed_invites.receiver_id',
+                default: 'owner_id'
+            },
+            entity_field: {
+                type: 'string',
+                format: 'column-ref',
+                description: 'Column containing the entity ID (org/group) for entity-scoped referral 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',
+        'referral',
+        'invites',
+        'analytics',
+        'tracking'
+    ]
+};

package/esm/event/tracker.d.ts

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

package/esm/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/index.d.ts

@@ -1,7 +1,12 @@
 export * from './authz';
 export * from './blueprint-types.generated';
+export * from './conditions';
 export * from './data';
+export * from './event';
+export * from './job';
+export * from './limit';
 export * from './module-presets';
+export * from './process';
 export * from './relation';
 export type { JSONSchema, NodeTypeDefinition } from './types';
 export * from './view';

package/esm/index.js

@@ -1,16 +1,29 @@
 export * from './authz';
 export * from './blueprint-types.generated';
+export * from './conditions';
 export * from './data';
+export * from './event';
+export * from './job';
+export * from './limit';
 export * from './module-presets';
+export * from './process';
 export * from './relation';
 export * from './view';
 import * as authz from './authz';
 import * as data from './data';
+import * as event from './event';
+import * as job from './job';
+import * as limit from './limit';
+import * as process from './process';
 import * as relation from './relation';
 import * as view from './view';
 export const allNodeTypes = [
     ...Object.values(authz),
     ...Object.values(data),
+    ...Object.values(event),
+    ...Object.values(job),
+    ...Object.values(limit),
+    ...Object.values(process),
     ...Object.values(relation),
     ...Object.values(view)
 ];

package/esm/job/index.d.ts

@@ -0,0 +1 @@
+export { JobTrigger } from './trigger';

package/esm/job/index.js

@@ -0,0 +1 @@
+export { JobTrigger } from './trigger';

package/esm/{data/data-job-trigger.js → 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/limit/enforce-aggregate.d.ts

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

package/esm/{data/data-aggregate-limit-counter.js → limit/enforce-aggregate.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/limit/enforce-counter.d.ts

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