@tsrx/core 0.0.22 → 0.0.24

package/README.md

@@ -42,7 +42,7 @@ The TSRX website is the canonical source for language documentation:
 - [Getting Started](https://tsrx.dev/getting-started) — install TSRX for React,
   Preact, Solid, Vue, or Ripple and configure editor/AI tooling.
 - [Features](https://tsrx.dev/features) — examples of components, statement
-  templates, control flow, scoped styles, server blocks, and lazy destructuring.
+  templates, control flow, scoped styles, submodules, and lazy destructuring.
 - [Specification](https://tsrx.dev/specification) — the current grammar and
   parser-level semantics.
 

package/package.json

@@ -3,7 +3,7 @@
   "description": "Core compiler infrastructure for TSRX syntax",
   "license": "MIT",
   "author": "Dominic Gannaway",
-  "version": "0.0.22",
+  "version": "0.0.24",
   "type": "module",
   "repository": {
     "type": "git",

package/src/analyze/validation.js

@@ -7,6 +7,18 @@ import { error } from '../errors.js';
 
 export const COMPONENT_RETURN_VALUE_ERROR =
 	'Return statements inside components cannot have a return value.';
+export const COMPONENT_LOOP_RETURN_ERROR =
+	'Return statements are not allowed inside component for...of loops. Use continue instead.';
+export const COMPONENT_LOOP_BREAK_ERROR =
+	'Break statements are not allowed inside component for...of loops.';
+export const COMPONENT_FOR_STATEMENT_ERROR =
+	'For loops are not supported in components. Use for...of instead.';
+export const COMPONENT_FOR_IN_STATEMENT_ERROR =
+	'For...in loops are not supported in components. Use for...of instead.';
+export const COMPONENT_WHILE_STATEMENT_ERROR =
+	'While loops are not supported in components. Move the while loop into a function.';
+export const COMPONENT_DO_WHILE_STATEMENT_ERROR =
+	'Do...while loops are not supported in components. Move the do...while loop into a function.';
 
 const invalid_nestings = {
 	// <p> cannot contain block-level elements
@@ -133,19 +145,29 @@ function get_element_tag(element) {
  * @returns {AST.ReturnStatement}
  */
 export function get_return_keyword_node(node) {
-	const return_keyword_length = 'return'.length;
+	return get_statement_keyword_node(node, 'return');
+}
+
+/**
+ * @template {AST.Node} T
+ * @param {T} node
+ * @param {string} keyword
+ * @returns {T}
+ */
+export function get_statement_keyword_node(node, keyword) {
+	const keyword_length = keyword.length;
 	const start = /** @type {AST.NodeWithLocation} */ (node).start ?? 0;
 	const loc = /** @type {AST.NodeWithLocation} */ (node).loc;
 
-	return /** @type {AST.ReturnStatement} */ ({
+	return /** @type {T} */ ({
 		...node,
-		end: start + return_keyword_length,
+		end: start + keyword_length,
 		loc: loc
 			? {
 					start: loc.start,
 					end: {
 						line: loc.start.line,
-						column: loc.start.column + return_keyword_length,
+						column: loc.start.column + keyword_length,
 					},
 				}
 			: undefined,
@@ -172,6 +194,59 @@ export function validate_component_return_statement(node, filename, errors, comm
 	);
 }
 
+/**
+ * @param {AST.ReturnStatement} node
+ * @param {string | null | undefined} filename
+ * @param {CompileError[]} [errors]
+ * @param {AST.CommentWithLocation[]} [comments]
+ */
+export function validate_component_loop_return_statement(node, filename, errors, comments) {
+	error(
+		COMPONENT_LOOP_RETURN_ERROR,
+		filename ?? null,
+		get_return_keyword_node(node),
+		errors,
+		comments,
+	);
+}
+
+/**
+ * @param {AST.BreakStatement} node
+ * @param {string | null | undefined} filename
+ * @param {CompileError[]} [errors]
+ * @param {AST.CommentWithLocation[]} [comments]
+ */
+export function validate_component_loop_break_statement(node, filename, errors, comments) {
+	error(
+		COMPONENT_LOOP_BREAK_ERROR,
+		filename ?? null,
+		get_statement_keyword_node(node, 'break'),
+		errors,
+		comments,
+	);
+}
+
+/**
+ * @param {AST.ForStatement | AST.ForInStatement | AST.WhileStatement | AST.DoWhileStatement} node
+ * @param {string | null | undefined} filename
+ * @param {CompileError[]} [errors]
+ * @param {AST.CommentWithLocation[]} [comments]
+ */
+export function validate_component_unsupported_loop_statement(node, filename, errors, comments) {
+	let message;
+	if (node.type === 'ForStatement') {
+		message = COMPONENT_FOR_STATEMENT_ERROR;
+	} else if (node.type === 'ForInStatement') {
+		message = COMPONENT_FOR_IN_STATEMENT_ERROR;
+	} else if (node.type === 'WhileStatement') {
+		message = COMPONENT_WHILE_STATEMENT_ERROR;
+	} else {
+		message = COMPONENT_DO_WHILE_STATEMENT_ERROR;
+	}
+
+	error(message, filename ?? null, node, errors, comments);
+}
+
 /**
  * @param {AST.Element} element
  * @param {AnalysisContext} context

package/src/identifier-utils.js

@@ -1,6 +1,5 @@
 export const IDENTIFIER_OBFUSCATION_PREFIX = '_$_';
-export const STYLE_IDENTIFIER = IDENTIFIER_OBFUSCATION_PREFIX + encode_utf16_char('#') + 'style';
-export const SERVER_IDENTIFIER = IDENTIFIER_OBFUSCATION_PREFIX + encode_utf16_char('#') + 'server';
+export const SERVER_IDENTIFIER = IDENTIFIER_OBFUSCATION_PREFIX + 'server_$_';
 export const CSS_HASH_IDENTIFIER = IDENTIFIER_OBFUSCATION_PREFIX + 'hash';
 
 const DECODE_UTF16_REGEX = /_u([0-9a-fA-F]{4})_/g;

package/src/index.js

@@ -50,7 +50,6 @@ export {
 // Identifier utils
 export {
 	IDENTIFIER_OBFUSCATION_PREFIX,
-	STYLE_IDENTIFIER,
 	SERVER_IDENTIFIER,
 	CSS_HASH_IDENTIFIER,
 	obfuscate_identifier as obfuscateIdentifier,
@@ -141,6 +140,7 @@ export { escape } from './utils/escaping.js';
 export {
 	createJsxTransform,
 	merge_duplicate_refs as mergeDuplicateRefs,
+	rewrite_loop_continues_to_bare_returns as rewriteLoopContinuesToBareReturns,
 	to_jsx_attribute as toJsxAttribute,
 	validate_at_most_one_ref_attribute as validateAtMostOneRefAttribute,
 	component_to_function_declaration as componentToFunctionDeclaration,
@@ -210,8 +210,18 @@ export {
 // Analyze
 export { analyze_css as analyzeCss } from './analyze/css-analyze.js';
 export {
+	COMPONENT_DO_WHILE_STATEMENT_ERROR,
+	COMPONENT_FOR_IN_STATEMENT_ERROR,
+	COMPONENT_FOR_STATEMENT_ERROR,
+	COMPONENT_LOOP_BREAK_ERROR,
+	COMPONENT_LOOP_RETURN_ERROR,
 	COMPONENT_RETURN_VALUE_ERROR,
+	COMPONENT_WHILE_STATEMENT_ERROR,
 	get_return_keyword_node as getReturnKeywordNode,
+	get_statement_keyword_node as getStatementKeywordNode,
+	validate_component_loop_break_statement as validateComponentLoopBreakStatement,
+	validate_component_loop_return_statement as validateComponentLoopReturnStatement,
 	validate_component_return_statement as validateComponentReturnStatement,
+	validate_component_unsupported_loop_statement as validateComponentUnsupportedLoopStatement,
 	validate_nesting as validateNesting,
 } from './analyze/validation.js';

package/src/plugin.js

@@ -189,7 +189,7 @@ function previous_word_before(input, pos) {
 /**
  * Acorn parser plugin for Ripple syntax extensions.
  * Adds support for: component declarations, &[]/&{} lazy destructuring,
- * #server blocks, #style identifiers, and enhanced JSX handling.
+ * submodule imports, TSRX directives, and enhanced JSX handling.
  *
  * @param {import('../types/index').TSRXPluginConfig} [config] - Plugin configuration
  * @returns {(Parser: Parse.ParserConstructor) => Parse.ParserConstructor} Parser extension function
@@ -221,6 +221,22 @@ export function TSRXPlugin(config) {
 			#filename = null;
 			#functionBodyDepth = 0;
 
+			/**
+			 * @type {Parse.Parser['finishNode']}
+			 */
+			finishNode(node, type) {
+				const finished = super.finishNode(node, type);
+				if (type === 'TSModuleDeclaration') {
+					const start = /** @type {number} */ (finished.start);
+					const source = this.input.slice(start, start + 'namespace'.length);
+					finished.metadata ??= { path: [] };
+					finished.metadata.module_keyword = source.startsWith('namespace')
+						? 'namespace'
+						: 'module';
+				}
+				return finished;
+			}
+
 			/**
 			 * @param {Parse.Options} options
 			 * @param {string} input
@@ -234,6 +250,13 @@ export function TSRXPlugin(config) {
 				this.#filename = tsrx_options?.filename || null;
 			}
 
+			#resetTokenStartToCurrentPosition() {
+				if (this.start !== this.pos) {
+					this.start = this.pos;
+					this.startLoc = this.curPosition();
+				}
+			}
+
 			#previousNonWhitespaceChar() {
 				let index = this.pos - 1;
 				while (index >= 0) {
@@ -246,6 +269,50 @@ export function TSRXPlugin(config) {
 				return null;
 			}
 
+			#popTsxTokenContextBeforeTemplateExpressionChild() {
+				let index = this.pos;
+				let has_newline = false;
+
+				// Text-only Tsx nodes can leave the tokenizer in JSX text mode.
+				// Only unwind it for ASI before a following TSRX `{expr}` child;
+				// fragment props like `content={<></>}` still need the JSX context.
+				while (index < this.input.length) {
+					const ch = this.input.charCodeAt(index);
+					if (ch === 32 || ch === 9) {
+						index++;
+					} else if (ch === 10 || ch === 13) {
+						has_newline = true;
+						index++;
+					} else if (ch === 47 && this.input.charCodeAt(index + 1) === 42) {
+						const end = this.input.indexOf('*/', index + 2);
+						const comment_end = end === -1 ? this.input.length : end + 2;
+						if (this.input.slice(index, comment_end).match(regex_newline_characters)) {
+							has_newline = true;
+						}
+						index = comment_end;
+					} else if (ch === 47 && this.input.charCodeAt(index + 1) === 47) {
+						has_newline = true;
+						index += 2;
+						while (index < this.input.length) {
+							const comment_ch = this.input.charCodeAt(index);
+							if (comment_ch === 10 || comment_ch === 13) break;
+							index++;
+						}
+					} else {
+						break;
+					}
+				}
+
+				if (!has_newline || this.input.charCodeAt(index) !== 123) {
+					return;
+				}
+
+				const context_index = this.context.lastIndexOf(tstc.tc_expr);
+				if (context_index !== -1) {
+					this.context.length = context_index;
+				}
+			}
+
 			#isDoubleQuotedTextChildStart() {
 				if (this.#path.findLast((n) => n.type === 'TsxCompat' || n.type === 'Tsx')) {
 					return false;
@@ -820,44 +887,6 @@ export function TSRXPlugin(config) {
 					}
 				}
 
-				if (code === 35) {
-					// # character
-					if (this.pos + 1 < this.input.length) {
-						/** @param {string} value */
-						const startsWith = (value) =>
-							this.input.slice(this.pos, this.pos + value.length) === value;
-						/** @param {number} length */
-						const char_after = (length) =>
-							this.pos + length < this.input.length ? this.input.charCodeAt(this.pos + length) : -1;
-						/** @param {number} ch */
-						const is_ripple_delimiter = (ch) =>
-							ch === 40 || // (
-							ch === 41 || // )
-							ch === 60 || // <
-							ch === 46 || // .
-							ch === 44 || // ,
-							ch === 59 || // ;
-							ch === 91 || // [
-							ch === 93 || // ]
-							ch === 123 || // {
-							ch === 125 || // }
-							ch === 32 || // space
-							ch === 9 || // tab
-							ch === 10 || // newline
-							ch === 13 || // carriage return
-							ch === -1; // EOF
-
-						if (startsWith('#server') && is_ripple_delimiter(char_after(7))) {
-							this.pos += 7;
-							return this.finishToken(tt.name, '#server');
-						}
-
-						if (startsWith('#style') && is_ripple_delimiter(char_after(6))) {
-							this.pos += 6;
-							return this.finishToken(tt.name, '#style');
-						}
-					}
-				}
 				this.#allowTagStartAfterDoubleQuotedText = false;
 				return super.getTokenFromCode(code);
 			}
@@ -970,22 +999,6 @@ export function TSRXPlugin(config) {
 			 * @type {Parse.Parser['parseExprAtom']}
 			 */
 			parseExprAtom(refDestructuringErrors, forNew, forInit) {
-				const lookahead_type = this.lookahead().type;
-				const is_next_call_token = lookahead_type === tt.parenL || lookahead_type === tt.relational;
-
-				// Check if this is #server identifier for server function calls
-				if (this.type === tt.name && this.value === '#server') {
-					const node = this.startNode();
-					this.next();
-					return /** @type {AST.ServerIdentifier} */ (this.finishNode(node, 'ServerIdentifier'));
-				}
-
-				if (this.type === tt.name && this.value === '#style') {
-					const node = this.startNode();
-					this.next();
-					return /** @type {AST.StyleIdentifier} */ (this.finishNode(node, 'StyleIdentifier'));
-				}
-
 				// Check if this is a component expression (e.g., in object literal values)
 				if (this.type === tt.name && this.value === 'component') {
 					return this.parseComponent();
@@ -1015,9 +1028,9 @@ export function TSRXPlugin(config) {
 
 			/**
 			 * Override checkLocalExport to check all scopes in the scope stack.
-			 * This is needed because server blocks create nested scopes, but exports
-			 * from within server blocks should still be valid if the identifier is
-			 * declared in the server block's scope (not just the top-level module scope).
+			 * This is needed because submodules create nested scopes, but exports
+			 * from within submodules should still be valid if the identifier is
+			 * declared in the submodule scope (not just the top-level module scope).
 			 * @type {Parse.Parser['checkLocalExport']}
 			 */
 			checkLocalExport(id) {
@@ -1036,31 +1049,6 @@ export function TSRXPlugin(config) {
 				this.undefinedExports[name] = id;
 			}
 
-			/**
-			 * @type {Parse.Parser['parseServerBlock']}
-			 */
-			parseServerBlock() {
-				const node = /** @type {AST.ServerBlock} */ (this.startNode());
-				this.next();
-
-				const body = /** @type {AST.ServerBlockStatement} */ (this.startNode());
-				node.body = body;
-				body.body = [];
-
-				this.expect(tt.braceL);
-				this.enterScope(0);
-				while (this.type !== tt.braceR) {
-					const stmt = /** @type {AST.Statement} */ (this.parseStatement(null, true));
-					body.body.push(stmt);
-				}
-				this.next();
-				this.exitScope();
-				this.finishNode(body, 'BlockStatement');
-
-				this.awaitPos = 0;
-				return this.finishNode(node, 'ServerBlock');
-			}
-
 			/**
 			 * Parse a component - common implementation used by statements, expressions, and export defaults
 			 * @type {Parse.Parser['parseComponent']}
@@ -1415,10 +1403,26 @@ export function TSRXPlugin(config) {
 							'"text" is a TSRX keyword and must be used in the form {text some_value}',
 						);
 					}
+				} else if (
+					this.type === tt.name &&
+					this.value === 'style' &&
+					this.lookahead().type === tt.string
+				) {
+					node.style = true;
+					this.next();
 				}
 
 				node.expression =
 					this.type === tt.braceR ? this.jsx_parseEmptyExpression() : this.parseExpression();
+				if (
+					node.style &&
+					(node.expression.type !== 'Literal' || typeof node.expression.value !== 'string')
+				) {
+					this.raise(
+						/** @type {number} */ (node.expression.start),
+						'"style" is a TSRX keyword and must be used in the form {style "class_name"}',
+					);
+				}
 				this.expect(tt.braceR);
 
 				return this.finishNode(node, 'JSXExpressionContainer');
@@ -1812,6 +1816,7 @@ export function TSRXPlugin(config) {
 								break;
 							}
 							// If not a comment, fall through to default case
+							this.#resetTokenStartToCurrentPosition();
 							this.context.push(b_stat);
 							this.exprAllowed = true;
 							return original.readToken.call(this, ch);
@@ -1831,6 +1836,7 @@ export function TSRXPlugin(config) {
 									this.#path.at(-1)?.type === 'Component' ||
 									this.#path.at(-1)?.type === 'Element')
 							) {
+								this.#resetTokenStartToCurrentPosition();
 								return original.readToken.call(this, ch);
 							}
 							this.raise(
@@ -1855,6 +1861,7 @@ export function TSRXPlugin(config) {
 							} else if (ch === 32 || ch === 9) {
 								++this.pos;
 							} else {
+								this.#resetTokenStartToCurrentPosition();
 								this.context.push(b_stat);
 								this.exprAllowed = true;
 								return original.readToken.call(this, ch);
@@ -1986,6 +1993,14 @@ export function TSRXPlugin(config) {
 						if (attr.value !== null) {
 							if (attr.value.type === 'JSXExpressionContainer') {
 								const expression = attr.value.expression;
+								if (attr.value.style) {
+									/** @type {AST.Style} */ (/** @type {unknown} */ (attr.value)).type = 'Style';
+									/** @type {AST.Style} */ (/** @type {unknown} */ (attr.value)).value =
+										/** @type {AST.Literal} */ (expression);
+									delete (/** @type {any} */ (attr.value).expression);
+									delete (/** @type {any} */ (attr.value).style);
+									continue;
+								}
 								if (expression.type === 'Literal') {
 									expression.was_expression = true;
 								}
@@ -2038,6 +2053,7 @@ export function TSRXPlugin(config) {
 							if (this.type !== tstt.jsxTagEnd) {
 								raise_error();
 							}
+							this.#popTsxTokenContextBeforeTemplateExpressionChild();
 							this.next();
 						}
 					}
@@ -2223,6 +2239,7 @@ export function TSRXPlugin(config) {
 								if (this.type !== tstt.jsxTagEnd) {
 									raise_error();
 								}
+								this.#popTsxTokenContextBeforeTemplateExpressionChild();
 								this.next();
 							}
 						} else if (element.type === 'TsxCompat') {
@@ -2254,6 +2271,7 @@ export function TSRXPlugin(config) {
 								if (this.type !== tstt.jsxTagEnd) {
 									raise_error();
 								}
+								this.#popTsxTokenContextBeforeTemplateExpressionChild();
 								this.next();
 							}
 						} else if (this.#path[this.#path.length - 1] === element) {
@@ -2455,11 +2473,23 @@ export function TSRXPlugin(config) {
 					// Keep JSXEmptyExpression as-is (for prettier to handle comments)
 					// but convert other expressions to Html/TSRXExpression/Text nodes
 					if (node.expression.type !== 'JSXEmptyExpression') {
-						/** @type {AST.TSRXExpression | AST.Html | AST.TextNode} */ (
+						/** @type {AST.TSRXExpression | AST.Html | AST.TextNode | AST.Style} */ (
 							/** @type {unknown} */ (node)
-						).type = node.html ? 'Html' : node.text ? 'Text' : 'TSRXExpression';
+						).type = node.html
+							? 'Html'
+							: node.text
+								? 'Text'
+								: node.style
+									? 'Style'
+									: 'TSRXExpression';
+						if (node.style) {
+							/** @type {AST.Style} */ (/** @type {unknown} */ (node)).value =
+								/** @type {AST.Literal} */ (node.expression);
+							delete (/** @type {any} */ (node).expression);
+						}
 						delete node.html;
 						delete node.text;
+						delete node.style;
 					}
 					body.push(node);
 				} else if (this.type === tt.string && this.input.charCodeAt(this.start) === 34) {
@@ -2601,6 +2631,66 @@ export function TSRXPlugin(config) {
 				this.parseTemplateBody(body);
 			}
 
+			/**
+			 * Parse proposal-style imports from an inline module declaration:
+			 * `import { foo } from server;`
+			 *
+			 * Acorn's import parser currently requires a string literal source. TSRX
+			 * extends only the source position; all specifier parsing stays delegated
+			 * to Acorn/@sveltejs/acorn-typescript.
+			 * @type {Parse.Parser['parseImport']}
+			 */
+			parseImport(node) {
+				const tokenIsIdentifier = /** @type {any} */ (Parser.acornTypeScript).tokenIsIdentifier;
+				const parser = /** @type {any} */ (this);
+				const import_node = /** @type {any} */ (node);
+				let enterHead = parser.lookahead();
+				import_node.importKind = 'value';
+				parser.importOrExportOuterKind = 'value';
+				if (tokenIsIdentifier(enterHead.type) || this.match(tt.star) || this.match(tt.braceL)) {
+					let ahead = parser.lookahead(2);
+					if (
+						ahead.type !== tt.comma &&
+						!parser.isContextualWithState('from', ahead) &&
+						ahead.type !== tt.eq &&
+						parser.ts_eatContextualWithState('type', 1, enterHead)
+					) {
+						parser.importOrExportOuterKind = 'type';
+						import_node.importKind = 'type';
+						enterHead = parser.lookahead();
+						ahead = parser.lookahead(2);
+					}
+					if (tokenIsIdentifier(enterHead.type) && ahead.type === tt.eq) {
+						this.next();
+						const importNode = parser.tsParseImportEqualsDeclaration(node);
+						parser.importOrExportOuterKind = 'value';
+						return importNode;
+					}
+				}
+				this.next();
+				if (this.type === tt.string) {
+					import_node.specifiers = [];
+					import_node.source = this.parseExprAtom();
+				} else {
+					import_node.specifiers = this.parseImportSpecifiers();
+					this.expectContextual('from');
+					if (this.type === tt.string) {
+						import_node.source = this.parseExprAtom();
+					} else if (tokenIsIdentifier(this.type)) {
+						const source = this.parseIdent(false);
+						source.metadata ??= { path: [] };
+						import_node.source = source;
+					} else {
+						this.unexpected();
+					}
+				}
+				parser.parseMaybeImportAttributes(node);
+				this.semicolon();
+				this.finishNode(node, 'ImportDeclaration');
+				parser.importOrExportOuterKind = 'value';
+				return import_node;
+			}
+
 			/**
 			 * @type {Parse.Parser['parseStatement']}
 			 */
@@ -2616,11 +2706,23 @@ export function TSRXPlugin(config) {
 					const node = this.jsx_parseExpressionContainer();
 					// Keep JSXEmptyExpression as-is (don't convert to TSRXExpression/Text/Html)
 					if (node.expression.type !== 'JSXEmptyExpression') {
-						/** @type {AST.TSRXExpression | AST.Html | AST.TextNode} */ (
+						/** @type {AST.TSRXExpression | AST.Html | AST.TextNode | AST.Style} */ (
 							/** @type {unknown} */ (node)
-						).type = node.html ? 'Html' : node.text ? 'Text' : 'TSRXExpression';
+						).type = node.html
+							? 'Html'
+							: node.text
+								? 'Text'
+								: node.style
+									? 'Style'
+									: 'TSRXExpression';
+						if (node.style) {
+							/** @type {AST.Style} */ (/** @type {unknown} */ (node)).value =
+								/** @type {AST.Literal} */ (node.expression);
+							delete (/** @type {any} */ (node).expression);
+						}
 						delete node.html;
 						delete node.text;
+						delete node.style;
 					}
 
 					return /** @type {ESTreeJSX.JSXEmptyExpression | AST.TSRXExpression | AST.Html | AST.TextNode | ESTreeJSX.JSXExpressionContainer} */ (
@@ -2628,18 +2730,6 @@ export function TSRXPlugin(config) {
 					);
 				}
 
-				if (this.value === '#server') {
-					// Peek ahead to see if this is a server block (#server { ... }) vs
-					// a server identifier expression (#server.fn(), #server.fn().then())
-					let peek_pos = this.end;
-					while (peek_pos < this.input.length && /\s/.test(this.input[peek_pos])) peek_pos++;
-					if (peek_pos < this.input.length && this.input.charCodeAt(peek_pos) === 123) {
-						// Next non-whitespace character is '{' — parse as server block
-						return this.parseServerBlock();
-					}
-					// Otherwise fall through to parse as expression statement (e.g., #server.fn().then(...))
-				}
-
 				if (this.value === 'component') {
 					this.awaitPos = 0;
 					return this.parseComponent({ requireName: true, declareName: true });

package/src/scope.js

@@ -127,10 +127,18 @@ export function create_scopes(ast, root, parent, error_options) {
 			next({ scope });
 		},
 
-		ServerBlock(node, { state, next }) {
+		TSModuleDeclaration(node, { state, next }) {
+			const is_submodule = node.metadata?.module_keyword === 'module';
+			if (is_submodule && node.id?.type === 'Identifier') {
+				state.scope.declare(node.id, 'normal', 'module', node);
+			}
+
 			const scope = state.scope.child();
-			scope.server_block = true;
+			scope.server_block = is_submodule;
 			scopes.set(node, scope);
+			if (node.body) {
+				scopes.set(node.body, scope);
+			}
 
 			next({ scope });
 		},
@@ -296,7 +304,7 @@ export class Scope {
 	tracing = null;
 
 	/**
-	 * Is this scope a top-level server block scope
+	 * Is this scope a submodule scope
 	 * @type {ScopeInterface['server_block']}
 	 */
 	server_block = false;
@@ -325,7 +333,7 @@ export class Scope {
 				return this.parent.declare(node, kind, declaration_kind);
 			}
 
-			if (declaration_kind === 'import' && !this.parent.server_block) {
+			if (declaration_kind === 'import' && !this.server_block && !this.parent.server_block) {
 				return this.parent.declare(node, kind, declaration_kind, initial);
 			}
 		}

package/src/transform/jsx/helpers.js

@@ -204,6 +204,12 @@ export function tsx_with_ts_locations() {
 			}
 			context.write('>');
 		},
+		TSModuleDeclaration: (node, context) => {
+			context.write(node.metadata?.module_keyword ?? 'module');
+			context.write(' ');
+			context.visit(node.id);
+			context.visit(node.body);
+		},
 	};
 
 	// Be careful when duplicating visitors that are already defined