@moxxy/sdk 0.43.0 → 0.45.0

package/src/cron.ts

@@ -0,0 +1,355 @@
+/**
+ * Tiny POSIX-style 5-field cron parser.
+ *
+ *   ┌───────────── minute        (0-59)
+ *   │ ┌─────────── hour          (0-23)
+ *   │ │ ┌───────── day-of-month  (1-31)
+ *   │ │ │ ┌─────── month         (1-12)
+ *   │ │ │ │ ┌───── day-of-week   (0-6, Sunday=0)
+ *   * * * * *
+ *
+ * Each field supports:
+ *   - `*`           — any value in range
+ *   - `n`           — literal
+ *   - `a-b`         — inclusive range
+ *   - `a,b,c`       — list
+ *   - `*\/n`         — every n
+ *   - `a-b/n`       — every n within a range
+ *
+ * `nextFireTime(expr, after)` walks forward minute-by-minute (with cheap
+ * field-by-field jumps) until every field matches, capped at a year
+ * lookahead. Returns null if no fire is reachable (impossible expression
+ * like `0 0 31 2 *`).
+ *
+ * Standard cron quirk: when both DOM and DOW are restricted, vixie-cron
+ * matches on EITHER. We follow that convention.
+ */
+
+import { assertDefined } from './assert.js';
+
+interface FieldSpec {
+  readonly values: ReadonlySet<number>;
+  readonly restricted: boolean;
+}
+
+export interface ParsedCron {
+  readonly minute: FieldSpec;
+  readonly hour: FieldSpec;
+  readonly dom: FieldSpec;
+  readonly month: FieldSpec;
+  readonly dow: FieldSpec;
+}
+
+interface FieldRange {
+  readonly min: number;
+  readonly max: number;
+}
+
+const FIELD_RANGES: Record<keyof ParsedCron, FieldRange> = {
+  minute: { min: 0, max: 59 },
+  hour: { min: 0, max: 23 },
+  dom: { min: 1, max: 31 },
+  month: { min: 1, max: 12 },
+  dow: { min: 0, max: 6 },
+};
+
+function parseField(raw: string, range: FieldRange, fieldName: string): FieldSpec {
+  const values = new Set<number>();
+  const restricted = raw !== '*' && !raw.startsWith('*/');
+  for (const piece of raw.split(',')) {
+    const [rangePart, stepPart] = piece.split('/');
+    if (rangePart === undefined) throw new Error(`empty term in ${fieldName}: "${raw}"`);
+    const step = stepPart ? toIntStrict(stepPart, fieldName) : 1;
+    if (step < 1) throw new Error(`step must be >= 1 in ${fieldName}: "${raw}"`);
+
+    let lo: number;
+    let hi: number;
+    if (rangePart === '*') {
+      lo = range.min;
+      hi = range.max;
+    } else if (rangePart.includes('-')) {
+      const [a, b] = rangePart.split('-');
+      // A string containing '-' always splits into >= 2 parts, so both bounds
+      // are present by construction (empty strings are caught by toIntStrict).
+      assertDefined(a, 'range lower bound (rangePart contains "-")');
+      assertDefined(b, 'range upper bound (rangePart contains "-")');
+      lo = toIntStrict(a, fieldName);
+      hi = toIntStrict(b, fieldName);
+    } else {
+      lo = toIntStrict(rangePart, fieldName);
+      hi = lo;
+    }
+    if (lo < range.min || hi > range.max || lo > hi) {
+      throw new Error(
+        `out-of-range term "${piece}" in ${fieldName} (allowed ${range.min}-${range.max})`,
+      );
+    }
+    for (let v = lo; v <= hi; v += step) values.add(v);
+  }
+  return { values, restricted };
+}
+
+function toIntStrict(s: string, fieldName: string): number {
+  if (!/^-?\d+$/.test(s)) throw new Error(`non-integer "${s}" in ${fieldName}`);
+  return Number(s);
+}
+
+export function parseCron(expr: string): ParsedCron {
+  const fields = expr.trim().split(/\s+/);
+  if (fields.length !== 5) {
+    throw new Error(`cron expression must have 5 fields, got ${fields.length}: "${expr}"`);
+  }
+  const [minute, hour, dom, month, dow] = fields as [string, string, string, string, string];
+  return {
+    minute: parseField(minute, FIELD_RANGES.minute, 'minute'),
+    hour: parseField(hour, FIELD_RANGES.hour, 'hour'),
+    dom: parseField(dom, FIELD_RANGES.dom, 'dom'),
+    month: parseField(month, FIELD_RANGES.month, 'month'),
+    dow: parseField(dow, FIELD_RANGES.dow, 'dow'),
+  };
+}
+
+export function isValidCron(expr: string): boolean {
+  try {
+    parseCron(expr);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// Calendar maximum day-of-month per month (1-12). February uses 29 to allow
+// leap-year Feb 29 fires; non-leap years are then handled by the normal walk.
+const MAX_DOM_BY_MONTH: Record<number, number> = {
+  1: 31, 2: 29, 3: 31, 4: 30, 5: 31, 6: 30,
+  7: 31, 8: 31, 9: 30, 10: 31, 11: 30, 12: 31,
+};
+
+/**
+ * Cheap, zone-independent structural-impossibility check. Some cron
+ * expressions can never fire because their day-of-month is larger than every
+ * candidate month allows (e.g. `0 0 30 2 *` — Feb never has a 30th, or
+ * `0 0 31 4 *` — April has no 31st). Without this, an explicit-IANA-zone walk
+ * for such an expression advances minute-by-minute through the full 366-day cap
+ * (~527k `Intl.formatToParts` calls, ~2s of blocked event loop) only to return
+ * null. The DOM/DOW OR-semantics quirk means this is only safe to declare
+ * impossible when DOW is unrestricted (`*`): if DOW is restricted the day can
+ * still match via the weekday arm regardless of DOM. We check exactly the case
+ * the walk is slowest on — a restricted DOM whose smallest value exceeds the
+ * largest day any selected month can hold — and bail to "no fire" instantly.
+ */
+function isStructurallyImpossible(cron: ParsedCron): boolean {
+  // OR-semantics: a restricted DOW can satisfy the day on its own, so DOM being
+  // unreachable does not make the expression impossible. Only decide when DOW
+  // is unrestricted (every weekday allowed) and DOM is restricted.
+  if (cron.dow.restricted || !cron.dom.restricted) return false;
+  const minDom = Math.min(...cron.dom.values);
+  let maxAllowed = 0;
+  for (const month of cron.month.values) {
+    const cap = MAX_DOM_BY_MONTH[month] ?? 31;
+    if (cap > maxAllowed) maxAllowed = cap;
+  }
+  // If the smallest requested day-of-month is larger than the biggest day any
+  // selected month can ever hold, no instant can match — impossible.
+  return minDom > maxAllowed;
+}
+
+/**
+ * Whether `tz` is an IANA zone the runtime's `Intl` accepts. A non-IANA
+ * string (e.g. 'PST', 'Mars/Phobos') makes `Intl.DateTimeFormat` throw a
+ * RangeError. `nextFireTime` would otherwise inherit that throw deep inside
+ * the poller tick (outside its per-entry try/catch), aborting evaluation of
+ * every schedule positioned after the bad one. We reject the zone at the
+ * trust boundary instead. `undefined`/'local' mean system-local (always ok).
+ */
+export function isValidTimeZone(tz: string | undefined): boolean {
+  if (tz === undefined || tz === 'local') return true;
+  try {
+    new Intl.DateTimeFormat(undefined, { timeZone: tz });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Minute-precision walk forward from `after` (exclusive) until every
+ * field matches. Operates in the caller-supplied IANA timezone via
+ * `Intl.DateTimeFormat` — defaults to system local. The walk is
+ * bounded at 1-year so a structurally-impossible expression returns
+ * null instead of looping forever.
+ */
+export function nextFireTime(
+  expr: string,
+  after: Date,
+  timeZone?: string,
+): Date | null {
+  const cron = parseCron(expr);
+  // Defense in depth: a malformed/legacy timeZone that slipped past the
+  // trust-boundary validation would make `Intl.DateTimeFormat` throw deep in
+  // the walk — outside the poller's per-entry guard, which would abort every
+  // later schedule's evaluation. Treat an unusable zone as "no reachable fire"
+  // (null) so the entry is simply never due, matching how callers handle null.
+  if (!isValidTimeZone(timeZone)) return null;
+  // Bail instantly on a structurally-impossible expression (e.g. Feb 30,
+  // Apr 31) BEFORE the walk. For an explicit IANA zone the walk would
+  // otherwise advance minute-by-minute through the full 366-day cap (~527k
+  // `Intl.formatToParts` calls, ~2s of blocked event loop) just to return
+  // null — a self-inflicted DoS one typo'd skill could trigger every time its
+  // baseline changes. This check is calendar-fact-only, so it is correct in
+  // any zone.
+  if (isStructurallyImpossible(cron)) return null;
+  // Start at after + 1 minute, zero seconds.
+  const start = new Date(after.getTime() + 60_000);
+  start.setSeconds(0, 0);
+  const limit = new Date(start.getTime() + 366 * 24 * 60 * 60_000);
+
+  // The field-by-field jump helpers mutate the cursor with system-local
+  // `Date` methods, so they are only correct when matching is also done in
+  // the host's local zone. For an explicit (non-local) IANA zone we walk
+  // minute-by-minute on the absolute instant instead — slower, but advancing
+  // the cursor by a fixed 60_000 ms is zone-independent, whereas the local
+  // setHours/setDate jumps would land on the wrong wall-clock instant in the
+  // target zone (off-by-offset / DST errors). The 1-year cap still bounds it.
+  const explicitZone = !!timeZone && timeZone !== 'local';
+
+  const cursor = new Date(start);
+  while (cursor <= limit) {
+    const parts = decomposeInZone(cursor, timeZone);
+    if (!cron.month.values.has(parts.month)) {
+      if (explicitZone) {
+        cursor.setTime(cursor.getTime() + 60_000);
+      } else {
+        // Jump to the first day of the next candidate month.
+        jumpToNextMonth(cursor, parts, cron.month.values, timeZone);
+      }
+      continue;
+    }
+    const domOk = cron.dom.values.has(parts.dom);
+    const dowOk = cron.dow.values.has(parts.dow);
+    // Vixie-cron OR semantics when both DOM and DOW are restricted.
+    const dayMatches = cron.dom.restricted && cron.dow.restricted
+      ? domOk || dowOk
+      : domOk && dowOk;
+    if (!dayMatches) {
+      if (explicitZone) cursor.setTime(cursor.getTime() + 60_000);
+      else jumpToNextDay(cursor, timeZone);
+      continue;
+    }
+    if (!cron.hour.values.has(parts.hour)) {
+      if (explicitZone) cursor.setTime(cursor.getTime() + 60_000);
+      else jumpToNextHour(cursor, timeZone);
+      continue;
+    }
+    if (!cron.minute.values.has(parts.minute)) {
+      if (explicitZone) cursor.setTime(cursor.getTime() + 60_000);
+      else cursor.setMinutes(cursor.getMinutes() + 1, 0, 0);
+      continue;
+    }
+    return new Date(cursor.getTime());
+  }
+  return null;
+}
+
+interface DateParts {
+  readonly year: number;
+  readonly month: number; // 1-12
+  readonly dom: number; // 1-31
+  readonly dow: number; // 0=Sunday
+  readonly hour: number;
+  readonly minute: number;
+}
+
+// Memoized Intl.DateTimeFormat per IANA zone. Formatters are stateless, so
+// caching them across the (potentially long) minute-walk avoids re-allocating
+// one on every cursor step for explicit-zone crons.
+const formatterCache = new Map<string, Intl.DateTimeFormat>();
+
+function formatterFor(timeZone: string): Intl.DateTimeFormat {
+  let fmt = formatterCache.get(timeZone);
+  if (!fmt) {
+    fmt = new Intl.DateTimeFormat('en-US', {
+      timeZone,
+      year: 'numeric',
+      month: '2-digit',
+      day: '2-digit',
+      weekday: 'short',
+      hour: '2-digit',
+      minute: '2-digit',
+      hour12: false,
+    });
+    formatterCache.set(timeZone, fmt);
+  }
+  return fmt;
+}
+
+function decomposeInZone(d: Date, timeZone?: string): DateParts {
+  // Local time decomposition. We deliberately default to system-local —
+  // a user saying "every day at 9 AM" overwhelmingly means their wall
+  // clock, not UTC. Callers that need UTC pass timeZone='UTC'.
+  if (!timeZone || timeZone === 'local') {
+    return {
+      year: d.getFullYear(),
+      month: d.getMonth() + 1,
+      dom: d.getDate(),
+      dow: d.getDay(),
+      hour: d.getHours(),
+      minute: d.getMinutes(),
+    };
+  }
+  // Intl-based decomposition for explicit zones. A formatter is stateless,
+  // so memoize one per IANA zone — `nextFireTime` can walk many minute steps
+  // for a sparse cron and was previously allocating a fresh formatter on each
+  // step. Correctness is unchanged; only the per-step allocation is removed.
+  const fmt = formatterFor(timeZone);
+  const parts: Record<string, string> = {};
+  for (const part of fmt.formatToParts(d)) parts[part.type] = part.value;
+  const weekdayMap: Record<string, number> = { Sun: 0, Mon: 1, Tue: 2, Wed: 3, Thu: 4, Fri: 5, Sat: 6 };
+  // The formatter is configured with `weekday: 'short'`, so formatToParts
+  // always emits a weekday part, so its presence is impossible by construction.
+  const weekday = parts.weekday;
+  assertDefined(weekday, 'formatToParts includes weekday (formatter sets weekday: short)');
+  return {
+    year: Number(parts.year),
+    month: Number(parts.month),
+    dom: Number(parts.day),
+    dow: weekdayMap[weekday] ?? 0,
+    hour: Number(parts.hour) % 24,
+    minute: Number(parts.minute),
+  };
+}
+
+function jumpToNextMonth(
+  cursor: Date,
+  current: DateParts,
+  validMonths: ReadonlySet<number>,
+  _timeZone?: string,
+): void {
+  // Find next valid month >= current+1; wraps to next year if needed.
+  let nextMonth = current.month + 1;
+  let yearDelta = 0;
+  while (!validMonths.has(((nextMonth - 1) % 12) + 1)) {
+    nextMonth += 1;
+    if (nextMonth > 24) {
+      // Pathological: walk hit a wall. Caller's outer loop will give up
+      // at the 1-year limit.
+      cursor.setFullYear(cursor.getFullYear() + 1);
+      return;
+    }
+  }
+  while (nextMonth > 12) {
+    nextMonth -= 12;
+    yearDelta += 1;
+  }
+  cursor.setFullYear(cursor.getFullYear() + yearDelta, nextMonth - 1, 1);
+  cursor.setHours(0, 0, 0, 0);
+}
+
+function jumpToNextDay(cursor: Date, _timeZone?: string): void {
+  cursor.setDate(cursor.getDate() + 1);
+  cursor.setHours(0, 0, 0, 0);
+}
+
+function jumpToNextHour(cursor: Date, _timeZone?: string): void {
+  cursor.setHours(cursor.getHours() + 1, 0, 0, 0);
+}

package/src/define.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import { z } from 'zod';
+import { z } from 'zod/v3';
 import {
   defineCompactor,
   defineMode,

package/src/define.ts

@@ -17,7 +17,7 @@ import type { SynthesizerDef } from './synthesizer.js';
 import type { ViewRendererDef } from './view-renderer.js';
 import type { TunnelProviderDef } from './tunnel.js';
 import type { WorkflowExecutorDef } from './workflow.js';
-import type { z } from 'zod';
+import type { z } from 'zod/v3';
 
 export function definePlugin(spec: PluginSpec): Plugin {
   // Spread spec first so the defaults below can't be clobbered by an
@@ -52,6 +52,7 @@ export function defineTool<S extends z.ZodTypeAny, O = unknown>(spec: {
   liveState?: boolean;
   alwaysLoaded?: boolean;
   modes?: ReadonlyArray<string>;
+  notInModes?: ReadonlyArray<string>;
   refusalEndsTurn?: string;
 }): ToolDef {
   return Object.freeze({
@@ -70,6 +71,7 @@ export function defineTool<S extends z.ZodTypeAny, O = unknown>(spec: {
     ...(spec.alwaysLoaded ? { alwaysLoaded: true } : {}),
     ...(spec.refusalEndsTurn !== undefined ? { refusalEndsTurn: spec.refusalEndsTurn } : {}),
     ...(spec.modes ? { modes: Object.freeze([...spec.modes]) } : {}),
+    ...(spec.notInModes ? { notInModes: Object.freeze([...spec.notInModes]) } : {}),
   });
 }
 

package/src/event-store.ts

@@ -19,6 +19,7 @@ export const SESSION_SOURCES = [
   'cli',
   'tui',
   'desktop',
+  // The mobile app was removed; kept so sessions it recorded still read back.
   'mobile',
   'slack',
   'telegram',
@@ -34,7 +35,7 @@ export type SessionSource = (typeof SESSION_SOURCES)[number];
 /**
  * The single per-session metadata record (the JSONL impl writes it to
  * `~/.moxxy/sessions/<id>.json`). ONE per session — the unit every surface
- * (TUI/desktop/mobile) lists, searches and caches; the conversation itself is
+ * (TUI/desktop) lists, searches and caches; the conversation itself is
  * the append-only event stream. Fields split by owner: the runner owns the
  * content fields (`firstPrompt`/`eventCount`/`lastActivity`/`provider`/`model`/
  * `startedAt`/`source`); the UI owns `title` (rename) and `groupId` (desk).

package/src/events.ts

@@ -48,6 +48,12 @@ export interface UserPromptAttachment {
   readonly name?: string;
   /** MIME type — required for `image`, `document`, and raw `audio` so providers translate correctly. */
   readonly mediaType?: string;
+  /**
+   * Set only on a client's copy of the event: the payload was too large to send
+   * to clients, so `content` is empty and this is the real size in bytes. The
+   * bytes stay in the runner's log; `session.readAttachment` reads them back.
+   */
+  readonly omittedBytes?: number;
 }
 
 /**
@@ -68,11 +74,19 @@ export interface UserPromptAttachment {
  * `kind: 'voice'` marks the voice conversation (GPT-Live) held while an agent
  * turn ran and recorded after it as one transcript: context for later turns,
  * not a request, and shown as one collapsed block.
+ *
+ * `kind: 'agent'` opens a turn the vendor's agent of an agent connection
+ * started by itself (Claude after a task it ran in the background finished),
+ * or one Moxxy opened to show work the agent left running ending (Codex's
+ * helper or background command); `name` says what it took up. Nothing is
+ * sent to the agent for it.
  */
 export interface TriggerOrigin {
-  readonly kind: 'webhook' | 'schedule' | 'workflow' | 'checkpoint' | 'voice';
+  readonly kind: 'webhook' | 'schedule' | 'workflow' | 'checkpoint' | 'voice' | 'agent';
   /** The trigger's name (webhook/schedule/workflow/checkpoint), for the marker label. */
   readonly name: string;
+  /** `agent`: the background work whose end the agent took up (`AgentBackgroundWork.id`), when it says. */
+  readonly workId?: string;
 }
 
 export interface UserPromptEvent extends EventBase {
@@ -141,6 +155,8 @@ export interface ToolCallRequestedEvent extends EventBase {
   readonly name: string;
   readonly input: unknown;
   readonly skillContext?: SkillId;
+  /** Set when the provider's own agent ran the tool (an agent connection), not Moxxy. */
+  readonly executedBy?: 'provider';
 }
 
 export interface ToolCallApprovedEvent extends EventBase {
@@ -303,6 +319,12 @@ export interface ProviderResponseEvent extends EventBase {
   readonly outputTokens?: number;
   readonly cacheReadTokens?: number;
   readonly cacheCreationTokens?: number;
+  /**
+   * How many tokens the model's context holds after this response, when the usage
+   * above is not that: an agent connection reports one response per turn whose usage
+   * adds up every call the agent made.
+   */
+  readonly contextTokens?: number;
   readonly timing?: ProviderCallTiming;
 }
 

package/src/file-diff.test.ts

@@ -0,0 +1,103 @@
+/** A file change shown as a diff, whether Moxxy made it or an agent reported its own. */
+import { describe, expect, it } from 'vitest';
+import { diffPathIn, fileDiffFromPatch, fileDiffFromText, parseUnifiedDiff } from './file-diff.js';
+
+describe('a diff from the text before and after', () => {
+  it('shows the changed lines with two lines of context and their numbers', () => {
+    const d = fileDiffFromText({ path: 'a.ts', mode: 'update', before: 'a\nb\nc\nd\ne\nf\ng', after: 'a\nb\nc\nX\ne\nf\ng' });
+
+    expect(d).toMatchObject({ kind: 'file-diff', path: 'a.ts', mode: 'update', added: 1, removed: 1 });
+    expect(d.hunks).toHaveLength(1);
+    expect(d.hunks[0]?.lines).toEqual([
+      { kind: 'context', text: 'b', oldNo: 2, newNo: 2 },
+      { kind: 'context', text: 'c', oldNo: 3, newNo: 3 },
+      { kind: 'del', text: 'd', oldNo: 4 },
+      { kind: 'add', text: 'X', newNo: 4 },
+      { kind: 'context', text: 'e', oldNo: 5, newNo: 5 },
+      { kind: 'context', text: 'f', oldNo: 6, newNo: 6 },
+    ]);
+  });
+
+  it('shows a new file as all added', () => {
+    const d = fileDiffFromText({ path: 'new.ts', mode: 'create', before: '', after: 'one\ntwo\n' });
+
+    expect(d).toMatchObject({ mode: 'create', added: 2, removed: 0 });
+    expect(d.hunks[0]?.lines.map((line) => line.kind)).toEqual(['add', 'add']);
+  });
+});
+
+describe('a diff from patch hunks an agent reports', () => {
+  it('numbers the lines of each hunk from where it starts', () => {
+    const d = fileDiffFromPatch({
+      path: 'src/db.ts',
+      mode: 'update',
+      hunks: [{ oldStart: 10, newStart: 10, lines: [' const host = "x";', '-const port = 5432;', '+const port = 5433;', '+const pool = 4;'] }],
+    });
+
+    expect(d).toMatchObject({ added: 2, removed: 1 });
+    expect(d.hunks).toEqual([
+      {
+        oldStart: 10,
+        oldLines: 2,
+        newStart: 10,
+        newLines: 3,
+        lines: [
+          { kind: 'context', text: 'const host = "x";', oldNo: 10, newNo: 10 },
+          { kind: 'del', text: 'const port = 5432;', oldNo: 11 },
+          { kind: 'add', text: 'const port = 5433;', newNo: 11 },
+          { kind: 'add', text: 'const pool = 4;', newNo: 12 },
+        ],
+      },
+    ]);
+  });
+
+  it('skips the "no newline at end of file" marker', () => {
+    const d = fileDiffFromPatch({ path: 'a', mode: 'update', hunks: [{ oldStart: 1, newStart: 1, lines: ['-a', '\', '+b'] }] });
+
+    expect(d.hunks[0]?.lines.map((line) => line.text)).toEqual(['a', 'b']);
+  });
+
+  it('caps what it shows on a huge patch but counts every line', () => {
+    const lines = Array.from({ length: 1_000 }, (_, i) => `+line ${i}`);
+    const d = fileDiffFromPatch({ path: 'big', mode: 'create', hunks: [{ oldStart: 0, newStart: 1, lines }] });
+
+    expect(d.added).toBe(1_000);
+    expect(d.truncated).toBe(true);
+    expect(d.hunks[0]?.lines.length).toBeLessThan(1_000);
+  });
+});
+
+describe('reading a unified diff', () => {
+  it('reads each hunk and leaves out the file headers', () => {
+    const text = '--- a/x.ts\n+++ b/x.ts\n@@ -1 +1,2 @@\n-old\n+new\n+more\n@@ -20,3 +21,3 @@ function f() {\n a\n-b\n+c\n d\n';
+
+    expect(parseUnifiedDiff(text)).toEqual([
+      { oldStart: 1, newStart: 1, lines: ['-old', '+new', '+more'] },
+      { oldStart: 20, newStart: 21, lines: [' a', '-b', '+c', ' d'] },
+    ]);
+  });
+
+  it('finds no hunks in text that is not a diff', () => {
+    expect(parseUnifiedDiff('just some file content')).toEqual([]);
+  });
+});
+
+describe('the path a diff shows', () => {
+  it('is relative to the project folder when the file is inside it', () => {
+    expect(diffPathIn('/repo', '/repo/src/a.ts')).toBe('src/a.ts');
+    expect(diffPathIn('C:\\repo', 'C:\\repo\\src\\a.ts')).toBe('src\\a.ts');
+  });
+
+  it('stays as given outside the project folder', () => {
+    expect(diffPathIn('/repo', '/repository/a.ts')).toBe('/repository/a.ts');
+    expect(diffPathIn('/repo', 'src/a.ts')).toBe('src/a.ts');
+  });
+  it('ignores trailing separators on the project folder, in time linear in its length', () => {
+    expect(diffPathIn('/repo//', '/repo/src/a.ts')).toBe('src/a.ts');
+    expect(diffPathIn('C:\\repo\\', 'C:\\repo\\a.ts')).toBe('a.ts');
+
+    const started = performance.now();
+    diffPathIn(`${'/'.repeat(100_000)}x`, '/a.ts');
+    expect(performance.now() - started).toBeLessThan(500);
+  });
+});