@fedify/vocab-runtime 2.0.35 → 2.0.36-dev.2551

package/deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/vocab-runtime",
-  "version": "2.0.35",
+  "version": "2.0.36-dev.2551+8b012df4",
   "license": "MIT",
   "exports": {
     ".": "./src/mod.ts",

package/dist/mod.cjs

@@ -4502,7 +4502,7 @@ const preloadedContexts = {
 //#endregion
 //#region deno.json
 var name = "@fedify/vocab-runtime";
-var version = "2.0.35";
+var version = "2.0.36-dev.2551+8b012df4";
 //#endregion
 //#region src/request.ts
 /**

package/dist/mod.js

@@ -4498,7 +4498,7 @@ const preloadedContexts = {
 //#endregion
 //#region deno.json
 var name = "@fedify/vocab-runtime";
-var version = "2.0.35";
+var version = "2.0.36-dev.2551+8b012df4";
 //#endregion
 //#region src/request.ts
 /**

package/dist/temporal.cjs

@@ -2,7 +2,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 //#region src/temporal.ts
 /**
-* Type guards for `Temporal` namespace objects.
+* Type guards for `Temporal` namespace objects and normalization of
+* `xsd:dateTime` literals.
 *
 * Fedify accepts both runtime polyfills (e.g. `@js-temporal/polyfill`,
 * `temporal-polyfill`) and the host's native `Temporal` implementation
@@ -55,6 +56,23 @@ function isTemporalInstant(value) {
 function isTemporalDuration(value) {
 	return typeof value === "object" && value !== null && Object.prototype.toString.call(value) === "[object Temporal.Duration]" && "sign" in value && (value.sign === -1 || value.sign === 0 || value.sign === 1) && "toString" in value && typeof value.toString === "function" && value.toString !== Object.prototype.toString;
 }
+/**
+* Normalizes an `xsd:dateTime` literal into a form that
+* `Temporal.Instant.from()` accepts.  A literal without a UTC offset is
+* treated as UTC, and seconds omitted before a fraction, which Activity Streams
+* 2.0 allows, are filled in.
+*
+* @param value The date-time literal to normalize.
+* @returns The normalized literal.
+*/
+function normalizeDateTimeLiteral(value) {
+	const timeStart = value.search(/[Tt ]/) + 1;
+	if (timeStart < 1) return value;
+	const date = value.substring(0, timeStart);
+	const time = value.substring(timeStart).replace(/^(\d{2}:\d{2})(?=\.)/, "$1:00");
+	return date + (/[Zz+-]/.test(time) ? time : time + "Z");
+}
 //#endregion
 exports.isTemporalDuration = isTemporalDuration;
 exports.isTemporalInstant = isTemporalInstant;
+exports.normalizeDateTimeLiteral = normalizeDateTimeLiteral;

package/dist/temporal.d.cts

@@ -1,7 +1,8 @@
 /// <reference lib="esnext.temporal" />
 //#region src/temporal.d.ts
 /**
-* Type guards for `Temporal` namespace objects.
+* Type guards for `Temporal` namespace objects and normalization of
+* `xsd:dateTime` literals.
 *
 * Fedify accepts both runtime polyfills (e.g. `@js-temporal/polyfill`,
 * `temporal-polyfill`) and the host's native `Temporal` implementation
@@ -50,5 +51,15 @@ declare function isTemporalInstant(value: unknown): value is Temporal.Instant;
 *          and overrides `toString`; `false` otherwise.
 */
 declare function isTemporalDuration(value: unknown): value is Temporal.Duration;
+/**
+* Normalizes an `xsd:dateTime` literal into a form that
+* `Temporal.Instant.from()` accepts.  A literal without a UTC offset is
+* treated as UTC, and seconds omitted before a fraction, which Activity Streams
+* 2.0 allows, are filled in.
+*
+* @param value The date-time literal to normalize.
+* @returns The normalized literal.
+*/
+declare function normalizeDateTimeLiteral(value: string): string;
 //#endregion
-export { isTemporalDuration, isTemporalInstant };
+export { isTemporalDuration, isTemporalInstant, normalizeDateTimeLiteral };

package/dist/temporal.d.ts

@@ -1,7 +1,8 @@
 /// <reference lib="esnext.temporal" />
 //#region src/temporal.d.ts
 /**
-* Type guards for `Temporal` namespace objects.
+* Type guards for `Temporal` namespace objects and normalization of
+* `xsd:dateTime` literals.
 *
 * Fedify accepts both runtime polyfills (e.g. `@js-temporal/polyfill`,
 * `temporal-polyfill`) and the host's native `Temporal` implementation
@@ -50,5 +51,15 @@ declare function isTemporalInstant(value: unknown): value is Temporal.Instant;
 *          and overrides `toString`; `false` otherwise.
 */
 declare function isTemporalDuration(value: unknown): value is Temporal.Duration;
+/**
+* Normalizes an `xsd:dateTime` literal into a form that
+* `Temporal.Instant.from()` accepts.  A literal without a UTC offset is
+* treated as UTC, and seconds omitted before a fraction, which Activity Streams
+* 2.0 allows, are filled in.
+*
+* @param value The date-time literal to normalize.
+* @returns The normalized literal.
+*/
+declare function normalizeDateTimeLiteral(value: string): string;
 //#endregion
-export { isTemporalDuration, isTemporalInstant };
+export { isTemporalDuration, isTemporalInstant, normalizeDateTimeLiteral };

package/dist/temporal.js

@@ -1,7 +1,8 @@
 
 //#region src/temporal.ts
 /**
-* Type guards for `Temporal` namespace objects.
+* Type guards for `Temporal` namespace objects and normalization of
+* `xsd:dateTime` literals.
 *
 * Fedify accepts both runtime polyfills (e.g. `@js-temporal/polyfill`,
 * `temporal-polyfill`) and the host's native `Temporal` implementation
@@ -54,5 +55,21 @@ function isTemporalInstant(value) {
 function isTemporalDuration(value) {
 	return typeof value === "object" && value !== null && Object.prototype.toString.call(value) === "[object Temporal.Duration]" && "sign" in value && (value.sign === -1 || value.sign === 0 || value.sign === 1) && "toString" in value && typeof value.toString === "function" && value.toString !== Object.prototype.toString;
 }
+/**
+* Normalizes an `xsd:dateTime` literal into a form that
+* `Temporal.Instant.from()` accepts.  A literal without a UTC offset is
+* treated as UTC, and seconds omitted before a fraction, which Activity Streams
+* 2.0 allows, are filled in.
+*
+* @param value The date-time literal to normalize.
+* @returns The normalized literal.
+*/
+function normalizeDateTimeLiteral(value) {
+	const timeStart = value.search(/[Tt ]/) + 1;
+	if (timeStart < 1) return value;
+	const date = value.substring(0, timeStart);
+	const time = value.substring(timeStart).replace(/^(\d{2}:\d{2})(?=\.)/, "$1:00");
+	return date + (/[Zz+-]/.test(time) ? time : time + "Z");
+}
 //#endregion
-export { isTemporalDuration, isTemporalInstant };
+export { isTemporalDuration, isTemporalInstant, normalizeDateTimeLiteral };

package/dist/tests/{body-Cul4-oB8.cjs → body-5wwZdMK0.cjs}

@@ -1,5 +1,5 @@
 require("./chunk-Do9eywBl.cjs");
-const require_request = require("./request-B7Iyskql.cjs");
+const require_request = require("./request-BNAT7gZ3.cjs");
 let _logtape_logtape = require("@logtape/logtape");
 //#region src/body.ts
 /** Decoded JSON body limit: 16 MiB.  @internal */

package/dist/tests/{body-ByUnLtuw.mjs → body-DqkK9XBY.mjs}

@@ -1,4 +1,4 @@
-import { t as FetchError } from "./request-pGToUa6Q.mjs";
+import { t as FetchError } from "./request-BiuryHCs.mjs";
 import { getLogger } from "@logtape/logtape";
 //#region src/body.ts
 /** Decoded JSON body limit: 16 MiB.  @internal */

package/dist/tests/body.test.cjs

@@ -1,5 +1,5 @@
 require("./chunk-Do9eywBl.cjs");
-const require_body = require("./body-Cul4-oB8.cjs");
+const require_body = require("./body-5wwZdMK0.cjs");
 let node_assert_strict = require("node:assert/strict");
 let node_test = require("node:test");
 let node_zlib = require("node:zlib");

package/dist/tests/body.test.mjs

@@ -1,4 +1,4 @@
-import { r as readBoundedText, t as BodyTooLargeError } from "./body-ByUnLtuw.mjs";
+import { r as readBoundedText, t as BodyTooLargeError } from "./body-DqkK9XBY.mjs";
 import { deepStrictEqual, ok, rejects } from "node:assert/strict";
 import { test } from "node:test";
 import { gunzipSync, gzipSync } from "node:zlib";

package/dist/tests/docloader.test.cjs

@@ -1,6 +1,6 @@
 const require_chunk = require("./chunk-Do9eywBl.cjs");
-const require_request = require("./request-B7Iyskql.cjs");
-const require_body = require("./body-Cul4-oB8.cjs");
+const require_request = require("./request-BNAT7gZ3.cjs");
+const require_body = require("./body-5wwZdMK0.cjs");
 const require_esm = require("./esm-4DuocLvD.cjs");
 const require_link = require("./link-qDTmjPw_.cjs");
 const require_url = require("./url-DLuSj57U.cjs");

package/dist/tests/docloader.test.mjs

@@ -1,6 +1,6 @@
 import { t as esm_default } from "./esm-CnLt0wAF.mjs";
-import { a as name, i as logRequest, n as createActivityPubRequest, o as version, t as FetchError } from "./request-pGToUa6Q.mjs";
-import { n as MAX_BODY_SIZE, r as readBoundedText } from "./body-ByUnLtuw.mjs";
+import { a as name, i as logRequest, n as createActivityPubRequest, o as version, t as FetchError } from "./request-BiuryHCs.mjs";
+import { n as MAX_BODY_SIZE, r as readBoundedText } from "./body-DqkK9XBY.mjs";
 import { t as HttpHeaderLink } from "./link-CYszIegt.mjs";
 import { t as UrlError } from "./url-DjsVF44Q.mjs";
 import { n as openDirectFetch, r as openPublicFetch, t as createPublicFetch } from "./public-fetch-BUSPlh1C.mjs";

package/dist/tests/{request-B7Iyskql.cjs → request-BNAT7gZ3.cjs}

@@ -3,7 +3,7 @@ let node_process = require("node:process");
 node_process = require_chunk.__toESM(node_process);
 //#region deno.json
 var name = "@fedify/vocab-runtime";
-var version = "2.0.35";
+var version = "2.0.36-dev.2551+8b012df4";
 //#endregion
 //#region src/request.ts
 /**

package/dist/tests/{request-pGToUa6Q.mjs → request-BiuryHCs.mjs}

@@ -1,7 +1,7 @@
 import process from "node:process";
 //#region deno.json
 var name = "@fedify/vocab-runtime";
-var version = "2.0.35";
+var version = "2.0.36-dev.2551+8b012df4";
 //#endregion
 //#region src/request.ts
 /**

package/dist/tests/request.test.cjs

@@ -1,5 +1,5 @@
 const require_chunk = require("./chunk-Do9eywBl.cjs");
-const require_request = require("./request-B7Iyskql.cjs");
+const require_request = require("./request-BNAT7gZ3.cjs");
 let node_test = require("node:test");
 let node_process = require("node:process");
 node_process = require_chunk.__toESM(node_process);

package/dist/tests/request.test.mjs

@@ -1,4 +1,4 @@
-import { o as version, r as getUserAgent } from "./request-pGToUa6Q.mjs";
+import { o as version, r as getUserAgent } from "./request-BiuryHCs.mjs";
 import { test } from "node:test";
 import process from "node:process";
 import { deepStrictEqual } from "node:assert";

package/dist/tests/temporal.test.cjs

@@ -4,7 +4,8 @@ let node_assert = require("node:assert");
 let _js_temporal_polyfill = require("@js-temporal/polyfill");
 //#region src/temporal.ts
 /**
-* Type guards for `Temporal` namespace objects.
+* Type guards for `Temporal` namespace objects and normalization of
+* `xsd:dateTime` literals.
 *
 * Fedify accepts both runtime polyfills (e.g. `@js-temporal/polyfill`,
 * `temporal-polyfill`) and the host's native `Temporal` implementation
@@ -57,6 +58,22 @@ function isTemporalInstant(value) {
 function isTemporalDuration(value) {
 	return typeof value === "object" && value !== null && Object.prototype.toString.call(value) === "[object Temporal.Duration]" && "sign" in value && (value.sign === -1 || value.sign === 0 || value.sign === 1) && "toString" in value && typeof value.toString === "function" && value.toString !== Object.prototype.toString;
 }
+/**
+* Normalizes an `xsd:dateTime` literal into a form that
+* `Temporal.Instant.from()` accepts.  A literal without a UTC offset is
+* treated as UTC, and seconds omitted before a fraction, which Activity Streams
+* 2.0 allows, are filled in.
+*
+* @param value The date-time literal to normalize.
+* @returns The normalized literal.
+*/
+function normalizeDateTimeLiteral(value) {
+	const timeStart = value.search(/[Tt ]/) + 1;
+	if (timeStart < 1) return value;
+	const date = value.substring(0, timeStart);
+	const time = value.substring(timeStart).replace(/^(\d{2}:\d{2})(?=\.)/, "$1:00");
+	return date + (/[Zz+-]/.test(time) ? time : time + "Z");
+}
 //#endregion
 //#region src/temporal.test.ts
 (0, node_test.test)("isTemporalInstant() accepts polyfill instances", () => {
@@ -131,4 +148,71 @@ function isTemporalDuration(value) {
 		sign: 0
 	}), false);
 });
+const literalsWithOffset = [
+	"2024-01-01T10:00Z",
+	"2024-01-01T10:00+09:00",
+	"2024-01-01T10:00-05:00",
+	"2024-01-01T10:00:00Z",
+	"2024-01-01T10:00:00+09:00",
+	"2024-01-01T10:00:00-05:00",
+	"2024-01-01T10:00:00+0900",
+	"2024-01-01T10:00:00.123456789Z",
+	"2024-01-01t10:00z",
+	"2024-01-01 10:00:00Z"
+];
+const literalsWithoutOffset = [
+	"2024-01-01T10:00",
+	"2024-01-01T10:00:00",
+	"2024-01-01T10:00:00.123",
+	"2025-01-01 12:34:56"
+];
+const literalsWithoutSeconds = [
+	["2024-01-01T10:00.5Z", "2024-01-01T10:00:00.5Z"],
+	["2024-01-01T10:00.5+09:00", "2024-01-01T10:00:00.5+09:00"],
+	["2024-01-01T10:00.5-05:00", "2024-01-01T10:00:00.5-05:00"],
+	["2024-01-01T10:00.5", "2024-01-01T10:00:00.5Z"],
+	["2024-01-01T10:00.123456789Z", "2024-01-01T10:00:00.123456789Z"]
+];
+const literalsWithExpandedYear = [["+002024-01-01T10:00", "+002024-01-01T10:00Z"], ["-000001-01-01T10:00.5Z", "-000001-01-01T10:00:00.5Z"]];
+(0, node_test.test)("normalizeDateTimeLiteral() keeps literals with a UTC offset", () => {
+	for (const literal of literalsWithOffset) {
+		(0, node_assert.strictEqual)(normalizeDateTimeLiteral(literal), literal);
+		(0, node_assert.strictEqual)(typeof _js_temporal_polyfill.Temporal.Instant.from(literal), "object");
+	}
+});
+(0, node_test.test)("normalizeDateTimeLiteral() treats literals without an offset as UTC", () => {
+	for (const literal of literalsWithoutOffset) {
+		(0, node_assert.strictEqual)(normalizeDateTimeLiteral(literal), `${literal}Z`);
+		(0, node_assert.strictEqual)(typeof _js_temporal_polyfill.Temporal.Instant.from(normalizeDateTimeLiteral(literal)), "object");
+	}
+});
+(0, node_test.test)("normalizeDateTimeLiteral() keeps literals without a time part", () => {
+	(0, node_assert.strictEqual)(normalizeDateTimeLiteral("2024-01-01"), "2024-01-01");
+});
+(0, node_test.test)("normalizeDateTimeLiteral() inserts omitted seconds before a fraction", () => {
+	for (const [literal, normalized] of literalsWithoutSeconds) {
+		(0, node_assert.strictEqual)(normalizeDateTimeLiteral(literal), normalized);
+		(0, node_assert.strictEqual)(typeof _js_temporal_polyfill.Temporal.Instant.from(normalized), "object");
+	}
+	(0, node_assert.strictEqual)(normalizeDateTimeLiteral("2024-01-01T10:00:00.5Z"), "2024-01-01T10:00:00.5Z");
+});
+(0, node_test.test)("normalizeDateTimeLiteral() handles expanded years", () => {
+	for (const [literal, normalized] of literalsWithExpandedYear) {
+		(0, node_assert.strictEqual)(normalizeDateTimeLiteral(literal), normalized);
+		(0, node_assert.strictEqual)(typeof _js_temporal_polyfill.Temporal.Instant.from(normalized), "object");
+	}
+});
+(0, node_test.test)("normalizeDateTimeLiteral() is idempotent", () => {
+	const literals = [
+		...literalsWithOffset,
+		...literalsWithoutOffset,
+		...literalsWithoutSeconds.map(([literal]) => literal),
+		...literalsWithExpandedYear.map(([literal]) => literal),
+		"2024-01-01"
+	];
+	for (const literal of literals) {
+		const normalized = normalizeDateTimeLiteral(literal);
+		(0, node_assert.strictEqual)(normalizeDateTimeLiteral(normalized), normalized);
+	}
+});
 //#endregion

package/dist/tests/temporal.test.mjs

@@ -3,7 +3,8 @@ import { strictEqual } from "node:assert";
 import { Temporal } from "@js-temporal/polyfill";
 //#region src/temporal.ts
 /**
-* Type guards for `Temporal` namespace objects.
+* Type guards for `Temporal` namespace objects and normalization of
+* `xsd:dateTime` literals.
 *
 * Fedify accepts both runtime polyfills (e.g. `@js-temporal/polyfill`,
 * `temporal-polyfill`) and the host's native `Temporal` implementation
@@ -56,6 +57,22 @@ function isTemporalInstant(value) {
 function isTemporalDuration(value) {
 	return typeof value === "object" && value !== null && Object.prototype.toString.call(value) === "[object Temporal.Duration]" && "sign" in value && (value.sign === -1 || value.sign === 0 || value.sign === 1) && "toString" in value && typeof value.toString === "function" && value.toString !== Object.prototype.toString;
 }
+/**
+* Normalizes an `xsd:dateTime` literal into a form that
+* `Temporal.Instant.from()` accepts.  A literal without a UTC offset is
+* treated as UTC, and seconds omitted before a fraction, which Activity Streams
+* 2.0 allows, are filled in.
+*
+* @param value The date-time literal to normalize.
+* @returns The normalized literal.
+*/
+function normalizeDateTimeLiteral(value) {
+	const timeStart = value.search(/[Tt ]/) + 1;
+	if (timeStart < 1) return value;
+	const date = value.substring(0, timeStart);
+	const time = value.substring(timeStart).replace(/^(\d{2}:\d{2})(?=\.)/, "$1:00");
+	return date + (/[Zz+-]/.test(time) ? time : time + "Z");
+}
 //#endregion
 //#region src/temporal.test.ts
 test("isTemporalInstant() accepts polyfill instances", () => {
@@ -130,5 +147,72 @@ test("isTemporalDuration() rejects default Object.prototype.toString", () => {
 		sign: 0
 	}), false);
 });
+const literalsWithOffset = [
+	"2024-01-01T10:00Z",
+	"2024-01-01T10:00+09:00",
+	"2024-01-01T10:00-05:00",
+	"2024-01-01T10:00:00Z",
+	"2024-01-01T10:00:00+09:00",
+	"2024-01-01T10:00:00-05:00",
+	"2024-01-01T10:00:00+0900",
+	"2024-01-01T10:00:00.123456789Z",
+	"2024-01-01t10:00z",
+	"2024-01-01 10:00:00Z"
+];
+const literalsWithoutOffset = [
+	"2024-01-01T10:00",
+	"2024-01-01T10:00:00",
+	"2024-01-01T10:00:00.123",
+	"2025-01-01 12:34:56"
+];
+const literalsWithoutSeconds = [
+	["2024-01-01T10:00.5Z", "2024-01-01T10:00:00.5Z"],
+	["2024-01-01T10:00.5+09:00", "2024-01-01T10:00:00.5+09:00"],
+	["2024-01-01T10:00.5-05:00", "2024-01-01T10:00:00.5-05:00"],
+	["2024-01-01T10:00.5", "2024-01-01T10:00:00.5Z"],
+	["2024-01-01T10:00.123456789Z", "2024-01-01T10:00:00.123456789Z"]
+];
+const literalsWithExpandedYear = [["+002024-01-01T10:00", "+002024-01-01T10:00Z"], ["-000001-01-01T10:00.5Z", "-000001-01-01T10:00:00.5Z"]];
+test("normalizeDateTimeLiteral() keeps literals with a UTC offset", () => {
+	for (const literal of literalsWithOffset) {
+		strictEqual(normalizeDateTimeLiteral(literal), literal);
+		strictEqual(typeof Temporal.Instant.from(literal), "object");
+	}
+});
+test("normalizeDateTimeLiteral() treats literals without an offset as UTC", () => {
+	for (const literal of literalsWithoutOffset) {
+		strictEqual(normalizeDateTimeLiteral(literal), `${literal}Z`);
+		strictEqual(typeof Temporal.Instant.from(normalizeDateTimeLiteral(literal)), "object");
+	}
+});
+test("normalizeDateTimeLiteral() keeps literals without a time part", () => {
+	strictEqual(normalizeDateTimeLiteral("2024-01-01"), "2024-01-01");
+});
+test("normalizeDateTimeLiteral() inserts omitted seconds before a fraction", () => {
+	for (const [literal, normalized] of literalsWithoutSeconds) {
+		strictEqual(normalizeDateTimeLiteral(literal), normalized);
+		strictEqual(typeof Temporal.Instant.from(normalized), "object");
+	}
+	strictEqual(normalizeDateTimeLiteral("2024-01-01T10:00:00.5Z"), "2024-01-01T10:00:00.5Z");
+});
+test("normalizeDateTimeLiteral() handles expanded years", () => {
+	for (const [literal, normalized] of literalsWithExpandedYear) {
+		strictEqual(normalizeDateTimeLiteral(literal), normalized);
+		strictEqual(typeof Temporal.Instant.from(normalized), "object");
+	}
+});
+test("normalizeDateTimeLiteral() is idempotent", () => {
+	const literals = [
+		...literalsWithOffset,
+		...literalsWithoutOffset,
+		...literalsWithoutSeconds.map(([literal]) => literal),
+		...literalsWithExpandedYear.map(([literal]) => literal),
+		"2024-01-01"
+	];
+	for (const literal of literals) {
+		const normalized = normalizeDateTimeLiteral(literal);
+		strictEqual(normalizeDateTimeLiteral(normalized), normalized);
+	}
+});
 //#endregion
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/vocab-runtime",
-  "version": "2.0.35",
+  "version": "2.0.36-dev.2551+8b012df4",
   "homepage": "https://fedify.dev/",
   "repository": {
     "type": "git",

package/src/temporal.test.ts

@@ -1,7 +1,11 @@
 import { Temporal } from "@js-temporal/polyfill";
 import { strictEqual } from "node:assert";
 import { test } from "node:test";
-import { isTemporalDuration, isTemporalInstant } from "./temporal.ts";
+import {
+  isTemporalDuration,
+  isTemporalInstant,
+  normalizeDateTimeLiteral,
+} from "./temporal.ts";
 
 test("isTemporalInstant() accepts polyfill instances", () => {
   strictEqual(
@@ -119,3 +123,89 @@ test("isTemporalDuration() rejects default Object.prototype.toString", () => {
   };
   strictEqual(isTemporalDuration(decoy), false);
 });
+
+const literalsWithOffset = [
+  "2024-01-01T10:00Z",
+  "2024-01-01T10:00+09:00",
+  "2024-01-01T10:00-05:00",
+  "2024-01-01T10:00:00Z",
+  "2024-01-01T10:00:00+09:00",
+  "2024-01-01T10:00:00-05:00",
+  "2024-01-01T10:00:00+0900",
+  "2024-01-01T10:00:00.123456789Z",
+  "2024-01-01t10:00z",
+  "2024-01-01 10:00:00Z",
+] as const;
+
+const literalsWithoutOffset = [
+  "2024-01-01T10:00",
+  "2024-01-01T10:00:00",
+  "2024-01-01T10:00:00.123",
+  "2025-01-01 12:34:56",
+] as const;
+
+const literalsWithoutSeconds = [
+  ["2024-01-01T10:00.5Z", "2024-01-01T10:00:00.5Z"],
+  ["2024-01-01T10:00.5+09:00", "2024-01-01T10:00:00.5+09:00"],
+  ["2024-01-01T10:00.5-05:00", "2024-01-01T10:00:00.5-05:00"],
+  ["2024-01-01T10:00.5", "2024-01-01T10:00:00.5Z"],
+  ["2024-01-01T10:00.123456789Z", "2024-01-01T10:00:00.123456789Z"],
+] as const;
+
+const literalsWithExpandedYear = [
+  ["+002024-01-01T10:00", "+002024-01-01T10:00Z"],
+  ["-000001-01-01T10:00.5Z", "-000001-01-01T10:00:00.5Z"],
+] as const;
+
+test("normalizeDateTimeLiteral() keeps literals with a UTC offset", () => {
+  for (const literal of literalsWithOffset) {
+    strictEqual(normalizeDateTimeLiteral(literal), literal);
+    strictEqual(typeof Temporal.Instant.from(literal), "object");
+  }
+});
+
+test("normalizeDateTimeLiteral() treats literals without an offset as UTC", () => {
+  for (const literal of literalsWithoutOffset) {
+    strictEqual(normalizeDateTimeLiteral(literal), `${literal}Z`);
+    strictEqual(
+      typeof Temporal.Instant.from(normalizeDateTimeLiteral(literal)),
+      "object",
+    );
+  }
+});
+
+test("normalizeDateTimeLiteral() keeps literals without a time part", () => {
+  strictEqual(normalizeDateTimeLiteral("2024-01-01"), "2024-01-01");
+});
+
+test("normalizeDateTimeLiteral() inserts omitted seconds before a fraction", () => {
+  for (const [literal, normalized] of literalsWithoutSeconds) {
+    strictEqual(normalizeDateTimeLiteral(literal), normalized);
+    strictEqual(typeof Temporal.Instant.from(normalized), "object");
+  }
+  strictEqual(
+    normalizeDateTimeLiteral("2024-01-01T10:00:00.5Z"),
+    "2024-01-01T10:00:00.5Z",
+  );
+});
+
+test("normalizeDateTimeLiteral() handles expanded years", () => {
+  for (const [literal, normalized] of literalsWithExpandedYear) {
+    strictEqual(normalizeDateTimeLiteral(literal), normalized);
+    strictEqual(typeof Temporal.Instant.from(normalized), "object");
+  }
+});
+
+test("normalizeDateTimeLiteral() is idempotent", () => {
+  const literals = [
+    ...literalsWithOffset,
+    ...literalsWithoutOffset,
+    ...literalsWithoutSeconds.map(([literal]) => literal),
+    ...literalsWithExpandedYear.map(([literal]) => literal),
+    "2024-01-01",
+  ];
+  for (const literal of literals) {
+    const normalized = normalizeDateTimeLiteral(literal);
+    strictEqual(normalizeDateTimeLiteral(normalized), normalized);
+  }
+});

package/src/temporal.ts

@@ -1,5 +1,6 @@
 /**
- * Type guards for `Temporal` namespace objects.
+ * Type guards for `Temporal` namespace objects and normalization of
+ * `xsd:dateTime` literals.
  *
  * Fedify accepts both runtime polyfills (e.g. `@js-temporal/polyfill`,
  * `temporal-polyfill`) and the host's native `Temporal` implementation
@@ -72,3 +73,21 @@ export function isTemporalDuration(value: unknown): value is Temporal.Duration {
     value.toString !== Object.prototype.toString
   );
 }
+
+/**
+ * Normalizes an `xsd:dateTime` literal into a form that
+ * `Temporal.Instant.from()` accepts.  A literal without a UTC offset is
+ * treated as UTC, and seconds omitted before a fraction, which Activity Streams
+ * 2.0 allows, are filled in.
+ *
+ * @param value The date-time literal to normalize.
+ * @returns The normalized literal.
+ */
+export function normalizeDateTimeLiteral(value: string): string {
+  const timeStart = value.search(/[Tt ]/) + 1;
+  if (timeStart < 1) return value;
+  const date = value.substring(0, timeStart);
+  const time = value.substring(timeStart)
+    .replace(/^(\d{2}:\d{2})(?=\.)/, "$1:00");
+  return date + (/[Zz+-]/.test(time) ? time : time + "Z");
+}