The MJ: AI Prompts ID to run for each record.
Mapping shaping the data passed to the prompt; undefined for the default ({ record }).
The DataFeatureSpec defining outputs, constraints, and caching policy; undefined when there is none.
The Record Process's OutputMapping text, part of the spec hash (null when it has none).
ReadonlyDefaultDefault dry-run sample cap for Infer pipelines over a stored scope (every previewed record calls the model).
ReadonlyFailAn Infer run that completed with one or more failed records ends with status Failed.
Protected ReadonlyinputMapping shaping the data passed to the prompt; undefined for the default ({ record }).
Protected ReadonlyoutputThe Record Process's OutputMapping text, part of the spec hash (null when it has none).
ProtectedPipelineThe pipeline version this run computes under (part of the Feature Value key); null until resolved.
Protected ReadonlypromptThe MJ: AI Prompts ID to run for each record.
Protected ReadonlyspecThe DataFeatureSpec defining outputs, constraints, and caching policy; undefined when there is none.
Whether this processor writes its records' MJ: Feature Values (off on a Decision pipeline's escalation target).
Static ReadonlyBELOW_The reserved payload key listing the outputs withheld below their confidence floor (cached with the outputs).
Static ReadonlyDRIVER_The reserved payload key holding the driver's own per-output confidences (cached with the outputs).
Static ReadonlyRESERVED_The payload keys this processor reserves; they ride in the cached and result payloads.
The hash that versions this pipeline's output constraints, including the allowed values the run resolved.
How many records this processor has escalated to its spec's Escalation pipeline. A processor
serves one run, so this is the run's count. It counts every record whose answer was escalated,
including the records that shared a Dedup Cache key with one, and the escalations that failed.
The MJ: AI Prompts ID this processor runs for each record.
The pipeline's DataFeatureSpec, when it has one.
ProtectedafterLifecycle hook called after prompt execution returns successfully. Defaults to returning result.result.
ProtectedApplyWithholds each output below its confidence floor (by the confidences its Feature Values carry): nulled in the payload and named under BELOW_CONFIDENCE_KEY.
the validated payload; unknown on purpose, a model's answer of any shape
ProtectedbeforeLifecycle hook called before prompt data context is constructed.
ProtectedbeforeLifecycle hook called immediately before ExecutePrompt is invoked.
Lifecycle hook called before write-back is executed on this record.
ProtectedbuildBuilds the data object passed to the prompt. Incorporates spec.Context (EntityDocumentID rendering, QueryID parameterized execution, Field filtering), input mapping, and Layer-1 constraint instructions.
Optionalctx: RecordProcessorContextBuilds the Feature Pipeline run summary (and WouldRefuse on a dry run) from the run's counts and per-record results.
ProtectedBuildThe prompt's user turn when the spec sets Context.RecordAsUserMessage: the record's Context.Fields values as
one JSON object (JSON-encoding fences each value), else null (the runner's default turn).
Computes the watermark basis hash for Checksum strategy: the record's prompt data and the pin.
ProtectedcomputeComputes a deterministic SHA-256 hash representing the output constraints and their resolved allowed values.
Optionalspec: DataFeatureSpecOptionalresolved: Map<string, ResolvedConstraint>ProtectedcomputeComputes a deterministic SHA-256 hash representing the prompt version and constraint instructions.
A pipeline type other than LLM is part of the hash, so switching a pipeline's type never serves
the old type's cached values. An LLM pipeline's hash is unchanged by the type's introduction.
So are the Escalation settings: the floor decides which decision answers are confident enough to
keep, so changing it (or the target) invalidates the answers cached under the old settings. A
pipeline without Escalation keeps its hash.
Optionalspec: DataFeatureSpecOptionalresolved: Map<string, ResolvedConstraint>ProtectedCreateCreates the parser that renders the spec's context Entity Document for a record.
Optionalprovider: IMetadataProviderthe run's provider, which resolves the document's entities; the parser's default when omitted
The guard write-back uses to keep values a person entered; undefined when the run has no pipeline, entity or spec.
The pin this run computes under once resolved, else null (the run result of skipped records reports it).
On a dry run, why the version registry would refuse the real run, else null.
Queues this processor's Feature Value writes for the write-back unit that wraps it (WriteDeferredFeatureValues).
Generic DeferredRecordWriteSource hook delegating to DeferFeatureValuesToWriteBack.
Drops a record's queued Feature Value writes: its result failed, so it gets no write-back.
Generic DeferredRecordWriteSource hook delegating to DiscardDeferredFeatureValues.
ProtectedensureEnsures that every record in the batch has its full field data loaded on record.Record.
If records only have primary keys (as yielded by source pagination), batch-fetches the
full records via RunView in a single query per entity.
The pin and input hash a record's result was computed under in this batch; undefined when it did not succeed.
ProtectedFeatureThe message a dry-run record fails with when its stored Feature Values cannot be read for the preview; also logged.
ProtectedFeatureThe message a record fails with when its Feature Values cannot be written; also logged.
The resolved output constraints (with lookup rows) of this processor; the golden-set driver scores with them.
ProtectedKeepKeeps a record's pre-run values: the first write's capture per feature in this batch.
ProtectedLoadResolves every output's constraint and loads lookup rows through the run's provider (OutputConstraintResolver.Resolve).
Run-level checks before the first record: the prompt template renders the constraint block, and the version registry's run gate resolves the version the run writes under.
Enriches the output mapping with fieldLookups from spec.Outputs and reports whether any output has no write target.
What the record's outputs with no write target would store on this dry-run batch; empty when none would change.
ProtectedPreviewOn a dry run, works out what the record's outputs with no write target would store and keeps it for PreviewFeatureValues: each one whose typed answer differs from the record's latest stored value (its Pipeline value), or that has none. A withheld output stores nothing, so it is omitted.
What the record's unmapped outputs would store on this dry-run batch (WriteBackProcessor hook).
A record's Feature Values before this processor first wrote them in the current batch; undefined when it wrote none.
Two-phase batch execution (P1-7c). Resolves distinct keys across the batch first, checks the dedup cache in one batch query, executes LLM prompts ONCE per distinct key, and fans results back across all matching rows.
Processes one record.
The record to process.
The per-record execution context.
Optionaloptions: { keyInfo?: CacheKeyResult; skipLookup?: boolean }The record's outcome (Succeeded / Failed / Skipped) plus any payload / trace links.
ProtectedRecordedThe reasoning and per-output confidences a record's Feature Values carry, read from the payload the Dedup Cache stores (so a cache hit records what the miss recorded). The driver's confidence wins over a ConfidenceRef; an output the constraint check replaced gets none.
ProtectedrecordExtracts a plain field map from the record (BaseEntity → GetAll(), plain object → as-is).
ProtectedResetStarts a batch: drops the previous batch's per-record state (PreviousFeatureValues, FeatureValueKeyOf).
ProtectedresolveLifecycle hook to resolve a dedup cache key for this record. Default returns null (computed by cache service).
ProtectedResolveThe pipeline's resolved output constraints, lookup rows included; loaded once per processor (a failed load too).
ProtectedResolveResolves the driver for this pipeline's type, once per processor instance.
The type is DataFeatureSpec.PipelineType, or LLM when absent. It is matched by name
(case-insensitive, trimmed) against the MJ: Feature Pipeline Types catalog cached by
KnowledgeHubMetadataEngine, and its DriverClass is created through the ClassFactory. LLM
resolves to LLMFeaturePipelineDriver when the catalog has no LLM row, or cannot be read,
so a database without the seed row keeps working. The driver's ValidateOutputs then runs once.
ProtectedResolveThe pin hash of this Decision pipeline's escalation target, which its spec hash covers; null when it does not escalate, or the target is unusable as configured (each escalating record then fails with the reason).
The pin this processor's prompt and spec give right now: prompt version hash, primary model, parameters hash and spec hash. Resolved per record but re-hashed only when a fingerprint of its inputs (prompt text and parameters, primary model, escalation target pin) changed, so an edited prompt takes effect on the next record.
ProtectedResolveKeeps the version this run writes under, the pin hash it was resolved for and, on a dry run, why a real run would be refused.
The pin of this processor's current run state (prompt, model, parameters, spec).
ProtectedRunThe run-result pin of a Feature Value pin: this processor's pipeline version plus the pin's three key hashes.
ProtectedSyncF-FP-6: the pin hashes the template text that is in the database at run start, not the text the prompt loaded
when the process started, and the template engine is reloaded when its cache holds other text — so an edited
template changes the next run's pin and is what the next run renders, without a restart. The text is read once
per run (per ProcessRunID and template); a call without a ProcessRunID reads every time.
ProtectedUpsertUpserts a record's Feature Values for all outputs, on their key. OutputConfidence sets each output's confidence
ahead of Confidence; OmitValues writes every value as null (a superseded decision's row). When deferred
(DeferFeatureValuesToWriteBack) the write is queued for the record's write-back unit instead.
What the upsert did; null when nothing is written now (a dry run, nothing to write, or deferred).
ProtectedvalidateLayer 2 output validation hook. Evaluates outputs against declared constraints, applies OnViolation
policies (fail, null, coerce-to-other), and builds the processed payload. replacedOutputs names
the outputs whose value a null or coerce-to-other policy replaced.
ProtectedWithWrites one record's Feature Values and returns its result: Failed when the write failed, else with Outcome,
PipelineVersion and PipelinePin. A dry run writes nothing: DryRun: true and no Outcome.
The field and child-entity targets a successful result withheld; undefined when it withheld nothing.
Saves a record's queued Feature Value writes on the write-back unit's provider; null when none were queued.
Generic DeferredRecordWriteSource hook delegating to WriteDeferredFeatureValues.
ProtectedWriteWrites one record's Feature Values now, on params.Context.Provider, and keeps the values they replaced.
ProtectedWriteOne queued write on the unit's provider; a failure names the record.
StaticConstraintThe TSType a constraint implies for an output with no write target (no column to take one from): 'number' for
numeric and money, 'boolean' for boolean, 'Date' for date; undefined for the others.
Protected StaticDriverThe driver confidences a payload stores under DRIVER_CONFIDENCE_KEY (numbers in [0, 1] only).
StaticExtractThe model's reasoning (ModelAnswer.Reasoning); undefined when capture is off.
StaticFromBuilds the processor for an Infer Feature Pipeline from its MJ: Record Processes row: parses and
validates the DataFeatureSpec in Configuration (and its materialization targets), and creates the
spec's ProcessorExtensionKey subclass when it names one. RecordProcessExecutor builds every
Infer pipeline this way, and so does a Decision pipeline's escalation to an LLM pipeline.
The pipeline's row (WorkType Infer).
Optionalprovider: IMetadataProviderThe provider whose metadata the materialization targets are checked against (default: the global one).
Protected StaticResolvedThe allowed values an output resolved from outside its spec (lookup rows, field-metadata enum values).
Protected StaticWithThe payload with the driver's confidences under DRIVER_CONFIDENCE_KEY; unchanged without any or for a non-object.
StaticWithheldThe outputs a payload withheld below their confidence floor (BELOW_CONFIDENCE_KEY); empty when none.
Protected StaticWithoutA model's answer without the reserved keys (RESERVED_PAYLOAD_KEYS); a non-object answer as it is.
Runs an AI Prompt per record and returns its structured output (write-back is the wrapper's job). A pipeline whose spec sets
Escalationcomputes a whole batch before recording any of it, so its batch path does not call ProcessRecord once per record: an extension that overridesProcessRecorddoes not see those records.