diff --git a/.changeset/humble-paths-fly.md b/.changeset/humble-paths-fly.md
new file mode 100644
index 0000000000..a33d0ea32b
--- /dev/null
+++ b/.changeset/humble-paths-fly.md
@@ -0,0 +1,5 @@
+---
+'@fuzdev/gro': minor
+---
+
+feat: rewrite `.ts` to `.js` in dist files
diff --git a/CLAUDE.md b/CLAUDE.md
index 85ed11ac60..605ee2b05d 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -275,7 +275,8 @@ Builtin plugins:
 - `gro_plugin_sveltekit_app` - runs `vite dev` or `vite build` for SvelteKit
   frontends ([docs](src/docs/gro_plugin_sveltekit_app.md))
 - `gro_plugin_sveltekit_library` - runs `svelte-package` to publish from
-  `src/lib/` ([docs](src/docs/gro_plugin_sveltekit_library.md))
+  `src/lib/`, then rewrites relative `.ts`→`.js` import specifiers in the
+  emitted `.d.ts`/`.svelte` ([docs](src/docs/gro_plugin_sveltekit_library.md))
 - `gro_plugin_server` - runs Node servers with auto-restart on changes
 
 ### Configuration
diff --git a/src/docs/gro_plugin_sveltekit_library.md b/src/docs/gro_plugin_sveltekit_library.md
index dd0e98e745..d6a461c15e 100644
--- a/src/docs/gro_plugin_sveltekit_library.md
+++ b/src/docs/gro_plugin_sveltekit_library.md
@@ -22,7 +22,14 @@ npm i -D @sveltejs/package
 ## behavior
 
 In production (`gro build`), runs `svelte-package` during `setup`
-to compile `src/lib/` into `dist/`.
+to compile `src/lib/` into `dist/`, then rewrites relative `.ts` import
+specifiers to `.js` (and `.svelte.ts` to `.svelte.js`) in the emitted `.d.ts`
+declarations and `.svelte` `<script>` blocks
+(the two outputs `svelte-package` leaves on `.ts`)
+so the published `dist` resolves for consumers without
+`allowImportingTsExtensions`. Bare `@fuzdev/*.ts` specifiers (resolved by the
+package `exports` `.js`/`.ts` mirror), `.svelte` component imports, and
+already-`.js` specifiers are left untouched.
 
 In development (`gro dev`), does nothing — `svelte-package` is a build-time tool.
 
diff --git a/src/lib/dist_rewrite_imports.ts b/src/lib/dist_rewrite_imports.ts
new file mode 100644
index 0000000000..c8122ffcb8
--- /dev/null
+++ b/src/lib/dist_rewrite_imports.ts
@@ -0,0 +1,118 @@
+import {fs_search} from '@fuzdev/fuz_util/fs.js';
+import {map_concurrent} from '@fuzdev/fuz_util/async.js';
+import type {Logger} from '@fuzdev/fuz_util/log.js';
+import {readFile, writeFile} from 'node:fs/promises';
+
+import {SVELTE_SCRIPT_MATCHER, SVELTEKIT_DIST_DIRNAME} from './constants.ts';
+
+/*
+
+Post-`svelte-package` pass that rewrites relative `.ts` import specifiers to `.js`
+in the published `dist` output.
+
+The ecosystem writes import specifiers with the real source extension
+(`./foo.ts`, `./bar.svelte.ts`) and relies on emit-only rewrites to make `dist`
+resolve for external consumers. `tsc`'s `rewriteRelativeImportExtensions` handles
+the `.ts`/`.svelte.ts` → `dist/*.js` emit, but two outputs are left untouched:
+
+- `.svelte` files, which `svelte-package` ships verbatim (source `<script>` and
+  its relative specifiers intact), and
+- `.d.ts` / `*.svelte.d.ts` declaration files, whose specifiers `svelte-package`'s
+  declaration emit leaves as `.ts`.
+
+This pass closes both gaps so a flagless external consumer (no
+`allowImportingTsExtensions`) resolves the package's types and runtime.
+
+Only **relative** specifiers (`./`, `../`) are rewritten. Bare `@fuzdev/…ts`
+specifiers are left alone — the package `exports` `.js`/`.ts` mirror resolves them
+in both source and dist. `.svelte` component imports and specifiers already ending
+in `.js` are likewise untouched.
+
+This is intentionally parse-light; the long-term home for the rewrite is tsv.
+
+*/
+
+/**
+ * Matches a relative import/export specifier ending in `.ts` (including the
+ * `.svelte.ts` double extension), capturing the introducer, the opening quote,
+ * and the path body so the trailing `.ts` can be swapped for `.js`.
+ *
+ * Anchored on a module-specifier introducer (`from`, `import`, `require`) so it
+ * doesn't touch incidental relative-looking string literals, on a `./`/`../`
+ * prefix so bare specifiers like `@fuzdev/fuz_util/foo.ts` are left untouched, and
+ * on a `(?<!\.)` lookbehind so member calls like `arr.from('./x.ts')` are skipped.
+ */
+const RELATIVE_TS_IMPORT_MATCHER =
+	/(?<!\.)((?:\bfrom|\bimport|\brequire)\b\s*\(?\s*)(['"])(\.\.?\/[^'"\n]*?)\.ts\2/g;
+
+/**
+ * Rewrites relative `.ts` (and `.svelte.ts`) import specifiers to `.js` (and
+ * `.svelte.js`) across a chunk of TypeScript source — a whole `.d.ts` file or a
+ * `.svelte` `<script>` block.
+ */
+export const rewrite_relative_ts_imports = (content: string): string =>
+	content.replace(
+		RELATIVE_TS_IMPORT_MATCHER,
+		(_match, intro: string, quote: string, body: string) => `${intro}${quote}${body}.js${quote}`,
+	);
+
+/**
+ * Rewrites relative `.ts` import specifiers to `.js` inside each `<script>` block
+ * of a `.svelte` file, leaving template markup untouched.
+ */
+export const rewrite_svelte_ts_imports = (content: string): string =>
+	content.replace(SVELTE_SCRIPT_MATCHER, (full: string, inner: string) => {
+		const rewritten = rewrite_relative_ts_imports(inner);
+		if (rewritten === inner) return full;
+		// replace via a function so `$`-sequences in the script (`$$props`, `$:`,
+		// `$&`, …) aren't interpreted as `String.prototype.replace` substitution patterns
+		return full.replace(inner, () => rewritten);
+	});
+
+export interface RewriteDistImportsResult {
+	/** Number of files scanned (`.d.ts` and `.svelte`). */
+	scanned: number;
+	/** Number of scanned files whose contents changed. */
+	rewritten: number;
+}
+
+/** Bounds open file descriptors while rewriting the dist tree. */
+const DIST_REWRITE_CONCURRENCY = 16;
+
+/**
+ * Walks `dist_dir` and rewrites relative `.ts` import specifiers to `.js` in every
+ * `.d.ts` declaration file (whole-file) and `.svelte` file (`<script>` blocks
+ * only). `.js` files are skipped — `tsc`'s `rewriteRelativeImportExtensions`
+ * already rewrites those — as are source maps.
+ *
+ * @param dist_dir - the packaged output directory; defaults to `dist`
+ * @returns counts of files scanned and rewritten
+ */
+export const rewrite_dist_imports = async (
+	dist_dir: string = SVELTEKIT_DIST_DIRNAME,
+	log?: Logger,
+): Promise<RewriteDistImportsResult> => {
+	const found = await fs_search(dist_dir, {
+		file_filter: (id) => id.endsWith('.d.ts') || id.endsWith('.svelte'),
+	});
+
+	const changed = await map_concurrent(found, DIST_REWRITE_CONCURRENCY, async ({id, path}) => {
+		const content = await readFile(id, 'utf8');
+		const next = id.endsWith('.svelte')
+			? rewrite_svelte_ts_imports(content)
+			: rewrite_relative_ts_imports(content);
+		if (next === content) return false;
+		await writeFile(id, next);
+		log?.debug(`rewrote relative .ts import specifiers to .js in ${path}`);
+		return true;
+	});
+	const rewritten = changed.filter(Boolean).length;
+
+	if (found.length) {
+		log?.info(
+			`rewrote relative .ts→.js import specifiers in ${rewritten}/${found.length} dist files`,
+		);
+	}
+
+	return {scanned: found.length, rewritten};
+};
diff --git a/src/lib/gro_plugin_sveltekit_library.ts b/src/lib/gro_plugin_sveltekit_library.ts
index 26a54697c6..410271ea16 100644
--- a/src/lib/gro_plugin_sveltekit_library.ts
+++ b/src/lib/gro_plugin_sveltekit_library.ts
@@ -4,7 +4,8 @@ import type {Plugin} from './plugin.ts';
 import {TaskError} from './task.ts';
 import {package_json_load} from './package_json.ts';
 import {run_svelte_package, type SveltePackageOptions} from './sveltekit_helpers.ts';
-import {SVELTE_PACKAGE_CLI} from './constants.ts';
+import {SVELTE_PACKAGE_CLI, SVELTEKIT_DIST_DIRNAME} from './constants.ts';
+import {rewrite_dist_imports} from './dist_rewrite_imports.ts';
 
 export interface GroPluginSveltekitLibraryOptions {
 	/**
@@ -35,6 +36,12 @@ export const gro_plugin_sveltekit_library = ({
 					log,
 					config.pm_cli,
 				);
+				// `svelte-package` ships `.svelte` source verbatim and leaves relative `.ts`
+				// specifiers in `.d.ts` declarations; rewrite them to `.js` so the published
+				// `dist` resolves for external consumers without `allowImportingTsExtensions`.
+				const output_dir =
+					svelte_package_options?.output ?? svelte_package_options?.o ?? SVELTEKIT_DIST_DIRNAME;
+				await rewrite_dist_imports(output_dir, log);
 			}
 		},
 		adapt: async ({log, timings, config}) => {
diff --git a/src/test/dist_rewrite_imports.test.ts b/src/test/dist_rewrite_imports.test.ts
new file mode 100644
index 0000000000..8729888d4e
--- /dev/null
+++ b/src/test/dist_rewrite_imports.test.ts
@@ -0,0 +1,242 @@
+import {describe, test, assert, beforeEach, afterEach} from 'vitest';
+import {mkdtemp, mkdir, writeFile, readFile, rm} from 'node:fs/promises';
+import {tmpdir} from 'node:os';
+import {join} from 'node:path';
+
+import {
+	rewrite_relative_ts_imports,
+	rewrite_svelte_ts_imports,
+	rewrite_dist_imports,
+} from '../lib/dist_rewrite_imports.ts';
+
+describe('rewrite_relative_ts_imports', () => {
+	test('rewrites relative `.ts` specifiers to `.js`', () => {
+		assert.equal(
+			rewrite_relative_ts_imports(`import {a} from './a.ts';`),
+			`import {a} from './a.js';`,
+		);
+		assert.equal(
+			rewrite_relative_ts_imports(`import {a} from '../parent/a.ts';`),
+			`import {a} from '../parent/a.js';`,
+		);
+	});
+
+	test('rewrites the `.svelte.ts` double extension to `.svelte.js`', () => {
+		assert.equal(
+			rewrite_relative_ts_imports(`import {s} from './state.svelte.ts';`),
+			`import {s} from './state.svelte.js';`,
+		);
+	});
+
+	test('leaves bare `@fuzdev/…ts` specifiers alone (the exports mirror resolves them)', () => {
+		const input = `import {x} from '@fuzdev/fuz_util/string.ts';`;
+		assert.equal(rewrite_relative_ts_imports(input), input);
+	});
+
+	test('leaves other bare specifiers alone', () => {
+		const input = `import {page} from '$app/state';\nimport type {Snippet} from 'svelte';`;
+		assert.equal(rewrite_relative_ts_imports(input), input);
+	});
+
+	test('leaves `.svelte` component imports alone', () => {
+		const input = `import Svg from './Svg.svelte';`;
+		assert.equal(rewrite_relative_ts_imports(input), input);
+	});
+
+	test('leaves specifiers already ending in `.js` alone', () => {
+		const input = `import {a} from './a.js';\nimport {b} from './b.svelte.js';`;
+		assert.equal(rewrite_relative_ts_imports(input), input);
+	});
+
+	test('rewrites `import type` specifiers', () => {
+		assert.equal(
+			rewrite_relative_ts_imports(`import type {Logger} from './log.ts';`),
+			`import type {Logger} from './log.js';`,
+		);
+	});
+
+	test('rewrites `export … from` and `export * from` specifiers', () => {
+		assert.equal(
+			rewrite_relative_ts_imports(`export {a} from './a.ts';`),
+			`export {a} from './a.js';`,
+		);
+		assert.equal(rewrite_relative_ts_imports(`export * from './a.ts';`), `export * from './a.js';`);
+	});
+
+	test('rewrites side-effect imports', () => {
+		assert.equal(rewrite_relative_ts_imports(`import './register.ts';`), `import './register.js';`);
+	});
+
+	test('rewrites dynamic and `.d.ts` `import(...)` type specifiers', () => {
+		assert.equal(
+			rewrite_relative_ts_imports(`const m = await import('./lazy.ts');`),
+			`const m = await import('./lazy.js');`,
+		);
+		assert.equal(
+			rewrite_relative_ts_imports(`export declare const x: import("./types.ts").Foo;`),
+			`export declare const x: import("./types.js").Foo;`,
+		);
+	});
+
+	test('handles both quote styles', () => {
+		assert.equal(
+			rewrite_relative_ts_imports(`import {a} from "./a.ts";`),
+			`import {a} from "./a.js";`,
+		);
+	});
+
+	test('does not match `.tsx`, `.mts`, or query-suffixed specifiers', () => {
+		const input = `import X from './X.tsx';\nimport {m} from './m.mts';\nimport raw from './r.ts?raw';`;
+		assert.equal(rewrite_relative_ts_imports(input), input);
+	});
+
+	test("does not match member calls like `arr.from('./x.ts')`", () => {
+		const input = `const a = Array.from('./x.ts');\nconst b = q.from('./y.ts');`;
+		assert.equal(rewrite_relative_ts_imports(input), input);
+	});
+
+	test('rewrites every specifier across a realistic `.d.ts` body', () => {
+		const input = [
+			`import { type ContextmenuRootBaseProps } from './contextmenu_helpers.ts';`,
+			`import type {SvgData} from './svg.ts';`,
+			`import {Tome} from './tome.ts';`,
+			`import {strip_start} from '@fuzdev/fuz_util/string.ts';`,
+			`export * from './reexport.ts';`,
+		].join('\n');
+		const expected = [
+			`import { type ContextmenuRootBaseProps } from './contextmenu_helpers.js';`,
+			`import type {SvgData} from './svg.js';`,
+			`import {Tome} from './tome.js';`,
+			`import {strip_start} from '@fuzdev/fuz_util/string.ts';`,
+			`export * from './reexport.js';`,
+		].join('\n');
+		assert.equal(rewrite_relative_ts_imports(input), expected);
+	});
+});
+
+describe('rewrite_svelte_ts_imports', () => {
+	test('rewrites specifiers inside the `<script>` block only', () => {
+		const input = `<script lang="ts">
+	import {strip_start} from '@fuzdev/fuz_util/string.ts';
+	import {contextmenu_context} from './contextmenu_state.svelte.ts';
+	import {icon_link} from './icons.ts';
+	import type {SvgData} from './svg.ts';
+	import Svg from './Svg.svelte';
+</script>
+
+<a href="./not-an-import.ts">{icon_link}</a>
+`;
+		const expected = `<script lang="ts">
+	import {strip_start} from '@fuzdev/fuz_util/string.ts';
+	import {contextmenu_context} from './contextmenu_state.svelte.js';
+	import {icon_link} from './icons.js';
+	import type {SvgData} from './svg.js';
+	import Svg from './Svg.svelte';
+</script>
+
+<a href="./not-an-import.ts">{icon_link}</a>
+`;
+		assert.equal(rewrite_svelte_ts_imports(input), expected);
+	});
+
+	test('rewrites both module and instance `<script>` blocks', () => {
+		const input = `<script module lang="ts">
+	import {shared} from './shared.ts';
+</script>
+<script lang="ts">
+	import {local} from './local.ts';
+</script>
+`;
+		const expected = `<script module lang="ts">
+	import {shared} from './shared.js';
+</script>
+<script lang="ts">
+	import {local} from './local.js';
+</script>
+`;
+		assert.equal(rewrite_svelte_ts_imports(input), expected);
+	});
+
+	test('preserves `$`-sequences ($$props, $:) while rewriting specifiers', () => {
+		const input = `<script lang="ts">
+	import {x} from './x.ts';
+	const props = $$props;
+	$: doubled = x;
+</script>
+`;
+		const expected = `<script lang="ts">
+	import {x} from './x.js';
+	const props = $$props;
+	$: doubled = x;
+</script>
+`;
+		assert.equal(rewrite_svelte_ts_imports(input), expected);
+	});
+
+	test('leaves a `.svelte` with no rewritable specifiers untouched', () => {
+		const input = `<script lang="ts">
+	import Svg from './Svg.svelte';
+	import {x} from '@fuzdev/fuz_util/x.ts';
+</script>
+<div>hi</div>
+`;
+		assert.equal(rewrite_svelte_ts_imports(input), input);
+	});
+});
+
+describe('rewrite_dist_imports', () => {
+	let dir: string;
+
+	beforeEach(async () => {
+		dir = await mkdtemp(join(tmpdir(), 'gro-dist-rewrite-'));
+	});
+
+	afterEach(async () => {
+		await rm(dir, {recursive: true, force: true});
+	});
+
+	test('rewrites `.d.ts`, `.svelte.d.ts`, and `.svelte`, leaving `.js` and maps alone', async () => {
+		await mkdir(join(dir, 'nested'), {recursive: true});
+		await writeFile(join(dir, 'a.d.ts'), `import type {B} from './b.ts';\n`);
+		await writeFile(join(dir, 'Comp.svelte.d.ts'), `import {type P} from './helpers.ts';\n`);
+		await writeFile(
+			join(dir, 'Comp.svelte'),
+			`<script lang="ts">\n\timport {s} from './state.svelte.ts';\n</script>\n`,
+		);
+		// already emitted by tsc — must stay untouched
+		await writeFile(join(dir, 'a.js'), `import {b} from './b.js';\n`);
+		await writeFile(join(dir, 'a.d.ts.map'), `{"sources":["../src/lib/a.ts"]}\n`);
+		await writeFile(join(dir, 'nested', 'c.d.ts'), `export * from '../a.ts';\n`);
+
+		const result = await rewrite_dist_imports(dir);
+
+		assert.equal(await readFile(join(dir, 'a.d.ts'), 'utf8'), `import type {B} from './b.js';\n`);
+		assert.equal(
+			await readFile(join(dir, 'Comp.svelte.d.ts'), 'utf8'),
+			`import {type P} from './helpers.js';\n`,
+		);
+		assert.equal(
+			await readFile(join(dir, 'Comp.svelte'), 'utf8'),
+			`<script lang="ts">\n\timport {s} from './state.svelte.js';\n</script>\n`,
+		);
+		assert.equal(await readFile(join(dir, 'a.js'), 'utf8'), `import {b} from './b.js';\n`);
+		assert.equal(
+			await readFile(join(dir, 'a.d.ts.map'), 'utf8'),
+			`{"sources":["../src/lib/a.ts"]}\n`,
+		);
+		assert.equal(
+			await readFile(join(dir, 'nested', 'c.d.ts'), 'utf8'),
+			`export * from '../a.js';\n`,
+		);
+
+		// 4 files scanned (a.d.ts, Comp.svelte.d.ts, Comp.svelte, nested/c.d.ts); all 4 rewritten
+		assert.equal(result.scanned, 4);
+		assert.equal(result.rewritten, 4);
+	});
+
+	test('returns zero rewrites for a missing directory', async () => {
+		const result = await rewrite_dist_imports(join(dir, 'does-not-exist'));
+		assert.equal(result.scanned, 0);
+		assert.equal(result.rewritten, 0);
+	});
+});