@rocicorp/zero 1.11.0-canary.7 → 1.11.0-canary.9

package/out/zero-server/src/zql-database.js.map

@@ -1 +1 @@
-{"version":3,"file":"zql-database.js","names":["#crudFactory","#makeServerTransaction"],"sources":["../../../../zero-server/src/zql-database.ts"],"sourcesContent":["import type {MaybePromise} from '../../shared/src/types.ts';\nimport {formatPg, sql} from '../../z2s/src/sql.ts';\nimport type {CleanupResultsArg} from '../../zero-protocol/src/mutation.ts';\nimport type {Schema} from '../../zero-types/src/schema.ts';\nimport type {DBConnection, DBTransaction} from '../../zql/src/mutate/custom.ts';\nimport type {\n  HumanReadable,\n  Query,\n  RunOptions,\n} from '../../zql/src/query/query.ts';\nimport {CRUDMutatorFactory, type TransactionImpl} from './custom.ts';\nimport type {\n  Database,\n  TransactionProviderHooks,\n  TransactionProviderInput,\n} from './process-mutations.ts';\n\n/**\n * Implements a Database for use with PushProcessor that is backed by Postgres.\n *\n * This implementation also implements the same ZQL interfaces for reading and\n * writing data that the Zero client does, so that mutator functions can be\n * shared across client and server.\n */\nexport class ZQLDatabase<\n  TSchema extends Schema,\n  TWrappedTransaction,\n> implements Database<TransactionImpl<TSchema, TWrappedTransaction>> {\n  readonly connection: DBConnection<TWrappedTransaction>;\n  readonly #crudFactory: CRUDMutatorFactory<TSchema>;\n\n  constructor(connection: DBConnection<TWrappedTransaction>, schema: TSchema) {\n    this.connection = connection;\n    this.#crudFactory = new CRUDMutatorFactory(schema);\n  }\n\n  transaction<R>(\n    callback: (\n      tx: TransactionImpl<TSchema, TWrappedTransaction>,\n      transactionHooks: TransactionProviderHooks,\n    ) => MaybePromise<R>,\n    transactionInput?: TransactionProviderInput,\n  ): Promise<R> {\n    // Icky hack. This is just here to have user not have to do this.\n    // These interfaces need to be factored better.\n    const {\n      upstreamSchema = '',\n      clientGroupID = '',\n      clientID = '',\n      mutationID = 0,\n    } = transactionInput ?? {};\n    return this.connection.transaction(async dbTx => {\n      const zeroTx = await this.#makeServerTransaction(\n        dbTx,\n        clientID,\n        mutationID,\n      );\n\n      return callback(zeroTx, {\n        async updateClientMutationID() {\n          const formatted = formatPg(\n            sql`INSERT INTO ${sql.ident(upstreamSchema)}.clients \n                    as current (\"clientGroupID\", \"clientID\", \"lastMutationID\")\n                        VALUES (${clientGroupID}, ${clientID}, ${1})\n                    ON CONFLICT (\"clientGroupID\", \"clientID\")\n                    DO UPDATE SET \"lastMutationID\" = current.\"lastMutationID\" + 1\n                    RETURNING \"lastMutationID\"`,\n          );\n\n          const [{lastMutationID}] = (await dbTx.query(\n            formatted.text,\n            formatted.values,\n          )) as {lastMutationID: bigint}[];\n\n          return {lastMutationID};\n        },\n\n        async writeMutationResult(result) {\n          const formatted = formatPg(\n            sql`INSERT INTO ${sql.ident(upstreamSchema)}.mutations\n                    (\"clientGroupID\", \"clientID\", \"mutationID\", \"result\")\n                VALUES (${clientGroupID}, ${result.id.clientID}, ${result.id.id}, ${JSON.stringify(\n                  result.result,\n                )}::text::json)`,\n          );\n          await dbTx.query(formatted.text, formatted.values);\n        },\n\n        async deleteMutationResults(args: CleanupResultsArg) {\n          if ('type' in args && args.type === 'bulk') {\n            // Bulk deletion: delete all mutations for multiple clients\n            const formatted = formatPg(\n              sql`DELETE FROM ${sql.ident(upstreamSchema)}.\"mutations\"\n                  WHERE \"clientGroupID\" = ${args.clientGroupID}\n                    AND \"clientID\" = ANY(${args.clientIDs})`,\n            );\n            await dbTx.query(formatted.text, formatted.values);\n          } else {\n            // Single client (explicit 'single' or legacy without type): delete up to mutation ID\n            const formatted = formatPg(\n              sql`DELETE FROM ${sql.ident(upstreamSchema)}.\"mutations\"\n                  WHERE \"clientGroupID\" = ${args.clientGroupID}\n                    AND \"clientID\" = ${args.clientID}\n                    AND \"mutationID\" <= ${args.upToMutationID}`,\n            );\n            await dbTx.query(formatted.text, formatted.values);\n          }\n        },\n      });\n    });\n  }\n\n  #makeServerTransaction(\n    dbTx: DBTransaction<TWrappedTransaction>,\n    clientID: string,\n    mutationID: number,\n  ) {\n    return this.#crudFactory.createTransaction(dbTx, clientID, mutationID);\n  }\n\n  run<TTable extends keyof TSchema['tables'] & string, TReturn>(\n    query: Query<TTable, TSchema, TReturn>,\n    options?: RunOptions,\n  ): Promise<HumanReadable<TReturn>> {\n    return this.transaction(tx => tx.run(query, options));\n  }\n}\n"],"mappings":";;;;;;;;;;AAwBA,IAAa,cAAb,MAGqE;CACnE;CACA;CAEA,YAAY,YAA+C,QAAiB;EAC1E,KAAK,aAAa;EAClB,KAAKA,eAAe,IAAI,mBAAmB,MAAM;CACnD;CAEA,YACE,UAIA,kBACY;EAGZ,MAAM,EACJ,iBAAiB,IACjB,gBAAgB,IAChB,WAAW,IACX,aAAa,MACX,oBAAoB,CAAC;EACzB,OAAO,KAAK,WAAW,YAAY,OAAM,SAAQ;GAO/C,OAAO,SAAS,MANK,KAAKC,uBACxB,MACA,UACA,UACF,GAEwB;IACtB,MAAM,yBAAyB;KAC7B,MAAM,YAAY,SAChB,GAAG,eAAe,IAAI,MAAM,cAAc,EAAE;;kCAEtB,cAAc,IAAI,SAAS,IAAI,EAAE;;;+CAIzD;KAEA,MAAM,CAAC,EAAC,oBAAoB,MAAM,KAAK,MACrC,UAAU,MACV,UAAU,MACZ;KAEA,OAAO,EAAC,eAAc;IACxB;IAEA,MAAM,oBAAoB,QAAQ;KAChC,MAAM,YAAY,SAChB,GAAG,eAAe,IAAI,MAAM,cAAc,EAAE;;0BAE9B,cAAc,IAAI,OAAO,GAAG,SAAS,IAAI,OAAO,GAAG,GAAG,IAAI,KAAK,UACvE,OAAO,MACT,EAAE,cACR;KACA,MAAM,KAAK,MAAM,UAAU,MAAM,UAAU,MAAM;IACnD;IAEA,MAAM,sBAAsB,MAAyB;KACnD,IAAI,UAAU,QAAQ,KAAK,SAAS,QAAQ;MAE1C,MAAM,YAAY,SAChB,GAAG,eAAe,IAAI,MAAM,cAAc,EAAE;4CACd,KAAK,cAAc;2CACpB,KAAK,UAAU,EAC9C;MACA,MAAM,KAAK,MAAM,UAAU,MAAM,UAAU,MAAM;KACnD,OAAO;MAEL,MAAM,YAAY,SAChB,GAAG,eAAe,IAAI,MAAM,cAAc,EAAE;4CACd,KAAK,cAAc;uCACxB,KAAK,SAAS;0CACX,KAAK,gBACnC;MACA,MAAM,KAAK,MAAM,UAAU,MAAM,UAAU,MAAM;KACnD;IACF;GACF,CAAC;EACH,CAAC;CACH;CAEA,uBACE,MACA,UACA,YACA;EACA,OAAO,KAAKD,aAAa,kBAAkB,MAAM,UAAU,UAAU;CACvE;CAEA,IACE,OACA,SACiC;EACjC,OAAO,KAAK,aAAY,OAAM,GAAG,IAAI,OAAO,OAAO,CAAC;CACtD;AACF"}
+{"version":3,"file":"zql-database.js","names":["#crudFactory","#schema","#makeServerTransaction","#runOn"],"sources":["../../../../zero-server/src/zql-database.ts"],"sourcesContent":["import type {MaybePromise} from '../../shared/src/types.ts';\nimport {formatPg, sql} from '../../z2s/src/sql.ts';\nimport type {CleanupResultsArg} from '../../zero-protocol/src/mutation.ts';\nimport type {Schema} from '../../zero-types/src/schema.ts';\nimport type {\n  DBConnection,\n  DBTransaction,\n  Queryable,\n} from '../../zql/src/mutate/custom.ts';\nimport {asQueryInternals} from '../../zql/src/query/query-internals.ts';\nimport type {\n  HumanReadable,\n  Query,\n  RunOptions,\n} from '../../zql/src/query/query.ts';\nimport {CRUDMutatorFactory, type TransactionImpl} from './custom.ts';\nimport {executePostgresQuery} from './pg-query-executor.ts';\nimport type {\n  Database,\n  TransactionProviderHooks,\n  TransactionProviderInput,\n} from './process-mutations.ts';\n\n/**\n * Implements a Database for use with PushProcessor that is backed by Postgres.\n *\n * This implementation also implements the same ZQL interfaces for reading and\n * writing data that the Zero client does, so that mutator functions can be\n * shared across client and server.\n */\nexport class ZQLDatabase<\n  TSchema extends Schema,\n  TWrappedTransaction,\n> implements Database<TransactionImpl<TSchema, TWrappedTransaction>> {\n  readonly connection: DBConnection<TWrappedTransaction>;\n  readonly #crudFactory: CRUDMutatorFactory<TSchema>;\n  readonly #schema: TSchema;\n\n  constructor(connection: DBConnection<TWrappedTransaction>, schema: TSchema) {\n    this.connection = connection;\n    this.#crudFactory = new CRUDMutatorFactory(schema);\n    this.#schema = schema;\n  }\n\n  transaction<R>(\n    callback: (\n      tx: TransactionImpl<TSchema, TWrappedTransaction>,\n      transactionHooks: TransactionProviderHooks,\n    ) => MaybePromise<R>,\n    transactionInput?: TransactionProviderInput,\n  ): Promise<R> {\n    // Icky hack. This is just here to have user not have to do this.\n    // These interfaces need to be factored better.\n    const {\n      upstreamSchema = '',\n      clientGroupID = '',\n      clientID = '',\n      mutationID = 0,\n    } = transactionInput ?? {};\n    return this.connection.transaction(async dbTx => {\n      const zeroTx = await this.#makeServerTransaction(\n        dbTx,\n        clientID,\n        mutationID,\n      );\n\n      return callback(zeroTx, {\n        async updateClientMutationID() {\n          const formatted = formatPg(\n            sql`INSERT INTO ${sql.ident(upstreamSchema)}.clients \n                    as current (\"clientGroupID\", \"clientID\", \"lastMutationID\")\n                        VALUES (${clientGroupID}, ${clientID}, ${1})\n                    ON CONFLICT (\"clientGroupID\", \"clientID\")\n                    DO UPDATE SET \"lastMutationID\" = current.\"lastMutationID\" + 1\n                    RETURNING \"lastMutationID\"`,\n          );\n\n          const [{lastMutationID}] = (await dbTx.query(\n            formatted.text,\n            formatted.values,\n          )) as {lastMutationID: bigint}[];\n\n          return {lastMutationID};\n        },\n\n        async writeMutationResult(result) {\n          const formatted = formatPg(\n            sql`INSERT INTO ${sql.ident(upstreamSchema)}.mutations\n                    (\"clientGroupID\", \"clientID\", \"mutationID\", \"result\")\n                VALUES (${clientGroupID}, ${result.id.clientID}, ${result.id.id}, ${JSON.stringify(\n                  result.result,\n                )}::text::json)`,\n          );\n          await dbTx.query(formatted.text, formatted.values);\n        },\n\n        async deleteMutationResults(args: CleanupResultsArg) {\n          if ('type' in args && args.type === 'bulk') {\n            // Bulk deletion: delete all mutations for multiple clients\n            const formatted = formatPg(\n              sql`DELETE FROM ${sql.ident(upstreamSchema)}.\"mutations\"\n                  WHERE \"clientGroupID\" = ${args.clientGroupID}\n                    AND \"clientID\" = ANY(${args.clientIDs})`,\n            );\n            await dbTx.query(formatted.text, formatted.values);\n          } else {\n            // Single client (explicit 'single' or legacy without type): delete up to mutation ID\n            const formatted = formatPg(\n              sql`DELETE FROM ${sql.ident(upstreamSchema)}.\"mutations\"\n                  WHERE \"clientGroupID\" = ${args.clientGroupID}\n                    AND \"clientID\" = ${args.clientID}\n                    AND \"mutationID\" <= ${args.upToMutationID}`,\n            );\n            await dbTx.query(formatted.text, formatted.values);\n          }\n        },\n      });\n    });\n  }\n\n  #makeServerTransaction(\n    dbTx: DBTransaction<TWrappedTransaction>,\n    clientID: string,\n    mutationID: number,\n  ) {\n    return this.#crudFactory.createTransaction(dbTx, clientID, mutationID);\n  }\n\n  /**\n   * Runs a single read query.\n   *\n   * When the {@linkcode DBConnection} implements `query`, the compiled SQL is\n   * issued as a bare statement with no `BEGIN`/`COMMIT` around it (plus a\n   * one-time server schema lookup the first time this instance touches the\n   * database). Postgres then releases the statement's locks the moment it\n   * finishes instead of waiting for a `COMMIT` round-trip, which matters in\n   * serverless environments where the process can be frozen or reclaimed\n   * between the query resolving and the `COMMIT` being sent, leaving the\n   * transaction and its locks open indefinitely.\n   *\n   * Because no transaction is opened, any per-transaction setup the adapter\n   * performs inside `transaction` does not apply to these reads. If the\n   * connection does not implement `query`, the read is wrapped in a\n   * transaction as before.\n   *\n   * If you need multiple reads to observe a consistent snapshot, use\n   * {@linkcode transaction} and call `tx.run(...)` for each query instead.\n   */\n  run<TTable extends keyof TSchema['tables'] & string, TReturn>(\n    query: Query<TTable, TSchema, TReturn>,\n    _options?: RunOptions,\n  ): Promise<HumanReadable<TReturn>> {\n    const {connection} = this;\n    if (connection.query) {\n      // TS narrows `connection.query`, not `connection` itself.\n      return this.#runOn(connection as ReadTarget<TWrappedTransaction>, query);\n    }\n    return connection.transaction(dbTx => this.#runOn(dbTx, query));\n  }\n\n  async #runOn<TTable extends keyof TSchema['tables'] & string, TReturn>(\n    target: ReadTarget<TWrappedTransaction>,\n    query: Query<TTable, TSchema, TReturn>,\n  ): Promise<HumanReadable<TReturn>> {\n    const {ast, format} = asQueryInternals(query);\n    const serverSchema = await this.#crudFactory.getOrFetchServerSchema(target);\n    return target.runQuery\n      ? target.runQuery<TReturn>(ast, format, this.#schema, serverSchema)\n      : executePostgresQuery<TReturn>(\n          target,\n          ast,\n          format,\n          this.#schema,\n          serverSchema,\n        );\n  }\n}\n\n/**\n * Something a read can be executed against: a `DBTransaction`, or a\n * `DBConnection` that implements `query`.\n */\ntype ReadTarget<TWrappedTransaction> = Queryable & {\n  runQuery?: DBTransaction<TWrappedTransaction>['runQuery'] | undefined;\n};\n"],"mappings":";;;;;;;;;;;;AA8BA,IAAa,cAAb,MAGqE;CACnE;CACA;CACA;CAEA,YAAY,YAA+C,QAAiB;EAC1E,KAAK,aAAa;EAClB,KAAKA,eAAe,IAAI,mBAAmB,MAAM;EACjD,KAAKC,UAAU;CACjB;CAEA,YACE,UAIA,kBACY;EAGZ,MAAM,EACJ,iBAAiB,IACjB,gBAAgB,IAChB,WAAW,IACX,aAAa,MACX,oBAAoB,CAAC;EACzB,OAAO,KAAK,WAAW,YAAY,OAAM,SAAQ;GAO/C,OAAO,SAAS,MANK,KAAKC,uBACxB,MACA,UACA,UACF,GAEwB;IACtB,MAAM,yBAAyB;KAC7B,MAAM,YAAY,SAChB,GAAG,eAAe,IAAI,MAAM,cAAc,EAAE;;kCAEtB,cAAc,IAAI,SAAS,IAAI,EAAE;;;+CAIzD;KAEA,MAAM,CAAC,EAAC,oBAAoB,MAAM,KAAK,MACrC,UAAU,MACV,UAAU,MACZ;KAEA,OAAO,EAAC,eAAc;IACxB;IAEA,MAAM,oBAAoB,QAAQ;KAChC,MAAM,YAAY,SAChB,GAAG,eAAe,IAAI,MAAM,cAAc,EAAE;;0BAE9B,cAAc,IAAI,OAAO,GAAG,SAAS,IAAI,OAAO,GAAG,GAAG,IAAI,KAAK,UACvE,OAAO,MACT,EAAE,cACR;KACA,MAAM,KAAK,MAAM,UAAU,MAAM,UAAU,MAAM;IACnD;IAEA,MAAM,sBAAsB,MAAyB;KACnD,IAAI,UAAU,QAAQ,KAAK,SAAS,QAAQ;MAE1C,MAAM,YAAY,SAChB,GAAG,eAAe,IAAI,MAAM,cAAc,EAAE;4CACd,KAAK,cAAc;2CACpB,KAAK,UAAU,EAC9C;MACA,MAAM,KAAK,MAAM,UAAU,MAAM,UAAU,MAAM;KACnD,OAAO;MAEL,MAAM,YAAY,SAChB,GAAG,eAAe,IAAI,MAAM,cAAc,EAAE;4CACd,KAAK,cAAc;uCACxB,KAAK,SAAS;0CACX,KAAK,gBACnC;MACA,MAAM,KAAK,MAAM,UAAU,MAAM,UAAU,MAAM;KACnD;IACF;GACF,CAAC;EACH,CAAC;CACH;CAEA,uBACE,MACA,UACA,YACA;EACA,OAAO,KAAKF,aAAa,kBAAkB,MAAM,UAAU,UAAU;CACvE;;;;;;;;;;;;;;;;;;;;;CAsBA,IACE,OACA,UACiC;EACjC,MAAM,EAAC,eAAc;EACrB,IAAI,WAAW,OAEb,OAAO,KAAKG,OAAO,YAA+C,KAAK;EAEzE,OAAO,WAAW,aAAY,SAAQ,KAAKA,OAAO,MAAM,KAAK,CAAC;CAChE;CAEA,MAAMA,OACJ,QACA,OACiC;EACjC,MAAM,EAAC,KAAK,WAAU,iBAAiB,KAAK;EAC5C,MAAM,eAAe,MAAM,KAAKH,aAAa,uBAAuB,MAAM;EAC1E,OAAO,OAAO,WACV,OAAO,SAAkB,KAAK,QAAQ,KAAKC,SAAS,YAAY,IAChE,qBACE,QACA,KACA,QACA,KAAKA,SACL,YACF;CACN;AACF"}

package/out/zero-solid/src/solid-view.d.ts

@@ -3,6 +3,7 @@ import { type Change, type Entry, type ErroredQuery, type Format, type Input, ty
 export type State = [Entry, QueryResultDetails];
 export declare const COMPLETE: QueryResultDetails;
 export declare const UNKNOWN: QueryResultDetails;
+export declare const CACHED: QueryResultDetails;
 /**
  * SolidView bridges Zero's incremental view updates with Solid's reactive
  * store.
@@ -49,6 +50,15 @@ export declare class SolidView implements Output {
     #private;
     constructor(input: Input, onTransactionCommit: (cb: () => void) => void, format: Format, onDestroy: () => void, queryComplete: true | ErroredQuery | Promise<true>, updateTTL: (ttl: TTL) => void, setState: SetStoreFunction<State>, retry: () => void);
     destroy(): void;
+    /**
+     * The store holds the server-confirmed result of this query from a
+     * previous connection. Never downgrades 'complete'/'error'; freshness stays
+     * a promise only the connection can keep, so nothing that waits on
+     * 'complete' resolves here.
+     */
+    markCached(): void;
+    /** The got key was deleted (eviction) before this connection confirmed it. */
+    unmarkCached(): void;
     push(change: Change): readonly never[];
     updateTTL(ttl: TTL): void;
 }

package/out/zero-solid/src/solid-view.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"solid-view.d.ts","sourceRoot":"","sources":["../../../../zero-solid/src/solid-view.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,KAAK,gBAAgB,EAAC,MAAM,gBAAgB,CAAC;AAUzE,OAAO,EAEL,KAAK,MAAM,EACX,KAAK,KAAK,EACV,KAAK,YAAY,EACjB,KAAK,MAAM,EACX,KAAK,KAAK,EAEV,KAAK,MAAM,EACX,KAAK,KAAK,EAEV,KAAK,kBAAkB,EACvB,KAAK,MAAM,EAEX,KAAK,GAAG,EACT,MAAM,WAAW,CAAC;AAEnB,MAAM,MAAM,KAAK,GAAG,CAAC,KAAK,EAAE,kBAAkB,CAAC,CAAC;AAEhD,eAAO,MAAM,QAAQ,EAAE,kBAAsD,CAAC;AAC9E,eAAO,MAAM,OAAO,EAAE,kBAAqD,CAAC;AAE5E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,qBAAa,SAAU,YAAW,MAAM;;IAoBtC,YACE,KAAK,EAAE,KAAK,EACZ,mBAAmB,EAAE,CAAC,EAAE,EAAE,MAAM,IAAI,KAAK,IAAI,EAC7C,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,IAAI,EACrB,aAAa,EAAE,IAAI,GAAG,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,EAClD,SAAS,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,IAAI,EAC7B,QAAQ,EAAE,gBAAgB,CAAC,KAAK,CAAC,EACjC,KAAK,EAAE,MAAM,IAAI,EAiDlB;IAgBD,OAAO,IAAI,IAAI,CAEd;IAwBD,IAAI,CAAC,MAAM,EAAE,MAAM,oBAgBlB;IAyCD,SAAS,CAAC,GAAG,EAAE,GAAG,GAAG,IAAI,CAExB;CACF;AAsDD,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,gBAAgB,CAAC,KAAK,CAAC,EACjC,KAAK,CAAC,EAAE,MAAM,IAAI,IAGhB,MAAM,SAAS,MAAM,OAAO,CAAC,QAAQ,CAAC,GAAG,MAAM,EAC/C,OAAO,SAAS,MAAM,EACtB,OAAO,UAEC,KAAK,CAAC,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,SAChC,KAAK,UACJ,MAAM,aACH,MAAM,IAAI,uBACA,CAAC,EAAE,EAAE,MAAM,IAAI,KAAK,IAAI,iBAC9B,IAAI,GAAG,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,aACvC,CAAC,GAAG,EAAE,GAAG,KAAK,IAAI,eAiBhC"}
+{"version":3,"file":"solid-view.d.ts","sourceRoot":"","sources":["../../../../zero-solid/src/solid-view.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,KAAK,gBAAgB,EAAC,MAAM,gBAAgB,CAAC;AAUzE,OAAO,EAEL,KAAK,MAAM,EACX,KAAK,KAAK,EACV,KAAK,YAAY,EACjB,KAAK,MAAM,EACX,KAAK,KAAK,EAEV,KAAK,MAAM,EACX,KAAK,KAAK,EAEV,KAAK,kBAAkB,EACvB,KAAK,MAAM,EAEX,KAAK,GAAG,EACT,MAAM,WAAW,CAAC;AAEnB,MAAM,MAAM,KAAK,GAAG,CAAC,KAAK,EAAE,kBAAkB,CAAC,CAAC;AAEhD,eAAO,MAAM,QAAQ,EAAE,kBAAsD,CAAC;AAC9E,eAAO,MAAM,OAAO,EAAE,kBAAqD,CAAC;AAC5E,eAAO,MAAM,MAAM,EAAE,kBAAoD,CAAC;AAE1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,qBAAa,SAAU,YAAW,MAAM;;IAwBtC,YACE,KAAK,EAAE,KAAK,EACZ,mBAAmB,EAAE,CAAC,EAAE,EAAE,MAAM,IAAI,KAAK,IAAI,EAC7C,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,IAAI,EACrB,aAAa,EAAE,IAAI,GAAG,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,EAClD,SAAS,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,IAAI,EAC7B,QAAQ,EAAE,gBAAgB,CAAC,KAAK,CAAC,EACjC,KAAK,EAAE,MAAM,IAAI,EAiDlB;IAgBD,OAAO,IAAI,IAAI,CAEd;IAED;;;;;OAKG;IACH,UAAU,IAAI,IAAI,CAIjB;IAED,8EAA8E;IAC9E,YAAY,IAAI,IAAI,CAInB;IA8CD,IAAI,CAAC,MAAM,EAAE,MAAM,oBAgBlB;IAyCD,SAAS,CAAC,GAAG,EAAE,GAAG,GAAG,IAAI,CAExB;CACF;AAsDD,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,gBAAgB,CAAC,KAAK,CAAC,EACjC,KAAK,CAAC,EAAE,MAAM,IAAI,IAGhB,MAAM,SAAS,MAAM,OAAO,CAAC,QAAQ,CAAC,GAAG,MAAM,EAC/C,OAAO,SAAS,MAAM,EACtB,OAAO,UAEC,KAAK,CAAC,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,SAChC,KAAK,UACJ,MAAM,aACH,MAAM,IAAI,uBACA,CAAC,EAAE,EAAE,MAAM,IAAI,KAAK,IAAI,iBAC9B,IAAI,GAAG,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,aACvC,CAAC,GAAG,EAAE,GAAG,KAAK,IAAI,eAiBhC"}

package/out/zero-solid/src/solid-view.js

@@ -7,6 +7,7 @@ import { produce, reconcile } from "solid-js/store";
 //#region ../zero-solid/src/solid-view.ts
 var COMPLETE = Object.freeze({ type: "complete" });
 var UNKNOWN = Object.freeze({ type: "unknown" });
+var CACHED = Object.freeze({ type: "cached" });
 /**
 * SolidView bridges Zero's incremental view updates with Solid's reactive
 * store.
@@ -57,6 +58,7 @@ var SolidView = class {
 	#setState;
 	#builderRoot;
 	#pendingChanges = [];
+	#pendingResultType;
 	#updateTTL;
 	constructor(input, onTransactionCommit, format, onDestroy, queryComplete, updateTTL, setState, retry) {
 		this.#input = input;
@@ -96,6 +98,26 @@ var SolidView = class {
 	destroy() {
 		this.#onDestroy();
 	}
+	/**
+	* The store holds the server-confirmed result of this query from a
+	* previous connection. Never downgrades 'complete'/'error'; freshness stays
+	* a promise only the connection can keep, so nothing that waits on
+	* 'complete' resolves here.
+	*/
+	markCached() {
+		this.#transitionResultType((prev) => prev[1].type === "unknown" ? [prev[0], CACHED] : prev);
+	}
+	/** The got key was deleted (eviction) before this connection confirmed it. */
+	unmarkCached() {
+		this.#transitionResultType((prev) => prev[1].type === "cached" ? [prev[0], UNKNOWN] : prev);
+	}
+	#transitionResultType(transition) {
+		if (this.#hasUncommittedChanges()) this.#pendingResultType = transition;
+		else this.#setState(transition);
+	}
+	#hasUncommittedChanges() {
+		return this.#builderRoot !== void 0 && !isEmptyRoot(this.#builderRoot) || this.#pendingChanges.length > 0;
+	}
 	#onTransactionCommit = () => {
 		const builderRoot = this.#builderRoot;
 		if (builderRoot) {
@@ -108,6 +130,11 @@ var SolidView = class {
 		} finally {
 			this.#pendingChanges = [];
 		}
+		const pendingResultType = this.#pendingResultType;
+		if (pendingResultType) {
+			this.#pendingResultType = void 0;
+			this.#setState(pendingResultType);
+		}
 	};
 	push(change) {
 		if (this.#builderRoot) this.#applyChangeToRoot(materializeRelationships(change), this.#builderRoot);

package/out/zero-solid/src/solid-view.js.map

@@ -1 +1 @@
-{"version":3,"file":"solid-view.js","names":["#input","#format","#onDestroy","#retry","#updateTTL","#onTransactionCommit","#createEmptyRoot","#applyChangesToRoot","#setState","#makeError","#builderRoot","#applyChanges","#pendingChanges","#applyChangeToRoot"],"sources":["../../../../zero-solid/src/solid-view.ts"],"sourcesContent":["import {produce, reconcile, type SetStoreFunction} from 'solid-js/store';\nimport {emptyArray} from '../../shared/src/sentinels.ts';\nimport {ChangeIndex} from '../../zql/src/ivm/change-index.ts';\nimport {ChangeType} from '../../zql/src/ivm/change-type.ts';\nimport {\n  applyChange,\n  idSymbol,\n  skipYields,\n  type ViewChange,\n} from './bindings.ts';\nimport {\n  type AnyViewFactory,\n  type Change,\n  type Entry,\n  type ErroredQuery,\n  type Format,\n  type Input,\n  type Node,\n  type Output,\n  type Query,\n  type QueryErrorDetails,\n  type QueryResultDetails,\n  type Schema,\n  type Stream,\n  type TTL,\n} from './zero.ts';\n\nexport type State = [Entry, QueryResultDetails];\n\nexport const COMPLETE: QueryResultDetails = Object.freeze({type: 'complete'});\nexport const UNKNOWN: QueryResultDetails = Object.freeze({type: 'unknown'});\n\n/**\n * SolidView bridges Zero's incremental view updates with Solid's reactive\n * store.\n *\n * The challenge: Zero pushes individual row changes (add/remove/edit) as they\n * arrive, but updating Solid's store on each push is expensive. We batch\n * changes until transaction commit, then apply them all at once.\n *\n * Two code paths optimize for different scenarios:\n *\n *   1. BULK INSERT (builderRoot path): When building from empty, we skip\n *      Solid's reactive tracking entirely and build a plain JS object. This is\n *      5x faster for large initial loads. Uses reconcile() to diff the final\n *      result into Solid.\n *\n *   2. INCREMENTAL UPDATE (#pendingChanges path): For existing views, we queue\n *      changes and apply them in-place within a produce() draft. produce()\n *      creates a mutable draft, applyChange mutates it directly, then produce()\n *      handles diffing and reactivity.\n *\n *\n *   push(change)\n *       │\n *       ▼\n *   ┌─────────────────────────────────┐\n *   │ builderRoot defined?            │\n *   │ (building from empty)           │\n *   └─────────────────────────────────┘\n *       │yes                │no\n *       ▼                   ▼\n *   Build plain JS      Queue in\n *   object (fast)       #pendingChanges\n *       │                   │\n *       └───────┬───────────┘\n *               ▼\n *         onTransactionCommit()\n *               │\n *       ┌───────┴──────────┐\n *       │                  │\n *   builderRoot      produce(draft =>\n *   → reconcile()      applyChange(draft, ..., mutate: true))\n */\nexport class SolidView implements Output {\n  readonly #input: Input;\n  readonly #format: Format;\n  readonly #onDestroy: () => void;\n  readonly #retry: () => void;\n\n  #setState: SetStoreFunction<State>;\n\n  // Optimization: if the store is currently empty we build up\n  // the view on a plain old JS object stored at #builderRoot, and return\n  // that for the new state on transaction commit.  This avoids building up\n  // large views from scratch via solid produce.  The proxy object used by\n  // solid produce is slow and in this case we don't care about solid tracking\n  // the fine grained changes (everything has changed, it's all new).  For a\n  // test case with a view with 3000 rows, each row having 2 children, this\n  // optimization reduced #applyChanges time from 743ms to 133ms.\n  #builderRoot: Entry | undefined;\n  #pendingChanges: ViewChange[] = [];\n  readonly #updateTTL: (ttl: TTL) => void;\n\n  constructor(\n    input: Input,\n    onTransactionCommit: (cb: () => void) => void,\n    format: Format,\n    onDestroy: () => void,\n    queryComplete: true | ErroredQuery | Promise<true>,\n    updateTTL: (ttl: TTL) => void,\n    setState: SetStoreFunction<State>,\n    retry: () => void,\n  ) {\n    this.#input = input;\n    onTransactionCommit(this.#onTransactionCommit);\n    this.#format = format;\n    this.#onDestroy = onDestroy;\n    this.#updateTTL = updateTTL;\n    this.#retry = retry;\n\n    input.setOutput(this);\n\n    const initialRoot = this.#createEmptyRoot();\n    this.#applyChangesToRoot(\n      skipYields(input.fetch({})),\n      node => ({type: 'add', node}),\n      initialRoot,\n    );\n\n    this.#setState = setState;\n    this.#setState(\n      reconcile(\n        [\n          initialRoot,\n          queryComplete === true\n            ? COMPLETE\n            : 'error' in queryComplete\n              ? this.#makeError(queryComplete)\n              : UNKNOWN,\n        ],\n        {\n          // solidjs's types want a string, but a symbol works\n          key: idSymbol as unknown as string,\n        },\n      ),\n    );\n\n    if (isEmptyRoot(initialRoot)) {\n      this.#builderRoot = this.#createEmptyRoot();\n    }\n\n    if (queryComplete !== true && !('error' in queryComplete)) {\n      void queryComplete\n        .then(() => {\n          this.#setState(prev => [prev[0], COMPLETE]);\n        })\n        .catch((error: ErroredQuery) => {\n          this.#setState(prev => [prev[0], this.#makeError(error)]);\n        });\n    }\n  }\n\n  #makeError(error: ErroredQuery): QueryErrorDetails {\n    const message = error.message ?? 'An unknown error occurred';\n    return {\n      type: 'error',\n      retry: this.#retry,\n      refetch: this.#retry,\n      error: {\n        type: error.error,\n        message,\n        ...(error.details ? {details: error.details} : {}),\n      },\n    };\n  }\n\n  destroy(): void {\n    this.#onDestroy();\n  }\n\n  #onTransactionCommit = () => {\n    const builderRoot = this.#builderRoot;\n    if (builderRoot) {\n      if (!isEmptyRoot(builderRoot)) {\n        this.#setState(\n          0,\n          reconcile(builderRoot, {\n            // solidjs's types want a string, but a symbol works\n            key: idSymbol as unknown as string,\n          }),\n        );\n        this.#builderRoot = undefined;\n      }\n    } else {\n      try {\n        this.#applyChanges(this.#pendingChanges, c => c);\n      } finally {\n        this.#pendingChanges = [];\n      }\n    }\n  };\n\n  push(change: Change) {\n    // Delay updating the solid store state until the transaction commit\n    // (because each update of the solid store is quite expensive).  If\n    // this.#builderRoot is defined apply the changes to it (we are building\n    // from an empty root), otherwise queue the changes to be applied\n    // using produce at the end of the transaction but read the relationships\n    // now as they are only valid to read when the push is received.\n    if (this.#builderRoot) {\n      this.#applyChangeToRoot(\n        materializeRelationships(change),\n        this.#builderRoot,\n      );\n    } else {\n      this.#pendingChanges.push(materializeRelationships(change));\n    }\n    return emptyArray;\n  }\n\n  #applyChanges<T>(changes: Iterable<T>, mapper: (v: T) => ViewChange): void {\n    this.#setState(\n      produce((draftState: State) => {\n        this.#applyChangesToRoot<T>(changes, mapper, draftState[0]);\n        if (isEmptyRoot(draftState[0])) {\n          this.#builderRoot = this.#createEmptyRoot();\n        }\n      }),\n    );\n  }\n\n  #applyChangesToRoot<T>(\n    changes: Iterable<T>,\n    mapper: (v: T) => ViewChange,\n    root: Entry,\n  ) {\n    for (const change of changes) {\n      this.#applyChangeToRoot(mapper(change), root);\n    }\n  }\n\n  #applyChangeToRoot(change: ViewChange, root: Entry) {\n    applyChange(\n      root,\n      change,\n      this.#input.getSchema(),\n      '',\n      this.#format,\n      true /* withIDs */,\n      true /* mutate */,\n    );\n  }\n\n  #createEmptyRoot(): Entry {\n    return {\n      '': this.#format.singular ? undefined : [],\n    };\n  }\n\n  updateTTL(ttl: TTL): void {\n    this.#updateTTL(ttl);\n  }\n}\n\nfunction materializeRelationships(change: Change): ViewChange {\n  switch (change[ChangeIndex.TYPE]) {\n    case ChangeType.ADD:\n      return {\n        type: 'add',\n        node: materializeNodeRelationships(change[ChangeIndex.NODE]),\n      };\n    case ChangeType.REMOVE:\n      return {\n        type: 'remove',\n        node: materializeNodeRelationships(change[ChangeIndex.NODE]),\n      };\n    case ChangeType.CHILD:\n      return {\n        type: 'child',\n        node: {row: change[ChangeIndex.NODE].row},\n        child: {\n          relationshipName: change[ChangeIndex.CHILD_DATA].relationshipName,\n          change: materializeRelationships(\n            change[ChangeIndex.CHILD_DATA].change,\n          ),\n        },\n      };\n    case ChangeType.EDIT:\n      return {\n        type: 'edit',\n        node: {row: change[ChangeIndex.NODE].row},\n        oldNode: {row: change[ChangeIndex.OLD_NODE].row},\n      };\n  }\n}\n\nfunction materializeNodeRelationships(node: Node): Node {\n  const relationships: Record<string, () => Stream<Node>> = {};\n  for (const relationship in node.relationships) {\n    const materialized: Node[] = [];\n    for (const n of skipYields(node.relationships[relationship]())) {\n      materialized.push(materializeNodeRelationships(n));\n    }\n    relationships[relationship] = () => materialized;\n  }\n  return {\n    row: node.row,\n    relationships,\n  };\n}\n\nfunction isEmptyRoot(entry: Entry) {\n  const data = entry[''];\n  return data === undefined || (Array.isArray(data) && data.length === 0);\n}\n\nexport function createSolidViewFactory(\n  setState: SetStoreFunction<State>,\n  retry?: () => void,\n) {\n  function solidViewFactory<\n    TTable extends keyof TSchema['tables'] & string,\n    TSchema extends Schema,\n    TReturn,\n  >(\n    _query: Query<TTable, TSchema, TReturn>,\n    input: Input,\n    format: Format,\n    onDestroy: () => void,\n    onTransactionCommit: (cb: () => void) => void,\n    queryComplete: true | ErroredQuery | Promise<true>,\n    updateTTL: (ttl: TTL) => void,\n  ) {\n    return new SolidView(\n      input,\n      onTransactionCommit,\n      format,\n      onDestroy,\n      queryComplete,\n      updateTTL,\n      setState,\n      retry || (() => {}),\n    );\n  }\n\n  solidViewFactory satisfies AnyViewFactory;\n\n  return solidViewFactory;\n}\n"],"mappings":";;;;;;;AA6BA,IAAa,WAA+B,OAAO,OAAO,EAAC,MAAM,WAAU,CAAC;AAC5E,IAAa,UAA8B,OAAO,OAAO,EAAC,MAAM,UAAS,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4C1E,IAAa,YAAb,MAAyC;CACvC;CACA;CACA;CACA;CAEA;CAUA;CACA,kBAAgC,CAAC;CACjC;CAEA,YACE,OACA,qBACA,QACA,WACA,eACA,WACA,UACA,OACA;EACA,KAAKA,SAAS;EACd,oBAAoB,KAAKK,oBAAoB;EAC7C,KAAKJ,UAAU;EACf,KAAKC,aAAa;EAClB,KAAKE,aAAa;EAClB,KAAKD,SAAS;EAEd,MAAM,UAAU,IAAI;EAEpB,MAAM,cAAc,KAAKG,iBAAiB;EAC1C,KAAKC,oBACH,WAAW,MAAM,MAAM,CAAC,CAAC,CAAC,IAC1B,UAAS;GAAC,MAAM;GAAO;EAAI,IAC3B,WACF;EAEA,KAAKC,YAAY;EACjB,KAAKA,UACH,UACE,CACE,aACA,kBAAkB,OACd,WACA,WAAW,gBACT,KAAKC,WAAW,aAAa,IAC7B,OACR,GACA,EAEE,KAAK,SACP,CACF,CACF;EAEA,IAAI,YAAY,WAAW,GACzB,KAAKC,eAAe,KAAKJ,iBAAiB;EAG5C,IAAI,kBAAkB,QAAQ,EAAE,WAAW,gBACzC,cACG,WAAW;GACV,KAAKE,WAAU,SAAQ,CAAC,KAAK,IAAI,QAAQ,CAAC;EAC5C,CAAC,EACA,OAAO,UAAwB;GAC9B,KAAKA,WAAU,SAAQ,CAAC,KAAK,IAAI,KAAKC,WAAW,KAAK,CAAC,CAAC;EAC1D,CAAC;CAEP;CAEA,WAAW,OAAwC;EACjD,MAAM,UAAU,MAAM,WAAW;EACjC,OAAO;GACL,MAAM;GACN,OAAO,KAAKN;GACZ,SAAS,KAAKA;GACd,OAAO;IACL,MAAM,MAAM;IACZ;IACA,GAAI,MAAM,UAAU,EAAC,SAAS,MAAM,QAAO,IAAI,CAAC;GAClD;EACF;CACF;CAEA,UAAgB;EACd,KAAKD,WAAW;CAClB;CAEA,6BAA6B;EAC3B,MAAM,cAAc,KAAKQ;EACzB,IAAI;OACE,CAAC,YAAY,WAAW,GAAG;IAC7B,KAAKF,UACH,GACA,UAAU,aAAa,EAErB,KAAK,SACP,CAAC,CACH;IACA,KAAKE,eAAe,KAAA;GACtB;SAEA,IAAI;GACF,KAAKC,cAAc,KAAKC,kBAAiB,MAAK,CAAC;EACjD,UAAU;GACR,KAAKA,kBAAkB,CAAC;EAC1B;CAEJ;CAEA,KAAK,QAAgB;EAOnB,IAAI,KAAKF,cACP,KAAKG,mBACH,yBAAyB,MAAM,GAC/B,KAAKH,YACP;OAEA,KAAKE,gBAAgB,KAAK,yBAAyB,MAAM,CAAC;EAE5D,OAAO;CACT;CAEA,cAAiB,SAAsB,QAAoC;EACzE,KAAKJ,UACH,SAAS,eAAsB;GAC7B,KAAKD,oBAAuB,SAAS,QAAQ,WAAW,EAAE;GAC1D,IAAI,YAAY,WAAW,EAAE,GAC3B,KAAKG,eAAe,KAAKJ,iBAAiB;EAE9C,CAAC,CACH;CACF;CAEA,oBACE,SACA,QACA,MACA;EACA,KAAK,MAAM,UAAU,SACnB,KAAKO,mBAAmB,OAAO,MAAM,GAAG,IAAI;CAEhD;CAEA,mBAAmB,QAAoB,MAAa;EAClD,YACE,MACA,QACA,KAAKb,OAAO,UAAU,GACtB,IACA,KAAKC,SACL,MACA,IACF;CACF;CAEA,mBAA0B;EACxB,OAAO,EACL,IAAI,KAAKA,QAAQ,WAAW,KAAA,IAAY,CAAC,EAC3C;CACF;CAEA,UAAU,KAAgB;EACxB,KAAKG,WAAW,GAAG;CACrB;AACF;AAEA,SAAS,yBAAyB,QAA4B;CAC5D,QAAQ,OAAO,IAAf;EACE,KAAK,GACH,OAAO;GACL,MAAM;GACN,MAAM,6BAA6B,OAAO,EAAiB;EAC7D;EACF,KAAK,GACH,OAAO;GACL,MAAM;GACN,MAAM,6BAA6B,OAAO,EAAiB;EAC7D;EACF,KAAK,GACH,OAAO;GACL,MAAM;GACN,MAAM,EAAC,KAAK,OAAO,GAAkB,IAAG;GACxC,OAAO;IACL,kBAAkB,OAAO,GAAwB;IACjD,QAAQ,yBACN,OAAO,GAAwB,MACjC;GACF;EACF;EACF,KAAK,GACH,OAAO;GACL,MAAM;GACN,MAAM,EAAC,KAAK,OAAO,GAAkB,IAAG;GACxC,SAAS,EAAC,KAAK,OAAO,GAAsB,IAAG;EACjD;CACJ;AACF;AAEA,SAAS,6BAA6B,MAAkB;CACtD,MAAM,gBAAoD,CAAC;CAC3D,KAAK,MAAM,gBAAgB,KAAK,eAAe;EAC7C,MAAM,eAAuB,CAAC;EAC9B,KAAK,MAAM,KAAK,WAAW,KAAK,cAAc,cAAc,CAAC,GAC3D,aAAa,KAAK,6BAA6B,CAAC,CAAC;EAEnD,cAAc,sBAAsB;CACtC;CACA,OAAO;EACL,KAAK,KAAK;EACV;CACF;AACF;AAEA,SAAS,YAAY,OAAc;CACjC,MAAM,OAAO,MAAM;CACnB,OAAO,SAAS,KAAA,KAAc,MAAM,QAAQ,IAAI,KAAK,KAAK,WAAW;AACvE;AAEA,SAAgB,uBACd,UACA,OACA;CACA,SAAS,iBAKP,QACA,OACA,QACA,WACA,qBACA,eACA,WACA;EACA,OAAO,IAAI,UACT,OACA,qBACA,QACA,WACA,eACA,WACA,UACA,gBAAgB,CAAC,EACnB;CACF;CAIA,OAAO;AACT"}
+{"version":3,"file":"solid-view.js","names":["#input","#format","#onDestroy","#retry","#updateTTL","#onTransactionCommit","#createEmptyRoot","#applyChangesToRoot","#setState","#makeError","#builderRoot","#transitionResultType","#hasUncommittedChanges","#pendingResultType","#pendingChanges","#applyChanges","#applyChangeToRoot"],"sources":["../../../../zero-solid/src/solid-view.ts"],"sourcesContent":["import {produce, reconcile, type SetStoreFunction} from 'solid-js/store';\nimport {emptyArray} from '../../shared/src/sentinels.ts';\nimport {ChangeIndex} from '../../zql/src/ivm/change-index.ts';\nimport {ChangeType} from '../../zql/src/ivm/change-type.ts';\nimport {\n  applyChange,\n  idSymbol,\n  skipYields,\n  type ViewChange,\n} from './bindings.ts';\nimport {\n  type AnyViewFactory,\n  type Change,\n  type Entry,\n  type ErroredQuery,\n  type Format,\n  type Input,\n  type Node,\n  type Output,\n  type Query,\n  type QueryErrorDetails,\n  type QueryResultDetails,\n  type Schema,\n  type Stream,\n  type TTL,\n} from './zero.ts';\n\nexport type State = [Entry, QueryResultDetails];\n\nexport const COMPLETE: QueryResultDetails = Object.freeze({type: 'complete'});\nexport const UNKNOWN: QueryResultDetails = Object.freeze({type: 'unknown'});\nexport const CACHED: QueryResultDetails = Object.freeze({type: 'cached'});\n\n/**\n * SolidView bridges Zero's incremental view updates with Solid's reactive\n * store.\n *\n * The challenge: Zero pushes individual row changes (add/remove/edit) as they\n * arrive, but updating Solid's store on each push is expensive. We batch\n * changes until transaction commit, then apply them all at once.\n *\n * Two code paths optimize for different scenarios:\n *\n *   1. BULK INSERT (builderRoot path): When building from empty, we skip\n *      Solid's reactive tracking entirely and build a plain JS object. This is\n *      5x faster for large initial loads. Uses reconcile() to diff the final\n *      result into Solid.\n *\n *   2. INCREMENTAL UPDATE (#pendingChanges path): For existing views, we queue\n *      changes and apply them in-place within a produce() draft. produce()\n *      creates a mutable draft, applyChange mutates it directly, then produce()\n *      handles diffing and reactivity.\n *\n *\n *   push(change)\n *       │\n *       ▼\n *   ┌─────────────────────────────────┐\n *   │ builderRoot defined?            │\n *   │ (building from empty)           │\n *   └─────────────────────────────────┘\n *       │yes                │no\n *       ▼                   ▼\n *   Build plain JS      Queue in\n *   object (fast)       #pendingChanges\n *       │                   │\n *       └───────┬───────────┘\n *               ▼\n *         onTransactionCommit()\n *               │\n *       ┌───────┴──────────┐\n *       │                  │\n *   builderRoot      produce(draft =>\n *   → reconcile()      applyChange(draft, ..., mutate: true))\n */\nexport class SolidView implements Output {\n  readonly #input: Input;\n  readonly #format: Format;\n  readonly #onDestroy: () => void;\n  readonly #retry: () => void;\n\n  #setState: SetStoreFunction<State>;\n\n  // Optimization: if the store is currently empty we build up\n  // the view on a plain old JS object stored at #builderRoot, and return\n  // that for the new state on transaction commit.  This avoids building up\n  // large views from scratch via solid produce.  The proxy object used by\n  // solid produce is slow and in this case we don't care about solid tracking\n  // the fine grained changes (everything has changed, it's all new).  For a\n  // test case with a view with 3000 rows, each row having 2 children, this\n  // optimization reduced #applyChanges time from 743ms to 133ms.\n  #builderRoot: Entry | undefined;\n  #pendingChanges: ViewChange[] = [];\n  // A result type transition requested while row changes are waiting for the\n  // next commit. It is applied with them, so a cached claim never reaches the\n  // store before the rows it is about.\n  #pendingResultType: ((prev: State) => State) | undefined;\n  readonly #updateTTL: (ttl: TTL) => void;\n\n  constructor(\n    input: Input,\n    onTransactionCommit: (cb: () => void) => void,\n    format: Format,\n    onDestroy: () => void,\n    queryComplete: true | ErroredQuery | Promise<true>,\n    updateTTL: (ttl: TTL) => void,\n    setState: SetStoreFunction<State>,\n    retry: () => void,\n  ) {\n    this.#input = input;\n    onTransactionCommit(this.#onTransactionCommit);\n    this.#format = format;\n    this.#onDestroy = onDestroy;\n    this.#updateTTL = updateTTL;\n    this.#retry = retry;\n\n    input.setOutput(this);\n\n    const initialRoot = this.#createEmptyRoot();\n    this.#applyChangesToRoot(\n      skipYields(input.fetch({})),\n      node => ({type: 'add', node}),\n      initialRoot,\n    );\n\n    this.#setState = setState;\n    this.#setState(\n      reconcile(\n        [\n          initialRoot,\n          queryComplete === true\n            ? COMPLETE\n            : 'error' in queryComplete\n              ? this.#makeError(queryComplete)\n              : UNKNOWN,\n        ],\n        {\n          // solidjs's types want a string, but a symbol works\n          key: idSymbol as unknown as string,\n        },\n      ),\n    );\n\n    if (isEmptyRoot(initialRoot)) {\n      this.#builderRoot = this.#createEmptyRoot();\n    }\n\n    if (queryComplete !== true && !('error' in queryComplete)) {\n      void queryComplete\n        .then(() => {\n          this.#setState(prev => [prev[0], COMPLETE]);\n        })\n        .catch((error: ErroredQuery) => {\n          this.#setState(prev => [prev[0], this.#makeError(error)]);\n        });\n    }\n  }\n\n  #makeError(error: ErroredQuery): QueryErrorDetails {\n    const message = error.message ?? 'An unknown error occurred';\n    return {\n      type: 'error',\n      retry: this.#retry,\n      refetch: this.#retry,\n      error: {\n        type: error.error,\n        message,\n        ...(error.details ? {details: error.details} : {}),\n      },\n    };\n  }\n\n  destroy(): void {\n    this.#onDestroy();\n  }\n\n  /**\n   * The store holds the server-confirmed result of this query from a\n   * previous connection. Never downgrades 'complete'/'error'; freshness stays\n   * a promise only the connection can keep, so nothing that waits on\n   * 'complete' resolves here.\n   */\n  markCached(): void {\n    this.#transitionResultType(prev =>\n      prev[1].type === 'unknown' ? [prev[0], CACHED] : prev,\n    );\n  }\n\n  /** The got key was deleted (eviction) before this connection confirmed it. */\n  unmarkCached(): void {\n    this.#transitionResultType(prev =>\n      prev[1].type === 'cached' ? [prev[0], UNKNOWN] : prev,\n    );\n  }\n\n  #transitionResultType(transition: (prev: State) => State): void {\n    if (this.#hasUncommittedChanges()) {\n      // The last requested transition wins; each is a no-op unless the state\n      // it expects is current, so the net effect at commit is correct.\n      this.#pendingResultType = transition;\n    } else {\n      this.#setState(transition);\n    }\n  }\n\n  #hasUncommittedChanges(): boolean {\n    return (\n      (this.#builderRoot !== undefined && !isEmptyRoot(this.#builderRoot)) ||\n      this.#pendingChanges.length > 0\n    );\n  }\n\n  #onTransactionCommit = () => {\n    const builderRoot = this.#builderRoot;\n    if (builderRoot) {\n      if (!isEmptyRoot(builderRoot)) {\n        this.#setState(\n          0,\n          reconcile(builderRoot, {\n            // solidjs's types want a string, but a symbol works\n            key: idSymbol as unknown as string,\n          }),\n        );\n        this.#builderRoot = undefined;\n      }\n    } else {\n      try {\n        this.#applyChanges(this.#pendingChanges, c => c);\n      } finally {\n        this.#pendingChanges = [];\n      }\n    }\n    const pendingResultType = this.#pendingResultType;\n    if (pendingResultType) {\n      this.#pendingResultType = undefined;\n      this.#setState(pendingResultType);\n    }\n  };\n\n  push(change: Change) {\n    // Delay updating the solid store state until the transaction commit\n    // (because each update of the solid store is quite expensive).  If\n    // this.#builderRoot is defined apply the changes to it (we are building\n    // from an empty root), otherwise queue the changes to be applied\n    // using produce at the end of the transaction but read the relationships\n    // now as they are only valid to read when the push is received.\n    if (this.#builderRoot) {\n      this.#applyChangeToRoot(\n        materializeRelationships(change),\n        this.#builderRoot,\n      );\n    } else {\n      this.#pendingChanges.push(materializeRelationships(change));\n    }\n    return emptyArray;\n  }\n\n  #applyChanges<T>(changes: Iterable<T>, mapper: (v: T) => ViewChange): void {\n    this.#setState(\n      produce((draftState: State) => {\n        this.#applyChangesToRoot<T>(changes, mapper, draftState[0]);\n        if (isEmptyRoot(draftState[0])) {\n          this.#builderRoot = this.#createEmptyRoot();\n        }\n      }),\n    );\n  }\n\n  #applyChangesToRoot<T>(\n    changes: Iterable<T>,\n    mapper: (v: T) => ViewChange,\n    root: Entry,\n  ) {\n    for (const change of changes) {\n      this.#applyChangeToRoot(mapper(change), root);\n    }\n  }\n\n  #applyChangeToRoot(change: ViewChange, root: Entry) {\n    applyChange(\n      root,\n      change,\n      this.#input.getSchema(),\n      '',\n      this.#format,\n      true /* withIDs */,\n      true /* mutate */,\n    );\n  }\n\n  #createEmptyRoot(): Entry {\n    return {\n      '': this.#format.singular ? undefined : [],\n    };\n  }\n\n  updateTTL(ttl: TTL): void {\n    this.#updateTTL(ttl);\n  }\n}\n\nfunction materializeRelationships(change: Change): ViewChange {\n  switch (change[ChangeIndex.TYPE]) {\n    case ChangeType.ADD:\n      return {\n        type: 'add',\n        node: materializeNodeRelationships(change[ChangeIndex.NODE]),\n      };\n    case ChangeType.REMOVE:\n      return {\n        type: 'remove',\n        node: materializeNodeRelationships(change[ChangeIndex.NODE]),\n      };\n    case ChangeType.CHILD:\n      return {\n        type: 'child',\n        node: {row: change[ChangeIndex.NODE].row},\n        child: {\n          relationshipName: change[ChangeIndex.CHILD_DATA].relationshipName,\n          change: materializeRelationships(\n            change[ChangeIndex.CHILD_DATA].change,\n          ),\n        },\n      };\n    case ChangeType.EDIT:\n      return {\n        type: 'edit',\n        node: {row: change[ChangeIndex.NODE].row},\n        oldNode: {row: change[ChangeIndex.OLD_NODE].row},\n      };\n  }\n}\n\nfunction materializeNodeRelationships(node: Node): Node {\n  const relationships: Record<string, () => Stream<Node>> = {};\n  for (const relationship in node.relationships) {\n    const materialized: Node[] = [];\n    for (const n of skipYields(node.relationships[relationship]())) {\n      materialized.push(materializeNodeRelationships(n));\n    }\n    relationships[relationship] = () => materialized;\n  }\n  return {\n    row: node.row,\n    relationships,\n  };\n}\n\nfunction isEmptyRoot(entry: Entry) {\n  const data = entry[''];\n  return data === undefined || (Array.isArray(data) && data.length === 0);\n}\n\nexport function createSolidViewFactory(\n  setState: SetStoreFunction<State>,\n  retry?: () => void,\n) {\n  function solidViewFactory<\n    TTable extends keyof TSchema['tables'] & string,\n    TSchema extends Schema,\n    TReturn,\n  >(\n    _query: Query<TTable, TSchema, TReturn>,\n    input: Input,\n    format: Format,\n    onDestroy: () => void,\n    onTransactionCommit: (cb: () => void) => void,\n    queryComplete: true | ErroredQuery | Promise<true>,\n    updateTTL: (ttl: TTL) => void,\n  ) {\n    return new SolidView(\n      input,\n      onTransactionCommit,\n      format,\n      onDestroy,\n      queryComplete,\n      updateTTL,\n      setState,\n      retry || (() => {}),\n    );\n  }\n\n  solidViewFactory satisfies AnyViewFactory;\n\n  return solidViewFactory;\n}\n"],"mappings":"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"}

package/out/zql/src/ivm/array-view.d.ts

@@ -25,5 +25,15 @@ export declare class ArrayView<V extends View> implements Output, TypedView<V> {
     push(change: Change): readonly never[];
     flush(): void;
     updateTTL(ttl: TTL): void;
+    /**
+     * The store holds the server-confirmed complete result of this query from a
+     * previous sync (the persisted got-queries key exists, pre-authoritative).
+     * Never downgrades 'complete'/'error', and never resolves anything that
+     * waits on 'complete' — freshness stays a promise only the connection can
+     * keep.
+     */
+    markCached(): void;
+    /** The got key was deleted (eviction) while still pre-authoritative. */
+    unmarkCached(): void;
 }
 //# sourceMappingURL=array-view.d.ts.map

package/out/zql/src/ivm/array-view.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"array-view.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/array-view.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,8CAA8C,CAAC;AAC/E,OAAO,KAAK,EAAC,GAAG,EAAC,MAAM,iBAAiB,CAAC;AACzC,OAAO,KAAK,EAAC,QAAQ,EAAc,SAAS,EAAC,MAAM,wBAAwB,CAAC;AAG5E,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AACxC,OAAO,EAAa,KAAK,KAAK,EAAE,KAAK,MAAM,EAAC,MAAM,eAAe,CAAC;AAGlE,OAAO,KAAK,EAAQ,MAAM,EAAE,IAAI,EAAC,MAAM,WAAW,CAAC;AA0BnD;;;;;;;;;;GAUG;AACH,qBAAa,SAAS,CAAC,CAAC,SAAS,IAAI,CAAE,YAAW,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC;;IAgBpE,SAAS,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,CAAC;IAcpC,YACE,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,MAAM,EACd,aAAa,EAAE,IAAI,GAAG,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,EAClD,SAAS,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,IAAI,EA0B9B;IAED,IAAI,IAAI,IACmB,CAAC,CAC3B;IAMD,WAAW,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,cAShC;IAYD,OAAO,SAEN;IAqBD,IAAI,CAAC,MAAM,EAAE,MAAM,oBAYlB;IAED,KAAK,SAUJ;IAED,SAAS,CAAC,GAAG,EAAE,GAAG,QAEjB;CACF"}
+{"version":3,"file":"array-view.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/array-view.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,8CAA8C,CAAC;AAC/E,OAAO,KAAK,EAAC,GAAG,EAAC,MAAM,iBAAiB,CAAC;AACzC,OAAO,KAAK,EAAC,QAAQ,EAAc,SAAS,EAAC,MAAM,wBAAwB,CAAC;AAG5E,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AACxC,OAAO,EAAa,KAAK,KAAK,EAAE,KAAK,MAAM,EAAC,MAAM,eAAe,CAAC;AAGlE,OAAO,KAAK,EAAQ,MAAM,EAAE,IAAI,EAAC,MAAM,WAAW,CAAC;AA0BnD;;;;;;;;;;GAUG;AACH,qBAAa,SAAS,CAAC,CAAC,SAAS,IAAI,CAAE,YAAW,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC;;IAgBpE,SAAS,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,CAAC;IAcpC,YACE,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,MAAM,EACd,aAAa,EAAE,IAAI,GAAG,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,EAClD,SAAS,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,IAAI,EAmB9B;IAED,IAAI,IAAI,IACmB,CAAC,CAC3B;IAMD,WAAW,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,cAShC;IAYD,OAAO,SAEN;IAqBD,IAAI,CAAC,MAAM,EAAE,MAAM,oBAYlB;IAED,KAAK,SAUJ;IAED,SAAS,CAAC,GAAG,EAAE,GAAG,QAEjB;IAED;;;;;;OAMG;IACH,UAAU,IAAI,IAAI,CAIjB;IAED,wEAAwE;IACxE,YAAY,IAAI,IAAI,CAInB;CAaF"}

package/out/zql/src/ivm/array-view.js

@@ -61,14 +61,7 @@ var ArrayView = class {
 		else if ("error" in queryComplete) {
 			this.#resultType = "error";
 			this.#error = queryComplete;
-		} else queryComplete.then(() => {
-			this.#resultType = "complete";
-			this.#fireListeners();
-		}).catch((e) => {
-			this.#resultType = "error";
-			this.#error = e;
-			this.#fireListeners();
-		});
+		} else queryComplete.then(() => this.#setResultType("complete")).catch((e) => this.#setResultType("error", e));
 		this.#hydrate();
 	}
 	get data() {
@@ -116,6 +109,25 @@ var ArrayView = class {
 	updateTTL(ttl) {
 		this.#updateTTL(ttl);
 	}
+	/**
+	* The store holds the server-confirmed complete result of this query from a
+	* previous sync (the persisted got-queries key exists, pre-authoritative).
+	* Never downgrades 'complete'/'error', and never resolves anything that
+	* waits on 'complete' — freshness stays a promise only the connection can
+	* keep.
+	*/
+	markCached() {
+		if (this.#resultType === "unknown") this.#setResultType("cached");
+	}
+	/** The got key was deleted (eviction) while still pre-authoritative. */
+	unmarkCached() {
+		if (this.#resultType === "cached") this.#setResultType("unknown");
+	}
+	#setResultType(resultType, error) {
+		this.#resultType = resultType;
+		this.#error = error;
+		if (!this.#dirty) this.#fireListeners();
+	}
 };
 //#endregion
 export { ArrayView };

package/out/zql/src/ivm/array-view.js.map

@@ -1 +1 @@
-{"version":3,"file":"array-view.js","names":["#input","#listeners","#format","#updateTTL","#root","#resultType","#error","#fireListeners","#hydrate","#schema","#fireListener","#dirty","#getSchema","#txnDirty"],"sources":["../../../../../zql/src/ivm/array-view.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport type {Immutable} from '../../../shared/src/immutable.ts';\nimport {emptyArray} from '../../../shared/src/sentinels.ts';\nimport type {ErroredQuery} from '../../../zero-protocol/src/custom-queries.ts';\nimport type {TTL} from '../query/ttl.ts';\nimport type {Listener, ResultType, TypedView} from '../query/typed-view.ts';\nimport {ChangeIndex} from './change-index.ts';\nimport {ChangeType} from './change-type.ts';\nimport type {Change} from './change.ts';\nimport {skipYields, type Input, type Output} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport {applyChange, type ViewChange} from './view-apply-change.ts';\nimport type {Entry, Format, View} from './view.ts';\n\nfunction changeToViewChange(change: Change): ViewChange {\n  switch (change[ChangeIndex.TYPE]) {\n    case ChangeType.ADD:\n      return {type: 'add', node: change[ChangeIndex.NODE]};\n    case ChangeType.REMOVE:\n      return {type: 'remove', node: change[ChangeIndex.NODE]};\n    case ChangeType.CHILD:\n      return {\n        type: 'child',\n        node: change[ChangeIndex.NODE],\n        child: {\n          relationshipName: change[ChangeIndex.CHILD_DATA].relationshipName,\n          change: changeToViewChange(change[ChangeIndex.CHILD_DATA].change),\n        },\n      };\n    case ChangeType.EDIT:\n      return {\n        type: 'edit',\n        node: change[ChangeIndex.NODE],\n        oldNode: change[ChangeIndex.OLD_NODE],\n      };\n  }\n}\n\n/**\n * Implements a materialized view of the output of an operator.\n *\n * It might seem more efficient to use an immutable b-tree for the\n * materialization, but it's not so clear. Inserts in the middle are\n * asymptotically slower in an array, but can often be done with zero\n * allocations, where changes to the b-tree will often require several allocs.\n *\n * Also the plain array view is more convenient for consumers since you can dump\n * it into console to see what it is, rather than having to iterate it.\n */\nexport class ArrayView<V extends View> implements Output, TypedView<V> {\n  readonly #input: Input;\n  readonly #listeners = new Set<Listener<V>>();\n  // Read lazily: a DeferredInput has no schema until its pipeline is attached,\n  // and the schema is only needed once there is a change to apply.\n  #schema: SourceSchema | undefined;\n  readonly #format: Format;\n\n  // Synthetic \"root\" entry that has a single \"\" relationship, so that we can\n  // treat all changes, including the root change, generically.\n  //\n  // applyChange is immutable: it returns a new root, preserving the references\n  // of unchanged subtrees so consumers (React.memo / Solid) can skip them. We\n  // therefore reassign #root on every change rather than mutating in place.\n  #root: Entry;\n\n  onDestroy: (() => void) | undefined;\n\n  #dirty = false;\n  #resultType: ResultType = 'unknown';\n  #error: ErroredQuery | undefined;\n  readonly #updateTTL: (ttl: TTL) => void;\n\n  // Objects/arrays created or cloned during the current (un-flushed)\n  // transaction. applyChange may mutate these in place rather than copying\n  // again, since they are not yet observed by any listener. Replaced at\n  // flush(), after which the committed snapshot must be copied-on-write again.\n  // A WeakSet (not a Set) so it never extends the lifetime of transient clones.\n  #txnDirty: WeakSet<object> = new WeakSet();\n\n  constructor(\n    input: Input,\n    format: Format,\n    queryComplete: true | ErroredQuery | Promise<true>,\n    updateTTL: (ttl: TTL) => void,\n  ) {\n    this.#input = input;\n    this.#format = format;\n    this.#updateTTL = updateTTL;\n    this.#root = {'': format.singular ? undefined : []};\n    input.setOutput(this);\n\n    if (queryComplete === true) {\n      this.#resultType = 'complete';\n    } else if ('error' in queryComplete) {\n      this.#resultType = 'error';\n      this.#error = queryComplete;\n    } else {\n      void queryComplete\n        .then(() => {\n          this.#resultType = 'complete';\n          this.#fireListeners();\n        })\n        .catch(e => {\n          this.#resultType = 'error';\n          this.#error = e;\n          this.#fireListeners();\n        });\n    }\n    this.#hydrate();\n  }\n\n  get data() {\n    return this.#root[''] as V;\n  }\n\n  #getSchema(): SourceSchema {\n    return (this.#schema ??= this.#input.getSchema());\n  }\n\n  addListener(listener: Listener<V>) {\n    assert(!this.#listeners.has(listener), 'Listener already registered');\n    this.#listeners.add(listener);\n\n    this.#fireListener(listener);\n\n    return () => {\n      this.#listeners.delete(listener);\n    };\n  }\n\n  #fireListeners() {\n    for (const listener of this.#listeners) {\n      this.#fireListener(listener);\n    }\n  }\n\n  #fireListener(listener: Listener<V>) {\n    listener(this.data as Immutable<V>, this.#resultType, this.#error);\n  }\n\n  destroy() {\n    this.onDestroy?.();\n  }\n\n  #hydrate() {\n    this.#dirty = true;\n    for (const node of skipYields(this.#input.fetch({}))) {\n      this.#root = applyChange(\n        this.#root,\n        {type: 'add', node},\n        this.#getSchema(),\n        '',\n        this.#format,\n        false /* withIDs */,\n        true /* mutate: #root is freshly created and not yet observed by any\n                 consumer, so build it in place to avoid O(N^2) array copies.\n                 Every later push() is immutable, preserving reference\n                 stability for unchanged subtrees. */,\n      );\n    }\n    this.flush();\n  }\n\n  push(change: Change) {\n    this.#dirty = true;\n    this.#root = applyChange(\n      this.#root,\n      changeToViewChange(change),\n      this.#getSchema(),\n      '',\n      this.#format,\n      false /* withIDs */,\n      this.#txnDirty /* mutate: copy-on-write within this transaction */,\n    );\n    return emptyArray;\n  }\n\n  flush() {\n    if (!this.#dirty) {\n      return;\n    }\n    this.#dirty = false;\n    this.#fireListeners();\n    // The snapshot just handed to listeners is now observed; the next\n    // transaction must copy-on-write rather than mutate these objects. A fresh\n    // WeakSet drops all \"owned\" marks (WeakSet has no clear()).\n    this.#txnDirty = new WeakSet();\n  }\n\n  updateTTL(ttl: TTL) {\n    this.#updateTTL(ttl);\n  }\n}\n"],"mappings":";;;;;AAcA,SAAS,mBAAmB,QAA4B;CACtD,QAAQ,OAAO,IAAf;EACE,KAAK,GACH,OAAO;GAAC,MAAM;GAAO,MAAM,OAAO;EAAiB;EACrD,KAAK,GACH,OAAO;GAAC,MAAM;GAAU,MAAM,OAAO;EAAiB;EACxD,KAAK,GACH,OAAO;GACL,MAAM;GACN,MAAM,OAAO;GACb,OAAO;IACL,kBAAkB,OAAO,GAAwB;IACjD,QAAQ,mBAAmB,OAAO,GAAwB,MAAM;GAClE;EACF;EACF,KAAK,GACH,OAAO;GACL,MAAM;GACN,MAAM,OAAO;GACb,SAAS,OAAO;EAClB;CACJ;AACF;;;;;;;;;;;;AAaA,IAAa,YAAb,MAAuE;CACrE;CACA,6BAAsB,IAAI,IAAiB;CAG3C;CACA;CAQA;CAEA;CAEA,SAAS;CACT,cAA0B;CAC1B;CACA;CAOA,4BAA6B,IAAI,QAAQ;CAEzC,YACE,OACA,QACA,eACA,WACA;EACA,KAAKA,SAAS;EACd,KAAKE,UAAU;EACf,KAAKC,aAAa;EAClB,KAAKC,QAAQ,EAAC,IAAI,OAAO,WAAW,KAAA,IAAY,CAAC,EAAC;EAClD,MAAM,UAAU,IAAI;EAEpB,IAAI,kBAAkB,MACpB,KAAKC,cAAc;OACd,IAAI,WAAW,eAAe;GACnC,KAAKA,cAAc;GACnB,KAAKC,SAAS;EAChB,OACE,cACG,WAAW;GACV,KAAKD,cAAc;GACnB,KAAKE,eAAe;EACtB,CAAC,EACA,OAAM,MAAK;GACV,KAAKF,cAAc;GACnB,KAAKC,SAAS;GACd,KAAKC,eAAe;EACtB,CAAC;EAEL,KAAKC,SAAS;CAChB;CAEA,IAAI,OAAO;EACT,OAAO,KAAKJ,MAAM;CACpB;CAEA,aAA2B;EACzB,OAAQ,KAAKK,YAAY,KAAKT,OAAO,UAAU;CACjD;CAEA,YAAY,UAAuB;EACjC,OAAO,CAAC,KAAKC,WAAW,IAAI,QAAQ,GAAG,6BAA6B;EACpE,KAAKA,WAAW,IAAI,QAAQ;EAE5B,KAAKS,cAAc,QAAQ;EAE3B,aAAa;GACX,KAAKT,WAAW,OAAO,QAAQ;EACjC;CACF;CAEA,iBAAiB;EACf,KAAK,MAAM,YAAY,KAAKA,YAC1B,KAAKS,cAAc,QAAQ;CAE/B;CAEA,cAAc,UAAuB;EACnC,SAAS,KAAK,MAAsB,KAAKL,aAAa,KAAKC,MAAM;CACnE;CAEA,UAAU;EACR,KAAK,YAAY;CACnB;CAEA,WAAW;EACT,KAAKK,SAAS;EACd,KAAK,MAAM,QAAQ,WAAW,KAAKX,OAAO,MAAM,CAAC,CAAC,CAAC,GACjD,KAAKI,QAAQ,YACX,KAAKA,OACL;GAAC,MAAM;GAAO;EAAI,GAClB,KAAKQ,WAAW,GAChB,IACA,KAAKV,SACL,OACA,IAIF;EAEF,KAAK,MAAM;CACb;CAEA,KAAK,QAAgB;EACnB,KAAKS,SAAS;EACd,KAAKP,QAAQ,YACX,KAAKA,OACL,mBAAmB,MAAM,GACzB,KAAKQ,WAAW,GAChB,IACA,KAAKV,SACL,OACA,KAAKW,SACP;EACA,OAAO;CACT;CAEA,QAAQ;EACN,IAAI,CAAC,KAAKF,QACR;EAEF,KAAKA,SAAS;EACd,KAAKJ,eAAe;EAIpB,KAAKM,4BAAY,IAAI,QAAQ;CAC/B;CAEA,UAAU,KAAU;EAClB,KAAKV,WAAW,GAAG;CACrB;AACF"}
+{"version":3,"file":"array-view.js","names":["#input","#listeners","#format","#updateTTL","#root","#resultType","#error","#setResultType","#hydrate","#schema","#fireListener","#dirty","#getSchema","#txnDirty","#fireListeners"],"sources":["../../../../../zql/src/ivm/array-view.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport type {Immutable} from '../../../shared/src/immutable.ts';\nimport {emptyArray} from '../../../shared/src/sentinels.ts';\nimport type {ErroredQuery} from '../../../zero-protocol/src/custom-queries.ts';\nimport type {TTL} from '../query/ttl.ts';\nimport type {Listener, ResultType, TypedView} from '../query/typed-view.ts';\nimport {ChangeIndex} from './change-index.ts';\nimport {ChangeType} from './change-type.ts';\nimport type {Change} from './change.ts';\nimport {skipYields, type Input, type Output} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport {applyChange, type ViewChange} from './view-apply-change.ts';\nimport type {Entry, Format, View} from './view.ts';\n\nfunction changeToViewChange(change: Change): ViewChange {\n  switch (change[ChangeIndex.TYPE]) {\n    case ChangeType.ADD:\n      return {type: 'add', node: change[ChangeIndex.NODE]};\n    case ChangeType.REMOVE:\n      return {type: 'remove', node: change[ChangeIndex.NODE]};\n    case ChangeType.CHILD:\n      return {\n        type: 'child',\n        node: change[ChangeIndex.NODE],\n        child: {\n          relationshipName: change[ChangeIndex.CHILD_DATA].relationshipName,\n          change: changeToViewChange(change[ChangeIndex.CHILD_DATA].change),\n        },\n      };\n    case ChangeType.EDIT:\n      return {\n        type: 'edit',\n        node: change[ChangeIndex.NODE],\n        oldNode: change[ChangeIndex.OLD_NODE],\n      };\n  }\n}\n\n/**\n * Implements a materialized view of the output of an operator.\n *\n * It might seem more efficient to use an immutable b-tree for the\n * materialization, but it's not so clear. Inserts in the middle are\n * asymptotically slower in an array, but can often be done with zero\n * allocations, where changes to the b-tree will often require several allocs.\n *\n * Also the plain array view is more convenient for consumers since you can dump\n * it into console to see what it is, rather than having to iterate it.\n */\nexport class ArrayView<V extends View> implements Output, TypedView<V> {\n  readonly #input: Input;\n  readonly #listeners = new Set<Listener<V>>();\n  // Read lazily: a DeferredInput has no schema until its pipeline is attached,\n  // and the schema is only needed once there is a change to apply.\n  #schema: SourceSchema | undefined;\n  readonly #format: Format;\n\n  // Synthetic \"root\" entry that has a single \"\" relationship, so that we can\n  // treat all changes, including the root change, generically.\n  //\n  // applyChange is immutable: it returns a new root, preserving the references\n  // of unchanged subtrees so consumers (React.memo / Solid) can skip them. We\n  // therefore reassign #root on every change rather than mutating in place.\n  #root: Entry;\n\n  onDestroy: (() => void) | undefined;\n\n  #dirty = false;\n  #resultType: ResultType = 'unknown';\n  #error: ErroredQuery | undefined;\n  readonly #updateTTL: (ttl: TTL) => void;\n\n  // Objects/arrays created or cloned during the current (un-flushed)\n  // transaction. applyChange may mutate these in place rather than copying\n  // again, since they are not yet observed by any listener. Replaced at\n  // flush(), after which the committed snapshot must be copied-on-write again.\n  // A WeakSet (not a Set) so it never extends the lifetime of transient clones.\n  #txnDirty: WeakSet<object> = new WeakSet();\n\n  constructor(\n    input: Input,\n    format: Format,\n    queryComplete: true | ErroredQuery | Promise<true>,\n    updateTTL: (ttl: TTL) => void,\n  ) {\n    this.#input = input;\n    this.#format = format;\n    this.#updateTTL = updateTTL;\n    this.#root = {'': format.singular ? undefined : []};\n    input.setOutput(this);\n\n    if (queryComplete === true) {\n      this.#resultType = 'complete';\n    } else if ('error' in queryComplete) {\n      this.#resultType = 'error';\n      this.#error = queryComplete;\n    } else {\n      void queryComplete\n        .then(() => this.#setResultType('complete'))\n        .catch(e => this.#setResultType('error', e));\n    }\n    this.#hydrate();\n  }\n\n  get data() {\n    return this.#root[''] as V;\n  }\n\n  #getSchema(): SourceSchema {\n    return (this.#schema ??= this.#input.getSchema());\n  }\n\n  addListener(listener: Listener<V>) {\n    assert(!this.#listeners.has(listener), 'Listener already registered');\n    this.#listeners.add(listener);\n\n    this.#fireListener(listener);\n\n    return () => {\n      this.#listeners.delete(listener);\n    };\n  }\n\n  #fireListeners() {\n    for (const listener of this.#listeners) {\n      this.#fireListener(listener);\n    }\n  }\n\n  #fireListener(listener: Listener<V>) {\n    listener(this.data as Immutable<V>, this.#resultType, this.#error);\n  }\n\n  destroy() {\n    this.onDestroy?.();\n  }\n\n  #hydrate() {\n    this.#dirty = true;\n    for (const node of skipYields(this.#input.fetch({}))) {\n      this.#root = applyChange(\n        this.#root,\n        {type: 'add', node},\n        this.#getSchema(),\n        '',\n        this.#format,\n        false /* withIDs */,\n        true /* mutate: #root is freshly created and not yet observed by any\n                 consumer, so build it in place to avoid O(N^2) array copies.\n                 Every later push() is immutable, preserving reference\n                 stability for unchanged subtrees. */,\n      );\n    }\n    this.flush();\n  }\n\n  push(change: Change) {\n    this.#dirty = true;\n    this.#root = applyChange(\n      this.#root,\n      changeToViewChange(change),\n      this.#getSchema(),\n      '',\n      this.#format,\n      false /* withIDs */,\n      this.#txnDirty /* mutate: copy-on-write within this transaction */,\n    );\n    return emptyArray;\n  }\n\n  flush() {\n    if (!this.#dirty) {\n      return;\n    }\n    this.#dirty = false;\n    this.#fireListeners();\n    // The snapshot just handed to listeners is now observed; the next\n    // transaction must copy-on-write rather than mutate these objects. A fresh\n    // WeakSet drops all \"owned\" marks (WeakSet has no clear()).\n    this.#txnDirty = new WeakSet();\n  }\n\n  updateTTL(ttl: TTL) {\n    this.#updateTTL(ttl);\n  }\n\n  /**\n   * The store holds the server-confirmed complete result of this query from a\n   * previous sync (the persisted got-queries key exists, pre-authoritative).\n   * Never downgrades 'complete'/'error', and never resolves anything that\n   * waits on 'complete' — freshness stays a promise only the connection can\n   * keep.\n   */\n  markCached(): void {\n    if (this.#resultType === 'unknown') {\n      this.#setResultType('cached');\n    }\n  }\n\n  /** The got key was deleted (eviction) while still pre-authoritative. */\n  unmarkCached(): void {\n    if (this.#resultType === 'cached') {\n      this.#setResultType('unknown');\n    }\n  }\n\n  #setResultType(resultType: ResultType, error?: ErroredQuery) {\n    this.#resultType = resultType;\n    this.#error = error;\n    // A dirty view is mid-transaction: rows were pushed and not yet flushed,\n    // and the objects in #txnDirty are still mutable. Firing now would hand\n    // those to listeners and then fire again at flush() with the same data, so\n    // let the pending flush deliver the new result type instead.\n    if (!this.#dirty) {\n      this.#fireListeners();\n    }\n  }\n}\n"],"mappings":";;;;;AAcA,SAAS,mBAAmB,QAA4B;CACtD,QAAQ,OAAO,IAAf;EACE,KAAK,GACH,OAAO;GAAC,MAAM;GAAO,MAAM,OAAO;EAAiB;EACrD,KAAK,GACH,OAAO;GAAC,MAAM;GAAU,MAAM,OAAO;EAAiB;EACxD,KAAK,GACH,OAAO;GACL,MAAM;GACN,MAAM,OAAO;GACb,OAAO;IACL,kBAAkB,OAAO,GAAwB;IACjD,QAAQ,mBAAmB,OAAO,GAAwB,MAAM;GAClE;EACF;EACF,KAAK,GACH,OAAO;GACL,MAAM;GACN,MAAM,OAAO;GACb,SAAS,OAAO;EAClB;CACJ;AACF;;;;;;;;;;;;AAaA,IAAa,YAAb,MAAuE;CACrE;CACA,6BAAsB,IAAI,IAAiB;CAG3C;CACA;CAQA;CAEA;CAEA,SAAS;CACT,cAA0B;CAC1B;CACA;CAOA,4BAA6B,IAAI,QAAQ;CAEzC,YACE,OACA,QACA,eACA,WACA;EACA,KAAKA,SAAS;EACd,KAAKE,UAAU;EACf,KAAKC,aAAa;EAClB,KAAKC,QAAQ,EAAC,IAAI,OAAO,WAAW,KAAA,IAAY,CAAC,EAAC;EAClD,MAAM,UAAU,IAAI;EAEpB,IAAI,kBAAkB,MACpB,KAAKC,cAAc;OACd,IAAI,WAAW,eAAe;GACnC,KAAKA,cAAc;GACnB,KAAKC,SAAS;EAChB,OACE,cACG,WAAW,KAAKC,eAAe,UAAU,CAAC,EAC1C,OAAM,MAAK,KAAKA,eAAe,SAAS,CAAC,CAAC;EAE/C,KAAKC,SAAS;CAChB;CAEA,IAAI,OAAO;EACT,OAAO,KAAKJ,MAAM;CACpB;CAEA,aAA2B;EACzB,OAAQ,KAAKK,YAAY,KAAKT,OAAO,UAAU;CACjD;CAEA,YAAY,UAAuB;EACjC,OAAO,CAAC,KAAKC,WAAW,IAAI,QAAQ,GAAG,6BAA6B;EACpE,KAAKA,WAAW,IAAI,QAAQ;EAE5B,KAAKS,cAAc,QAAQ;EAE3B,aAAa;GACX,KAAKT,WAAW,OAAO,QAAQ;EACjC;CACF;CAEA,iBAAiB;EACf,KAAK,MAAM,YAAY,KAAKA,YAC1B,KAAKS,cAAc,QAAQ;CAE/B;CAEA,cAAc,UAAuB;EACnC,SAAS,KAAK,MAAsB,KAAKL,aAAa,KAAKC,MAAM;CACnE;CAEA,UAAU;EACR,KAAK,YAAY;CACnB;CAEA,WAAW;EACT,KAAKK,SAAS;EACd,KAAK,MAAM,QAAQ,WAAW,KAAKX,OAAO,MAAM,CAAC,CAAC,CAAC,GACjD,KAAKI,QAAQ,YACX,KAAKA,OACL;GAAC,MAAM;GAAO;EAAI,GAClB,KAAKQ,WAAW,GAChB,IACA,KAAKV,SACL,OACA,IAIF;EAEF,KAAK,MAAM;CACb;CAEA,KAAK,QAAgB;EACnB,KAAKS,SAAS;EACd,KAAKP,QAAQ,YACX,KAAKA,OACL,mBAAmB,MAAM,GACzB,KAAKQ,WAAW,GAChB,IACA,KAAKV,SACL,OACA,KAAKW,SACP;EACA,OAAO;CACT;CAEA,QAAQ;EACN,IAAI,CAAC,KAAKF,QACR;EAEF,KAAKA,SAAS;EACd,KAAKG,eAAe;EAIpB,KAAKD,4BAAY,IAAI,QAAQ;CAC/B;CAEA,UAAU,KAAU;EAClB,KAAKV,WAAW,GAAG;CACrB;;;;;;;;CASA,aAAmB;EACjB,IAAI,KAAKE,gBAAgB,WACvB,KAAKE,eAAe,QAAQ;CAEhC;;CAGA,eAAqB;EACnB,IAAI,KAAKF,gBAAgB,UACvB,KAAKE,eAAe,SAAS;CAEjC;CAEA,eAAe,YAAwB,OAAsB;EAC3D,KAAKF,cAAc;EACnB,KAAKC,SAAS;EAKd,IAAI,CAAC,KAAKK,QACR,KAAKG,eAAe;CAExB;AACF"}

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

@@ -1 +1 @@
-{"version":3,"file":"cap.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/cap.ts"],"names":[],"mappings":"AAKA,OAAO,EAAgB,KAAK,MAAM,EAAkB,MAAM,aAAa,CAAC;AAExE,OAAO,KAAK,EAAa,IAAI,EAAC,MAAM,WAAW,CAAC;AAChD,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,KAAK,EACV,KAAK,QAAQ,EACb,KAAK,MAAM,EACX,KAAK,OAAO,EACb,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAC,KAAK,MAAM,EAAC,MAAM,aAAa,CAAC;AACxC,OAAO,EAGL,KAAK,YAAY,EAClB,MAAM,WAAW,CAAC;AAanB;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,GAAI,YAAW,QAAQ;;IAUlC,YACE,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,MAAM,EACb,YAAY,CAAC,EAAE,YAAY,EAW5B;IAED,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAE9B;IAED,SAAS,IAAI,YAAY,CAExB;IAEA,KAAK,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC,CAoChD;IAsDA,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,CAiFrC;IAqCD,OAAO,IAAI,IAAI,CAEd;CACF"}
+{"version":3,"file":"cap.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/cap.ts"],"names":[],"mappings":"AAMA,OAAO,EAAgB,KAAK,MAAM,EAAkB,MAAM,aAAa,CAAC;AAExE,OAAO,KAAK,EAAa,IAAI,EAAC,MAAM,WAAW,CAAC;AAChD,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,KAAK,EACV,KAAK,QAAQ,EACb,KAAK,MAAM,EACX,KAAK,OAAO,EACb,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAC,KAAK,MAAM,EAAC,MAAM,aAAa,CAAC;AACxC,OAAO,EAGL,KAAK,YAAY,EAClB,MAAM,WAAW,CAAC;AAanB;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,GAAI,YAAW,QAAQ;;IAUlC,YACE,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,MAAM,EACb,YAAY,CAAC,EAAE,YAAY,EAW5B;IAED,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAE9B;IAED,SAAS,IAAI,YAAY,CAExB;IAEA,KAAK,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC,CAoChD;IAsDA,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,CAiFrC;IAsCD,OAAO,IAAI,IAAI,CAEd;CACF"}

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

@@ -1,4 +1,5 @@
 import { assert } from "../../../shared/src/asserts.js";
+import { emptyArray } from "../../../shared/src/sentinels.js";
 import { throwOutput } from "./operator.js";
 import { makeAddChange } from "./change.js";
 import { constraintMatchesPartitionKey, makePartitionKeyComparator } from "./take.js";
@@ -163,11 +164,11 @@ var Cap = class {
 			if (new Set(capState.pks).has(pk)) yield* this.#output.push(change, this);
 		}
 	}
-	*#pushEditChange(change) {
+	#pushEditChange(change) {
 		assert(!this.#partitionKeyComparator || this.#partitionKeyComparator(change[2].row, change[1].row) === 0, "Unexpected change of partition key");
 		const capStateKey = getCapStateKey(this.#partitionKey, change[2].row);
 		const capState = this.#storage.get(capStateKey);
-		if (!capState) return;
+		if (!capState) return emptyArray;
 		const oldPK = serializePK(change[2].row, this.#primaryKey);
 		if (new Set(capState.pks).has(oldPK)) {
 			const newPK = serializePK(change[1].row, this.#primaryKey);
@@ -178,8 +179,9 @@ var Cap = class {
 					pks
 				});
 			}
-			yield* this.#output.push(change, this);
+			return this.#output.push(change, this);
 		}
+		return emptyArray;
 	}
 	destroy() {
 		this.#input.destroy();

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

@@ -1 +1 @@
-{"version":3,"file":"cap.js","names":["#input","#storage","#limit","#partitionKey","#partitionKeyComparator","#primaryKey","#output","#initialFetch","#pushEditChange"],"sources":["../../../../../zql/src/ivm/cap.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport type {Row, Value} from '../../../zero-protocol/src/data.ts';\nimport type {PrimaryKey} from '../../../zero-protocol/src/primary-key.ts';\nimport {ChangeIndex} from './change-index.ts';\nimport {ChangeType} from './change-type.ts';\nimport {makeAddChange, type Change, type EditChange} from './change.ts';\nimport type {Constraint} from './constraint.ts';\nimport type {Comparator, Node} from './data.ts';\nimport {\n  throwOutput,\n  type FetchRequest,\n  type Input,\n  type Operator,\n  type Output,\n  type Storage,\n} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport {type Stream} from './stream.ts';\nimport {\n  constraintMatchesPartitionKey,\n  makePartitionKeyComparator,\n  type PartitionKey,\n} from './take.ts';\n\ntype CapState = {\n  size: number;\n  pks: string[];\n};\n\ninterface CapStorage {\n  get(key: string): CapState | undefined;\n  set(key: string, value: CapState): void;\n  del(key: string): void;\n}\n\n/**\n * The Cap operator is a count-based limiter for EXISTS subqueries that\n * does not require ordering. Unlike Take, it tracks membership by primary\n * key set rather than by a sorted bound. This means:\n *\n * - No comparator needed (no ordering requirement)\n * - No `start` or `reverse` fetch support\n * - No `#rowHiddenFromFetch` complexity (we can defer when adding to the pk set)\n *\n * Cap is used in EXISTS child pipelines where only the count of matching\n * rows matters, not their order. This allows SQLite to skip ORDER BY\n * entirely, enabling much faster query plans.\n *\n * Cap can count rows globally or by unique value of some partition key\n * (same as Take).\n */\nexport class Cap implements Operator {\n  readonly #input: Input;\n  readonly #storage: CapStorage;\n  readonly #limit: number;\n  readonly #partitionKey: PartitionKey | undefined;\n  readonly #partitionKeyComparator: Comparator | undefined;\n  readonly #primaryKey: PrimaryKey;\n\n  #output: Output = throwOutput;\n\n  constructor(\n    input: Input,\n    storage: Storage,\n    limit: number,\n    partitionKey?: PartitionKey,\n  ) {\n    assert(limit >= 0, 'Limit must be non-negative');\n    input.setOutput(this);\n    this.#input = input;\n    this.#storage = storage as CapStorage;\n    this.#limit = limit;\n    this.#partitionKey = partitionKey;\n    this.#partitionKeyComparator =\n      partitionKey && makePartitionKeyComparator(partitionKey);\n    this.#primaryKey = input.getSchema().primaryKey;\n  }\n\n  setOutput(output: Output): void {\n    this.#output = output;\n  }\n\n  getSchema(): SourceSchema {\n    return this.#input.getSchema();\n  }\n\n  *fetch(req: FetchRequest): Stream<Node | 'yield'> {\n    assert(!req.start, 'Cap does not support start');\n    assert(!req.reverse, 'Cap does not support reverse');\n\n    // Cap is only built for non-flipped EXISTS subqueries, whose only\n    // downstream consumer is a Join that always fetches with a constraint\n    // built from the correlation's childField — which is Cap's partition\n    // key. So either partitionKey is undefined, or constraint matches.\n    assert(\n      !this.#partitionKey ||\n        (req.constraint !== undefined &&\n          constraintMatchesPartitionKey(req.constraint, this.#partitionKey)),\n      'Cap fetch: constraint must match partition key when partitioned',\n    );\n\n    const capStateKey = getCapStateKey(this.#partitionKey, req.constraint);\n    const capState = this.#storage.get(capStateKey);\n    if (!capState) {\n      yield* this.#initialFetch(req);\n      return;\n    }\n    if (capState.size === 0) {\n      return;\n    }\n    // PK-based point lookups: fetch each tracked row by its PK directly,\n    // rather than scanning the partition and filtering.\n    for (const pk of capState.pks) {\n      const constraint = deserializePKToConstraint(pk, this.#primaryKey);\n      for (const inputNode of this.#input.fetch({constraint})) {\n        if (inputNode === 'yield') {\n          yield inputNode;\n          continue;\n        }\n        yield inputNode;\n      }\n    }\n  }\n\n  *#initialFetch(req: FetchRequest): Stream<Node | 'yield'> {\n    if (this.#limit === 0) {\n      return;\n    }\n\n    assert(\n      constraintMatchesPartitionKey(req.constraint, this.#partitionKey),\n      'Constraint should match partition key',\n    );\n\n    const capStateKey = getCapStateKey(this.#partitionKey, req.constraint);\n    assert(\n      this.#storage.get(capStateKey) === undefined,\n      'Cap state should be undefined',\n    );\n\n    let size = 0;\n    const pks: string[] = [];\n    let downstreamEarlyReturn = true;\n    let exceptionThrown = false;\n    try {\n      for (const inputNode of this.#input.fetch(req)) {\n        if (inputNode === 'yield') {\n          yield 'yield';\n          continue;\n        }\n        yield inputNode;\n        pks.push(serializePK(inputNode.row, this.#primaryKey));\n        size++;\n        if (size === this.#limit) {\n          break;\n        }\n      }\n      downstreamEarlyReturn = false;\n    } catch (e) {\n      exceptionThrown = true;\n      throw e;\n    } finally {\n      if (!exceptionThrown) {\n        this.#storage.set(capStateKey, {size, pks});\n        // If it becomes necessary to support downstream early return, this\n        // assert should be removed, and replaced with code that consumes\n        // the input stream until limit is reached or the input stream is\n        // exhausted so that capState is properly hydrated.\n        assert(\n          !downstreamEarlyReturn,\n          'Unexpected early return prevented full hydration',\n        );\n      }\n    }\n  }\n\n  *push(change: Change): Stream<'yield'> {\n    if (change[ChangeIndex.TYPE] === ChangeType.EDIT) {\n      yield* this.#pushEditChange(change);\n      return;\n    }\n\n    const capStateKey = getCapStateKey(\n      this.#partitionKey,\n      change[ChangeIndex.NODE].row,\n    );\n    const capState = this.#storage.get(capStateKey);\n    if (!capState) {\n      return;\n    }\n\n    const pk = serializePK(change[ChangeIndex.NODE].row, this.#primaryKey);\n\n    if (change[ChangeIndex.TYPE] === ChangeType.ADD) {\n      if (capState.size < this.#limit) {\n        const pks = [...capState.pks, pk];\n        this.#storage.set(capStateKey, {size: capState.size + 1, pks});\n        yield* this.#output.push(change, this);\n        return;\n      }\n      // Full — drop\n      return;\n    } else if (change[ChangeIndex.TYPE] === ChangeType.REMOVE) {\n      const pkIndex = capState.pks.indexOf(pk);\n      if (pkIndex === -1) {\n        // Not in our set — drop\n        return;\n      }\n      // Remove from set\n      const pks = [...capState.pks];\n      pks.splice(pkIndex, 1);\n      const newSize = capState.size - 1;\n\n      // Try to refill: fetch from input with partition constraint,\n      // find first row NOT in PK set\n      const pkSet = new Set(pks);\n      const constraint = this.#partitionKey\n        ? (Object.fromEntries(\n            this.#partitionKey.map(\n              key => [key, change[ChangeIndex.NODE].row[key]] as const,\n            ),\n          ) as Constraint)\n        : undefined;\n\n      let replacement: Node | undefined;\n      for (const node of this.#input.fetch({constraint})) {\n        if (node === 'yield') {\n          yield node;\n          continue;\n        }\n        const nodePK = serializePK(node.row, this.#primaryKey);\n        if (!pkSet.has(nodePK)) {\n          replacement = node;\n          break;\n        }\n      }\n\n      if (replacement) {\n        // Store state WITHOUT replacement during remove forward,\n        // matching Take's pattern of hiding in-flight changes from re-fetches.\n        this.#storage.set(capStateKey, {size: newSize, pks});\n        yield* this.#output.push(change, this);\n        // Now add replacement to set and forward the add.\n        const replacementPK = serializePK(replacement.row, this.#primaryKey);\n        pks.push(replacementPK);\n        this.#storage.set(capStateKey, {size: newSize + 1, pks});\n        yield* this.#output.push(makeAddChange(replacement), this);\n      } else {\n        this.#storage.set(capStateKey, {size: newSize, pks});\n        yield* this.#output.push(change, this);\n      }\n    } else if (change[ChangeIndex.TYPE] === ChangeType.CHILD) {\n      const pkSet = new Set(capState.pks);\n      if (pkSet.has(pk)) {\n        yield* this.#output.push(change, this);\n      }\n    }\n  }\n\n  *#pushEditChange(change: EditChange): Stream<'yield'> {\n    assert(\n      !this.#partitionKeyComparator ||\n        this.#partitionKeyComparator(\n          change[ChangeIndex.OLD_NODE].row,\n          change[ChangeIndex.NODE].row,\n        ) === 0,\n      'Unexpected change of partition key',\n    );\n    const capStateKey = getCapStateKey(\n      this.#partitionKey,\n      change[ChangeIndex.OLD_NODE].row,\n    );\n    const capState = this.#storage.get(capStateKey);\n    if (!capState) {\n      return;\n    }\n\n    const oldPK = serializePK(\n      change[ChangeIndex.OLD_NODE].row,\n      this.#primaryKey,\n    );\n    const pkSet = new Set(capState.pks);\n    if (pkSet.has(oldPK)) {\n      // Update the PK in our set if it changed\n      const newPK = serializePK(change[ChangeIndex.NODE].row, this.#primaryKey);\n      if (oldPK !== newPK) {\n        const pks = capState.pks.map(p => (p === oldPK ? newPK : p));\n        this.#storage.set(capStateKey, {size: capState.size, pks});\n      }\n      yield* this.#output.push(change, this);\n    }\n    // If not in our set, drop\n  }\n\n  destroy(): void {\n    this.#input.destroy();\n  }\n}\n\nfunction getCapStateKey(\n  partitionKey: PartitionKey | undefined,\n  rowOrConstraint: Row | Constraint | undefined,\n): string {\n  const partitionValues: Value[] = [];\n\n  if (partitionKey && rowOrConstraint) {\n    for (const key of partitionKey) {\n      partitionValues.push(rowOrConstraint[key]);\n    }\n  }\n\n  return JSON.stringify(['cap', ...partitionValues]);\n}\n\nfunction serializePK(row: Row, primaryKey: PrimaryKey): string {\n  return JSON.stringify(primaryKey.map(k => row[k]));\n}\n\nfunction deserializePKToConstraint(\n  pk: string,\n  primaryKey: PrimaryKey,\n): Constraint {\n  const values = JSON.parse(pk) as Value[];\n  const constraint: Record<string, Value> = {};\n  for (let i = 0; i < primaryKey.length; i++) {\n    constraint[primaryKey[i]] = values[i];\n  }\n  return constraint;\n}\n"],"mappings":"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"}
+{"version":3,"file":"cap.js","names":["#input","#storage","#limit","#partitionKey","#partitionKeyComparator","#primaryKey","#output","#initialFetch","#pushEditChange"],"sources":["../../../../../zql/src/ivm/cap.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport {emptyArray} from '../../../shared/src/sentinels.ts';\nimport type {Row, Value} from '../../../zero-protocol/src/data.ts';\nimport type {PrimaryKey} from '../../../zero-protocol/src/primary-key.ts';\nimport {ChangeIndex} from './change-index.ts';\nimport {ChangeType} from './change-type.ts';\nimport {makeAddChange, type Change, type EditChange} from './change.ts';\nimport type {Constraint} from './constraint.ts';\nimport type {Comparator, Node} from './data.ts';\nimport {\n  throwOutput,\n  type FetchRequest,\n  type Input,\n  type Operator,\n  type Output,\n  type Storage,\n} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport {type Stream} from './stream.ts';\nimport {\n  constraintMatchesPartitionKey,\n  makePartitionKeyComparator,\n  type PartitionKey,\n} from './take.ts';\n\ntype CapState = {\n  size: number;\n  pks: string[];\n};\n\ninterface CapStorage {\n  get(key: string): CapState | undefined;\n  set(key: string, value: CapState): void;\n  del(key: string): void;\n}\n\n/**\n * The Cap operator is a count-based limiter for EXISTS subqueries that\n * does not require ordering. Unlike Take, it tracks membership by primary\n * key set rather than by a sorted bound. This means:\n *\n * - No comparator needed (no ordering requirement)\n * - No `start` or `reverse` fetch support\n * - No `#rowHiddenFromFetch` complexity (we can defer when adding to the pk set)\n *\n * Cap is used in EXISTS child pipelines where only the count of matching\n * rows matters, not their order. This allows SQLite to skip ORDER BY\n * entirely, enabling much faster query plans.\n *\n * Cap can count rows globally or by unique value of some partition key\n * (same as Take).\n */\nexport class Cap implements Operator {\n  readonly #input: Input;\n  readonly #storage: CapStorage;\n  readonly #limit: number;\n  readonly #partitionKey: PartitionKey | undefined;\n  readonly #partitionKeyComparator: Comparator | undefined;\n  readonly #primaryKey: PrimaryKey;\n\n  #output: Output = throwOutput;\n\n  constructor(\n    input: Input,\n    storage: Storage,\n    limit: number,\n    partitionKey?: PartitionKey,\n  ) {\n    assert(limit >= 0, 'Limit must be non-negative');\n    input.setOutput(this);\n    this.#input = input;\n    this.#storage = storage as CapStorage;\n    this.#limit = limit;\n    this.#partitionKey = partitionKey;\n    this.#partitionKeyComparator =\n      partitionKey && makePartitionKeyComparator(partitionKey);\n    this.#primaryKey = input.getSchema().primaryKey;\n  }\n\n  setOutput(output: Output): void {\n    this.#output = output;\n  }\n\n  getSchema(): SourceSchema {\n    return this.#input.getSchema();\n  }\n\n  *fetch(req: FetchRequest): Stream<Node | 'yield'> {\n    assert(!req.start, 'Cap does not support start');\n    assert(!req.reverse, 'Cap does not support reverse');\n\n    // Cap is only built for non-flipped EXISTS subqueries, whose only\n    // downstream consumer is a Join that always fetches with a constraint\n    // built from the correlation's childField — which is Cap's partition\n    // key. So either partitionKey is undefined, or constraint matches.\n    assert(\n      !this.#partitionKey ||\n        (req.constraint !== undefined &&\n          constraintMatchesPartitionKey(req.constraint, this.#partitionKey)),\n      'Cap fetch: constraint must match partition key when partitioned',\n    );\n\n    const capStateKey = getCapStateKey(this.#partitionKey, req.constraint);\n    const capState = this.#storage.get(capStateKey);\n    if (!capState) {\n      yield* this.#initialFetch(req);\n      return;\n    }\n    if (capState.size === 0) {\n      return;\n    }\n    // PK-based point lookups: fetch each tracked row by its PK directly,\n    // rather than scanning the partition and filtering.\n    for (const pk of capState.pks) {\n      const constraint = deserializePKToConstraint(pk, this.#primaryKey);\n      for (const inputNode of this.#input.fetch({constraint})) {\n        if (inputNode === 'yield') {\n          yield inputNode;\n          continue;\n        }\n        yield inputNode;\n      }\n    }\n  }\n\n  *#initialFetch(req: FetchRequest): Stream<Node | 'yield'> {\n    if (this.#limit === 0) {\n      return;\n    }\n\n    assert(\n      constraintMatchesPartitionKey(req.constraint, this.#partitionKey),\n      'Constraint should match partition key',\n    );\n\n    const capStateKey = getCapStateKey(this.#partitionKey, req.constraint);\n    assert(\n      this.#storage.get(capStateKey) === undefined,\n      'Cap state should be undefined',\n    );\n\n    let size = 0;\n    const pks: string[] = [];\n    let downstreamEarlyReturn = true;\n    let exceptionThrown = false;\n    try {\n      for (const inputNode of this.#input.fetch(req)) {\n        if (inputNode === 'yield') {\n          yield 'yield';\n          continue;\n        }\n        yield inputNode;\n        pks.push(serializePK(inputNode.row, this.#primaryKey));\n        size++;\n        if (size === this.#limit) {\n          break;\n        }\n      }\n      downstreamEarlyReturn = false;\n    } catch (e) {\n      exceptionThrown = true;\n      throw e;\n    } finally {\n      if (!exceptionThrown) {\n        this.#storage.set(capStateKey, {size, pks});\n        // If it becomes necessary to support downstream early return, this\n        // assert should be removed, and replaced with code that consumes\n        // the input stream until limit is reached or the input stream is\n        // exhausted so that capState is properly hydrated.\n        assert(\n          !downstreamEarlyReturn,\n          'Unexpected early return prevented full hydration',\n        );\n      }\n    }\n  }\n\n  *push(change: Change): Stream<'yield'> {\n    if (change[ChangeIndex.TYPE] === ChangeType.EDIT) {\n      yield* this.#pushEditChange(change);\n      return;\n    }\n\n    const capStateKey = getCapStateKey(\n      this.#partitionKey,\n      change[ChangeIndex.NODE].row,\n    );\n    const capState = this.#storage.get(capStateKey);\n    if (!capState) {\n      return;\n    }\n\n    const pk = serializePK(change[ChangeIndex.NODE].row, this.#primaryKey);\n\n    if (change[ChangeIndex.TYPE] === ChangeType.ADD) {\n      if (capState.size < this.#limit) {\n        const pks = [...capState.pks, pk];\n        this.#storage.set(capStateKey, {size: capState.size + 1, pks});\n        yield* this.#output.push(change, this);\n        return;\n      }\n      // Full — drop\n      return;\n    } else if (change[ChangeIndex.TYPE] === ChangeType.REMOVE) {\n      const pkIndex = capState.pks.indexOf(pk);\n      if (pkIndex === -1) {\n        // Not in our set — drop\n        return;\n      }\n      // Remove from set\n      const pks = [...capState.pks];\n      pks.splice(pkIndex, 1);\n      const newSize = capState.size - 1;\n\n      // Try to refill: fetch from input with partition constraint,\n      // find first row NOT in PK set\n      const pkSet = new Set(pks);\n      const constraint = this.#partitionKey\n        ? (Object.fromEntries(\n            this.#partitionKey.map(\n              key => [key, change[ChangeIndex.NODE].row[key]] as const,\n            ),\n          ) as Constraint)\n        : undefined;\n\n      let replacement: Node | undefined;\n      for (const node of this.#input.fetch({constraint})) {\n        if (node === 'yield') {\n          yield node;\n          continue;\n        }\n        const nodePK = serializePK(node.row, this.#primaryKey);\n        if (!pkSet.has(nodePK)) {\n          replacement = node;\n          break;\n        }\n      }\n\n      if (replacement) {\n        // Store state WITHOUT replacement during remove forward,\n        // matching Take's pattern of hiding in-flight changes from re-fetches.\n        this.#storage.set(capStateKey, {size: newSize, pks});\n        yield* this.#output.push(change, this);\n        // Now add replacement to set and forward the add.\n        const replacementPK = serializePK(replacement.row, this.#primaryKey);\n        pks.push(replacementPK);\n        this.#storage.set(capStateKey, {size: newSize + 1, pks});\n        yield* this.#output.push(makeAddChange(replacement), this);\n      } else {\n        this.#storage.set(capStateKey, {size: newSize, pks});\n        yield* this.#output.push(change, this);\n      }\n    } else if (change[ChangeIndex.TYPE] === ChangeType.CHILD) {\n      const pkSet = new Set(capState.pks);\n      if (pkSet.has(pk)) {\n        yield* this.#output.push(change, this);\n      }\n    }\n  }\n\n  #pushEditChange(change: EditChange): Stream<'yield'> {\n    assert(\n      !this.#partitionKeyComparator ||\n        this.#partitionKeyComparator(\n          change[ChangeIndex.OLD_NODE].row,\n          change[ChangeIndex.NODE].row,\n        ) === 0,\n      'Unexpected change of partition key',\n    );\n    const capStateKey = getCapStateKey(\n      this.#partitionKey,\n      change[ChangeIndex.OLD_NODE].row,\n    );\n    const capState = this.#storage.get(capStateKey);\n    if (!capState) {\n      return emptyArray;\n    }\n\n    const oldPK = serializePK(\n      change[ChangeIndex.OLD_NODE].row,\n      this.#primaryKey,\n    );\n    const pkSet = new Set(capState.pks);\n    if (pkSet.has(oldPK)) {\n      // Update the PK in our set if it changed\n      const newPK = serializePK(change[ChangeIndex.NODE].row, this.#primaryKey);\n      if (oldPK !== newPK) {\n        const pks = capState.pks.map(p => (p === oldPK ? newPK : p));\n        this.#storage.set(capStateKey, {size: capState.size, pks});\n      }\n      return this.#output.push(change, this);\n    }\n    // If not in our set, drop\n    return emptyArray;\n  }\n\n  destroy(): void {\n    this.#input.destroy();\n  }\n}\n\nfunction getCapStateKey(\n  partitionKey: PartitionKey | undefined,\n  rowOrConstraint: Row | Constraint | undefined,\n): string {\n  const partitionValues: Value[] = [];\n\n  if (partitionKey && rowOrConstraint) {\n    for (const key of partitionKey) {\n      partitionValues.push(rowOrConstraint[key]);\n    }\n  }\n\n  return JSON.stringify(['cap', ...partitionValues]);\n}\n\nfunction serializePK(row: Row, primaryKey: PrimaryKey): string {\n  return JSON.stringify(primaryKey.map(k => row[k]));\n}\n\nfunction deserializePKToConstraint(\n  pk: string,\n  primaryKey: PrimaryKey,\n): Constraint {\n  const values = JSON.parse(pk) as Value[];\n  const constraint: Record<string, Value> = {};\n  for (let i = 0; i < primaryKey.length; i++) {\n    constraint[primaryKey[i]] = values[i];\n  }\n  return constraint;\n}\n"],"mappings":"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"}

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

@@ -1 +1 @@
-{"version":3,"file":"deferred-input.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/deferred-input.ts"],"names":[],"mappings":"AAEA,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;IACH,YAAY,MAAM,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,KAAK,EAGnD;IAED,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAED,IAAI,SAAS,IAAI,OAAO,CAEvB;IAED,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAG9B;IAED,SAAS,IAAI,YAAY,CAExB;IAEA,KAAK,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC,CAIhD;IAED,OAAO,IAAI,IAAI,CAGd;IAED;;;;;;;;OAQG;IACH,MAAM,IAAI,IAAI,CAuBb;CACF"}
+{"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;IACH,YAAY,MAAM,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,KAAK,EAGnD;IAED,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAED,IAAI,SAAS,IAAI,OAAO,CAEvB;IAED,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAG9B;IAED,SAAS,IAAI,YAAY,CAExB;IAED,KAAK,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC,CAE/C;IAED,OAAO,IAAI,IAAI,CAGd;IAED;;;;;;;;OAQG;IACH,MAAM,IAAI,IAAI,CAuBb;CACF"}

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

@@ -1,4 +1,5 @@
 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
@@ -44,8 +45,8 @@ var DeferredInput = class {
 	getSchema() {
 		return this.#schema;
 	}
-	*fetch(req) {
-		if (this.#input) yield* this.#input.fetch(req);
+	fetch(req) {
+		return this.#input ? this.#input.fetch(req) : emptyArray;
 	}
 	destroy() {
 		this.#destroyed = true;

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

@@ -1 +1 @@
-{"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 {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    if (this.#input) {\n      yield* this.#input.fetch(req);\n    }\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":";;;;;;;;;;;;;;;;;AAoBA,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,CAAC,MAAM,KAA2C;EAChD,IAAI,KAAKE,QACP,OAAO,KAAKA,OAAO,MAAM,GAAG;CAEhC;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"}
+{"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/ivm/exists.d.ts

@@ -14,7 +14,7 @@ export declare class Exists implements FilterOperator {
     setFilterOutput(output: FilterOutput): void;
     beginFilter(): void;
     endFilter(): void;
-    filter(node: Node): Generator<'yield', boolean>;
+    filter(node: Node): IterableIterator<'yield', boolean>;
     destroy(): void;
     getSchema(): SourceSchema;
     push(change: Change): Stream<'yield'>;

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

@@ -1 +1 @@
-{"version":3,"file":"exists.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/exists.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,mCAAmC,CAAC;AAGnE,OAAO,EAAkC,KAAK,MAAM,EAAC,MAAM,aAAa,CAAC;AACzE,OAAO,EAAqB,KAAK,IAAI,EAAuB,MAAM,WAAW,CAAC;AAC9E,OAAO,EAEL,KAAK,WAAW,EAChB,KAAK,cAAc,EACnB,KAAK,YAAY,EAClB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAC,KAAK,MAAM,EAAC,MAAM,aAAa,CAAC;AAExC;;;GAGG;AACH,qBAAa,MAAO,YAAW,cAAc;;IAoB3C,YACE,KAAK,EAAE,WAAW,EAClB,gBAAgB,EAAE,MAAM,EACxB,aAAa,EAAE,WAAW,EAC1B,IAAI,EAAE,QAAQ,GAAG,YAAY,EAC7B,wBAAwB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAoB/C;IAED,eAAe,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI,CAE1C;IAED,WAAW,SAEV;IAED,SAAS,SAGR;IAEA,MAAM,CAAC,IAAI,EAAE,IAAI,GAAG,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,CAmB/C;IAED,OAAO,IAAI,IAAI,CAEd;IAED,SAAS,IAAI,YAAY,CAExB;IAEA,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,CAmGrC;CAyDF"}
+{"version":3,"file":"exists.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/exists.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,mCAAmC,CAAC;AAGnE,OAAO,EAAkC,KAAK,MAAM,EAAC,MAAM,aAAa,CAAC;AACzE,OAAO,EAAqB,KAAK,IAAI,EAAuB,MAAM,WAAW,CAAC;AAC9E,OAAO,EAEL,KAAK,WAAW,EAChB,KAAK,cAAc,EACnB,KAAK,YAAY,EAClB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAC,KAAK,MAAM,EAAC,MAAM,aAAa,CAAC;AAExC;;;GAGG;AACH,qBAAa,MAAO,YAAW,cAAc;;IAoB3C,YACE,KAAK,EAAE,WAAW,EAClB,gBAAgB,EAAE,MAAM,EACxB,aAAa,EAAE,WAAW,EAC1B,IAAI,EAAE,QAAQ,GAAG,YAAY,EAC7B,wBAAwB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAoB/C;IAED,eAAe,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI,CAE1C;IAED,WAAW,SAEV;IAED,SAAS,SAGR;IAEA,MAAM,CAAC,IAAI,EAAE,IAAI,GAAG,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,CAmBtD;IAED,OAAO,IAAI,IAAI,CAEd;IAED,SAAS,IAAI,YAAY,CAExB;IAEA,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,CAmGrC;CAyDF"}

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

@@ -1 +1 @@
-{"version":3,"file":"exists.js","names":["#input","#relationshipName","#not","#parentJoinKey","#noSizeReuse","#cache","#cacheHitCountsForTesting","#output","#inPush","#getCacheKey","#fetchExists","#filter","#pushWithFilter","#fetchSize"],"sources":["../../../../../zql/src/ivm/exists.ts"],"sourcesContent":["import {areEqual} from '../../../shared/src/arrays.ts';\nimport {assert, unreachable} from '../../../shared/src/asserts.ts';\nimport type {CompoundKey} from '../../../zero-protocol/src/ast.ts';\nimport {ChangeIndex} from './change-index.ts';\nimport {ChangeType} from './change-type.ts';\nimport {makeAddChange, makeRemoveChange, type Change} from './change.ts';\nimport {normalizeUndefined, type Node, type NormalizedValue} from './data.ts';\nimport {\n  throwFilterOutput,\n  type FilterInput,\n  type FilterOperator,\n  type FilterOutput,\n} from './filter-operators.ts';\nimport type {SourceSchema} from './schema.ts';\nimport {type Stream} from './stream.ts';\n\n/**\n * The Exists operator filters data based on whether or not a relationship is\n * non-empty.\n */\nexport class Exists implements FilterOperator {\n  readonly #input: FilterInput;\n  readonly #relationshipName: string;\n  readonly #not: boolean;\n  readonly #parentJoinKey: CompoundKey;\n  readonly #noSizeReuse: boolean;\n  #cache: Map<string, boolean>;\n  #cacheHitCountsForTesting: Map<string, number> | undefined;\n  #output: FilterOutput = throwFilterOutput;\n\n  /**\n   * This instance variable is `true` when this operator is processing a `push`,\n   * and is used to disable reuse of cached sizes across rows with the\n   * same parent join key value.\n   * This is necessary because during a push relationships can be inconsistent\n   * due to push communicating changes (which may change multiple Nodes) one\n   * Node at a time.\n   */\n  #inPush = false;\n\n  constructor(\n    input: FilterInput,\n    relationshipName: string,\n    parentJoinKey: CompoundKey,\n    type: 'EXISTS' | 'NOT EXISTS',\n    cacheHitCountsForTesting?: Map<string, number>,\n  ) {\n    this.#input = input;\n    this.#relationshipName = relationshipName;\n    this.#input.setFilterOutput(this);\n    this.#cache = new Map();\n    this.#cacheHitCountsForTesting = cacheHitCountsForTesting;\n    assert(\n      this.#input.getSchema().relationships[relationshipName],\n      // log-leak-ignore -- relationship name is schema, allowed in errors\n      `Input schema missing ${relationshipName}`,\n    );\n    this.#not = type === 'NOT EXISTS';\n    this.#parentJoinKey = parentJoinKey;\n\n    // If the parentJoinKey is the primary key, no sense in trying to reuse.\n    this.#noSizeReuse = areEqual(\n      parentJoinKey,\n      this.#input.getSchema().primaryKey,\n    );\n  }\n\n  setFilterOutput(output: FilterOutput): void {\n    this.#output = output;\n  }\n\n  beginFilter() {\n    this.#output.beginFilter();\n  }\n\n  endFilter() {\n    this.#cache = new Map();\n    this.#output.endFilter();\n  }\n\n  *filter(node: Node): Generator<'yield', boolean> {\n    let exists: boolean | undefined;\n    if (!this.#noSizeReuse && !this.#inPush) {\n      const key = this.#getCacheKey(node, this.#parentJoinKey);\n      exists = this.#cache.get(key);\n      if (exists === undefined) {\n        exists = yield* this.#fetchExists(node);\n        this.#cache.set(key, exists);\n      } else if (this.#cacheHitCountsForTesting) {\n        this.#cacheHitCountsForTesting.set(\n          key,\n          (this.#cacheHitCountsForTesting.get(key) ?? 0) + 1,\n        );\n      }\n    }\n\n    const result =\n      (yield* this.#filter(node, exists)) && (yield* this.#output.filter(node));\n    return result;\n  }\n\n  destroy(): void {\n    this.#input.destroy();\n  }\n\n  getSchema(): SourceSchema {\n    return this.#input.getSchema();\n  }\n\n  *push(change: Change): Stream<'yield'> {\n    assert(!this.#inPush, 'Unexpected re-entrancy');\n    this.#inPush = true;\n    try {\n      switch (change[ChangeIndex.TYPE]) {\n        // add, remove and edit cannot change the size of the\n        // this.#relationshipName relationship, so simply #pushWithFilter\n        case ChangeType.ADD:\n        case ChangeType.EDIT:\n        case ChangeType.REMOVE: {\n          yield* this.#pushWithFilter(change);\n          return;\n        }\n        case ChangeType.CHILD:\n          // Only add and remove child changes for the\n          // this.#relationshipName relationship, can change the size\n          // of the this.#relationshipName relationship, for other\n          // child changes simply #pushWithFilter\n          if (\n            change[ChangeIndex.CHILD_DATA].relationshipName !==\n              this.#relationshipName ||\n            change[ChangeIndex.CHILD_DATA].change[ChangeIndex.TYPE] ===\n              ChangeType.EDIT ||\n            change[ChangeIndex.CHILD_DATA].change[ChangeIndex.TYPE] ===\n              ChangeType.CHILD\n          ) {\n            yield* this.#pushWithFilter(change);\n            return;\n          }\n          switch (change[ChangeIndex.CHILD_DATA].change[ChangeIndex.TYPE]) {\n            case ChangeType.ADD: {\n              const size = yield* this.#fetchSize(change[ChangeIndex.NODE]);\n              if (size === 1) {\n                if (this.#not) {\n                  // Since the add child change currently being processed is not\n                  // pushed to output, the added child needs to be excluded from\n                  // the remove being pushed to output (since the child has\n                  // never been added to the output).\n                  yield* this.#output.push(\n                    makeRemoveChange({\n                      row: change[ChangeIndex.NODE].row,\n                      relationships: {\n                        ...change[ChangeIndex.NODE].relationships,\n                        [this.#relationshipName]: () => [],\n                      },\n                    }),\n                    this,\n                  );\n                } else {\n                  yield* this.#output.push(\n                    makeAddChange(change[ChangeIndex.NODE]),\n                    this,\n                  );\n                }\n              } else {\n                yield* this.#pushWithFilter(change, size > 0);\n              }\n              return;\n            }\n            case ChangeType.REMOVE: {\n              const size = yield* this.#fetchSize(change[ChangeIndex.NODE]);\n              if (size === 0) {\n                if (this.#not) {\n                  yield* this.#output.push(\n                    makeAddChange(change[ChangeIndex.NODE]),\n                    this,\n                  );\n                } else {\n                  // Since the remove child change currently being processed is\n                  // not pushed to output, the removed child needs to be added to\n                  // the remove being pushed to output.\n                  yield* this.#output.push(\n                    makeRemoveChange({\n                      row: change[ChangeIndex.NODE].row,\n                      relationships: {\n                        ...change[ChangeIndex.NODE].relationships,\n                        [this.#relationshipName]: () => [\n                          change[ChangeIndex.CHILD_DATA].change[\n                            ChangeIndex.NODE\n                          ],\n                        ],\n                      },\n                    }),\n                    this,\n                  );\n                }\n              } else {\n                yield* this.#pushWithFilter(change, size > 0);\n              }\n              return;\n            }\n          }\n          return;\n        default:\n          unreachable(change);\n      }\n    } finally {\n      this.#inPush = false;\n    }\n  }\n\n  /**\n   * Returns whether or not the node's this.#relationshipName\n   * relationship passes the exist/not exists filter condition.\n   * If the optional `size` is passed it is used.\n   * Otherwise, if there is a stored size for the row it is used.\n   * Otherwise the size is computed by streaming the node's\n   * relationship with this.#relationshipName (this computed size is also\n   * stored).\n   */\n  *#filter(node: Node, exists?: boolean): Generator<'yield', boolean> {\n    exists = exists ?? (yield* this.#fetchExists(node));\n    return this.#not ? !exists : exists;\n  }\n\n  #getCacheKey(node: Node, def: CompoundKey): string {\n    const values: NormalizedValue[] = [];\n    for (const key of def) {\n      values.push(normalizeUndefined(node.row[key]));\n    }\n    return JSON.stringify(values);\n  }\n\n  /**\n   * Pushes a change if this.#filter is true for its row.\n   */\n  *#pushWithFilter(change: Change, exists?: boolean): Stream<'yield'> {\n    if (yield* this.#filter(change[ChangeIndex.NODE], exists)) {\n      yield* this.#output.push(change, this);\n    }\n  }\n\n  *#fetchExists(node: Node): Generator<'yield', boolean> {\n    // While it seems like this should be able to fetch just 1 node\n    // to check for exists, we can't because Take does not support\n    // early return during initial fetch.\n    return (yield* this.#fetchSize(node)) > 0;\n  }\n\n  *#fetchSize(node: Node): Generator<'yield', number> {\n    const relationship = node.relationships[this.#relationshipName];\n    assert(\n      relationship,\n      () =>\n        `Exists: relationship \"${this.#relationshipName}\" not found on node`,\n    );\n    let size = 0;\n    for (const n of relationship()) {\n      if (n === 'yield') {\n        yield 'yield';\n      } else {\n        size++;\n      }\n    }\n    return size;\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"exists.js","names":["#input","#relationshipName","#not","#parentJoinKey","#noSizeReuse","#cache","#cacheHitCountsForTesting","#output","#inPush","#getCacheKey","#fetchExists","#filter","#pushWithFilter","#fetchSize"],"sources":["../../../../../zql/src/ivm/exists.ts"],"sourcesContent":["import {areEqual} from '../../../shared/src/arrays.ts';\nimport {assert, unreachable} from '../../../shared/src/asserts.ts';\nimport type {CompoundKey} from '../../../zero-protocol/src/ast.ts';\nimport {ChangeIndex} from './change-index.ts';\nimport {ChangeType} from './change-type.ts';\nimport {makeAddChange, makeRemoveChange, type Change} from './change.ts';\nimport {normalizeUndefined, type Node, type NormalizedValue} from './data.ts';\nimport {\n  throwFilterOutput,\n  type FilterInput,\n  type FilterOperator,\n  type FilterOutput,\n} from './filter-operators.ts';\nimport type {SourceSchema} from './schema.ts';\nimport {type Stream} from './stream.ts';\n\n/**\n * The Exists operator filters data based on whether or not a relationship is\n * non-empty.\n */\nexport class Exists implements FilterOperator {\n  readonly #input: FilterInput;\n  readonly #relationshipName: string;\n  readonly #not: boolean;\n  readonly #parentJoinKey: CompoundKey;\n  readonly #noSizeReuse: boolean;\n  #cache: Map<string, boolean>;\n  #cacheHitCountsForTesting: Map<string, number> | undefined;\n  #output: FilterOutput = throwFilterOutput;\n\n  /**\n   * This instance variable is `true` when this operator is processing a `push`,\n   * and is used to disable reuse of cached sizes across rows with the\n   * same parent join key value.\n   * This is necessary because during a push relationships can be inconsistent\n   * due to push communicating changes (which may change multiple Nodes) one\n   * Node at a time.\n   */\n  #inPush = false;\n\n  constructor(\n    input: FilterInput,\n    relationshipName: string,\n    parentJoinKey: CompoundKey,\n    type: 'EXISTS' | 'NOT EXISTS',\n    cacheHitCountsForTesting?: Map<string, number>,\n  ) {\n    this.#input = input;\n    this.#relationshipName = relationshipName;\n    this.#input.setFilterOutput(this);\n    this.#cache = new Map();\n    this.#cacheHitCountsForTesting = cacheHitCountsForTesting;\n    assert(\n      this.#input.getSchema().relationships[relationshipName],\n      // log-leak-ignore -- relationship name is schema, allowed in errors\n      `Input schema missing ${relationshipName}`,\n    );\n    this.#not = type === 'NOT EXISTS';\n    this.#parentJoinKey = parentJoinKey;\n\n    // If the parentJoinKey is the primary key, no sense in trying to reuse.\n    this.#noSizeReuse = areEqual(\n      parentJoinKey,\n      this.#input.getSchema().primaryKey,\n    );\n  }\n\n  setFilterOutput(output: FilterOutput): void {\n    this.#output = output;\n  }\n\n  beginFilter() {\n    this.#output.beginFilter();\n  }\n\n  endFilter() {\n    this.#cache = new Map();\n    this.#output.endFilter();\n  }\n\n  *filter(node: Node): IterableIterator<'yield', boolean> {\n    let exists: boolean | undefined;\n    if (!this.#noSizeReuse && !this.#inPush) {\n      const key = this.#getCacheKey(node, this.#parentJoinKey);\n      exists = this.#cache.get(key);\n      if (exists === undefined) {\n        exists = yield* this.#fetchExists(node);\n        this.#cache.set(key, exists);\n      } else if (this.#cacheHitCountsForTesting) {\n        this.#cacheHitCountsForTesting.set(\n          key,\n          (this.#cacheHitCountsForTesting.get(key) ?? 0) + 1,\n        );\n      }\n    }\n\n    const result =\n      (yield* this.#filter(node, exists)) && (yield* this.#output.filter(node));\n    return result;\n  }\n\n  destroy(): void {\n    this.#input.destroy();\n  }\n\n  getSchema(): SourceSchema {\n    return this.#input.getSchema();\n  }\n\n  *push(change: Change): Stream<'yield'> {\n    assert(!this.#inPush, 'Unexpected re-entrancy');\n    this.#inPush = true;\n    try {\n      switch (change[ChangeIndex.TYPE]) {\n        // add, remove and edit cannot change the size of the\n        // this.#relationshipName relationship, so simply #pushWithFilter\n        case ChangeType.ADD:\n        case ChangeType.EDIT:\n        case ChangeType.REMOVE: {\n          yield* this.#pushWithFilter(change);\n          return;\n        }\n        case ChangeType.CHILD:\n          // Only add and remove child changes for the\n          // this.#relationshipName relationship, can change the size\n          // of the this.#relationshipName relationship, for other\n          // child changes simply #pushWithFilter\n          if (\n            change[ChangeIndex.CHILD_DATA].relationshipName !==\n              this.#relationshipName ||\n            change[ChangeIndex.CHILD_DATA].change[ChangeIndex.TYPE] ===\n              ChangeType.EDIT ||\n            change[ChangeIndex.CHILD_DATA].change[ChangeIndex.TYPE] ===\n              ChangeType.CHILD\n          ) {\n            yield* this.#pushWithFilter(change);\n            return;\n          }\n          switch (change[ChangeIndex.CHILD_DATA].change[ChangeIndex.TYPE]) {\n            case ChangeType.ADD: {\n              const size = yield* this.#fetchSize(change[ChangeIndex.NODE]);\n              if (size === 1) {\n                if (this.#not) {\n                  // Since the add child change currently being processed is not\n                  // pushed to output, the added child needs to be excluded from\n                  // the remove being pushed to output (since the child has\n                  // never been added to the output).\n                  yield* this.#output.push(\n                    makeRemoveChange({\n                      row: change[ChangeIndex.NODE].row,\n                      relationships: {\n                        ...change[ChangeIndex.NODE].relationships,\n                        [this.#relationshipName]: () => [],\n                      },\n                    }),\n                    this,\n                  );\n                } else {\n                  yield* this.#output.push(\n                    makeAddChange(change[ChangeIndex.NODE]),\n                    this,\n                  );\n                }\n              } else {\n                yield* this.#pushWithFilter(change, size > 0);\n              }\n              return;\n            }\n            case ChangeType.REMOVE: {\n              const size = yield* this.#fetchSize(change[ChangeIndex.NODE]);\n              if (size === 0) {\n                if (this.#not) {\n                  yield* this.#output.push(\n                    makeAddChange(change[ChangeIndex.NODE]),\n                    this,\n                  );\n                } else {\n                  // Since the remove child change currently being processed is\n                  // not pushed to output, the removed child needs to be added to\n                  // the remove being pushed to output.\n                  yield* this.#output.push(\n                    makeRemoveChange({\n                      row: change[ChangeIndex.NODE].row,\n                      relationships: {\n                        ...change[ChangeIndex.NODE].relationships,\n                        [this.#relationshipName]: () => [\n                          change[ChangeIndex.CHILD_DATA].change[\n                            ChangeIndex.NODE\n                          ],\n                        ],\n                      },\n                    }),\n                    this,\n                  );\n                }\n              } else {\n                yield* this.#pushWithFilter(change, size > 0);\n              }\n              return;\n            }\n          }\n          return;\n        default:\n          unreachable(change);\n      }\n    } finally {\n      this.#inPush = false;\n    }\n  }\n\n  /**\n   * Returns whether or not the node's this.#relationshipName\n   * relationship passes the exist/not exists filter condition.\n   * If the optional `size` is passed it is used.\n   * Otherwise, if there is a stored size for the row it is used.\n   * Otherwise the size is computed by streaming the node's\n   * relationship with this.#relationshipName (this computed size is also\n   * stored).\n   */\n  *#filter(node: Node, exists?: boolean): IterableIterator<'yield', boolean> {\n    exists = exists ?? (yield* this.#fetchExists(node));\n    return this.#not ? !exists : exists;\n  }\n\n  #getCacheKey(node: Node, def: CompoundKey): string {\n    const values: NormalizedValue[] = [];\n    for (const key of def) {\n      values.push(normalizeUndefined(node.row[key]));\n    }\n    return JSON.stringify(values);\n  }\n\n  /**\n   * Pushes a change if this.#filter is true for its row.\n   */\n  *#pushWithFilter(change: Change, exists?: boolean): Stream<'yield'> {\n    if (yield* this.#filter(change[ChangeIndex.NODE], exists)) {\n      yield* this.#output.push(change, this);\n    }\n  }\n\n  *#fetchExists(node: Node): IterableIterator<'yield', boolean> {\n    // While it seems like this should be able to fetch just 1 node\n    // to check for exists, we can't because Take does not support\n    // early return during initial fetch.\n    return (yield* this.#fetchSize(node)) > 0;\n  }\n\n  *#fetchSize(node: Node): IterableIterator<'yield', number> {\n    const relationship = node.relationships[this.#relationshipName];\n    assert(\n      relationship,\n      () =>\n        `Exists: relationship \"${this.#relationshipName}\" not found on node`,\n    );\n    let size = 0;\n    for (const n of relationship()) {\n      if (n === 'yield') {\n        yield 'yield';\n      } else {\n        size++;\n      }\n    }\n    return size;\n  }\n}\n"],"mappings":"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"}

package/out/zql/src/ivm/fan-in.d.ts

@@ -26,8 +26,8 @@ export declare class FanIn implements FilterOperator {
     getSchema(): SourceSchema;
     beginFilter(): void;
     endFilter(): void;
-    filter(node: Node): Generator<'yield', boolean>;
+    filter(node: Node): IterableIterator<'yield', boolean>;
     push(change: Change): readonly never[];
-    fanOutDonePushingToAllBranches(fanOutChangeType: ChangeType): Generator<"yield", void, any>;
+    fanOutDonePushingToAllBranches(fanOutChangeType: ChangeType): IterableIterator<any, undefined> | import("./stream.ts").Stream<"yield">;
 }
 //# sourceMappingURL=fan-in.d.ts.map

package/out/zql/src/ivm/fan-in.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fan-in.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/fan-in.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAC,KAAK,MAAM,EAAC,MAAM,aAAa,CAAC;AACxC,OAAO,EAAC,KAAK,IAAI,EAAC,MAAM,WAAW,CAAC;AACpC,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,cAAc,CAAC;AACzC,OAAO,EAEL,KAAK,WAAW,EAChB,KAAK,cAAc,EACnB,KAAK,YAAY,EAClB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAE9C;;;;;;;;;;;;;GAaG;AACH,qBAAa,KAAM,YAAW,cAAc;;IAM1C,YAAY,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,EAOhD;IAED,eAAe,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI,CAE1C;IAED,OAAO,IAAI,IAAI,CAId;IAED,SAAS,iBAER;IAED,WAAW,IAAI,IAAI,CAElB;IAED,SAAS,IAAI,IAAI,CAEhB;IAEA,MAAM,CAAC,IAAI,EAAE,IAAI,GAAG,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,CAE/C;IAED,IAAI,CAAC,MAAM,EAAE,MAAM,oBAGlB;IAEA,8BAA8B,CAAC,gBAAgB,EAAE,UAAU,iCAiB3D;CACF"}
+{"version":3,"file":"fan-in.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/fan-in.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAC,KAAK,MAAM,EAAC,MAAM,aAAa,CAAC;AACxC,OAAO,EAAC,KAAK,IAAI,EAAC,MAAM,WAAW,CAAC;AACpC,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,cAAc,CAAC;AACzC,OAAO,EAEL,KAAK,WAAW,EAChB,KAAK,cAAc,EACnB,KAAK,YAAY,EAClB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAE9C;;;;;;;;;;;;;GAaG;AACH,qBAAa,KAAM,YAAW,cAAc;;IAM1C,YAAY,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,EAOhD;IAED,eAAe,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI,CAE1C;IAED,OAAO,IAAI,IAAI,CAId;IAED,SAAS,iBAER;IAED,WAAW,IAAI,IAAI,CAElB;IAED,SAAS,IAAI,IAAI,CAEhB;IAED,MAAM,CAAC,IAAI,EAAE,IAAI,GAAG,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,CAErD;IAED,IAAI,CAAC,MAAM,EAAE,MAAM,oBAGlB;IAED,8BAA8B,CAAC,gBAAgB,EAAE,UAAU,4EAiB1D;CACF"}