@hot-updater/server 1.0.0-rc.0 → 1.0.0-rc.2

package/dist/schema/v1_0_0.mjs

@@ -255,19 +255,30 @@ const releaseCatalogsV100 = table("release_catalogs", {
 		referencedColumns: ["id"]
 	})]
 });
+const insightsTextCollations = {
+	postgresql: "\"C\"",
+	mysql: "utf8mb4_0900_bin"
+};
+const insightsProviders = [
+	"postgresql",
+	"mysql",
+	"sqlite",
+	"cockroachdb",
+	"mongodb"
+];
 const bundleEventsV100 = table("bundle_events", {
 	id: idColumn("id", "uuid"),
-	type: stringColumn("type"),
-	install_id: stringColumn("install_id"),
-	user_id: stringColumn("user_id").nullable(),
+	type: column("type", varchar(32)),
+	install_id: column("install_id", varchar(255)).collate(insightsTextCollations),
+	user_id: column("user_id", varchar(255)).collate(insightsTextCollations).nullable(),
 	username: stringColumn("username").nullable(),
 	from_release_id: uuid("from_release_id").nullable(),
 	from_bundle_id: uuid("from_bundle_id").nullable(),
 	to_release_id: uuid("to_release_id").nullable(),
 	to_bundle_id: uuid("to_bundle_id"),
-	platform: stringColumn("platform"),
+	platform: stringColumn("platform").collate(insightsTextCollations),
 	app_version: stringColumn("app_version"),
-	channel: stringColumn("channel"),
+	channel: stringColumn("channel").collate(insightsTextCollations),
 	cohort: stringColumn("cohort"),
 	update_strategy: stringColumn("update_strategy").nullable(),
 	fingerprint_hash: stringColumn("fingerprint_hash").nullable(),
@@ -278,43 +289,26 @@ const bundleEventsV100 = table("bundle_events", {
 		index("bundle_events_received_at_idx", ["received_at_ms", "id"]),
 		index("bundle_events_install_idx", [
 			"install_id",
-			"received_at_ms",
-			"id"
-		]),
-		index("bundle_events_user_id_idx", [
-			"user_id",
-			"received_at_ms",
-			"id"
-		]),
-		index("bundle_events_username_idx", [
-			"username",
-			"received_at_ms",
-			"id"
-		]),
-		index("bundle_events_to_bundle_idx", [
 			"type",
-			"to_bundle_id",
 			"received_at_ms",
 			"id"
 		]),
 		index("bundle_events_from_bundle_idx", [
 			"type",
+			"platform",
+			"channel",
 			"from_bundle_id",
 			"received_at_ms",
 			"id"
-		]),
-		index("bundle_events_to_release_idx", [
-			"type",
-			"to_release_id",
-			"received_at_ms",
-			"id"
-		]),
-		index("bundle_events_from_release_idx", [
+		], insightsProviders),
+		index("bundle_events_to_bundle_idx", [
 			"type",
-			"from_release_id",
+			"platform",
+			"channel",
+			"to_bundle_id",
 			"received_at_ms",
 			"id"
-		])
+		], insightsProviders)
 	],
 	checks: [
 		check({
@@ -339,6 +333,52 @@ const bundleEventsV100 = table("bundle_events", {
 		})
 	]
 });
+const bundleInstallationsV100 = table("bundle_installations", {
+	install_id: idColumn("install_id", varchar(255)).collate(insightsTextCollations),
+	id: uuid("id"),
+	user_id: column("user_id", varchar(255)).collate(insightsTextCollations).nullable(),
+	username: stringColumn("username").nullable(),
+	to_bundle_id: uuid("to_bundle_id"),
+	type: column("type", varchar(32)),
+	platform: stringColumn("platform").collate(insightsTextCollations),
+	app_version: stringColumn("app_version"),
+	channel: stringColumn("channel").collate(insightsTextCollations),
+	cohort: stringColumn("cohort"),
+	received_at_ms: float("received_at_ms")
+}, {
+	indexes: [
+		index("bundle_installations_user_id_idx", ["user_id", "install_id"]),
+		index("bundle_installations_received_at_idx", ["received_at_ms"]),
+		index("bundle_installations_scope_idx", [
+			"platform",
+			"channel",
+			"received_at_ms"
+		], insightsProviders),
+		index("bundle_installations_bundle_idx", [
+			"platform",
+			"channel",
+			"to_bundle_id",
+			"received_at_ms"
+		], insightsProviders)
+	],
+	checks: [
+		check({
+			name: "bundle_installations_type_check",
+			expression: "type in ('UPDATE_APPLIED', 'RECOVERED', 'RELEASE_ADOPTED', 'UNCHANGED')",
+			sqliteInline: true
+		}),
+		check({
+			name: "bundle_installations_platform_check",
+			expression: "platform in ('ios', 'android')",
+			sqliteInline: true
+		}),
+		check({
+			name: "bundle_installations_received_at_check",
+			expression: "received_at_ms >= 0",
+			sqliteInline: true
+		})
+	]
+});
 const v1_0_0 = schema({
 	version: "1.0.0",
 	settingsTable: HOT_UPDATER_SETTINGS_TABLE,
@@ -349,9 +389,10 @@ const v1_0_0 = schema({
 		releasesV100,
 		releaseCatalogsV100,
 		bundleEventsV100,
+		bundleInstallationsV100,
 		apiKeysV100,
 		createSettingsTable("1.0.0")
 	]
 });
 //#endregion
-export { apiKeysV100, bundleEventsV100, bundlePatchesV100, bundlesV100, channelsV100, releaseCatalogsV100, releasesV100, v1_0_0 };
+export { apiKeysV100, bundleEventsV100, bundleInstallationsV100, bundlePatchesV100, bundlesV100, channelsV100, releaseCatalogsV100, releasesV100, v1_0_0 };

package/dist/storageAccess.cjs

@@ -1,4 +1,3 @@
-require("./_virtual/_rolldown/runtime.cjs");
 let _hot_updater_plugin_core = require("@hot-updater/plugin-core");
 //#region src/storageAccess.ts
 const assertRemoteUrl = (value) => {

package/dist/types/index.d.cts

@@ -1,7 +1,6 @@
 import { HotUpdaterAPI } from "../createHotUpdaterCore.cjs";
 import { Bundle, Bundle as Bundle$2 } from "@hot-updater/core";
 import { ChannelRow } from "@hot-updater/plugin-core";
-
 //#region src/types/index.d.ts
 interface PaginationInfo {
   total: number;

package/dist/types/index.d.mts

@@ -1,7 +1,6 @@
 import { HotUpdaterAPI } from "../createHotUpdaterCore.mjs";
 import { ChannelRow } from "@hot-updater/plugin-core";
 import { Bundle as Bundle$1, Bundle as Bundle$2 } from "@hot-updater/core";
-
 //#region src/types/index.d.ts
 interface PaginationInfo {
   total: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hot-updater/server",
-  "version": "1.0.0-rc.0",
+  "version": "1.0.0-rc.2",
   "type": "module",
   "description": "React Native OTA solution for self-hosted",
   "sideEffects": false,
@@ -54,10 +54,10 @@
   },
   "dependencies": {
     "rou3": "0.7.9",
-    "verkit": "0.3.2",
-    "@hot-updater/plugin-core": "1.0.0-rc.0",
-    "@hot-updater/bsdiff": "1.0.0-rc.0",
-    "@hot-updater/core": "1.0.0-rc.0"
+    "verkit": "0.4.0",
+    "@hot-updater/core": "1.0.0-rc.0",
+    "@hot-updater/plugin-core": "1.0.0-rc.2",
+    "@hot-updater/bsdiff": "1.0.0-rc.0"
   },
   "peerDependencies": {
     "@prisma/client": "*",
@@ -91,8 +91,8 @@
     "mongodb": "6.20.0",
     "msw": "^2.7.0",
     "uuidv7": "^1.0.2",
-    "@hot-updater/standalone": "1.0.0-rc.0",
-    "@hot-updater/test-utils": "1.0.0-rc.0"
+    "@hot-updater/standalone": "1.0.0-rc.2",
+    "@hot-updater/test-utils": "1.0.0-rc.2"
   },
   "scripts": {
     "build": "tsdown",

package/src/adapters/databasePluginTestDatabase.ts

@@ -84,6 +84,19 @@ export const DATABASE_PLUGIN_TEST_SCHEMA_SQL = `
     sdk_version text,
     received_at_ms integer not null
   );
+  create table bundle_installations (
+    install_id varchar(255) primary key,
+    id text not null,
+    user_id text,
+    username text,
+    to_bundle_id text not null,
+    type text not null,
+    platform text not null,
+    app_version text not null,
+    channel text not null,
+    cohort text not null,
+    received_at_ms integer not null
+  );
   create table api_keys (
     id text primary key,
     hash text not null unique,
@@ -97,6 +110,7 @@ export const DATABASE_PLUGIN_TEST_SCHEMA_SQL = `
 
 export const DATABASE_PLUGIN_TEST_RESET_SQL = `
   delete from bundle_events;
+  delete from bundle_installations;
   delete from api_keys;
   delete from bundle_patches;
   delete from release_catalogs;

package/src/adapters/drizzle.spec.ts

@@ -1,4 +1,5 @@
 import { PGlite } from "@electric-sql/pglite";
+import { toInsightsInstallationRow } from "@hot-updater/plugin-core";
 import {
   boolean,
   doublePrecision,
@@ -11,6 +12,7 @@ import {
 import { drizzle } from "drizzle-orm/pglite";
 import { describe, expect, it, vi } from "vitest";
 
+import { createBundleEventRowFixture } from "../../../test-utils/src/databaseTestFixtures";
 import { setupDatabasePluginTestSuite } from "../../../test-utils/src/setupDatabasePluginTestSuite";
 import type { DatabaseAdapterWithCapabilities } from "../db/types";
 import {
@@ -100,6 +102,19 @@ const bundleEvents = pgTable("bundle_events", {
   sdk_version: text("sdk_version"),
   received_at_ms: integer("received_at_ms").notNull(),
 });
+const bundleInstallations = pgTable("bundle_installations", {
+  install_id: varchar("install_id", { length: 255 }).primaryKey(),
+  id: text("id").notNull(),
+  user_id: text("user_id"),
+  username: text("username"),
+  to_bundle_id: text("to_bundle_id").notNull(),
+  type: text("type").notNull(),
+  platform: text("platform").notNull(),
+  app_version: text("app_version").notNull(),
+  channel: text("channel").notNull(),
+  cohort: text("cohort").notNull(),
+  received_at_ms: integer("received_at_ms").notNull(),
+});
 const apiKeys = pgTable("api_keys", {
   id: text("id").primaryKey(),
   hash: text("hash").notNull().unique(),
@@ -111,6 +126,7 @@ const apiKeys = pgTable("api_keys", {
 });
 const schema = {
   bundle_events: bundleEvents,
+  bundle_installations: bundleInstallations,
   bundle_patches: bundlePatches,
   bundles,
   channels,
@@ -156,6 +172,87 @@ setupDatabasePluginTestSuite({
 });
 
 describe("drizzleAdapter schema requirements", () => {
+  it("keeps Bun SQLite event and snapshot writes inside its synchronous transaction", async () => {
+    const { stdout } = await promisify(execFile)(
+      new URL("../../../../node_modules/.bin/bun", import.meta.url).pathname,
+      [
+        "-e",
+        `
+        import { Database } from "bun:sqlite";
+        import { drizzle } from "drizzle-orm/bun-sqlite";
+        import { toInsightsInstallationRow } from "@hot-updater/plugin-core";
+        import { drizzleAdapter } from "./src/adapters/drizzle.ts";
+        import { createTableSql } from "./src/db/schema/sql.ts";
+        import { createBundleEventRowFixture } from "../test-utils/src/databaseTestFixtures.ts";
+        import * as schema from "../../examples-server/elysia-drizzle-libsql/hot-updater-schema.ts";
+        const db = new Database(":memory:");
+        db.exec(createTableSql("sqlite").join(";"));
+        db.exec("create trigger reject_snapshot before insert on bundle_installations begin select raise(abort, 'injected snapshot failure'); end;");
+        const plugin = drizzleAdapter({ db: drizzle(db, { schema }), provider: "sqlite" });
+        const event = createBundleEventRowFixture("708", 100);
+        const input = { event, installation: toInsightsInstallationRow(event) };
+        let rejected = false;
+        try { await plugin.models.insights.record(input); } catch { rejected = true; }
+        if (!rejected || db.query("select count(*) as total from bundle_events").get().total !== 0) throw new Error("transaction failed to roll back");
+        db.exec("drop trigger reject_snapshot");
+        await plugin.models.insights.record(input);
+        await plugin.models.insights.record(input);
+        if (db.query("select count(*) as total from bundle_events").get().total !== 1 || db.query("select count(*) as total from bundle_installations").get().total !== 1) throw new Error("retry did not commit exactly one report");
+        db.close();
+        console.log("atomic retry verified");
+      `,
+      ],
+      { cwd: new URL("../..", import.meta.url).pathname },
+    );
+    expect(stdout).toContain("atomic retry verified");
+  });
+  it("rolls back the event when the installation write fails and permits retry", async () => {
+    const db = new PGlite();
+    await db.exec(DATABASE_PLUGIN_TEST_SCHEMA_SQL);
+    await db.exec(
+      "alter table bundle_installations add constraint reject_snapshot check (install_id <> 'install-701')",
+    );
+    const plugin = drizzleAdapter({
+      db: drizzle(db, { schema }),
+      provider: "postgresql",
+    });
+    const event = createBundleEventRowFixture("701", 100);
+    const input = { event, installation: toInsightsInstallationRow(event) };
+    try {
+      await expect(plugin.models.insights.record(input)).rejects.toThrow();
+      expect((await db.query("select id from bundle_events")).rows).toEqual([]);
+      await db.exec(
+        "alter table bundle_installations drop constraint reject_snapshot",
+      );
+      await plugin.models.insights.record(input);
+      await expect(
+        plugin.models.insights.findInstallations({
+          installId: event.install_id,
+        }),
+      ).resolves.toEqual([input.installation]);
+    } finally {
+      await db.close();
+    }
+  });
+
+  it("requires transaction support before recording on a lazy database", async () => {
+    const getDB = vi.fn(() => {
+      throw new DrizzleTestStateError();
+    });
+    const plugin = drizzleAdapter({
+      db: getDB,
+      provider: "postgresql",
+      schema,
+    });
+    const event = createBundleEventRowFixture("702", 100);
+    await expect(
+      plugin.models.insights.record({
+        event,
+        installation: toInsightsInstallationRow(event),
+      }),
+    ).rejects.toThrow("transaction support");
+    expect(getDB).not.toHaveBeenCalled();
+  });
   it("does not resolve a lazy database while generating a schema", () => {
     const getDB = vi.fn(() => {
       throw new DrizzleTestStateError();
@@ -235,3 +332,5 @@ describe("drizzleAdapter schema requirements", () => {
     );
   });
 });
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";

package/src/adapters/drizzle.ts

@@ -15,8 +15,9 @@ import type {
   ORMProvider,
   SchemaGenerator,
 } from "../db/types";
-import { createDrizzleCrud } from "./drizzleCrud";
+import { createDrizzleCrud, recordDrizzleInsights } from "./drizzleCrud";
 import { createLazyDB } from "./drizzleLazyDB";
+import { runInsightsTransaction } from "./insightsTransaction";
 
 export type DrizzleProvider = Exclude<
   ORMProvider,
@@ -38,6 +39,18 @@ const createImplementation = (
   const transaction = db.transaction?.bind(db);
   return {
     ...crud,
+    recordInsights: (input) => {
+      if (transaction === undefined) {
+        throw new Error(
+          "Drizzle Insights recording requires transaction support.",
+        );
+      }
+      return runInsightsTransaction(() =>
+        transaction((transactionDatabase) =>
+          recordDrizzleInsights(transactionDatabase, config.provider, input),
+        ),
+      );
+    },
     deleteChannel: (input) => {
       if (transaction === undefined) {
         throw new Error(
@@ -115,9 +128,14 @@ export const drizzleAdapter = (
         list: (input) => getAdapter().models.channels.list(input),
         delete: (input) => getAdapter().models.channels.delete(input),
       },
-      analytics: {
-        append: (row) => getAdapter().models.analytics.append(row),
-        scan: (input) => getAdapter().models.analytics.scan(input),
+      insights: {
+        record: (input) => getAdapter().models.insights.record(input),
+        listEvents: (input) => getAdapter().models.insights.listEvents(input),
+        findInstallations: (input) =>
+          getAdapter().models.insights.findInstallations(input),
+        countInstallations: (input) =>
+          getAdapter().models.insights.countInstallations(input),
+        countEvents: (input) => getAdapter().models.insights.countEvents(input),
       },
       apiKeys: {
         create: (row) => getAdapter().models.apiKeys.create(row),

package/src/adapters/drizzleCrud.ts

@@ -1,9 +1,12 @@
-import { DatabasePluginInputError } from "@hot-updater/plugin-core";
+import {
+  DatabasePluginInputError,
+  type InsightsRecordInput,
+} from "@hot-updater/plugin-core";
 import type {
   DatabasePluginImplementation,
   TransactionDatabasePluginImplementation,
 } from "@hot-updater/plugin-core/internal";
-import { asc, desc, eq, sql, type SQLWrapper } from "drizzle-orm";
+import { and, asc, desc, eq, lt, or, sql, type SQLWrapper } from "drizzle-orm";
 
 import {
   isChannelDeleteReferencedError,
@@ -78,9 +81,98 @@ const executeInsert = async (
   await ignored.execute();
 };
 
+export const recordDrizzleInsights = (
+  db: DrizzleDB,
+  provider: DrizzleProvider,
+  input: InsightsRecordInput,
+): void | Promise<void> => {
+  if (db.resultKind !== "sync")
+    return recordAsyncDrizzleInsights(db, provider, input);
+  const events = getDrizzleTable(db, "bundle_events");
+  const installations = getDrizzleTable(db, "bundle_installations");
+  const eventInsert = db
+    .insert(events)
+    .values(input.event)
+    .onConflictDoNothing?.()
+    .returning?.({ id: getDrizzleColumn(events, "id") });
+  const installationInsert = db
+    .insert(installations)
+    .values(input.installation)
+    .onConflictDoNothing?.();
+  const installationUpdate = db
+    .update(installations)
+    .set(input.installation)
+    .where(newerInstallationWhere(installations, input.installation));
+  if (
+    eventInsert?.all === undefined ||
+    installationInsert?.run === undefined ||
+    installationUpdate.run === undefined
+  )
+    throw new DrizzleAdapterInvariantError();
+  if (eventInsert.all().length === 0) return;
+  installationInsert.run();
+  installationUpdate.run();
+};
+
+const newerInstallationWhere = (
+  installations: DrizzleTable,
+  installation: InsightsRecordInput["installation"],
+) => {
+  const receivedAt = getDrizzleColumn(installations, "received_at_ms");
+  return and(
+    eq(getDrizzleColumn(installations, "install_id"), installation.install_id),
+    or(
+      lt(receivedAt, installation.received_at_ms),
+      and(
+        eq(receivedAt, installation.received_at_ms),
+        lt(getDrizzleColumn(installations, "id"), installation.id),
+      ),
+    ),
+  );
+};
+
+const recordAsyncDrizzleInsights = async (
+  db: DrizzleDB,
+  provider: DrizzleProvider,
+  { event, installation }: InsightsRecordInput,
+): Promise<void> => {
+  const events = getDrizzleTable(db, "bundle_events");
+  const installations = getDrizzleTable(db, "bundle_installations");
+  if (provider === "mysql") {
+    const existing = await db.query.bundle_events.findFirst({
+      where: eq(getDrizzleColumn(events, "id"), event.id),
+    });
+    if (existing !== undefined) return;
+    await db.insert(events).values(event).execute();
+    const insertInstallation = db
+      .insert(installations)
+      .values(installation)
+      .onDuplicateKeyUpdate?.({ set: { install_id: installation.install_id } });
+    if (insertInstallation === undefined)
+      throw new DrizzleAdapterInvariantError();
+    await insertInstallation.execute();
+  } else {
+    const insert = db.insert(events).values(event).onConflictDoNothing?.();
+    const returning = insert?.returning?.({
+      id: getDrizzleColumn(events, "id"),
+    });
+    if (returning === undefined) throw new DrizzleAdapterInvariantError();
+    const rows = await returning.execute();
+    if (!Array.isArray(rows)) throw new DrizzleAdapterInvariantError();
+    if (rows.length === 0) return;
+    await executeInsert(db, provider, installations, installation, "ignore");
+  }
+  await db
+    .update(installations)
+    .set(installation)
+    .where(newerInstallationWhere(installations, installation))
+    .execute();
+};
+
 const toOrderBy = (
   table: DrizzleTable,
   input: {
+    model?: string;
     orderBy?: readonly {
       field: string;
       direction: "asc" | "desc";
@@ -91,6 +183,12 @@ const toOrderBy = (
   const clauses = input.orderBy;
   return clauses?.flatMap((clause) => {
     const column = getDrizzleColumn(table, clause.field);
+    if (
+      input.model === "bundle_events" ||
+      input.model === "bundle_installations"
+    ) {
+      return [clause.direction === "asc" ? asc(column) : desc(column)];
+    }
     const nulls =
       clause.nulls ?? (clause.direction === "asc" ? "last" : "first");
     return [
@@ -110,6 +208,7 @@ export const createDrizzleCrud = (
   const bundles = getDrizzleTable(db, "bundles");
   const patches = getDrizzleTable(db, "bundle_patches");
   const events = getDrizzleTable(db, "bundle_events");
+  const installations = getDrizzleTable(db, "bundle_installations");
   const releases = getDrizzleTable(db, "releases");
   const releaseCatalogs = getDrizzleTable(db, "release_catalogs");
   const channels = getDrizzleTable(db, "channels");
@@ -169,6 +268,15 @@ export const createDrizzleCrud = (
         case "bundle_events":
           await executeInsert(db, provider, events, input.data, undefined);
           return input.data;
+        case "bundle_installations":
+          await executeInsert(
+            db,
+            provider,
+            installations,
+            input.data,
+            input.onConflict,
+          );
+          return input.data;
         case "releases":
           await executeInsert(
             db,
@@ -208,6 +316,27 @@ export const createDrizzleCrud = (
       }
     },
     async update(input) {
+      if (input.model === "bundle_installations") {
+        const installId = input.where.find(
+          (item) =>
+            item.field === "install_id" &&
+            (item.operator === undefined || item.operator === "eq") &&
+            typeof item.value === "string",
+        )?.value;
+        if (typeof installId !== "string") {
+          throw new DrizzleAdapterInvariantError();
+        }
+        const where = buildDrizzleWhere(provider, installations, input.where);
+        if (where === undefined) throw new DrizzleAdapterInvariantError();
+        await db.update(installations).set(input.update).where(where).execute();
+        const row = await db.query.bundle_installations.findFirst({
+          where: eq(getDrizzleColumn(installations, "install_id"), installId),
+        });
+        return row?.id === input.update.id &&
+          row.received_at_ms === input.update.received_at_ms
+          ? row
+          : null;
+      }
       const selector = input.where[0];
       if (selector === undefined || typeof selector.value !== "string") {
         throw new DrizzleAdapterInvariantError();
@@ -296,6 +425,11 @@ export const createDrizzleCrud = (
         throw new DatabasePluginInputError("invalid-operation");
       }
       switch (input.model) {
+        case "bundle_events":
+          return db.$count(
+            events,
+            buildDrizzleWhere(provider, events, input.where),
+          );
         case "bundles":
           return db.$count(
             bundles,
@@ -311,6 +445,11 @@ export const createDrizzleCrud = (
             releases,
             buildDrizzleWhere(provider, releases, input.where),
           );
+        case "bundle_installations":
+          return db.$count(
+            installations,
+            buildDrizzleWhere(provider, installations, input.where),
+          );
       }
     },
     async findOne(input) {
@@ -351,6 +490,12 @@ export const createDrizzleCrud = (
           });
           return row === undefined ? null : fromStoredReleaseCatalogRow(row);
         }
+        case "bundle_installations":
+          return (
+            (await db.query.bundle_installations.findFirst({
+              where: buildDrizzleWhere(provider, installations, input.where),
+            })) ?? null
+          );
       }
     },
     async findMany(input) {
@@ -374,6 +519,13 @@ export const createDrizzleCrud = (
             limit: input.limit,
             offset: input.offset,
           });
+        case "bundle_installations":
+          return db.query.bundle_installations.findMany({
+            where: buildDrizzleWhere(provider, installations, input.where),
+            orderBy: toOrderBy(installations, input),
+            limit: input.limit,
+            offset: input.offset,
+          });
         case "api_keys":
           return db.query.api_keys.findMany({
             where: buildDrizzleWhere(provider, apiKeys, input.where),