@sveltesentio/core 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [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.0",
   "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,15 @@
     }
   },
   "devDependencies": {
-    "@sveltejs/kit": "^2.0.0",
-    "@types/node": "^24.0.0",
+    "@sveltejs/kit": "^2.65.1",
+    "@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.8",
+    "zod": "^4.4.3"
   },
   "keywords": [
     "sveltesentio",
@@ -80,6 +84,6 @@
     "build": "tsc",
     "lint": "eslint src/",
     "typecheck": "tsc --noEmit",
-    "test": "vitest run"
+    "test": "vitest run --coverage"
   }
 }

package/src/eslint.ts

@@ -0,0 +1,107 @@
+import type { Rule } from 'eslint';
+
+/**
+ * Flat-config ESLint plugin enforcing the core "no direct time reads" invariant
+ * (see AGENTS.md §Invariants + docs/principles.md §2.1): time must flow through
+ * the injected {@link Clock} (`useClock` / `getClock` from `@sveltesentio/core`)
+ * so it is deterministic and testable. Banned forms:
+ *
+ * - `Date.now()`
+ * - `new Date()` (zero-argument — `new Date(serverMs)` is explicit + allowed)
+ * - `performance.now()`
+ *
+ * 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' },
+ *   },
+ * ];
+ * ```
+ */
+
+// 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 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' });
+				}
+			},
+		};
+	},
+};
+
+/** The flat-config plugin object (`plugins: { '@sveltesentio': sentioEslint }`). */
+const sentioEslint = {
+	meta: { name: '@sveltesentio/core', version: '0.1.0' },
+	rules: {
+		'no-direct-time': noDirectTime,
+	},
+} satisfies {
+	meta: { name: string; version: string };
+	rules: Record<string, Rule.RuleModule>;
+};
+
+export { noDirectTime, 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);
+		},
 	};
 }