@delacour/react-native-charts 0.1.0-alpha.4

package/src/core/ticks/tick-count.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, test } from "bun:test";
+import { downsampleTicks, normalizeTickCount } from "./tick-count";
+
+describe("downsampleTicks", () => {
+	test("returns the input untouched when it already fits", () => {
+		expect(downsampleTicks([1, 2, 3], 5)).toEqual([1, 2, 3]);
+	});
+
+	test("keeps both ends when thinning", () => {
+		const thinned = downsampleTicks([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], 4);
+		expect(thinned).toHaveLength(4);
+		expect(thinned[0]).toBe(0);
+		expect(thinned.at(-1)).toBe(9);
+	});
+
+	test("degenerates safely", () => {
+		expect(downsampleTicks([1, 2, 3], 0)).toEqual([]);
+		expect(downsampleTicks([1, 2, 3], 1)).toEqual([1]);
+		expect(downsampleTicks([], 5)).toEqual([]);
+	});
+
+	test("does not alias the input array", () => {
+		const source = [1, 2, 3];
+		expect(downsampleTicks(source, 5)).not.toBe(source);
+	});
+});
+
+describe("normalizeTickCount", () => {
+	test("spreads exactly count values across the domain", () => {
+		expect(normalizeTickCount([0, 100], 5)).toEqual([0, 25, 50, 75, 100]);
+	});
+
+	test("puts a secondary axis' gridlines on the primary's", () => {
+		// The point of the function: same count, same fractions, same pixels.
+		const primary = normalizeTickCount([0, 100], 6);
+		const secondary = normalizeTickCount([-3, 12], 6);
+		expect(secondary).toHaveLength(primary.length);
+		const fractionOf = (values: number[], lo: number, hi: number) => values.map((v) => (v - lo) / (hi - lo));
+		expect(fractionOf(secondary, -3, 12)).toEqual(fractionOf(primary, 0, 100));
+	});
+
+	test("degenerates safely", () => {
+		expect(normalizeTickCount([0, 100], 0)).toEqual([]);
+		expect(normalizeTickCount([4, 9], 1)).toEqual([4]);
+	});
+});

package/src/core/ticks/tick-count.ts

@@ -0,0 +1,35 @@
+import type { DomainTuple } from "../scale/scale.types";
+
+export const DEFAULT_TICK_COUNT = 5;
+
+/**
+ * At most `count` of `values`, evenly sampled, keeping both ends.
+ *
+ * For when the tick values are given rather than generated — a caller's
+ * explicit `tickValues`, or a categorical axis with one tick per datum that
+ * would otherwise overprint itself.
+ */
+export function downsampleTicks(values: readonly number[], count: number): number[] {
+	if (count <= 0) return [];
+	if (values.length <= count) return [...values];
+	if (count === 1) return [values[0] as number];
+
+	const last = values.length - 1;
+	return Array.from({ length: count }, (_, index) => values[Math.round((index * last) / (count - 1))] as number);
+}
+
+/**
+ * Exactly `count` values spread evenly across `domain`.
+ *
+ * Two y axes drawing their own round numbers produce two sets of gridlines at
+ * different heights, and the chart reads as two charts overlaid. Giving the
+ * secondary axis the primary's count puts every line in the same place, at the
+ * cost of the secondary's labels no longer being round — which is the right
+ * trade, because a gridline is structural and a label is not.
+ */
+export function normalizeTickCount(domain: DomainTuple, count: number): number[] {
+	if (count <= 0) return [];
+	if (count === 1) return [domain[0]];
+	const span = domain[1] - domain[0];
+	return Array.from({ length: count }, (_, index) => domain[0] + (span * index) / (count - 1));
+}

package/src/core/ticks/tick.types.ts

@@ -0,0 +1,7 @@
+/** One axis tick: what it means, and where it sits. */
+export type ChartTick = {
+	/** The domain value. Epoch milliseconds on a time scale. */
+	readonly value: number;
+	/** Canvas position in points, already through the scale. */
+	readonly position: number;
+};

package/src/core/ticks/time-ticks.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, test } from "bun:test";
+import { timeTicks } from "./time-ticks";
+
+const DAY = 86_400_000;
+
+describe("timeTicks", () => {
+	test("lands on local midnight across a week", () => {
+		const start = new Date(2026, 0, 1).getTime();
+		const ticks = timeTicks([start, start + 7 * DAY], 7);
+		expect(ticks.length).toBeGreaterThan(0);
+		for (const tick of ticks) {
+			const date = new Date(tick);
+			expect(date.getHours()).toBe(0);
+			expect(date.getMinutes()).toBe(0);
+			expect(date.getSeconds()).toBe(0);
+		}
+	});
+
+	test("lands on the first of the month across a year", () => {
+		const start = new Date(2026, 0, 1).getTime();
+		const end = new Date(2027, 0, 1).getTime();
+		for (const tick of timeTicks([start, end], 12)) {
+			expect(new Date(tick).getDate()).toBe(1);
+		}
+	});
+
+	test("keeps midnight across a DST transition", () => {
+		// New Zealand leaves DST on 2026-04-05 and enters it on 2026-09-27. A
+		// ladder snapping on epoch multiples would put every tick an hour off
+		// midnight on one side of each boundary; d3-time uses calendar
+		// arithmetic and does not.
+		const previous = process.env.TZ;
+		process.env.TZ = "Pacific/Auckland";
+		try {
+			for (const [year, month, day] of [
+				[2026, 2, 30],
+				[2026, 8, 21],
+			] as const) {
+				const start = new Date(year, month, day).getTime();
+				const ticks = timeTicks([start, start + 14 * DAY], 14);
+				expect(ticks.length).toBeGreaterThan(0);
+				for (const tick of ticks) expect(new Date(tick).getHours()).toBe(0);
+			}
+		} finally {
+			process.env.TZ = previous;
+		}
+	});
+
+	test("stays inside the hour on a sub-day span", () => {
+		const start = new Date(2026, 0, 1, 9, 0, 0).getTime();
+		const ticks = timeTicks([start, start + 6 * 3_600_000], 6);
+		expect(ticks.length).toBeGreaterThan(0);
+		for (const tick of ticks) expect(new Date(tick).getMinutes() % 15).toBe(0);
+	});
+
+	test("degenerates safely", () => {
+		expect(timeTicks([0, DAY], 0)).toEqual([]);
+		expect(timeTicks([5, 5], 4)).toEqual([5]);
+		expect(timeTicks([Number.NaN, DAY], 4)).toEqual([]);
+	});
+});

package/src/core/ticks/time-ticks.ts

@@ -0,0 +1,22 @@
+import { scaleTime } from "d3-scale";
+import type { DomainTuple } from "../scale/scale.types";
+
+/**
+ * Tick values across a time domain, as epoch milliseconds.
+ *
+ * This delegates to `scaleTime` rather than walking a fixed interval ladder,
+ * and that is the single biggest thing `d3-scale` buys this package. Local
+ * calendar boundaries are not evenly spaced: a DST spring-forward day is 23
+ * hours, months are four different lengths, and a hand-rolled ladder that
+ * snaps on epoch multiples puts every tick an hour off midnight for half the
+ * year. d3-time already knows all of it.
+ */
+export function timeTicks(domain: DomainTuple, count: number): number[] {
+	if (count <= 0) return [];
+	if (!Number.isFinite(domain[0]) || !Number.isFinite(domain[1])) return [];
+	if (domain[0] === domain[1]) return [domain[0]];
+	return scaleTime()
+		.domain([new Date(domain[0]), new Date(domain[1])])
+		.ticks(Math.max(1, Math.round(count)))
+		.map((date) => date.getTime());
+}

package/src/core/util/as-number.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, test } from "bun:test";
+import { asNumber, isPlottable } from "./as-number";
+
+describe("asNumber", () => {
+	test("passes a number through, including zero and negatives", () => {
+		expect(asNumber(0)).toBe(0);
+		expect(asNumber(-12.5)).toBe(-12.5);
+	});
+
+	test("reads a Date as epoch milliseconds", () => {
+		expect(asNumber(new Date(1_700_000_000_000))).toBe(1_700_000_000_000);
+	});
+
+	test("parses a numeric string", () => {
+		expect(asNumber("42")).toBe(42);
+		expect(asNumber(" -3.5 ")).toBe(-3.5);
+	});
+
+	test("returns NaN for a label rather than throwing", () => {
+		expect(asNumber("January")).toBeNaN();
+		expect(asNumber(null)).toBeNaN();
+		expect(asNumber(undefined)).toBeNaN();
+		expect(asNumber({})).toBeNaN();
+		expect(asNumber("")).toBeNaN();
+		expect(asNumber("   ")).toBeNaN();
+	});
+
+	test("keeps an already-NaN number NaN", () => {
+		expect(asNumber(Number.NaN)).toBeNaN();
+	});
+});
+
+describe("isPlottable", () => {
+	test("accepts finite numbers only", () => {
+		expect(isPlottable(0)).toBe(true);
+		expect(isPlottable(-1)).toBe(true);
+	});
+
+	test("rejects the gap marker and every non-finite number", () => {
+		expect(isPlottable(null)).toBe(false);
+		expect(isPlottable(undefined)).toBe(false);
+		expect(isPlottable(Number.NaN)).toBe(false);
+		expect(isPlottable(Number.POSITIVE_INFINITY)).toBe(false);
+	});
+});

package/src/core/util/as-number.ts

@@ -0,0 +1,22 @@
+/**
+ * A value as a number, or `NaN` when it is not one.
+ *
+ * A chart's x field is routinely a `Date` or a string label rather than a
+ * number. A `Date` is its epoch milliseconds; a numeric string is that number;
+ * anything else is `NaN`, and the caller substitutes the datum's index.
+ *
+ * It returns `NaN` rather than throwing on purpose. One unparseable row in a
+ * thousand should leave a gap in the line, not blank the whole chart.
+ */
+export function asNumber(value: unknown): number {
+	if (typeof value === "number") return value;
+	if (value instanceof Date) return value.getTime();
+	if (typeof value === "string" && value.trim() !== "") return Number(value);
+	if (typeof value === "boolean") return value ? 1 : 0;
+	return Number.NaN;
+}
+
+/** Whether a value can be drawn — finite, and not the `null` that marks a gap. */
+export function isPlottable(value: number | null | undefined): value is number {
+	return typeof value === "number" && Number.isFinite(value);
+}

package/src/core/util/clamp.test.ts

@@ -0,0 +1,21 @@
+import { describe, expect, test } from "bun:test";
+import { clamp } from "./clamp";
+
+describe("clamp", () => {
+	test("holds a value inside the bounds", () => {
+		expect(clamp(5, 0, 10)).toBe(5);
+		expect(clamp(-1, 0, 10)).toBe(0);
+		expect(clamp(11, 0, 10)).toBe(10);
+	});
+
+	test("returns the bound when the range is a point", () => {
+		expect(clamp(5, 3, 3)).toBe(3);
+	});
+
+	test("passes the value through when the bounds are inverted", () => {
+		// A plot rect measured before layout can produce max < min. Returning the
+		// input keeps a finite number flowing; pinning to either bound would put
+		// a mark at an edge it was never near.
+		expect(clamp(5, 10, 0)).toBe(5);
+	});
+});

package/src/core/util/clamp.ts

@@ -0,0 +1,16 @@
+/**
+ * `value` held inside `[min, max]`.
+ *
+ * Flat worklet: it calls nothing and closes over nothing, so it is safe to
+ * reference from a gesture callback on the UI thread. See the package
+ * AGENTS.md — a module-scope worklet that calls another module-scope worklet
+ * binds at import time in source order, and the UI thread gets
+ * `undefined is not a function`.
+ */
+export function clamp(value: number, min: number, max: number): number {
+	"worklet";
+	if (min > max) return value;
+	if (value < min) return min;
+	if (value > max) return max;
+	return value;
+}

package/src/core/util/extent.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, test } from "bun:test";
+import { extent, unionExtents } from "./extent";
+
+describe("extent", () => {
+	test("finds min and max", () => {
+		expect(extent([3, 1, 4, 1, 5])).toEqual([1, 5]);
+	});
+
+	test("skips gaps and non-finite values", () => {
+		expect(extent([3, null, 1, undefined, Number.NaN, Number.POSITIVE_INFINITY, 5])).toEqual([1, 5]);
+	});
+
+	test("returns null for nothing plottable, distinguishing it from all-zero", () => {
+		expect(extent([])).toBeNull();
+		expect(extent([null, undefined, Number.NaN])).toBeNull();
+		expect(extent([0, 0, 0])).toEqual([0, 0]);
+	});
+
+	test("collapses a single point to a zero-width extent", () => {
+		expect(extent([7])).toEqual([7, 7]);
+	});
+});
+
+describe("unionExtents", () => {
+	test("spans every series", () => {
+		expect(unionExtents([[1, 4], [-2, 3], null])).toEqual([-2, 4]);
+	});
+
+	test("returns null when every series is empty", () => {
+		expect(unionExtents([null, null])).toBeNull();
+		expect(unionExtents([])).toBeNull();
+	});
+});

package/src/core/util/extent.ts

@@ -0,0 +1,37 @@
+/**
+ * The `[min, max]` of everything finite in `values`, or `null` when nothing is.
+ *
+ * `null` rather than `[0, 0]` because an empty series and a series that is
+ * genuinely all zeroes need different domains, and collapsing them here would
+ * make that impossible to tell apart later.
+ */
+export function extent(values: Iterable<number | null | undefined>): readonly [number, number] | null {
+	let min = Number.POSITIVE_INFINITY;
+	let max = Number.NEGATIVE_INFINITY;
+	let seen = false;
+
+	for (const value of values) {
+		if (typeof value !== "number" || !Number.isFinite(value)) continue;
+		seen = true;
+		if (value < min) min = value;
+		if (value > max) max = value;
+	}
+
+	return seen ? [min, max] : null;
+}
+
+/** The union of several extents, skipping the empty ones. */
+export function unionExtents(extents: Iterable<readonly [number, number] | null>): readonly [number, number] | null {
+	let min = Number.POSITIVE_INFINITY;
+	let max = Number.NEGATIVE_INFINITY;
+	let seen = false;
+
+	for (const current of extents) {
+		if (current === null) continue;
+		seen = true;
+		if (current[0] < min) min = current[0];
+		if (current[1] > max) max = current[1];
+	}
+
+	return seen ? [min, max] : null;
+}

package/src/core/util/read-at.test.ts

@@ -0,0 +1,14 @@
+import { describe, expect, test } from "bun:test";
+import { readAt } from "./read-at";
+
+describe("readAt", () => {
+	test("reads a number", () => {
+		expect(readAt([1, 2, 3], 1)).toBe(2);
+	});
+
+	test("a null, a missing index and the -1 of no datum all read as NaN", () => {
+		expect(Number.isNaN(readAt([1, null, 3], 1))).toBe(true);
+		expect(Number.isNaN(readAt([1, 2, 3], 7))).toBe(true);
+		expect(Number.isNaN(readAt([1, 2, 3], -1))).toBe(true);
+	});
+});

package/src/core/util/read-at.ts

@@ -0,0 +1,14 @@
+/**
+ * `list[index]` as a number, with a null, a missing index or the `-1` that
+ * means "no datum" all reading as `NaN`.
+ *
+ * Flat worklet: it calls nothing and closes over nothing, so the scrub can
+ * read a series on the UI thread without a branch per field. `NaN` rather
+ * than a throw because a shared value that is never written is a dot parked
+ * off-screen, and a worklet that throws is a chart that stops responding.
+ */
+export function readAt(list: readonly (number | null)[], index: number): number {
+	"worklet";
+	const value = list[index];
+	return value === null || value === undefined ? Number.NaN : value;
+}

package/src/core/util/sided-number.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, test } from "bun:test";
+import { sidesOf, valueFromSidedNumber } from "./sided-number";
+
+describe("valueFromSidedNumber", () => {
+	test("spreads a bare number to every side", () => {
+		expect(valueFromSidedNumber(8, "top")).toBe(8);
+		expect(valueFromSidedNumber(8, "left")).toBe(8);
+	});
+
+	test("reads one side of an object and defaults the rest to zero", () => {
+		expect(valueFromSidedNumber({ left: 40 }, "left")).toBe(40);
+		expect(valueFromSidedNumber({ left: 40 }, "right")).toBe(0);
+	});
+
+	test("treats undefined and non-finite as zero", () => {
+		expect(valueFromSidedNumber(undefined, "top")).toBe(0);
+		expect(valueFromSidedNumber(Number.NaN, "top")).toBe(0);
+		expect(valueFromSidedNumber({ top: Number.POSITIVE_INFINITY }, "top")).toBe(0);
+	});
+});
+
+describe("sidesOf", () => {
+	test("returns all four", () => {
+		expect(sidesOf({ top: 1, right: 2, bottom: 3, left: 4 })).toEqual({ top: 1, right: 2, bottom: 3, left: 4 });
+		expect(sidesOf(5)).toEqual({ top: 5, right: 5, bottom: 5, left: 5 });
+		expect(sidesOf(undefined)).toEqual({ top: 0, right: 0, bottom: 0, left: 0 });
+	});
+});

package/src/core/util/sided-number.ts

@@ -0,0 +1,34 @@
+/** A number for every side, or one number for all four. */
+export type SidedNumber =
+	| number
+	| {
+			readonly top?: number;
+			readonly right?: number;
+			readonly bottom?: number;
+			readonly left?: number;
+	  };
+
+export type Side = "top" | "right" | "bottom" | "left";
+
+/** One side's value, defaulting to zero. */
+export function valueFromSidedNumber(value: SidedNumber | undefined, side: Side): number {
+	if (value === undefined) return 0;
+	if (typeof value === "number") return Number.isFinite(value) ? value : 0;
+	const side_ = value[side];
+	return typeof side_ === "number" && Number.isFinite(side_) ? side_ : 0;
+}
+
+/** All four sides at once, in `top right bottom left` order. */
+export function sidesOf(value: SidedNumber | undefined): {
+	readonly top: number;
+	readonly right: number;
+	readonly bottom: number;
+	readonly left: number;
+} {
+	return {
+		top: valueFromSidedNumber(value, "top"),
+		right: valueFromSidedNumber(value, "right"),
+		bottom: valueFromSidedNumber(value, "bottom"),
+		left: valueFromSidedNumber(value, "left"),
+	};
+}

package/src/docs.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, test } from "bun:test";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { PACKAGE_ROOT, SRC, sourceFiles } from "./source-tree.test";
+
+/**
+ * Documentation is part of the change.
+ *
+ * `@delacour/react-native-ui` grew this test because `Radio` shipped undocumented
+ * and nothing caught it for fifteen commits. The same applies here, scoped to
+ * the top-level folders rather than every nested one — a doc per directory of
+ * four utility modules is noise, a doc per subsystem is not.
+ */
+describe("docs", () => {
+	const folders = readdirSync(SRC)
+		.map((entry) => join(SRC, entry))
+		.filter((path) => statSync(path).isDirectory())
+		.filter((path) => sourceFiles(path, { skipTests: true }).length > 0);
+
+	test("the package documents itself", () => {
+		const doc = join(PACKAGE_ROOT, "AGENTS.md");
+		expect(existsSync(doc)).toBe(true);
+		expect(readFileSync(doc, "utf8").split("\n").length).toBeGreaterThan(20);
+	});
+
+	test("finds the subsystems, so a broken walker cannot pass silently", () => {
+		expect(folders.length).toBeGreaterThan(0);
+	});
+
+	test("every subsystem has an AGENTS.md that is not a stub", () => {
+		const missing: string[] = [];
+		for (const folder of folders) {
+			const doc = join(folder, "AGENTS.md");
+			if (!existsSync(doc)) {
+				missing.push(`${folder.slice(SRC.length + 1)} has no AGENTS.md`);
+				continue;
+			}
+			const content = readFileSync(doc, "utf8");
+			if (!content.startsWith("# ") || content.split("\n").length < 10) {
+				missing.push(`${folder.slice(SRC.length + 1)}/AGENTS.md is a stub`);
+			}
+		}
+		expect(missing).toEqual([]);
+	});
+});

package/src/flat-worklet.test.ts

@@ -0,0 +1,130 @@
+import { describe, expect, test } from "bun:test";
+import { read, relative, SRC, sourceFiles } from "./source-tree.test";
+
+/**
+ * The flat-worklet rule.
+ *
+ * **A worklet declared at module scope may close over module-scope constants
+ * but never over another function, imported or local.** Any helper it needs is
+ * declared inside its own body.
+ *
+ * Module scope is the whole rule. A module-scope worklet that calls another
+ * module-scope worklet binds at import time in source order, and the UI thread
+ * gets `undefined is not a function` — at the moment a finger touches the
+ * chart, on a device, with a stack that names neither function. Four
+ * components in `@delacour/react-native-ui` document having learned this.
+ *
+ * A worklet created *inside* a hook is captured by ordinary closure and may
+ * call whatever it likes, including the module-scope worklets here. That is
+ * how the gesture layer composes `closestIndex` and `getYForX` without
+ * duplicating sixty lines of solver.
+ */
+
+/** Members of these are always safe — they exist in every worklet runtime. */
+const GLOBAL_NAMESPACES = ["Math", "Number", "Array", "Object", "String", "JSON", "Boolean", "Date"];
+
+/** Control-flow keywords that look like calls to a regex. */
+const KEYWORDS = new Set(["if", "for", "while", "switch", "catch", "return", "typeof", "function", "new"]);
+
+/** The body of the block opening at `open`, by brace matching. */
+function blockAt(source: string, open: number): string {
+	let depth = 0;
+	for (let index = open; index < source.length; index += 1) {
+		const char = source[index];
+		if (char === "{") depth += 1;
+		else if (char === "}") {
+			depth -= 1;
+			if (depth === 0) return source.slice(open + 1, index);
+		}
+	}
+	return source.slice(open + 1);
+}
+
+/** Bodies of every column-zero `function` whose first statement is the directive. */
+function moduleScopeWorklets(source: string): { readonly name: string; readonly body: string }[] {
+	const found: { name: string; body: string }[] = [];
+	const declaration = /^(?:export\s+)?function\s+(\w+)/gm;
+
+	for (let match = declaration.exec(source); match !== null; match = declaration.exec(source)) {
+		const open = source.indexOf("{", match.index);
+		if (open === -1) continue;
+		const body = blockAt(source, open);
+		if (!body.trimStart().startsWith('"worklet";')) continue;
+		found.push({ name: match[1] as string, body });
+	}
+
+	return found;
+}
+
+/** Value names this module imports — the ones a module-scope worklet must not call. */
+function importedValues(source: string): Set<string> {
+	const names = new Set<string>();
+	const pattern = /^\s*import\s+([\s\S]*?)\s*from\s*["'][^"']+["']/gm;
+	for (let match = pattern.exec(source); match !== null; match = pattern.exec(source)) {
+		const clause = (match[1] as string).trim();
+		if (clause.startsWith("type ")) continue;
+		const named = clause.match(/\{([\s\S]*)\}/);
+		if (named) {
+			for (const raw of (named[1] as string).split(",")) {
+				const specifier = raw.trim();
+				if (specifier === "" || specifier.startsWith("type ")) continue;
+				names.add((specifier.split(/\s+as\s+/).pop() as string).trim());
+			}
+		}
+		const bare = clause
+			.replace(/\{[\s\S]*\}/, "")
+			.replace(/,/g, "")
+			.trim();
+		if (bare !== "" && !bare.startsWith("*")) names.add(bare);
+	}
+	return names;
+}
+
+/** Functions declared at module scope — also off limits inside a module-scope worklet. */
+function functionNames(source: string): Set<string> {
+	const names = new Set<string>();
+	const patterns = [
+		/(?:^|\n)\s*(?:export\s+)?function\s+(\w+)/g,
+		/(?:^|\n)\s*(?:export\s+)?const\s+(\w+)\s*=\s*(?:\([^)]*\)|\w+)\s*(?::[^=]+)?=>/g,
+	];
+	for (const pattern of patterns) {
+		for (let match = pattern.exec(source); match !== null; match = pattern.exec(source)) {
+			names.add(match[1] as string);
+		}
+	}
+	return names;
+}
+
+describe("flat worklets", () => {
+	const files = sourceFiles(SRC, { skipTests: true });
+
+	test("finds the module-scope worklets, so a broken walker cannot pass silently", () => {
+		const total = files.reduce((count, file) => count + moduleScopeWorklets(read(file)).length, 0);
+		expect(total).toBeGreaterThan(3);
+	});
+
+	test("no module-scope worklet calls an imported or module-scope function", () => {
+		const offenders: string[] = [];
+
+		for (const file of files) {
+			const source = read(file);
+			if (!source.includes('"worklet";')) continue;
+			const forbidden = new Set([...importedValues(source), ...functionNames(source)]);
+
+			for (const worklet of moduleScopeWorklets(source)) {
+				const declaredInside = functionNames(worklet.body);
+				const calls = /(?:^|[^.\w$])(\w+)\s*\(/g;
+
+				for (let call = calls.exec(worklet.body); call !== null; call = calls.exec(worklet.body)) {
+					const name = call[1] as string;
+					if (KEYWORDS.has(name) || GLOBAL_NAMESPACES.includes(name)) continue;
+					if (declaredInside.has(name) || name === worklet.name) continue;
+					if (!forbidden.has(name)) continue;
+					offenders.push(`${relative(file)}: ${worklet.name}() calls ${name}()`);
+				}
+			}
+		}
+
+		expect(offenders).toEqual([]);
+	});
+});