@sveltesentio/core 0.1.0 → 0.2.1

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.2.1](https://github.com/golusoris/sveltesentio/compare/core-v0.2.0...core-v0.2.1) (2026-06-19)
+
+
+### Bug Fixes
+
+* **core:** restore eslint.config.ts + chart-a11y rule (prior commit's git add aborted) ([a978cf6](https://github.com/golusoris/sveltesentio/commit/a978cf6f4a362b1fb83eabdc426e6b04276607c3))
+
+## [0.2.0](https://github.com/golusoris/sveltesentio/compare/core-v0.1.0...core-v0.2.0) (2026-06-19)
+
+
+### Features
+
+* **core:** no-direct-time ESLint rule + bundle-size gate in sentioPlugin ([f3e223b](https://github.com/golusoris/sveltesentio/commit/f3e223b24cafdfae9646315e9ab64ea0899fd297))
+
 ## [0.1.0](https://github.com/golusoris/sveltesentio/compare/core-v0.0.1...core-v0.1.0) (2026-06-14)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltesentio/core",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Vite plugin, env schema, error types, id/clock utils — sveltesentio core",
   "type": "module",
   "private": false,
@@ -37,6 +37,10 @@
     "./vite": {
       "import": "./src/vite.ts",
       "types": "./src/vite.ts"
+    },
+    "./eslint": {
+      "import": "./src/eslint.ts",
+      "types": "./src/eslint.ts"
     }
   },
   "peerDependencies": {
@@ -54,15 +58,16 @@
     }
   },
   "devDependencies": {
-    "@sveltejs/kit": "^2.0.0",
-    "@types/node": "^24.0.0",
+    "@sveltejs/kit": "^2.65.2",
+    "@types/node": "^24.13.2",
     "esm-env": "^1.2.2",
     "openapi-fetch": "^0.17.0",
-    "svelte": "^5.55.4",
+    "svelte": "^5.56.3",
     "typescript": "^6.0.3",
-    "uuid": "^13.0.0",
-    "vitest": "^4.1.4",
-    "zod": "^4.3.6"
+    "uuid": "^14.0.0",
+    "vitest": "^4.1.9",
+    "zod": "^4.4.3",
+    "svelte-eslint-parser": "^1.8.0"
   },
   "keywords": [
     "sveltesentio",
@@ -80,6 +85,6 @@
     "build": "tsc",
     "lint": "eslint src/",
     "typecheck": "tsc --noEmit",
-    "test": "vitest run"
+    "test": "vitest run --coverage"
   }
 }

package/src/eslint.ts

@@ -0,0 +1,209 @@
+import type { Rule } from 'eslint';
+
+/**
+ * Flat-config ESLint plugin bundling sveltesentio's two cross-package
+ * invariants:
+ *
+ * - `no-direct-time` — time must flow through the injected {@link Clock}
+ *   (`useClock` / `getClock` from `@sveltesentio/core`) so it is deterministic
+ *   and testable (AGENTS.md §Invariants + docs/principles.md §2.1). Banned forms:
+ *   `Date.now()`, zero-argument `new Date()`, `performance.now()`.
+ * - `chart-a11y-wrapper` — every chart visual rendered from `layerchart` /
+ *   `uplot` must go through `@sveltesentio/charts`' `<ChartFigure>` so the WCAG
+ *   2.2 SC 1.1.1 text alternative cannot be skipped (charts/AGENTS.md §Invariants,
+ *   ADR-0013). A bare `<LineChart>` / `<Chart>` / uPlot element with no
+ *   `<ChartFigure>` ancestor is an error.
+ *
+ * Register in a flat `eslint.config.js`:
+ *
+ * ```js
+ * import sentio from '@sveltesentio/core/eslint';
+ * export default [
+ *   {
+ *     files: ['src/**\/*.ts'],
+ *     plugins: { '@sveltesentio': sentio },
+ *     rules: { '@sveltesentio/no-direct-time': 'error' },
+ *   },
+ *   {
+ *     files: ['src/**\/*.svelte'],
+ *     plugins: { '@sveltesentio': sentio },
+ *     rules: { '@sveltesentio/chart-a11y-wrapper': 'error' },
+ *   },
+ * ];
+ * ```
+ */
+
+// Pull the concrete AST node shapes from ESLint's own `Rule.Node` union so we
+// don't take a direct dependency on `@types/estree` (ESLint owns that peer).
+type Node = Rule.Node;
+type CallExpressionNode = Extract<Node, { type: 'CallExpression' }>;
+type NewExpressionNode = Extract<Node, { type: 'NewExpression' }>;
+type ImportDeclarationNode = Extract<Node, { type: 'ImportDeclaration' }>;
+type Callee = CallExpressionNode['callee'];
+
+const CLOCK_HINT =
+	'route time through the injected Clock — `useClock()`/`getClock()` ' +
+	'(or `testClock` in tests) from @sveltesentio/core — so it stays ' +
+	'deterministic and testable';
+
+/** Matches `<object>.<property>` where both are plain (non-computed) identifiers. */
+function isMemberCall(
+	callee: Callee,
+	objectName: string,
+	propertyName: string,
+): boolean {
+	if (callee.type !== 'MemberExpression') return false;
+	if (callee.computed) return false;
+	if (callee.property.type !== 'Identifier') return false;
+	if (callee.property.name !== propertyName) return false;
+	return (
+		callee.object.type === 'Identifier' && callee.object.name === objectName
+	);
+}
+
+const noDirectTime: Rule.RuleModule = {
+	meta: {
+		type: 'problem',
+		docs: {
+			description:
+				'disallow direct wall-clock / monotonic time reads; use the injected Clock',
+			recommended: true,
+		},
+		schema: [],
+		messages: {
+			dateNow: `Avoid \`Date.now()\` — ${CLOCK_HINT}.`,
+			newDate: `Avoid argument-less \`new Date()\` — ${CLOCK_HINT}.`,
+			performanceNow: `Avoid \`performance.now()\` — ${CLOCK_HINT}.`,
+		},
+	},
+
+	create(context: Rule.RuleContext): Rule.RuleListener {
+		return {
+			CallExpression(node: CallExpressionNode): void {
+				if (isMemberCall(node.callee, 'Date', 'now')) {
+					context.report({ node, messageId: 'dateNow' });
+					return;
+				}
+				if (isMemberCall(node.callee, 'performance', 'now')) {
+					context.report({ node, messageId: 'performanceNow' });
+				}
+			},
+
+			NewExpression(node: NewExpressionNode): void {
+				if (node.callee.type !== 'Identifier') return;
+				if (node.callee.name !== 'Date') return;
+				// `new Date(serverMs)` is an explicit, deterministic construction —
+				// only the zero-argument form reads ambient wall-clock time.
+				if (node.arguments.length === 0) {
+					context.report({ node, messageId: 'newDate' });
+				}
+			},
+		};
+	},
+};
+
+// --- chart-a11y-wrapper ------------------------------------------------------
+
+const CHART_LIBS = ['layerchart', 'uplot'] as const;
+
+/** The a11y wrappers from `@sveltesentio/charts` that satisfy the invariant. */
+const A11Y_WRAPPER_ELEMENTS = new Set(['ChartFigure']);
+
+const CHART_HINT =
+	'render it inside `<ChartFigure>` from @sveltesentio/charts so the chart ' +
+	'ships the required visually-hidden data table (WCAG 2.2 SC 1.1.1, ADR-0013)';
+
+/**
+ * Structural read of a `svelte-eslint-parser` `SvelteElement` name without
+ * depending on the parser's types: a component element exposes
+ * `name: { type: 'Identifier' | 'SvelteName', name: string }`. Anything else
+ * (HTML tags, member-expression names) is not a chart-library binding and is
+ * intentionally ignored.
+ */
+function svelteElementName(node: unknown): string | undefined {
+	if (typeof node !== 'object' || node === null) return undefined;
+	const name = (node as { name?: unknown }).name;
+	if (typeof name !== 'object' || name === null) return undefined;
+	const raw = (name as { name?: unknown }).name;
+	return typeof raw === 'string' ? raw : undefined;
+}
+
+/** Reads the source string of a (validated) `ImportDeclaration`. */
+function importSource(node: ImportDeclarationNode): string {
+	const value = node.source.value;
+	return typeof value === 'string' ? value : '';
+}
+
+/** True for `layerchart`, `layerchart/...`, `uplot`, `uplot/...`. */
+function isChartLibSource(source: string): boolean {
+	return CHART_LIBS.some(
+		(lib) => source === lib || source.startsWith(`${lib}/`),
+	);
+}
+
+const chartA11yWrapper: Rule.RuleModule = {
+	meta: {
+		type: 'problem',
+		docs: {
+			description:
+				'require chart visuals from layerchart / uplot to be wrapped in <ChartFigure>',
+			recommended: true,
+		},
+		schema: [],
+		messages: {
+			bareChart: `Bare \`<{{name}}>\` from \`{{source}}\` bypasses the a11y wrapper — ${CHART_HINT}.`,
+		},
+	},
+
+	create(context: Rule.RuleContext): Rule.RuleListener {
+		// Local binding names imported from a chart library → the source they
+		// came from, so the message can name it.
+		const chartBindings = new Map<string, string>();
+
+		return {
+			ImportDeclaration(node: ImportDeclarationNode): void {
+				const source = importSource(node);
+				if (!isChartLibSource(source)) return;
+				for (const spec of node.specifiers) {
+					chartBindings.set(spec.local.name, source);
+				}
+			},
+
+			// `SvelteElement` is the svelte-eslint-parser node for any element;
+			// not part of ESLint's core `NodeListener`, so it rides the
+			// RuleListener index signature.
+			SvelteElement(node: Rule.Node): void {
+				const name = svelteElementName(node);
+				if (name === undefined) return;
+				const source = chartBindings.get(name);
+				if (source === undefined) return;
+				// Allowed when nested under a sanctioned a11y wrapper element.
+				const ancestors = context.sourceCode.getAncestors(node);
+				const wrapped = ancestors.some((ancestor) =>
+					A11Y_WRAPPER_ELEMENTS.has(svelteElementName(ancestor) ?? ''),
+				);
+				if (wrapped) return;
+				context.report({
+					node,
+					messageId: 'bareChart',
+					data: { name, source },
+				});
+			},
+		};
+	},
+};
+
+/** The flat-config plugin object (`plugins: { '@sveltesentio': sentioEslint }`). */
+const sentioEslint = {
+	meta: { name: '@sveltesentio/core', version: '0.2.0' },
+	rules: {
+		'no-direct-time': noDirectTime,
+		'chart-a11y-wrapper': chartA11yWrapper,
+	},
+} satisfies {
+	meta: { name: string; version: string };
+	rules: Record<string, Rule.RuleModule>;
+};
+
+export { noDirectTime, chartA11yWrapper, sentioEslint };
+export default sentioEslint;

package/src/index.ts

@@ -39,5 +39,12 @@ export {
 	strictCsp,
 } from './csp.js';
 
-export type { SentioPluginOptions } from './vite.js';
-export { sentioPlugin } from './vite.js';
+export type {
+	BudgetViolation,
+	BundleBudget,
+	BundleLike,
+	SentioPluginOptions,
+} from './vite.js';
+export { checkBundleBudget, sentioPlugin } from './vite.js';
+
+export { noDirectTime, sentioEslint } from './eslint.js';

package/src/vite.ts

@@ -1,16 +1,89 @@
 import type { Plugin } from 'vite';
 
+/** A budget map: output chunk file name → maximum allowed size in bytes. */
+export type BundleBudget = Readonly<Record<string, number>>;
+
 export interface SentioPluginOptions {
 	requiredEnv?: readonly string[];
 	verbose?: boolean;
 	virtualModule?: Readonly<Record<string, unknown>>;
+	/**
+	 * Per-chunk size budgets (§2.9 perf budgets). Keys are output `fileName`s
+	 * (exact match) — e.g. `{ 'entry.js': 150_000 }`. On `generateBundle`, any
+	 * emitted chunk whose byte size exceeds its budget fails the build, unless
+	 * {@link bundleBudgetWarnOnly} is set.
+	 */
+	bundleBudget?: BundleBudget;
+	/** When true, over-budget chunks warn instead of failing the build. */
+	bundleBudgetWarnOnly?: boolean;
 }
 
 const VIRTUAL_ID = '$sentio';
 const RESOLVED_ID = '\0$sentio';
 
+/** Minimal structural view of a Rollup/Rolldown output item we need to size. */
+interface BundleEntry {
+	type: 'chunk' | 'asset';
+	code?: string;
+	source?: string | Uint8Array;
+}
+
+/** A bundle is a `fileName → entry` map, as passed to `generateBundle`. */
+export type BundleLike = Readonly<Record<string, BundleEntry>>;
+
+export interface BudgetViolation {
+	fileName: string;
+	size: number;
+	budget: number;
+}
+
+/** Byte size of a chunk's code or an asset's source. */
+function entrySize(entry: BundleEntry): number {
+	if (entry.type === 'chunk') {
+		return entry.code === undefined ? 0 : Buffer.byteLength(entry.code, 'utf8');
+	}
+	const { source } = entry;
+	if (source === undefined) return 0;
+	if (typeof source === 'string') return Buffer.byteLength(source, 'utf8');
+	return source.byteLength;
+}
+
+/**
+ * Pure budget check: returns every output entry that exceeds its budget. An
+ * entry with no matching budget key is unconstrained. Exported for unit tests.
+ */
+export function checkBundleBudget(
+	bundle: BundleLike,
+	budget: BundleBudget,
+): BudgetViolation[] {
+	const violations: BudgetViolation[] = [];
+	for (const [fileName, entry] of Object.entries(bundle)) {
+		const max = budget[fileName];
+		if (max === undefined) continue;
+		const size = entrySize(entry);
+		if (size > max) violations.push({ fileName, size, budget: max });
+	}
+	return violations;
+}
+
+function formatViolations(violations: readonly BudgetViolation[]): string {
+	const lines = violations.map(
+		(v) =>
+			`  - ${v.fileName}: ${v.size} B exceeds budget ${v.budget} B (+${
+				v.size - v.budget
+			} B)`,
+	);
+	return `[sentio] Bundle-size budget exceeded:\n${lines.join('\n')}`;
+}
+
 export function sentioPlugin(options: SentioPluginOptions = {}): Plugin {
-	const { requiredEnv = [], verbose = false, virtualModule = {} } = options;
+	const {
+		requiredEnv = [],
+		verbose = false,
+		virtualModule = {},
+		bundleBudget,
+		bundleBudgetWarnOnly = false,
+	} = options;
 
 	return {
 		name: 'vite-plugin-sentio',
@@ -52,5 +125,22 @@ export function sentioPlugin(options: SentioPluginOptions = {}): Plugin {
 				);
 			}
 		},
+
+		generateBundle(_options, bundle) {
+			if (!bundleBudget || Object.keys(bundleBudget).length === 0) return;
+			const violations = checkBundleBudget(bundle, bundleBudget);
+			if (violations.length === 0) {
+				if (verbose) {
+					console.warn('[sentio] Bundle-size budget: all chunks within budget.');
+				}
+				return;
+			}
+			const message = formatViolations(violations);
+			if (bundleBudgetWarnOnly) {
+				console.warn(message);
+				return;
+			}
+			throw new Error(message);
+		},
 	};
 }