@fedify/fedify 2.4.0-dev.1488 → 2.4.0-dev.1504

package/dist/federation/tasks/tasks.test.d.mts

@@ -0,0 +1,2 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { URLPattern } from "urlpattern-polyfill";

package/dist/federation/tasks/tasks.test.mjs

@@ -0,0 +1,555 @@
+import { Temporal } from "@js-temporal/polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+import { a as numberSchema, i as makeSchema, n as baseOptions, o as stringSchema, t as MockQueue } from "../../testing-Dy-WhqpN.mjs";
+import { o as createFederation } from "../../middleware-iP9VRMus.mjs";
+import { r as createFederationBuilder } from "../../builder-Ck0Fl_a5.mjs";
+import { t as TaskCodec } from "../../codec-CmlPqjNX.mjs";
+import { t as InProcessMessageQueue } from "../../mq-03vS-C9P.mjs";
+import { Note } from "@fedify/vocab";
+import { delay } from "es-toolkit";
+import { mockDocumentLoader, test } from "@fedify/fixture";
+import { deepStrictEqual, ok, rejects, strictEqual, throws } from "node:assert/strict";
+//#region src/federation/tasks/tasks.test.ts
+const envelopeSchema = makeSchema((data) => typeof data === "object" && data != null && data.note instanceof Note && typeof data.title === "string");
+const makeTaskMessage = async (taskName, data, overrides = {}) => ({
+	type: "task",
+	id: crypto.randomUUID(),
+	baseUrl: "https://example.com/",
+	taskName,
+	data: await new TaskCodec({ contextLoader: mockDocumentLoader }).serialize(data),
+	started: Temporal.Now.instant().toString(),
+	attempt: 0,
+	traceContext: {},
+	...overrides
+});
+async function waitFor(predicate, timeoutMs) {
+	const started = Date.now();
+	while (!predicate()) {
+		await delay(50);
+		if (Date.now() - started > timeoutMs) throw new Error("Timeout");
+	}
+}
+test("defineTask()", async (t) => {
+	await t.step("returns a handle carrying name and schema", () => {
+		const task = createFederation({
+			...baseOptions,
+			queue: { task: new MockQueue() }
+		}).defineTask("greet", {
+			schema: stringSchema,
+			handler: () => {}
+		});
+		strictEqual(task.name, "greet");
+		strictEqual(task.schema, stringSchema);
+	});
+	await t.step("throws on a duplicate name", () => {
+		const federation = createFederation({
+			...baseOptions,
+			queue: { task: new MockQueue() }
+		});
+		federation.defineTask("dup", {
+			schema: stringSchema,
+			handler: () => {}
+		});
+		throws(() => federation.defineTask("dup", {
+			schema: stringSchema,
+			handler: () => {}
+		}), {
+			name: "TypeError",
+			message: /already defined/
+		});
+	});
+	await t.step("accepts names that collide with Object.prototype", () => {
+		const federation = createFederation({
+			...baseOptions,
+			queue: { task: new MockQueue() }
+		});
+		for (const name of [
+			"constructor",
+			"toString",
+			"hasOwnProperty"
+		]) {
+			strictEqual(federation.defineTask(name, {
+				schema: stringSchema,
+				handler: () => {}
+			}).name, name);
+			strictEqual(federation.taskDefinitions.get(name)?.name, name);
+		}
+		throws(() => federation.defineTask("toString", {
+			schema: stringSchema,
+			handler: () => {}
+		}), {
+			name: "TypeError",
+			message: /already defined/
+		});
+	});
+	await t.step("build() clones the task registry", async () => {
+		const builder = createFederationBuilder();
+		builder.defineTask("first", {
+			schema: stringSchema,
+			handler: () => {}
+		});
+		const f1 = await builder.build({
+			...baseOptions,
+			queue: { task: new MockQueue() }
+		});
+		builder.defineTask("second", {
+			schema: stringSchema,
+			handler: () => {}
+		});
+		const f2 = await builder.build({
+			...baseOptions,
+			queue: { task: new MockQueue() }
+		});
+		deepStrictEqual([...f1.taskDefinitions.keys()], ["first"]);
+		deepStrictEqual([...f2.taskDefinitions.keys()], ["first", "second"]);
+		f1.defineTask("third", {
+			schema: stringSchema,
+			handler: () => {}
+		});
+		deepStrictEqual([...f2.taskDefinitions.keys()], ["first", "second"]);
+	});
+});
+test("task type-level guards", () => {});
+test("Context.enqueueTask() end-to-end", async (t) => {
+	await t.step("round-trips a typed payload to the handler", async () => {
+		const queue = new InProcessMessageQueue();
+		const federation = createFederation({
+			...baseOptions,
+			queue: { task: queue }
+		});
+		const received = [];
+		const task = federation.defineTask("notify", {
+			schema: envelopeSchema,
+			handler: (ctx, data) => {
+				received.push({
+					ctx,
+					data
+				});
+			}
+		});
+		await federation.createContext(new URL("https://example.com/"), void 0).enqueueTask(task, {
+			note: new Note({ content: "Hello, world!" }),
+			title: "greeting"
+		});
+		const controller = new AbortController();
+		const listening = federation.startQueue(void 0, {
+			signal: controller.signal,
+			queue: "task"
+		});
+		try {
+			await waitFor(() => received.length > 0, 15e3);
+		} finally {
+			controller.abort();
+			await listening;
+		}
+		strictEqual(received.length, 1);
+		const { ctx: handlerCtx, data } = received[0];
+		ok(data.note instanceof Note);
+		strictEqual(data.note.content?.toString(), "Hello, world!");
+		strictEqual(data.title, "greeting");
+		strictEqual(handlerCtx.origin, "https://example.com");
+	});
+});
+test("task queue routing", async (t) => {
+	await t.step("prefers the per-task queue", async () => {
+		const taskQueue = new MockQueue();
+		const perTaskQueue = new MockQueue();
+		const federation = createFederation({
+			...baseOptions,
+			queue: { task: taskQueue }
+		});
+		const task = federation.defineTask("isolated", {
+			schema: stringSchema,
+			handler: () => {},
+			queue: perTaskQueue
+		});
+		await federation.createContext(new URL("https://example.com/"), void 0).enqueueTask(task, "data");
+		strictEqual(perTaskQueue.enqueued.length, 1);
+		strictEqual(taskQueue.enqueued.length, 0);
+	});
+	await t.step("falls back to the outbox queue by default", async () => {
+		const outboxQueue = new MockQueue();
+		const federation = createFederation({
+			...baseOptions,
+			queue: { outbox: outboxQueue }
+		});
+		const task = federation.defineTask("fallback", {
+			schema: stringSchema,
+			handler: () => {}
+		});
+		await federation.createContext(new URL("https://example.com/"), void 0).enqueueTask(task, "data");
+		strictEqual(outboxQueue.enqueued.length, 1);
+	});
+	await t.step("taskQueueResolution: \"strict\" throws at enqueue instead", async () => {
+		const outboxQueue = new MockQueue();
+		const federation = createFederation({
+			...baseOptions,
+			queue: { outbox: outboxQueue },
+			taskQueueResolution: "strict"
+		});
+		const task = federation.defineTask("strict", {
+			schema: stringSchema,
+			handler: () => {}
+		});
+		const ctx = federation.createContext(new URL("https://example.com/"), void 0);
+		await rejects(() => ctx.enqueueTask(task, "data"), {
+			name: "TypeError",
+			message: /No message queue is configured/
+		});
+		strictEqual(outboxQueue.enqueued.length, 0);
+	});
+	await t.step("throws when no queue is configured at all", async () => {
+		const federation = createFederation({ ...baseOptions });
+		const task = federation.defineTask("queueless", {
+			schema: stringSchema,
+			handler: () => {}
+		});
+		const ctx = federation.createContext(new URL("https://example.com/"), void 0);
+		await rejects(() => ctx.enqueueTask(task, "data"), {
+			name: "TypeError",
+			message: /No message queue is configured/
+		});
+	});
+});
+test("startQueue() task worker", async (t) => {
+	await t.step("starts only the task worker for queue: \"task\"", async () => {
+		const inbox = new MockQueue();
+		const outbox = new MockQueue();
+		const fanout = new MockQueue();
+		const taskQueue = new MockQueue();
+		const federation = createFederation({
+			...baseOptions,
+			queue: {
+				inbox,
+				outbox,
+				fanout,
+				task: taskQueue
+			}
+		});
+		const controller = new AbortController();
+		const listening = federation.startQueue(void 0, {
+			signal: controller.signal,
+			queue: "task"
+		});
+		strictEqual(taskQueue.listenCount, 1);
+		strictEqual(inbox.listenCount, 0);
+		strictEqual(outbox.listenCount, 0);
+		strictEqual(fanout.listenCount, 0);
+		controller.abort();
+		await listening;
+	});
+	await t.step("starts the worker for a task-only deployment", async () => {
+		const taskQueue = new MockQueue();
+		const federation = createFederation({
+			...baseOptions,
+			queue: { task: taskQueue }
+		});
+		const controller = new AbortController();
+		const listening = federation.startQueue(void 0, { signal: controller.signal });
+		strictEqual(taskQueue.listenCount, 1);
+		controller.abort();
+		await listening;
+	});
+	await t.step("does not double-listen on a shared queue", async () => {
+		const shared = new MockQueue();
+		const federation = createFederation({
+			...baseOptions,
+			queue: {
+				outbox: shared,
+				task: shared
+			}
+		});
+		const controller = new AbortController();
+		const listening = federation.startQueue(void 0, { signal: controller.signal });
+		strictEqual(shared.listenCount, 1);
+		controller.abort();
+		await listening;
+	});
+	await t.step("starts a worker for a dedicated per-task queue", async () => {
+		const taskQueue = new MockQueue();
+		const dedicated = new MockQueue();
+		const federation = createFederation({
+			...baseOptions,
+			queue: { task: taskQueue }
+		});
+		federation.defineTask("dedicated", {
+			schema: stringSchema,
+			handler: () => {},
+			queue: dedicated
+		});
+		const controller = new AbortController();
+		const listening = federation.startQueue(void 0, { signal: controller.signal });
+		strictEqual(taskQueue.listenCount, 1);
+		strictEqual(dedicated.listenCount, 1);
+		controller.abort();
+		await listening;
+	});
+	await t.step("starts a per-task queue even without a federation queue", async () => {
+		const dedicated = new MockQueue();
+		const federation = createFederation({ ...baseOptions });
+		federation.defineTask("dedicated", {
+			schema: stringSchema,
+			handler: () => {},
+			queue: dedicated
+		});
+		const controller = new AbortController();
+		const listening = federation.startQueue(void 0, { signal: controller.signal });
+		strictEqual(dedicated.listenCount, 1);
+		controller.abort();
+		await listening;
+	});
+	await t.step("does not listen twice on a per-task queue shared with a standard queue", async () => {
+		const shared = new MockQueue();
+		const federation = createFederation({
+			...baseOptions,
+			queue: { task: shared }
+		});
+		federation.defineTask("reuses-task-queue", {
+			schema: stringSchema,
+			handler: () => {},
+			queue: shared
+		});
+		const controller = new AbortController();
+		const listening = federation.startQueue(void 0, { signal: controller.signal });
+		strictEqual(shared.listenCount, 1);
+		controller.abort();
+		await listening;
+	});
+	await t.step("routes an enqueued task on a dedicated queue to its handler", async () => {
+		const dedicated = new MockQueue();
+		const federation = createFederation({ ...baseOptions });
+		let received;
+		const task = federation.defineTask("dedicated-end-to-end", {
+			schema: stringSchema,
+			handler: (_ctx, data) => {
+				received = data;
+			},
+			queue: dedicated
+		});
+		await federation.createContext(new URL("https://example.com/"), void 0).enqueueTask(task, "payload");
+		strictEqual(dedicated.enqueued.length, 1);
+		await federation.processQueuedTask(void 0, dedicated.enqueued[0].message);
+		strictEqual(received, "payload");
+	});
+	await t.step("queue: \"task\" starts the outbox fallback when no task queue is set", async () => {
+		const inbox = new MockQueue();
+		const outbox = new MockQueue();
+		const fanout = new MockQueue();
+		const federation = createFederation({
+			...baseOptions,
+			queue: {
+				inbox,
+				outbox,
+				fanout
+			}
+		});
+		federation.defineTask("fallback", {
+			schema: stringSchema,
+			handler: () => {}
+		});
+		const controller = new AbortController();
+		const listening = federation.startQueue(void 0, {
+			signal: controller.signal,
+			queue: "task"
+		});
+		strictEqual(outbox.listenCount, 1);
+		strictEqual(inbox.listenCount, 0);
+		strictEqual(fanout.listenCount, 0);
+		controller.abort();
+		await listening;
+	});
+	await t.step("queue: \"task\" starts a task queue shared with the outbox once", async () => {
+		const inbox = new MockQueue();
+		const shared = new MockQueue();
+		const fanout = new MockQueue();
+		const federation = createFederation({
+			...baseOptions,
+			queue: {
+				inbox,
+				outbox: shared,
+				fanout,
+				task: shared
+			}
+		});
+		const controller = new AbortController();
+		const listening = federation.startQueue(void 0, {
+			signal: controller.signal,
+			queue: "task"
+		});
+		strictEqual(shared.listenCount, 1);
+		strictEqual(inbox.listenCount, 0);
+		strictEqual(fanout.listenCount, 0);
+		controller.abort();
+		await listening;
+	});
+});
+test("MockQueue.listen() resolves on a pre-aborted signal", async () => {
+	const queue = new MockQueue();
+	const controller = new AbortController();
+	controller.abort();
+	let timer;
+	const settled = await Promise.race([queue.listen(() => {}, { signal: controller.signal }).then(() => "resolved"), new Promise((resolve) => {
+		timer = setTimeout(() => resolve("pending"), 50);
+	})]);
+	clearTimeout(timer);
+	strictEqual(settled, "resolved");
+});
+test("processQueuedTask() task dispatch", async (t) => {
+	await t.step("drops an unknown task with a warning", async () => {
+		const queue = new MockQueue();
+		const federation = createFederation({
+			...baseOptions,
+			queue: { task: queue }
+		});
+		const message = await makeTaskMessage("never-defined", "data");
+		await federation.processQueuedTask(void 0, message);
+		strictEqual(queue.enqueued.length, 0);
+	});
+	await t.step("drops an undecodable payload without retry", async () => {
+		const queue = new MockQueue();
+		const federation = createFederation({
+			...baseOptions,
+			queue: { task: queue }
+		});
+		let called = 0;
+		federation.defineTask("broken-wire", {
+			schema: stringSchema,
+			handler: () => {
+				called++;
+			}
+		});
+		const message = await makeTaskMessage("broken-wire", "data");
+		await federation.processQueuedTask(void 0, {
+			...message,
+			data: "garbage that is not devalue"
+		});
+		strictEqual(called, 0);
+		strictEqual(queue.enqueued.length, 0);
+	});
+	await t.step("drops a drifted payload without retry", async () => {
+		const queue = new MockQueue();
+		const federation = createFederation({
+			...baseOptions,
+			queue: { task: queue }
+		});
+		let called = 0;
+		federation.defineTask("drifted", {
+			schema: numberSchema,
+			handler: () => {
+				called++;
+			}
+		});
+		const message = await makeTaskMessage("drifted", "stringly-typed");
+		await federation.processQueuedTask(void 0, message);
+		strictEqual(called, 0);
+		strictEqual(queue.enqueued.length, 0);
+	});
+	await t.step("re-enqueues with attempt + 1 when the handler throws", async () => {
+		const queue = new MockQueue();
+		const federation = createFederation({
+			...baseOptions,
+			queue: { task: queue }
+		});
+		const errors = [];
+		federation.defineTask("flaky", {
+			schema: stringSchema,
+			handler: () => {
+				throw new Error("boom");
+			},
+			retryPolicy: () => Temporal.Duration.from({ milliseconds: 1 }),
+			onError: (_ctx, error, data) => {
+				errors.push([error, data]);
+			}
+		});
+		const message = await makeTaskMessage("flaky", "data", { orderingKey: "k" });
+		await federation.processQueuedTask(void 0, message);
+		strictEqual(queue.enqueued.length, 1);
+		const retry = queue.enqueued[0];
+		strictEqual(retry.message.attempt, 1);
+		strictEqual(retry.message.taskName, "flaky");
+		strictEqual(retry.message.orderingKey, "k");
+		strictEqual(retry.options?.orderingKey, "k");
+		ok(retry.options?.delay instanceof Temporal.Duration);
+		strictEqual(errors.length, 1);
+		deepStrictEqual(errors[0], [/* @__PURE__ */ new Error("boom"), "data"]);
+	});
+	await t.step("gives up when the retry policy returns null", async () => {
+		const queue = new MockQueue();
+		const federation = createFederation({
+			...baseOptions,
+			queue: { task: queue }
+		});
+		federation.defineTask("hopeless", {
+			schema: stringSchema,
+			handler: () => {
+				throw new Error("boom");
+			},
+			retryPolicy: () => null
+		});
+		const message = await makeTaskMessage("hopeless", "data");
+		await federation.processQueuedTask(void 0, message);
+		strictEqual(queue.enqueued.length, 0);
+	});
+	await t.step("per-task retryPolicy overrides the federation default", async () => {
+		const queue = new MockQueue();
+		const federation = createFederation({
+			...baseOptions,
+			queue: { task: queue },
+			taskRetryPolicy: () => null
+		});
+		federation.defineTask("override", {
+			schema: stringSchema,
+			handler: () => {
+				throw new Error("boom");
+			},
+			retryPolicy: () => Temporal.Duration.from({ milliseconds: 1 })
+		});
+		federation.defineTask("default", {
+			schema: stringSchema,
+			handler: () => {
+				throw new Error("boom");
+			}
+		});
+		await federation.processQueuedTask(void 0, await makeTaskMessage("override", "data"));
+		strictEqual(queue.enqueued.length, 1);
+		await federation.processQueuedTask(void 0, await makeTaskMessage("default", "data"));
+		strictEqual(queue.enqueued.length, 1);
+	});
+	await t.step("still retries when message.started is malformed", async () => {
+		const queue = new MockQueue();
+		const federation = createFederation({
+			...baseOptions,
+			queue: { task: queue }
+		});
+		federation.defineTask("bad-started", {
+			schema: stringSchema,
+			handler: () => {
+				throw new Error("boom");
+			},
+			retryPolicy: () => Temporal.Duration.from({ milliseconds: 1 })
+		});
+		const message = await makeTaskMessage("bad-started", "data", { started: "not-an-instant" });
+		await federation.processQueuedTask(void 0, message);
+		strictEqual(queue.enqueued.length, 1);
+		strictEqual(queue.enqueued[0].message.attempt, 1);
+	});
+	await t.step("rethrows on a nativeRetrial queue", async () => {
+		const queue = new MockQueue({ nativeRetrial: true });
+		const federation = createFederation({
+			...baseOptions,
+			queue: { task: queue }
+		});
+		federation.defineTask("native", {
+			schema: stringSchema,
+			handler: () => {
+				throw new Error("boom");
+			}
+		});
+		const message = await makeTaskMessage("native", "data");
+		await rejects(() => federation.processQueuedTask(void 0, message), { message: /boom/ });
+		strictEqual(queue.enqueued.length, 0);
+	});
+});
+//#endregion
+export {};

package/dist/federation/temporal.test.mjs

@@ -1,10 +1,10 @@
 import "@js-temporal/polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import "../std__assert-BBjXFNOb.mjs";
-import { r as assertFalse } from "../assert_rejects-DN60FHPX.mjs";
-import { t as assert } from "../assert-OguE97r2.mjs";
-import { t as hasMalformedKnownTemporalLiteral } from "../temporal-C8M0Y7v9.mjs";
+import "../std__assert-Dh6uLf_q.mjs";
+import { r as assertFalse } from "../assert_rejects-DAdaaIWM.mjs";
+import { t as assert } from "../assert-DvVHoIZ0.mjs";
+import { t as hasMalformedKnownTemporalLiteral } from "../temporal-CyOjsqPj.mjs";
 import { test } from "@fedify/fixture";
 //#region src/federation/temporal.test.ts
 test("hasMalformedKnownTemporalLiteral() detects expanded proof timestamps", async () => {

package/dist/federation/webfinger.test.mjs

@@ -1,12 +1,12 @@
 import { Temporal } from "@js-temporal/polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { r as createRequestContext } from "../context-DVoTs_wM.mjs";
-import { t as assertEquals } from "../assert_equals-C-ZRDbaf.mjs";
-import "../std__assert-BBjXFNOb.mjs";
-import { t as assertNotEquals } from "../assert_not_equals-DkVK8oqV.mjs";
-import { t as MemoryKvStore } from "../kv-rV3vodCc.mjs";
-import { o as createFederation, s as handleWebFinger } from "../middleware-D3kuDjvb.mjs";
+import { r as createRequestContext } from "../context-BBRTgkrs.mjs";
+import { t as MemoryKvStore } from "../kv-CIvR3Non.mjs";
+import { t as assertEquals } from "../assert_equals-PBVKNMJd.mjs";
+import "../std__assert-Dh6uLf_q.mjs";
+import { t as assertNotEquals } from "../assert_not_equals-C8vcTTA3.mjs";
+import { o as createFederation, s as handleWebFinger } from "../middleware-iP9VRMus.mjs";
 import { Image, Link, Person, Tombstone } from "@fedify/vocab";
 import { createTestMeterProvider, test } from "@fedify/fixture";
 //#region src/federation/webfinger.test.ts

package/dist/{http-RriziGDE.mjs → http-BNFQkiEZ.mjs}

@@ -1,10 +1,10 @@
 import { Temporal } from "@js-temporal/polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { n as version, t as name } from "./deno-BCFGf8NR.mjs";
-import { n as getDurationMs, r as getFederationMetrics, s as measureSignatureKeyFetch } from "./metrics-BLoa2pab.mjs";
-import { i as validateAcceptSignature, n as fulfillAcceptSignature, r as parseAcceptSignature } from "./accept-CPkZzmGN.mjs";
-import { o as validateCryptoKey, r as fetchKeyDetailed } from "./key-Bkg8Zg36.mjs";
+import { n as version, t as name } from "./deno-D3gb4X9v.mjs";
+import { n as getDurationMs, r as getFederationMetrics, s as measureSignatureKeyFetch } from "./metrics-BXR36qzu.mjs";
+import { i as validateAcceptSignature, n as fulfillAcceptSignature, r as parseAcceptSignature } from "./accept-CgDcxvjV.mjs";
+import { o as validateCryptoKey, r as fetchKeyDetailed } from "./key-BM_SRwBV.mjs";
 import { getLogger } from "@logtape/logtape";
 import { CryptographicKey } from "@fedify/vocab";
 import { SpanStatusCode, trace } from "@opentelemetry/api";

package/dist/{http-DaVoLyyA.js → http-CrZzUAtV.js}

@@ -10,7 +10,7 @@ import { ATTR_HTTP_REQUEST_HEADER, ATTR_HTTP_REQUEST_METHOD, ATTR_URL_FULL } fro
 import { decodeBase64, encodeBase64 } from "byte-encodings/base64";
 //#region deno.json
 var name = "@fedify/fedify";
-var version = "2.4.0-dev.1488+a9fe1094";
+var version = "2.4.0-dev.1504+756217cc";
 //#endregion
 //#region src/sig/accept.ts
 /**
@@ -1200,31 +1200,21 @@ async function resolveFetchedKey(document, cacheKey, keyId, cls, { documentLoade
 		const keys = cls === CryptographicKey ? object.getPublicKeys({
 			documentLoader,
 			contextLoader,
-			suppressError: true,
 			tracerProvider
 		}) : object.getAssertionMethods({
 			documentLoader,
 			contextLoader,
-			suppressError: true,
 			tracerProvider
 		});
 		let length = 0;
 		let lastKey = null;
-		try {
-			for await (const k of keys) {
-				length++;
-				lastKey = k;
-				if (k.id?.href === keyId) {
-					key = k;
-					break;
-				}
+		for await (const k of keys) {
+			length++;
+			lastKey = k;
+			if (k.id?.href === keyId) {
+				key = k;
+				break;
 			}
-		} catch (e) {
-			if (!(e instanceof TypeError)) throw e;
-			logger.debug("Failed to verify; a malformed key was encountered while iterating the keys of {keyId}; treating it as a missing key: {error}", {
-				keyId,
-				error: e
-			});
 		}
 		const keyIdUrl = new URL(keyId);
 		if (key == null && keyIdUrl.hash === "" && length === 1) key = lastKey;