@stacksjs/defaults 0.75.46 → 0.75.48

package/ai/skills/stacks-chat/SKILL.md

@@ -385,6 +385,11 @@ controller the driver only opens the conversation in Messages for the person to
 from Recently Deleted, and `confirmDeletes: true` accepts Messages' alert too.
 Attic (`~/Code/Apps/attic`, `app/Desktop/messages-control.swift`) is the reference.
 
+A conversation deleted in Messages sits in Recently Deleted for 30 days:
+`conversation.visible` is false and `conversation.deleted` counts what is still
+recoverable. `messages(id, { includeDeleted: true })` reads those messages, so an
+app can keep a deleted conversation without recovering it in Messages.
+
 Discord personal DMs are deliberately absent: only a user token reads them, and
 automating a user account breaks Discord's terms. Reactions are separate
 `kind: 'reaction'` messages with `targetId` and an emoji `reaction`; Slack and

package/ide/vscode/README.md

@@ -8,7 +8,9 @@ The Stacks commands, pickier and the env features activate in workspaces that co
 
 `.stx` files get the full stx language support: highlighting, completions for directives, components and props, hovers, diagnostics, go to definition, folding, semantic highlighting, snippets, and previews of utility classes with their colors.
 
-It is the same code as the standalone [stx extension](https://marketplace.visualstudio.com/items?itemName=Stacks.vscode-stx) (`Stacks.vscode-stx`), built in from `@stacksjs/stx-vscode`. You do not need that extension; if you have both, it stands down so nothing is registered twice.
+The TypeScript in `.stx` files, `<script>` blocks and `{{ }}` template expressions alike, is type-checked by the TypeScript server, with its hovers, completions and go to definition, against the same declarations `stx typecheck` uses: `import { state } from 'stx'` resolves to exactly what the runtime binds. Turn it off with `stxTypescriptPlugin.enabled`.
+
+It is the same code as the standalone [stx extension](https://marketplace.visualstudio.com/items?itemName=Stacks.vscode-stx) (`Stacks.vscode-stx`), built in from `@stacksjs/stx-vscode`. You do not need that extension; if you have both, it stands down so nothing is registered twice, and the TypeScript plugin both contribute checks each file once.
 
 ## Pickier
 
@@ -97,7 +99,7 @@ bun run package    # build and create a .vsix
 code --install-extension vscode-stacks-<version>.vsix
 ```
 
-The extension has no runtime dependencies: `@stacksjs/stx-vscode` and the env decryption from `core/env` are bundled into `dist/extension.js`. It is published automatically by the Stacks release workflow, and `vscode:prepublish` builds `dist/` first.
+The extension has no runtime dependencies: `@stacksjs/stx-vscode` and the env decryption from `core/env` are bundled into `dist/extension.js`. The one exception is the stx TypeScript plugin, which tsserver loads by package name from the extension's `node_modules`: `bun run package` (and `bun run release`, which publishes that VSIX) adds it there after `vsce package --no-dependencies`, which leaves `node_modules` out. It is published automatically by the Stacks release workflow, and `vscode:prepublish` builds `dist/` first.
 
 ## Relevant links
 

package/ide/vscode/build.ts

@@ -5,13 +5,18 @@
  *   pickier-worker.js           the Bun process that runs the project's pickier (src/pickier-worker.ts)
  *   pickier-worker.bunfig.toml  an empty bunfig, so the worker skips the project's preloads
  *   stx/                        grammar, language configuration and snippets from @stacksjs/stx-vscode
+ *   stx-typescript-plugin/      the stx TypeScript server plugin from @stacksjs/stx-vscode
  *
  * `vsce package` runs this first (`vscode:prepublish`), and `files` in
- * package.json ships exactly these.
+ * package.json ships exactly these. tsserver loads the plugin from
+ * node_modules, so a forwarder to it is written there as well, which is what
+ * a development host (`--extensionDevelopmentPath`) loads; scripts/package.ts
+ * adds the same forwarder to the VSIX (see scripts/ts-plugin.ts).
  */
-import { cpSync, mkdirSync, rmSync, writeFileSync } from 'node:fs'
+import { cpSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
 import { dirname, join } from 'node:path'
 import process from 'node:process'
+import { copyTsPlugin, tsPluginName, writeTsPluginForwarder } from './scripts/ts-plugin'
 
 const here = import.meta.dir
 const dist = join(here, 'dist')
@@ -40,4 +45,8 @@ writeFileSync(join(dist, 'pickier-worker.bunfig.toml'), '# Intentionally empty:
 const stxAssets = join(dirname(Bun.resolveSync('@stacksjs/stx-vscode/contributes.json', here)), 'assets')
 cpSync(stxAssets, join(dist, 'stx'), { recursive: true })
 
+copyTsPlugin(here)
+const { version } = JSON.parse(readFileSync(join(here, 'package.json'), 'utf8'))
+writeTsPluginForwarder(here, tsPluginName(here), version)
+
 console.log('Built dist/')

package/ide/vscode/package.json

@@ -2,7 +2,7 @@
   "publisher": "Stacks",
   "name": "vscode-stacks",
   "displayName": "Stacks",
-  "version": "0.75.46",
+  "version": "0.75.48",
   "description": "Stacks, built into VS Code: stx templates, pickier linting and formatting, encrypted env files, the dev server preview and every buddy command. No other extensions required.",
   "license": "MIT",
   "funding": "https://github.com/sponsors/chrisbbreuer",
@@ -44,6 +44,7 @@
     "dist/pickier-worker.js",
     "dist/pickier-worker.bunfig.toml",
     "dist/stx/**",
+    "dist/stx-typescript-plugin/**",
     "LICENSE.md",
     "README.md",
     "logo.png"
@@ -72,8 +73,8 @@
     "test": "bun test ./tests",
     "typecheck": "bun x --bun tsc --noEmit -p tsconfig.json",
     "sync:stx": "bun scripts/stx-contributes.ts --write",
-    "package": "bunx --bun vsce package --no-dependencies",
-    "release": "bunx --bun vsce publish --no-dependencies"
+    "package": "bun scripts/package.ts",
+    "release": "bun scripts/package.ts --publish"
   },
   "galleryBanner": {
     "color": "#d7e4f5",
@@ -410,10 +411,19 @@
           "meta.component.parameters.stx": "typescript"
         }
       }
+    ],
+    "typescriptServerPlugins": [
+      {
+        "name": "@stacksjs/stx-typescript-plugin",
+        "enableForWorkspaceTypeScriptVersions": true,
+        "languages": [
+          "stx"
+        ]
+      }
     ]
   },
   "devDependencies": {
-    "@stacksjs/stx-vscode": "^0.2.357",
+    "@stacksjs/stx-vscode": "^0.2.358",
     "@types/vscode": "~1.109.0",
     "@vscode/vsce": "^4.0.0"
   }

package/ide/vscode/scripts/package.ts

@@ -0,0 +1,71 @@
+/**
+ * Package (and with `--publish`, publish) the extension.
+ *
+ *   bun scripts/package.ts [--out <file.vsix>] [--publish]
+ *
+ * `vsce package --no-dependencies` keeps the VSIX to what `files` lists, and it
+ * leaves out everything under node_modules - including the one package the
+ * extension needs there: the stx TypeScript server plugin, which tsserver will
+ * only load by package name from `<extension>/node_modules` (see ts-plugin.ts).
+ * So its forwarder is added to the VSIX after vsce writes it, and a publish
+ * uploads that VSIX rather than letting vsce package a second time.
+ */
+import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join, resolve } from 'node:path'
+import process from 'node:process'
+import { TS_PLUGIN_DIST, tsPluginModuleDir, tsPluginName, writeTsPluginForwarder } from './ts-plugin'
+
+const ROOT = join(import.meta.dir, '..')
+
+function run(command: string[], cwd = ROOT, capture = false): string {
+  const result = Bun.spawnSync(command, { cwd, stdout: capture ? 'pipe' : 'inherit', stderr: 'inherit', env: process.env })
+  if (result.exitCode !== 0)
+    throw new Error(`${command.join(' ')} exited with ${result.exitCode}`)
+  return capture ? String(result.stdout ?? '') : ''
+}
+
+/** Build the VSIX at `out`, with the TypeScript plugin's forwarder in it. */
+export function packageExtension(out: string): string {
+  const manifest = JSON.parse(readFileSync(join(ROOT, 'package.json'), 'utf8'))
+  const name = tsPluginName(ROOT)
+
+  // vsce runs `vscode:prepublish` (the build) first.
+  run(['bun', 'x', '--bun', 'vsce', 'package', '--no-dependencies', '--out', out])
+
+  // A staging tree whose layout is the VSIX's, so zip records the paths VS
+  // Code extracts: extension/node_modules/<package>/...
+  const stage = mkdtempSync(join(tmpdir(), 'stacks-vsix-'))
+  try {
+    writeTsPluginForwarder(join(stage, 'extension'), name, manifest.version)
+    run(['zip', '-q', '-r', '-X', '-D', out, `extension/${tsPluginModuleDir(name)}`], stage)
+  }
+  finally {
+    rmSync(stage, { recursive: true, force: true })
+  }
+
+  const listing = run(['unzip', '-Z1', out], ROOT, true).split('\n')
+  for (const file of [`extension/${tsPluginModuleDir(name)}/index.js`, `extension/${TS_PLUGIN_DIST}/index.js`, `extension/${TS_PLUGIN_DIST}/typescript-stx-plugin.js`]) {
+    if (!listing.includes(file))
+      throw new Error(`${out} is missing ${file}`)
+  }
+
+  return out
+}
+
+if (import.meta.main) {
+  const args = process.argv.slice(2)
+  const outFlag = args.indexOf('--out')
+  const manifest = JSON.parse(readFileSync(join(ROOT, 'package.json'), 'utf8'))
+  const out = resolve(outFlag === -1 ? join(ROOT, `${manifest.name}-${manifest.version}.vsix`) : args[outFlag + 1]!)
+
+  packageExtension(out)
+  console.log(`Packaged ${out}`)
+
+  if (args.includes('--publish')) {
+    if (!existsSync(out))
+      throw new Error(`${out} was not written`)
+    run(['bun', 'x', '--bun', 'vsce', 'publish', '--packagePath', out])
+    console.log(`Published ${manifest.publisher}.${manifest.name}@${manifest.version}`)
+  }
+}

package/ide/vscode/scripts/stx-contributes.ts

@@ -6,7 +6,8 @@
  * manifest, so the built-in stx support needs them declared here, pointing at
  * dist/stx/ (copied there by build.ts). The library describes them in
  * `contributes.json`; this derives the manifest from it rather than keeping a
- * second copy by hand. Snippets are left out on purpose: the extension offers
+ * second copy by hand. That includes the TypeScript server plugin entry, which
+ * type-checks `.stx` files (see ts-plugin.ts). Snippets are left out on purpose: the extension offers
  * them as completions only when the stx extension is not installed, because
  * a manifest entry would show every snippet twice next to it.
  *
@@ -23,6 +24,7 @@ export interface StxContributes {
   grammars: Array<Record<string, unknown> & { language: string, path: string }>
   commands: Array<{ command: string, title: string, category?: string }>
   configuration: { title: string, properties: Record<string, unknown> }
+  typescriptServerPlugins: Array<Record<string, unknown> & { name: string, languages?: string[] }>
 }
 
 const STX_DIR = './dist/stx/'
@@ -54,6 +56,7 @@ export function withStxContributes(manifest: any, stx: StxContributes): any {
       grammars: stx.grammars.map(grammar => ({ ...grammar, path: fromStx(grammar.path) })),
       commands: [...contributes.commands.filter((command: { command: string }) => command.command.startsWith(OWN_COMMAND_PREFIX)), ...stx.commands],
       configuration: [...sections.filter(section => section.title !== stx.configuration.title), stx.configuration],
+      typescriptServerPlugins: stx.typescriptServerPlugins,
     },
   }
 }

package/ide/vscode/scripts/ts-plugin.ts

@@ -0,0 +1,72 @@
+/**
+ * The stx TypeScript server plugin, as this extension ships it.
+ *
+ * It is what type-checks the TypeScript in `.stx` files (script blocks and
+ * template expressions) in the editor. `@stacksjs/stx-vscode` publishes it as a
+ * complete package, `dist/typescript-plugin/`, and its `contributes.json`
+ * carries the `typescriptServerPlugins` entry that `bun run sync:stx` copies
+ * into package.json.
+ *
+ * tsserver loads a plugin only by package name, resolved from
+ * `<extension>/node_modules`, the probe location VS Code passes for every
+ * extension that contributes one. This extension is packaged with
+ * `vsce --no-dependencies`, which leaves node_modules out of the VSIX, so:
+ *
+ *   dist/stx-typescript-plugin/            the package itself, copied by build.ts
+ *                                          (shipped through `files`, like the rest of dist/)
+ *   node_modules/<name>/{package.json,index.js}
+ *                                          a forwarder to it, written by build.ts for
+ *                                          a development host and added to the VSIX
+ *                                          by scripts/package.ts after vsce writes it
+ *
+ * The stx extension (Stacks.vscode-stx) contributes the same plugin under the
+ * same name. With both installed tsserver loads it twice, and the plugin
+ * decorates each project only the first time (stacksjs/stx#2028).
+ */
+import { cpSync, mkdirSync, rmSync, writeFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { libraryContributes } from './stx-contributes'
+
+/** Where build.ts puts the plugin package, relative to the extension root. */
+export const TS_PLUGIN_DIST = 'dist/stx-typescript-plugin'
+
+/** The name the plugin is contributed and configured under. */
+export function tsPluginName(root: string): string {
+  const [plugin] = libraryContributes(root).typescriptServerPlugins
+  if (!plugin)
+    throw new Error('@stacksjs/stx-vscode contributes no TypeScript server plugin')
+  return plugin.name
+}
+
+/** Where tsserver resolves the plugin from, relative to the extension root. */
+export function tsPluginModuleDir(name: string): string {
+  return `node_modules/${name}`
+}
+
+/** The forwarder's files, relative to its directory under node_modules. */
+export function tsPluginForwarder(name: string, version: string): Record<string, string> {
+  const up = '../'.repeat(1 + name.split('/').length)
+  return {
+    'package.json': `${JSON.stringify({ name, version, private: true, main: 'index.js' }, null, 2)}\n`,
+    // tsserver calls `module.exports` as the factory, unwrapped.
+    'index.js': `module.exports = require('${up}${TS_PLUGIN_DIST}/index.js')\n`,
+  }
+}
+
+/** Write the forwarder under `<root>/node_modules`, returning its directory. */
+export function writeTsPluginForwarder(root: string, name: string, version: string): string {
+  const dir = join(root, tsPluginModuleDir(name))
+  mkdirSync(dir, { recursive: true })
+  for (const [file, content] of Object.entries(tsPluginForwarder(name, version)))
+    writeFileSync(join(dir, file), content)
+  return dir
+}
+
+/** Copy the plugin package from `@stacksjs/stx-vscode` into `<root>/dist`. */
+export function copyTsPlugin(root: string): string {
+  const source = dirname(Bun.resolveSync('@stacksjs/stx-vscode/typescript-plugin/package.json', root))
+  const target = join(root, TS_PLUGIN_DIST)
+  rmSync(target, { recursive: true, force: true })
+  cpSync(source, target, { recursive: true })
+  return target
+}

package/ide/vscode/src/extension.ts

@@ -6,7 +6,8 @@
  * - ./stacks.ts   preview, dev server and buddy commands
  * - ./pickier.ts  lint diagnostics, formatting and fix-all from the project's pickier
  * - ./env.ts      decrypted env values on hover, missing keys, `buddy env:*` commands
- * - stx           the stx extension's language support, built in from `@stacksjs/stx-vscode`
+ * - stx           the stx extension's language support, built in from `@stacksjs/stx-vscode`,
+ *                 and its TypeScript server plugin, which type-checks `.stx` files
  *
  * Nothing here depends on another extension being installed.
  */
@@ -18,7 +19,7 @@ import { connect } from 'node:net'
 import { join } from 'node:path'
 import process from 'node:process'
 import { createInterface } from 'node:readline'
-import { activateStxLanguage, deactivateStxLanguage, STX_EXTENSION_ID } from '@stacksjs/stx-vscode'
+import { activateStxLanguage, configureTypeScriptPlugin, deactivateStxLanguage, STX_EXTENSION_ID } from '@stacksjs/stx-vscode'
 import * as vscode from 'vscode'
 import { createEnvSupport, projectDecryptor } from './env'
 import { createPickierSupport } from './pickier'
@@ -136,6 +137,15 @@ async function startStx(context: vscode.ExtensionContext): Promise<boolean> {
 }
 
 export async function activate(context: vscode.ExtensionContext): Promise<StacksExtensionApi> {
+  // The manifest contributes the stx TypeScript server plugin. VS Code's
+  // TypeScript extension does not activate on `stx` by itself, so this starts
+  // it, and forwards `stxTypescriptPlugin.enabled` to the plugin. The stx
+  // extension, when installed, does the same; the plugin decorates a project
+  // once however many extensions contribute it.
+  configureTypeScriptPlugin(vscode, context.subscriptions).catch((error) => {
+    console.error('Stacks: could not configure the stx TypeScript plugin', error)
+  })
+
   stacks.activate(context)
   env.activate(context)
   pickier = createPickierSupport(vscode, { exists: existsSync, spawnBun }, {

package/ide/vscode/tests/build.test.ts

@@ -8,6 +8,8 @@ import { existsSync, readFileSync } from 'node:fs'
 import { builtinModules } from 'node:module'
 import { join } from 'node:path'
 import process from 'node:process'
+import { TS_PLUGIN_DIST, tsPluginName } from '../scripts/ts-plugin'
+import { expectDeclarationsFound, loadLikeTsserver } from './ts-plugin-harness'
 
 const root = join(import.meta.dir, '..')
 const manifest = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'))
@@ -39,6 +41,28 @@ describe('dist/extension.js', () => {
 
     expect(unshipped).toEqual([])
   })
+
+  it('starts the TypeScript extension and configures the stx plugin by the name the manifest contributes', () => {
+    const bundle = readFileSync(join(root, 'dist/extension.js'), 'utf8')
+    expect(bundle).toContain('vscode.typescript-language-features')
+    expect(bundle).toContain('configurePlugin')
+    for (const plugin of manifest.contributes.typescriptServerPlugins)
+      expect(bundle).toContain(plugin.name)
+  })
+})
+
+describe('the stx TypeScript plugin', () => {
+  it('is in dist/ as the package the manifest contributes', () => {
+    const plugin = JSON.parse(readFileSync(join(root, TS_PLUGIN_DIST, 'package.json'), 'utf8'))
+    expect(manifest.contributes.typescriptServerPlugins.map((entry: { name: string }) => entry.name)).toEqual([plugin.name])
+    expect(manifest.files).toContain(`${TS_PLUGIN_DIST}/**`)
+  })
+
+  it('loads from node_modules the way tsserver loads it, as in a development host', () => {
+    const name = tsPluginName(root)
+    expect(typeof loadLikeTsserver(root, name)).toBe('function')
+    expectDeclarationsFound(root, name, join(root, TS_PLUGIN_DIST, 'types'))
+  })
 })
 
 describe('dist/', () => {

package/ide/vscode/tests/manifest.test.ts

@@ -92,7 +92,47 @@ describe('stx language support', () => {
   })
 })
 
+// tsserver loads a plugin only by package name, from the extension's
+// node_modules, and VS Code only sends it documents of a language a plugin
+// claims (stacksjs/stx#2028).
+describe('stx type checking', () => {
+  const plugins = manifest.contributes.typescriptServerPlugins as Array<{ name: string, languages?: string[], enableForWorkspaceTypeScriptVersions?: boolean }>
+
+  it('contributes the stx TypeScript server plugin by package name', () => {
+    expect(plugins.map(plugin => plugin.name)).toEqual(['@stacksjs/stx-typescript-plugin'])
+    for (const plugin of plugins) {
+      // The rule tsserver applies before loading anything (requestEnablePlugin).
+      expect(plugin.name).not.toMatch(/^(?:\.\.?(?:\/|$)|\/|[a-z]:)/i)
+      expect(plugin.name).not.toMatch(/[\\/]\.\.?(?:$|[\\/])/)
+    }
+  })
+
+  it('claims the stx language, also with the workspace TypeScript the project settings select', () => {
+    for (const plugin of plugins) {
+      expect(plugin.languages).toEqual(['stx'])
+      expect(plugin.enableForWorkspaceTypeScriptVersions).toBeTrue()
+    }
+    expect(manifest.contributes.configurationDefaults['typescript.tsdk']).toBe('node_modules/typescript/lib')
+  })
+
+  it('declares the setting that switches it off', () => {
+    const settings = Object.assign({}, ...manifest.contributes.configuration.map((section: { properties: object }) => section.properties))
+    expect(settings['stxTypescriptPlugin.enabled'].default).toBeTrue()
+  })
+})
+
 describe('packaging', () => {
+  it('adds the plugin to the VSIX, which vsce --no-dependencies leaves without node_modules', () => {
+    expect(manifest.scripts.package).toBe('bun scripts/package.ts')
+    expect(manifest.scripts.release).toBe('bun scripts/package.ts --publish')
+    expect(readFileSync(join(root, 'scripts/package.ts'), 'utf8')).toContain(`'vsce', 'package', '--no-dependencies'`)
+    // The release workflow publishes through the script, not a bare `vsce publish`.
+    const workflow = readFileSync(join(root, '../../../../../.github/workflows/release.yml'), 'utf8')
+    const step = workflow.slice(workflow.indexOf('- name: Publish VS Code Extension'))
+    expect(step.slice(0, step.indexOf('- name:', 10))).toContain('bun run release')
+    expect(workflow).not.toContain('vsce publish')
+  })
+
   it('ships the files the extension loads at runtime', () => {
     for (const file of ['dist/extension.js', 'dist/pickier-worker.js', 'dist/pickier-worker.bunfig.toml'])
       expect(manifest.files).toContain(file)

package/ide/vscode/tests/package.test.ts

@@ -0,0 +1,47 @@
+/**
+ * The VSIX, as VS Code installs it. It is packaged with `--no-dependencies`,
+ * which leaves node_modules out, so scripts/package.ts adds the stx TypeScript
+ * plugin's entry there afterwards; without it tsserver finds no plugin and no
+ * `.stx` file is type-checked.
+ */
+import { describe, expect, it } from 'bun:test'
+import { mkdtempSync, readFileSync, realpathSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { packageExtension } from '../scripts/package'
+import { TS_PLUGIN_DIST, tsPluginModuleDir, tsPluginName } from '../scripts/ts-plugin'
+import { expectDeclarationsFound, loadLikeTsserver } from './ts-plugin-harness'
+
+const root = join(import.meta.dir, '..')
+const manifest = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'))
+
+// vsce runs `vscode:prepublish` through npm, so this needs npm on PATH; the
+// release workflow, which runs these tests before publishing, has it.
+const canPackage = Boolean(Bun.which('npm') && Bun.which('zip') && Bun.which('unzip'))
+
+describe('the VSIX', () => {
+  it.skipIf(!canPackage)('carries the stx TypeScript plugin, and it loads from the installed layout', () => {
+    // Real path: require() resolves symlinks, and macOS's tmpdir is one.
+    const dir = realpathSync(mkdtempSync(join(tmpdir(), 'stacks-vsix-test-')))
+    try {
+      const vsix = packageExtension(join(dir, 'stacks.vsix'))
+      const listing = Bun.spawnSync(['unzip', '-Z1', vsix]).stdout.toString().split('\n')
+      const name = tsPluginName(root)
+
+      expect(listing).toContain(`extension/${tsPluginModuleDir(name)}/package.json`)
+      expect(listing).toContain(`extension/${tsPluginModuleDir(name)}/index.js`)
+      // Nothing else of node_modules: the bundle carries its dependencies.
+      expect(listing.filter(file => file.startsWith('extension/node_modules/') && !file.startsWith(`extension/${tsPluginModuleDir(name)}/`))).toEqual([])
+      expect(listing).toContain(`extension/${TS_PLUGIN_DIST}/types/stx-module.d.ts`)
+
+      expect(Bun.spawnSync(['unzip', '-q', vsix, 'extension/*', '-d', dir]).exitCode).toBe(0)
+      const installed = join(dir, 'extension')
+      expect(JSON.parse(readFileSync(join(installed, 'package.json'), 'utf8')).version).toBe(manifest.version)
+      expect(typeof loadLikeTsserver(installed, name)).toBe('function')
+      expectDeclarationsFound(installed, name, join(installed, TS_PLUGIN_DIST, 'types'))
+    }
+    finally {
+      rmSync(dir, { recursive: true, force: true })
+    }
+  }, 180_000)
+})

package/ide/vscode/tests/ts-plugin-harness.ts

@@ -0,0 +1,39 @@
+/**
+ * Loading the stx TypeScript server plugin the way tsserver loads it, for the
+ * tests that check the built extension and the packaged VSIX.
+ */
+import { expect } from 'bun:test'
+import { existsSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import { join } from 'node:path'
+
+/**
+ * `require()` the plugin by name from `<extensionRoot>/node_modules` (VS Code
+ * passes the extension root as the probe location) and take `module.exports`
+ * as the factory, unwrapped, as tsserver does.
+ */
+export function loadLikeTsserver(extensionRoot: string, name: string): unknown {
+  return createRequire(join(extensionRoot, 'node_modules', 'index.js'))(name)
+}
+
+/**
+ * Create the plugin on a stub language service and read the buffer it serves
+ * for a `.stx` file: line 1 references the declaration files the plugin found,
+ * which it can only find when the package tells it where they are (Bun inlines
+ * `__dirname` into the bundle at build time).
+ */
+export function expectDeclarationsFound(extensionRoot: string, name: string, typesDir: string): void {
+  const factory = loadLikeTsserver(extensionRoot, name) as (modules: { typescript: unknown }) => { create: (info: unknown) => unknown }
+  expect(typeof factory).toBe('function')
+
+  const text = '<script client>\nconst n = state(0)\n</script>\n'
+  const snapshot = (value: string) => ({ getText: (start: number, end: number) => value.slice(start, end), getLength: () => value.length, getChangeRange: () => undefined })
+  const host: Record<string, any> = { getScriptSnapshot: () => snapshot(text), getScriptVersion: () => '1' }
+  factory({ typescript: { ScriptSnapshot: { fromString: snapshot } } })
+    .create({ languageService: {}, languageServiceHost: host, project: { projectService: { logger: { info: () => {} } } } })
+
+  const buffer = host.getScriptSnapshot('/tmp/page.stx')
+  const referenced = /^\/\/\/ <reference path="(.+)" \/>$/.exec(buffer.getText(0, buffer.getLength()).split('\n')[0])?.[1]
+  expect(referenced).toBe(join(typesDir, 'stx-module.d.ts'))
+  expect(existsSync(join(typesDir, 'stx.d.ts'))).toBeTrue()
+}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@stacksjs/defaults",
   "type": "module",
   "sideEffects": false,
-  "version": "0.75.46",
+  "version": "0.75.48",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/stacksjs/stacks.git",
@@ -55,7 +55,7 @@
   "dependencies": {
     "@iconify-json/f7": "^1.2.2",
     "@iconify-json/hugeicons": "^1.2.35",
-    "@stacksjs/mobile": "^0.75.46",
+    "@stacksjs/mobile": "^0.75.48",
     "@stacksjs/sanitizer": "^0.2.348",
     "ts-qr-codes": "^0.1.8"
   }