velocious 1.0.504 → 1.0.506

package/build/src/database/drivers/sqlite/table-rebuilder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"table-rebuilder.d.ts","sourceRoot":"","sources":["../../../../../src/database/drivers/sqlite/table-rebuilder.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;GAeG;AACH;IACE;;;;;;;OAOG;IACH,sFALG;QAA2C,MAAM,EAAzC,OAAO,YAAY,EAAE,OAAO;QACf,iBAAiB,EAA9B,MAAM;QACU,eAAe,EAA/B,SAAS;QACqB,WAAW,EAAzC,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;KACjC,EAUA;IAJC,qCAAoB;IACpB,0BAA0C;IAC1C,2BAAsC;IACtC,gCAA8B;IAGhC;;;OAGG;IACH,UAFa,OAAO,CAAC,MAAM,EAAE,CAAC,CAkD7B;CACF;sBA3FqB,2BAA2B"}
+{"version":3,"file":"table-rebuilder.d.ts","sourceRoot":"","sources":["../../../../../src/database/drivers/sqlite/table-rebuilder.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;GAeG;AACH;IACE;;;;;;;OAOG;IACH,sFALG;QAA2C,MAAM,EAAzC,OAAO,YAAY,EAAE,OAAO;QACf,iBAAiB,EAA9B,MAAM;QACU,eAAe,EAA/B,SAAS;QACqB,WAAW,EAAzC,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;KACjC,EAUA;IAJC,qCAAoB;IACpB,0BAA0C;IAC1C,2BAAsC;IACtC,gCAA8B;IAGhC;;;OAGG;IACH,UAFa,OAAO,CAAC,MAAM,EAAE,CAAC,CAqF7B;CACF;sBA9HqB,2BAA2B"}

package/build/src/database/drivers/sqlite/table-rebuilder.js

@@ -47,6 +47,21 @@ export default class VelociousDatabaseDriversSqliteTableRebuilder {
         const tempTableName = `${originalTableName}_velocious_rebuild`;
         const targetTableData = this.targetTableData;
         const previousTargetName = targetTableData.getName();
+        // Column-level `index: true` indexes are named after the table they are created with, and
+        // ALTER TABLE ... RENAME does not rename indexes - creating them inside the temp table's
+        // CREATE would leak the temp rebuild name permanently. Strip the flags for the temp CREATE
+        // and create those indexes explicitly on the temp table with their FINAL names BEFORE the
+        // copy: index names are database-global and survive the rename, and a violation (e.g. a new
+        // unique index over rows that all receive the same default) fails during INSERT...SELECT,
+        // while the original table still exists - never after the swap.
+        /** @type {Array<{column: import("../../table-data/table-column.js").default, index: ?, indexArgs: ?}>} */
+        const strippedColumnIndexes = [];
+        for (const column of targetTableData.getColumns()) {
+            if (!column.getIndex())
+                continue;
+            strippedColumnIndexes.push({ column, index: column.getIndex(), indexArgs: column.getIndexArgs() });
+            column.setIndex(false);
+        }
         targetTableData.setName(tempTableName);
         let createTableSQLs;
         try {
@@ -54,12 +69,27 @@ export default class VelociousDatabaseDriversSqliteTableRebuilder {
         }
         finally {
             targetTableData.setName(previousTargetName);
+            for (const { column, index } of strippedColumnIndexes)
+                column.setIndex(index);
         }
         const newColumnsSQL = this.columnPairs.map(([, newName]) => options.quoteColumnName(newName)).join(", ");
         const oldColumnsSQL = this.columnPairs.map(([oldName]) => options.quoteColumnName(oldName)).join(", ");
         const sqls = [];
         for (const sql of createTableSQLs)
             sqls.push(sql);
+        for (const { column, indexArgs } of strippedColumnIndexes) {
+            const { unique, ...restIndexArgs } = indexArgs || {};
+            restArgsError(restIndexArgs);
+            const createIndexSQLs = await new CreateIndexBase({
+                columns: [column.getName()],
+                driver,
+                name: `index_on_${originalTableName}_${column.getName()}`,
+                tableName: tempTableName,
+                unique
+            }).toSQLs();
+            for (const sql of createIndexSQLs)
+                sqls.push(sql);
+        }
         if (this.columnPairs.length > 0) {
             sqls.push(`INSERT INTO ${options.quoteTableName(tempTableName)} (${newColumnsSQL}) ` +
                 `SELECT ${oldColumnsSQL} FROM ${options.quoteTableName(originalTableName)}`);
@@ -80,4 +110,4 @@ export default class VelociousDatabaseDriversSqliteTableRebuilder {
         return sqls;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-rebuilder.js","sourceRoot":"","sources":["../../../../../src/database/drivers/sqlite/table-rebuilder.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport CreateIndexBase from \"../../query/create-index-base.js\"\nimport restArgsError from \"../../../utils/rest-args-error.js\"\nimport TableData from \"../../table-data/index.js\"\n\n/**\n * Emits the SQL sequence for SQLite's \"rebuild\" approach to schema changes.\n *\n * SQLite cannot add/drop foreign-key constraints, drop columns on older\n * versions, change column types, or add CHECK constraints via ALTER TABLE.\n * The standard workaround (https://sqlite.org/lang_altertable.html) is to\n * create a new table with the desired schema, copy rows over, drop the\n * original, and rename the replacement.\n *\n * Caller passes the desired final schema; this class handles the mechanical\n * sequence (CREATE temp / INSERT...SELECT / DROP / RENAME / recreate\n * indexes). Caller is responsible for any FK toggling or transaction setup\n * around the returned SQL — `PRAGMA foreign_keys` is connection-scoped and\n * cannot be flipped inside a transaction, so wrapping policy is left to the\n * caller (see `sql/alter-table.js`).\n */\nexport default class VelociousDatabaseDriversSqliteTableRebuilder {\n  /**\n   * Runs constructor.\n   * @param {object} args - Options object.\n   * @param {import(\"../base.js\").default} args.driver - Database driver instance.\n   * @param {string} args.originalTableName - Name of the existing table to rebuild.\n   * @param {TableData} args.targetTableData - Desired final schema (columns + foreign keys + indexes). The instance's name is overwritten internally during emission.\n   * @param {Array<[string, string]>} args.columnPairs - Pairs of [oldColumnName, newColumnName] describing how rows from the original table should populate the rebuilt table.\n   */\n  constructor({driver, originalTableName, targetTableData, columnPairs, ...restArgs}) {\n    restArgsError(restArgs)\n\n    if (!(targetTableData instanceof TableData)) throw new Error(\"Invalid target table data was given\")\n\n    this.driver = driver\n    this.originalTableName = originalTableName\n    this.targetTableData = targetTableData\n    this.columnPairs = columnPairs\n  }\n\n  /**\n   * Runs to sqls.\n   * @returns {Promise<string[]>} - Resolves with SQL statements to execute in order.\n   */\n  async toSQLs() {\n    const driver = this.driver\n    const options = driver.options()\n    const originalTableName = this.originalTableName\n    const tempTableName = `${originalTableName}_velocious_rebuild`\n    const targetTableData = this.targetTableData\n    const previousTargetName = targetTableData.getName()\n\n    targetTableData.setName(tempTableName)\n\n    let createTableSQLs\n\n    try {\n      createTableSQLs = await driver.createTableSql(targetTableData)\n    } finally {\n      targetTableData.setName(previousTargetName)\n    }\n\n    const newColumnsSQL = this.columnPairs.map(([, newName]) => options.quoteColumnName(newName)).join(\", \")\n    const oldColumnsSQL = this.columnPairs.map(([oldName]) => options.quoteColumnName(oldName)).join(\", \")\n\n    const sqls = []\n\n    for (const sql of createTableSQLs) sqls.push(sql)\n\n    if (this.columnPairs.length > 0) {\n      sqls.push(\n        `INSERT INTO ${options.quoteTableName(tempTableName)} (${newColumnsSQL}) ` +\n        `SELECT ${oldColumnsSQL} FROM ${options.quoteTableName(originalTableName)}`\n      )\n    }\n\n    sqls.push(`DROP TABLE ${options.quoteTableName(originalTableName)}`)\n    sqls.push(`ALTER TABLE ${options.quoteTableName(tempTableName)} RENAME TO ${options.quoteTableName(originalTableName)}`)\n\n    for (const tableDataIndex of targetTableData.getIndexes()) {\n      const createIndexSQLs = await new CreateIndexBase({\n        columns: tableDataIndex.getColumns(),\n        driver,\n        name: tableDataIndex.getName(),\n        tableName: originalTableName,\n        unique: tableDataIndex.getUnique()\n      }).toSQLs()\n\n      for (const sql of createIndexSQLs) sqls.push(sql)\n    }\n\n    return sqls\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-rebuilder.js","sourceRoot":"","sources":["../../../../../src/database/drivers/sqlite/table-rebuilder.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport CreateIndexBase from \"../../query/create-index-base.js\"\nimport restArgsError from \"../../../utils/rest-args-error.js\"\nimport TableData from \"../../table-data/index.js\"\n\n/**\n * Emits the SQL sequence for SQLite's \"rebuild\" approach to schema changes.\n *\n * SQLite cannot add/drop foreign-key constraints, drop columns on older\n * versions, change column types, or add CHECK constraints via ALTER TABLE.\n * The standard workaround (https://sqlite.org/lang_altertable.html) is to\n * create a new table with the desired schema, copy rows over, drop the\n * original, and rename the replacement.\n *\n * Caller passes the desired final schema; this class handles the mechanical\n * sequence (CREATE temp / INSERT...SELECT / DROP / RENAME / recreate\n * indexes). Caller is responsible for any FK toggling or transaction setup\n * around the returned SQL — `PRAGMA foreign_keys` is connection-scoped and\n * cannot be flipped inside a transaction, so wrapping policy is left to the\n * caller (see `sql/alter-table.js`).\n */\nexport default class VelociousDatabaseDriversSqliteTableRebuilder {\n  /**\n   * Runs constructor.\n   * @param {object} args - Options object.\n   * @param {import(\"../base.js\").default} args.driver - Database driver instance.\n   * @param {string} args.originalTableName - Name of the existing table to rebuild.\n   * @param {TableData} args.targetTableData - Desired final schema (columns + foreign keys + indexes). The instance's name is overwritten internally during emission.\n   * @param {Array<[string, string]>} args.columnPairs - Pairs of [oldColumnName, newColumnName] describing how rows from the original table should populate the rebuilt table.\n   */\n  constructor({driver, originalTableName, targetTableData, columnPairs, ...restArgs}) {\n    restArgsError(restArgs)\n\n    if (!(targetTableData instanceof TableData)) throw new Error(\"Invalid target table data was given\")\n\n    this.driver = driver\n    this.originalTableName = originalTableName\n    this.targetTableData = targetTableData\n    this.columnPairs = columnPairs\n  }\n\n  /**\n   * Runs to sqls.\n   * @returns {Promise<string[]>} - Resolves with SQL statements to execute in order.\n   */\n  async toSQLs() {\n    const driver = this.driver\n    const options = driver.options()\n    const originalTableName = this.originalTableName\n    const tempTableName = `${originalTableName}_velocious_rebuild`\n    const targetTableData = this.targetTableData\n    const previousTargetName = targetTableData.getName()\n\n    // Column-level `index: true` indexes are named after the table they are created with, and\n    // ALTER TABLE ... RENAME does not rename indexes - creating them inside the temp table's\n    // CREATE would leak the temp rebuild name permanently. Strip the flags for the temp CREATE\n    // and create those indexes explicitly on the temp table with their FINAL names BEFORE the\n    // copy: index names are database-global and survive the rename, and a violation (e.g. a new\n    // unique index over rows that all receive the same default) fails during INSERT...SELECT,\n    // while the original table still exists - never after the swap.\n    /** @type {Array<{column: import(\"../../table-data/table-column.js\").default, index: ?, indexArgs: ?}>} */\n    const strippedColumnIndexes = []\n\n    for (const column of targetTableData.getColumns()) {\n      if (!column.getIndex()) continue\n\n      strippedColumnIndexes.push({column, index: column.getIndex(), indexArgs: column.getIndexArgs()})\n      column.setIndex(false)\n    }\n\n    targetTableData.setName(tempTableName)\n\n    let createTableSQLs\n\n    try {\n      createTableSQLs = await driver.createTableSql(targetTableData)\n    } finally {\n      targetTableData.setName(previousTargetName)\n\n      for (const {column, index} of strippedColumnIndexes) column.setIndex(index)\n    }\n\n    const newColumnsSQL = this.columnPairs.map(([, newName]) => options.quoteColumnName(newName)).join(\", \")\n    const oldColumnsSQL = this.columnPairs.map(([oldName]) => options.quoteColumnName(oldName)).join(\", \")\n\n    const sqls = []\n\n    for (const sql of createTableSQLs) sqls.push(sql)\n\n    for (const {column, indexArgs} of strippedColumnIndexes) {\n      const {unique, ...restIndexArgs} = indexArgs || {}\n\n      restArgsError(restIndexArgs)\n\n      const createIndexSQLs = await new CreateIndexBase({\n        columns: [column.getName()],\n        driver,\n        name: `index_on_${originalTableName}_${column.getName()}`,\n        tableName: tempTableName,\n        unique\n      }).toSQLs()\n\n      for (const sql of createIndexSQLs) sqls.push(sql)\n    }\n\n    if (this.columnPairs.length > 0) {\n      sqls.push(\n        `INSERT INTO ${options.quoteTableName(tempTableName)} (${newColumnsSQL}) ` +\n        `SELECT ${oldColumnsSQL} FROM ${options.quoteTableName(originalTableName)}`\n      )\n    }\n\n    sqls.push(`DROP TABLE ${options.quoteTableName(originalTableName)}`)\n    sqls.push(`ALTER TABLE ${options.quoteTableName(tempTableName)} RENAME TO ${options.quoteTableName(originalTableName)}`)\n\n    for (const tableDataIndex of targetTableData.getIndexes()) {\n      const createIndexSQLs = await new CreateIndexBase({\n        columns: tableDataIndex.getColumns(),\n        driver,\n        name: tableDataIndex.getName(),\n        tableName: originalTableName,\n        unique: tableDataIndex.getUnique()\n      }).toSQLs()\n\n      for (const sql of createIndexSQLs) sqls.push(sql)\n    }\n\n    return sqls\n  }\n}\n"]}

package/build/src/sync/query-scope.d.ts

@@ -10,7 +10,12 @@
  */
 export function serializedScopeFromQuery(query: import("../database/query/model-class-query.js").default<unknown>): import("./sync-client-types.js").SerializedSyncScope;
 /**
- * Returns a stable canonical key identifying a sync scope.
+ * Returns a stable canonical key identifying a sync scope. When an `owner` is
+ * present (the authenticated identity that declared the scope locally), it
+ * participates in the key so the same wire scope owned by a different user gets
+ * its own local identity and cursor — a user scope's empty-conditions cursor
+ * never leaks across accounts on a shared device, while the same user
+ * reconnecting keeps continuity. Owner-less scopes keep their pre-owner key.
  * @param {import("./sync-client-types.js").SerializedSyncScope} scope - Serialized sync scope.
  * @returns {string} Stable scope key.
  */

package/build/src/sync/query-scope.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"query-scope.d.ts","sourceRoot":"","sources":["../../../src/sync/query-scope.js"],"names":[],"mappings":"AAIA;;;;;;;;;GASG;AACH,gDAHW,OAAO,wCAAwC,EAAE,OAAO,CAAC,OAAC,CAAC,GACzD,OAAO,wBAAwB,EAAE,mBAAmB,CA+BhE;AAED;;;;GAIG;AACH,gCAHW,OAAO,wBAAwB,EAAE,mBAAmB,GAClD,MAAM,CAIlB"}
+{"version":3,"file":"query-scope.d.ts","sourceRoot":"","sources":["../../../src/sync/query-scope.js"],"names":[],"mappings":"AAIA;;;;;;;;;GASG;AACH,gDAHW,OAAO,wCAAwC,EAAE,OAAO,CAAC,OAAC,CAAC,GACzD,OAAO,wBAAwB,EAAE,mBAAmB,CA+BhE;AAED;;;;;;;;;GASG;AACH,gCAHW,OAAO,wBAAwB,EAAE,mBAAmB,GAClD,MAAM,CAMlB"}

package/build/src/sync/query-scope.js

@@ -39,12 +39,18 @@ export function serializedScopeFromQuery(query) {
     return { conditions, resourceType: modelClass.getModelName() };
 }
 /**
- * Returns a stable canonical key identifying a sync scope.
+ * Returns a stable canonical key identifying a sync scope. When an `owner` is
+ * present (the authenticated identity that declared the scope locally), it
+ * participates in the key so the same wire scope owned by a different user gets
+ * its own local identity and cursor — a user scope's empty-conditions cursor
+ * never leaks across accounts on a shared device, while the same user
+ * reconnecting keeps continuity. Owner-less scopes keep their pre-owner key.
  * @param {import("./sync-client-types.js").SerializedSyncScope} scope - Serialized sync scope.
  * @returns {string} Stable scope key.
  */
 export function scopeKey(scope) {
-    return `${scope.resourceType}:${stableJsonStringify(scope.conditions)}`;
+    const ownerPrefix = scope.owner === undefined || scope.owner === null ? "" : `owner=${stableJsonStringify(scope.owner)}|`;
+    return `${ownerPrefix}${scope.resourceType}:${stableJsonStringify(scope.conditions)}`;
 }
 /**
  * Validates one scope condition value as a scalar or array of scalars.
@@ -74,4 +80,4 @@ function validateScalar(attributeName, value) {
         return;
     throw new Error(`sync(query) condition values must be scalar, got ${typeof value} for: ${attributeName}`);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query-scope.js","sourceRoot":"","sources":["../../../src/sync/query-scope.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ,OAAO,mBAAmB,MAAM,kBAAkB,CAAA;AAElD;;;;;;;;;GASG;AACH,MAAM,UAAU,wBAAwB,CAAC,KAAK;IAC5C,IAAI,KAAK,CAAC,QAAQ,EAAE,CAAC,MAAM,GAAG,CAAC;QAAE,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAA;IACtF,IAAI,KAAK,CAAC,SAAS,EAAE,CAAC,MAAM,GAAG,CAAC;QAAE,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAA;IACxF,IAAI,KAAK,CAAC,QAAQ,EAAE,KAAK,IAAI,IAAI,KAAK,CAAC,QAAQ,EAAE,KAAK,SAAS;QAAE,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAA;IACtH,IAAI,KAAK,CAAC,SAAS,EAAE,KAAK,IAAI,IAAI,KAAK,CAAC,SAAS,EAAE,KAAK,SAAS;QAAE,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAA;IACzH,IAAI,KAAK,CAAC,SAAS,EAAE,CAAC,MAAM,GAAG,CAAC;QAAE,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAA;IAExF,MAAM,UAAU,GAAG,KAAK,CAAC,aAAa,EAAE,CAAA;IACxC,MAAM,UAAU,GAAG,gCAAgC,CAAC,CAAC,EAAE,CAAC,CAAA;IAExD,KAAK,MAAM,KAAK,IAAI,KAAK,CAAC,SAAS,EAAE,EAAE,CAAC;QACtC,MAAM,SAAS,GAAG,yCAAyC,CAAC,CAAC,KAAK,CAAC,CAAC,IAAI,CAAA;QAExE,IAAI,CAAC,SAAS,IAAI,OAAO,SAAS,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,0BAA0B,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,CAAC;YACxH,MAAM,IAAI,KAAK,CAAC,8DAA8D,KAAK,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC,CAAA;QACzG,CAAC;QAED,KAAK,MAAM,CAAC,aAAa,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC;YAC/D,MAAM,cAAc,GAAG,oBAAoB,CAAC,aAAa,EAAE,KAAK,CAAC,CAAA;YAEjE,IAAI,aAAa,IAAI,UAAU,IAAI,mBAAmB,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC,KAAK,mBAAmB,CAAC,cAAc,CAAC,EAAE,CAAC;gBAC1H,MAAM,IAAI,KAAK,CAAC,+CAA+C,aAAa,EAAE,CAAC,CAAA;YACjF,CAAC;YAED,UAAU,CAAC,aAAa,CAAC,GAAG,cAAc,CAAA;QAC5C,CAAC;IACH,CAAC;IAED,OAAO,EAAC,UAAU,EAAE,YAAY,EAAE,UAAU,CAAC,YAAY,EAAE,EAAC,CAAA;AAC9D,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,QAAQ,CAAC,KAAK;IAC5B,MAAM,WAAW,GAAG,KAAK,CAAC,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,KAAK,KAAK,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,mBAAmB,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAA;IAEzH,OAAO,GAAG,WAAW,GAAG,KAAK,CAAC,YAAY,IAAI,mBAAmB,CAAC,KAAK,CAAC,UAAU,CAAC,EAAE,CAAA;AACvF,CAAC;AAED;;;;;GAKG;AACH,SAAS,oBAAoB,CAAC,aAAa,EAAE,KAAK;IAChD,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACzB,KAAK,MAAM,IAAI,IAAI,KAAK;YAAE,cAAc,CAAC,aAAa,EAAE,IAAI,CAAC,CAAA;QAE7D,OAAO,KAAK,CAAA;IACd,CAAC;IAED,cAAc,CAAC,aAAa,EAAE,KAAK,CAAC,CAAA;IAEpC,OAAO,KAAK,CAAA;AACd,CAAC;AAED;;;;;GAKG;AACH,SAAS,cAAc,CAAC,aAAa,EAAE,KAAK;IAC1C,IAAI,KAAK,KAAK,IAAI;QAAE,OAAM;IAC1B,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,OAAO,KAAK,KAAK,SAAS;QAAE,OAAM;IAEhG,MAAM,IAAI,KAAK,CAAC,oDAAoD,OAAO,KAAK,SAAS,aAAa,EAAE,CAAC,CAAA;AAC3G,CAAC","sourcesContent":["// @ts-check\n\nimport stableJsonStringify from \"./stable-json.js\"\n\n/**\n * Serializes a model query into a transportable sync scope.\n *\n * Only plain attribute equality conditions are supported: the scope must be\n * expressible as `{resourceType, conditions}` so servers can match it against\n * their change feeds. Anything else (raw SQL, negations, joins, orders,\n * limits, offsets, groups) fails loudly.\n * @param {import(\"../database/query/model-class-query.js\").default<?>} query - Model query declaring the sync scope.\n * @returns {import(\"./sync-client-types.js\").SerializedSyncScope} Serialized sync scope.\n */\nexport function serializedScopeFromQuery(query) {\n  if (query.getJoins().length > 0) throw new Error(\"sync(query) does not support joins\")\n  if (query.getOrders().length > 0) throw new Error(\"sync(query) does not support orders\")\n  if (query.getLimit() !== null && query.getLimit() !== undefined) throw new Error(\"sync(query) does not support limit\")\n  if (query.getOffset() !== null && query.getOffset() !== undefined) throw new Error(\"sync(query) does not support offset\")\n  if (query.getGroups().length > 0) throw new Error(\"sync(query) does not support groups\")\n\n  const modelClass = query.getModelClass()\n  const conditions = /** @type {Record<string, ?>} */ ({})\n\n  for (const where of query.getWheres()) {\n    const whereHash = /** @type {{hash?: Record<string, ?>}} */ (where).hash\n\n    if (!whereHash || typeof whereHash !== \"object\" || Array.isArray(whereHash) || /** @type {{where?: ?}} */ (where).where) {\n      throw new Error(`sync(query) only supports plain attribute conditions, got: ${where.constructor.name}`)\n    }\n\n    for (const [attributeName, value] of Object.entries(whereHash)) {\n      const conditionValue = scalarConditionValue(attributeName, value)\n\n      if (attributeName in conditions && stableJsonStringify(conditions[attributeName]) !== stableJsonStringify(conditionValue)) {\n        throw new Error(`sync(query) got conflicting conditions for: ${attributeName}`)\n      }\n\n      conditions[attributeName] = conditionValue\n    }\n  }\n\n  return {conditions, resourceType: modelClass.getModelName()}\n}\n\n/**\n * Returns a stable canonical key identifying a sync scope. When an `owner` is\n * present (the authenticated identity that declared the scope locally), it\n * participates in the key so the same wire scope owned by a different user gets\n * its own local identity and cursor — a user scope's empty-conditions cursor\n * never leaks across accounts on a shared device, while the same user\n * reconnecting keeps continuity. Owner-less scopes keep their pre-owner key.\n * @param {import(\"./sync-client-types.js\").SerializedSyncScope} scope - Serialized sync scope.\n * @returns {string} Stable scope key.\n */\nexport function scopeKey(scope) {\n  const ownerPrefix = scope.owner === undefined || scope.owner === null ? \"\" : `owner=${stableJsonStringify(scope.owner)}|`\n\n  return `${ownerPrefix}${scope.resourceType}:${stableJsonStringify(scope.conditions)}`\n}\n\n/**\n * Validates one scope condition value as a scalar or array of scalars.\n * @param {string} attributeName - Condition attribute name for error messages.\n * @param {?} value - Condition value.\n * @returns {?} Validated condition value.\n */\nfunction scalarConditionValue(attributeName, value) {\n  if (Array.isArray(value)) {\n    for (const item of value) validateScalar(attributeName, item)\n\n    return value\n  }\n\n  validateScalar(attributeName, value)\n\n  return value\n}\n\n/**\n * Validates one scalar condition value.\n * @param {string} attributeName - Condition attribute name for error messages.\n * @param {?} value - Condition value.\n * @returns {void}\n */\nfunction validateScalar(attributeName, value) {\n  if (value === null) return\n  if (typeof value === \"string\" || typeof value === \"number\" || typeof value === \"boolean\") return\n\n  throw new Error(`sync(query) condition values must be scalar, got ${typeof value} for: ${attributeName}`)\n}\n"]}

package/build/src/sync/sync-client-types.d.ts

@@ -10,6 +10,10 @@ export type SerializedSyncScope = {
      * - Resource/model name the scope was declared for.
      */
     resourceType: string;
+    /**
+     * - Local partition key: the authenticated identity that declared the scope. Used only to partition the local scope/cursor store (never sent to the server as scope conditions), so a user scope's empty-conditions cursor does not leak across accounts on a shared device.
+     */
+    owner?: string | undefined;
 };
 /**
  * Static realtime channel declaration on a model's `static sync`, for channels
@@ -154,6 +158,12 @@ export type ModelSyncDeclarationConfig<TModel = any> = {
  * object customizes the derived resource config.
  */
 export type ModelSyncDeclaration<TModel = any> = boolean | ModelSyncDeclarationConfig<TModel>;
+/**
+ * Shared app-lifetime websocket connection all sync traffic rides. Matches the
+ * realtime websocket client contract; the sync client rides it without owning
+ * its connect/disconnect lifecycle.
+ */
+export type SyncClientSharedConnection = import("../configuration-types.js").VelociousSyncRealtimeWebsocketClient;
 /**
  * Options for building a sync client. Everything else — resources, transport
  * POSTers, auth, connectivity, batch size — is derived from the configuration's
@@ -235,5 +245,13 @@ export type SyncClientConfig = {
      * - Local pending-sync model class.
      */
     syncModel: unknown;
+    /**
+     * - Shared app-lifetime websocket client instance (the low-level shared-connection form).
+     */
+    websocketClient?: import("../configuration-types.js").VelociousSyncRealtimeWebsocketClient | undefined;
+    /**
+     * - Shared app-lifetime websocket URL the framework builds a client from.
+     */
+    websocketUrl?: string | (() => string | null | undefined) | undefined;
 };
 //# sourceMappingURL=sync-client-types.d.ts.map

package/build/src/sync/sync-client-types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sync-client-types.d.ts","sourceRoot":"","sources":["../../../src/sync/sync-client-types.js"],"names":[],"mappings":";;;;;;;gBAKc,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC;;;;kBACjB,MAAM;;;;;;;;;;aAQN,MAAM;;;;;;;;;;;;;gBAON,OAAC;;;;;;;;;;;;iBAED,OAAO,4BAA4B,EAAE,kBAAkB,CAAC,YAAY,CAAC;;;;0BACrE,OAAO,4BAA4B,EAAE,kBAAkB,CAAC,qBAAqB,CAAC;;;;iBAC9E,OAAO,4BAA4B,EAAE,kBAAkB,CAAC,YAAY,CAAC;;;;;;;;;;;;kCAGlD;QAAC,SAAS,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAC;QAAC,MAAM,EAAE,OAAC,CAAA;KAAC,KAAK,MAAM;;;;0BAC9E;QAAC,SAAS,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAC;QAAC,MAAM,EAAE,OAAC,CAAA;KAAC,KAAK,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC;;;;;oBAC7D,KAAK,CAAC,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAC;;;;;;;;;;;;uCAQ7D,MAAM;;;;iBAEN,OAAO,4BAA4B,EAAE,kBAAkB,CAAC,YAAY,CAAC;;;;;;;;;;;;;;;;iBAGrE,OAAO,4BAA4B,EAAE,kBAAkB,CAAC,YAAY,CAAC;;;;0BACrE,OAAO,4BAA4B,EAAE,kBAAkB,CAAC,qBAAqB,CAAC;;;;;;;;;;;;kCAG3D;QAAC,SAAS,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAC;QAAC,MAAM,EAAE,OAAC,CAAA;KAAC,KAAK,MAAM;;;;;oBACrB,KAAK,CAAC,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAC;;;;;0BAC/F;QAAC,SAAS,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAC;QAAC,MAAM,EAAE,OAAC,CAAA;KAAC,KAAK,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC;;;;;;;;;;iCAOpF,MAAM,UACP,OAAO,GAAG,0BAA0B,CAAC,MAAM,CAAC;;;;;;;;;;;;;;2BASpC;QAAC,KAAK,EAAE,mBAAmB,CAAA;KAAC,KAAK,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;;;;;;;;gBAE9E,OAAC;;;;;;;;;;yBAOD,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;;;;;;;;mBAE9B,OAAO,qBAAqB,EAAE,OAAO;;;;sBAC/B,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;;;;2BACzB;QAAC,KAAK,EAAE,mBAAmB,CAAA;KAAC,KAAK,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;;;;uBACtE,KAAK,KAAK,IAAI;;;;iBACtB,CAAC,OAAO,EAAE,OAAO,4BAA4B,EAAE,kBAAkB,GAAG;QAAC,KAAK,EAAE,mBAAmB,CAAA;KAAC,KAAK,OAAO,CAAC,OAAO,4BAA4B,EAAE,mBAAmB,CAAC;;;;gBACtK,CAAC,OAAO,EAAE;QAAC,mBAAmB,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC,CAAA;KAAC,KAAK,OAAO,CAAC,OAAO,4BAA4B,EAAE,kBAAkB,CAAC;;;;;;;;eAE7I,MAAM,CAAC,MAAM,EAAE,wBAAwB,CAAC;;;;eACxC,OAAC"}
+{"version":3,"file":"sync-client-types.d.ts","sourceRoot":"","sources":["../../../src/sync/sync-client-types.js"],"names":[],"mappings":";;;;;;;gBAKc,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC;;;;kBACjB,MAAM;;;;;;;;;;;;;;aASN,MAAM;;;;;;;;;;;;;gBAON,OAAC;;;;;;;;;;;;iBAED,OAAO,4BAA4B,EAAE,kBAAkB,CAAC,YAAY,CAAC;;;;0BACrE,OAAO,4BAA4B,EAAE,kBAAkB,CAAC,qBAAqB,CAAC;;;;iBAC9E,OAAO,4BAA4B,EAAE,kBAAkB,CAAC,YAAY,CAAC;;;;;;;;;;;;kCAGlD;QAAC,SAAS,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAC;QAAC,MAAM,EAAE,OAAC,CAAA;KAAC,KAAK,MAAM;;;;0BAC9E;QAAC,SAAS,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAC;QAAC,MAAM,EAAE,OAAC,CAAA;KAAC,KAAK,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC;;;;;oBAC7D,KAAK,CAAC,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAC;;;;;;;;;;;;uCAQ7D,MAAM;;;;iBAEN,OAAO,4BAA4B,EAAE,kBAAkB,CAAC,YAAY,CAAC;;;;;;;;;;;;;;;;iBAGrE,OAAO,4BAA4B,EAAE,kBAAkB,CAAC,YAAY,CAAC;;;;0BACrE,OAAO,4BAA4B,EAAE,kBAAkB,CAAC,qBAAqB,CAAC;;;;;;;;;;;;kCAG3D;QAAC,SAAS,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAC;QAAC,MAAM,EAAE,OAAC,CAAA;KAAC,KAAK,MAAM;;;;;oBACrB,KAAK,CAAC,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAC;;;;;0BAC/F;QAAC,SAAS,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAC;QAAC,MAAM,EAAE,OAAC,CAAA;KAAC,KAAK,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC;;;;;;;;;;iCAOpF,MAAM,UACP,OAAO,GAAG,0BAA0B,CAAC,MAAM,CAAC;;;;;;yCAO5C,OAAO,2BAA2B,EAAE,oCAAoC;;;;;;;;;;;;;;2BAShE;QAAC,KAAK,EAAE,mBAAmB,CAAA;KAAC,KAAK,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;;;;;;;;gBAE9E,OAAC;;;;;;;;;;yBAOD,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;;;;;;;;mBAE9B,OAAO,qBAAqB,EAAE,OAAO;;;;sBAC/B,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;;;;2BACzB;QAAC,KAAK,EAAE,mBAAmB,CAAA;KAAC,KAAK,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;;;;uBACtE,KAAK,KAAK,IAAI;;;;iBACtB,CAAC,OAAO,EAAE,OAAO,4BAA4B,EAAE,kBAAkB,GAAG;QAAC,KAAK,EAAE,mBAAmB,CAAA;KAAC,KAAK,OAAO,CAAC,OAAO,4BAA4B,EAAE,mBAAmB,CAAC;;;;gBACtK,CAAC,OAAO,EAAE;QAAC,mBAAmB,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC,CAAA;KAAC,KAAK,OAAO,CAAC,OAAO,4BAA4B,EAAE,kBAAkB,CAAC;;;;;;;;eAE7I,MAAM,CAAC,MAAM,EAAE,wBAAwB,CAAC;;;;eACxC,OAAC;;;;;;;;mCAEe,MAAM,GAAG,IAAI,GAAG,SAAS"}

package/build/src/sync/sync-client-types.js

@@ -1,3 +1,3 @@
 // @ts-check
 export {};
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sync-client-types.js","sourceRoot":"","sources":["../../../src/sync/sync-client-types.js"],"names":[],"mappings":"AAAA,YAAY","sourcesContent":["// @ts-check\n\n/**\n * Client-declared sync scope serialized from a model query.\n * @typedef {object} SerializedSyncScope\n * @property {Record<string, ?>} conditions - Plain attribute conditions from the query.\n * @property {string} resourceType - Resource/model name the scope was declared for.\n */\n\n/**\n * Static realtime channel declaration on a model's `static sync`, for channels\n * whose name and params are static.\n * @deprecated Declared pull scopes subscribe the framework sync channel automatically; keep this only for legacy app channels.\n * @typedef {object} ModelSyncRealtimeDeclaration\n * @property {string} channel - Server channel name to subscribe.\n * @property {Record<string, ?>} [params] - Static subscribe params. The framework injects `authenticationToken` automatically.\n */\n\n/**\n * Declarative per-resource sync policy.\n * @typedef {object} SyncClientResourceConfig\n * @property {?} modelClass - Local model class for this resource.\n * @property {import(\"./sync-api-client-types.js\").SyncResourceConfig[\"attributes\"]} [attributes] - Pull-apply attribute mapper. Required for resources that receive pulled changes.\n * @property {import(\"./sync-api-client-types.js\").SyncResourceConfig[\"findRecord\"]} [findRecord] - Custom pull-apply record resolver.\n * @property {import(\"./sync-api-client-types.js\").SyncResourceConfig[\"findRecordForDelete\"]} [findRecordForDelete] - Custom pull-apply delete resolver.\n * @property {import(\"./sync-api-client-types.js\").SyncResourceConfig[\"afterApply\"]} [afterApply] - Post-apply hook.\n * @property {string[]} [booleanAttributes] - Attributes coerced through sync boolean parsing when queueing.\n * @property {string[]} [localOnlyAttributes] - Attributes stripped from queued payloads.\n * @property {\"upsert\" | ((args: {operation: \"create\" | \"update\" | \"destroy\", record: ?}) => string)} [syncType] - Maps a mutation operation to a sync type. The \"upsert\" flag queues creates and updates as \"update\" rows (the server upserts by resource id) and destroys as \"delete\". Defaults to the operation name with destroy mapped to \"delete\".\n * @property {(args: {operation: \"create\" | \"update\" | \"destroy\", record: ?}) => Record<string, ?>} [trackedData] - Custom queued-payload builder for tracked mutations.\n * @property {boolean | {operations: Array<\"create\" | \"update\" | \"destroy\">}} [track] - Automatic mutation tracking policy. On by default (creates and updates queue automatically); `false` opts the resource out, `true` adds destroys, `{operations}` narrows the tracked operations.\n * @property {ModelSyncRealtimeDeclaration} [realtime] - Deprecated: static legacy realtime channel this resource subscribes through `subscribeRealtime(...)`. Declared pull scopes subscribe the framework sync channel automatically.\n */\n\n/**\n * Model-level client sync declaration read from `static sync` by\n * `SyncClient.fromConfiguration(...)`. `true` opts the model in with all\n * defaults; an object customizes the derived resource config.\n * @template [TModel=any]\n * @typedef {object} ModelSyncDeclarationConfig\n * @property {import(\"./sync-api-client-types.js\").SyncResourceConfig[\"afterApply\"]} [afterApply] - Post-apply hook.\n * @property {import(\"./sync-api-client-types.js\").SyncResourceConfig[\"attributes\"]} [attributes] - Pull-apply attribute mapper. Required for resources that receive pulled changes.\n * @property {string[]} [booleanAttributes] - Extra boolean attributes merged with the boolean columns derived from column types.\n * @property {import(\"./sync-api-client-types.js\").SyncResourceConfig[\"findRecord\"]} [findRecord] - Custom pull-apply record resolver.\n * @property {import(\"./sync-api-client-types.js\").SyncResourceConfig[\"findRecordForDelete\"]} [findRecordForDelete] - Custom pull-apply delete resolver.\n * @property {string[]} [localOnlyAttributes] - Extra local-only attributes merged with the derived primary key, createdAt/updatedAt, and sync bookkeeping attributes.\n * @property {import(\"./sync-publisher-types.js\").SyncPublishDeclaration<TModel>} [publish] - Server-side publish declaration consumed by `SyncPublisher.fromConfiguration(...)` on the backend; ignored by the client.\n * @property {\"upsert\" | ((args: {operation: \"create\" | \"update\" | \"destroy\", record: ?}) => string)} [syncType] - Sync type flag or mapper (see SyncClientResourceConfig).\n * @property {boolean | Array<\"create\" | \"update\" | \"destroy\"> | {operations: Array<\"create\" | \"update\" | \"destroy\">}} [track] - Automatic mutation tracking policy; an array is shorthand for {operations}. On by default (creates and updates queue automatically); `false` opts the model out (for models written by non-user flows), `true` adds destroys.\n * @property {(args: {operation: \"create\" | \"update\" | \"destroy\", record: ?}) => Record<string, ?>} [trackedData] - Custom queued-payload builder for tracked mutations.\n * @property {ModelSyncRealtimeDeclaration} [realtime] - Deprecated: static legacy realtime channel this resource subscribes through `subscribeRealtime(...)`. Declared pull scopes subscribe the framework sync channel automatically.\n */\n\n/**\n * Model-level sync declaration value: `true` opts in with all defaults, an\n * object customizes the derived resource config.\n * @template [TModel=any]\n * @typedef {boolean | ModelSyncDeclarationConfig<TModel>} ModelSyncDeclaration\n */\n\n/**\n * Options for building a sync client. Everything else — resources, transport\n * POSTers, auth, connectivity, batch size — is derived from the configuration's\n * registered models (`static sync`) and its `sync.client` block.\n * @typedef {object} SyncClientOptions\n * @property {import(\"../configuration.js\").default} [configuration] - Configuration owning the registered models, the `sync.client` block, and the scope-store database. Defaults to the current configuration.\n * @property {(args: {scope: SerializedSyncScope}) => string | null | Promise<string | null>} [legacyCursor] - Seeds a newly declared scope's cursor (e.g. from a pre-scope cursor store) so devices don't re-pull everything.\n * @property {import(\"./sync-scope-store.js\").default} [scopeStore] - Scope store override (tests).\n * @property {?} [syncModel] - Pending-sync model override. Defaults to the registered \"Sync\" model.\n */\n\n/**\n * Internal derived sync client configuration built by the SyncClient\n * constructor — not an app-facing API.\n * @typedef {object} SyncClientConfig\n * @property {() => string | Promise<string>} authenticationToken - Resolves the auth token sent with sync requests.\n * @property {number} [batchSize] - Max syncs per request.\n * @property {import(\"../configuration.js\").default} configuration - Configuration owning the scope-store database.\n * @property {() => boolean | Promise<boolean>} [isOnline] - Connectivity gate for pulls and replays. Defaults to always online.\n * @property {(args: {scope: SerializedSyncScope}) => string | null | Promise<string | null>} [legacyCursor] - Seeds a newly declared scope's cursor (e.g. from a pre-scope cursor store) so devices don't re-pull everything.\n * @property {(error: Error) => void} [onError] - Reports background replay/pull failures. Defaults to rethrowing.\n * @property {(payload: import(\"./sync-api-client-types.js\").SyncChangesRequest & {scope: SerializedSyncScope}) => Promise<import(\"./sync-api-client-types.js\").SyncChangesResponse>} postChanges - Posts one changes request.\n * @property {(payload: {authenticationToken: string, syncs: Array<Record<string, ?>>}) => Promise<import(\"./sync-api-client-types.js\").SyncReplayResponse>} postReplay - Posts one replay request.\n * @property {import(\"../configuration-types.js\").VelociousSyncClientRealtimeConfiguration} [realtime] - Realtime push configuration consumed by `subscribeRealtime(...)`.\n * @property {Record<string, SyncClientResourceConfig>} resources - Derived resource policies keyed by resource/model name.\n * @property {?} syncModel - Local pending-sync model class.\n */\n\nexport {}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sync-client-types.js","sourceRoot":"","sources":["../../../src/sync/sync-client-types.js"],"names":[],"mappings":"AAAA,YAAY","sourcesContent":["// @ts-check\n\n/**\n * Client-declared sync scope serialized from a model query.\n * @typedef {object} SerializedSyncScope\n * @property {Record<string, ?>} conditions - Plain attribute conditions from the query.\n * @property {string} resourceType - Resource/model name the scope was declared for.\n * @property {string} [owner] - Local partition key: the authenticated identity that declared the scope. Used only to partition the local scope/cursor store (never sent to the server as scope conditions), so a user scope's empty-conditions cursor does not leak across accounts on a shared device.\n */\n\n/**\n * Static realtime channel declaration on a model's `static sync`, for channels\n * whose name and params are static.\n * @deprecated Declared pull scopes subscribe the framework sync channel automatically; keep this only for legacy app channels.\n * @typedef {object} ModelSyncRealtimeDeclaration\n * @property {string} channel - Server channel name to subscribe.\n * @property {Record<string, ?>} [params] - Static subscribe params. The framework injects `authenticationToken` automatically.\n */\n\n/**\n * Declarative per-resource sync policy.\n * @typedef {object} SyncClientResourceConfig\n * @property {?} modelClass - Local model class for this resource.\n * @property {import(\"./sync-api-client-types.js\").SyncResourceConfig[\"attributes\"]} [attributes] - Pull-apply attribute mapper. Required for resources that receive pulled changes.\n * @property {import(\"./sync-api-client-types.js\").SyncResourceConfig[\"findRecord\"]} [findRecord] - Custom pull-apply record resolver.\n * @property {import(\"./sync-api-client-types.js\").SyncResourceConfig[\"findRecordForDelete\"]} [findRecordForDelete] - Custom pull-apply delete resolver.\n * @property {import(\"./sync-api-client-types.js\").SyncResourceConfig[\"afterApply\"]} [afterApply] - Post-apply hook.\n * @property {string[]} [booleanAttributes] - Attributes coerced through sync boolean parsing when queueing.\n * @property {string[]} [localOnlyAttributes] - Attributes stripped from queued payloads.\n * @property {\"upsert\" | ((args: {operation: \"create\" | \"update\" | \"destroy\", record: ?}) => string)} [syncType] - Maps a mutation operation to a sync type. The \"upsert\" flag queues creates and updates as \"update\" rows (the server upserts by resource id) and destroys as \"delete\". Defaults to the operation name with destroy mapped to \"delete\".\n * @property {(args: {operation: \"create\" | \"update\" | \"destroy\", record: ?}) => Record<string, ?>} [trackedData] - Custom queued-payload builder for tracked mutations.\n * @property {boolean | {operations: Array<\"create\" | \"update\" | \"destroy\">}} [track] - Automatic mutation tracking policy. On by default (creates and updates queue automatically); `false` opts the resource out, `true` adds destroys, `{operations}` narrows the tracked operations.\n * @property {ModelSyncRealtimeDeclaration} [realtime] - Deprecated: static legacy realtime channel this resource subscribes through `subscribeRealtime(...)`. Declared pull scopes subscribe the framework sync channel automatically.\n */\n\n/**\n * Model-level client sync declaration read from `static sync` by\n * `SyncClient.fromConfiguration(...)`. `true` opts the model in with all\n * defaults; an object customizes the derived resource config.\n * @template [TModel=any]\n * @typedef {object} ModelSyncDeclarationConfig\n * @property {import(\"./sync-api-client-types.js\").SyncResourceConfig[\"afterApply\"]} [afterApply] - Post-apply hook.\n * @property {import(\"./sync-api-client-types.js\").SyncResourceConfig[\"attributes\"]} [attributes] - Pull-apply attribute mapper. Required for resources that receive pulled changes.\n * @property {string[]} [booleanAttributes] - Extra boolean attributes merged with the boolean columns derived from column types.\n * @property {import(\"./sync-api-client-types.js\").SyncResourceConfig[\"findRecord\"]} [findRecord] - Custom pull-apply record resolver.\n * @property {import(\"./sync-api-client-types.js\").SyncResourceConfig[\"findRecordForDelete\"]} [findRecordForDelete] - Custom pull-apply delete resolver.\n * @property {string[]} [localOnlyAttributes] - Extra local-only attributes merged with the derived primary key, createdAt/updatedAt, and sync bookkeeping attributes.\n * @property {import(\"./sync-publisher-types.js\").SyncPublishDeclaration<TModel>} [publish] - Server-side publish declaration consumed by `SyncPublisher.fromConfiguration(...)` on the backend; ignored by the client.\n * @property {\"upsert\" | ((args: {operation: \"create\" | \"update\" | \"destroy\", record: ?}) => string)} [syncType] - Sync type flag or mapper (see SyncClientResourceConfig).\n * @property {boolean | Array<\"create\" | \"update\" | \"destroy\"> | {operations: Array<\"create\" | \"update\" | \"destroy\">}} [track] - Automatic mutation tracking policy; an array is shorthand for {operations}. On by default (creates and updates queue automatically); `false` opts the model out (for models written by non-user flows), `true` adds destroys.\n * @property {(args: {operation: \"create\" | \"update\" | \"destroy\", record: ?}) => Record<string, ?>} [trackedData] - Custom queued-payload builder for tracked mutations.\n * @property {ModelSyncRealtimeDeclaration} [realtime] - Deprecated: static legacy realtime channel this resource subscribes through `subscribeRealtime(...)`. Declared pull scopes subscribe the framework sync channel automatically.\n */\n\n/**\n * Model-level sync declaration value: `true` opts in with all defaults, an\n * object customizes the derived resource config.\n * @template [TModel=any]\n * @typedef {boolean | ModelSyncDeclarationConfig<TModel>} ModelSyncDeclaration\n */\n\n/**\n * Shared app-lifetime websocket connection all sync traffic rides. Matches the\n * realtime websocket client contract; the sync client rides it without owning\n * its connect/disconnect lifecycle.\n * @typedef {import(\"../configuration-types.js\").VelociousSyncRealtimeWebsocketClient} SyncClientSharedConnection\n */\n\n/**\n * Options for building a sync client. Everything else — resources, transport\n * POSTers, auth, connectivity, batch size — is derived from the configuration's\n * registered models (`static sync`) and its `sync.client` block.\n * @typedef {object} SyncClientOptions\n * @property {import(\"../configuration.js\").default} [configuration] - Configuration owning the registered models, the `sync.client` block, and the scope-store database. Defaults to the current configuration.\n * @property {(args: {scope: SerializedSyncScope}) => string | null | Promise<string | null>} [legacyCursor] - Seeds a newly declared scope's cursor (e.g. from a pre-scope cursor store) so devices don't re-pull everything.\n * @property {import(\"./sync-scope-store.js\").default} [scopeStore] - Scope store override (tests).\n * @property {?} [syncModel] - Pending-sync model override. Defaults to the registered \"Sync\" model.\n */\n\n/**\n * Internal derived sync client configuration built by the SyncClient\n * constructor — not an app-facing API.\n * @typedef {object} SyncClientConfig\n * @property {() => string | Promise<string>} authenticationToken - Resolves the auth token sent with sync requests.\n * @property {number} [batchSize] - Max syncs per request.\n * @property {import(\"../configuration.js\").default} configuration - Configuration owning the scope-store database.\n * @property {() => boolean | Promise<boolean>} [isOnline] - Connectivity gate for pulls and replays. Defaults to always online.\n * @property {(args: {scope: SerializedSyncScope}) => string | null | Promise<string | null>} [legacyCursor] - Seeds a newly declared scope's cursor (e.g. from a pre-scope cursor store) so devices don't re-pull everything.\n * @property {(error: Error) => void} [onError] - Reports background replay/pull failures. Defaults to rethrowing.\n * @property {(payload: import(\"./sync-api-client-types.js\").SyncChangesRequest & {scope: SerializedSyncScope}) => Promise<import(\"./sync-api-client-types.js\").SyncChangesResponse>} postChanges - Posts one changes request.\n * @property {(payload: {authenticationToken: string, syncs: Array<Record<string, ?>>}) => Promise<import(\"./sync-api-client-types.js\").SyncReplayResponse>} postReplay - Posts one replay request.\n * @property {import(\"../configuration-types.js\").VelociousSyncClientRealtimeConfiguration} [realtime] - Realtime push configuration consumed by `subscribeRealtime(...)`.\n * @property {Record<string, SyncClientResourceConfig>} resources - Derived resource policies keyed by resource/model name.\n * @property {?} syncModel - Local pending-sync model class.\n * @property {SyncClientSharedConnection} [websocketClient] - Shared app-lifetime websocket client instance (the low-level shared-connection form).\n * @property {string | (() => string | null | undefined)} [websocketUrl] - Shared app-lifetime websocket URL the framework builds a client from.\n */\n\nexport {}\n"]}

package/build/src/sync/sync-client.d.ts

@@ -57,6 +57,12 @@ export default class SyncClient {
     _clientNumber: number;
     /** @type {SyncRealtimeBridge | null} */
     _realtimeBridge: SyncRealtimeBridge | null;
+    /** @type {import("./sync-client-types.js").SyncClientSharedConnection | null | undefined} Shared app-lifetime websocket connection (undefined until first resolved, null when none is configured). */
+    _syncConnection: import("./sync-client-types.js").SyncClientSharedConnection | null | undefined;
+    /** @type {Promise<void> | null} */
+    _subscribeUserScopePromise: Promise<void> | null;
+    /** @type {"subscribed" | "subscribing" | "unsubscribed"} */
+    _userScopeState: "subscribed" | "subscribing" | "unsubscribed";
     /** @type {import("./sync-scope-store.js").default | null} */
     _scopeStore: import("./sync-scope-store.js").default | null;
     /** @type {Promise<void> | null} */
@@ -210,6 +216,18 @@ export default class SyncClient {
     remoteApplySync({ source }?: {
         source?: string;
     }): (sync: import("./sync-api-client-types.js").SyncChangeEnvelope) => Promise<import("./sync-api-client-types.js").SyncChangeApplyResult>;
+    /**
+     * Resolves the shared app-lifetime websocket connection all sync traffic
+     * rides, or null when none is configured. Built once and memoized (per
+     * client): an app-provided `sync.client.websocketClient` instance wins (the
+     * frontend-model transport can pass its own client so one socket carries
+     * everything), else a framework-owned reconnecting {@link VelociousWebsocketClient}
+     * built from `sync.client.websocketUrl`. The realtime bridge rides this
+     * connection without owning its lifecycle; when neither is configured the
+     * bridge falls back to the deprecated per-cycle `realtime.createClient`.
+     * @returns {import("./sync-client-types.js").SyncClientSharedConnection | null} Shared websocket connection, or null.
+     */
+    syncConnection(): import("./sync-client-types.js").SyncClientSharedConnection | null;
     /**
      * Subscribes the derived realtime channels so pushed websocket changes apply
      * through the same derived applier as pulls (idempotent, single-flighted).
@@ -217,6 +235,49 @@ export default class SyncClient {
      * @returns {Promise<void>}
      */
     subscribeRealtime(context?: unknown): Promise<void>;
+    /**
+     * Subscribes the server-enumerated user scope: "everything my ability can
+     * see". Declares a user scope (empty conditions) for every pullable synced
+     * resource type, subscribes realtime so their framework sync channel
+     * subscriptions go live, and pulls so the device catches up. The server
+     * authorizes each empty-conditions scope through the app sync resource's
+     * `authorizeChanges` and re-checks record access per delivery, so the client
+     * subscribes with just its token and the server decides membership.
+     * Idempotent and single-flighted like {@link SyncClient#subscribeRealtime}.
+     * @returns {Promise<void>}
+     */
+    subscribeUserScope(): Promise<void>;
+    /**
+     * Declares and activates the user scope for every pullable resource, then
+     * subscribes realtime and pulls.
+     * @returns {Promise<void>}
+     */
+    _subscribeUserScope(): Promise<void>;
+    /**
+     * Unsubscribes the user scope: deactivates the per-resource user scopes and
+     * closes the realtime channel subscriptions. The shared websocket connection
+     * stays open when one is configured (sign-out drops subscriptions without
+     * disconnecting), so a subsequent sign-in resubscribes over the same socket.
+     * @returns {Promise<void>}
+     */
+    unsubscribeUserScope(): Promise<void>;
+    /**
+     * The resource types a user scope covers: every declared resource that
+     * receives pulled changes (has pull `attributes`).
+     * @returns {string[]} Pullable resource type names.
+     */
+    userScopeResourceTypes(): string[];
+    /**
+     * Resolves the local partition key for the user scope: the currently
+     * configured authenticated identity (the sync auth token). Partitioning the
+     * user scope's local scope/cursor rows by this owner keeps the
+     * empty-conditions cursor from leaking across accounts on a shared device
+     * (account B signing in after account A gets a fresh cursor) while the same
+     * account reconnecting keeps its cursor continuity. The owner is a local
+     * partition key only — pulls still post empty conditions to the server.
+     * @returns {Promise<string>} User-scope owner partition key.
+     */
+    userScopeOwner(): Promise<string>;
     /**
      * Unsubscribes the realtime channels and disconnects the websocket client (idempotent).
      * @returns {Promise<void>}

package/build/src/sync/sync-client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sync-client.d.ts","sourceRoot":"","sources":["../../../src/sync/sync-client.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"sync-client.d.ts","sourceRoot":"","sources":["../../../src/sync/sync-client.js"],"names":[],"mappings":"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"}