@dudousxd/nestjs-catalog 0.19.0 → 0.21.0

package/dist/catalog.pipeline.d.ts

@@ -27,6 +27,46 @@ export type ConnectorKind = (typeof CONNECTOR_KINDS)[number];
  * entirely. Anything narrowing a stored value narrows against *this*.
  */
 export declare function isConnectorKind(value: unknown): value is ConnectorKind;
+/**
+ * How the bytes behind a `file` or `s3` connector are read as records.
+ *
+ * A list rather than a loose string, for the reason {@link CONNECTOR_KINDS} is
+ * one: this used to be compared against string literals in the parser and
+ * spelled out again in a dropdown, and the two had no way to disagree loudly.
+ * The parser's chain also *ended* in JSON, so a format it did not recognise was
+ * not refused — it was read as JSON, so a spreadsheet handed to `JSON.parse`
+ * failed with a syntax error naming a byte offset rather than the format, and
+ * so did `format: "parquet"`.
+ *
+ * Two things distinguish the members, and everything downstream turns on one or
+ * the other. **Text or binary:** `xlsx` and `parquet` are binary, so everything
+ * that reads them takes bytes, and the other two are decoded first. **Whether
+ * there is a row boundary a reader can find without holding the whole
+ * payload:** `csv` and `ndjson` have one at every newline and `parquet` has one
+ * at every row group, so those three are read as a stream; `json` is a single
+ * value whose array may be nested inside an envelope that is only found by
+ * parsing down to it, and `xlsx` is a ZIP whose shared-string table generally
+ * has to be read before the sheet. Anything deciding something *per format*
+ * narrows against this list and answers {@link unreachableSourceFormat}.
+ */
+export declare const SOURCE_FORMATS: readonly ["csv", "ndjson", "json", "xlsx", "parquet"];
+export type SourceFormat = (typeof SOURCE_FORMATS)[number];
+/** Same reason as {@link isConnectorKind}: one list, no second copy to drift. */
+export declare function isSourceFormat(value: unknown): value is SourceFormat;
+/**
+ * The format that never compiles quietly.
+ *
+ * The {@link unreachableNodeKind} of formats, and it exists for the same reason:
+ * a member added to {@link SOURCE_FORMATS} without a branch in the parser should
+ * be a type error naming the file, not a connector that offers a format in a
+ * dropdown and then reads the file as JSON.
+ *
+ * It throws as well as failing to compile, because a connector config is JSON
+ * that outlives the build that wrote it: a `format` stored by a newer deployment
+ * and read by an older one is possible, and falling back to a default for it
+ * would be exactly the silent path this closes.
+ */
+export declare function unreachableSourceFormat(format: never, where: string): never;
 /**
  * What a published workflow runs as. **Not an authored object.**
  *
@@ -1042,6 +1082,13 @@ export interface WorkflowSinkNode extends WorkflowNodeBase, ReusableNodeRef {
  * answers are two documented shapes, and anything else fails the node naming
  * the workflow, the version and the child run id.
  *
+ * All of the paragraph above describes the **envelope** mode, which is the
+ * default and what every stored call node is. {@link callMode} names the other
+ * one: a plain call sends {@link config} verbatim, so a workflow that has never
+ * heard of this catalog can be called without being edited — and gives up the
+ * ability to hand rows back, because it is told no key to stage them under. See
+ * {@link WORKFLOW_CALL_MODES}.
+ *
  * ## `config` is not a credential store
  *
  * Named `config` rather than `input` so it travels the same path a source
@@ -1067,9 +1114,109 @@ export interface WorkflowCallNode extends WorkflowNodeBase {
      * to *this* graph and is a number. This one identifies somebody else's code.
      */
     callVersion: string;
-    /** Parameters the author typed, handed to the child under `input`. */
+    /**
+     * Parameters the author typed. Where they land depends on
+     * {@link WorkflowCallNode.callMode}: under `input` in an envelope call, and as
+     * the whole of the child's payload in a plain one.
+     */
     config: Record<string, unknown>;
+    /**
+     * Whether the child is handed a {@link WorkflowCallEnvelope} or the bare
+     * {@link config}. See {@link WORKFLOW_CALL_MODES}, which is where the choice
+     * is argued.
+     *
+     * Absent means `'envelope'`, which is what every call node stored before this
+     * field existed is and what every one of them has always done. Read it through
+     * {@link workflowCallMode} rather than defaulting it a second time — one
+     * default, no second copy to drift.
+     */
+    callMode?: WorkflowCallMode;
 }
+/**
+ * What a {@link WorkflowCallNode} puts on the wire, and the whole of it.
+ *
+ * ## Why there is a second mode at all
+ *
+ * The catalog could not call a workflow that does not know about the catalog.
+ * A `call` node wraps the author's `config` in a {@link WorkflowCallEnvelope},
+ * so a workflow that already exists — one registered years before this package,
+ * whose body reads `data["proc"]` — receives `{catalog: {...}, input: {proc:
+ * ...}}` and dies on the first key it looks for. The only repair available was
+ * to edit the callee, which inverts the dependency exactly the wrong way round:
+ * every workflow anybody wanted to call would have to start depending on this
+ * package's contract, and a Python workflow registered in another repository
+ * would have to be changed to be reachable from a graph.
+ *
+ * ## Why the nesting is not being loosened instead
+ *
+ * The envelope nests for one stated reason, which is on {@link
+ * WorkflowCallEnvelope}: an author's parameter called `runId` must not be able
+ * to shadow the run id. That reason is sound and it is not being weakened. It
+ * simply does not reach the plain mode, because a plain call sends **no catalog
+ * metadata at all** — there is no `runId`, no `nodeId`, no contract number on
+ * the wire, so there is nothing a parameter could shadow. The flat payload is
+ * not the envelope with its guard removed; it is a different, smaller promise.
+ *
+ * ## What the plain mode costs, which is not small
+ *
+ * No `runId` and no `nodeId` means the callee has no key to stage rows under.
+ * Rows travel through the stage store addressed by `(runId, nodeId, batch)` —
+ * see {@link WorkflowStageRef} — and a callee that was told neither cannot
+ * write where the next node would read. So a plain call **cannot return rows to
+ * the graph**, and that is not a convention anybody could follow more carefully:
+ * it is arithmetic. `validateWorkflow` refuses a plain call with an outbound
+ * edge for exactly this reason (`call-plain-has-output`), and its return value
+ * is not read as a row count — see {@link readWorkflowCallOutput} for the shape
+ * that is deliberately *not* consulted on this path.
+ *
+ * A plain call is therefore for its **effect**: run the thing, and let something
+ * else in the graph produce what gets committed.
+ *
+ * ## Why a mode on the node rather than a second node kind or a boolean
+ *
+ * A boolean is the shape {@link WORKFLOW_PREDICATE_KINDS} argues against one
+ * level down, and for the reason it gives: a `plain?: boolean` beside a future
+ * third wire format is two optional flags whose combinations nobody defined, and
+ * every reader invents its own rule for which wins. A closed list with an
+ * exhaustiveness guard ({@link unreachableCallMode}) makes a third format a
+ * compile error naming the files that have to answer for it.
+ *
+ * A second node *kind* was the other candidate and it is too big. The kind list
+ * is deliberately small and every entry earns it by doing something no wiring
+ * can express (see {@link WORKFLOW_NODE_KINDS}). A plain call does the same
+ * thing a call does at the level the graph reasons about — it hands this
+ * position to a workflow somebody else registered, pinned by name and version.
+ * What differs is the payload. Splitting the kind would duplicate `callName`,
+ * `callVersion`, `config`, the pin check, the picker, the plan entry and the
+ * canvas node for a difference of one field, and every place that today writes
+ * `node.kind === 'call'` would have to remember to write both — which is the
+ * hand-maintained list going quiet that {@link NODE_KIND_IS_REUSABLE} exists to
+ * stop.
+ */
+export declare const WORKFLOW_CALL_MODES: readonly ["envelope", "plain"];
+export type WorkflowCallMode = (typeof WORKFLOW_CALL_MODES)[number];
+/** Same reason as {@link isConnectorKind}: one list, no second copy to drift. */
+export declare function isWorkflowCallMode(value: unknown): value is WorkflowCallMode;
+/**
+ * {@link unreachableNodeKind}, one level down, and for the identical reason.
+ *
+ * Every branch over {@link WorkflowCallMode} ends here, so a third wire format
+ * added to the list without a rule for building its payload, hashing it,
+ * validating it or reading its answer is a type error naming the file. It throws
+ * as well, because a mode arrives as JSON out of a column and a build older than
+ * the data is a thing that happens.
+ */
+export declare function unreachableCallMode(mode: never, where: string): never;
+/**
+ * The mode this call node runs in, with the default applied once.
+ *
+ * Absent means `'envelope'` — that is what every node stored before the field
+ * existed is, and reading it as anything else would silently change what a
+ * deployment's graphs already do. One function so that the store, the runner,
+ * the hash and the canvas cannot each carry their own `?? 'envelope'` and have
+ * one of them drift.
+ */
+export declare function workflowCallMode(node: WorkflowCallNode): WorkflowCallMode;
 /**
  * The kinds of test an {@link WorkflowIfNode} can make.
  *
@@ -2364,6 +2511,18 @@ export interface WorkflowCallOutput {
  * schema for a workflow's output anywhere in the durable contract, and no way
  * to reach one if there were. So the check is here, at the one moment the
  * answer exists, and it names what it saw.
+ *
+ * ## Not called at all for a plain call, which is a decision and not an omission
+ *
+ * A plain call is handed no run id and no node id, so its callee could not have
+ * staged anything under `(runId, nodeId, batch)` even if it wanted to. Running
+ * this over its answer would be worse than pointless in both directions: a
+ * callee that happens to return `{batches, rowCount}` meaning something else
+ * entirely would have this graph go and read a stage that does not exist, and a
+ * callee returning one of the two would fail the node over a key it was never
+ * told about. So the plain path reports zero rows unconditionally and reads
+ * nothing — see `WorkflowRunnerService.callOutput`, which is where that is
+ * enforced rather than merely intended.
  */
 export declare function readWorkflowCallOutput(value: unknown): WorkflowCallOutput | undefined;
 /**
@@ -2489,7 +2648,7 @@ export interface CallableWorkflowBlock {
 }
 export declare function callableWorkflowBlock(ref: CallableWorkflowRef): CallableWorkflowBlock | undefined;
 /** Every way a graph can be refused. Exported so a canvas can key off the code. */
-export declare const WORKFLOW_ISSUE_CODES: readonly ["empty", "invalid-node-id", "duplicate-node-id", "edge-endpoint-missing", "self-edge", "duplicate-edge", "cycle", "no-source", "source-has-input", "no-sink", "duplicate-sink-type", "sink-has-output", "unreachable", "dead-end", "transform-not-named", "call-not-named", "if-not-named", "if-threshold-invalid", "if-needs-one-input", "branch-not-labelled", "branch-on-plain-edge", "filter-predicate-invalid", "filter-narrows-unacknowledged", "filter-narrows-nothing", "version-pin-invalid"];
+export declare const WORKFLOW_ISSUE_CODES: readonly ["empty", "invalid-node-id", "duplicate-node-id", "edge-endpoint-missing", "self-edge", "duplicate-edge", "cycle", "no-source", "source-has-input", "no-sink", "duplicate-sink-type", "sink-has-output", "unreachable", "dead-end", "transform-not-named", "call-not-named", "call-plain-has-output", "if-not-named", "if-threshold-invalid", "if-needs-one-input", "branch-not-labelled", "branch-on-plain-edge", "filter-predicate-invalid", "filter-narrows-unacknowledged", "filter-narrows-nothing", "version-pin-invalid"];
 export type WorkflowIssueCode = (typeof WORKFLOW_ISSUE_CODES)[number];
 export interface WorkflowValidationIssue {
     code: WorkflowIssueCode;

package/dist/catalog.pipeline.js

@@ -9,14 +9,19 @@
  * systems each believing they decide when a load runs.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.REDACTED_SECRET = exports.CATALOG_PIPELINE_STORE = exports.WORKFLOW_ISSUE_CODES = exports.WORKFLOW_CALL_CONTRACT = exports.WORKFLOW_EXECUTION_MODES = exports.WORKFLOW_STATUSES = exports.WORKFLOW_BRANCH_LABELS = exports.NODE_KIND_IS_REUSABLE = exports.REUSABLE_NODE_KINDS = exports.WORKFLOW_FILTER_MAX_VALUES = exports.WORKFLOW_FILTER_MAX_DEPTH = exports.WORKFLOW_FILTER_COLUMN_PATTERN = exports.WORKFLOW_FILTER_OPERATORS = exports.WORKFLOW_FILTER_PREDICATE_KINDS = exports.WORKFLOW_PREDICATE_KINDS = exports.WORKFLOW_ROW_GAP = exports.WORKFLOW_COLUMN_GAP = exports.WORKFLOW_NODE_HEIGHT = exports.WORKFLOW_NODE_WIDTH = exports.WORKFLOW_NODE_ID_PATTERN = exports.WORKFLOW_NODE_KINDS = exports.WORKFLOW_SKIP_REASONS = exports.CODE_CONTEXT_CONTRACT = exports.TRANSFORM_RUNNER = exports.TRANSFORM_LANGUAGES = exports.CONNECTOR_KINDS = void 0;
+exports.REDACTED_SECRET = exports.CATALOG_PIPELINE_STORE = exports.WORKFLOW_ISSUE_CODES = exports.WORKFLOW_CALL_CONTRACT = exports.WORKFLOW_EXECUTION_MODES = exports.WORKFLOW_STATUSES = exports.WORKFLOW_BRANCH_LABELS = exports.NODE_KIND_IS_REUSABLE = exports.REUSABLE_NODE_KINDS = exports.WORKFLOW_FILTER_MAX_VALUES = exports.WORKFLOW_FILTER_MAX_DEPTH = exports.WORKFLOW_FILTER_COLUMN_PATTERN = exports.WORKFLOW_FILTER_OPERATORS = exports.WORKFLOW_FILTER_PREDICATE_KINDS = exports.WORKFLOW_PREDICATE_KINDS = exports.WORKFLOW_CALL_MODES = exports.WORKFLOW_ROW_GAP = exports.WORKFLOW_COLUMN_GAP = exports.WORKFLOW_NODE_HEIGHT = exports.WORKFLOW_NODE_WIDTH = exports.WORKFLOW_NODE_ID_PATTERN = exports.WORKFLOW_NODE_KINDS = exports.WORKFLOW_SKIP_REASONS = exports.CODE_CONTEXT_CONTRACT = exports.TRANSFORM_RUNNER = exports.TRANSFORM_LANGUAGES = exports.SOURCE_FORMATS = exports.CONNECTOR_KINDS = void 0;
 exports.isConnectorKind = isConnectorKind;
+exports.isSourceFormat = isSourceFormat;
+exports.unreachableSourceFormat = unreachableSourceFormat;
 exports.isTransformLanguage = isTransformLanguage;
 exports.isWorkflowSkipReason = isWorkflowSkipReason;
 exports.isWorkflowNodeKind = isWorkflowNodeKind;
 exports.unreachableNodeKind = unreachableNodeKind;
 exports.workflowColumnX = workflowColumnX;
 exports.workflowRowY = workflowRowY;
+exports.isWorkflowCallMode = isWorkflowCallMode;
+exports.unreachableCallMode = unreachableCallMode;
+exports.workflowCallMode = workflowCallMode;
 exports.isWorkflowPredicateKind = isWorkflowPredicateKind;
 exports.unreachablePredicateKind = unreachablePredicateKind;
 exports.isWorkflowIfPredicate = isWorkflowIfPredicate;
@@ -93,6 +98,73 @@ exports.CONNECTOR_KINDS = [
 function isConnectorKind(value) {
     return exports.CONNECTOR_KINDS.some((kind) => kind === value);
 }
+/**
+ * How the bytes behind a `file` or `s3` connector are read as records.
+ *
+ * A list rather than a loose string, for the reason {@link CONNECTOR_KINDS} is
+ * one: this used to be compared against string literals in the parser and
+ * spelled out again in a dropdown, and the two had no way to disagree loudly.
+ * The parser's chain also *ended* in JSON, so a format it did not recognise was
+ * not refused — it was read as JSON, so a spreadsheet handed to `JSON.parse`
+ * failed with a syntax error naming a byte offset rather than the format, and
+ * so did `format: "parquet"`.
+ *
+ * Two things distinguish the members, and everything downstream turns on one or
+ * the other. **Text or binary:** `xlsx` and `parquet` are binary, so everything
+ * that reads them takes bytes, and the other two are decoded first. **Whether
+ * there is a row boundary a reader can find without holding the whole
+ * payload:** `csv` and `ndjson` have one at every newline and `parquet` has one
+ * at every row group, so those three are read as a stream; `json` is a single
+ * value whose array may be nested inside an envelope that is only found by
+ * parsing down to it, and `xlsx` is a ZIP whose shared-string table generally
+ * has to be read before the sheet. Anything deciding something *per format*
+ * narrows against this list and answers {@link unreachableSourceFormat}.
+ */
+exports.SOURCE_FORMATS = [
+    /** Delimited text with a header row. The delimiter is configurable. */
+    'csv',
+    /** One JSON value per line. */
+    'ndjson',
+    /** A JSON document, optionally with the array nested in an envelope. */
+    'json',
+    /**
+     * A spreadsheet workbook — binary, and read whole.
+     *
+     * Named for the modern extension, but the reader identifies the container
+     * from its own bytes, so the legacy `.xls` and the macro-enabled `.xlsm` are
+     * this format too rather than three names for one decision.
+     */
+    'xlsx',
+    /**
+     * Apache Parquet — binary, and read a row group at a time.
+     *
+     * A row group is a chunk boundary the format supplies rather than one a
+     * reader has to invent, which is what separates it from `xlsx`. It also
+     * carries a real type system, so unlike the text formats a value arrives as
+     * the type the writer meant rather than as a string.
+     */
+    'parquet',
+];
+/** Same reason as {@link isConnectorKind}: one list, no second copy to drift. */
+function isSourceFormat(value) {
+    return exports.SOURCE_FORMATS.some((format) => format === value);
+}
+/**
+ * The format that never compiles quietly.
+ *
+ * The {@link unreachableNodeKind} of formats, and it exists for the same reason:
+ * a member added to {@link SOURCE_FORMATS} without a branch in the parser should
+ * be a type error naming the file, not a connector that offers a format in a
+ * dropdown and then reads the file as JSON.
+ *
+ * It throws as well as failing to compile, because a connector config is JSON
+ * that outlives the build that wrote it: a `format` stored by a newer deployment
+ * and read by an older one is possible, and falling back to a default for it
+ * would be exactly the silent path this closes.
+ */
+function unreachableSourceFormat(format, where) {
+    throw new Error(`${where} does not handle a source format of ${JSON.stringify(format)}. The format list and every decision made per format are meant to move together.`);
+}
 /**
  * TypeScript is Node's own type stripping, so it costs no compiler and no build
  * step — and types are erased, never checked. A transform with a wrong type
@@ -321,6 +393,109 @@ function workflowColumnX(column) {
 function workflowRowY(row) {
     return row * (exports.WORKFLOW_NODE_HEIGHT + exports.WORKFLOW_ROW_GAP);
 }
+/**
+ * What a {@link WorkflowCallNode} puts on the wire, and the whole of it.
+ *
+ * ## Why there is a second mode at all
+ *
+ * The catalog could not call a workflow that does not know about the catalog.
+ * A `call` node wraps the author's `config` in a {@link WorkflowCallEnvelope},
+ * so a workflow that already exists — one registered years before this package,
+ * whose body reads `data["proc"]` — receives `{catalog: {...}, input: {proc:
+ * ...}}` and dies on the first key it looks for. The only repair available was
+ * to edit the callee, which inverts the dependency exactly the wrong way round:
+ * every workflow anybody wanted to call would have to start depending on this
+ * package's contract, and a Python workflow registered in another repository
+ * would have to be changed to be reachable from a graph.
+ *
+ * ## Why the nesting is not being loosened instead
+ *
+ * The envelope nests for one stated reason, which is on {@link
+ * WorkflowCallEnvelope}: an author's parameter called `runId` must not be able
+ * to shadow the run id. That reason is sound and it is not being weakened. It
+ * simply does not reach the plain mode, because a plain call sends **no catalog
+ * metadata at all** — there is no `runId`, no `nodeId`, no contract number on
+ * the wire, so there is nothing a parameter could shadow. The flat payload is
+ * not the envelope with its guard removed; it is a different, smaller promise.
+ *
+ * ## What the plain mode costs, which is not small
+ *
+ * No `runId` and no `nodeId` means the callee has no key to stage rows under.
+ * Rows travel through the stage store addressed by `(runId, nodeId, batch)` —
+ * see {@link WorkflowStageRef} — and a callee that was told neither cannot
+ * write where the next node would read. So a plain call **cannot return rows to
+ * the graph**, and that is not a convention anybody could follow more carefully:
+ * it is arithmetic. `validateWorkflow` refuses a plain call with an outbound
+ * edge for exactly this reason (`call-plain-has-output`), and its return value
+ * is not read as a row count — see {@link readWorkflowCallOutput} for the shape
+ * that is deliberately *not* consulted on this path.
+ *
+ * A plain call is therefore for its **effect**: run the thing, and let something
+ * else in the graph produce what gets committed.
+ *
+ * ## Why a mode on the node rather than a second node kind or a boolean
+ *
+ * A boolean is the shape {@link WORKFLOW_PREDICATE_KINDS} argues against one
+ * level down, and for the reason it gives: a `plain?: boolean` beside a future
+ * third wire format is two optional flags whose combinations nobody defined, and
+ * every reader invents its own rule for which wins. A closed list with an
+ * exhaustiveness guard ({@link unreachableCallMode}) makes a third format a
+ * compile error naming the files that have to answer for it.
+ *
+ * A second node *kind* was the other candidate and it is too big. The kind list
+ * is deliberately small and every entry earns it by doing something no wiring
+ * can express (see {@link WORKFLOW_NODE_KINDS}). A plain call does the same
+ * thing a call does at the level the graph reasons about — it hands this
+ * position to a workflow somebody else registered, pinned by name and version.
+ * What differs is the payload. Splitting the kind would duplicate `callName`,
+ * `callVersion`, `config`, the pin check, the picker, the plan entry and the
+ * canvas node for a difference of one field, and every place that today writes
+ * `node.kind === 'call'` would have to remember to write both — which is the
+ * hand-maintained list going quiet that {@link NODE_KIND_IS_REUSABLE} exists to
+ * stop.
+ */
+exports.WORKFLOW_CALL_MODES = [
+    /**
+     * The child is handed a {@link WorkflowCallEnvelope}: the catalog's metadata
+     * under `catalog`, the author's parameters under `input`. The callee can stage
+     * rows back for the graph, and it has to have been written for this catalog.
+     */
+    'envelope',
+    /**
+     * The child is handed {@link WorkflowCallNode.config} verbatim, with nothing
+     * added and nothing wrapped. The callee needs to know nothing about the
+     * catalog — and cannot return rows to it.
+     */
+    'plain',
+];
+/** Same reason as {@link isConnectorKind}: one list, no second copy to drift. */
+function isWorkflowCallMode(value) {
+    return exports.WORKFLOW_CALL_MODES.some((mode) => mode === value);
+}
+/**
+ * {@link unreachableNodeKind}, one level down, and for the identical reason.
+ *
+ * Every branch over {@link WorkflowCallMode} ends here, so a third wire format
+ * added to the list without a rule for building its payload, hashing it,
+ * validating it or reading its answer is a type error naming the file. It throws
+ * as well, because a mode arrives as JSON out of a column and a build older than
+ * the data is a thing that happens.
+ */
+function unreachableCallMode(mode, where) {
+    throw new Error(`${where} has no rule for the call mode ${JSON.stringify(mode)}. It was added to WORKFLOW_CALL_MODES without teaching this code what to put on the wire for it, and guessing would send a workflow a payload nobody authored.`);
+}
+/**
+ * The mode this call node runs in, with the default applied once.
+ *
+ * Absent means `'envelope'` — that is what every node stored before the field
+ * existed is, and reading it as anything else would silently change what a
+ * deployment's graphs already do. One function so that the store, the runner,
+ * the hash and the canvas cannot each carry their own `?? 'envelope'` and have
+ * one of them drift.
+ */
+function workflowCallMode(node) {
+    return node.callMode ?? 'envelope';
+}
 /**
  * The kinds of test an {@link WorkflowIfNode} can make.
  *
@@ -1169,6 +1344,18 @@ exports.WORKFLOW_CALL_CONTRACT = 1;
  * schema for a workflow's output anywhere in the durable contract, and no way
  * to reach one if there were. So the check is here, at the one moment the
  * answer exists, and it names what it saw.
+ *
+ * ## Not called at all for a plain call, which is a decision and not an omission
+ *
+ * A plain call is handed no run id and no node id, so its callee could not have
+ * staged anything under `(runId, nodeId, batch)` even if it wanted to. Running
+ * this over its answer would be worse than pointless in both directions: a
+ * callee that happens to return `{batches, rowCount}` meaning something else
+ * entirely would have this graph go and read a stage that does not exist, and a
+ * callee returning one of the two would fail the node over a key it was never
+ * told about. So the plain path reports zero rows unconditionally and reads
+ * nothing — see `WorkflowRunnerService.callOutput`, which is where that is
+ * enforced rather than merely intended.
  */
 function readWorkflowCallOutput(value) {
     if (typeof value !== 'object' || value === null)
@@ -1223,6 +1410,13 @@ exports.WORKFLOW_ISSUE_CODES = [
     'dead-end',
     'transform-not-named',
     'call-not-named',
+    /**
+     * A plain call wired into something. See {@link WORKFLOW_CALL_MODES}: a plain
+     * call is told no run id and no node id, so it has nowhere to stage rows and
+     * always passes on none — and every node that can sit downstream of a call
+     * consumes rows and nothing else.
+     */
+    'call-plain-has-output',
     'if-not-named',
     'if-threshold-invalid',
     'if-needs-one-input',
@@ -1279,11 +1473,17 @@ function validateWorkflow(graph) {
         return issues;
     const { outgoing, incoming } = buildAdjacency(nodes, edges);
     const originators = nodes.filter(originatesRows);
+    // Deliberately a *different* set from `originators` — see `runsWithoutInput`.
+    const roots = nodes.filter(runsWithoutInput);
     const sinks = nodes.filter((node) => node.kind === 'sink');
     checkNodeWiring(nodes, incoming, outgoing, issues);
     checkEndpoints(originators, sinks, issues);
     checkBranches(edges, byId, issues);
-    checkFilterNarrowing({ nodes, edges }, originators, outgoing, issues);
+    checkPlainCallOutputs(nodes, outgoing, byId, issues);
+    // `roots` rather than `originators`, because this walks the graph forwards to
+    // find which sinks a filter can narrow and a plain call is a perfectly
+    // ordinary ancestor of nothing at all — it just never contributes rows.
+    checkFilterNarrowing({ nodes, edges }, roots, outgoing, issues);
     const looped = findCycle(nodes, incoming, outgoing);
     if (looped) {
         issues.push({
@@ -1295,27 +1495,127 @@ function validateWorkflow(graph) {
         // only unreachable *because* of the cycle, which points at the wrong boxes.
         return issues;
     }
-    checkReachability(nodes, originators, sinks, incoming, outgoing, issues);
+    checkReachability(nodes, roots, sinks, incoming, outgoing, issues);
     return issues;
 }
+/**
+ * A plain call may not feed anything, and this is where that is refused.
+ *
+ * ## The rule, stated once
+ *
+ * **A call node in `plain` mode must have no outbound edge.** Not "must not feed
+ * a sink", not "must not be the only thing feeding a sink" — no outbound edge at
+ * all, and the reason it collapses that far is that there is no weaker version
+ * of it that means anything. Every node kind that can sit downstream of a call —
+ * transform, if, filter, sink — consumes rows and *only* rows. There is no
+ * ordering-only wire in this model. So "a plain call with downstream nodes
+ * expecting rows" and "a plain call with an outbound edge" are the same set.
+ *
+ * ## How it lands against the rest of the validator
+ *
+ * Three rules had to move for this one to be statable, and each moved in a way
+ * that is narrower than it looks:
+ *
+ * - **`no-source`.** A plain call is no longer something that "reads": see
+ *   {@link originatesRows}. Without that, a graph of `plain call → sink` would
+ *   have passed the check that a graph has something producing rows, and then
+ *   committed an empty snapshot over whatever was live. It is refused here
+ *   first, and would be refused by `no-source` even if this check were deleted.
+ * - **`dead-end` — every path reaches the sink.** A plain call reaches no sink
+ *   by construction, so it is exempt, and the exemption is exactly one node
+ *   wide: nothing can be *behind* a plain call, because a plain call has no
+ *   outbound edge, so no other node's route to the sink can run through one.
+ *   The message `dead-end` carries is "it would be computed and thrown away",
+ *   and that is precisely what a plain call is not — its effect is the point,
+ *   and it has already happened by the time the sink commits.
+ * - **the one-sink rule.** Untouched. A graph still needs a sink and still needs
+ *   something that originates rows, and a plain call is now neither, so plain
+ *   calls cannot be a graph on their own — the rows come from a source or from
+ *   an envelope call, exactly as before.
+ *
+ * What a legal plain call looks like, then: `source → sink` with `source →
+ * plainCall` beside it — the effect runs after the source and the load commits
+ * the source's rows — or a plain call with nothing wired to it at all, which
+ * runs at some point in the topological order and is reported like any other
+ * node. Wiring a source into a plain call that is the source's *only* outbound
+ * edge is still refused, by `dead-end`, pointed at the source: those rows really
+ * would be fetched and dropped.
+ */
+function checkPlainCallOutputs(nodes, outgoing, byId, issues) {
+    for (const node of nodes) {
+        if (node.kind !== 'call' || workflowCallMode(node) !== 'plain')
+            continue;
+        const fed = outgoing.get(node.id) ?? [];
+        if (fed.length === 0)
+            continue;
+        issues.push({
+            code: 'call-plain-has-output',
+            nodeIds: [node.id, ...fed],
+            message: `Call node "${node.name}" (${node.id}) is a plain call and is wired into ${listNodes(fed, byId)}, which cannot work. A plain call sends this node's parameters to ${node.callName || 'the workflow it calls'} verbatim and nothing else — no run id and no node id — so the workflow it calls is told no key to write rows under and this node always passes on zero. Everything downstream would run on an empty input and the load would commit an empty snapshot without anything failing. Unwire it: a plain call is run for its effect, and something else in this graph produces what gets committed. If the workflow you are calling is meant to produce rows for this graph, it needs the envelope instead, which is what tells it where to put them.`,
+        });
+    }
+}
+/** `"a" (n1) and "b" (n2)`, for a message that has to name several boxes. */
+function listNodes(ids, byId) {
+    return ids
+        .map((id) => {
+        const node = byId.get(id);
+        return node ? `"${node.name}" (${id})` : `"${id}"`;
+    })
+        .join(' and ');
+}
 /**
  * Whether a node can produce rows without anything wired into it.
  *
- * A source obviously can. A **call** node can too, and this is the one rule the
- * `call` kind changes rather than extends: the workflow it hands off to may
- * itself read from a system, so a graph of `call → sink` is a real pipeline and
- * refusing it for having "no source" would be false. What is not weakened is
+ * A source obviously can. An **envelope call** node can too, and this is the one
+ * rule the `call` kind changes rather than extends: the workflow it hands off to
+ * may itself read from a system, so a graph of `call → sink` is a real pipeline
+ * and refusing it for having "no source" would be false. What is not weakened is
  * that a graph still needs *something* that originates rows and *something*
  * that commits them — a graph of transforms alone is still refused.
  *
- * Every call node counts, not only the ones with no inbound edge, and that is
- * the conservative direction: it makes this the root set for reachability too,
- * so a mid-graph call node cannot make everything downstream of it look
- * unreachable when its own upstream is fine.
+ * A **plain** call is not one of them, and that is the load-bearing half of this
+ * function now. A plain call is told no run id and no node id, so it has no key
+ * to stage rows under and cannot produce any — see {@link WORKFLOW_CALL_MODES}.
+ * Counting it here would let `plain call → sink` past `no-source` and commit an
+ * empty snapshot over whatever was live, which is the exact silence this file is
+ * arranged against.
+ *
+ * ## This used to be the reachability root set as well, and no longer is
+ *
+ * It said so, and the reason it gave was that it made the root set conservative.
+ * The plain mode splits the two questions, because the answers genuinely differ:
+ * a plain call **runs** with nothing wired into it (so it is a root, and calling
+ * it unreachable would be false — it would run) and **produces nothing** (so it
+ * is not something that reads). One function answering both would have to be
+ * wrong about one of them. See {@link runsWithoutInput} for the other half.
  */
 function originatesRows(node) {
+    if (node.kind === 'source')
+        return true;
+    return node.kind === 'call' && workflowCallMode(node) === 'envelope';
+}
+/**
+ * Whether a node runs whether or not anything is wired into it.
+ *
+ * The root set for reachability, which used to be {@link originatesRows} and is
+ * now its own question — see the note there. Every call node is one of these,
+ * both modes: a call with no inbound edge sits at in-degree zero in the
+ * topological order and is dispatched like anything else, so reporting it as
+ * "not reachable from any source, so it would never run" would be a message that
+ * is simply untrue.
+ *
+ * Every call node rather than only the unwired ones, for the reason the old
+ * function gave: it keeps a mid-graph call node from making everything
+ * downstream of it look unreachable when its own upstream is fine.
+ */
+function runsWithoutInput(node) {
     return node.kind === 'source' || node.kind === 'call';
 }
+/** Whether this node is a call that can never hand rows back to the graph. */
+function isPlainCall(node) {
+    return node.kind === 'call' && workflowCallMode(node) === 'plain';
+}
 /**
  * Index the nodes by id, reporting the ids that cannot be used as one.
  *
@@ -1852,12 +2152,17 @@ function peelTails(leftover, outgoing) {
     }
     return leftover;
 }
-/** Nodes that nothing reading reaches, and nodes that reach no sink. */
-function checkReachability(nodes, originators, sinks, incoming, outgoing, issues) {
-    const reachableFromSources = walk(originators.map((node) => node.id), outgoing);
+/**
+ * Nodes that nothing reading reaches, and nodes that reach no sink.
+ *
+ * `roots` is {@link runsWithoutInput} and not {@link originatesRows}: this asks
+ * what would *run*, and a plain call runs whether anything feeds it or not.
+ */
+function checkReachability(nodes, roots, sinks, incoming, outgoing, issues) {
+    const reachableFromSources = walk(roots.map((node) => node.id), outgoing);
     const reachesASink = walk(sinks.map((sink) => sink.id), incoming);
     for (const node of nodes) {
-        if (originators.length > 0 && !reachableFromSources.has(node.id)) {
+        if (roots.length > 0 && !reachableFromSources.has(node.id)) {
             issues.push({
                 code: 'unreachable',
                 nodeIds: [node.id],
@@ -1865,6 +2170,15 @@ function checkReachability(nodes, originators, sinks, incoming, outgoing, issues
             });
             continue;
         }
+        // The one exemption the plain mode buys, and it is exactly one node wide.
+        // A plain call reaches no sink by construction — `call-plain-has-output`
+        // refuses it an outbound edge — so `dead-end` would fire on every one of
+        // them, with a message ("it would be computed and thrown away") that is
+        // false about it: the effect it was run for has happened. Nothing can hide
+        // behind this, because nothing can be downstream of a plain call, so no
+        // other node's route to the sink can run through one.
+        if (isPlainCall(node))
+            continue;
         if (sinks.length > 0 && !reachesASink.has(node.id)) {
             issues.push({
                 code: 'dead-end',
@@ -2100,6 +2414,13 @@ function canonicalNode(node) {
             node.callName,
             node.callVersion,
             sortedEntries(node.config),
+            // Appended only for the non-default mode, exactly as `edge.branch` above
+            // is appended only when there is a label. Every call node in every
+            // deployment today is an envelope call — whether it says so or says
+            // nothing — so every one of them hashes to the string it always did and
+            // no stored graph is renumbered by picking up this release. See
+            // `canonicalCallMode` for why the two spellings must fold together.
+            ...canonicalCallMode(workflowCallMode(node)),
         ]);
     }
     if (node.kind === 'if') {
@@ -2144,6 +2465,27 @@ function canonicalNode(node) {
  * no version bump and no diff — which is precisely the silence this feature was
  * built to end.
  */
+/**
+ * The call mode, as zero or one trailing hash component.
+ *
+ * Zero for `envelope`, and that is the opposite choice from {@link
+ * canonicalReuse} beside it — for the opposite reason. There, absent and present
+ * mean genuinely different things ("follow the latest" against "pinned to v1"),
+ * so they must hash differently. Here absent and `'envelope'` are one behaviour
+ * spelled two ways: a node that says `callMode: 'envelope'` puts precisely the
+ * same bytes on the wire as a node that says nothing. A fingerprint that told
+ * them apart would report an edit when a canvas normalised the field, which is
+ * the cosmetic version bump {@link workflowGraphHash} exists to not do.
+ *
+ * `plain` earns its component, because it changes what the child receives.
+ */
+function canonicalCallMode(mode) {
+    if (mode === 'envelope')
+        return [];
+    if (mode === 'plain')
+        return ['plain'];
+    return unreachableCallMode(mode, 'workflowGraphHash');
+}
 function canonicalReuse(node) {
     if (node.useId === undefined)
         return [];
@@ -2252,18 +2594,8 @@ function isWorkflowNode(value) {
     if (kind === 'sink') {
         return typeof Reflect.get(value, 'targetType') === 'string';
     }
-    if (kind === 'call') {
-        // Both strings, and the config object, exactly as strictly as a source's:
-        // a stored call node missing its version is a node that would run whatever
-        // is registered today, which is the failure the pin exists to remove — and
-        // a graph that half-narrows is a load that runs nine nodes of ten.
-        const config = Reflect.get(value, 'config');
-        return (typeof Reflect.get(value, 'callName') === 'string' &&
-            typeof Reflect.get(value, 'callVersion') === 'string' &&
-            typeof config === 'object' &&
-            config !== null &&
-            !Array.isArray(config));
-    }
+    if (kind === 'call')
+        return isCallNodeShape(value);
     if (kind === 'if') {
         // The predicate in full, refused rather than defaulted: a gate read back
         // without a test it recognises would have to invent one, and inventing one
@@ -2282,6 +2614,34 @@ function isWorkflowNode(value) {
     }
     return isWorkflowNodeKindUnhandled(kind);
 }
+/**
+ * Everything a `call` node carries, checked as strictly as a source's.
+ *
+ * Its own function rather than a branch of {@link isWorkflowNode}, which the
+ * complexity bound will not hold any more of — and the split is where it should
+ * be, because this is the kind with the most to check.
+ *
+ * A stored call node missing its version is a node that would run whatever is
+ * registered today, which is the failure the pin exists to remove, and a graph
+ * that half-narrows is a load that runs nine nodes of ten. A `callMode` that is
+ * present and unrecognised is refused rather than dropped, for the reason an
+ * unrecognised `edge.branch` is: reading it back as the default would turn a
+ * plain call into an envelope call silently, and the callee would be handed a
+ * payload nobody authored. Absent is accepted and always will be — it is what
+ * every call node written before the field existed carries, and it means the
+ * envelope, which is what those nodes have always sent.
+ */
+function isCallNodeShape(value) {
+    const callMode = Reflect.get(value, 'callMode');
+    if (callMode !== undefined && !isWorkflowCallMode(callMode))
+        return false;
+    const config = Reflect.get(value, 'config');
+    return (typeof Reflect.get(value, 'callName') === 'string' &&
+        typeof Reflect.get(value, 'callVersion') === 'string' &&
+        typeof config === 'object' &&
+        config !== null &&
+        !Array.isArray(config));
+}
 /**
  * Whether a stored `narrows` is one this build can read.
  *

package/dist/client.d.ts

@@ -153,8 +153,8 @@ export declare const catalogRoutes: {
     readonly traces: () => string;
     readonly trace: (id: string) => string;
 };
-export type { CatalogConnection, CatalogConnector, ConnectionCheck, CatalogTransform, CatalogWorkflow, CatalogWorkflowCapabilities, CatalogWorkflowRelease, ConnectorKind, ConnectorRun, TransformLanguage, TransformResult, CallableWorkflowRef, WorkflowBranchLabel, WorkflowCallEnvelope, WorkflowCallNode, WorkflowCallOutput, WorkflowEdge, WorkflowExecutionMode, WorkflowFilterAll, WorkflowFilterAny, WorkflowFilterComparison, WorkflowFilterGroup, WorkflowFilterNode, WorkflowFilterOneOf, WorkflowFilterOperator, WorkflowFilterPredicate, WorkflowFilterPredicateKind, WorkflowFilterPresence, WorkflowFilterValue, WorkflowGraph, WorkflowEnvPredicate, WorkflowIfNode, WorkflowIfPredicate, WorkflowIssueCode, WorkflowNode, WorkflowNodeKind, WorkflowNodeOutcome, WorkflowPredicateKind, WorkflowRowCountPredicate, WorkflowRunOrderEntry, WorkflowSinkNode, WorkflowSkipReason, WorkflowSourceNode, WorkflowStageRef, WorkflowTransformNode, WorkflowValidationIssue, CatalogReusableNode, CatalogReusableNodeUse, ReusableNodeBody, ReusableNodeKind, ReusableNodeRef, ReusableSinkBody, ReusableSourceBody, VersionPinCopy, } from './catalog.pipeline';
-export { CONNECTOR_KINDS, isConnectorKind, isTransformLanguage, isWorkflowEdge, isWorkflowNode, liveWorkflowVersion, REDACTED_SECRET, TRANSFORM_LANGUAGES, readWorkflowCallOutput, WORKFLOW_CALL_CONTRACT, applyReusableNode, reusableNodeBodyOf, isReusableNodeBody, isReusableNodeKind, REUSABLE_NODE_KINDS, NODE_KIND_IS_REUSABLE, nodeKindIsReusable, unreachableReusableNodeKind, describeLiveVersion, describeVersionPin, } from './catalog.pipeline';
+export type { CatalogConnection, CatalogConnector, ConnectionCheck, CatalogTransform, CatalogWorkflow, CatalogWorkflowCapabilities, CatalogWorkflowRelease, ConnectorKind, ConnectorRun, TransformLanguage, TransformResult, CallableWorkflowRef, WorkflowBranchLabel, WorkflowCallEnvelope, WorkflowCallMode, WorkflowCallNode, WorkflowCallOutput, WorkflowEdge, WorkflowExecutionMode, WorkflowFilterAll, WorkflowFilterAny, WorkflowFilterComparison, WorkflowFilterGroup, WorkflowFilterNode, WorkflowFilterOneOf, WorkflowFilterOperator, WorkflowFilterPredicate, WorkflowFilterPredicateKind, WorkflowFilterPresence, WorkflowFilterValue, WorkflowGraph, WorkflowEnvPredicate, WorkflowIfNode, WorkflowIfPredicate, WorkflowIssueCode, WorkflowNode, WorkflowNodeKind, WorkflowNodeOutcome, WorkflowPredicateKind, WorkflowRowCountPredicate, WorkflowRunOrderEntry, WorkflowSinkNode, WorkflowSkipReason, WorkflowSourceNode, WorkflowStageRef, WorkflowTransformNode, WorkflowValidationIssue, CatalogReusableNode, CatalogReusableNodeUse, ReusableNodeBody, ReusableNodeKind, ReusableNodeRef, ReusableSinkBody, ReusableSourceBody, SourceFormat, VersionPinCopy, } from './catalog.pipeline';
+export { CONNECTOR_KINDS, isConnectorKind, isSourceFormat, isTransformLanguage, SOURCE_FORMATS, isWorkflowEdge, isWorkflowNode, liveWorkflowVersion, REDACTED_SECRET, TRANSFORM_LANGUAGES, readWorkflowCallOutput, WORKFLOW_CALL_CONTRACT, WORKFLOW_CALL_MODES, isWorkflowCallMode, unreachableCallMode, workflowCallMode, applyReusableNode, reusableNodeBodyOf, isReusableNodeBody, isReusableNodeKind, REUSABLE_NODE_KINDS, NODE_KIND_IS_REUSABLE, nodeKindIsReusable, unreachableReusableNodeKind, describeLiveVersion, describeVersionPin, } from './catalog.pipeline';
 /**
  * The workflow validator, shipped to the browser deliberately.
  *

package/dist/client.js

@@ -11,8 +11,8 @@
  * types are.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WORKFLOW_PREDICATE_KINDS = exports.WORKFLOW_BRANCH_LABELS = exports.WORKFLOW_NODE_KINDS = exports.WORKFLOW_NODE_ID_PATTERN = exports.WORKFLOW_ISSUE_CODES = exports.WORKFLOW_EXECUTION_MODES = exports.validateWorkflow = exports.workflowRowY = exports.workflowColumnX = exports.WORKFLOW_ROW_GAP = exports.WORKFLOW_NODE_WIDTH = exports.WORKFLOW_NODE_HEIGHT = exports.WORKFLOW_COLUMN_GAP = exports.describeVersionPin = exports.describeLiveVersion = exports.unreachableReusableNodeKind = exports.nodeKindIsReusable = exports.NODE_KIND_IS_REUSABLE = exports.REUSABLE_NODE_KINDS = exports.isReusableNodeKind = exports.isReusableNodeBody = exports.reusableNodeBodyOf = exports.applyReusableNode = exports.WORKFLOW_CALL_CONTRACT = exports.readWorkflowCallOutput = exports.TRANSFORM_LANGUAGES = exports.REDACTED_SECRET = exports.liveWorkflowVersion = exports.isWorkflowNode = exports.isWorkflowEdge = exports.isTransformLanguage = exports.isConnectorKind = exports.CONNECTOR_KINDS = exports.catalogRoutes = exports.UnsafeIdentifierError = exports.physicalColumn = exports.outputAlias = exports.isSafeIdentifier = exports.VALUELESS_FILTER_OPERATORS = exports.resolveObjectFilters = exports.parseObjectFilter = exports.offeredFilterOperators = exports.isCatalogFilterOperator = exports.filterOperatorsFor = exports.filterOperatorTakesValue = exports.encodeObjectFilter = exports.coerceFilterValue = exports.CATALOG_FILTER_OPERATORS = exports.CATALOG_FILTER_LIMIT = exports.CATALOG_REVISION_LIMIT = void 0;
-exports.DELETE_RECONCILIATION_STRATEGIES = exports.callableWorkflowBlock = exports.isWorkflowStatus = exports.isWorkflowNodeKind = exports.isWorkflowExecutionMode = exports.workflowRunOrder = exports.workflowGraphHash = exports.WORKFLOW_STATUSES = exports.unreachablePredicateKind = exports.unreachableNodeKind = exports.unreachableFilterPredicateKind = exports.unreachableFilterOperator = exports.workflowNodeRuns = exports.workflowNarrowedTypes = exports.workflowFilterMatches = exports.isWorkflowSkipReason = exports.isWorkflowPredicateKind = exports.isWorkflowIfPredicate = exports.isWorkflowFilterValue = exports.isWorkflowFilterPredicateKind = exports.isWorkflowFilterPredicate = exports.isWorkflowFilterOperator = exports.isWorkflowBranchLabel = exports.WORKFLOW_SKIP_REASONS = exports.WORKFLOW_FILTER_PREDICATE_KINDS = exports.WORKFLOW_FILTER_OPERATORS = exports.WORKFLOW_FILTER_MAX_VALUES = exports.WORKFLOW_FILTER_MAX_DEPTH = exports.WORKFLOW_FILTER_COLUMN_PATTERN = void 0;
+exports.validateWorkflow = exports.workflowRowY = exports.workflowColumnX = exports.WORKFLOW_ROW_GAP = exports.WORKFLOW_NODE_WIDTH = exports.WORKFLOW_NODE_HEIGHT = exports.WORKFLOW_COLUMN_GAP = exports.describeVersionPin = exports.describeLiveVersion = exports.unreachableReusableNodeKind = exports.nodeKindIsReusable = exports.NODE_KIND_IS_REUSABLE = exports.REUSABLE_NODE_KINDS = exports.isReusableNodeKind = exports.isReusableNodeBody = exports.reusableNodeBodyOf = exports.applyReusableNode = exports.workflowCallMode = exports.unreachableCallMode = exports.isWorkflowCallMode = exports.WORKFLOW_CALL_MODES = exports.WORKFLOW_CALL_CONTRACT = exports.readWorkflowCallOutput = exports.TRANSFORM_LANGUAGES = exports.REDACTED_SECRET = exports.liveWorkflowVersion = exports.isWorkflowNode = exports.isWorkflowEdge = exports.SOURCE_FORMATS = exports.isTransformLanguage = exports.isSourceFormat = exports.isConnectorKind = exports.CONNECTOR_KINDS = exports.catalogRoutes = exports.UnsafeIdentifierError = exports.physicalColumn = exports.outputAlias = exports.isSafeIdentifier = exports.VALUELESS_FILTER_OPERATORS = exports.resolveObjectFilters = exports.parseObjectFilter = exports.offeredFilterOperators = exports.isCatalogFilterOperator = exports.filterOperatorsFor = exports.filterOperatorTakesValue = exports.encodeObjectFilter = exports.coerceFilterValue = exports.CATALOG_FILTER_OPERATORS = exports.CATALOG_FILTER_LIMIT = exports.CATALOG_REVISION_LIMIT = void 0;
+exports.DELETE_RECONCILIATION_STRATEGIES = exports.callableWorkflowBlock = exports.isWorkflowStatus = exports.isWorkflowNodeKind = exports.isWorkflowExecutionMode = exports.workflowRunOrder = exports.workflowGraphHash = exports.WORKFLOW_STATUSES = exports.unreachablePredicateKind = exports.unreachableNodeKind = exports.unreachableFilterPredicateKind = exports.unreachableFilterOperator = exports.workflowNodeRuns = exports.workflowNarrowedTypes = exports.workflowFilterMatches = exports.isWorkflowSkipReason = exports.isWorkflowPredicateKind = exports.isWorkflowIfPredicate = exports.isWorkflowFilterValue = exports.isWorkflowFilterPredicateKind = exports.isWorkflowFilterPredicate = exports.isWorkflowFilterOperator = exports.isWorkflowBranchLabel = exports.WORKFLOW_SKIP_REASONS = exports.WORKFLOW_FILTER_PREDICATE_KINDS = exports.WORKFLOW_FILTER_OPERATORS = exports.WORKFLOW_FILTER_MAX_VALUES = exports.WORKFLOW_FILTER_MAX_DEPTH = exports.WORKFLOW_FILTER_COLUMN_PATTERN = exports.WORKFLOW_PREDICATE_KINDS = exports.WORKFLOW_BRANCH_LABELS = exports.WORKFLOW_NODE_KINDS = exports.WORKFLOW_NODE_ID_PATTERN = exports.WORKFLOW_ISSUE_CODES = exports.WORKFLOW_EXECUTION_MODES = void 0;
 exports.isDeleteReconciliationStrategy = isDeleteReconciliationStrategy;
 exports.pipelineExpectationRoutes = pipelineExpectationRoutes;
 // A value, not a type: a screen saying how far back the history goes should read
@@ -134,7 +134,9 @@ exports.catalogRoutes = {
 var catalog_pipeline_1 = require("./catalog.pipeline");
 Object.defineProperty(exports, "CONNECTOR_KINDS", { enumerable: true, get: function () { return catalog_pipeline_1.CONNECTOR_KINDS; } });
 Object.defineProperty(exports, "isConnectorKind", { enumerable: true, get: function () { return catalog_pipeline_1.isConnectorKind; } });
+Object.defineProperty(exports, "isSourceFormat", { enumerable: true, get: function () { return catalog_pipeline_1.isSourceFormat; } });
 Object.defineProperty(exports, "isTransformLanguage", { enumerable: true, get: function () { return catalog_pipeline_1.isTransformLanguage; } });
+Object.defineProperty(exports, "SOURCE_FORMATS", { enumerable: true, get: function () { return catalog_pipeline_1.SOURCE_FORMATS; } });
 // The canvas narrows nodes and edges it reads back from HTTP. Without these
 // it either imports them from the package root — dragging NestJS and MikroORM
 // into a browser bundle — or writes its own copy of the checks, which is the
@@ -158,6 +160,15 @@ Object.defineProperty(exports, "TRANSFORM_LANGUAGES", { enumerable: true, get: f
 // runner does, so the two cannot disagree about what "no rows" looks like.
 Object.defineProperty(exports, "readWorkflowCallOutput", { enumerable: true, get: function () { return catalog_pipeline_1.readWorkflowCallOutput; } });
 Object.defineProperty(exports, "WORKFLOW_CALL_CONTRACT", { enumerable: true, get: function () { return catalog_pipeline_1.WORKFLOW_CALL_CONTRACT; } });
+// The two wire formats a call node can take, and the reader that applies the
+// default. The inspector has to offer exactly the modes the runner can build a
+// payload for, and a screen carrying its own `?? 'envelope'` is the second
+// copy of a default that eventually disagrees with the hash — which would show
+// an author unsaved changes on a graph nobody edited.
+Object.defineProperty(exports, "WORKFLOW_CALL_MODES", { enumerable: true, get: function () { return catalog_pipeline_1.WORKFLOW_CALL_MODES; } });
+Object.defineProperty(exports, "isWorkflowCallMode", { enumerable: true, get: function () { return catalog_pipeline_1.isWorkflowCallMode; } });
+Object.defineProperty(exports, "unreachableCallMode", { enumerable: true, get: function () { return catalog_pipeline_1.unreachableCallMode; } });
+Object.defineProperty(exports, "workflowCallMode", { enumerable: true, get: function () { return catalog_pipeline_1.workflowCallMode; } });
 // Reusable nodes, and the two directions a screen needs them in: the fold onto
 // a node, so a picker can show what choosing one will do without a round trip,
 // and the lift off a node, so "save this as reusable" sends the same body the

package/dist/index.d.ts

@@ -8,7 +8,7 @@ export { type CatalogOverlayStore, FileCatalogOverlayStore, InMemoryCatalogOverl
 export { CATALOG_OVERLAY_STORE } from './catalog.overlay-store.token';
 export { MikroOrmCatalogRegistry } from './catalog.registry';
 export { CatalogRegistry } from './catalog.registry.base';
-export { CATALOG_PIPELINE_STORE, CODE_CONTEXT_CONTRACT, type CatalogCodeContext, type CatalogConnection, type CatalogConnector, type ConnectionCheck, CONNECTOR_KINDS, type CatalogLoadExpectations, type CatalogLoadExpectationStore, type CatalogPipelineStore, type CatalogStageStore, type CatalogTransform, type CatalogWorkflow, type CatalogWorkflowCapabilities, type CatalogWorkflowRelease, type CatalogWorkflowReleaseStore, type CatalogWorkflowStore, type CallableWorkflowBlock, type CallableWorkflowDisagreement, type CallableWorkflowRef, callableWorkflowBlock, type ConnectorKind, type ConnectorRun, type DeleteReconciliation, isConnectorKind, isPipelineStore, isTransformLanguage, type LoadExpectation, type RowCountBound, type StoredLoadExpectation, readWorkflowCallOutput, REDACTED_SECRET, supportsLoadExpectations, supportsReusableNodes, supportsTransformPins, supportsTransformRevisions, applyReusableNode, type CatalogReusableNode, type CatalogReusableNodeStore, type CatalogReusableNodeUse, describeLiveVersion, describeVersionPin, isReusableNodeBody, isReusableNodeKind, NODE_KIND_IS_REUSABLE, nodeKindIsReusable, REUSABLE_NODE_KINDS, type ReusableNodeBody, type ReusableNodeKind, type ReusableNodeRef, type ReusableSinkBody, type ReusableSourceBody, reusableNodeBodyOf, unreachableReusableNodeKind, type VersionPinCopy, isWorkflowBranchLabel, isWorkflowEdge, isWorkflowExecutionMode, isWorkflowFilterOperator, isWorkflowFilterPredicate, isWorkflowFilterPredicateKind, isWorkflowFilterValue, isWorkflowIfPredicate, isWorkflowNode, isWorkflowNodeKind, isWorkflowPredicateKind, isWorkflowSkipReason, isWorkflowStatus, liveWorkflowVersion, supportsWorkflowReleases, supportsWorkflows, supportsWorkflowStages, TRANSFORM_RUNNER, TRANSFORM_LANGUAGES, type TransformLanguage, type TransformResult, type TransformRunner, unreachableFilterOperator, unreachableFilterPredicateKind, unreachableNodeKind, unreachablePredicateKind, validateWorkflow, WORKFLOW_BRANCH_LABELS, WORKFLOW_CALL_CONTRACT, WORKFLOW_COLUMN_GAP, WORKFLOW_EXECUTION_MODES, WORKFLOW_FILTER_COLUMN_PATTERN, WORKFLOW_FILTER_MAX_DEPTH, WORKFLOW_FILTER_MAX_VALUES, WORKFLOW_FILTER_OPERATORS, WORKFLOW_FILTER_PREDICATE_KINDS, WORKFLOW_ISSUE_CODES, WORKFLOW_NODE_HEIGHT, WORKFLOW_NODE_ID_PATTERN, WORKFLOW_NODE_KINDS, WORKFLOW_NODE_WIDTH, WORKFLOW_PREDICATE_KINDS, WORKFLOW_ROW_GAP, WORKFLOW_SKIP_REASONS, WORKFLOW_STATUSES, type WorkflowBranchLabel, workflowColumnX, workflowRowY, type WorkflowCallEnvelope, type WorkflowCallNode, type WorkflowCallOutput, type WorkflowEdge, type WorkflowExecutionMode, type WorkflowFilterAll, type WorkflowFilterAny, type WorkflowFilterComparison, type WorkflowFilterGroup, workflowFilterMatches, type WorkflowFilterNode, type WorkflowFilterOneOf, type WorkflowFilterOperator, type WorkflowFilterPredicate, type WorkflowFilterPredicateKind, type WorkflowFilterPresence, type WorkflowFilterValue, type WorkflowGraph, workflowGraphHash, type WorkflowEnvPredicate, type WorkflowIfNode, type WorkflowIfPredicate, type WorkflowIssueCode, type WorkflowNode, type WorkflowNodeKind, workflowNarrowedTypes, type WorkflowNodeOutcome, workflowNodeRuns, type WorkflowNodeStepInput, type WorkflowNodeStepOutput, workflowRunOrder, type WorkflowRunOrderEntry, type WorkflowPredicateKind, type WorkflowRowCountPredicate, type WorkflowSinkNode, type WorkflowSkipReason, type WorkflowSourceNode, type WorkflowStageRef, type WorkflowStatus, type WorkflowTransformNode, type WorkflowValidationIssue, } from './catalog.pipeline';
+export { CATALOG_PIPELINE_STORE, CODE_CONTEXT_CONTRACT, type CatalogCodeContext, type CatalogConnection, type CatalogConnector, type ConnectionCheck, CONNECTOR_KINDS, type CatalogLoadExpectations, type CatalogLoadExpectationStore, type CatalogPipelineStore, type CatalogStageStore, type CatalogTransform, type CatalogWorkflow, type CatalogWorkflowCapabilities, type CatalogWorkflowRelease, type CatalogWorkflowReleaseStore, type CatalogWorkflowStore, type CallableWorkflowBlock, type CallableWorkflowDisagreement, type CallableWorkflowRef, callableWorkflowBlock, type ConnectorKind, type ConnectorRun, type DeleteReconciliation, isConnectorKind, isPipelineStore, isSourceFormat, isTransformLanguage, type LoadExpectation, type RowCountBound, SOURCE_FORMATS, type SourceFormat, unreachableSourceFormat, type StoredLoadExpectation, readWorkflowCallOutput, REDACTED_SECRET, supportsLoadExpectations, supportsReusableNodes, supportsTransformPins, supportsTransformRevisions, applyReusableNode, type CatalogReusableNode, type CatalogReusableNodeStore, type CatalogReusableNodeUse, describeLiveVersion, describeVersionPin, isReusableNodeBody, isReusableNodeKind, NODE_KIND_IS_REUSABLE, nodeKindIsReusable, REUSABLE_NODE_KINDS, type ReusableNodeBody, type ReusableNodeKind, type ReusableNodeRef, type ReusableSinkBody, type ReusableSourceBody, reusableNodeBodyOf, unreachableReusableNodeKind, type VersionPinCopy, isWorkflowBranchLabel, isWorkflowEdge, isWorkflowExecutionMode, isWorkflowFilterOperator, isWorkflowFilterPredicate, isWorkflowFilterPredicateKind, isWorkflowFilterValue, isWorkflowIfPredicate, isWorkflowNode, isWorkflowCallMode, isWorkflowNodeKind, isWorkflowPredicateKind, isWorkflowSkipReason, isWorkflowStatus, liveWorkflowVersion, supportsWorkflowReleases, supportsWorkflows, supportsWorkflowStages, TRANSFORM_RUNNER, TRANSFORM_LANGUAGES, type TransformLanguage, type TransformResult, type TransformRunner, unreachableFilterOperator, unreachableFilterPredicateKind, unreachableCallMode, unreachableNodeKind, unreachablePredicateKind, validateWorkflow, WORKFLOW_BRANCH_LABELS, WORKFLOW_CALL_CONTRACT, WORKFLOW_CALL_MODES, WORKFLOW_COLUMN_GAP, WORKFLOW_EXECUTION_MODES, WORKFLOW_FILTER_COLUMN_PATTERN, WORKFLOW_FILTER_MAX_DEPTH, WORKFLOW_FILTER_MAX_VALUES, WORKFLOW_FILTER_OPERATORS, WORKFLOW_FILTER_PREDICATE_KINDS, WORKFLOW_ISSUE_CODES, WORKFLOW_NODE_HEIGHT, WORKFLOW_NODE_ID_PATTERN, WORKFLOW_NODE_KINDS, WORKFLOW_NODE_WIDTH, WORKFLOW_PREDICATE_KINDS, WORKFLOW_ROW_GAP, WORKFLOW_SKIP_REASONS, WORKFLOW_STATUSES, type WorkflowBranchLabel, workflowColumnX, workflowRowY, type WorkflowCallEnvelope, type WorkflowCallMode, workflowCallMode, type WorkflowCallNode, type WorkflowCallOutput, type WorkflowEdge, type WorkflowExecutionMode, type WorkflowFilterAll, type WorkflowFilterAny, type WorkflowFilterComparison, type WorkflowFilterGroup, workflowFilterMatches, type WorkflowFilterNode, type WorkflowFilterOneOf, type WorkflowFilterOperator, type WorkflowFilterPredicate, type WorkflowFilterPredicateKind, type WorkflowFilterPresence, type WorkflowFilterValue, type WorkflowGraph, workflowGraphHash, type WorkflowEnvPredicate, type WorkflowIfNode, type WorkflowIfPredicate, type WorkflowIssueCode, type WorkflowNode, type WorkflowNodeKind, workflowNarrowedTypes, type WorkflowNodeOutcome, workflowNodeRuns, type WorkflowNodeStepInput, type WorkflowNodeStepOutput, workflowRunOrder, type WorkflowRunOrderEntry, type WorkflowPredicateKind, type WorkflowRowCountPredicate, type WorkflowSinkNode, type WorkflowSkipReason, type WorkflowSourceNode, type WorkflowStageRef, type WorkflowStatus, type WorkflowTransformNode, type WorkflowValidationIssue, } from './catalog.pipeline';
 export { type ColumnarStageBatch, STAGE_ENCODING, STAGE_ENCODING_VERSION, type StagePayload, classifyStagePayload, decodeStageRows, encodeStageRows, isColumnarStageBatch, } from './catalog.stage-encoding';
 export * from './catalog.environment';
 export { QueryCache } from './catalog.query-cache';

package/dist/index.js

@@ -14,10 +14,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isWorkflowFilterPredicateKind = exports.isWorkflowFilterPredicate = exports.isWorkflowFilterOperator = exports.isWorkflowExecutionMode = exports.isWorkflowEdge = exports.isWorkflowBranchLabel = exports.unreachableReusableNodeKind = exports.reusableNodeBodyOf = exports.REUSABLE_NODE_KINDS = exports.nodeKindIsReusable = exports.NODE_KIND_IS_REUSABLE = exports.isReusableNodeKind = exports.isReusableNodeBody = exports.describeVersionPin = exports.describeLiveVersion = exports.applyReusableNode = exports.supportsTransformRevisions = exports.supportsTransformPins = exports.supportsReusableNodes = exports.supportsLoadExpectations = exports.REDACTED_SECRET = exports.readWorkflowCallOutput = exports.isTransformLanguage = exports.isPipelineStore = exports.isConnectorKind = exports.callableWorkflowBlock = exports.CONNECTOR_KINDS = exports.CODE_CONTEXT_CONTRACT = exports.CATALOG_PIPELINE_STORE = exports.CatalogRegistry = exports.MikroOrmCatalogRegistry = exports.CATALOG_OVERLAY_STORE = exports.InMemoryCatalogOverlayStore = exports.FileCatalogOverlayStore = exports.CATALOG_OPTIONS = exports.isStreamingQueryStore = exports.isQueryStore = exports.assertReadOnlyShape = exports.CatalogModule = exports.emitCatalog = exports.curationActor = exports.channelNameFor = exports.catalogEventPhase = exports.UNATTRIBUTED_PRINCIPAL_ID = exports.CATALOG_LIB = exports.CATALOG_EVENTS = exports.CATALOG_EVENT_PHASE_FALLBACK = exports.CATALOG_EVENT_PHASE = exports.CatalogType = exports.CatalogProperty = void 0;
-exports.QueryCache = exports.isColumnarStageBatch = exports.encodeStageRows = exports.decodeStageRows = exports.classifyStagePayload = exports.STAGE_ENCODING_VERSION = exports.STAGE_ENCODING = exports.workflowRunOrder = exports.workflowNodeRuns = exports.workflowNarrowedTypes = exports.workflowGraphHash = exports.workflowFilterMatches = exports.workflowRowY = exports.workflowColumnX = exports.WORKFLOW_STATUSES = exports.WORKFLOW_SKIP_REASONS = exports.WORKFLOW_ROW_GAP = exports.WORKFLOW_PREDICATE_KINDS = exports.WORKFLOW_NODE_WIDTH = exports.WORKFLOW_NODE_KINDS = exports.WORKFLOW_NODE_ID_PATTERN = exports.WORKFLOW_NODE_HEIGHT = exports.WORKFLOW_ISSUE_CODES = exports.WORKFLOW_FILTER_PREDICATE_KINDS = exports.WORKFLOW_FILTER_OPERATORS = exports.WORKFLOW_FILTER_MAX_VALUES = exports.WORKFLOW_FILTER_MAX_DEPTH = exports.WORKFLOW_FILTER_COLUMN_PATTERN = exports.WORKFLOW_EXECUTION_MODES = exports.WORKFLOW_COLUMN_GAP = exports.WORKFLOW_CALL_CONTRACT = exports.WORKFLOW_BRANCH_LABELS = exports.validateWorkflow = exports.unreachablePredicateKind = exports.unreachableNodeKind = exports.unreachableFilterPredicateKind = exports.unreachableFilterOperator = exports.TRANSFORM_LANGUAGES = exports.TRANSFORM_RUNNER = exports.supportsWorkflowStages = exports.supportsWorkflows = exports.supportsWorkflowReleases = exports.liveWorkflowVersion = exports.isWorkflowStatus = exports.isWorkflowSkipReason = exports.isWorkflowPredicateKind = exports.isWorkflowNodeKind = exports.isWorkflowNode = exports.isWorkflowIfPredicate = exports.isWorkflowFilterValue = void 0;
-exports.supportsCarryForward = exports.physicalColumn = exports.outputAlias = exports.isWriteStore = exports.isSafeIdentifier = exports.isReservedColumn = exports.isCatalogStoreCapabilities = exports.findColumnCollisions = exports.supportsObjectFilters = exports.CatalogColumnCollisionError = exports.CATALOG_STORE = exports.CATALOG_SNAPSHOT_MODES = exports.CATALOG_RESERVED_COLUMNS = exports.assertSafeIdentifier = exports.assertNoColumnCollisions = exports.StaticKeyPrincipalResolver = exports.readableObjectPage = exports.mayWrite = exports.mayRead = exports.maySeeClassification = exports.PRINCIPAL_ACTOR_SEPARATOR = exports.parsePrincipalId = exports.hasScope = exports.expandScopes = exports.delegatePrincipal = exports.composePrincipalId = exports.CATALOG_PRINCIPAL_RESOLVER = exports.traceOutcomeFilter = exports.supportsSavedQueryRevisions = exports.isWorkspaceStore = exports.isTraceStore = exports.isCatalogTraceOutcome = exports.embeddedVisualization = exports.CATALOG_WORKSPACE_STORE = exports.CATALOG_TRACE_STORE = exports.CATALOG_TRACE_OUTCOMES = exports.CATALOG_REVISION_LIMIT = exports.visibleToPrincipal = exports.searchCatalog = exports.maySearch = exports.emptySearch = exports.bestMatch = exports.MAX_SEARCH_LIMIT = exports.DEFAULT_SEARCH_LIMIT = exports.CatalogService = exports.SubprocessTransformRunner = exports.toCsv = exports.guardFormula = exports.csvLines = exports.csvCell = void 0;
-exports.RequireScopes = exports.RequireHuman = exports.REQUIRES_HUMAN = exports.REQUIRED_SCOPES = exports.MikroOrmReadStore = exports.UnsafeIdentifierError = void 0;
+exports.isWorkflowExecutionMode = exports.isWorkflowEdge = exports.isWorkflowBranchLabel = exports.unreachableReusableNodeKind = exports.reusableNodeBodyOf = exports.REUSABLE_NODE_KINDS = exports.nodeKindIsReusable = exports.NODE_KIND_IS_REUSABLE = exports.isReusableNodeKind = exports.isReusableNodeBody = exports.describeVersionPin = exports.describeLiveVersion = exports.applyReusableNode = exports.supportsTransformRevisions = exports.supportsTransformPins = exports.supportsReusableNodes = exports.supportsLoadExpectations = exports.REDACTED_SECRET = exports.readWorkflowCallOutput = exports.unreachableSourceFormat = exports.SOURCE_FORMATS = exports.isTransformLanguage = exports.isSourceFormat = exports.isPipelineStore = exports.isConnectorKind = exports.callableWorkflowBlock = exports.CONNECTOR_KINDS = exports.CODE_CONTEXT_CONTRACT = exports.CATALOG_PIPELINE_STORE = exports.CatalogRegistry = exports.MikroOrmCatalogRegistry = exports.CATALOG_OVERLAY_STORE = exports.InMemoryCatalogOverlayStore = exports.FileCatalogOverlayStore = exports.CATALOG_OPTIONS = exports.isStreamingQueryStore = exports.isQueryStore = exports.assertReadOnlyShape = exports.CatalogModule = exports.emitCatalog = exports.curationActor = exports.channelNameFor = exports.catalogEventPhase = exports.UNATTRIBUTED_PRINCIPAL_ID = exports.CATALOG_LIB = exports.CATALOG_EVENTS = exports.CATALOG_EVENT_PHASE_FALLBACK = exports.CATALOG_EVENT_PHASE = exports.CatalogType = exports.CatalogProperty = void 0;
+exports.workflowRunOrder = exports.workflowNodeRuns = exports.workflowNarrowedTypes = exports.workflowGraphHash = exports.workflowFilterMatches = exports.workflowCallMode = exports.workflowRowY = exports.workflowColumnX = exports.WORKFLOW_STATUSES = exports.WORKFLOW_SKIP_REASONS = exports.WORKFLOW_ROW_GAP = exports.WORKFLOW_PREDICATE_KINDS = exports.WORKFLOW_NODE_WIDTH = exports.WORKFLOW_NODE_KINDS = exports.WORKFLOW_NODE_ID_PATTERN = exports.WORKFLOW_NODE_HEIGHT = exports.WORKFLOW_ISSUE_CODES = exports.WORKFLOW_FILTER_PREDICATE_KINDS = exports.WORKFLOW_FILTER_OPERATORS = exports.WORKFLOW_FILTER_MAX_VALUES = exports.WORKFLOW_FILTER_MAX_DEPTH = exports.WORKFLOW_FILTER_COLUMN_PATTERN = exports.WORKFLOW_EXECUTION_MODES = exports.WORKFLOW_COLUMN_GAP = exports.WORKFLOW_CALL_MODES = exports.WORKFLOW_CALL_CONTRACT = exports.WORKFLOW_BRANCH_LABELS = exports.validateWorkflow = exports.unreachablePredicateKind = exports.unreachableNodeKind = exports.unreachableCallMode = exports.unreachableFilterPredicateKind = exports.unreachableFilterOperator = exports.TRANSFORM_LANGUAGES = exports.TRANSFORM_RUNNER = exports.supportsWorkflowStages = exports.supportsWorkflows = exports.supportsWorkflowReleases = exports.liveWorkflowVersion = exports.isWorkflowStatus = exports.isWorkflowSkipReason = exports.isWorkflowPredicateKind = exports.isWorkflowNodeKind = exports.isWorkflowCallMode = exports.isWorkflowNode = exports.isWorkflowIfPredicate = exports.isWorkflowFilterValue = exports.isWorkflowFilterPredicateKind = exports.isWorkflowFilterPredicate = exports.isWorkflowFilterOperator = void 0;
+exports.findColumnCollisions = exports.supportsObjectFilters = exports.CatalogColumnCollisionError = exports.CATALOG_STORE = exports.CATALOG_SNAPSHOT_MODES = exports.CATALOG_RESERVED_COLUMNS = exports.assertSafeIdentifier = exports.assertNoColumnCollisions = exports.StaticKeyPrincipalResolver = exports.readableObjectPage = exports.mayWrite = exports.mayRead = exports.maySeeClassification = exports.PRINCIPAL_ACTOR_SEPARATOR = exports.parsePrincipalId = exports.hasScope = exports.expandScopes = exports.delegatePrincipal = exports.composePrincipalId = exports.CATALOG_PRINCIPAL_RESOLVER = exports.traceOutcomeFilter = exports.supportsSavedQueryRevisions = exports.isWorkspaceStore = exports.isTraceStore = exports.isCatalogTraceOutcome = exports.embeddedVisualization = exports.CATALOG_WORKSPACE_STORE = exports.CATALOG_TRACE_STORE = exports.CATALOG_TRACE_OUTCOMES = exports.CATALOG_REVISION_LIMIT = exports.visibleToPrincipal = exports.searchCatalog = exports.maySearch = exports.emptySearch = exports.bestMatch = exports.MAX_SEARCH_LIMIT = exports.DEFAULT_SEARCH_LIMIT = exports.CatalogService = exports.SubprocessTransformRunner = exports.toCsv = exports.guardFormula = exports.csvLines = exports.csvCell = exports.QueryCache = exports.isColumnarStageBatch = exports.encodeStageRows = exports.decodeStageRows = exports.classifyStagePayload = exports.STAGE_ENCODING_VERSION = exports.STAGE_ENCODING = void 0;
+exports.RequireScopes = exports.RequireHuman = exports.REQUIRES_HUMAN = exports.REQUIRED_SCOPES = exports.MikroOrmReadStore = exports.UnsafeIdentifierError = exports.supportsCarryForward = exports.physicalColumn = exports.outputAlias = exports.isWriteStore = exports.isSafeIdentifier = exports.isReservedColumn = exports.isCatalogStoreCapabilities = void 0;
 var catalog_decorators_1 = require("./catalog.decorators");
 Object.defineProperty(exports, "CatalogProperty", { enumerable: true, get: function () { return catalog_decorators_1.CatalogProperty; } });
 Object.defineProperty(exports, "CatalogType", { enumerable: true, get: function () { return catalog_decorators_1.CatalogType; } });
@@ -63,7 +63,10 @@ Object.defineProperty(exports, "CONNECTOR_KINDS", { enumerable: true, get: funct
 Object.defineProperty(exports, "callableWorkflowBlock", { enumerable: true, get: function () { return catalog_pipeline_1.callableWorkflowBlock; } });
 Object.defineProperty(exports, "isConnectorKind", { enumerable: true, get: function () { return catalog_pipeline_1.isConnectorKind; } });
 Object.defineProperty(exports, "isPipelineStore", { enumerable: true, get: function () { return catalog_pipeline_1.isPipelineStore; } });
+Object.defineProperty(exports, "isSourceFormat", { enumerable: true, get: function () { return catalog_pipeline_1.isSourceFormat; } });
 Object.defineProperty(exports, "isTransformLanguage", { enumerable: true, get: function () { return catalog_pipeline_1.isTransformLanguage; } });
+Object.defineProperty(exports, "SOURCE_FORMATS", { enumerable: true, get: function () { return catalog_pipeline_1.SOURCE_FORMATS; } });
+Object.defineProperty(exports, "unreachableSourceFormat", { enumerable: true, get: function () { return catalog_pipeline_1.unreachableSourceFormat; } });
 Object.defineProperty(exports, "readWorkflowCallOutput", { enumerable: true, get: function () { return catalog_pipeline_1.readWorkflowCallOutput; } });
 Object.defineProperty(exports, "REDACTED_SECRET", { enumerable: true, get: function () { return catalog_pipeline_1.REDACTED_SECRET; } });
 Object.defineProperty(exports, "supportsLoadExpectations", { enumerable: true, get: function () { return catalog_pipeline_1.supportsLoadExpectations; } });
@@ -89,6 +92,7 @@ Object.defineProperty(exports, "isWorkflowFilterPredicateKind", { enumerable: tr
 Object.defineProperty(exports, "isWorkflowFilterValue", { enumerable: true, get: function () { return catalog_pipeline_1.isWorkflowFilterValue; } });
 Object.defineProperty(exports, "isWorkflowIfPredicate", { enumerable: true, get: function () { return catalog_pipeline_1.isWorkflowIfPredicate; } });
 Object.defineProperty(exports, "isWorkflowNode", { enumerable: true, get: function () { return catalog_pipeline_1.isWorkflowNode; } });
+Object.defineProperty(exports, "isWorkflowCallMode", { enumerable: true, get: function () { return catalog_pipeline_1.isWorkflowCallMode; } });
 Object.defineProperty(exports, "isWorkflowNodeKind", { enumerable: true, get: function () { return catalog_pipeline_1.isWorkflowNodeKind; } });
 Object.defineProperty(exports, "isWorkflowPredicateKind", { enumerable: true, get: function () { return catalog_pipeline_1.isWorkflowPredicateKind; } });
 Object.defineProperty(exports, "isWorkflowSkipReason", { enumerable: true, get: function () { return catalog_pipeline_1.isWorkflowSkipReason; } });
@@ -101,11 +105,13 @@ Object.defineProperty(exports, "TRANSFORM_RUNNER", { enumerable: true, get: func
 Object.defineProperty(exports, "TRANSFORM_LANGUAGES", { enumerable: true, get: function () { return catalog_pipeline_1.TRANSFORM_LANGUAGES; } });
 Object.defineProperty(exports, "unreachableFilterOperator", { enumerable: true, get: function () { return catalog_pipeline_1.unreachableFilterOperator; } });
 Object.defineProperty(exports, "unreachableFilterPredicateKind", { enumerable: true, get: function () { return catalog_pipeline_1.unreachableFilterPredicateKind; } });
+Object.defineProperty(exports, "unreachableCallMode", { enumerable: true, get: function () { return catalog_pipeline_1.unreachableCallMode; } });
 Object.defineProperty(exports, "unreachableNodeKind", { enumerable: true, get: function () { return catalog_pipeline_1.unreachableNodeKind; } });
 Object.defineProperty(exports, "unreachablePredicateKind", { enumerable: true, get: function () { return catalog_pipeline_1.unreachablePredicateKind; } });
 Object.defineProperty(exports, "validateWorkflow", { enumerable: true, get: function () { return catalog_pipeline_1.validateWorkflow; } });
 Object.defineProperty(exports, "WORKFLOW_BRANCH_LABELS", { enumerable: true, get: function () { return catalog_pipeline_1.WORKFLOW_BRANCH_LABELS; } });
 Object.defineProperty(exports, "WORKFLOW_CALL_CONTRACT", { enumerable: true, get: function () { return catalog_pipeline_1.WORKFLOW_CALL_CONTRACT; } });
+Object.defineProperty(exports, "WORKFLOW_CALL_MODES", { enumerable: true, get: function () { return catalog_pipeline_1.WORKFLOW_CALL_MODES; } });
 Object.defineProperty(exports, "WORKFLOW_COLUMN_GAP", { enumerable: true, get: function () { return catalog_pipeline_1.WORKFLOW_COLUMN_GAP; } });
 Object.defineProperty(exports, "WORKFLOW_EXECUTION_MODES", { enumerable: true, get: function () { return catalog_pipeline_1.WORKFLOW_EXECUTION_MODES; } });
 Object.defineProperty(exports, "WORKFLOW_FILTER_COLUMN_PATTERN", { enumerable: true, get: function () { return catalog_pipeline_1.WORKFLOW_FILTER_COLUMN_PATTERN; } });
@@ -124,6 +130,7 @@ Object.defineProperty(exports, "WORKFLOW_SKIP_REASONS", { enumerable: true, get:
 Object.defineProperty(exports, "WORKFLOW_STATUSES", { enumerable: true, get: function () { return catalog_pipeline_1.WORKFLOW_STATUSES; } });
 Object.defineProperty(exports, "workflowColumnX", { enumerable: true, get: function () { return catalog_pipeline_1.workflowColumnX; } });
 Object.defineProperty(exports, "workflowRowY", { enumerable: true, get: function () { return catalog_pipeline_1.workflowRowY; } });
+Object.defineProperty(exports, "workflowCallMode", { enumerable: true, get: function () { return catalog_pipeline_1.workflowCallMode; } });
 Object.defineProperty(exports, "workflowFilterMatches", { enumerable: true, get: function () { return catalog_pipeline_1.workflowFilterMatches; } });
 Object.defineProperty(exports, "workflowGraphHash", { enumerable: true, get: function () { return catalog_pipeline_1.workflowGraphHash; } });
 Object.defineProperty(exports, "workflowNarrowedTypes", { enumerable: true, get: function () { return catalog_pipeline_1.workflowNarrowedTypes; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dudousxd/nestjs-catalog",
-  "version": "0.19.0",
+  "version": "0.21.0",
   "description": "A metadata registry for NestJS: object types, properties and relations, derived from your ORM and enriched with decorators.",
   "license": "MIT",
   "author": "Davide Carvalho",