@rsvelte/vite-plugin-svelte-native 0.2.6 → 0.2.8

package/envelope.js

@@ -12,6 +12,8 @@
 
 'use strict';
 
+const { isWindowOutOfBounds, windowOutOfBoundsMessage } = require('./lib/bounds-check.js');
+
 const MAGIC = 0x31565352; // "RSV1" little-endian
 const VERSION = 1;
 const HEADER_LEN = 60;
@@ -27,10 +29,8 @@ const WARN_HAS_FRAME = 1 << 3;
 
 /**
  * Validate that the byte window `[off, off + len)` lies fully inside a
- * buffer of `bufLen` bytes. The encoder writes offsets/lengths as u32s
- * the decoder otherwise trusts blindly — `buf.toString` / `subarray`
- * silently *clamp* an out-of-range window, so a malformed envelope would
- * decode to truncated data instead of failing loudly. Throw instead (M-012).
+ * buffer of `bufLen` bytes (see `./lib/bounds-check.js` for why this must
+ * throw rather than let `toString`/`subarray` clamp silently — M-012).
  *
  * @param {number} bufLen
  * @param {number} off
@@ -38,11 +38,8 @@ const WARN_HAS_FRAME = 1 << 3;
  * @param {string} label
  */
 function assertWindow(bufLen, off, len, label) {
-	if (off < 0 || len < 0 || off + len > bufLen) {
-		throw new Error(
-			`[rsvelte] envelope ${label} out of bounds ` +
-				`(offset ${off} + length ${len} exceeds buffer of ${bufLen} bytes)`,
-		);
+	if (isWindowOutOfBounds(off, len, bufLen)) {
+		throw new Error(`[rsvelte] envelope ${windowOutOfBoundsMessage(label, off, len, bufLen)}`);
 	}
 }
 

package/index.cjs

@@ -137,6 +137,8 @@ module.exports.parseEnvelope = binding.parseEnvelope;
 module.exports.decodeParseEnvelope = decodeParseEnvelope;
 // Upstream Svelte version this binding emits code for — used by
 // downstream consumers (the `@rsvelte/vite-plugin-svelte` fork, etc.)
-// for `gte(VERSION, '5.36.0')`-style feature detection. Synced
-// manually against `submodules/svelte/packages/svelte/package.json`.
-module.exports.VERSION = '5.51.3';
+// for `gte(VERSION, '5.36.0')`-style feature detection. Kept in sync
+// with `submodules/svelte/packages/svelte/package.json` by hand; run
+// `node scripts/dev/check-vps-version.mjs` (also wired into CI) to
+// catch drift.
+module.exports.VERSION = '5.56.4';

package/lib/bounds-check.js

@@ -0,0 +1,38 @@
+// Shared bounds-check primitive for the two raw-transfer envelope decoders
+// (`../envelope.js` for `compileEnvelope`/`compileModuleEnvelope`, and
+// `../parse-envelope.js` for `parseEnvelope`). Both wire formats encode
+// offsets/lengths as u32s that the decoder otherwise trusts blindly —
+// `Buffer.toString` / `Uint8Array.subarray` silently *clamp* an
+// out-of-range window instead of throwing, so a malformed envelope would
+// decode to truncated/misaligned data rather than failing loudly (M-012).
+//
+// Each decoder wraps this in its own `assertWindow` helper so it can throw
+// its own Error subtype with its own message prefix (`[rsvelte] envelope …`
+// vs `parse envelope: …`) while sharing the actual bounds arithmetic and
+// message body.
+
+'use strict';
+
+/**
+ * @param {number} off
+ * @param {number} len
+ * @param {number} bufLen
+ * @returns {boolean} true when the byte window `[off, off + len)` does NOT
+ *   lie fully inside a buffer of `bufLen` bytes.
+ */
+function isWindowOutOfBounds(off, len, bufLen) {
+	return off < 0 || len < 0 || off + len > bufLen;
+}
+
+/**
+ * @param {string} label
+ * @param {number} off
+ * @param {number} len
+ * @param {number} bufLen
+ * @returns {string}
+ */
+function windowOutOfBoundsMessage(label, off, len, bufLen) {
+	return `${label} out of bounds (offset ${off} + length ${len} exceeds buffer of ${bufLen} bytes)`;
+}
+
+module.exports = { isWindowOutOfBounds, windowOutOfBoundsMessage };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsvelte/vite-plugin-svelte-native",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "description": "NAPI bindings to the rsvelte compiler — used by the @rsvelte vite-plugin-svelte shim",
   "license": "MIT",
   "repository": {
@@ -24,15 +24,16 @@
   "files": [
     "envelope.js",
     "parse-envelope.js",
+    "lib/bounds-check.js",
     "index.cjs",
     "index.d.ts"
   ],
   "optionalDependencies": {
-    "@rsvelte/vite-plugin-svelte-native-darwin-arm64": "^0.2.6",
-    "@rsvelte/vite-plugin-svelte-native-darwin-x64": "^0.2.6",
-    "@rsvelte/vite-plugin-svelte-native-linux-arm64-gnu": "^0.2.6",
-    "@rsvelte/vite-plugin-svelte-native-linux-x64-gnu": "^0.2.6",
-    "@rsvelte/vite-plugin-svelte-native-win32-x64-msvc": "^0.2.6"
+    "@rsvelte/vite-plugin-svelte-native-darwin-arm64": "^0.2.8",
+    "@rsvelte/vite-plugin-svelte-native-darwin-x64": "^0.2.8",
+    "@rsvelte/vite-plugin-svelte-native-linux-arm64-gnu": "^0.2.8",
+    "@rsvelte/vite-plugin-svelte-native-linux-x64-gnu": "^0.2.8",
+    "@rsvelte/vite-plugin-svelte-native-win32-x64-msvc": "^0.2.8"
   },
   "publishConfig": {
     "access": "public"

package/parse-envelope.js

@@ -12,6 +12,8 @@
 
 'use strict';
 
+const { isWindowOutOfBounds, windowOutOfBoundsMessage } = require('./lib/bounds-check.js');
+
 const MAGIC = 0x3156_5052; // "RPV1" little-endian
 const VERSION = 1;
 const HEADER_LEN = 24;
@@ -74,7 +76,7 @@ const TAG_AWAIT_BLOCK = 0x72;
 const TAG_KEY_BLOCK = 0x73;
 const TAG_SNIPPET_BLOCK = 0x74;
 
-// JsNode (estree) tags — 0x80..0xCB. Mirrors `napi_raw_parse.rs`.
+// JsNode (estree) tags — 0x80..0xCC. Mirrors `napi_raw_parse.rs`.
 const JS_IDENTIFIER = 0x80;
 const JS_PRIVATE_IDENTIFIER = 0x81;
 const JS_LITERAL = 0x82;
@@ -150,7 +152,14 @@ const JS_TS_ENUM_DECLARATION = 0xc7;
 const JS_TS_MODULE_DECLARATION = 0xc8;
 const JS_COMMENT = 0xc9;
 const JS_NULL = 0xca;
-const JS_RAW_JSON = 0xcb;
+// 0xcb was the former whole-node JS_RAW_JSON escape (removed — TS type
+// annotations now ride a per-node trailer; see readOptTypeAnnotation).
+const JS_TS_PARAMETER_PROPERTY = 0xcc;
+const JS_TS_AS_EXPRESSION = 0xcd;
+const JS_TS_SATISFIES_EXPRESSION = 0xce;
+const JS_TS_NON_NULL_EXPRESSION = 0xcf;
+const JS_TS_TYPE_ASSERTION = 0xd0;
+const JS_TS_INSTANTIATION_EXPRESSION = 0xd1;
 
 // LiteralValue inner tag (within a JS_LITERAL payload).
 const LV_NULL = 0;
@@ -253,10 +262,31 @@ function readU32(ctx) {
 function readBool(ctx) {
 	return readU8(ctx) !== 0;
 }
+
+/**
+ * Validate that the byte window `[start, start + len)` lies fully inside
+ * `ctx.bytes` (see `./lib/bounds-check.js`, shared with `envelope.js`'s
+ * `assertWindow`, for why this must throw rather than let
+ * `Buffer.toString`/`Uint8Array.subarray` clamp silently — M-012).
+ *
+ * @param {object} ctx
+ * @param {number} start
+ * @param {number} len
+ * @param {string} label
+ */
+function assertWindow(ctx, start, len, label) {
+	if (isWindowOutOfBounds(start, len, ctx.bytes.byteLength)) {
+		throw new EnvelopeError(
+			`parse envelope: ${windowOutOfBoundsMessage(label, start, len, ctx.bytes.byteLength)}`,
+		);
+	}
+}
+
 function readStr(ctx) {
 	const len = readU32(ctx);
 	const start = ctx.pos;
 	const end = start + len;
+	assertWindow(ctx, start, len, 'string');
 	ctx.pos = end;
 	// Branch is monomorphic per envelope: V8 specialises after warmup.
 	return ctx.isBuffer
@@ -287,6 +317,7 @@ function readInlineJson(ctx) {
 	const len = readU32(ctx);
 	const start = ctx.pos;
 	const end = start + len;
+	assertWindow(ctx, start, len, 'inline JSON');
 	ctx.pos = end;
 	if (len === 0) return null;
 	return JSON.parse(
@@ -301,6 +332,16 @@ function readJsonNodePayload(ctx) {
 	return readInlineJson(ctx);
 }
 
+/**
+ * Read an optional TS `typeAnnotation` trailer: a flag byte, then (when set) a
+ * length-prefixed JSON blob. Mirrors `write_opt_type_annotation` in
+ * `napi_raw_parse.rs`. Returns `null` when absent.
+ */
+function readOptTypeAnnotation(ctx) {
+	if (readU8(ctx) === 0) return null;
+	return readInlineJson(ctx);
+}
+
 // ---------------------------------------------------------------------------
 // Dispatch on tag
 // ---------------------------------------------------------------------------
@@ -397,8 +438,6 @@ function readNodeBody(ctx, tag, start, end) {
 		// ----- JsNode (estree) ----------------------------------------
 		case JS_NULL:
 			return null;
-		case JS_RAW_JSON:
-			return readJsonNodePayload(ctx);
 		case JS_IDENTIFIER:
 			return readJsIdentifier(ctx, start, end);
 		case JS_PRIVATE_IDENTIFIER:
@@ -543,8 +582,20 @@ function readNodeBody(ctx, tag, start, end) {
 			return readJsTSTypeAnnotation(ctx, start, end);
 		case JS_TS_ENUM_DECLARATION:
 			return readJsBareExpr(ctx, 'TSEnumDeclaration', start, end);
+		case JS_TS_PARAMETER_PROPERTY:
+			return readJsBareExpr(ctx, 'TSParameterProperty', start, end);
 		case JS_TS_MODULE_DECLARATION:
 			return readJsTSModuleDeclaration(ctx, start, end);
+		case JS_TS_AS_EXPRESSION:
+			return readJsTSAssertion(ctx, 'TSAsExpression', start, end, true);
+		case JS_TS_SATISFIES_EXPRESSION:
+			return readJsTSAssertion(ctx, 'TSSatisfiesExpression', start, end, true);
+		case JS_TS_NON_NULL_EXPRESSION:
+			return readJsTSAssertion(ctx, 'TSNonNullExpression', start, end, false);
+		case JS_TS_TYPE_ASSERTION:
+			return readJsTSTypeAssertion(ctx, start, end);
+		case JS_TS_INSTANTIATION_EXPRESSION:
+			return readJsTSInstantiationExpression(ctx, start, end);
 		case JS_COMMENT:
 			return readJsComment_(ctx, start, end);
 
@@ -650,6 +701,8 @@ function readJsIdentifier(ctx, start, end) {
 	const node = { type: 'Identifier', start, end };
 	if (loc !== null) node.loc = loc;
 	node.name = name;
+	const typeAnnotation = readOptTypeAnnotation(ctx);
+	if (typeAnnotation !== null) node.typeAnnotation = typeAnnotation;
 	return node;
 }
 
@@ -937,6 +990,45 @@ function readJsChainExpression(ctx, start, end) {
 	return node;
 }
 
+// TS assertion wrappers (`x as T` / `x satisfies T` / `x!`). As/Satisfies carry
+// a `typeAnnotation` trailer; NonNull does not (`hasTypeAnnotation` is false).
+function readJsTSAssertion(ctx, typeName, start, end, hasTypeAnnotation) {
+	const loc = readTypedLoc(ctx);
+	const expression = readNode(ctx);
+	const node = { type: typeName, start, end };
+	if (loc !== null) node.loc = loc;
+	node.expression = expression;
+	if (hasTypeAnnotation) {
+		const typeAnnotation = readOptTypeAnnotation(ctx);
+		if (typeAnnotation !== null) node.typeAnnotation = typeAnnotation;
+	}
+	return node;
+}
+
+function readJsTSTypeAssertion(ctx, start, end) {
+	// Wire order: loc, expression, typeAnnotation — but svelte/compiler emits
+	// `typeAnnotation` before `expression`, so build the object in that order.
+	const loc = readTypedLoc(ctx);
+	const expression = readNode(ctx);
+	const typeAnnotation = readOptTypeAnnotation(ctx);
+	const node = { type: 'TSTypeAssertion', start, end };
+	if (loc !== null) node.loc = loc;
+	if (typeAnnotation !== null) node.typeAnnotation = typeAnnotation;
+	node.expression = expression;
+	return node;
+}
+
+function readJsTSInstantiationExpression(ctx, start, end) {
+	const loc = readTypedLoc(ctx);
+	const expression = readNode(ctx);
+	const typeArguments = readOptTypeAnnotation(ctx);
+	const node = { type: 'TSInstantiationExpression', start, end };
+	if (loc !== null) node.loc = loc;
+	node.expression = expression;
+	if (typeArguments !== null) node.typeArguments = typeArguments;
+	return node;
+}
+
 function readJsMetaProperty(ctx, start, end) {
 	const loc = readTypedLoc(ctx);
 	const meta = readNode(ctx);
@@ -963,6 +1055,8 @@ function readJsObjectPattern(ctx, start, end) {
 	const node = { type: 'ObjectPattern', start, end };
 	if (loc !== null) node.loc = loc;
 	node.properties = properties;
+	const typeAnnotation = readOptTypeAnnotation(ctx);
+	if (typeAnnotation !== null) node.typeAnnotation = typeAnnotation;
 	return node;
 }
 
@@ -972,6 +1066,8 @@ function readJsArrayPattern(ctx, start, end) {
 	const node = { type: 'ArrayPattern', start, end };
 	if (loc !== null) node.loc = loc;
 	node.elements = elements;
+	const typeAnnotation = readOptTypeAnnotation(ctx);
+	if (typeAnnotation !== null) node.typeAnnotation = typeAnnotation;
 	return node;
 }