@syncular/client 0.15.47 → 0.15.48

package/dist/worker-entry.js

@@ -147,9 +147,6 @@ export function startSyncWorker(overrides = {}) {
         autoSyncScheduled = true;
         queueMicrotask(runAutoSync);
     }
-    function consumeEffects(effects) {
-        consumeSyncIntent(effects.sync);
-    }
     function requireClient() {
         if (client === undefined) {
             throw new ClientSyncError(WORKER_FAILED_CODE, 'the worker received a call before init completed');
@@ -304,20 +301,16 @@ export function startSyncWorker(overrides = {}) {
         subscribe: (input) => requireClient().subscribe(input),
         unsubscribe: (id) => requireClient().unsubscribe(id),
         setWindow: async (base, units) => {
-            const result = await requireClient().setWindowCommand(base, units);
-            consumeEffects(result.effects);
+            await requireClient().setWindowCommand(base, units);
         },
         windowState: (base) => requireClient().windowState(base),
         mutate: (mutations) => {
-            const result = requireClient().mutateCommand(mutations);
-            consumeEffects(result.effects);
-            return result.value;
+            return requireClient().mutateCommand(mutations).value;
         },
         patch: (table, rowId, partial, options) => {
             // Same §8.4 rule as `mutate`: a local write must push without the app
             // orchestrating sync, so consume the core's immediate intent.
             const result = requireClient().patchCommand(table, rowId, partial, options);
-            consumeEffects(result.effects);
             return result.value;
         },
         purgeLocalData: (input) => requireClient().purgeLocalData(input),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syncular/client",
-  "version": "0.15.47",
+  "version": "0.15.48",
   "description": "Syncular TypeScript client core — offline-first sync over SQLite (WASM/OPFS, Bun, Node)",
   "license": "Apache-2.0",
   "author": "Benjamin Kniffler",
@@ -97,9 +97,9 @@
   },
   "dependencies": {
     "@sqlite.org/sqlite-wasm": "^3.53.0-build1",
-    "@syncular/core": "0.15.47"
+    "@syncular/core": "0.15.48"
   },
   "devDependencies": {
-    "@syncular/server": "0.15.47"
+    "@syncular/server": "0.15.48"
   }
 }

package/src/bun-database.ts

@@ -15,6 +15,12 @@ import {
   type SqlValue,
 } from './database';
 
+declare module 'bun:sqlite' {
+  interface Database {
+    clearQueryCache(): void;
+  }
+}
+
 type BunParam = string | number | bigint | Uint8Array | null;
 
 function coerceParams(params: readonly SqlValue[]): BunParam[] {
@@ -34,6 +40,11 @@ export class BunClientDatabase implements ClientDatabase {
 
   exec(sql: string, params: readonly SqlValue[] = []): void {
     this.db.query(sql).run(...coerceParams(params));
+    // `Database.query()` caches prepared statements. Clear that cache after
+    // schema DDL so a reset does not reprepare every later row upsert.
+    if (/^\s*(?:CREATE|DROP|ALTER)\b/i.test(sql)) {
+      this.db.clearQueryCache();
+    }
   }
 
   query(sql: string, params: readonly SqlValue[] = []): SqlRow[] {

package/src/client.ts

@@ -513,6 +513,8 @@ function emptySummary(pushed: number): MutableSummary {
   };
 }
 
+const LOG_EPOCH_META_KEY = 'logEpoch';
+
 function isFinalPushResult(frame: PushResultFrame): boolean {
   return (
     frame.status !== 'rejected' ||
@@ -579,6 +581,10 @@ export class SyncClient {
   readonly #invalidation = new InvalidationEmitter();
   /** §8.6: subscribable presence-change listeners (twin of onPresence). */
   readonly #presenceListeners = new Set<(scopeKey: string) => void>();
+  readonly #syncNeededListeners = new Set<
+    (reason: 'startup' | 'hello' | WakeReason) => void
+  >();
+  readonly #syncIntentListeners = new Set<(intent: SyncIntent) => void>();
   readonly #diagnostics = new ClientDiagnosticsEmitter();
   #diagnosticsDeferralDepth = 0;
   #diagnosticsPending = false;
@@ -705,8 +711,8 @@ export class SyncClient {
         subscriptions.some((sub) => sub.status === 'active'));
     if (startupWork && this.#securityLifecycle === 'active') {
       this.#needsPull = true;
-      this.#config.onSyncNeeded?.('startup');
-      this.#config.onSyncIntent?.({ kind: 'interactive' });
+      this.#emitSyncNeeded('startup');
+      this.#emitSyncIntent({ kind: 'interactive' });
     }
     // Console introspection is a no-op outside a dev page.
     this.#devtoolsUnregister = registerDevtools({
@@ -776,6 +782,29 @@ export class SyncClient {
     this.#replayOutbox();
   }
 
+  /** §2.1 reset after the server reports a different log continuity. */
+  #runLogEpochReset(logEpoch: string): string[] {
+    const subscriptions = loadSubscriptions(this.#db);
+    const pending = listOutbox(this.#db);
+    this.#setUpgrading(true);
+    this.#applyBatch((batch) => {
+      this.#db.transaction(() => {
+        dropAndRecreateSyncedTables(this.#db, this.#schema);
+        resetSubscriptionsForBump(this.#db);
+        setMeta(this.#db, LOG_EPOCH_META_KEY, logEpoch);
+        for (const commit of pending) {
+          this.#applyOperationsLocally(commit.operations, batch);
+        }
+      });
+      for (const table of this.#schema.tables.values()) batch.table(table.name);
+    });
+    this.#localResetEpoch += 1;
+    this.#setSyncNeeded(true);
+    this.#emitSyncNeeded('startup');
+    this.#emitSyncIntent({ kind: 'interactive' });
+    return subscriptions.map((subscription) => subscription.id);
+  }
+
   #setUpgrading(upgrading: boolean): void {
     if (this.#upgrading === upgrading) return;
     this.#applyBatch((batch) => {
@@ -803,6 +832,7 @@ export class SyncClient {
   }
 
   async close(): Promise<void> {
+    this.#emitSyncIntent({ kind: 'none' });
     this.#devtoolsUnregister?.();
     this.#devtoolsUnregister = undefined;
     this.disconnectRealtime();
@@ -810,6 +840,38 @@ export class SyncClient {
     await this.#lease?.release();
     this.#lease = undefined;
     this.#started = false;
+    this.#syncNeededListeners.clear();
+    this.#syncIntentListeners.clear();
+  }
+
+  #emitSyncNeeded(reason: 'startup' | 'hello' | WakeReason): void {
+    try {
+      this.#config.onSyncNeeded?.(reason);
+    } catch {
+      // An observer cannot alter sync correctness.
+    }
+    for (const listener of this.#syncNeededListeners) {
+      try {
+        listener(reason);
+      } catch {
+        // An observer cannot alter sync correctness.
+      }
+    }
+  }
+
+  #emitSyncIntent(intent: SyncIntent): void {
+    try {
+      this.#config.onSyncIntent?.(intent);
+    } catch {
+      // An observer cannot alter sync correctness.
+    }
+    for (const listener of this.#syncIntentListeners) {
+      try {
+        listener(intent);
+      } catch {
+        // An observer cannot alter sync correctness.
+      }
+    }
   }
 
   /** Current fail-closed local-replica security state. */
@@ -869,8 +931,8 @@ export class SyncClient {
         loadSubscriptions(this.#db).some((sub) => sub.status === 'active'));
     if (startupWork) {
       this.#setSyncNeeded(true);
-      this.#config.onSyncNeeded?.('startup');
-      this.#config.onSyncIntent?.({ kind: 'interactive' });
+      this.#emitSyncNeeded('startup');
+      this.#emitSyncIntent({ kind: 'interactive' });
     }
     this.#emitDiagnostics();
   }
@@ -982,6 +1044,24 @@ export class SyncClient {
     return this.#changes.on(listener);
   }
 
+  /** Subscribe to host wake signals raised by startup and realtime. */
+  onSyncNeeded(
+    listener: (reason: 'startup' | 'hello' | WakeReason) => void,
+  ): () => void {
+    this.#syncNeededListeners.add(listener);
+    return () => {
+      this.#syncNeededListeners.delete(listener);
+    };
+  }
+
+  /** Subscribe to exact core-owned scheduling instructions. */
+  onSyncIntent(listener: (intent: SyncIntent) => void): () => void {
+    this.#syncIntentListeners.add(listener);
+    return () => {
+      this.#syncIntentListeners.delete(listener);
+    };
+  }
+
   /** Subscribe to complete, privacy-safe diagnostic snapshots. */
   onDiagnostics(listener: ClientDiagnosticsListener): () => void {
     return this.#diagnostics.on(listener);
@@ -1781,12 +1861,17 @@ export class SyncClient {
       cursor: -1,
       status: 'active',
     });
+    this.#setSyncNeeded(true);
+    this.#emitSyncIntent({ kind: 'interactive' });
     this.#emitDiagnostics();
   }
 
   unsubscribe(id: string): void {
     this.#requireActive();
+    if (getSubscription(this.#db, id) === undefined) return;
     deleteSubscription(this.#db, id);
+    this.#setSyncNeeded(true);
+    this.#emitSyncIntent({ kind: 'interactive' });
     this.#emitDiagnostics();
   }
 
@@ -1851,7 +1936,9 @@ export class SyncClient {
               status: 'active',
             });
           });
+          this.#needsPull = true;
           batch.window(baseKey, base.table, unit);
+          batch.status();
         });
         changed = true;
         widened = true;
@@ -1867,6 +1954,9 @@ export class SyncClient {
     const effects: CommandEffects = {
       sync: changed || widened ? { kind: 'interactive' } : { kind: 'none' },
     };
+    if (effects.sync.kind === 'interactive') {
+      this.#emitSyncIntent(effects.sync);
+    }
     return { value: undefined, effects };
   }
 
@@ -1934,6 +2024,8 @@ export class SyncClient {
       });
       batch.scopeMap(table, effective);
       batch.window(baseKey, table.name, unit);
+      this.#needsPull = true;
+      batch.status();
     });
   }
 
@@ -2043,7 +2135,9 @@ export class SyncClient {
         this.#applyOperationsLocally(operations, batch);
         batch.status();
       });
+      this.#needsPull = true;
     });
+    this.#emitSyncIntent({ kind: 'interactive' });
     return clientCommitId;
   }
 
@@ -2320,8 +2414,8 @@ export class SyncClient {
     this.#localResetEpoch += 1;
 
     if (!priorUpgrading) this.#config.onUpgrading?.(true);
-    this.#config.onSyncNeeded?.('startup');
-    this.#config.onSyncIntent?.({ kind: 'interactive' });
+    this.#emitSyncNeeded('startup');
+    this.#emitSyncIntent({ kind: 'interactive' });
     return {
       alreadyApplied: false,
       retainedCommits: pending.length,
@@ -2585,9 +2679,14 @@ export class SyncClient {
     // survive it — the reference server keeps no replay buffer (§8.2).
     this.#setSyncNeeded(false);
     try {
+      const logEpoch = getMeta(this.#db, LOG_EPOCH_META_KEY);
       // §5.9.7 B4: upload pending blobs BEFORE pushing rows that reference
       // them, so the server-side existence check (§6.6) passes.
-      if (this.#hasBlobs && this.#config.blobs !== undefined) {
+      if (
+        logEpoch !== undefined &&
+        this.#hasBlobs &&
+        this.#config.blobs !== undefined
+      ) {
         await this.flushBlobUploads();
       }
       // §7.4.4: encode the outbox with the CURRENT codec; a commit that
@@ -2596,7 +2695,9 @@ export class SyncClient {
       // the queue. `pushFrames` and `outbox` stay index-aligned for result
       // mapping.
       const { pushFrames, outbox, deferred } =
-        await this.#encodeOutboxForPush();
+        logEpoch === undefined
+          ? { pushFrames: [], outbox: [], deferred: 0 }
+          : await this.#encodeOutboxForPush();
       // Captured together with the subscription state below: the response
       // apply persists SUB_END cursors only while this epoch is current.
       const resetEpoch = this.#localResetEpoch;
@@ -2609,6 +2710,7 @@ export class SyncClient {
           type: 'REQ_HEADER',
           clientId: this.#clientId,
           schemaVersion: this.#schema.version,
+          ...(logEpoch !== undefined ? { logEpoch } : {}),
         },
         ...pushFrames,
         {
@@ -2686,11 +2788,7 @@ export class SyncClient {
           delayMs: this.#retryDelayMs,
         };
         this.#retryDelayMs = Math.min(this.#retryDelayMs * 2, 30_000);
-        try {
-          this.#config.onSyncIntent?.(intent);
-        } catch {
-          // An observer cannot alter sync correctness.
-        }
+        this.#emitSyncIntent(intent);
       }
       throw error;
     } finally {
@@ -2916,14 +3014,14 @@ export class SyncClient {
     if (event.event === 'hello') {
       if (event.data.requiresSync) {
         this.#setSyncNeeded(true);
-        this.#config.onSyncNeeded?.('hello');
+        this.#emitSyncNeeded('hello');
       }
       return;
     }
     if (event.event === 'sync') {
       // §8.3: any wake-up means "run a pull soon", never data.
       this.#setSyncNeeded(true);
-      this.#config.onSyncNeeded?.(event.data.reason);
+      this.#emitSyncNeeded(event.data.reason);
       return;
     }
     if (event.event === 'presence') {
@@ -2995,7 +3093,7 @@ export class SyncClient {
       } catch {
         // A delta that cannot be applied is recovered by a pull (§8.3).
         this.#setSyncNeeded(true);
-        this.#config.onSyncNeeded?.('catchup-required');
+        this.#emitSyncNeeded('catchup-required');
       }
     });
   }
@@ -3057,6 +3155,16 @@ export class SyncClient {
     if (header?.type !== 'RESP_HEADER') {
       throw new ClientSyncError('sync.invalid_request', 'missing RESP_HEADER');
     }
+    if (
+      message.wireVersion < 2 ||
+      header.logEpoch === undefined ||
+      header.resetRequired === undefined
+    ) {
+      throw new ClientSyncError(
+        'client.invalid_host_response',
+        'the server response does not carry wire version 2 log-epoch state',
+      );
+    }
     if (header.requiredSchemaVersion !== undefined) {
       // §1.6 schema floor: nothing else was processed — stop syncing and
       // surface the upgrade requirement. A live-round floor always stops:
@@ -3078,6 +3186,26 @@ export class SyncClient {
         schemaFloor,
       };
     }
+    const currentLogEpoch = getMeta(this.#db, LOG_EPOCH_META_KEY);
+    if (header.resetRequired) {
+      if (mode !== 'pull' || message.frames.length !== 1) {
+        throw new ClientSyncError(
+          'client.invalid_host_response',
+          'a log-epoch reset response must contain only RESP_HEADER',
+        );
+      }
+      return {
+        ...summary,
+        resets: this.#runLogEpochReset(header.logEpoch),
+        bootstrapping: [],
+      };
+    }
+    if (currentLogEpoch === undefined || currentLogEpoch !== header.logEpoch) {
+      throw new ClientSyncError(
+        'client.invalid_host_response',
+        'the server changed logEpoch without requiring a reset',
+      );
+    }
 
     let section: OpenSection | undefined;
     let errorFrame: ClientSyncError | undefined;

package/src/index.ts

@@ -35,6 +35,7 @@ export * from './realtime-supervisor';
 export * from './schema';
 export * from './sql-tag';
 export * from './state';
+export * from './sync-scheduler';
 export * from './transport';
 export * from './window';
 export * from './worker-host';

package/src/remote.ts

@@ -10,7 +10,6 @@ import {
   encodeRemoteOperationRequest,
   encodeRemoteOperationRealtimeMessage,
   encodeRow,
-  PROTOCOL_WIRE_VERSION,
   type PushOperation,
   type PushOperationResult,
   type PushResultDetailsFrame,
@@ -42,6 +41,8 @@ export interface SyncRemoteClientConfig {
   readonly operations?: RemoteOperationTransport;
   readonly operationRealtime?: RemoteOperationRealtimeConnector;
   readonly encryption?: EncryptionConfig;
+  /** Acquired partition log epoch for restore-safe ordinary commits (§2.1). */
+  readonly logEpoch?: string;
 }
 
 export interface RemoteCommitInput {
@@ -203,11 +204,15 @@ export class SyncRemoteClient {
     }
   >();
   readonly #encryption: EncryptionConfig | undefined;
+  readonly #logEpoch: string | undefined;
 
   constructor(config: SyncRemoteClientConfig) {
     if (config.clientId.length === 0) {
       throw invalid('SyncRemoteClient clientId must be non-empty');
     }
+    if (config.logEpoch !== undefined && config.logEpoch.length === 0) {
+      throw invalid('SyncRemoteClient logEpoch must be non-empty');
+    }
     this.#schema =
       config.schema === undefined
         ? undefined
@@ -217,6 +222,7 @@ export class SyncRemoteClient {
     this.#operations = config.operations;
     this.#operationRealtime = config.operationRealtime;
     this.#encryption = config.encryption;
+    this.#logEpoch = config.logEpoch;
   }
 
   async prepareCommit(input: RemoteCommitInput): Promise<PreparedRemoteCommit> {
@@ -277,13 +283,16 @@ export class SyncRemoteClient {
     return {
       requestId: input.requestId,
       bytes: encodeMessage({
-        wireVersion: PROTOCOL_WIRE_VERSION,
+        wireVersion: this.#logEpoch === undefined ? 1 : 2,
         msgKind: 'request',
         frames: [
           {
             type: 'REQ_HEADER',
             clientId: this.#clientId,
             schemaVersion: schema.version,
+            ...(this.#logEpoch !== undefined
+              ? { logEpoch: this.#logEpoch }
+              : {}),
           },
           {
             type: 'PUSH_COMMIT',

package/src/sync-scheduler.ts

@@ -0,0 +1,154 @@
+import type { WakeReason } from '@syncular/core';
+import type { SecurityLifecycle } from './client';
+import type { SyncIntent } from './invalidation';
+
+export interface SyncSchedulerClient {
+  readonly syncNeeded: boolean;
+  readonly securityLifecycle: SecurityLifecycle;
+  syncUntilIdle(maxRounds?: number): Promise<unknown>;
+  onSyncNeeded(
+    listener: (reason: 'startup' | 'hello' | WakeReason) => void,
+  ): () => void;
+  onSyncIntent(listener: (intent: SyncIntent) => void): () => void;
+}
+
+export interface SyncSchedulerOptions {
+  readonly maxRounds?: number;
+  readonly onError?: (error: unknown) => void;
+  readonly now?: () => number;
+  readonly queueMicrotask?: (callback: () => void) => void;
+  readonly schedule?: (callback: () => void, delayMs: number) => () => void;
+}
+
+export interface SyncScheduler {
+  readonly stopped: boolean;
+  stop(): void;
+}
+
+/** Install the event-driven single-flight host loop for a direct client. */
+export function installSyncScheduler(
+  client: SyncSchedulerClient,
+  options: SyncSchedulerOptions = {},
+): SyncScheduler {
+  const now = options.now ?? Date.now;
+  const enqueue = options.queueMicrotask ?? globalThis.queueMicrotask;
+  const schedule =
+    options.schedule ??
+    ((callback: () => void, delayMs: number): (() => void) => {
+      const timer = globalThis.setTimeout(callback, delayMs);
+      return () => globalThis.clearTimeout(timer);
+    });
+  let stopped = false;
+  let running = false;
+  let immediatePending = false;
+  let immediateQueued = false;
+  let backgroundReady = false;
+  let backgroundDue = Number.POSITIVE_INFINITY;
+  let cancelBackground: (() => void) | undefined;
+
+  const report = (error: unknown): void => {
+    if (options.onError !== undefined) {
+      options.onError(error);
+      return;
+    }
+    const root: typeof globalThis & {
+      reportError?: (error: unknown) => void;
+    } = globalThis;
+    if (root.reportError !== undefined) root.reportError(error);
+    else console.error(error);
+  };
+
+  const clearBackground = (): void => {
+    cancelBackground?.();
+    cancelBackground = undefined;
+    backgroundReady = false;
+    backgroundDue = Number.POSITIVE_INFINITY;
+  };
+
+  const queueImmediate = (): void => {
+    immediatePending = true;
+    if (stopped || running || immediateQueued) return;
+    immediateQueued = true;
+    enqueue(() => {
+      immediateQueued = false;
+      if (stopped || !immediatePending) return;
+      immediatePending = false;
+      run();
+    });
+  };
+
+  const run = (): void => {
+    if (stopped || running) return;
+    if (client.securityLifecycle === 'preflight') {
+      immediatePending = false;
+      return;
+    }
+    running = true;
+    backgroundReady = false;
+    void client
+      .syncUntilIdle(options.maxRounds)
+      .catch((error: unknown) => {
+        if (!stopped) report(error);
+      })
+      .finally(() => {
+        running = false;
+        if (stopped) return;
+        if (immediatePending || backgroundReady) {
+          queueImmediate();
+          return;
+        }
+        if (cancelBackground !== undefined && backgroundDue <= now()) {
+          clearBackground();
+          queueImmediate();
+        }
+      });
+  };
+
+  const consume = (intent: SyncIntent): void => {
+    if (stopped) return;
+    if (intent.kind === 'none') {
+      clearBackground();
+      immediatePending = false;
+      return;
+    }
+    if (intent.kind === 'interactive') {
+      clearBackground();
+      queueImmediate();
+      return;
+    }
+    if (immediatePending || immediateQueued) return;
+    clearBackground();
+    backgroundDue = now() + Math.max(0, intent.delayMs);
+    cancelBackground = schedule(
+      () => {
+        cancelBackground = undefined;
+        backgroundDue = Number.POSITIVE_INFINITY;
+        backgroundReady = true;
+        if (!running) queueImmediate();
+      },
+      Math.max(0, intent.delayMs),
+    );
+  };
+
+  const unsubscribeNeeded = client.onSyncNeeded(() => {
+    consume({ kind: 'interactive' });
+  });
+  const unsubscribeIntent = client.onSyncIntent(consume);
+  if (client.syncNeeded && client.securityLifecycle === 'active') {
+    consume({ kind: 'interactive' });
+  }
+
+  return {
+    get stopped() {
+      return stopped;
+    },
+    stop() {
+      if (stopped) return;
+      stopped = true;
+      clearBackground();
+      immediatePending = false;
+      unsubscribeNeeded();
+      unsubscribeIntent();
+    },
+  };
+}

package/src/window.ts

@@ -14,6 +14,71 @@
  */
 import { canonicalScopeJson, type ScopeMap } from '@syncular/core';
 import type { ClientDatabase } from './database';
+import { ClientSyncError } from './errors';
+
+export type TimeBucketUnit = 'month';
+
+const MAX_TIME_BUCKET_MS = 253_402_300_799_999;
+
+function monthBucket(year: number, month: number): string {
+  return `${year.toString().padStart(4, '0')}-${month.toString().padStart(2, '0')}`;
+}
+
+/** Derive the immutable UTC scope value stored when a row is created. */
+export function creationTimeBucket(
+  createdAtMs: number,
+  unit: TimeBucketUnit,
+): string {
+  if (
+    unit !== 'month' ||
+    !Number.isSafeInteger(createdAtMs) ||
+    createdAtMs < 0 ||
+    createdAtMs > MAX_TIME_BUCKET_MS
+  ) {
+    throw new ClientSyncError(
+      'sync.invalid_request',
+      'creationTimeBucket requires a supported unit and a UTC timestamp from 1970 through 9999',
+    );
+  }
+  const date = new Date(createdAtMs);
+  return monthBucket(date.getUTCFullYear(), date.getUTCMonth() + 1);
+}
+
+/** Return a rolling UTC month window ordered from oldest to newest. */
+export function last(
+  count: number,
+  unit: TimeBucketUnit,
+  nowMs = Date.now(),
+): string[] {
+  if (
+    unit !== 'month' ||
+    !Number.isSafeInteger(count) ||
+    count < 1 ||
+    count > 1_200 ||
+    !Number.isSafeInteger(nowMs) ||
+    nowMs < 0 ||
+    nowMs > MAX_TIME_BUCKET_MS
+  ) {
+    throw new ClientSyncError(
+      'sync.invalid_request',
+      'last requires a supported unit, a count from 1 through 1200, and a UTC timestamp from 1970 through 9999',
+    );
+  }
+  const date = new Date(nowMs);
+  const current = date.getUTCFullYear() * 12 + date.getUTCMonth();
+  if (current - (count - 1) < 1970 * 12) {
+    throw new ClientSyncError(
+      'sync.invalid_request',
+      'last requires every returned UTC month to fall from 1970 through 9999',
+    );
+  }
+  const units: string[] = [];
+  for (let offset = count - 1; offset >= 0; offset -= 1) {
+    const value = current - offset;
+    units.push(monthBucket(Math.floor(value / 12), (value % 12) + 1));
+  }
+  return units;
+}
 
 /**
  * A window base: one table, one variable whose values are the window