@crewhaus/tool-notify 0.7.0 → 0.8.1

package/dist/lib/instant.d.ts

@@ -0,0 +1,57 @@
+/**
+ * An instant the caller supplies, read the same way on every machine.
+ *
+ * Every clock value in this package is an argument, so that the same
+ * question gets the same answer wherever it is asked. `new Date(text)` broke
+ * that for one spelling: an ISO-8601 date-time with no offset
+ * (`2026-09-17T23:30:00`) is read by ECMAScript as the HOST's local time, and
+ * a date alone as UTC midnight. The same QuietHours question was inside the
+ * window under UTC and outside it under Asia/Tokyo, and the same EmailCompose
+ * call wrote a different Date header and Message-ID.
+ *
+ * So an instant must say where it is, and the WHOLE string is read by a
+ * grammar here, never handed to `Date.parse`. Checking only that the text
+ * ended in something offset-shaped was not enough: JavaScriptCore's legacy
+ * parser reads `Sep 17 2026-23:30` as 23:30 host time and the trailing
+ * `-23:30` as noise, so it passed the check and still moved with the host
+ * zone (net review of 0.7.1). Two families are accepted, each with a
+ * mandatory zone:
+ *
+ * - ISO-8601 / RFC 3339: `2026-09-17T09:30:00Z`, `2026-09-17T18:30+09:00`,
+ *   `2026-09-17T02:30:00.250-0700` (a space may stand for the `T`),
+ *   `T24:00:00`, the end of the day, and a six-digit signed year
+ *   (`+002026-…`).
+ * - Written dates, as an email Date header and JavaScript print them:
+ *   `Thu, 17 Sep 2026 09:30:00 +0000`, `17 Sep 2026 09:30 GMT`,
+ *   `Thursday, 17 September 2026 09:30:00 GMT`, `Sep 17, 2026 09:30:00 UTC`,
+ *   and `Date.prototype.toString()`'s `Thu Sep 17 2026 09:30:00 GMT+0900
+ *   (Japan Standard Time)`. Day and month names may be short or long. The
+ *   weekday is optional and, as mail readers do, not checked against the
+ *   date.
+ *
+ * A zone is `Z`, `UT`, `UTC`, `GMT`, a numeric offset (`+09:00`, `-0700`,
+ * `GMT+0900`), or one of the US zones RFC 5322 §4.3 defines with a fixed
+ * offset (EST, EDT, CST, CDT, MST, MDT, PST, PDT). 0.7.0's `new Date(text)`
+ * read every one of these the same way on every host, so refusing them
+ * broke calls that were never host-dependent (net regression review). Any
+ * other abbreviation (`CET`, `IST`) names different zones in different
+ * places, and is refused.
+ *
+ * Anything else is refused with the reason. Reading an offset-less time in
+ * some other zone (the schedule's, say) is not done: it would be a guess
+ * about what the caller meant.
+ */
+/** The epoch milliseconds `text` names, or undefined when it is not one of the spellings above. */
+export declare function readZonedInstant(text: string): number | undefined;
+export type ParsedInstant = {
+    readonly ok: true;
+    readonly ms: number;
+} | {
+    readonly ok: false;
+    readonly message: string;
+};
+/**
+ * The epoch milliseconds `text` names, or a refusal that quotes it (clipped)
+ * and gives an example. `example` is the spelling the message suggests.
+ */
+export declare function parseOffsetInstant(text: string, example?: string): ParsedInstant;

package/dist/lib/instant.js

@@ -0,0 +1,188 @@
+/**
+ * An instant the caller supplies, read the same way on every machine.
+ *
+ * Every clock value in this package is an argument, so that the same
+ * question gets the same answer wherever it is asked. `new Date(text)` broke
+ * that for one spelling: an ISO-8601 date-time with no offset
+ * (`2026-09-17T23:30:00`) is read by ECMAScript as the HOST's local time, and
+ * a date alone as UTC midnight. The same QuietHours question was inside the
+ * window under UTC and outside it under Asia/Tokyo, and the same EmailCompose
+ * call wrote a different Date header and Message-ID.
+ *
+ * So an instant must say where it is, and the WHOLE string is read by a
+ * grammar here, never handed to `Date.parse`. Checking only that the text
+ * ended in something offset-shaped was not enough: JavaScriptCore's legacy
+ * parser reads `Sep 17 2026-23:30` as 23:30 host time and the trailing
+ * `-23:30` as noise, so it passed the check and still moved with the host
+ * zone (net review of 0.7.1). Two families are accepted, each with a
+ * mandatory zone:
+ *
+ * - ISO-8601 / RFC 3339: `2026-09-17T09:30:00Z`, `2026-09-17T18:30+09:00`,
+ *   `2026-09-17T02:30:00.250-0700` (a space may stand for the `T`),
+ *   `T24:00:00`, the end of the day, and a six-digit signed year
+ *   (`+002026-…`).
+ * - Written dates, as an email Date header and JavaScript print them:
+ *   `Thu, 17 Sep 2026 09:30:00 +0000`, `17 Sep 2026 09:30 GMT`,
+ *   `Thursday, 17 September 2026 09:30:00 GMT`, `Sep 17, 2026 09:30:00 UTC`,
+ *   and `Date.prototype.toString()`'s `Thu Sep 17 2026 09:30:00 GMT+0900
+ *   (Japan Standard Time)`. Day and month names may be short or long. The
+ *   weekday is optional and, as mail readers do, not checked against the
+ *   date.
+ *
+ * A zone is `Z`, `UT`, `UTC`, `GMT`, a numeric offset (`+09:00`, `-0700`,
+ * `GMT+0900`), or one of the US zones RFC 5322 §4.3 defines with a fixed
+ * offset (EST, EDT, CST, CDT, MST, MDT, PST, PDT). 0.7.0's `new Date(text)`
+ * read every one of these the same way on every host, so refusing them
+ * broke calls that were never host-dependent (net regression review). Any
+ * other abbreviation (`CET`, `IST`) names different zones in different
+ * places, and is refused.
+ *
+ * Anything else is refused with the reason. Reading an offset-less time in
+ * some other zone (the schedule's, say) is not done: it would be a guess
+ * about what the caller meant.
+ */
+// The same grammar as tool-http's lib/http-date.ts reads a Retry-After date
+// with a zone in. The packages do not depend on each other, and neither
+// should grow a dependency for one small reader: change both together.
+const MONTHS = ["jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec"];
+const LONG_MONTHS = [
+    "january",
+    "february",
+    "march",
+    "april",
+    "may",
+    "june",
+    "july",
+    "august",
+    "september",
+    "october",
+    "november",
+    "december",
+];
+const DAYS = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"];
+const LONG_DAYS = ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"];
+/** Minutes east of UTC for each zone name read here (RFC 5322 §3.3 and §4.3). */
+const NAMED_ZONES = new Map([
+    ["Z", 0],
+    ["UT", 0],
+    ["UTC", 0],
+    ["GMT", 0],
+    ["EST", -300],
+    ["EDT", -240],
+    ["CST", -360],
+    ["CDT", -300],
+    ["MST", -420],
+    ["MDT", -360],
+    ["PST", -480],
+    ["PDT", -420],
+]);
+// Anchored, bounded and without nested quantifiers: each is linear. The
+// input is also capped before either runs.
+const ISO = /^((?:[+-]\d{2})?\d{4})-(\d{2})-(\d{2})[Tt ](\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,9}))?)?([Zz]|[+-]\d{2}:?\d{2})$/;
+/**
+ * A written date: optional weekday, then day-first (`17 Sep 2026`,
+ * `17-Sep-2026`) or month-first (`Sep 17, 2026`, `Sep 17 2026`), a time,
+ * a zone, and an optional parenthesised zone name after it.
+ */
+const WRITTEN = /^(?:([A-Za-z]{3,9}),?\s+)?(?:(\d{1,2})[ -]([A-Za-z]{3,9})\.?[ -](\d{4})|([A-Za-z]{3,9})\.?\s(\d{1,2}),?\s(\d{4}))\s+(\d{1,2}):(\d{2})(?::(\d{2}))?\s*((?:GMT|UTC)?[+-]\d{2}:?\d{2}|UTC|UT|GMT|Z|[ECMP][SD]T)(?:\s+\([^()]{0,64}\))?$/i;
+const MAX_LENGTH = 128;
+/** Minutes east of UTC for a zone {@link ISO} or {@link WRITTEN} matched; undefined when out of range. */
+function offsetMinutes(zone) {
+    const upper = zone.toUpperCase();
+    const named = NAMED_ZONES.get(upper);
+    if (named !== undefined)
+        return named;
+    const numeric = upper.startsWith("GMT") || upper.startsWith("UTC") ? upper.slice(3) : upper;
+    const sign = numeric[0] === "-" ? -1 : 1;
+    const digits = numeric.slice(1).replace(":", "");
+    const hours = Number(digits.slice(0, 2));
+    const minutes = Number(digits.slice(2, 4));
+    if (hours > 23 || minutes > 59)
+        return undefined;
+    return sign * (hours * 60 + minutes);
+}
+/** A month's index from its short or long English name, or -1. */
+function monthIndex(name) {
+    const lower = name.toLowerCase();
+    return lower.length === 3 ? MONTHS.indexOf(lower) : LONG_MONTHS.indexOf(lower);
+}
+/** The instant, or undefined when a field is out of range (31 Nov, 25:00). */
+function instant(year, month, day, hour, minute, second, fraction, zone) {
+    const offset = offsetMinutes(zone);
+    if (offset === undefined || month < 0 || month > 11)
+        return undefined;
+    // 24:00:00 is ISO-8601's end of the day, the next day's 00:00.
+    const endOfDay = hour === 24 && minute === 0 && second === 0 && !/[1-9]/.test(fraction ?? "");
+    if ((hour > 23 && !endOfDay) || minute > 59 || second > 60)
+        return undefined;
+    const midnight = utc(year, month, day, 0, 0, 0, 0);
+    const check = new Date(midnight);
+    if (check.getUTCMonth() !== month || check.getUTCDate() !== day)
+        return undefined;
+    // A leap second (:60) names the same instant as the next minute's :00,
+    // which is what the arithmetic gives for 60.
+    const ms = fraction === undefined ? 0 : Math.floor(Number(`0.${fraction}`) * 1000);
+    return utc(year, month, day, hour, minute, second, ms) - offset * 60_000;
+}
+/**
+ * `Date.UTC` without its one surprise: it reads a year from 0 to 99 as
+ * 1900 plus that, so `0026-01-01T00:00:00Z` became 1926.
+ */
+function utc(year, month, day, hour, minute, second, ms) {
+    const d = new Date(0);
+    d.setUTCFullYear(year, month, day);
+    return d.getTime() + ((hour * 60 + minute) * 60 + second) * 1000 + ms;
+}
+/** The epoch milliseconds `text` names, or undefined when it is not one of the spellings above. */
+export function readZonedInstant(text) {
+    const t = text.trim();
+    if (t.length > MAX_LENGTH)
+        return undefined;
+    const iso = t.match(ISO);
+    if (iso !== null) {
+        // ECMAScript's rule: year zero has one spelling, 0000, not -000000.
+        if (iso[1] === "-000000")
+            return undefined;
+        return instant(Number(iso[1]), Number(iso[2]) - 1, Number(iso[3]), Number(iso[4]), Number(iso[5]), Number(iso[6] ?? 0), iso[7], iso[8]);
+    }
+    const w = t.match(WRITTEN);
+    if (w !== null) {
+        const weekday = w[1]?.toLowerCase();
+        if (weekday !== undefined && !DAYS.includes(weekday) && !LONG_DAYS.includes(weekday)) {
+            return undefined;
+        }
+        const dayFirst = w[2] !== undefined;
+        return instant(Number(dayFirst ? w[4] : w[7]), monthIndex((dayFirst ? w[3] : w[5])), Number(dayFirst ? w[2] : w[6]), Number(w[8]), Number(w[9]), Number(w[10] ?? 0), undefined, w[11]);
+    }
+    return undefined;
+}
+/**
+ * Whether `text` carries something that names a zone: a numeric offset after
+ * a digit or a space, a `Z` after a digit, `GMT`/`UTC`/`UT`, or a trailing
+ * abbreviation. Only for wording a refusal; linear, on capped input.
+ */
+function namesAZone(text) {
+    const t = text.slice(0, 200);
+    return (/[\d\s][+-]\d{2}:?\d{2}\b/.test(t) ||
+        /\d[Zz]$/.test(t) ||
+        /\b(?:GMT|UTC|UT)\b/i.test(t) ||
+        /\b[A-Z]{3,5}(?:\s*\([^()]*\))?$/.test(t));
+}
+/**
+ * The epoch milliseconds `text` names, or a refusal that quotes it (clipped)
+ * and gives an example. `example` is the spelling the message suggests.
+ */
+export function parseOffsetInstant(text, example = "2026-09-17T09:30:00Z") {
+    const trimmed = text.trim();
+    const shown = trimmed.length > 80 ? `${trimmed.slice(0, 80)}…` : trimmed;
+    const ms = readZonedInstant(trimmed);
+    if (ms !== undefined)
+        return { ok: true, ms };
+    const spellings = `write it as e.g. ${example} (ISO-8601) or Thu, 17 Sep 2026 09:30:00 +0000 (RFC 5322)`;
+    return {
+        ok: false,
+        message: namesAZone(trimmed)
+            ? `"${shown}" is not an instant in a spelling this tool reads, or one of its fields is out of range — ${spellings}. A zone must be Z, UT, UTC, GMT, a numeric offset, or one of the US zones RFC 5322 defines (EST, EDT, CST, CDT, MST, MDT, PST, PDT); other abbreviations name different zones in different places`
+            : `"${shown}" is not an instant with a UTC offset — ${spellings}; a time without an offset means the host's local time, which differs between machines`,
+    };
+}

package/dist/lib/preflight.js

@@ -23,6 +23,7 @@
  *     that is fine are different answers, and only one of them means the
  *     message is ready.
  */
+import { parseOffsetInstant } from "./instant";
 import { isMessageId, isReservedHeaderName, isValidAddress, isValidHeaderName } from "./mime";
 import { templatePlaceholders } from "./template";
 /** Locale-free order, so two runs list the same faults in the same place. */
@@ -171,18 +172,15 @@ function checkEnvelope(draft) {
     };
 }
 function checkDate(draft) {
-    const when = new Date(draft.date);
-    if (Number.isNaN(when.getTime())) {
-        return {
-            check: "date",
-            status: "fail",
-            detail: `"${draft.date}" is not an instant - use ISO-8601 with an offset, e.g. 2026-09-17T09:30:00Z`,
-        };
-    }
+    // The same reader EmailSend and EmailCompose build the header with, so a
+    // date the preflight passes is a date the send accepts.
+    const instant = parseOffsetInstant(draft.date);
+    if (!instant.ok)
+        return { check: "date", status: "fail", detail: instant.message };
     return {
         check: "date",
         status: "pass",
-        detail: `the Date header will read ${when.toISOString()}`,
+        detail: `the Date header will read ${new Date(instant.ms).toISOString()}`,
     };
 }
 function checkHeaders(draft) {

package/dist/lib/quiet.d.ts

@@ -44,6 +44,8 @@ export type QuietError = {
 };
 /** Minutes past local midnight, or `null` when `text` is not `HH:MM`. */
 export declare function parseClock(text: string): number | null;
+/** Test-only: how many formatters the cache holds. */
+export declare function __quietFormatterCountForTest(): number;
 /** Validate a schedule up front, so a bad window is one error and not silence. */
 export declare function validateSchedule(schedule: QuietSchedule): string | null;
 /**
@@ -56,4 +58,4 @@ export declare function validateSchedule(schedule: QuietSchedule): string | null
  * weekly schedule; a schedule that blacks out more than nine consecutive
  * days is reported as such rather than answered with a guess.
  */
-export declare function quietDecision(schedule: QuietSchedule, nowMs: number): QuietDecision | QuietError;
+export declare function quietDecision(given: QuietSchedule, nowMs: number): QuietDecision | QuietError;

package/dist/lib/quiet.js

@@ -28,25 +28,55 @@ export function parseClock(text) {
         return null;
     return hours * 60 + minutes;
 }
-/** A cached formatter per timezone — building one per call is the slow path. */
+/**
+ * The zone's canonical name: `america/new_york` is `America/New_York`,
+ * `-0800` is `-08:00`. Throws a RangeError for a zone the runtime does not
+ * know. The formatter it builds to ask is thrown away, never cached.
+ */
+function canonicalZone(timeZone) {
+    return new Intl.DateTimeFormat("en-US", { timeZone }).resolvedOptions().timeZone;
+}
+/**
+ * Formatters by CANONICAL zone name, least recently used first, at most
+ * {@link MAX_FORMATTERS} of them. Building one per call is the slow path,
+ * but a cache keyed by whatever the caller spelled is unbounded: Intl
+ * accepts any casing of an IANA name and several spellings of every offset,
+ * each formatter holds tens of kilobytes, and 0.7.0 kept every one for the
+ * life of the process (20 000 case variants of one zone cost about 730 MB).
+ * Canonical names alone are not a bound either — the offset zones number in
+ * the thousands — so the cache is also capped.
+ */
 const formatters = new Map();
+const MAX_FORMATTERS = 64;
+/** `timeZone` must already be canonical (see {@link canonicalZone}). */
 function formatterFor(timeZone) {
     let formatter = formatters.get(timeZone);
-    if (formatter === undefined) {
-        formatter = new Intl.DateTimeFormat("en-US", {
-            timeZone,
-            hourCycle: "h23",
-            year: "numeric",
-            month: "2-digit",
-            day: "2-digit",
-            hour: "2-digit",
-            minute: "2-digit",
-            second: "2-digit",
-        });
+    if (formatter !== undefined) {
+        // Most recently used moves to the back.
+        formatters.delete(timeZone);
         formatters.set(timeZone, formatter);
+        return formatter;
+    }
+    formatter = new Intl.DateTimeFormat("en-US", {
+        timeZone,
+        hourCycle: "h23",
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+    });
+    while (formatters.size >= MAX_FORMATTERS) {
+        formatters.delete(formatters.keys().next().value);
     }
+    formatters.set(timeZone, formatter);
     return formatter;
 }
+/** Test-only: how many formatters the cache holds. */
+export function __quietFormatterCountForTest() {
+    return formatters.size;
+}
 /** The wall-clock reading of an instant in a timezone. */
 function zonedParts(instant, timeZone) {
     const parts = formatterFor(timeZone).formatToParts(new Date(instant));
@@ -97,7 +127,7 @@ function isoDate(z) {
 /** Validate a schedule up front, so a bad window is one error and not silence. */
 export function validateSchedule(schedule) {
     try {
-        formatterFor(schedule.timezone);
+        canonicalZone(schedule.timezone);
     }
     catch {
         return `"${schedule.timezone}" is not a timezone this runtime knows — use an IANA name such as Europe/Berlin`;
@@ -170,10 +200,13 @@ const SEARCH_DAYS = 9;
  * weekly schedule; a schedule that blacks out more than nine consecutive
  * days is reported as such rather than answered with a guess.
  */
-export function quietDecision(schedule, nowMs) {
-    const invalid = validateSchedule(schedule);
+export function quietDecision(given, nowMs) {
+    const invalid = validateSchedule(given);
     if (invalid !== null)
         return { error: invalid };
+    // Every lookup below goes through the cache, so it is keyed by the zone,
+    // not by how this call happened to spell it.
+    const schedule = { ...given, timezone: canonicalZone(given.timezone) };
     const z = zonedParts(nowMs, schedule.timezone);
     const local = {
         localTime: `${pad(z.hour, 2)}:${pad(z.minute, 2)}`,

package/dist/lib/ratelimit.js

@@ -22,7 +22,10 @@
  * no longer refuse anything, so nothing is lost by forgetting them.
  */
 function prune(state, nowMs, windowMs, keep) {
-    const kept = {};
+    // A record indexed by a caller's string has no prototype: on a plain `{}`,
+    // `kept["__proto__"] = entry` sets the object's prototype instead of adding
+    // the key, JSON drops it, and that key was never limited at all.
+    const kept = Object.create(null);
     const pruned = [];
     for (const name of Object.keys(state).sort()) {
         const entry = state[name];
@@ -40,7 +43,7 @@ export function rateLimitGate(options) {
     const windowMs = Math.max(1, options.windowMs);
     const state = options.state ?? {};
     const { kept, pruned } = prune(state, options.nowMs, windowMs, options.key);
-    const existing = kept[options.key];
+    const existing = Object.hasOwn(kept, options.key) ? kept[options.key] : undefined;
     const inWindow = existing !== undefined && options.nowMs - existing.windowStart < windowMs;
     const current = inWindow ? existing : undefined;
     const count = current?.count ?? 0;
@@ -68,7 +71,7 @@ export function rateLimitGate(options) {
             pruned,
         };
     }
-    const next = { ...kept };
+    const next = Object.assign(Object.create(null), kept);
     next[options.key] = {
         windowStart: current?.windowStart ?? options.nowMs,
         count: count + 1,

package/dist/lib/template.js

@@ -1,13 +1,20 @@
 import { escapeFor } from "./blocks";
 /** `{{ name }}` or `{{ a.b.c }}`; whitespace inside the braces is ignored. */
 const PLACEHOLDER = /\{\{\s*([A-Za-z0-9_][A-Za-z0-9_.]*)\s*\}\}/g;
-/** Read a dotted path out of the data object. */
+/**
+ * Read a dotted path out of the data object: own properties only. An
+ * inherited one is not data the caller supplied: `{{__proto__}}` read
+ * Object.prototype and rendered `{}` where the rule is that a missing value
+ * is an error rather than a hole (net review, beside C208).
+ */
 function lookup(data, path) {
     let current = data;
     for (const segment of path.split(".")) {
         if (current === null || typeof current !== "object" || Array.isArray(current)) {
             return undefined;
         }
+        if (!Object.hasOwn(current, segment))
+            return undefined;
         current = current[segment];
     }
     return current;

package/dist/lib/webhook-path.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Whether a URL path is a Teams incoming webhook's, whose path is the
+ * credential: what `/^\/webhookb2\/[^/]+@[^/]+\/IncomingWebhook\/.+/i`
+ * answered, read a segment at a time. The segment after `/webhookb2/` must
+ * hold an `@` with a character on each side, `/IncomingWebhook/` must follow
+ * it, and a character that is not a line break after that. The pattern's
+ * `[^/]+@` overlapped the `@`, so it tried every `@` of a run and rescanned
+ * the rest of the segment from each: quadratic in a path the call wrote,
+ * before the allow-list was asked.
+ */
+export declare function isTeamsWebhookPath(path: string): boolean;

package/dist/lib/webhook-path.js

@@ -0,0 +1,42 @@
+/** Whether `text` holds `lower` at `at`, an ASCII letter in either case as the `i` flag matches. */
+function caseFoldedAt(text, at, lower) {
+    if (at + lower.length > text.length)
+        return false;
+    for (let i = 0; i < lower.length; i++) {
+        const want = lower.charCodeAt(i);
+        const got = text.charCodeAt(at + i);
+        if (got !== want && !(want >= 0x61 && want <= 0x7a && got === want - 0x20))
+            return false;
+    }
+    return true;
+}
+/** A code unit `.` does not match without the `s` flag. */
+function isLineBreak(c) {
+    return c === 0x0a || c === 0x0d || c === 0x2028 || c === 0x2029;
+}
+const TEAMS_PREFIX = "/webhookb2/";
+const TEAMS_MARKER = "/incomingwebhook/";
+/**
+ * Whether a URL path is a Teams incoming webhook's, whose path is the
+ * credential: what `/^\/webhookb2\/[^/]+@[^/]+\/IncomingWebhook\/.+/i`
+ * answered, read a segment at a time. The segment after `/webhookb2/` must
+ * hold an `@` with a character on each side, `/IncomingWebhook/` must follow
+ * it, and a character that is not a line break after that. The pattern's
+ * `[^/]+@` overlapped the `@`, so it tried every `@` of a run and rescanned
+ * the rest of the segment from each: quadratic in a path the call wrote,
+ * before the allow-list was asked.
+ */
+export function isTeamsWebhookPath(path) {
+    if (!caseFoldedAt(path, 0, TEAMS_PREFIX))
+        return false;
+    const segmentEnd = path.indexOf("/", TEAMS_PREFIX.length);
+    if (segmentEnd === -1)
+        return false;
+    const at = path.indexOf("@", TEAMS_PREFIX.length + 1);
+    if (at === -1 || at > segmentEnd - 2)
+        return false;
+    if (!caseFoldedAt(path, segmentEnd, TEAMS_MARKER))
+        return false;
+    const rest = segmentEnd + TEAMS_MARKER.length;
+    return rest < path.length && !isLineBreak(path.charCodeAt(rest));
+}