@rocicorp/zero 1.11.0-canary.2 → 1.11.0-canary.21

package/out/zql/src/ivm/operator.d.ts

@@ -35,6 +35,8 @@ export interface Input extends InputBase {
      * caller of fetch immediately.
      * - During push: If a fetch to an input consumed by the push logic yields
      * 'yield', it must be yielded to the caller of push immediately.
+     * - During reconcile: If a fetch to an input consumed by reconcile logic
+     * yields 'yield', it must be yielded to the caller of reconcile immediately.
      */
     fetch(req: FetchRequest): Stream<Node | 'yield'>;
 }
@@ -115,37 +117,64 @@ export type Start = {
     readonly basis: 'at' | 'after';
 };
 /**
- * An output for an operator. Typically another Operator but can also be
- * the code running the pipeline.
+ * An output for an operator. Typically another Operator in an IVM pipeline,
+ * but can also be a terminal sink (such as a View or test consumer).
  */
 export interface Output {
     /**
-     * Push incremental changes to data previously received with fetch().
-     * Consumers must apply all pushed changes or incremental result will
-     * be incorrect.
+     * Phase 1 of two-phase push: pushes incremental changes to data previously
+     * received with fetch(). Consumers must apply all pushed changes or the
+     * incremental result will be incorrect.
+     *
      * Callers must maintain some invariants for correct operation:
      * - Only add rows which do not already exist (by deep equality).
      * - Only remove rows which do exist (by deep equality).
-     * Implmentation can yield 'yield' to yield control to the caller for purposes
-     * of responsiveness.
+     *
+     * Implementations can yield 'yield' to yield control to the caller for
+     * purposes of responsiveness.
+     *
      * Yield contract:
      * - During a push: If a push call to an output yields 'yield', it must be
-     * yielded to the caller of push immediately.
+     *   yielded to the caller of push immediately.
      */
     push(change: Change, pusher: InputBase): Stream<'yield'>;
+    /**
+     * Phase 2 of two-phase push: invoked after Phase 1 changes have propagated.
+     * Bounded operators (such as Take or Cap) use this signal to refill deficits,
+     * emit refilled rows downstream via push(), and update their bounds.
+     *
+     * Implementations can yield 'yield' to yield control to the caller for
+     * purposes of responsiveness.
+     *
+     * Yield contract:
+     * - During reconcile: If an internal fetch, push, or downstream reconcile call
+     *   yields 'yield', it must be yielded to the caller of reconcile immediately.
+     *
+     * This method is optional on Output to allow terminal sinks (such as UI views
+     * or custom third-party sinks) that only consume changes to omit it without
+     * breaking compatibility. Intermediate operators must check
+     * `if (this.#output.reconcile)` before forwarding.
+     */
+    reconcile?(pusher: InputBase): Stream<'yield'>;
 }
 /**
  * An implementation of Output that throws if pushed to. It is used as the
- * initial value for for an operator's output before it is set.
+ * initial value for an operator's output before it is set.
  */
 export declare const throwOutput: Output;
 /**
- * Operators are arranged into pipelines.
+ * Operators are arranged into IVM pipelines.
  * They are stateful.
  * Each operator is an input to the next operator in the chain and an output
  * to the previous.
  */
 export interface Operator extends Input, Output {
+    /**
+     * Intermediate pipeline operators MUST implement reconcile so that Phase 2
+     * reconciliation reaches all bounded operators in the pipeline and is never
+     * accidentally swallowed.
+     */
+    reconcile(pusher: InputBase): Stream<'yield'>;
 }
 /**
  * Operators get access to storage that they can store their internal
@@ -161,5 +190,11 @@ export interface Storage {
         prefix: string;
     }): Stream<[string, JSONValue]>;
     del(key: string): void;
+    /**
+     * Called by the operator that owns the storage when the operator is
+     * destroyed. Releases anything the storage holds outside of the operator
+     * (e.g. rows in a shared database). The storage is not used afterwards.
+     */
+    destroy(): void;
 }
 //# sourceMappingURL=operator.d.ts.map

package/out/zql/src/ivm/operator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"operator.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/operator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAAC,GAAG,EAAC,MAAM,oCAAoC,CAAC;AAC5D,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,sBAAsB,CAAC;AAC9D,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AACxC,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,iBAAiB,CAAC;AAChD,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,WAAW,CAAC;AACpC,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AAExC,OAAO,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAE5C;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,iDAAiD;IACjD,SAAS,IAAI,YAAY,CAAC;IAE1B;;;;OAIG;IACH,OAAO,IAAI,IAAI,CAAC;CACjB;AAED,MAAM,WAAW,KAAM,SAAQ,SAAS;IACtC,+CAA+C;IAC/C,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAEhC;;;;;;;;;;;;OAYG;IACH,KAAK,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC,CAAC;CAClD;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,eAAe,GAAG,SAAS,UAAU,EAAE,CAAC;AAEpD,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,UAAU,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC;IAE7C;;;;;;;;OAQG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,SAAS,eAAe,EAAE,GAAG,SAAS,CAAC;IAEnE,kFAAkF;IAClF,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,GAAG,SAAS,CAAC;IAEnC,oEAAoE;IACpE,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAEvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,mBAAmB,GAAG,SAAS,CAAC;CACnD,CAAC;AAEF,MAAM,MAAM,KAAK,GAAG;IAClB,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC;IAClB,QAAQ,CAAC,KAAK,EAAE,IAAI,GAAG,OAAO,CAAC;CAChC,CAAC;AAEF;;;GAGG;AACH,MAAM,WAAW,MAAM;IACrB;;;;;;;;;;;;OAYG;IACH,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC;CAC1D;AAED;;;GAGG;AACH,eAAO,MAAM,WAAW,EAAE,MAIzB,CAAC;AAEF;;;;;GAKG;AACH,MAAM,WAAW,QAAS,SAAQ,KAAK,EAAE,MAAM;CAAG;AAElD;;;GAGG;AACH,MAAM,WAAW,OAAO;IACtB,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,IAAI,CAAC;IACzC,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,SAAS,GAAG,SAAS,GAAG,SAAS,CAAC;IACzD;;OAEG;IACH,IAAI,CAAC,OAAO,CAAC,EAAE;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,GAAG,MAAM,CAAC,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC;IAC9D,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB"}
+{"version":3,"file":"operator.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/operator.ts"],"names":[],"mappings":"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"}

package/out/zql/src/ivm/operator.js

@@ -2,11 +2,16 @@ import "./skip-yields.js";
 //#region ../zql/src/ivm/operator.ts
 /**
 * An implementation of Output that throws if pushed to. It is used as the
-* initial value for for an operator's output before it is set.
+* initial value for an operator's output before it is set.
 */
-var throwOutput = { push(_change) {
-	throw new Error("Output not set");
-} };
+var throwOutput = {
+	push(_change) {
+		throw new Error("Output not set");
+	},
+	reconcile() {
+		throw new Error("Output not set");
+	}
+};
 //#endregion
 export { throwOutput };
 

package/out/zql/src/ivm/operator.js.map

@@ -1 +1 @@
-{"version":3,"file":"operator.js","names":[],"sources":["../../../../../zql/src/ivm/operator.ts"],"sourcesContent":["import type {JSONValue} from '../../../shared/src/json.ts';\nimport type {Row} from '../../../zero-protocol/src/data.ts';\nimport type {NoSubqueryCondition} from '../builder/filter.ts';\nimport type {Change} from './change.ts';\nimport type {Constraint} from './constraint.ts';\nimport type {Node} from './data.ts';\nimport type {SourceSchema} from './schema.ts';\nimport type {Stream} from './stream.ts';\n\nexport {skipYields} from './skip-yields.ts';\n\n/**\n * Input to an operator.\n */\nexport interface InputBase {\n  /** The schema of the data this input returns. */\n  getSchema(): SourceSchema;\n\n  /**\n   * Completely destroy the input. Destroying an input\n   * causes it to call destroy on its upstreams, fully\n   * cleaning up a pipeline.\n   */\n  destroy(): void;\n}\n\nexport interface Input extends InputBase {\n  /** Tell the input where to send its output. */\n  setOutput(output: Output): void;\n\n  /**\n   * Fetch data. May modify the data in place.\n   * Returns nodes sorted in order of `SourceSchema.compareRows`.\n   *\n   * The stream may contain 'yield' to yield control to the caller for purposes\n   * of responsiveness.\n   *\n   * Contract:\n   * - During fetch: If an input yields 'yield', 'yield' must be yielded to the\n   * caller of fetch immediately.\n   * - During push: If a fetch to an input consumed by the push logic yields\n   * 'yield', it must be yielded to the caller of push immediately.\n   */\n  fetch(req: FetchRequest): Stream<Node | 'yield'>;\n}\n\n/**\n * A single multi-row IN clause: a non-empty list of Constraints all\n * sharing the same column shape. Sources treat it as\n * `(col_a, col_b, …) IN VALUES (…)`.\n *\n * Caller invariants (sources rely on these — they are not re-checked):\n * - **Unique entries.** TableSource gets set semantics for free from SQL\n *   `IN`; MemorySource fans sub-fetches out per entry, so duplicates\n *   would yield the same row N times. FlippedJoin groups by canonical\n *   parent-key (`flipped-join.ts:#fetchBatched`) before emitting.\n * - **Key-compatible with `req.constraint`.** Entries that contradict\n *   `constraint` should be dropped upstream. FlippedJoin filters\n *   incompatible children via `constraintsAreCompatible` before adding\n *   them to a batch.\n */\nexport type MultiConstraint = readonly Constraint[];\n\nexport type FetchRequest = {\n  readonly constraint?: Constraint | undefined;\n\n  /**\n   * List of multi-row IN clauses, all ANDed together (and ANDed with\n   * `constraint` if both are provided). Each entry is a `MultiConstraint`\n   * over its own set of columns.\n   *\n   * Used by FlippedJoin to push child→parent fetches into a single\n   * batched statement, and to AND together constraints contributed by\n   * chained FlippedJoins (e.g. `assigneeID IN (…) AND creatorID IN (…)`).\n   */\n  readonly multiConstraints?: readonly MultiConstraint[] | undefined;\n\n  /** If supplied, `start.row` must have previously been output by fetch or push. */\n  readonly start?: Start | undefined;\n\n  /** Whether to fetch in reverse order of the SourceSchema's sort. */\n  readonly reverse?: boolean | undefined;\n\n  /**\n   * Additional predicate the consumer wants the source/intermediate operators\n   * to apply to the fetched rows. The receiver must AND this with whatever\n   * filtering it already applies. Sources may use this to drive index\n   * selection (e.g. PK lookup) the same way they use the connection-time\n   * filter.\n   *\n   * Always a `NoSubqueryCondition` — anything passed via `req.filter` must\n   * already have had correlated subqueries stripped (see `transformFilters`).\n   *\n   * Contract:\n   * - The only operator that *introduces* `req.filter` is `FilterStart`. It\n   *   AND-merges its static condition with whatever `req.filter` it receives\n   *   and forwards the merged value upstream. No other operator should\n   *   construct a `req.filter`.\n   * - \"Pass-through\" fetch operators (`Skip`, `Take`, `Join`, `FlippedJoin`,\n   *   `UnionFanIn`, `UnionFanOut`) MUST preserve `req.filter` when forwarding\n   *   to their input — typically via `{...req, ...overrides}` spread. Dropping\n   *   it silently regresses predicate pushdown for queries below the\n   *   forwarding operator.\n   * - Operators that *initiate* internal fetches (e.g., `Join.#pushChildChange`,\n   *   `FlippedJoin.#pushChildChange`, `UnionFanIn.#pushInternalChange`,\n   *   `Take`'s push-time bound recomputation) construct fresh\n   *   `FetchRequest`s without `req.filter`, and that is correct: there is no\n   *   inbound consumer-side filter at those call sites. Any `FilterStart`\n   *   that sits between such an internal fetch and the source will still\n   *   apply its own condition on the way through, so the source still gets\n   *   the right WHERE.\n   * - `Cap` is *not* a pass-through: it intentionally builds fresh\n   *   `{constraint}` requests when replaying tracked PKs and drops any\n   *   incoming `req.filter`. This is sound only because `Cap`'s sole\n   *   consumer in production is a `Join`'s child fetch (see\n   *   `Join.#processParentNode` in `join.ts`), which itself never carries\n   *   `req.filter` — Join's child fetches are constructed with just\n   *   `{constraint}` derived from join keys. If `Cap` is ever wired below\n   *   something that does push a `req.filter`, this carve-out becomes a\n   *   correctness bug.\n   */\n  readonly filter?: NoSubqueryCondition | undefined;\n};\n\nexport type Start = {\n  readonly row: Row;\n  readonly basis: 'at' | 'after';\n};\n\n/**\n * An output for an operator. Typically another Operator but can also be\n * the code running the pipeline.\n */\nexport interface Output {\n  /**\n   * Push incremental changes to data previously received with fetch().\n   * Consumers must apply all pushed changes or incremental result will\n   * be incorrect.\n   * Callers must maintain some invariants for correct operation:\n   * - Only add rows which do not already exist (by deep equality).\n   * - Only remove rows which do exist (by deep equality).\n   * Implmentation can yield 'yield' to yield control to the caller for purposes\n   * of responsiveness.\n   * Yield contract:\n   * - During a push: If a push call to an output yields 'yield', it must be\n   * yielded to the caller of push immediately.\n   */\n  push(change: Change, pusher: InputBase): Stream<'yield'>;\n}\n\n/**\n * An implementation of Output that throws if pushed to. It is used as the\n * initial value for for an operator's output before it is set.\n */\nexport const throwOutput: Output = {\n  push(_change: Change): Stream<'yield'> {\n    throw new Error('Output not set');\n  },\n};\n\n/**\n * Operators are arranged into pipelines.\n * They are stateful.\n * Each operator is an input to the next operator in the chain and an output\n * to the previous.\n */\nexport interface Operator extends Input, Output {}\n\n/**\n * Operators get access to storage that they can store their internal\n * state in.\n */\nexport interface Storage {\n  set(key: string, value: JSONValue): void;\n  get(key: string, def?: JSONValue): JSONValue | undefined;\n  /**\n   * If options is not specified, defaults to scanning all entries.\n   */\n  scan(options?: {prefix: string}): Stream<[string, JSONValue]>;\n  del(key: string): void;\n}\n"],"mappings":";;;;;;AA0JA,IAAa,cAAsB,EACjC,KAAK,SAAkC;CACrC,MAAM,IAAI,MAAM,gBAAgB;AAClC,EACF"}
+{"version":3,"file":"operator.js","names":[],"sources":["../../../../../zql/src/ivm/operator.ts"],"sourcesContent":["import type {JSONValue} from '../../../shared/src/json.ts';\nimport type {Row} from '../../../zero-protocol/src/data.ts';\nimport type {NoSubqueryCondition} from '../builder/filter.ts';\nimport type {Change} from './change.ts';\nimport type {Constraint} from './constraint.ts';\nimport type {Node} from './data.ts';\nimport type {SourceSchema} from './schema.ts';\nimport type {Stream} from './stream.ts';\n\nexport {skipYields} from './skip-yields.ts';\n\n/**\n * Input to an operator.\n */\nexport interface InputBase {\n  /** The schema of the data this input returns. */\n  getSchema(): SourceSchema;\n\n  /**\n   * Completely destroy the input. Destroying an input\n   * causes it to call destroy on its upstreams, fully\n   * cleaning up a pipeline.\n   */\n  destroy(): void;\n}\n\nexport interface Input extends InputBase {\n  /** Tell the input where to send its output. */\n  setOutput(output: Output): void;\n\n  /**\n   * Fetch data. May modify the data in place.\n   * Returns nodes sorted in order of `SourceSchema.compareRows`.\n   *\n   * The stream may contain 'yield' to yield control to the caller for purposes\n   * of responsiveness.\n   *\n   * Contract:\n   * - During fetch: If an input yields 'yield', 'yield' must be yielded to the\n   * caller of fetch immediately.\n   * - During push: If a fetch to an input consumed by the push logic yields\n   * 'yield', it must be yielded to the caller of push immediately.\n   * - During reconcile: If a fetch to an input consumed by reconcile logic\n   * yields 'yield', it must be yielded to the caller of reconcile immediately.\n   */\n  fetch(req: FetchRequest): Stream<Node | 'yield'>;\n}\n\n/**\n * A single multi-row IN clause: a non-empty list of Constraints all\n * sharing the same column shape. Sources treat it as\n * `(col_a, col_b, …) IN VALUES (…)`.\n *\n * Caller invariants (sources rely on these — they are not re-checked):\n * - **Unique entries.** TableSource gets set semantics for free from SQL\n *   `IN`; MemorySource fans sub-fetches out per entry, so duplicates\n *   would yield the same row N times. FlippedJoin groups by canonical\n *   parent-key (`flipped-join.ts:#fetchBatched`) before emitting.\n * - **Key-compatible with `req.constraint`.** Entries that contradict\n *   `constraint` should be dropped upstream. FlippedJoin filters\n *   incompatible children via `constraintsAreCompatible` before adding\n *   them to a batch.\n */\nexport type MultiConstraint = readonly Constraint[];\n\nexport type FetchRequest = {\n  readonly constraint?: Constraint | undefined;\n\n  /**\n   * List of multi-row IN clauses, all ANDed together (and ANDed with\n   * `constraint` if both are provided). Each entry is a `MultiConstraint`\n   * over its own set of columns.\n   *\n   * Used by FlippedJoin to push child→parent fetches into a single\n   * batched statement, and to AND together constraints contributed by\n   * chained FlippedJoins (e.g. `assigneeID IN (…) AND creatorID IN (…)`).\n   */\n  readonly multiConstraints?: readonly MultiConstraint[] | undefined;\n\n  /** If supplied, `start.row` must have previously been output by fetch or push. */\n  readonly start?: Start | undefined;\n\n  /** Whether to fetch in reverse order of the SourceSchema's sort. */\n  readonly reverse?: boolean | undefined;\n\n  /**\n   * Additional predicate the consumer wants the source/intermediate operators\n   * to apply to the fetched rows. The receiver must AND this with whatever\n   * filtering it already applies. Sources may use this to drive index\n   * selection (e.g. PK lookup) the same way they use the connection-time\n   * filter.\n   *\n   * Always a `NoSubqueryCondition` — anything passed via `req.filter` must\n   * already have had correlated subqueries stripped (see `transformFilters`).\n   *\n   * Contract:\n   * - The only operator that *introduces* `req.filter` is `FilterStart`. It\n   *   AND-merges its static condition with whatever `req.filter` it receives\n   *   and forwards the merged value upstream. No other operator should\n   *   construct a `req.filter`.\n   * - \"Pass-through\" fetch operators (`Skip`, `Take`, `Join`, `FlippedJoin`,\n   *   `UnionFanIn`, `UnionFanOut`) MUST preserve `req.filter` when forwarding\n   *   to their input — typically via `{...req, ...overrides}` spread. Dropping\n   *   it silently regresses predicate pushdown for queries below the\n   *   forwarding operator.\n   * - Operators that *initiate* internal fetches (e.g., `Join.#pushChildChange`,\n   *   `FlippedJoin.#pushChildChange`, `UnionFanIn.#pushInternalChange`,\n   *   `Take`'s push-time bound recomputation) construct fresh\n   *   `FetchRequest`s without `req.filter`, and that is correct: there is no\n   *   inbound consumer-side filter at those call sites. Any `FilterStart`\n   *   that sits between such an internal fetch and the source will still\n   *   apply its own condition on the way through, so the source still gets\n   *   the right WHERE.\n   * - `Cap` is *not* a pass-through: it intentionally builds fresh\n   *   `{constraint}` requests when replaying tracked PKs and drops any\n   *   incoming `req.filter`. This is sound only because `Cap`'s sole\n   *   consumer in production is a `Join`'s child fetch (see\n   *   `Join.#processParentNode` in `join.ts`), which itself never carries\n   *   `req.filter` — Join's child fetches are constructed with just\n   *   `{constraint}` derived from join keys. If `Cap` is ever wired below\n   *   something that does push a `req.filter`, this carve-out becomes a\n   *   correctness bug.\n   */\n  readonly filter?: NoSubqueryCondition | undefined;\n};\n\nexport type Start = {\n  readonly row: Row;\n  readonly basis: 'at' | 'after';\n};\n\n/**\n * An output for an operator. Typically another Operator in an IVM pipeline,\n * but can also be a terminal sink (such as a View or test consumer).\n */\nexport interface Output {\n  /**\n   * Phase 1 of two-phase push: pushes incremental changes to data previously\n   * received with fetch(). Consumers must apply all pushed changes or the\n   * incremental result will be incorrect.\n   *\n   * Callers must maintain some invariants for correct operation:\n   * - Only add rows which do not already exist (by deep equality).\n   * - Only remove rows which do exist (by deep equality).\n   *\n   * Implementations can yield 'yield' to yield control to the caller for\n   * purposes of responsiveness.\n   *\n   * Yield contract:\n   * - During a push: If a push call to an output yields 'yield', it must be\n   *   yielded to the caller of push immediately.\n   */\n  push(change: Change, pusher: InputBase): Stream<'yield'>;\n\n  /**\n   * Phase 2 of two-phase push: invoked after Phase 1 changes have propagated.\n   * Bounded operators (such as Take or Cap) use this signal to refill deficits,\n   * emit refilled rows downstream via push(), and update their bounds.\n   *\n   * Implementations can yield 'yield' to yield control to the caller for\n   * purposes of responsiveness.\n   *\n   * Yield contract:\n   * - During reconcile: If an internal fetch, push, or downstream reconcile call\n   *   yields 'yield', it must be yielded to the caller of reconcile immediately.\n   *\n   * This method is optional on Output to allow terminal sinks (such as UI views\n   * or custom third-party sinks) that only consume changes to omit it without\n   * breaking compatibility. Intermediate operators must check\n   * `if (this.#output.reconcile)` before forwarding.\n   */\n  reconcile?(pusher: InputBase): Stream<'yield'>;\n}\n\n/**\n * An implementation of Output that throws if pushed to. It is used as the\n * initial value for an operator's output before it is set.\n */\nexport const throwOutput: Output = {\n  push(_change: Change): Stream<'yield'> {\n    throw new Error('Output not set');\n  },\n  reconcile(): Stream<'yield'> {\n    throw new Error('Output not set');\n  },\n};\n\n/**\n * Operators are arranged into IVM pipelines.\n * They are stateful.\n * Each operator is an input to the next operator in the chain and an output\n * to the previous.\n */\nexport interface Operator extends Input, Output {\n  /**\n   * Intermediate pipeline operators MUST implement reconcile so that Phase 2\n   * reconciliation reaches all bounded operators in the pipeline and is never\n   * accidentally swallowed.\n   */\n  reconcile(pusher: InputBase): Stream<'yield'>;\n}\n\n/**\n * Operators get access to storage that they can store their internal\n * state in.\n */\nexport interface Storage {\n  set(key: string, value: JSONValue): void;\n  get(key: string, def?: JSONValue): JSONValue | undefined;\n  /**\n   * If options is not specified, defaults to scanning all entries.\n   */\n  scan(options?: {prefix: string}): Stream<[string, JSONValue]>;\n  del(key: string): void;\n  /**\n   * Called by the operator that owns the storage when the operator is\n   * destroyed. Releases anything the storage holds outside of the operator\n   * (e.g. rows in a shared database). The storage is not used afterwards.\n   */\n  destroy(): void;\n}\n"],"mappings":";;;;;;AAkLA,IAAa,cAAsB;CACjC,KAAK,SAAkC;EACrC,MAAM,IAAI,MAAM,gBAAgB;CAClC;CACA,YAA6B;EAC3B,MAAM,IAAI,MAAM,gBAAgB;CAClC;AACF"}

package/out/zql/src/ivm/push-accumulated.d.ts

@@ -73,7 +73,12 @@ import type { Stream } from './stream.ts';
  * If an edit enters and is converted to only add or only remove, it exits as that change.
  * If an edit enters and exits as edits only, it exits as a single edit.
  */
-export declare function pushAccumulatedChanges(accumulatedPushes: Change[], output: Output, pusher: InputBase, fanOutChangeType: ChangeType, mergeRelationships: (existing: Change, incoming: Change) => Change, addEmptyRelationships: (change: Change) => Change): Stream<'yield'>;
+export declare function pushAccumulatedChanges(accumulatedPushes: Change[], output: Output, pusher: InputBase, fanOutChangeType: ChangeType, mergeRelationships: (existing: Change, incoming: Change) => Change, addEmptyRelationships: (change: Change) => Change, isBranchRel?: (name: string) => boolean): Stream<'yield'>;
+/**
+ * The row stays downstream, but it gained (`ADD`) or lost (`REMOVE`) every
+ * witness in `node`'s branch relationships. One child change per witness.
+ */
+export declare function pushWitnessDeltas(node: Node, type: ChangeType.ADD | ChangeType.REMOVE, isBranchRel: (name: string) => boolean, output: Output, pusher: InputBase): Stream<'yield'>;
 /**
  * Puts relationships from `right` into `left` if they don't already exist in `left`.
  */

package/out/zql/src/ivm/push-accumulated.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"push-accumulated.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/push-accumulated.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAKL,KAAK,MAAM,EACZ,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,WAAW,CAAC;AACpC,OAAO,KAAK,EAAC,SAAS,EAAE,MAAM,EAAC,MAAM,eAAe,CAAC;AACrD,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoEG;AACH,wBAAiB,sBAAsB,CACrC,iBAAiB,EAAE,MAAM,EAAE,EAC3B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,SAAS,EACjB,gBAAgB,EAAE,UAAU,EAC5B,kBAAkB,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,MAAM,EAClE,qBAAqB,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,GAChD,MAAM,CAAC,OAAO,CAAC,CAsKjB;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAsGtE;AAED,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,YAAY,GACnB,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,CA0C5B;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CACxB,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC,CAAC,EAC3D,iBAAiB,EAAE,MAAM,EAAE,QAO5B"}
+{"version":3,"file":"push-accumulated.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/push-accumulated.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAKL,KAAK,MAAM,EACZ,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,WAAW,CAAC;AACpC,OAAO,KAAK,EAAC,SAAS,EAAE,MAAM,EAAC,MAAM,eAAe,CAAC;AACrD,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoEG;AACH,wBAAiB,sBAAsB,CACrC,iBAAiB,EAAE,MAAM,EAAE,EAC3B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,SAAS,EACjB,gBAAgB,EAAE,UAAU,EAC5B,kBAAkB,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,MAAM,EAClE,qBAAqB,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,EAGjD,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,GACtC,MAAM,CAAC,OAAO,CAAC,CAyEjB;AAiND;;;GAGG;AACH,wBAAiB,iBAAiB,CAChC,IAAI,EAAE,IAAI,EACV,IAAI,EAAE,UAAU,CAAC,GAAG,GAAG,UAAU,CAAC,MAAM,EACxC,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,EACtC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,SAAS,GAChB,MAAM,CAAC,OAAO,CAAC,CAwBjB;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAsGtE;AAED,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,YAAY,GACnB,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,CA0C5B;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CACxB,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC,CAAC,EAC3D,iBAAiB,EAAE,MAAM,EAAE,QAO5B"}

package/out/zql/src/ivm/push-accumulated.js

@@ -72,10 +72,16 @@ import { makeAddChange, makeChildChange, makeEditChange, makeRemoveChange } from
 * If an edit enters and is converted to only add or only remove, it exits as that change.
 * If an edit enters and exits as edits only, it exits as a single edit.
 */
-function* pushAccumulatedChanges(accumulatedPushes, output, pusher, fanOutChangeType, mergeRelationships, addEmptyRelationships) {
+function* pushAccumulatedChanges(accumulatedPushes, output, pusher, fanOutChangeType, mergeRelationships, addEmptyRelationships, isBranchRel) {
 	if (accumulatedPushes.length === 0) return;
+	const witnessesLeft = [];
+	const witnessesEntered = [];
 	const candidatesToPush = /* @__PURE__ */ new Map();
 	for (const change of accumulatedPushes) {
+		if (isBranchRel && change[0] === 3 && isBranchRel(change[2].relationshipName)) {
+			(change[2].change[0] === 1 ? witnessesLeft : witnessesEntered).push(change);
+			continue;
+		}
 		if (fanOutChangeType === 3 && change[0] !== 3) assert(candidatesToPush.has(change[0]) === false, () => `Fan-in:child expected at most one ${change[0]} when fan-out is of type child`);
 		const existing = candidatesToPush.get(change[0]);
 		let mergedChange = change;
@@ -83,6 +89,12 @@ function* pushAccumulatedChanges(accumulatedPushes, output, pusher, fanOutChange
 		candidatesToPush.set(change[0], mergedChange);
 	}
 	accumulatedPushes.length = 0;
+	assert(candidatesToPush.size > 0, "Fan-in: witness changes without a change for their row");
+	for (const change of witnessesLeft) yield* output.push(change, pusher);
+	yield* pushCollapsed(candidatesToPush, output, pusher, fanOutChangeType, mergeRelationships, addEmptyRelationships, isBranchRel);
+	for (const change of witnessesEntered) yield* output.push(change, pusher);
+}
+function* pushCollapsed(candidatesToPush, output, pusher, fanOutChangeType, mergeRelationships, addEmptyRelationships, isBranchRel) {
 	const types = [...candidatesToPush.keys()];
 	/**
 	* Based on the received `fanOutChangeType` only certain output types are valid.
@@ -108,6 +120,16 @@ function* pushAccumulatedChanges(accumulatedPushes, output, pusher, fanOutChange
 			const addChange = candidatesToPush.get(0);
 			const removeChange = candidatesToPush.get(1);
 			let editChange = candidatesToPush.get(2);
+			if (isBranchRel && (editChange || addChange && removeChange)) {
+				if (removeChange) yield* pushWitnessDeltas(removeChange[1], 1, isBranchRel, output, pusher);
+				const strip = (n) => ({
+					row: n.row,
+					relationships: Object.fromEntries(Object.entries(n.relationships).filter(([k]) => !isBranchRel(k)))
+				});
+				yield* output.push(addEmptyRelationships(editChange ?? makeEditChange(strip(must(addChange)[1]), strip(must(removeChange)[1]))), pusher);
+				if (addChange) yield* pushWitnessDeltas(addChange[1], 0, isBranchRel, output, pusher);
+				return;
+			}
 			if (editChange) {
 				if (addChange) editChange = mergeRelationships(editChange, addChange);
 				if (removeChange) editChange = mergeRelationships(editChange, removeChange);
@@ -126,7 +148,11 @@ function* pushAccumulatedChanges(accumulatedPushes, output, pusher, fanOutChange
 			assert(types.length <= 2, "Fan-in:child expected at most 2 types on a child change from fan-out");
 			const childChange = candidatesToPush.get(3);
 			if (childChange) {
+				const left = candidatesToPush.get(1);
+				const entered = candidatesToPush.get(0);
+				if (isBranchRel && left) yield* pushWitnessDeltas(left[1], 1, isBranchRel, output, pusher);
 				yield* output.push(childChange, pusher);
+				if (isBranchRel && entered) yield* pushWitnessDeltas(entered[1], 0, isBranchRel, output, pusher);
 				return;
 			}
 			const addChange = candidatesToPush.get(0);
@@ -139,6 +165,25 @@ function* pushAccumulatedChanges(accumulatedPushes, output, pusher, fanOutChange
 	}
 }
 /**
+* The row stays downstream, but it gained (`ADD`) or lost (`REMOVE`) every
+* witness in `node`'s branch relationships. One child change per witness.
+*/
+function* pushWitnessDeltas(node, type, isBranchRel, output, pusher) {
+	for (const [relationshipName, children] of Object.entries(node.relationships)) {
+		if (!isBranchRel(relationshipName)) continue;
+		for (const child of children()) {
+			if (child === "yield") {
+				yield child;
+				continue;
+			}
+			yield* output.push(makeChildChange(node, {
+				relationshipName,
+				change: type === 0 ? makeAddChange(child) : makeRemoveChange(child)
+			}), pusher);
+		}
+	}
+}
+/**
 * Puts relationships from `right` into `left` if they don't already exist in `left`.
 */
 function mergeRelationships(left, right) {
@@ -248,6 +293,6 @@ function mergeEmpty(relationships, relationshipNames) {
 	for (const relName of relationshipNames) if (relationships[relName] === void 0) relationships[relName] = () => emptyArray;
 }
 //#endregion
-export { makeAddEmptyRelationships, mergeRelationships, pushAccumulatedChanges };
+export { makeAddEmptyRelationships, mergeEmpty, mergeRelationships, pushAccumulatedChanges, pushWitnessDeltas };
 
 //# sourceMappingURL=push-accumulated.js.map

package/out/zql/src/ivm/push-accumulated.js.map

@@ -1 +1 @@
-{"version":3,"file":"push-accumulated.js","names":[],"sources":["../../../../../zql/src/ivm/push-accumulated.ts"],"sourcesContent":["import {assert, unreachable} from '../../../shared/src/asserts.ts';\nimport {must} from '../../../shared/src/must.ts';\nimport {emptyArray} from '../../../shared/src/sentinels.ts';\nimport {ChangeIndex} from './change-index.ts';\nimport {ChangeType} from './change-type.ts';\nimport {\n  makeAddChange,\n  makeChildChange,\n  makeEditChange,\n  makeRemoveChange,\n  type Change,\n} from './change.ts';\nimport type {Node} from './data.ts';\nimport type {InputBase, Output} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport type {Stream} from './stream.ts';\n\n/**\n * # pushAccumulatedChanges\n *\n * Pushes the changes that were accumulated by\n * [fan-out, fan-in] or [ufo, ufi] sub-graphs.\n *\n * This function is called at the end of the sub-graph.\n *\n * The sub-graphs represents `OR`s.\n *\n * Changes that can enter the subgraphs:\n * 1. child (due to exist joins being above the sub-graph)\n * 2. add\n * 3. remove\n * 4. edit\n *\n * # Changes that can exit into `pushAccumulatedChanges`:\n *\n * ## Child\n * If a `child` change enters a sub-graph, it will flow to all branches.\n * Each branch will either:\n * - preserve the `child` change\n * - stop the `child` change (e.g., filter)\n * - convert it to an `add` or `remove` (e.g., exists filter)\n *\n * ## Add\n * If an `add` change enters a sub-graph, it will flow to all branches.\n * Each branch will either:\n * - preserve the `add` change\n * - hide the change (e.g., filter)\n *\n * ## Remove\n * If a `remove` change enters a sub-graph, it will flow to all branches.\n * Each branch will either:\n * - preserve the `remove` change\n * - hide the change (e.g., filter)\n *\n * ## Edit\n * If an `edit` change enters a sub-graph, it will flow to all branches.\n * Each branch will either:\n * - preserve the `edit` change\n * - convert it to an `add` (e.g., filter where old didn't match but new does)\n * - convert it to a `remove` (e.g., filter where old matched but new doesn't)\n *\n * This results in some invariants:\n * - an add coming in will only create adds coming out\n * - a remove coming in will only create removes coming out\n * - an edit coming in can create adds, removes, and edits coming out\n * - a child coming in can create adds, removes, and children coming out\n *\n * # Return of `pushAccumulatedChanges`\n *\n * This function will only push a single change.\n * Given the above invariants, how is this possible?\n *\n * An add that becomes many `adds` results in a single add\n * as the `add` is the same row across all adds. Branches do not change the row.\n *\n * A remove that becomes many `removes` results in a single remove\n * for the same reason.\n *\n * If a child enters and exits, it takes precedence over all other changes.\n * If a child enters and is converted only to add and remove it exits as an edit.\n * If a child enters and is converted to only add or only remove, it exits as that change.\n *\n * If an edit enters and is converted to add and remove it exits as an edit.\n * If an edit enters and is converted to only add or only remove, it exits as that change.\n * If an edit enters and exits as edits only, it exits as a single edit.\n */\nexport function* pushAccumulatedChanges(\n  accumulatedPushes: Change[],\n  output: Output,\n  pusher: InputBase,\n  fanOutChangeType: ChangeType,\n  mergeRelationships: (existing: Change, incoming: Change) => Change,\n  addEmptyRelationships: (change: Change) => Change,\n): Stream<'yield'> {\n  if (accumulatedPushes.length === 0) {\n    // It is possible for no forks to pass along the push.\n    // E.g., if no filters match in any fork.\n    return;\n  }\n\n  // collapse down to a single change per type\n  const candidatesToPush = new Map<ChangeType, Change>();\n  for (const change of accumulatedPushes) {\n    if (\n      fanOutChangeType === ChangeType.CHILD &&\n      change[ChangeIndex.TYPE] !== ChangeType.CHILD\n    ) {\n      assert(\n        candidatesToPush.has(change[ChangeIndex.TYPE]) === false,\n        () =>\n          `Fan-in:child expected at most one ${change[ChangeIndex.TYPE]} when fan-out is of type child`,\n      );\n    }\n\n    const existing = candidatesToPush.get(change[ChangeIndex.TYPE]);\n    let mergedChange = change;\n    if (existing) {\n      // merge in relationships\n      mergedChange = mergeRelationships(existing, change);\n    }\n    candidatesToPush.set(change[ChangeIndex.TYPE], mergedChange);\n  }\n\n  accumulatedPushes.length = 0;\n\n  const types = [...candidatesToPush.keys()];\n  /**\n   * Based on the received `fanOutChangeType` only certain output types are valid.\n   *\n   * - remove must result in all removes\n   * - add must result in all adds\n   * - edit must result in add or removes or edits\n   * - child must result in a single add or single remove or many child changes\n   *    - Single add or remove because the relationship will be unique to one exist check within the fan-out,fan-in sub-graph\n   *    - Many child changes because other operators may preserve the child change\n   */\n  switch (fanOutChangeType) {\n    case ChangeType.REMOVE:\n      assert(\n        types.length === 1 && types[0] === ChangeType.REMOVE,\n        'Fan-in:remove expected all removes',\n      );\n      yield* output.push(\n        addEmptyRelationships(must(candidatesToPush.get(ChangeType.REMOVE))),\n        pusher,\n      );\n      return;\n    case ChangeType.ADD:\n      assert(\n        types.length === 1 && types[0] === ChangeType.ADD,\n        'Fan-in:add expected all adds',\n      );\n      yield* output.push(\n        addEmptyRelationships(must(candidatesToPush.get(ChangeType.ADD))),\n        pusher,\n      );\n      return;\n    case ChangeType.EDIT: {\n      assert(\n        types.every(\n          type =>\n            type === ChangeType.ADD ||\n            type === ChangeType.REMOVE ||\n            type === ChangeType.EDIT,\n        ),\n        'Fan-in:edit expected all adds, removes, or edits',\n      );\n      const addChange = candidatesToPush.get(ChangeType.ADD);\n      const removeChange = candidatesToPush.get(ChangeType.REMOVE);\n      let editChange = candidatesToPush.get(ChangeType.EDIT);\n\n      // If an `edit` is present, it supersedes `add` and `remove`\n      // as it semantically represents both.\n      if (editChange) {\n        if (addChange) {\n          editChange = mergeRelationships(editChange, addChange);\n        }\n        if (removeChange) {\n          editChange = mergeRelationships(editChange, removeChange);\n        }\n        yield* output.push(addEmptyRelationships(editChange), pusher);\n        return;\n      }\n\n      // If `edit` didn't make it through but both `add` and `remove` did,\n      // convert back to an edit.\n      //\n      // When can this happen?\n      //\n      //  EDIT old: a=1, new: a=2\n      //            |\n      //          FanOut\n      //          /    \\\n      //         a=1   a=2\n      //          |     |\n      //        remove  add\n      //          \\     /\n      //           FanIn\n      //\n      // The left filter converts the edit into a remove.\n      // The right filter converts the edit into an add.\n      if (addChange && removeChange) {\n        yield* output.push(\n          addEmptyRelationships(\n            makeEditChange(\n              addChange[ChangeIndex.NODE],\n              removeChange[ChangeIndex.NODE],\n            ),\n          ),\n          pusher,\n        );\n        return;\n      }\n\n      yield* output.push(\n        addEmptyRelationships(must(addChange ?? removeChange)),\n        pusher,\n      );\n      return;\n    }\n    case ChangeType.CHILD: {\n      assert(\n        types.every(\n          type =>\n            type === ChangeType.ADD || // exists can change child to add or remove\n            type === ChangeType.REMOVE || // exists can change child to add or remove\n            type === ChangeType.CHILD, // other operators may preserve the child change\n        ),\n        'Fan-in:child expected all adds, removes, or children',\n      );\n      assert(\n        types.length <= 2,\n        'Fan-in:child expected at most 2 types on a child change from fan-out',\n      );\n\n      // If any branch preserved the original child change, that takes precedence over all other changes.\n      const childChange = candidatesToPush.get(ChangeType.CHILD);\n      if (childChange) {\n        yield* output.push(childChange, pusher);\n        return;\n      }\n\n      const addChange = candidatesToPush.get(ChangeType.ADD);\n      const removeChange = candidatesToPush.get(ChangeType.REMOVE);\n\n      assert(\n        addChange === undefined || removeChange === undefined,\n        'Fan-in:child expected either add or remove, not both',\n      );\n\n      yield* output.push(\n        addEmptyRelationships(must(addChange ?? removeChange)),\n        pusher,\n      );\n      return;\n    }\n    default:\n      fanOutChangeType satisfies never;\n  }\n}\n\n/**\n * Puts relationships from `right` into `left` if they don't already exist in `left`.\n */\nexport function mergeRelationships(left: Change, right: Change): Change {\n  // change types will always match\n  // unless we have an edit on the left\n  // then the right could be edit, add, or remove\n  if (left[ChangeIndex.TYPE] === right[ChangeIndex.TYPE]) {\n    switch (left[ChangeIndex.TYPE]) {\n      case ChangeType.ADD: {\n        return makeAddChange({\n          row: left[ChangeIndex.NODE].row,\n          relationships: {\n            ...right[ChangeIndex.NODE].relationships,\n            ...left[ChangeIndex.NODE].relationships,\n          },\n        });\n      }\n      case ChangeType.REMOVE: {\n        return makeRemoveChange({\n          row: left[ChangeIndex.NODE].row,\n          relationships: {\n            ...right[ChangeIndex.NODE].relationships,\n            ...left[ChangeIndex.NODE].relationships,\n          },\n        });\n      }\n      case ChangeType.EDIT: {\n        assert(\n          right[ChangeIndex.TYPE] === ChangeType.EDIT,\n          () =>\n            `mergeRelationships: when left.type is edit and types match, right.type must be edit, got ${right[ChangeIndex.TYPE]}`,\n        );\n        // merge edits into a single edit\n        return makeEditChange(\n          {\n            row: left[ChangeIndex.NODE].row,\n            relationships: {\n              ...right[ChangeIndex.NODE].relationships,\n              ...left[ChangeIndex.NODE].relationships,\n            },\n          },\n          {\n            row: left[ChangeIndex.OLD_NODE].row,\n            relationships: {\n              ...right[ChangeIndex.OLD_NODE].relationships,\n              ...left[ChangeIndex.OLD_NODE].relationships,\n            },\n          },\n        );\n      }\n      case ChangeType.CHILD: {\n        // Multiple branches may preserve the same child change, each adding\n        // different relationships. Merge the relationships, keeping the child\n        // (which should be identical across branches).\n        assert(\n          right[ChangeIndex.TYPE] === ChangeType.CHILD,\n          () =>\n            `mergeRelationships: when left.type is child and types match, right.type must be child, got ${right[ChangeIndex.TYPE]}`,\n        );\n        return makeChildChange(\n          {\n            row: left[ChangeIndex.NODE].row,\n            relationships: {\n              ...right[ChangeIndex.NODE].relationships,\n              ...left[ChangeIndex.NODE].relationships,\n            },\n          },\n          left[ChangeIndex.CHILD_DATA],\n        );\n      }\n    }\n  }\n\n  // left is always an edit here\n  assert(\n    left[ChangeIndex.TYPE] === ChangeType.EDIT,\n    () =>\n      `mergeRelationships: when types differ, left.type must be edit, got left.type=${left[ChangeIndex.TYPE]}, right.type=${right[ChangeIndex.TYPE]}`,\n  );\n  switch (right[ChangeIndex.TYPE]) {\n    case ChangeType.ADD: {\n      return makeEditChange(\n        {\n          ...left[ChangeIndex.NODE],\n          relationships: {\n            ...right[ChangeIndex.NODE].relationships,\n            ...left[ChangeIndex.NODE].relationships,\n          },\n        },\n        left[ChangeIndex.OLD_NODE],\n      );\n    }\n    case ChangeType.REMOVE: {\n      return makeEditChange(left[ChangeIndex.NODE], {\n        ...left[ChangeIndex.OLD_NODE],\n        relationships: {\n          ...right[ChangeIndex.NODE].relationships,\n          ...left[ChangeIndex.OLD_NODE].relationships,\n        },\n      });\n    }\n  }\n\n  unreachable();\n}\n\nexport function makeAddEmptyRelationships(\n  schema: SourceSchema,\n): (change: Change) => Change {\n  return (change: Change): Change => {\n    if (Object.keys(schema.relationships).length === 0) {\n      return change;\n    }\n\n    switch (change[ChangeIndex.TYPE]) {\n      case ChangeType.ADD: {\n        const relationships = {...change[ChangeIndex.NODE].relationships};\n        mergeEmpty(relationships, Object.keys(schema.relationships));\n        return makeAddChange({\n          row: change[ChangeIndex.NODE].row,\n          relationships,\n        });\n      }\n      case ChangeType.REMOVE: {\n        const relationships = {...change[ChangeIndex.NODE].relationships};\n        mergeEmpty(relationships, Object.keys(schema.relationships));\n        return makeRemoveChange({\n          row: change[ChangeIndex.NODE].row,\n          relationships,\n        });\n      }\n      case ChangeType.EDIT: {\n        const nodeRelationships = {...change[ChangeIndex.NODE].relationships};\n        const oldNodeRelationships = {\n          ...change[ChangeIndex.OLD_NODE].relationships,\n        };\n        mergeEmpty(nodeRelationships, Object.keys(schema.relationships));\n        mergeEmpty(oldNodeRelationships, Object.keys(schema.relationships));\n        return makeEditChange(\n          {row: change[ChangeIndex.NODE].row, relationships: nodeRelationships},\n          {\n            row: change[ChangeIndex.OLD_NODE].row,\n            relationships: oldNodeRelationships,\n          },\n        );\n      }\n      case ChangeType.CHILD:\n        return change; // children only have relationships along the path to the change\n    }\n  };\n}\n\n/**\n * For each relationship in `schema` that does not exist\n * in `relationships`, add it with an empty stream.\n *\n * This modifies the `relationships` object in place.\n */\nexport function mergeEmpty(\n  relationships: Record<string, () => Stream<Node | 'yield'>>,\n  relationshipNames: string[],\n) {\n  for (const relName of relationshipNames) {\n    if (relationships[relName] === undefined) {\n      relationships[relName] = () => emptyArray;\n    }\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"push-accumulated.js","names":[],"sources":["../../../../../zql/src/ivm/push-accumulated.ts"],"sourcesContent":["import {assert, unreachable} from '../../../shared/src/asserts.ts';\nimport {must} from '../../../shared/src/must.ts';\nimport {emptyArray} from '../../../shared/src/sentinels.ts';\nimport {ChangeIndex} from './change-index.ts';\nimport {ChangeType} from './change-type.ts';\nimport {\n  makeAddChange,\n  makeChildChange,\n  makeEditChange,\n  makeRemoveChange,\n  type Change,\n} from './change.ts';\nimport type {Node} from './data.ts';\nimport type {InputBase, Output} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport type {Stream} from './stream.ts';\n\n/**\n * # pushAccumulatedChanges\n *\n * Pushes the changes that were accumulated by\n * [fan-out, fan-in] or [ufo, ufi] sub-graphs.\n *\n * This function is called at the end of the sub-graph.\n *\n * The sub-graphs represents `OR`s.\n *\n * Changes that can enter the subgraphs:\n * 1. child (due to exist joins being above the sub-graph)\n * 2. add\n * 3. remove\n * 4. edit\n *\n * # Changes that can exit into `pushAccumulatedChanges`:\n *\n * ## Child\n * If a `child` change enters a sub-graph, it will flow to all branches.\n * Each branch will either:\n * - preserve the `child` change\n * - stop the `child` change (e.g., filter)\n * - convert it to an `add` or `remove` (e.g., exists filter)\n *\n * ## Add\n * If an `add` change enters a sub-graph, it will flow to all branches.\n * Each branch will either:\n * - preserve the `add` change\n * - hide the change (e.g., filter)\n *\n * ## Remove\n * If a `remove` change enters a sub-graph, it will flow to all branches.\n * Each branch will either:\n * - preserve the `remove` change\n * - hide the change (e.g., filter)\n *\n * ## Edit\n * If an `edit` change enters a sub-graph, it will flow to all branches.\n * Each branch will either:\n * - preserve the `edit` change\n * - convert it to an `add` (e.g., filter where old didn't match but new does)\n * - convert it to a `remove` (e.g., filter where old matched but new doesn't)\n *\n * This results in some invariants:\n * - an add coming in will only create adds coming out\n * - a remove coming in will only create removes coming out\n * - an edit coming in can create adds, removes, and edits coming out\n * - a child coming in can create adds, removes, and children coming out\n *\n * # Return of `pushAccumulatedChanges`\n *\n * This function will only push a single change.\n * Given the above invariants, how is this possible?\n *\n * An add that becomes many `adds` results in a single add\n * as the `add` is the same row across all adds. Branches do not change the row.\n *\n * A remove that becomes many `removes` results in a single remove\n * for the same reason.\n *\n * If a child enters and exits, it takes precedence over all other changes.\n * If a child enters and is converted only to add and remove it exits as an edit.\n * If a child enters and is converted to only add or only remove, it exits as that change.\n *\n * If an edit enters and is converted to add and remove it exits as an edit.\n * If an edit enters and is converted to only add or only remove, it exits as that change.\n * If an edit enters and exits as edits only, it exits as a single edit.\n */\nexport function* pushAccumulatedChanges(\n  accumulatedPushes: Change[],\n  output: Output,\n  pusher: InputBase,\n  fanOutChangeType: ChangeType,\n  mergeRelationships: (existing: Change, incoming: Change) => Change,\n  addEmptyRelationships: (change: Change) => Change,\n  // Relationships a branch adds (a flipped join's witnesses). Only the union\n  // fan has any; the filter fan passes nothing and behaves as before.\n  isBranchRel?: (name: string) => boolean,\n): Stream<'yield'> {\n  if (accumulatedPushes.length === 0) {\n    // It is possible for no forks to pass along the push.\n    // E.g., if no filters match in any fork.\n    return;\n  }\n\n  // A union nested in a branch keeps the row but reports its witness changes\n  // as child changes on its own branch relationships, around the change it\n  // pushes for the row. (A child change entering through the fan-out is on\n  // one of the fan-out's relationships, never a branch's.) Those are not\n  // candidates to collapse: pass them through around this fan-in's change,\n  // removals (old row) before and additions (new row) after, as the nested\n  // union ordered them.\n  const witnessesLeft: Change[] = [];\n  const witnessesEntered: Change[] = [];\n\n  // collapse down to a single change per type\n  const candidatesToPush = new Map<ChangeType, Change>();\n  for (const change of accumulatedPushes) {\n    if (\n      isBranchRel &&\n      change[ChangeIndex.TYPE] === ChangeType.CHILD &&\n      isBranchRel(change[ChangeIndex.CHILD_DATA].relationshipName)\n    ) {\n      (change[ChangeIndex.CHILD_DATA].change[ChangeIndex.TYPE] ===\n      ChangeType.REMOVE\n        ? witnessesLeft\n        : witnessesEntered\n      ).push(change);\n      continue;\n    }\n    if (\n      fanOutChangeType === ChangeType.CHILD &&\n      change[ChangeIndex.TYPE] !== ChangeType.CHILD\n    ) {\n      assert(\n        candidatesToPush.has(change[ChangeIndex.TYPE]) === false,\n        () =>\n          `Fan-in:child expected at most one ${change[ChangeIndex.TYPE]} when fan-out is of type child`,\n      );\n    }\n\n    const existing = candidatesToPush.get(change[ChangeIndex.TYPE]);\n    let mergedChange = change;\n    if (existing) {\n      // merge in relationships\n      mergedChange = mergeRelationships(existing, change);\n    }\n    candidatesToPush.set(change[ChangeIndex.TYPE], mergedChange);\n  }\n\n  accumulatedPushes.length = 0;\n\n  assert(\n    candidatesToPush.size > 0,\n    'Fan-in: witness changes without a change for their row',\n  );\n  for (const change of witnessesLeft) {\n    yield* output.push(change, pusher);\n  }\n  yield* pushCollapsed(\n    candidatesToPush,\n    output,\n    pusher,\n    fanOutChangeType,\n    mergeRelationships,\n    addEmptyRelationships,\n    isBranchRel,\n  );\n  for (const change of witnessesEntered) {\n    yield* output.push(change, pusher);\n  }\n}\n\nfunction* pushCollapsed(\n  candidatesToPush: Map<ChangeType, Change>,\n  output: Output,\n  pusher: InputBase,\n  fanOutChangeType: ChangeType,\n  mergeRelationships: (existing: Change, incoming: Change) => Change,\n  addEmptyRelationships: (change: Change) => Change,\n  isBranchRel: ((name: string) => boolean) | undefined,\n): Stream<'yield'> {\n  const types = [...candidatesToPush.keys()];\n  /**\n   * Based on the received `fanOutChangeType` only certain output types are valid.\n   *\n   * - remove must result in all removes\n   * - add must result in all adds\n   * - edit must result in add or removes or edits\n   * - child must result in a single add or single remove or many child changes\n   *    - Single add or remove because the relationship will be unique to one exist check within the fan-out,fan-in sub-graph\n   *    - Many child changes because other operators may preserve the child change\n   */\n  switch (fanOutChangeType) {\n    case ChangeType.REMOVE:\n      assert(\n        types.length === 1 && types[0] === ChangeType.REMOVE,\n        'Fan-in:remove expected all removes',\n      );\n      yield* output.push(\n        addEmptyRelationships(must(candidatesToPush.get(ChangeType.REMOVE))),\n        pusher,\n      );\n      return;\n    case ChangeType.ADD:\n      assert(\n        types.length === 1 && types[0] === ChangeType.ADD,\n        'Fan-in:add expected all adds',\n      );\n      yield* output.push(\n        addEmptyRelationships(must(candidatesToPush.get(ChangeType.ADD))),\n        pusher,\n      );\n      return;\n    case ChangeType.EDIT: {\n      assert(\n        types.every(\n          type =>\n            type === ChangeType.ADD ||\n            type === ChangeType.REMOVE ||\n            type === ChangeType.EDIT,\n        ),\n        'Fan-in:edit expected all adds, removes, or edits',\n      );\n      const addChange = candidatesToPush.get(ChangeType.ADD);\n      const removeChange = candidatesToPush.get(ChangeType.REMOVE);\n      let editChange = candidatesToPush.get(ChangeType.EDIT);\n\n      // The row stays downstream (a branch kept the edit, or it moved from\n      // one branch to another). Branches it left take their witnesses with\n      // them; branches it entered bring theirs. An edit syncs one row, so\n      // those must travel as child changes around it.\n      if (isBranchRel && (editChange || (addChange && removeChange))) {\n        if (removeChange) {\n          yield* pushWitnessDeltas(\n            removeChange[ChangeIndex.NODE],\n            ChangeType.REMOVE,\n            isBranchRel,\n            output,\n            pusher,\n          );\n        }\n        const strip = (n: Node): Node => ({\n          row: n.row,\n          relationships: Object.fromEntries(\n            Object.entries(n.relationships).filter(([k]) => !isBranchRel(k)),\n          ),\n        });\n        yield* output.push(\n          addEmptyRelationships(\n            editChange ??\n              makeEditChange(\n                strip(must(addChange)[ChangeIndex.NODE]),\n                strip(must(removeChange)[ChangeIndex.NODE]),\n              ),\n          ),\n          pusher,\n        );\n        if (addChange) {\n          yield* pushWitnessDeltas(\n            addChange[ChangeIndex.NODE],\n            ChangeType.ADD,\n            isBranchRel,\n            output,\n            pusher,\n          );\n        }\n        return;\n      }\n\n      // If an `edit` is present, it supersedes `add` and `remove`\n      // as it semantically represents both.\n      if (editChange) {\n        if (addChange) {\n          editChange = mergeRelationships(editChange, addChange);\n        }\n        if (removeChange) {\n          editChange = mergeRelationships(editChange, removeChange);\n        }\n        yield* output.push(addEmptyRelationships(editChange), pusher);\n        return;\n      }\n\n      // If `edit` didn't make it through but both `add` and `remove` did,\n      // convert back to an edit.\n      //\n      // When can this happen?\n      //\n      //  EDIT old: a=1, new: a=2\n      //            |\n      //          FanOut\n      //          /    \\\n      //         a=1   a=2\n      //          |     |\n      //        remove  add\n      //          \\     /\n      //           FanIn\n      //\n      // The left filter converts the edit into a remove.\n      // The right filter converts the edit into an add.\n      if (addChange && removeChange) {\n        yield* output.push(\n          addEmptyRelationships(\n            makeEditChange(\n              addChange[ChangeIndex.NODE],\n              removeChange[ChangeIndex.NODE],\n            ),\n          ),\n          pusher,\n        );\n        return;\n      }\n\n      yield* output.push(\n        addEmptyRelationships(must(addChange ?? removeChange)),\n        pusher,\n      );\n      return;\n    }\n    case ChangeType.CHILD: {\n      assert(\n        types.every(\n          type =>\n            type === ChangeType.ADD || // exists can change child to add or remove\n            type === ChangeType.REMOVE || // exists can change child to add or remove\n            type === ChangeType.CHILD, // other operators may preserve the child change\n        ),\n        'Fan-in:child expected all adds, removes, or children',\n      );\n      assert(\n        types.length <= 2,\n        'Fan-in:child expected at most 2 types on a child change from fan-out',\n      );\n\n      // If any branch preserved the original child change, that takes precedence over all other changes.\n      const childChange = candidatesToPush.get(ChangeType.CHILD);\n      if (childChange) {\n        const left = candidatesToPush.get(ChangeType.REMOVE);\n        const entered = candidatesToPush.get(ChangeType.ADD);\n        if (isBranchRel && left) {\n          yield* pushWitnessDeltas(\n            left[ChangeIndex.NODE],\n            ChangeType.REMOVE,\n            isBranchRel,\n            output,\n            pusher,\n          );\n        }\n        yield* output.push(childChange, pusher);\n        if (isBranchRel && entered) {\n          yield* pushWitnessDeltas(\n            entered[ChangeIndex.NODE],\n            ChangeType.ADD,\n            isBranchRel,\n            output,\n            pusher,\n          );\n        }\n        return;\n      }\n\n      const addChange = candidatesToPush.get(ChangeType.ADD);\n      const removeChange = candidatesToPush.get(ChangeType.REMOVE);\n\n      assert(\n        addChange === undefined || removeChange === undefined,\n        'Fan-in:child expected either add or remove, not both',\n      );\n\n      yield* output.push(\n        addEmptyRelationships(must(addChange ?? removeChange)),\n        pusher,\n      );\n      return;\n    }\n    default:\n      fanOutChangeType satisfies never;\n  }\n}\n\n/**\n * The row stays downstream, but it gained (`ADD`) or lost (`REMOVE`) every\n * witness in `node`'s branch relationships. One child change per witness.\n */\nexport function* pushWitnessDeltas(\n  node: Node,\n  type: ChangeType.ADD | ChangeType.REMOVE,\n  isBranchRel: (name: string) => boolean,\n  output: Output,\n  pusher: InputBase,\n): Stream<'yield'> {\n  for (const [relationshipName, children] of Object.entries(\n    node.relationships,\n  )) {\n    if (!isBranchRel(relationshipName)) {\n      continue;\n    }\n    for (const child of children()) {\n      if (child === 'yield') {\n        yield child;\n        continue;\n      }\n      yield* output.push(\n        makeChildChange(node, {\n          relationshipName,\n          change:\n            type === ChangeType.ADD\n              ? makeAddChange(child)\n              : makeRemoveChange(child),\n        }),\n        pusher,\n      );\n    }\n  }\n}\n\n/**\n * Puts relationships from `right` into `left` if they don't already exist in `left`.\n */\nexport function mergeRelationships(left: Change, right: Change): Change {\n  // change types will always match\n  // unless we have an edit on the left\n  // then the right could be edit, add, or remove\n  if (left[ChangeIndex.TYPE] === right[ChangeIndex.TYPE]) {\n    switch (left[ChangeIndex.TYPE]) {\n      case ChangeType.ADD: {\n        return makeAddChange({\n          row: left[ChangeIndex.NODE].row,\n          relationships: {\n            ...right[ChangeIndex.NODE].relationships,\n            ...left[ChangeIndex.NODE].relationships,\n          },\n        });\n      }\n      case ChangeType.REMOVE: {\n        return makeRemoveChange({\n          row: left[ChangeIndex.NODE].row,\n          relationships: {\n            ...right[ChangeIndex.NODE].relationships,\n            ...left[ChangeIndex.NODE].relationships,\n          },\n        });\n      }\n      case ChangeType.EDIT: {\n        assert(\n          right[ChangeIndex.TYPE] === ChangeType.EDIT,\n          () =>\n            `mergeRelationships: when left.type is edit and types match, right.type must be edit, got ${right[ChangeIndex.TYPE]}`,\n        );\n        // merge edits into a single edit\n        return makeEditChange(\n          {\n            row: left[ChangeIndex.NODE].row,\n            relationships: {\n              ...right[ChangeIndex.NODE].relationships,\n              ...left[ChangeIndex.NODE].relationships,\n            },\n          },\n          {\n            row: left[ChangeIndex.OLD_NODE].row,\n            relationships: {\n              ...right[ChangeIndex.OLD_NODE].relationships,\n              ...left[ChangeIndex.OLD_NODE].relationships,\n            },\n          },\n        );\n      }\n      case ChangeType.CHILD: {\n        // Multiple branches may preserve the same child change, each adding\n        // different relationships. Merge the relationships, keeping the child\n        // (which should be identical across branches).\n        assert(\n          right[ChangeIndex.TYPE] === ChangeType.CHILD,\n          () =>\n            `mergeRelationships: when left.type is child and types match, right.type must be child, got ${right[ChangeIndex.TYPE]}`,\n        );\n        return makeChildChange(\n          {\n            row: left[ChangeIndex.NODE].row,\n            relationships: {\n              ...right[ChangeIndex.NODE].relationships,\n              ...left[ChangeIndex.NODE].relationships,\n            },\n          },\n          left[ChangeIndex.CHILD_DATA],\n        );\n      }\n    }\n  }\n\n  // left is always an edit here\n  assert(\n    left[ChangeIndex.TYPE] === ChangeType.EDIT,\n    () =>\n      `mergeRelationships: when types differ, left.type must be edit, got left.type=${left[ChangeIndex.TYPE]}, right.type=${right[ChangeIndex.TYPE]}`,\n  );\n  switch (right[ChangeIndex.TYPE]) {\n    case ChangeType.ADD: {\n      return makeEditChange(\n        {\n          ...left[ChangeIndex.NODE],\n          relationships: {\n            ...right[ChangeIndex.NODE].relationships,\n            ...left[ChangeIndex.NODE].relationships,\n          },\n        },\n        left[ChangeIndex.OLD_NODE],\n      );\n    }\n    case ChangeType.REMOVE: {\n      return makeEditChange(left[ChangeIndex.NODE], {\n        ...left[ChangeIndex.OLD_NODE],\n        relationships: {\n          ...right[ChangeIndex.NODE].relationships,\n          ...left[ChangeIndex.OLD_NODE].relationships,\n        },\n      });\n    }\n  }\n\n  unreachable();\n}\n\nexport function makeAddEmptyRelationships(\n  schema: SourceSchema,\n): (change: Change) => Change {\n  return (change: Change): Change => {\n    if (Object.keys(schema.relationships).length === 0) {\n      return change;\n    }\n\n    switch (change[ChangeIndex.TYPE]) {\n      case ChangeType.ADD: {\n        const relationships = {...change[ChangeIndex.NODE].relationships};\n        mergeEmpty(relationships, Object.keys(schema.relationships));\n        return makeAddChange({\n          row: change[ChangeIndex.NODE].row,\n          relationships,\n        });\n      }\n      case ChangeType.REMOVE: {\n        const relationships = {...change[ChangeIndex.NODE].relationships};\n        mergeEmpty(relationships, Object.keys(schema.relationships));\n        return makeRemoveChange({\n          row: change[ChangeIndex.NODE].row,\n          relationships,\n        });\n      }\n      case ChangeType.EDIT: {\n        const nodeRelationships = {...change[ChangeIndex.NODE].relationships};\n        const oldNodeRelationships = {\n          ...change[ChangeIndex.OLD_NODE].relationships,\n        };\n        mergeEmpty(nodeRelationships, Object.keys(schema.relationships));\n        mergeEmpty(oldNodeRelationships, Object.keys(schema.relationships));\n        return makeEditChange(\n          {row: change[ChangeIndex.NODE].row, relationships: nodeRelationships},\n          {\n            row: change[ChangeIndex.OLD_NODE].row,\n            relationships: oldNodeRelationships,\n          },\n        );\n      }\n      case ChangeType.CHILD:\n        return change; // children only have relationships along the path to the change\n    }\n  };\n}\n\n/**\n * For each relationship in `schema` that does not exist\n * in `relationships`, add it with an empty stream.\n *\n * This modifies the `relationships` object in place.\n */\nexport function mergeEmpty(\n  relationships: Record<string, () => Stream<Node | 'yield'>>,\n  relationshipNames: string[],\n) {\n  for (const relName of relationshipNames) {\n    if (relationships[relName] === undefined) {\n      relationships[relName] = () => emptyArray;\n    }\n  }\n}\n"],"mappings":"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"}

package/out/zql/src/ivm/skip.d.ts

@@ -1,7 +1,7 @@
 import type { Row } from '../../../zero-protocol/src/data.ts';
 import { type Change } from './change.ts';
 import type { Node } from './data.ts';
-import { type FetchRequest, type Input, type Operator, type Output } from './operator.ts';
+import { type FetchRequest, type Input, type InputBase, type Operator, type Output } from './operator.ts';
 import type { SourceSchema } from './schema.ts';
 import type { Stream } from './stream.ts';
 export type Bound = {
@@ -20,5 +20,6 @@ export declare class Skip implements Operator {
     setOutput(output: Output): void;
     destroy(): void;
     push(change: Change): Stream<'yield'>;
+    reconcile(_pusher: InputBase): Stream<'yield'>;
 }
 //# sourceMappingURL=skip.d.ts.map

package/out/zql/src/ivm/skip.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"skip.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/skip.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,GAAG,EAAC,MAAM,oCAAoC,CAAC;AAG5D,OAAO,EAEL,KAAK,MAAM,EAGZ,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAa,IAAI,EAAC,MAAM,WAAW,CAAC;AAEhD,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,KAAK,EACV,KAAK,QAAQ,EACb,KAAK,MAAM,EAEZ,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AAExC,MAAM,MAAM,KAAK,GAAG;IAClB,GAAG,EAAE,GAAG,CAAC;IACT,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF;;;GAGG;AACH,qBAAa,IAAK,YAAW,QAAQ;;IAOnC,YAAY,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAOrC;IAED,SAAS,IAAI,YAAY,CAExB;IAEA,KAAK,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC,CAoBhD;IAED,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAE9B;IAED,OAAO,IAAI,IAAI,CAEd;IAOA,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,CAiBrC;CA8DF"}
+{"version":3,"file":"skip.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/skip.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,GAAG,EAAC,MAAM,oCAAoC,CAAC;AAG5D,OAAO,EAEL,KAAK,MAAM,EAGZ,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAa,IAAI,EAAC,MAAM,WAAW,CAAC;AAEhD,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,KAAK,EACV,KAAK,SAAS,EACd,KAAK,QAAQ,EACb,KAAK,MAAM,EAEZ,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AAExC,MAAM,MAAM,KAAK,GAAG;IAClB,GAAG,EAAE,GAAG,CAAC;IACT,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF;;;GAGG;AACH,qBAAa,IAAK,YAAW,QAAQ;;IAOnC,YAAY,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAOrC;IAED,SAAS,IAAI,YAAY,CAExB;IAEA,KAAK,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC,CAoBhD;IAED,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAE9B;IAED,OAAO,IAAI,IAAI,CAEd;IAOA,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,CAiBrC;IAEA,SAAS,CAAC,OAAO,EAAE,SAAS,GAAG,MAAM,CAAC,OAAO,CAAC,CAI9C;CA8DF"}

package/out/zql/src/ivm/skip.js

@@ -60,6 +60,9 @@ var Skip = class {
 		}
 		if (shouldBePresent(change[1].row)) yield* this.#output.push(change, this);
 	}
+	*reconcile(_pusher) {
+		if (this.#output.reconcile) yield* this.#output.reconcile(this);
+	}
 	#getStart(req) {
 		const boundStart = {
 			row: this.#bound.row,

package/out/zql/src/ivm/skip.js.map

@@ -1 +1 @@
-{"version":3,"file":"skip.js","names":["#input","#bound","#comparator","#getStart","#shouldBePresent","#output"],"sources":["../../../../../zql/src/ivm/skip.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport type {Row} from '../../../zero-protocol/src/data.ts';\nimport {ChangeIndex} from './change-index.ts';\nimport {ChangeType} from './change-type.ts';\nimport {\n  type AddChange,\n  type Change,\n  type ChildChange,\n  type RemoveChange,\n} from './change.ts';\nimport type {Comparator, Node} from './data.ts';\nimport {maybeSplitAndPushEditChange} from './maybe-split-and-push-edit-change.ts';\nimport {\n  throwOutput,\n  type FetchRequest,\n  type Input,\n  type Operator,\n  type Output,\n  type Start,\n} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport type {Stream} from './stream.ts';\n\nexport type Bound = {\n  row: Row;\n  exclusive: boolean;\n};\n\n/**\n * Skip sets the start position for the pipeline. No rows before the bound will\n * be output.\n */\nexport class Skip implements Operator {\n  readonly #input: Input;\n  readonly #bound: Bound;\n  readonly #comparator: Comparator;\n\n  #output: Output = throwOutput;\n\n  constructor(input: Input, bound: Bound) {\n    const {sort} = input.getSchema();\n    assert(sort !== undefined, 'Skip requires sorted input');\n    this.#input = input;\n    this.#bound = bound;\n    this.#comparator = input.getSchema().compareRows;\n    input.setOutput(this);\n  }\n\n  getSchema(): SourceSchema {\n    return this.#input.getSchema();\n  }\n\n  *fetch(req: FetchRequest): Stream<Node | 'yield'> {\n    const start = this.#getStart(req);\n    if (start === 'empty') {\n      return;\n    }\n    const nodes = this.#input.fetch({...req, start});\n    if (!req.reverse) {\n      yield* nodes;\n      return;\n    }\n    for (const node of nodes) {\n      if (node === 'yield') {\n        yield node;\n        continue;\n      }\n      if (!this.#shouldBePresent(node.row)) {\n        return;\n      }\n      yield node;\n    }\n  }\n\n  setOutput(output: Output): void {\n    this.#output = output;\n  }\n\n  destroy(): void {\n    this.#input.destroy();\n  }\n\n  #shouldBePresent(row: Row): boolean {\n    const cmp = this.#comparator(this.#bound.row, row);\n    return cmp < 0 || (cmp === 0 && !this.#bound.exclusive);\n  }\n\n  *push(change: Change): Stream<'yield'> {\n    const shouldBePresent = (row: Row) => this.#shouldBePresent(row);\n    if (change[ChangeIndex.TYPE] === ChangeType.EDIT) {\n      yield* maybeSplitAndPushEditChange(\n        change,\n        shouldBePresent,\n        this.#output,\n        this,\n      );\n      return;\n    }\n\n    change satisfies AddChange | RemoveChange | ChildChange;\n\n    if (shouldBePresent(change[ChangeIndex.NODE].row)) {\n      yield* this.#output.push(change, this);\n    }\n  }\n\n  #getStart(req: FetchRequest): Start | undefined | 'empty' {\n    const boundStart = {\n      row: this.#bound.row,\n      basis: this.#bound.exclusive ? 'after' : 'at',\n    } as const;\n\n    if (!req.start) {\n      if (req.reverse) {\n        return undefined;\n      }\n      return boundStart;\n    }\n\n    const cmp = this.#comparator(this.#bound.row, req.start.row);\n\n    if (!req.reverse) {\n      // The skip bound is after the requested bound. The requested bound cannot\n      // be relevant because even if it was basis: 'after', the skip bound is\n      // itself after the requested bound. Return the skip bound.\n      if (cmp > 0) {\n        return boundStart;\n      }\n\n      // The skip bound and requested bound are equal. If either is exclusive,\n      // return that bound with exclusive. Otherwise, return the skip bound.\n      if (cmp === 0) {\n        if (this.#bound.exclusive || req.start.basis === 'after') {\n          return {\n            row: this.#bound.row,\n            basis: 'after',\n          };\n        }\n        return boundStart;\n      }\n\n      return req.start;\n    }\n\n    req.reverse satisfies true;\n\n    // bound is after the start, but request is for reverse so results\n    // must be empty\n    if (cmp > 0) {\n      return 'empty';\n    }\n\n    if (cmp === 0) {\n      // if both are inclusive, the result can be the single row at bound\n      // return it as start\n      if (!this.#bound.exclusive && req.start.basis === 'at') {\n        return boundStart;\n      }\n      // otherwise the results must be empty, one or both are exclusive\n      // in opposite directions\n      return 'empty';\n    }\n\n    // bound is before the start, return start\n    return req.start;\n  }\n}\n"],"mappings":";;;;;;;;AAgCA,IAAa,OAAb,MAAsC;CACpC;CACA;CACA;CAEA,UAAkB;CAElB,YAAY,OAAc,OAAc;EACtC,MAAM,EAAC,SAAQ,MAAM,UAAU;EAC/B,OAAO,SAAS,KAAA,GAAW,4BAA4B;EACvD,KAAKA,SAAS;EACd,KAAKC,SAAS;EACd,KAAKC,cAAc,MAAM,UAAU,EAAE;EACrC,MAAM,UAAU,IAAI;CACtB;CAEA,YAA0B;EACxB,OAAO,KAAKF,OAAO,UAAU;CAC/B;CAEA,CAAC,MAAM,KAA2C;EAChD,MAAM,QAAQ,KAAKG,UAAU,GAAG;EAChC,IAAI,UAAU,SACZ;EAEF,MAAM,QAAQ,KAAKH,OAAO,MAAM;GAAC,GAAG;GAAK;EAAK,CAAC;EAC/C,IAAI,CAAC,IAAI,SAAS;GAChB,OAAO;GACP;EACF;EACA,KAAK,MAAM,QAAQ,OAAO;GACxB,IAAI,SAAS,SAAS;IACpB,MAAM;IACN;GACF;GACA,IAAI,CAAC,KAAKI,iBAAiB,KAAK,GAAG,GACjC;GAEF,MAAM;EACR;CACF;CAEA,UAAU,QAAsB;EAC9B,KAAKC,UAAU;CACjB;CAEA,UAAgB;EACd,KAAKL,OAAO,QAAQ;CACtB;CAEA,iBAAiB,KAAmB;EAClC,MAAM,MAAM,KAAKE,YAAY,KAAKD,OAAO,KAAK,GAAG;EACjD,OAAO,MAAM,KAAM,QAAQ,KAAK,CAAC,KAAKA,OAAO;CAC/C;CAEA,CAAC,KAAK,QAAiC;EACrC,MAAM,mBAAmB,QAAa,KAAKG,iBAAiB,GAAG;EAC/D,IAAI,OAAO,OAAsB,GAAiB;GAChD,OAAO,4BACL,QACA,iBACA,KAAKC,SACL,IACF;GACA;EACF;EAIA,IAAI,gBAAgB,OAAO,GAAkB,GAAG,GAC9C,OAAO,KAAKA,QAAQ,KAAK,QAAQ,IAAI;CAEzC;CAEA,UAAU,KAAgD;EACxD,MAAM,aAAa;GACjB,KAAK,KAAKJ,OAAO;GACjB,OAAO,KAAKA,OAAO,YAAY,UAAU;EAC3C;EAEA,IAAI,CAAC,IAAI,OAAO;GACd,IAAI,IAAI,SACN;GAEF,OAAO;EACT;EAEA,MAAM,MAAM,KAAKC,YAAY,KAAKD,OAAO,KAAK,IAAI,MAAM,GAAG;EAE3D,IAAI,CAAC,IAAI,SAAS;GAIhB,IAAI,MAAM,GACR,OAAO;GAKT,IAAI,QAAQ,GAAG;IACb,IAAI,KAAKA,OAAO,aAAa,IAAI,MAAM,UAAU,SAC/C,OAAO;KACL,KAAK,KAAKA,OAAO;KACjB,OAAO;IACT;IAEF,OAAO;GACT;GAEA,OAAO,IAAI;EACb;EAEA,IAAI;EAIJ,IAAI,MAAM,GACR,OAAO;EAGT,IAAI,QAAQ,GAAG;GAGb,IAAI,CAAC,KAAKA,OAAO,aAAa,IAAI,MAAM,UAAU,MAChD,OAAO;GAIT,OAAO;EACT;EAGA,OAAO,IAAI;CACb;AACF"}
+{"version":3,"file":"skip.js","names":["#input","#bound","#comparator","#getStart","#shouldBePresent","#output"],"sources":["../../../../../zql/src/ivm/skip.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport type {Row} from '../../../zero-protocol/src/data.ts';\nimport {ChangeIndex} from './change-index.ts';\nimport {ChangeType} from './change-type.ts';\nimport {\n  type AddChange,\n  type Change,\n  type ChildChange,\n  type RemoveChange,\n} from './change.ts';\nimport type {Comparator, Node} from './data.ts';\nimport {maybeSplitAndPushEditChange} from './maybe-split-and-push-edit-change.ts';\nimport {\n  throwOutput,\n  type FetchRequest,\n  type Input,\n  type InputBase,\n  type Operator,\n  type Output,\n  type Start,\n} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport type {Stream} from './stream.ts';\n\nexport type Bound = {\n  row: Row;\n  exclusive: boolean;\n};\n\n/**\n * Skip sets the start position for the pipeline. No rows before the bound will\n * be output.\n */\nexport class Skip implements Operator {\n  readonly #input: Input;\n  readonly #bound: Bound;\n  readonly #comparator: Comparator;\n\n  #output: Output = throwOutput;\n\n  constructor(input: Input, bound: Bound) {\n    const {sort} = input.getSchema();\n    assert(sort !== undefined, 'Skip requires sorted input');\n    this.#input = input;\n    this.#bound = bound;\n    this.#comparator = input.getSchema().compareRows;\n    input.setOutput(this);\n  }\n\n  getSchema(): SourceSchema {\n    return this.#input.getSchema();\n  }\n\n  *fetch(req: FetchRequest): Stream<Node | 'yield'> {\n    const start = this.#getStart(req);\n    if (start === 'empty') {\n      return;\n    }\n    const nodes = this.#input.fetch({...req, start});\n    if (!req.reverse) {\n      yield* nodes;\n      return;\n    }\n    for (const node of nodes) {\n      if (node === 'yield') {\n        yield node;\n        continue;\n      }\n      if (!this.#shouldBePresent(node.row)) {\n        return;\n      }\n      yield node;\n    }\n  }\n\n  setOutput(output: Output): void {\n    this.#output = output;\n  }\n\n  destroy(): void {\n    this.#input.destroy();\n  }\n\n  #shouldBePresent(row: Row): boolean {\n    const cmp = this.#comparator(this.#bound.row, row);\n    return cmp < 0 || (cmp === 0 && !this.#bound.exclusive);\n  }\n\n  *push(change: Change): Stream<'yield'> {\n    const shouldBePresent = (row: Row) => this.#shouldBePresent(row);\n    if (change[ChangeIndex.TYPE] === ChangeType.EDIT) {\n      yield* maybeSplitAndPushEditChange(\n        change,\n        shouldBePresent,\n        this.#output,\n        this,\n      );\n      return;\n    }\n\n    change satisfies AddChange | RemoveChange | ChildChange;\n\n    if (shouldBePresent(change[ChangeIndex.NODE].row)) {\n      yield* this.#output.push(change, this);\n    }\n  }\n\n  *reconcile(_pusher: InputBase): Stream<'yield'> {\n    if (this.#output.reconcile) {\n      yield* this.#output.reconcile(this);\n    }\n  }\n\n  #getStart(req: FetchRequest): Start | undefined | 'empty' {\n    const boundStart = {\n      row: this.#bound.row,\n      basis: this.#bound.exclusive ? 'after' : 'at',\n    } as const;\n\n    if (!req.start) {\n      if (req.reverse) {\n        return undefined;\n      }\n      return boundStart;\n    }\n\n    const cmp = this.#comparator(this.#bound.row, req.start.row);\n\n    if (!req.reverse) {\n      // The skip bound is after the requested bound. The requested bound cannot\n      // be relevant because even if it was basis: 'after', the skip bound is\n      // itself after the requested bound. Return the skip bound.\n      if (cmp > 0) {\n        return boundStart;\n      }\n\n      // The skip bound and requested bound are equal. If either is exclusive,\n      // return that bound with exclusive. Otherwise, return the skip bound.\n      if (cmp === 0) {\n        if (this.#bound.exclusive || req.start.basis === 'after') {\n          return {\n            row: this.#bound.row,\n            basis: 'after',\n          };\n        }\n        return boundStart;\n      }\n\n      return req.start;\n    }\n\n    req.reverse satisfies true;\n\n    // bound is after the start, but request is for reverse so results\n    // must be empty\n    if (cmp > 0) {\n      return 'empty';\n    }\n\n    if (cmp === 0) {\n      // if both are inclusive, the result can be the single row at bound\n      // return it as start\n      if (!this.#bound.exclusive && req.start.basis === 'at') {\n        return boundStart;\n      }\n      // otherwise the results must be empty, one or both are exclusive\n      // in opposite directions\n      return 'empty';\n    }\n\n    // bound is before the start, return start\n    return req.start;\n  }\n}\n"],"mappings":";;;;;;;;AAiCA,IAAa,OAAb,MAAsC;CACpC;CACA;CACA;CAEA,UAAkB;CAElB,YAAY,OAAc,OAAc;EACtC,MAAM,EAAC,SAAQ,MAAM,UAAU;EAC/B,OAAO,SAAS,KAAA,GAAW,4BAA4B;EACvD,KAAKA,SAAS;EACd,KAAKC,SAAS;EACd,KAAKC,cAAc,MAAM,UAAU,EAAE;EACrC,MAAM,UAAU,IAAI;CACtB;CAEA,YAA0B;EACxB,OAAO,KAAKF,OAAO,UAAU;CAC/B;CAEA,CAAC,MAAM,KAA2C;EAChD,MAAM,QAAQ,KAAKG,UAAU,GAAG;EAChC,IAAI,UAAU,SACZ;EAEF,MAAM,QAAQ,KAAKH,OAAO,MAAM;GAAC,GAAG;GAAK;EAAK,CAAC;EAC/C,IAAI,CAAC,IAAI,SAAS;GAChB,OAAO;GACP;EACF;EACA,KAAK,MAAM,QAAQ,OAAO;GACxB,IAAI,SAAS,SAAS;IACpB,MAAM;IACN;GACF;GACA,IAAI,CAAC,KAAKI,iBAAiB,KAAK,GAAG,GACjC;GAEF,MAAM;EACR;CACF;CAEA,UAAU,QAAsB;EAC9B,KAAKC,UAAU;CACjB;CAEA,UAAgB;EACd,KAAKL,OAAO,QAAQ;CACtB;CAEA,iBAAiB,KAAmB;EAClC,MAAM,MAAM,KAAKE,YAAY,KAAKD,OAAO,KAAK,GAAG;EACjD,OAAO,MAAM,KAAM,QAAQ,KAAK,CAAC,KAAKA,OAAO;CAC/C;CAEA,CAAC,KAAK,QAAiC;EACrC,MAAM,mBAAmB,QAAa,KAAKG,iBAAiB,GAAG;EAC/D,IAAI,OAAO,OAAsB,GAAiB;GAChD,OAAO,4BACL,QACA,iBACA,KAAKC,SACL,IACF;GACA;EACF;EAIA,IAAI,gBAAgB,OAAO,GAAkB,GAAG,GAC9C,OAAO,KAAKA,QAAQ,KAAK,QAAQ,IAAI;CAEzC;CAEA,CAAC,UAAU,SAAqC;EAC9C,IAAI,KAAKA,QAAQ,WACf,OAAO,KAAKA,QAAQ,UAAU,IAAI;CAEtC;CAEA,UAAU,KAAgD;EACxD,MAAM,aAAa;GACjB,KAAK,KAAKJ,OAAO;GACjB,OAAO,KAAKA,OAAO,YAAY,UAAU;EAC3C;EAEA,IAAI,CAAC,IAAI,OAAO;GACd,IAAI,IAAI,SACN;GAEF,OAAO;EACT;EAEA,MAAM,MAAM,KAAKC,YAAY,KAAKD,OAAO,KAAK,IAAI,MAAM,GAAG;EAE3D,IAAI,CAAC,IAAI,SAAS;GAIhB,IAAI,MAAM,GACR,OAAO;GAKT,IAAI,QAAQ,GAAG;IACb,IAAI,KAAKA,OAAO,aAAa,IAAI,MAAM,UAAU,SAC/C,OAAO;KACL,KAAK,KAAKA,OAAO;KACjB,OAAO;IACT;IAEF,OAAO;GACT;GAEA,OAAO,IAAI;EACb;EAEA,IAAI;EAIJ,IAAI,MAAM,GACR,OAAO;EAGT,IAAI,QAAQ,GAAG;GAGb,IAAI,CAAC,KAAKA,OAAO,aAAa,IAAI,MAAM,UAAU,MAChD,OAAO;GAIT,OAAO;EACT;EAGA,OAAO,IAAI;CACb;AACF"}

package/out/zql/src/ivm/take-gate.d.ts

@@ -0,0 +1,57 @@
+import type { Row } from '../../../zero-protocol/src/data.ts';
+import type { Change } from './change.ts';
+import { type Constraint } from './constraint.ts';
+import type { Comparator, Node } from './data.ts';
+import { type FetchRequest, type Input, type InputBase, type Operator, type Output } from './operator.ts';
+import type { SourceSchema } from './schema.ts';
+import type { Stream } from './stream.ts';
+export interface TakeBoundProvider {
+    getBound(constraint?: Constraint): Row | undefined;
+}
+/**
+ * The bound that a TakeGate caps one parent fetch of a join's child push at.
+ * `undefined` means the fetch is not capped.
+ */
+export type ParentFetchBound = {
+    readonly constraint: Constraint;
+    readonly bound: Row | undefined;
+};
+/**
+ * Reads the bounds for the parent fetches of a child push before the join
+ * starts them. TakeGate reads its bound once, when a fetch starts, so the set
+ * of parents that get the push stays fixed even when Take moves its bound
+ * during the push. Split-push overlays must use these bounds, not the bound
+ * Take reports later in the push.
+ */
+export declare function readParentFetchBounds(boundProvider: TakeBoundProvider, constraints: readonly Constraint[]): ParentFetchBound[];
+/**
+ * Returns true if one of the parent fetches of the push yields `row`: `row`
+ * matches the fetch's constraint and is not after the fetch's bound.
+ */
+export declare function isInParentFetch(bounds: readonly ParentFetchBound[], row: Row, compareRows: Comparator): boolean;
+/**
+ * TakeGate bounds upstream parent fetches using the active bound from a
+ * downstream Take operator.
+ *
+ * When a child table changes, joins fetch matching parent rows. Without
+ * TakeGate, this fetch scans all matching parent rows (which may be thousands)
+ * even if downstream Take only needs a few. TakeGate intercepts this fetch and
+ * stops the upstream stream once rows exceed Take's bound.
+ */
+export declare class TakeGate implements Operator, TakeBoundProvider {
+    #private;
+    constructor(input: Input);
+    open(): void;
+    close(): void;
+    isOpen(): boolean;
+    setBoundProvider(provider: TakeBoundProvider): void;
+    getBoundProvider(): TakeBoundProvider | undefined;
+    getBound(constraint?: Constraint): Row | undefined;
+    getSchema(): SourceSchema;
+    setOutput(output: Output): void;
+    destroy(): void;
+    push(change: Change, _pusher: InputBase): Stream<'yield'>;
+    reconcile(_pusher: InputBase): Stream<'yield'>;
+    fetch(req: FetchRequest): Stream<Node | 'yield'>;
+}
+//# sourceMappingURL=take-gate.d.ts.map

package/out/zql/src/ivm/take-gate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"take-gate.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/take-gate.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,GAAG,EAAC,MAAM,oCAAoC,CAAC;AAC5D,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AACxC,OAAO,EAAuB,KAAK,UAAU,EAAC,MAAM,iBAAiB,CAAC;AACtE,OAAO,KAAK,EAAC,UAAU,EAAE,IAAI,EAAC,MAAM,WAAW,CAAC;AAChD,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,KAAK,EACV,KAAK,SAAS,EACd,KAAK,QAAQ,EACb,KAAK,MAAM,EACZ,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AAExC,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,UAAU,CAAC,EAAE,UAAU,GAAG,GAAG,GAAG,SAAS,CAAC;CACpD;AAED;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC,QAAQ,CAAC,KAAK,EAAE,GAAG,GAAG,SAAS,CAAC;CACjC,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,aAAa,EAAE,iBAAiB,EAChC,WAAW,EAAE,SAAS,UAAU,EAAE,GACjC,gBAAgB,EAAE,CAKpB;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,SAAS,gBAAgB,EAAE,EACnC,GAAG,EAAE,GAAG,EACR,WAAW,EAAE,UAAU,GACtB,OAAO,CAOT;AAED;;;;;;;;GAQG;AACH,qBAAa,QAAS,YAAW,QAAQ,EAAE,iBAAiB;;IAO1D,YAAY,KAAK,EAAE,KAAK,EAMvB;IAED,IAAI,IAAI,IAAI,CAEX;IAED,KAAK,IAAI,IAAI,CAGZ;IAED,MAAM,IAAI,OAAO,CAEhB;IAED,gBAAgB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,IAAI,CAElD;IAED,gBAAgB,IAAI,iBAAiB,GAAG,SAAS,CAEhD;IAED,QAAQ,CAAC,UAAU,CAAC,EAAE,UAAU,GAAG,GAAG,GAAG,SAAS,CAKjD;IAED,SAAS,IAAI,YAAY,CAExB;IAED,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAE9B;IAED,OAAO,IAAI,IAAI,CAEd;IAEA,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,GAAG,MAAM,CAAC,OAAO,CAAC,CAEzD;IAEA,SAAS,CAAC,OAAO,EAAE,SAAS,GAAG,MAAM,CAAC,OAAO,CAAC,CAI9C;IAEA,KAAK,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC,CAsBhD;CACF"}