@rocicorp/zero 1.10.0-canary.24 → 1.10.0-canary.26

package/out/zql/src/ivm/connection-index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"connection-index.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/connection-index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,GAAG,EAAE,KAAK,EAAC,MAAM,oCAAoC,CAAC;AACnE,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,sBAAsB,CAAC;AAG9D,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAE9C;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,CAAC;CACnC,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,eAAe,CAAC,CAAC;;IAM5B,GAAG,CAAC,UAAU,EAAE,CAAC,EAAE,OAAO,EAAE,mBAAmB,GAAG,SAAS,GAAG,IAAI;IAwBlE,MAAM,CAAC,UAAU,EAAE,CAAC,GAAG,IAAI;IA8B3B,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;;;OAIG;IACH,SAAS,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO;IAY5B;;;;OAIG;IACH,eAAe,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO;CAS/C;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,mBAAmB,GAAG,SAAS,GACzC,gBAAgB,GAAG,SAAS,CA4D9B"}

package/out/zql/src/ivm/connection-index.js

@@ -1,149 +0,0 @@
-//#region ../zql/src/ivm/connection-index.ts
-/**
-* Indexes the connections of a source by a static equality constraint
-* (`column = literal` or `column IN (literals)`) taken from each
-* connection's filters, so that a push can determine in O(distinct indexed
-* columns) whether any connection could possibly accept a row, before doing
-* any per-connection work.
-*
-* The index is conservative: {@link mayAccept} returns `true` whenever a
-* connection's filters could accept the row, and may return `true` when they
-* do not (e.g. the connection has further conditions that reject it).
-* It only ever returns `false` when every connection's filters reject the
-* row. Connections without a static equality constraint (no filters, or
-* filters whose top level is not an equality) count as unconstrained and
-* make every row a candidate, as does an index with no connections at all.
-*
-* Values are matched with SameValueZero (`Map` key semantics), which agrees
-* with the `=` / `IN` predicates (`===` / `Set#has`) for every value except
-* `NaN`, where the index is merely more permissive.
-*/
-var ConnectionIndex = class {
-	#byColumn = /* @__PURE__ */ new Map();
-	#constraints = /* @__PURE__ */ new Map();
-	#unconstrained = 0;
-	add(connection, filters) {
-		if (this.#constraints.has(connection)) throw new Error("connection is already indexed");
-		const constraint = staticConstraint(filters);
-		this.#constraints.set(connection, constraint);
-		if (!constraint) {
-			this.#unconstrained++;
-			return;
-		}
-		if (constraint.values.length === 0) return;
-		let byValue = this.#byColumn.get(constraint.column);
-		if (!byValue) {
-			byValue = /* @__PURE__ */ new Map();
-			this.#byColumn.set(constraint.column, byValue);
-		}
-		for (const value of constraint.values) byValue.set(value, (byValue.get(value) ?? 0) + 1);
-	}
-	remove(connection) {
-		if (!this.#constraints.has(connection)) throw new Error("connection is not indexed");
-		const constraint = this.#constraints.get(connection);
-		this.#constraints.delete(connection);
-		if (!constraint) {
-			this.#unconstrained--;
-			return;
-		}
-		if (constraint.values.length === 0) return;
-		const byValue = this.#byColumn.get(constraint.column);
-		if (!byValue) throw new Error(`no index for column ${constraint.column}`);
-		for (const value of constraint.values) {
-			const count = byValue.get(value) ?? 0;
-			if (count <= 1) byValue.delete(value);
-			else byValue.set(value, count - 1);
-		}
-		if (byValue.size === 0) this.#byColumn.delete(constraint.column);
-	}
-	get size() {
-		return this.#constraints.size;
-	}
-	/**
-	* Returns `false` only if the filters of every indexed connection reject
-	* `row`. An empty index accepts every row: a source with no connections
-	* is still written to (e.g. to populate it).
-	*/
-	mayAccept(row) {
-		if (this.#unconstrained > 0 || this.#constraints.size === 0) return true;
-		for (const [column, byValue] of this.#byColumn) if (byValue.has(row[column])) return true;
-		return false;
-	}
-	/**
-	* Returns `false` only if the filters of every indexed connection reject
-	* the row(s) of `change`: the row for an add or remove, and both the old
-	* and the new row for an edit.
-	*/
-	mayAcceptChange(change) {
-		if (this.mayAccept(change[1])) return true;
-		return change[0] === 2 && this.mayAccept(change[2]);
-	}
-};
-/**
-* Extracts a static equality constraint that every row accepted by
-* `condition` must satisfy, or `undefined` if there is none.
-*
-* - `column = literal`, `column IS literal` and `column IN (literals)`
-*   constrain the column. `column = null` (which the predicate folds to
-*   `false`) and an empty `IN` constrain it to the empty set, i.e. the
-*   connection never accepts a row.
-* - An `and` is constrained by any of its constrained conditions; the one
-*   with the fewest values is chosen, so a never-matching condition wins.
-* - An `or` is constrained only if all of its branches constrain the same
-*   column, by the union of their values. Never-matching branches cannot
-*   widen the result and are ignored.
-* - Anything else (`!=`, `IS NOT`, `NOT IN`, ranges, `LIKE`, a literal on
-*   the left) is unconstrained.
-*/
-function staticConstraint(condition) {
-	if (!condition) return;
-	switch (condition.type) {
-		case "simple": {
-			const { left, right, op } = condition;
-			if (left.type !== "column" || right.type !== "literal") return;
-			switch (op) {
-				case "=": return {
-					column: left.name,
-					values: right.value === null ? [] : [right.value]
-				};
-				case "IS": return {
-					column: left.name,
-					values: [right.value]
-				};
-				case "IN": return Array.isArray(right.value) ? {
-					column: left.name,
-					values: right.value
-				} : void 0;
-				default: return;
-			}
-		}
-		case "and": {
-			let best;
-			for (const c of condition.conditions) {
-				const constraint = staticConstraint(c);
-				if (constraint && (!best || constraint.values.length < best.values.length)) best = constraint;
-			}
-			return best;
-		}
-		case "or": {
-			let column;
-			const values = [];
-			for (const c of condition.conditions) {
-				const constraint = staticConstraint(c);
-				if (!constraint) return;
-				if (constraint.values.length === 0) continue;
-				if (column !== void 0 && constraint.column !== column) return;
-				column = constraint.column;
-				values.push(...constraint.values);
-			}
-			return {
-				column: column ?? "",
-				values
-			};
-		}
-	}
-}
-//#endregion
-export { ConnectionIndex };
-
-//# sourceMappingURL=connection-index.js.map

package/out/zql/src/ivm/connection-index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"connection-index.js","names":["#byColumn","#constraints","#unconstrained"],"sources":["../../../../../zql/src/ivm/connection-index.ts"],"sourcesContent":["import type {Row, Value} from '../../../zero-protocol/src/data.ts';\nimport type {NoSubqueryCondition} from '../builder/filter.ts';\nimport {ChangeType} from './change-type.ts';\nimport {SourceChangeIndex} from './source-change-index.ts';\nimport type {SourceChange} from './source.ts';\n\n/**\n * The static equality constraint a connection's filters place on a single\n * column: the row is accepted only if `row[column]` is one of `values`.\n * The push-time counterpart of the fetch-time `Constraint` in\n * `constraint.ts`, which pins columns to single values.\n */\nexport type StaticConstraint = {\n  readonly column: string;\n  readonly values: readonly Value[];\n};\n\n/**\n * Indexes the connections of a source by a static equality constraint\n * (`column = literal` or `column IN (literals)`) taken from each\n * connection's filters, so that a push can determine in O(distinct indexed\n * columns) whether any connection could possibly accept a row, before doing\n * any per-connection work.\n *\n * The index is conservative: {@link mayAccept} returns `true` whenever a\n * connection's filters could accept the row, and may return `true` when they\n * do not (e.g. the connection has further conditions that reject it).\n * It only ever returns `false` when every connection's filters reject the\n * row. Connections without a static equality constraint (no filters, or\n * filters whose top level is not an equality) count as unconstrained and\n * make every row a candidate, as does an index with no connections at all.\n *\n * Values are matched with SameValueZero (`Map` key semantics), which agrees\n * with the `=` / `IN` predicates (`===` / `Set#has`) for every value except\n * `NaN`, where the index is merely more permissive.\n */\nexport class ConnectionIndex<C> {\n  // column -> value -> number of connections constrained to that value.\n  readonly #byColumn = new Map<string, Map<Value, number>>();\n  readonly #constraints = new Map<C, StaticConstraint | undefined>();\n  #unconstrained = 0;\n\n  add(connection: C, filters: NoSubqueryCondition | undefined): void {\n    if (this.#constraints.has(connection)) {\n      throw new Error('connection is already indexed');\n    }\n    const constraint = staticConstraint(filters);\n    this.#constraints.set(connection, constraint);\n    if (!constraint) {\n      this.#unconstrained++;\n      return;\n    }\n    if (constraint.values.length === 0) {\n      // Never matches: indexed nowhere, so it is never a candidate.\n      return;\n    }\n    let byValue = this.#byColumn.get(constraint.column);\n    if (!byValue) {\n      byValue = new Map();\n      this.#byColumn.set(constraint.column, byValue);\n    }\n    for (const value of constraint.values) {\n      byValue.set(value, (byValue.get(value) ?? 0) + 1);\n    }\n  }\n\n  remove(connection: C): void {\n    if (!this.#constraints.has(connection)) {\n      throw new Error('connection is not indexed');\n    }\n    const constraint = this.#constraints.get(connection);\n    this.#constraints.delete(connection);\n    if (!constraint) {\n      this.#unconstrained--;\n      return;\n    }\n    if (constraint.values.length === 0) {\n      return;\n    }\n    const byValue = this.#byColumn.get(constraint.column);\n    if (!byValue) {\n      throw new Error(`no index for column ${constraint.column}`);\n    }\n    for (const value of constraint.values) {\n      const count = byValue.get(value) ?? 0;\n      if (count <= 1) {\n        byValue.delete(value);\n      } else {\n        byValue.set(value, count - 1);\n      }\n    }\n    if (byValue.size === 0) {\n      this.#byColumn.delete(constraint.column);\n    }\n  }\n\n  get size(): number {\n    return this.#constraints.size;\n  }\n\n  /**\n   * Returns `false` only if the filters of every indexed connection reject\n   * `row`. An empty index accepts every row: a source with no connections\n   * is still written to (e.g. to populate it).\n   */\n  mayAccept(row: Row): boolean {\n    if (this.#unconstrained > 0 || this.#constraints.size === 0) {\n      return true;\n    }\n    for (const [column, byValue] of this.#byColumn) {\n      if (byValue.has(row[column])) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Returns `false` only if the filters of every indexed connection reject\n   * the row(s) of `change`: the row for an add or remove, and both the old\n   * and the new row for an edit.\n   */\n  mayAcceptChange(change: SourceChange): boolean {\n    if (this.mayAccept(change[SourceChangeIndex.ROW])) {\n      return true;\n    }\n    return (\n      change[SourceChangeIndex.TYPE] === ChangeType.EDIT &&\n      this.mayAccept(change[SourceChangeIndex.OLD_ROW])\n    );\n  }\n}\n\n/**\n * Extracts a static equality constraint that every row accepted by\n * `condition` must satisfy, or `undefined` if there is none.\n *\n * - `column = literal`, `column IS literal` and `column IN (literals)`\n *   constrain the column. `column = null` (which the predicate folds to\n *   `false`) and an empty `IN` constrain it to the empty set, i.e. the\n *   connection never accepts a row.\n * - An `and` is constrained by any of its constrained conditions; the one\n *   with the fewest values is chosen, so a never-matching condition wins.\n * - An `or` is constrained only if all of its branches constrain the same\n *   column, by the union of their values. Never-matching branches cannot\n *   widen the result and are ignored.\n * - Anything else (`!=`, `IS NOT`, `NOT IN`, ranges, `LIKE`, a literal on\n *   the left) is unconstrained.\n */\nexport function staticConstraint(\n  condition: NoSubqueryCondition | undefined,\n): StaticConstraint | undefined {\n  if (!condition) {\n    return undefined;\n  }\n  switch (condition.type) {\n    case 'simple': {\n      const {left, right, op} = condition;\n      if (left.type !== 'column' || right.type !== 'literal') {\n        return undefined;\n      }\n      switch (op) {\n        case '=':\n          return {\n            column: left.name,\n            values: right.value === null ? [] : [right.value],\n          };\n        case 'IS':\n          return {column: left.name, values: [right.value]};\n        case 'IN':\n          return Array.isArray(right.value)\n            ? {column: left.name, values: right.value}\n            : undefined;\n        default:\n          return undefined;\n      }\n    }\n    case 'and': {\n      let best: StaticConstraint | undefined;\n      for (const c of condition.conditions) {\n        const constraint = staticConstraint(c);\n        if (\n          constraint &&\n          (!best || constraint.values.length < best.values.length)\n        ) {\n          best = constraint;\n        }\n      }\n      return best;\n    }\n    case 'or': {\n      let column: string | undefined;\n      const values: Value[] = [];\n      for (const c of condition.conditions) {\n        const constraint = staticConstraint(c);\n        if (!constraint) {\n          return undefined;\n        }\n        if (constraint.values.length === 0) {\n          continue; // a never-matching branch cannot widen the result\n        }\n        if (column !== undefined && constraint.column !== column) {\n          return undefined;\n        }\n        column = constraint.column;\n        values.push(...constraint.values);\n      }\n      // Every branch never matches: the whole `or` never matches.\n      return {column: column ?? '', values};\n    }\n  }\n}\n"],"mappings":"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"}

package/out/zql/src/ivm/deferred-input.d.ts

@@ -1,44 +0,0 @@
-import type { Node } from './data.ts';
-import type { FetchRequest, Input, Output } from './operator.ts';
-import type { SourceSchema } from './schema.ts';
-import { type Stream } from './stream.ts';
-/**
- * A placeholder `Input` for a view whose pipeline has not been built yet.
- *
- * Until {@link attach} is called it behaves like an empty pipeline: `fetch`
- * yields nothing and pushes never happen. When the real pipeline is attached
- * the view is hydrated with a single `fetch`, whose rows are delivered to the
- * view as add changes, so the view sees the data exactly as it would see rows
- * arriving incrementally.
- *
- * This lets `materialize()` stay synchronous and return a view immediately
- * while the expensive pipeline construction and hydration are postponed, for
- * example until the client's replica has been loaded into the IVM sources.
- */
-export declare class DeferredInput implements Input {
-    #private;
-    /**
-     * @param schema The schema the built pipeline reports. Passed in so this
-     *   input can answer `getSchema()` unconditionally, as the `Input` contract
-     *   requires, before its pipeline exists.
-     * @param build Builds the real pipeline. Called once, from {@link attach}.
-     */
-    constructor(schema: SourceSchema, build: () => Input);
-    get attached(): boolean;
-    get destroyed(): boolean;
-    setOutput(output: Output): void;
-    getSchema(): SourceSchema;
-    fetch(req: FetchRequest): Stream<Node | 'yield'>;
-    destroy(): void;
-    /**
-     * Build the real pipeline and hydrate the output with its current contents.
-     *
-     * Must be called inside the delegate's `batchViewUpdates`; the delegate is
-     * responsible for notifying commit listeners afterwards so views flush.
-     *
-     * If building or hydrating throws, the pipeline is torn down again and this
-     * input stays unattached so the caller can report the failure.
-     */
-    attach(): void;
-}
-//# sourceMappingURL=deferred-input.d.ts.map

package/out/zql/src/ivm/deferred-input.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"deferred-input.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/deferred-input.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,WAAW,CAAC;AACpC,OAAO,KAAK,EAAC,YAAY,EAAE,KAAK,EAAE,MAAM,EAAC,MAAM,eAAe,CAAC;AAC/D,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAU,KAAK,MAAM,EAAC,MAAM,aAAa,CAAC;AAEjD;;;;;;;;;;;;GAYG;AACH,qBAAa,aAAc,YAAW,KAAK;;IAOzC;;;;;OAKG;gBACS,MAAM,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,KAAK;IAKpD,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAED,IAAI,SAAS,IAAI,OAAO,CAEvB;IAED,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAK/B,SAAS,IAAI,YAAY;IAIzB,KAAK,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC;IAIhD,OAAO,IAAI,IAAI;IAKf;;;;;;;;OAQG;IACH,MAAM,IAAI,IAAI;CAwBf"}

package/out/zql/src/ivm/deferred-input.js

@@ -1,89 +0,0 @@
-import { assert } from "../../../shared/src/asserts.js";
-import { emptyArray } from "../../../shared/src/sentinels.js";
-import { makeAddChange } from "./change.js";
-import { consume } from "./stream.js";
-//#region ../zql/src/ivm/deferred-input.ts
-/**
-* A placeholder `Input` for a view whose pipeline has not been built yet.
-*
-* Until {@link attach} is called it behaves like an empty pipeline: `fetch`
-* yields nothing and pushes never happen. When the real pipeline is attached
-* the view is hydrated with a single `fetch`, whose rows are delivered to the
-* view as add changes, so the view sees the data exactly as it would see rows
-* arriving incrementally.
-*
-* This lets `materialize()` stay synchronous and return a view immediately
-* while the expensive pipeline construction and hydration are postponed, for
-* example until the client's replica has been loaded into the IVM sources.
-*/
-var DeferredInput = class {
-	#schema;
-	#build;
-	#output;
-	#input;
-	#destroyed = false;
-	/**
-	* @param schema The schema the built pipeline reports. Passed in so this
-	*   input can answer `getSchema()` unconditionally, as the `Input` contract
-	*   requires, before its pipeline exists.
-	* @param build Builds the real pipeline. Called once, from {@link attach}.
-	*/
-	constructor(schema, build) {
-		this.#schema = schema;
-		this.#build = build;
-	}
-	get attached() {
-		return this.#input !== void 0;
-	}
-	get destroyed() {
-		return this.#destroyed;
-	}
-	setOutput(output) {
-		this.#output = output;
-		this.#input?.setOutput(output);
-	}
-	getSchema() {
-		return this.#schema;
-	}
-	fetch(req) {
-		return this.#input ? this.#input.fetch(req) : emptyArray;
-	}
-	destroy() {
-		this.#destroyed = true;
-		this.#input?.destroy();
-	}
-	/**
-	* Build the real pipeline and hydrate the output with its current contents.
-	*
-	* Must be called inside the delegate's `batchViewUpdates`; the delegate is
-	* responsible for notifying commit listeners afterwards so views flush.
-	*
-	* If building or hydrating throws, the pipeline is torn down again and this
-	* input stays unattached so the caller can report the failure.
-	*/
-	attach() {
-		assert(!this.#input, "DeferredInput: pipeline already attached");
-		assert(!this.#destroyed, "DeferredInput: cannot attach after destroy");
-		const input = this.#build();
-		const output = this.#output;
-		if (!output) {
-			this.#input = input;
-			return;
-		}
-		try {
-			input.setOutput(output);
-			for (const node of input.fetch({})) {
-				if (node === "yield") continue;
-				consume(output.push(makeAddChange(node), input));
-			}
-		} catch (e) {
-			input.destroy();
-			throw e;
-		}
-		this.#input = input;
-	}
-};
-//#endregion
-export { DeferredInput };
-
-//# sourceMappingURL=deferred-input.js.map

package/out/zql/src/ivm/deferred-input.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"deferred-input.js","names":["#schema","#build","#input","#destroyed","#output"],"sources":["../../../../../zql/src/ivm/deferred-input.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport {emptyArray} from '../../../shared/src/sentinels.ts';\nimport {makeAddChange} from './change.ts';\nimport type {Node} from './data.ts';\nimport type {FetchRequest, Input, Output} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport {consume, type Stream} from './stream.ts';\n\n/**\n * A placeholder `Input` for a view whose pipeline has not been built yet.\n *\n * Until {@link attach} is called it behaves like an empty pipeline: `fetch`\n * yields nothing and pushes never happen. When the real pipeline is attached\n * the view is hydrated with a single `fetch`, whose rows are delivered to the\n * view as add changes, so the view sees the data exactly as it would see rows\n * arriving incrementally.\n *\n * This lets `materialize()` stay synchronous and return a view immediately\n * while the expensive pipeline construction and hydration are postponed, for\n * example until the client's replica has been loaded into the IVM sources.\n */\nexport class DeferredInput implements Input {\n  readonly #schema: SourceSchema;\n  readonly #build: () => Input;\n  #output: Output | undefined;\n  #input: Input | undefined;\n  #destroyed = false;\n\n  /**\n   * @param schema The schema the built pipeline reports. Passed in so this\n   *   input can answer `getSchema()` unconditionally, as the `Input` contract\n   *   requires, before its pipeline exists.\n   * @param build Builds the real pipeline. Called once, from {@link attach}.\n   */\n  constructor(schema: SourceSchema, build: () => Input) {\n    this.#schema = schema;\n    this.#build = build;\n  }\n\n  get attached(): boolean {\n    return this.#input !== undefined;\n  }\n\n  get destroyed(): boolean {\n    return this.#destroyed;\n  }\n\n  setOutput(output: Output): void {\n    this.#output = output;\n    this.#input?.setOutput(output);\n  }\n\n  getSchema(): SourceSchema {\n    return this.#schema;\n  }\n\n  fetch(req: FetchRequest): Stream<Node | 'yield'> {\n    return this.#input ? this.#input.fetch(req) : emptyArray;\n  }\n\n  destroy(): void {\n    this.#destroyed = true;\n    this.#input?.destroy();\n  }\n\n  /**\n   * Build the real pipeline and hydrate the output with its current contents.\n   *\n   * Must be called inside the delegate's `batchViewUpdates`; the delegate is\n   * responsible for notifying commit listeners afterwards so views flush.\n   *\n   * If building or hydrating throws, the pipeline is torn down again and this\n   * input stays unattached so the caller can report the failure.\n   */\n  attach(): void {\n    assert(!this.#input, 'DeferredInput: pipeline already attached');\n    assert(!this.#destroyed, 'DeferredInput: cannot attach after destroy');\n    const input = this.#build();\n    const output = this.#output;\n    if (!output) {\n      // The view never asked for output; there is nothing to hydrate.\n      this.#input = input;\n      return;\n    }\n    try {\n      input.setOutput(output);\n      for (const node of input.fetch({})) {\n        if (node === 'yield') {\n          continue;\n        }\n        consume(output.push(makeAddChange(node), input));\n      }\n    } catch (e) {\n      input.destroy();\n      throw e;\n    }\n    this.#input = input;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAqBA,IAAa,gBAAb,MAA4C;CAC1C;CACA;CACA;CACA;CACA,aAAa;;;;;;;CAQb,YAAY,QAAsB,OAAoB;EACpD,KAAKA,UAAU;EACf,KAAKC,SAAS;CAChB;CAEA,IAAI,WAAoB;EACtB,OAAO,KAAKC,WAAW,KAAA;CACzB;CAEA,IAAI,YAAqB;EACvB,OAAO,KAAKC;CACd;CAEA,UAAU,QAAsB;EAC9B,KAAKC,UAAU;EACf,KAAKF,QAAQ,UAAU,MAAM;CAC/B;CAEA,YAA0B;EACxB,OAAO,KAAKF;CACd;CAEA,MAAM,KAA2C;EAC/C,OAAO,KAAKE,SAAS,KAAKA,OAAO,MAAM,GAAG,IAAI;CAChD;CAEA,UAAgB;EACd,KAAKC,aAAa;EAClB,KAAKD,QAAQ,QAAQ;CACvB;;;;;;;;;;CAWA,SAAe;EACb,OAAO,CAAC,KAAKA,QAAQ,0CAA0C;EAC/D,OAAO,CAAC,KAAKC,YAAY,4CAA4C;EACrE,MAAM,QAAQ,KAAKF,OAAO;EAC1B,MAAM,SAAS,KAAKG;EACpB,IAAI,CAAC,QAAQ;GAEX,KAAKF,SAAS;GACd;EACF;EACA,IAAI;GACF,MAAM,UAAU,MAAM;GACtB,KAAK,MAAM,QAAQ,MAAM,MAAM,CAAC,CAAC,GAAG;IAClC,IAAI,SAAS,SACX;IAEF,QAAQ,OAAO,KAAK,cAAc,IAAI,GAAG,KAAK,CAAC;GACjD;EACF,SAAS,GAAG;GACV,MAAM,QAAQ;GACd,MAAM;EACR;EACA,KAAKA,SAAS;CAChB;AACF"}

package/out/zql/src/planner/planner-filter.d.ts

@@ -1,59 +0,0 @@
-import type { NoSubqueryCondition } from '../builder/filter.ts';
-import type { PlannerConstraint } from './planner-constraint.ts';
-import type { PlanDebugger } from './planner-debug.ts';
-import type { CostEstimate, JoinOrConnection, PlannerNode } from './planner-node.ts';
-import type { PlannerTerminus } from './planner-terminus.ts';
-/**
- * Represents a simple (non-CSQ) branch of an OR in the planner graph.
- *
- * # Why this node exists
- * Without `PlannerFilter`, the planner would not see simple branches of an
- * OR at all — `processOr` historically only admitted subquery-bearing
- * branches into the graph. That meant the cost model never got to weigh
- * the per-branch filter that the runtime actually pushes down via
- * `FetchRequest.filter` for UFI/UFO branches.
- *
- * # What it does
- * - Stores the simple branch's `NoSubqueryCondition`.
- * - Forwards `propagateConstraints` to its input (typically a `PlannerFanOut`
- *   leading back to a `PlannerConnection`).
- * - When the enclosing FanIn is in `UFI` mode, registers the condition at
- *   the receiving `PlannerConnection` under the current `branchPattern` via
- *   `connection.setPerBranchFilter(...)`. This lets the cost model see the
- *   true per-branch filter at fetch time.
- * - In `FI` mode, registration is skipped — at runtime, FI/FO uses a
- *   single shared scan of the source for all branches, so per-branch filters
- *   would mis-credit the source scan cost.
- *
- * # Cost
- * Pass-through. The filter node itself adds no execution cost; the only
- * effect is at the connection layer (lower estimated rows).
- *
- * # Planner/runtime branch-count mismatch
- * For OR with multiple simple branches and a flipped CSQ (e.g.
- * `or(a=1, b=2, exists(...))`), the planner builds one `PlannerFilter` per
- * simple branch, but at runtime `applyFilterWithFlips` bundles all
- * non-flipped branches into a single source fetch with `(a=1 OR b=2)` —
- * one source scan, not N. In UFI mode the planner therefore models N
- * independent source scans against the runtime's 1, slightly inflating
- * the cost of OR-with-many-simples shapes. Common `or(simple, exists)`
- * shapes have only one simple branch and are unaffected.
- */
-export declare class PlannerFilter {
-    #private;
-    readonly kind: "filter";
-    constructor(input: Exclude<PlannerNode, PlannerTerminus>, condition: NoSubqueryCondition | undefined);
-    setOutput(node: PlannerNode): void;
-    get output(): PlannerNode;
-    closestJoinOrSource(): JoinOrConnection;
-    propagateConstraints(branchPattern: number[], constraint: PlannerConstraint | undefined, from?: PlannerNode, planDebugger?: PlanDebugger): void;
-    estimateCost(downstreamChildSelectivity: number, branchPattern: number[], planDebugger?: PlanDebugger): CostEstimate;
-    /**
-     * Forward unlimit propagation along the parent chain (toward the source).
-     */
-    propagateUnlimitFromFlippedJoin(): void;
-    reset(): void;
-    /** For debugging. */
-    getConditionForDebug(): NoSubqueryCondition | undefined;
-}
-//# sourceMappingURL=planner-filter.d.ts.map

package/out/zql/src/planner/planner-filter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"planner-filter.d.ts","sourceRoot":"","sources":["../../../../../zql/src/planner/planner-filter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,sBAAsB,CAAC;AAE9D,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,yBAAyB,CAAC;AAC/D,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,oBAAoB,CAAC;AAErD,OAAO,KAAK,EACV,YAAY,EACZ,gBAAgB,EAChB,WAAW,EACZ,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,uBAAuB,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,qBAAa,aAAa;;IACxB,QAAQ,CAAC,IAAI,EAAG,QAAQ,CAAU;gBAMhC,KAAK,EAAE,OAAO,CAAC,WAAW,EAAE,eAAe,CAAC,EAC5C,SAAS,EAAE,mBAAmB,GAAG,SAAS;IAM5C,SAAS,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI;IAIlC,IAAI,MAAM,IAAI,WAAW,CAGxB;IAED,mBAAmB,IAAI,gBAAgB;IAIvC,oBAAoB,CAClB,aAAa,EAAE,MAAM,EAAE,EACvB,UAAU,EAAE,iBAAiB,GAAG,SAAS,EACzC,IAAI,CAAC,EAAE,WAAW,EAClB,YAAY,CAAC,EAAE,YAAY,GAC1B,IAAI;IA8BP,YAAY,CACV,0BAA0B,EAAE,MAAM,EAClC,aAAa,EAAE,MAAM,EAAE,EACvB,YAAY,CAAC,EAAE,YAAY,GAC1B,YAAY;IAqBf;;OAEG;IACH,+BAA+B,IAAI,IAAI;IAWvC,KAAK,IAAI,IAAI;IAMb,qBAAqB;IACrB,oBAAoB,IAAI,mBAAmB,GAAG,SAAS;CAGxD"}

package/out/zql/src/planner/planner-filter.js

@@ -1,116 +0,0 @@
-import { assert } from "../../../shared/src/asserts.js";
-import { omitFanout } from "./planner-node.js";
-//#region ../zql/src/planner/planner-filter.ts
-/**
-* Represents a simple (non-CSQ) branch of an OR in the planner graph.
-*
-* # Why this node exists
-* Without `PlannerFilter`, the planner would not see simple branches of an
-* OR at all — `processOr` historically only admitted subquery-bearing
-* branches into the graph. That meant the cost model never got to weigh
-* the per-branch filter that the runtime actually pushes down via
-* `FetchRequest.filter` for UFI/UFO branches.
-*
-* # What it does
-* - Stores the simple branch's `NoSubqueryCondition`.
-* - Forwards `propagateConstraints` to its input (typically a `PlannerFanOut`
-*   leading back to a `PlannerConnection`).
-* - When the enclosing FanIn is in `UFI` mode, registers the condition at
-*   the receiving `PlannerConnection` under the current `branchPattern` via
-*   `connection.setPerBranchFilter(...)`. This lets the cost model see the
-*   true per-branch filter at fetch time.
-* - In `FI` mode, registration is skipped — at runtime, FI/FO uses a
-*   single shared scan of the source for all branches, so per-branch filters
-*   would mis-credit the source scan cost.
-*
-* # Cost
-* Pass-through. The filter node itself adds no execution cost; the only
-* effect is at the connection layer (lower estimated rows).
-*
-* # Planner/runtime branch-count mismatch
-* For OR with multiple simple branches and a flipped CSQ (e.g.
-* `or(a=1, b=2, exists(...))`), the planner builds one `PlannerFilter` per
-* simple branch, but at runtime `applyFilterWithFlips` bundles all
-* non-flipped branches into a single source fetch with `(a=1 OR b=2)` —
-* one source scan, not N. In UFI mode the planner therefore models N
-* independent source scans against the runtime's 1, slightly inflating
-* the cost of OR-with-many-simples shapes. Common `or(simple, exists)`
-* shapes have only one simple branch and are unaffected.
-*/
-var PlannerFilter = class {
-	kind = "filter";
-	#input;
-	#condition;
-	#output;
-	constructor(input, condition) {
-		this.#input = input;
-		this.#condition = condition;
-	}
-	setOutput(node) {
-		this.#output = node;
-	}
-	get output() {
-		assert(this.#output !== void 0, "Output not set");
-		return this.#output;
-	}
-	closestJoinOrSource() {
-		return this.#input.closestJoinOrSource();
-	}
-	propagateConstraints(branchPattern, constraint, from, planDebugger) {
-		planDebugger?.log({
-			type: "node-constraint",
-			nodeType: "filter",
-			node: "filter",
-			branchPattern,
-			constraint,
-			from: from?.kind ?? "unknown"
-		});
-		if (this.#condition && from?.kind === "fan-in" && from.type === "UFI") {
-			const conn = findParentConnection(this.#input);
-			if (conn) conn.setPerBranchFilter(branchPattern, this.#condition);
-		}
-		this.#input.propagateConstraints(branchPattern, constraint, this, planDebugger);
-	}
-	estimateCost(downstreamChildSelectivity, branchPattern, planDebugger) {
-		const cost = this.#input.estimateCost(downstreamChildSelectivity, branchPattern, planDebugger);
-		if (planDebugger) planDebugger.log({
-			type: "node-cost",
-			nodeType: "filter",
-			node: "filter",
-			branchPattern,
-			downstreamChildSelectivity,
-			costEstimate: omitFanout(cost)
-		});
-		return cost;
-	}
-	/**
-	* Forward unlimit propagation along the parent chain (toward the source).
-	*/
-	propagateUnlimitFromFlippedJoin() {
-		if ("propagateUnlimitFromFlippedJoin" in this.#input && typeof this.#input.propagateUnlimitFromFlippedJoin === "function") this.#input.propagateUnlimitFromFlippedJoin();
-	}
-	reset() {}
-	/** For debugging. */
-	getConditionForDebug() {
-		return this.#condition;
-	}
-};
-/**
-* Walk the input chain (toward the source) looking for the first
-* `PlannerConnection`. The simple branch's filter is meant to land on the
-* connection that the FanOut wraps — for nested AST shapes, that may be
-* several joins above.
-*/
-function findParentConnection(node) {
-	switch (node.kind) {
-		case "connection": return node;
-		case "fan-out": return findParentConnection(node.input);
-		case "join": return findParentConnection(node.parent);
-		case "fan-in": return;
-		case "filter": return;
-	}
-}
-//#endregion
-export { PlannerFilter };
-
-//# sourceMappingURL=planner-filter.js.map

package/out/zql/src/planner/planner-filter.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"planner-filter.js","names":["#input","#condition","#output"],"sources":["../../../../../zql/src/planner/planner-filter.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport type {NoSubqueryCondition} from '../builder/filter.ts';\nimport type {PlannerConnection} from './planner-connection.ts';\nimport type {PlannerConstraint} from './planner-constraint.ts';\nimport type {PlanDebugger} from './planner-debug.ts';\nimport {omitFanout} from './planner-node.ts';\nimport type {\n  CostEstimate,\n  JoinOrConnection,\n  PlannerNode,\n} from './planner-node.ts';\nimport type {PlannerTerminus} from './planner-terminus.ts';\n\n/**\n * Represents a simple (non-CSQ) branch of an OR in the planner graph.\n *\n * # Why this node exists\n * Without `PlannerFilter`, the planner would not see simple branches of an\n * OR at all — `processOr` historically only admitted subquery-bearing\n * branches into the graph. That meant the cost model never got to weigh\n * the per-branch filter that the runtime actually pushes down via\n * `FetchRequest.filter` for UFI/UFO branches.\n *\n * # What it does\n * - Stores the simple branch's `NoSubqueryCondition`.\n * - Forwards `propagateConstraints` to its input (typically a `PlannerFanOut`\n *   leading back to a `PlannerConnection`).\n * - When the enclosing FanIn is in `UFI` mode, registers the condition at\n *   the receiving `PlannerConnection` under the current `branchPattern` via\n *   `connection.setPerBranchFilter(...)`. This lets the cost model see the\n *   true per-branch filter at fetch time.\n * - In `FI` mode, registration is skipped — at runtime, FI/FO uses a\n *   single shared scan of the source for all branches, so per-branch filters\n *   would mis-credit the source scan cost.\n *\n * # Cost\n * Pass-through. The filter node itself adds no execution cost; the only\n * effect is at the connection layer (lower estimated rows).\n *\n * # Planner/runtime branch-count mismatch\n * For OR with multiple simple branches and a flipped CSQ (e.g.\n * `or(a=1, b=2, exists(...))`), the planner builds one `PlannerFilter` per\n * simple branch, but at runtime `applyFilterWithFlips` bundles all\n * non-flipped branches into a single source fetch with `(a=1 OR b=2)` —\n * one source scan, not N. In UFI mode the planner therefore models N\n * independent source scans against the runtime's 1, slightly inflating\n * the cost of OR-with-many-simples shapes. Common `or(simple, exists)`\n * shapes have only one simple branch and are unaffected.\n */\nexport class PlannerFilter {\n  readonly kind = 'filter' as const;\n  readonly #input: Exclude<PlannerNode, PlannerTerminus>;\n  readonly #condition: NoSubqueryCondition | undefined;\n  #output?: PlannerNode | undefined;\n\n  constructor(\n    input: Exclude<PlannerNode, PlannerTerminus>,\n    condition: NoSubqueryCondition | undefined,\n  ) {\n    this.#input = input;\n    this.#condition = condition;\n  }\n\n  setOutput(node: PlannerNode): void {\n    this.#output = node;\n  }\n\n  get output(): PlannerNode {\n    assert(this.#output !== undefined, 'Output not set');\n    return this.#output;\n  }\n\n  closestJoinOrSource(): JoinOrConnection {\n    return this.#input.closestJoinOrSource();\n  }\n\n  propagateConstraints(\n    branchPattern: number[],\n    constraint: PlannerConstraint | undefined,\n    from?: PlannerNode,\n    planDebugger?: PlanDebugger,\n  ): void {\n    planDebugger?.log({\n      type: 'node-constraint',\n      nodeType: 'filter',\n      node: 'filter',\n      branchPattern,\n      constraint,\n      from: from?.kind ?? 'unknown',\n    });\n\n    // Only register the per-branch filter when we're actually going to do\n    // a per-branch fetch at runtime — i.e., when our enclosing FanIn is in\n    // UFI mode. In FI mode, all branches share a single source scan, so\n    // applying our filter at the source would drop rows that other\n    // branches need.\n    if (this.#condition && from?.kind === 'fan-in' && from.type === 'UFI') {\n      const conn = findParentConnection(this.#input);\n      if (conn) {\n        conn.setPerBranchFilter(branchPattern, this.#condition);\n      }\n    }\n\n    this.#input.propagateConstraints(\n      branchPattern,\n      constraint,\n      this,\n      planDebugger,\n    );\n  }\n\n  estimateCost(\n    downstreamChildSelectivity: number,\n    branchPattern: number[],\n    planDebugger?: PlanDebugger,\n  ): CostEstimate {\n    const cost = this.#input.estimateCost(\n      downstreamChildSelectivity,\n      branchPattern,\n      planDebugger,\n    );\n\n    if (planDebugger) {\n      planDebugger.log({\n        type: 'node-cost',\n        nodeType: 'filter',\n        node: 'filter',\n        branchPattern,\n        downstreamChildSelectivity,\n        costEstimate: omitFanout(cost),\n      });\n    }\n\n    return cost;\n  }\n\n  /**\n   * Forward unlimit propagation along the parent chain (toward the source).\n   */\n  propagateUnlimitFromFlippedJoin(): void {\n    if (\n      'propagateUnlimitFromFlippedJoin' in this.#input &&\n      typeof this.#input.propagateUnlimitFromFlippedJoin === 'function'\n    ) {\n      (\n        this.#input as {propagateUnlimitFromFlippedJoin(): void}\n      ).propagateUnlimitFromFlippedJoin();\n    }\n  }\n\n  reset(): void {\n    // No mutable structural state. Per-branch filters are re-registered on\n    // every propagation pass, and PlannerConnection clears its\n    // #perBranchFilters in its own reset().\n  }\n\n  /** For debugging. */\n  getConditionForDebug(): NoSubqueryCondition | undefined {\n    return this.#condition;\n  }\n}\n\n/**\n * Walk the input chain (toward the source) looking for the first\n * `PlannerConnection`. The simple branch's filter is meant to land on the\n * connection that the FanOut wraps — for nested AST shapes, that may be\n * several joins above.\n */\nfunction findParentConnection(\n  node: Exclude<PlannerNode, PlannerTerminus>,\n): PlannerConnection | undefined {\n  switch (node.kind) {\n    case 'connection':\n      return node;\n    case 'fan-out':\n      return findParentConnection(node.input);\n    case 'join':\n      return findParentConnection(node.parent);\n    case 'fan-in':\n      // Reaching a FanIn while walking up means the simple branch sits\n      // above a nested OR/UFI. The connection that matters for *this*\n      // simple branch's filter is the one feeding the outer FanOut, but\n      // from a nested FanIn we don't have a single input to walk through.\n      // Be conservative: don't register, accept that deeply nested OR\n      // shapes lose this optimization.\n      return undefined;\n    case 'filter':\n      // Shouldn't occur in graphs built by `processOr` — a PlannerFilter's\n      // input is always the FanOut it's a branch of, never another filter.\n      return undefined;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDA,IAAa,gBAAb,MAA2B;CACzB,OAAgB;CAChB;CACA;CACA;CAEA,YACE,OACA,WACA;EACA,KAAKA,SAAS;EACd,KAAKC,aAAa;CACpB;CAEA,UAAU,MAAyB;EACjC,KAAKC,UAAU;CACjB;CAEA,IAAI,SAAsB;EACxB,OAAO,KAAKA,YAAY,KAAA,GAAW,gBAAgB;EACnD,OAAO,KAAKA;CACd;CAEA,sBAAwC;EACtC,OAAO,KAAKF,OAAO,oBAAoB;CACzC;CAEA,qBACE,eACA,YACA,MACA,cACM;EACN,cAAc,IAAI;GAChB,MAAM;GACN,UAAU;GACV,MAAM;GACN;GACA;GACA,MAAM,MAAM,QAAQ;EACtB,CAAC;EAOD,IAAI,KAAKC,cAAc,MAAM,SAAS,YAAY,KAAK,SAAS,OAAO;GACrE,MAAM,OAAO,qBAAqB,KAAKD,MAAM;GAC7C,IAAI,MACF,KAAK,mBAAmB,eAAe,KAAKC,UAAU;EAE1D;EAEA,KAAKD,OAAO,qBACV,eACA,YACA,MACA,YACF;CACF;CAEA,aACE,4BACA,eACA,cACc;EACd,MAAM,OAAO,KAAKA,OAAO,aACvB,4BACA,eACA,YACF;EAEA,IAAI,cACF,aAAa,IAAI;GACf,MAAM;GACN,UAAU;GACV,MAAM;GACN;GACA;GACA,cAAc,WAAW,IAAI;EAC/B,CAAC;EAGH,OAAO;CACT;;;;CAKA,kCAAwC;EACtC,IACE,qCAAqC,KAAKA,UAC1C,OAAO,KAAKA,OAAO,oCAAoC,YAEvD,KACOA,OACL,gCAAgC;CAEtC;CAEA,QAAc,CAId;;CAGA,uBAAwD;EACtD,OAAO,KAAKC;CACd;AACF;;;;;;;AAQA,SAAS,qBACP,MAC+B;CAC/B,QAAQ,KAAK,MAAb;EACE,KAAK,cACH,OAAO;EACT,KAAK,WACH,OAAO,qBAAqB,KAAK,KAAK;EACxC,KAAK,QACH,OAAO,qBAAqB,KAAK,MAAM;EACzC,KAAK,UAOH;EACF,KAAK,UAGH;CACJ;AACF"}