@vibesdotdev/kit 0.0.0-stage → 1.0.0-rc.4

package/dist/lib/components/code/language.js

@@ -0,0 +1,132 @@
+import { settleNow } from '../../attempt';
+/** Own keys only: `constructor`, `toString` and friends are not languages. */
+function isTableKey(table, key) {
+    return Object.hasOwn(table, key);
+}
+const EXACT_FILENAME_LANGUAGE = {
+    dockerfile: 'dockerfile',
+    containerfile: 'dockerfile',
+    makefile: 'makefile',
+    rakefile: 'ruby',
+    gemfile: 'ruby',
+    'package.json': 'json',
+    'package-lock.json': 'json',
+    'bun.lock': 'plaintext',
+    'pnpm-lock.yaml': 'yaml',
+    'yarn.lock': 'yaml',
+    'tsconfig.json': 'json',
+    'jsconfig.json': 'json'
+};
+const EXTENSION_LANGUAGE = {
+    bash: 'shell',
+    c: 'c',
+    cc: 'cpp',
+    cjs: 'javascript',
+    cpp: 'cpp',
+    cs: 'csharp',
+    css: 'css',
+    cts: 'typescript',
+    go: 'go',
+    gql: 'graphql',
+    graphql: 'graphql',
+    h: 'c',
+    hpp: 'cpp',
+    htm: 'html',
+    html: 'html',
+    ini: 'ini',
+    java: 'java',
+    js: 'javascript',
+    json: 'json',
+    jsonc: 'json',
+    jsx: 'javascript',
+    less: 'less',
+    markdown: 'markdown',
+    md: 'markdown',
+    mdx: 'mdx',
+    mjs: 'javascript',
+    mts: 'typescript',
+    py: 'python',
+    rb: 'ruby',
+    rs: 'rust',
+    scss: 'scss',
+    sh: 'shell',
+    sql: 'sql',
+    svelte: 'html',
+    toml: 'ini',
+    ts: 'typescript',
+    tsx: 'typescript',
+    vue: 'html',
+    xml: 'xml',
+    yaml: 'yaml',
+    yml: 'yaml',
+    zig: 'plaintext',
+    zsh: 'shell'
+};
+const LANGUAGE_ALIASES = {
+    bash: 'shell',
+    md: 'markdown',
+    plaintext: 'plaintext',
+    sh: 'shell',
+    shellscript: 'shell',
+    text: 'plaintext',
+    ts: 'typescript',
+    tsx: 'typescript',
+    js: 'javascript',
+    jsx: 'javascript',
+    mdx: 'mdx',
+    xml: 'xml',
+    svelte: 'html'
+};
+export function normalizeCodeLanguage(language) {
+    const value = (language ?? '').trim().toLowerCase();
+    if (!value || value === 'auto')
+        return 'auto';
+    return isTableKey(LANGUAGE_ALIASES, value) ? LANGUAGE_ALIASES[value] : value;
+}
+export function languageFromFilename(filename) {
+    const rawName = (filename ?? '').trim();
+    if (!rawName)
+        return undefined;
+    const name = rawName.split(/[\\/]/).pop()?.toLowerCase() ?? rawName.toLowerCase();
+    if (isTableKey(EXACT_FILENAME_LANGUAGE, name))
+        return EXACT_FILENAME_LANGUAGE[name];
+    const lastDot = name.lastIndexOf('.');
+    if (lastDot <= 0 || lastDot === name.length - 1)
+        return undefined;
+    const extension = name.slice(lastDot + 1);
+    return isTableKey(EXTENSION_LANGUAGE, extension) ? EXTENSION_LANGUAGE[extension] : undefined;
+}
+export function inferCodeLanguage(content, filename) {
+    const filenameLanguage = languageFromFilename(filename);
+    if (filenameLanguage)
+        return filenameLanguage;
+    const source = (content || '').trim();
+    if (!source)
+        return 'plaintext';
+    // A parse failure means "not JSON": keep looking.
+    if ((source.startsWith('{') || source.startsWith('[')) &&
+        settleNow(() => JSON.parse(source)).ok) {
+        return 'json';
+    }
+    if (source.startsWith('<'))
+        return 'html';
+    if (/(^|\n)\s{0,3}(#{1,6}\s|[-*+]\s|```)/.test(source))
+        return 'markdown';
+    if (/\b(interface|type|enum)\s+/.test(source))
+        return 'typescript';
+    if (/^#!.*\b(?:bash|sh|zsh)\b/.test(source))
+        return 'shell';
+    return 'plaintext';
+}
+export function resolveCodeLanguage(content, filename, language) {
+    const normalized = normalizeCodeLanguage(language);
+    if (normalized !== 'auto')
+        return normalized;
+    return inferCodeLanguage(content, filename);
+}
+export function countCodeDisplayLines(code) {
+    if (!code)
+        return 1;
+    const withoutTerminalNewline = code.endsWith('\n') ? code.slice(0, -1) : code;
+    return Math.max(1, withoutTerminalNewline.split('\n').length);
+}

package/dist/lib/components/code/monaco/themes/Tomorrow-Night-Bright.json

@@ -0,0 +1,6 @@
+{
+	"base": "vs-dark",
+	"inherit": true,
+	"rules": [],
+	"colors": {}
+}

package/dist/lib/components/code/monaco/themes/Tomorrow.json

@@ -0,0 +1,6 @@
+{
+	"base": "vs",
+	"inherit": true,
+	"rules": [],
+	"colors": {}
+}

package/dist/lib/components/code/monaco/types/benchmark-env.d.ts

@@ -0,0 +1,4 @@
+// Stub: minimal benchmark environment types for Monaco autocomplete
+declare const bench: (name: string, fn: () => void | Promise<void>) => void;
+declare const group: (name: string, fn: () => void) => void;
+declare const run: () => Promise<void>;

package/dist/lib/components/code/monaco/types/bun-test-types.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The `bun:test` declarations Monaco's TypeScript service loads for editor
+ * autocomplete (see `injectBunTypes` in `monaco-setup.ts`).
+ *
+ * This is editor content, not a kit type: it is kept as text so it never
+ * joins kit's own type program. The text is passed to Monaco unchanged.
+ */
+export declare const BUN_TEST_TYPES = "// Stub: bun:test types for Monaco autocomplete. Matcher surface covers\n// toEqual, toThrow, resolves, rejects, and the rest of the bun expect API.\ndeclare module 'bun:test' {\n\tinterface BunMatchers {\n\t\ttoBe(expected: unknown): void;\n\t\ttoEqual(expected: unknown): void;\n\t\ttoStrictEqual(expected: unknown): void;\n\t\ttoBeNull(): void;\n\t\ttoBeUndefined(): void;\n\t\ttoBeDefined(): void;\n\t\ttoBeNaN(): void;\n\t\ttoBeTruthy(): void;\n\t\ttoBeFalsy(): void;\n\t\ttoBeCloseTo(expected: number, numDigits?: number): void;\n\t\ttoBeGreaterThan(expected: number | bigint): void;\n\t\ttoBeGreaterThanOrEqual(expected: number | bigint): void;\n\t\ttoBeLessThan(expected: number | bigint): void;\n\t\ttoBeLessThanOrEqual(expected: number | bigint): void;\n\t\ttoBeInstanceOf(expected: unknown): void;\n\t\ttoContain(expected: unknown): void;\n\t\ttoContainEqual(expected: unknown): void;\n\t\ttoHaveLength(expected: number): void;\n\t\ttoHaveProperty(keyPath: string | Array<string | number>, value?: unknown): void;\n\t\ttoMatch(expected: string | RegExp): void;\n\t\ttoMatchObject(expected: unknown): void;\n\t\ttoThrow(expected?: unknown): void;\n\t\ttoThrowError(expected?: unknown): void;\n\t\ttoBeEmpty(): void;\n\t\ttoBeEmptyObject(): void;\n\t\ttoBeNil(): void;\n\t\ttoBeArray(): void;\n\t\ttoBeArrayOfSize(size: number): void;\n\t\ttoBeBoolean(): void;\n\t\ttoBeTrue(): void;\n\t\ttoBeFalse(): void;\n\t\ttoBeNumber(): void;\n\t\ttoBeInteger(): void;\n\t\ttoBeFinite(): void;\n\t\ttoBePositive(): void;\n\t\ttoBeNegative(): void;\n\t\ttoBeEven(): void;\n\t\ttoBeOdd(): void;\n\t\ttoBeWithin(start: number, end: number): void;\n\t\ttoBeString(): void;\n\t\ttoBeObject(): void;\n\t\ttoBeFunction(): void;\n\t\ttoBeSymbol(): void;\n\t\ttoBeDate(): void;\n\t\ttoBeValidDate(): void;\n\t\ttoBeDateString(): void;\n\t\ttoBeHexadecimal(): void;\n\t\ttoBeTypeOf(\n\t\t\ttype:\n\t\t\t\t| 'bigint'\n\t\t\t\t| 'boolean'\n\t\t\t\t| 'function'\n\t\t\t\t| 'number'\n\t\t\t\t| 'object'\n\t\t\t\t| 'string'\n\t\t\t\t| 'symbol'\n\t\t\t\t| 'undefined'\n\t\t): void;\n\t\ttoBeOneOf(expected: Iterable<unknown>): void;\n\t\ttoStartWith(expected: string): void;\n\t\ttoEndWith(expected: string): void;\n\t\ttoInclude(expected: string): void;\n\t\ttoIncludeRepeated(expected: string, times: number): void;\n\t\ttoEqualIgnoringWhitespace(expected: string): void;\n\t\ttoSatisfy(predicate: (value: unknown) => boolean): void;\n\t\ttoContainKey(key: PropertyKey): void;\n\t\ttoContainKeys(keys: Array<PropertyKey>): void;\n\t\ttoContainAllKeys(keys: Array<PropertyKey>): void;\n\t\ttoContainAnyKeys(keys: Array<PropertyKey>): void;\n\t\ttoContainValue(value: unknown): void;\n\t\ttoContainValues(values: Array<unknown>): void;\n\t\ttoContainAllValues(values: Array<unknown>): void;\n\t\ttoContainAnyValues(values: Array<unknown>): void;\n\t\ttoHaveBeenCalled(): void;\n\t\ttoBeCalled(): void;\n\t\ttoHaveBeenCalledTimes(count: number): void;\n\t\ttoBeCalledTimes(count: number): void;\n\t\ttoHaveBeenCalledWith(...args: unknown[]): void;\n\t\ttoBeCalledWith(...args: unknown[]): void;\n\t\ttoHaveBeenLastCalledWith(...args: unknown[]): void;\n\t\tlastCalledWith(...args: unknown[]): void;\n\t\ttoHaveBeenNthCalledWith(n: number, ...args: unknown[]): void;\n\t\tnthCalledWith(n: number, ...args: unknown[]): void;\n\t\ttoHaveReturned(): void;\n\t\ttoHaveReturnedTimes(times: number): void;\n\t\ttoHaveReturnedWith(expected: unknown): void;\n\t\ttoHaveLastReturnedWith(expected: unknown): void;\n\t\ttoHaveNthReturnedWith(n: number, expected: unknown): void;\n\t\ttoMatchSnapshot(hint?: string): void;\n\t\ttoMatchSnapshot(propertyMatchers?: object, hint?: string): void;\n\t\ttoMatchInlineSnapshot(value?: string): void;\n\t\ttoMatchInlineSnapshot(propertyMatchers?: object, value?: string): void;\n\t\ttoThrowErrorMatchingSnapshot(hint?: string): void;\n\t\ttoThrowErrorMatchingInlineSnapshot(value?: string): void;\n\t\tnot: BunMatchers;\n\t\tresolves: BunMatchers;\n\t\trejects: BunMatchers;\n\t}\n\n\texport function describe(name: string, fn: () => void): void;\n\texport function test(name: string, fn: () => void | Promise<void>): void;\n\texport function it(name: string, fn: () => void | Promise<void>): void;\n\texport function expect(value: unknown): BunMatchers;\n\texport function beforeAll(fn: () => void | Promise<void>): void;\n\texport function afterAll(fn: () => void | Promise<void>): void;\n\texport function beforeEach(fn: () => void | Promise<void>): void;\n\texport function afterEach(fn: () => void | Promise<void>): void;\n}\n";

package/dist/lib/components/code/monaco/types/bun-test-types.js

@@ -0,0 +1,120 @@
+/**
+ * The `bun:test` declarations Monaco's TypeScript service loads for editor
+ * autocomplete (see `injectBunTypes` in `monaco-setup.ts`).
+ *
+ * This is editor content, not a kit type: it is kept as text so it never
+ * joins kit's own type program. The text is passed to Monaco unchanged.
+ */
+export const BUN_TEST_TYPES = `// Stub: bun:test types for Monaco autocomplete. Matcher surface covers
+// toEqual, toThrow, resolves, rejects, and the rest of the bun expect API.
+declare module 'bun:test' {
+	interface BunMatchers {
+		toBe(expected: unknown): void;
+		toEqual(expected: unknown): void;
+		toStrictEqual(expected: unknown): void;
+		toBeNull(): void;
+		toBeUndefined(): void;
+		toBeDefined(): void;
+		toBeNaN(): void;
+		toBeTruthy(): void;
+		toBeFalsy(): void;
+		toBeCloseTo(expected: number, numDigits?: number): void;
+		toBeGreaterThan(expected: number | bigint): void;
+		toBeGreaterThanOrEqual(expected: number | bigint): void;
+		toBeLessThan(expected: number | bigint): void;
+		toBeLessThanOrEqual(expected: number | bigint): void;
+		toBeInstanceOf(expected: unknown): void;
+		toContain(expected: unknown): void;
+		toContainEqual(expected: unknown): void;
+		toHaveLength(expected: number): void;
+		toHaveProperty(keyPath: string | Array<string | number>, value?: unknown): void;
+		toMatch(expected: string | RegExp): void;
+		toMatchObject(expected: unknown): void;
+		toThrow(expected?: unknown): void;
+		toThrowError(expected?: unknown): void;
+		toBeEmpty(): void;
+		toBeEmptyObject(): void;
+		toBeNil(): void;
+		toBeArray(): void;
+		toBeArrayOfSize(size: number): void;
+		toBeBoolean(): void;
+		toBeTrue(): void;
+		toBeFalse(): void;
+		toBeNumber(): void;
+		toBeInteger(): void;
+		toBeFinite(): void;
+		toBePositive(): void;
+		toBeNegative(): void;
+		toBeEven(): void;
+		toBeOdd(): void;
+		toBeWithin(start: number, end: number): void;
+		toBeString(): void;
+		toBeObject(): void;
+		toBeFunction(): void;
+		toBeSymbol(): void;
+		toBeDate(): void;
+		toBeValidDate(): void;
+		toBeDateString(): void;
+		toBeHexadecimal(): void;
+		toBeTypeOf(
+			type:
+				| 'bigint'
+				| 'boolean'
+				| 'function'
+				| 'number'
+				| 'object'
+				| 'string'
+				| 'symbol'
+				| 'undefined'
+		): void;
+		toBeOneOf(expected: Iterable<unknown>): void;
+		toStartWith(expected: string): void;
+		toEndWith(expected: string): void;
+		toInclude(expected: string): void;
+		toIncludeRepeated(expected: string, times: number): void;
+		toEqualIgnoringWhitespace(expected: string): void;
+		toSatisfy(predicate: (value: unknown) => boolean): void;
+		toContainKey(key: PropertyKey): void;
+		toContainKeys(keys: Array<PropertyKey>): void;
+		toContainAllKeys(keys: Array<PropertyKey>): void;
+		toContainAnyKeys(keys: Array<PropertyKey>): void;
+		toContainValue(value: unknown): void;
+		toContainValues(values: Array<unknown>): void;
+		toContainAllValues(values: Array<unknown>): void;
+		toContainAnyValues(values: Array<unknown>): void;
+		toHaveBeenCalled(): void;
+		toBeCalled(): void;
+		toHaveBeenCalledTimes(count: number): void;
+		toBeCalledTimes(count: number): void;
+		toHaveBeenCalledWith(...args: unknown[]): void;
+		toBeCalledWith(...args: unknown[]): void;
+		toHaveBeenLastCalledWith(...args: unknown[]): void;
+		lastCalledWith(...args: unknown[]): void;
+		toHaveBeenNthCalledWith(n: number, ...args: unknown[]): void;
+		nthCalledWith(n: number, ...args: unknown[]): void;
+		toHaveReturned(): void;
+		toHaveReturnedTimes(times: number): void;
+		toHaveReturnedWith(expected: unknown): void;
+		toHaveLastReturnedWith(expected: unknown): void;
+		toHaveNthReturnedWith(n: number, expected: unknown): void;
+		toMatchSnapshot(hint?: string): void;
+		toMatchSnapshot(propertyMatchers?: object, hint?: string): void;
+		toMatchInlineSnapshot(value?: string): void;
+		toMatchInlineSnapshot(propertyMatchers?: object, value?: string): void;
+		toThrowErrorMatchingSnapshot(hint?: string): void;
+		toThrowErrorMatchingInlineSnapshot(value?: string): void;
+		not: BunMatchers;
+		resolves: BunMatchers;
+		rejects: BunMatchers;
+	}
+
+	export function describe(name: string, fn: () => void): void;
+	export function test(name: string, fn: () => void | Promise<void>): void;
+	export function it(name: string, fn: () => void | Promise<void>): void;
+	export function expect(value: unknown): BunMatchers;
+	export function beforeAll(fn: () => void | Promise<void>): void;
+	export function afterAll(fn: () => void | Promise<void>): void;
+	export function beforeEach(fn: () => void | Promise<void>): void;
+	export function afterEach(fn: () => void | Promise<void>): void;
+}
+`;

package/dist/lib/components/code/monaco/types/vite-imports.d.ts

@@ -0,0 +1,11 @@
+declare module '*?raw' {
+	const content: string;
+	export default content;
+}
+
+declare module '*?worker' {
+	const WorkerConstructor: {
+		new (): Worker;
+	};
+	export default WorkerConstructor;
+}

package/dist/lib/components/code/monaco-loader-minimal.d.ts

@@ -0,0 +1,17 @@
+type MonacoModule = typeof import('monaco-editor');
+/**
+ * Monaco with NO language services.
+ *
+ * The bundled loader pulls the json, css, html, typescript and graphql
+ * language-server workers. Measured 2026-09-01 that set is 8.2 MB, and Vite
+ * emits every one of them into any deployment whose module graph reaches
+ * `monaco-loader.ts` — a dynamic `import()` still produces the chunk, so the
+ * split has to happen at the module boundary rather than behind a runtime flag.
+ *
+ * A plain-text or markdown surface uses none of them. It needs the editor
+ * worker, which is what makes tokenization and diffing run off the main thread.
+ *
+ * Reach for `configureBundledMonacoLoader` when the surface edits code.
+ */
+export declare function configureMinimalMonacoLoader(): Promise<MonacoModule>;
+export {};

package/dist/lib/components/code/monaco-loader-minimal.js

@@ -0,0 +1,48 @@
+let minimalLoaderPromise = null;
+/** Whether an installed environment already routes workers. Monaco accepts either hook. */
+function routesWorkers(environment) {
+    return (typeof environment?.getWorker === 'function' || typeof environment?.getWorkerUrl === 'function');
+}
+/**
+ * Monaco with NO language services.
+ *
+ * The bundled loader pulls the json, css, html, typescript and graphql
+ * language-server workers. Measured 2026-09-01 that set is 8.2 MB, and Vite
+ * emits every one of them into any deployment whose module graph reaches
+ * `monaco-loader.ts` — a dynamic `import()` still produces the chunk, so the
+ * split has to happen at the module boundary rather than behind a runtime flag.
+ *
+ * A plain-text or markdown surface uses none of them. It needs the editor
+ * worker, which is what makes tokenization and diffing run off the main thread.
+ *
+ * Reach for `configureBundledMonacoLoader` when the surface edits code.
+ */
+export function configureMinimalMonacoLoader() {
+    minimalLoaderPromise ??= Promise.all([
+        import('@monaco-editor/loader'),
+        import('monaco-editor'),
+        import('monaco-editor/editor/editor.worker?worker')
+    ])
+        .then(([loaderModule, monacoModule, editorWorker]) => {
+        const EditorWorker = editorWorker.default;
+        // Monaco reads its environment hook from the window (it types it on `Window`); the
+        // host may have installed one.
+        const environment = window.MonacoEnvironment;
+        // Keep richer bundled or host-provided routing.
+        if (!routesWorkers(environment)) {
+            window.MonacoEnvironment = {
+                ...environment,
+                getWorker() {
+                    return new EditorWorker();
+                }
+            };
+        }
+        loaderModule.default.config({ monaco: monacoModule });
+        return monacoModule;
+    })
+        .catch((error) => {
+        minimalLoaderPromise = null;
+        throw error;
+    });
+    return minimalLoaderPromise;
+}

package/dist/lib/components/code/monaco-loader.d.ts

@@ -0,0 +1,12 @@
+import { type MonacoModelLease, type OpenMonacoModelOptions } from './monaco-model-registry.ts';
+type MonacoModule = typeof import('monaco-editor');
+export declare function configureBundledMonacoLoader(): Promise<MonacoModule>;
+/**
+ * Acquire a model against the fully loaded editor.
+ *
+ * This lives here, not in the model registry, because it is the only thing in
+ * the registry that needed a loader. Keeping it there gave every consumer of
+ * `acquireMonacoModel` a static edge to the language-server worker set.
+ */
+export declare function openMonacoModel(options: OpenMonacoModelOptions): Promise<MonacoModelLease>;
+export {};

package/dist/lib/components/code/monaco-loader.js

@@ -0,0 +1,89 @@
+import { acquireMonacoModel } from "./monaco-model-registry.js";
+let bundledLoaderPromise = null;
+function loadRepositoryLanguageContributions() {
+    return Promise.all([
+        import('monaco-editor/languages/definitions/cpp/register.js'),
+        import('monaco-editor/languages/definitions/csharp/register.js'),
+        import('monaco-editor/languages/definitions/dockerfile/register.js'),
+        import('monaco-editor/languages/definitions/go/register.js'),
+        import('monaco-editor/languages/definitions/graphql/register.js'),
+        import('monaco-editor/languages/definitions/ini/register.js'),
+        import('monaco-editor/languages/definitions/java/register.js'),
+        import('monaco-editor/languages/definitions/markdown/register.js'),
+        import('monaco-editor/languages/definitions/mdx/register.js'),
+        import('monaco-editor/languages/definitions/python/register.js'),
+        import('monaco-editor/languages/definitions/ruby/register.js'),
+        import('monaco-editor/languages/definitions/rust/register.js'),
+        import('monaco-editor/languages/definitions/shell/register.js'),
+        import('monaco-editor/languages/definitions/sql/register.js'),
+        import('monaco-editor/languages/definitions/xml/register.js'),
+        import('monaco-editor/languages/definitions/yaml/register.js')
+    ]);
+}
+export function configureBundledMonacoLoader() {
+    bundledLoaderPromise ??= Promise.all([
+        import('@monaco-editor/loader'),
+        import('monaco-editor'),
+        import('monaco-editor/editor/editor.worker?worker'),
+        import('monaco-editor/language/json/json.worker?worker'),
+        import('monaco-editor/language/css/css.worker?worker'),
+        import('monaco-editor/language/html/html.worker?worker'),
+        import('monaco-editor/language/typescript/ts.worker?worker'),
+        import('../graphql/graphql.worker?worker')
+    ])
+        .then(async ([loaderModule, monacoModule, editorWorker, jsonWorker, cssWorker, htmlWorker, tsWorker, graphqlWorker]) => {
+        await Promise.all([
+            import('monaco-editor/languages/features/json/register.js'),
+            import('monaco-editor/languages/features/css/register.js'),
+            import('monaco-editor/languages/features/html/register.js'),
+            import('monaco-editor/languages/features/typescript/register.js'),
+            loadRepositoryLanguageContributions()
+        ]);
+        const workers = {
+            editor: editorWorker.default,
+            json: jsonWorker.default,
+            css: cssWorker.default,
+            html: htmlWorker.default,
+            typescript: tsWorker.default,
+            graphql: graphqlWorker.default
+        };
+        // Monaco reads its environment hook from the window (it types it on `Window`); this
+        // browser-only loader installs the full routing there.
+        window.MonacoEnvironment = {
+            getWorker(_workerId, label) {
+                if (label === 'json')
+                    return new workers.json();
+                if (label === 'css' || label === 'scss' || label === 'less')
+                    return new workers.css();
+                if (label === 'html' || label === 'handlebars' || label === 'razor') {
+                    return new workers.html();
+                }
+                if (label === 'typescript' || label === 'javascript')
+                    return new workers.typescript();
+                if (label === 'graphql')
+                    return new workers.graphql();
+                return new workers.editor();
+            }
+        };
+        loaderModule.default.config({
+            monaco: monacoModule
+        });
+        return monacoModule;
+    })
+        .catch((error) => {
+        bundledLoaderPromise = null;
+        throw error;
+    });
+    return bundledLoaderPromise;
+}
+/**
+ * Acquire a model against the fully loaded editor.
+ *
+ * This lives here, not in the model registry, because it is the only thing in
+ * the registry that needed a loader. Keeping it there gave every consumer of
+ * `acquireMonacoModel` a static edge to the language-server worker set.
+ */
+export async function openMonacoModel(options) {
+    const monaco = await configureBundledMonacoLoader();
+    return acquireMonacoModel(monaco, options);
+}

package/dist/lib/components/code/monaco-model-registry.d.ts

@@ -0,0 +1,29 @@
+import type * as Monaco from 'monaco-editor';
+export type MonacoModule = typeof import('monaco-editor');
+export interface MonacoModelIdentity {
+    /** Canonical URI of the resource being edited. */
+    modelUri: string;
+    /** Isolates concurrent edit transactions without losing the resource path. */
+    transactionId?: string;
+}
+export interface OpenMonacoModelOptions extends MonacoModelIdentity {
+    initialValue: string;
+    language: string;
+}
+export interface MonacoModelLease {
+    monaco: MonacoModule;
+    model: Monaco.editor.ITextModel;
+    /** Fully resolved URI, including transaction isolation when requested. */
+    uri: string;
+    /** True only when VibesKit created and therefore owns disposal of the model. */
+    createdByRegistry: boolean;
+    release(): void;
+}
+export interface MonacoModelReadyDetail {
+    monaco: MonacoModule;
+    model: Monaco.editor.ITextModel;
+    uri: string;
+}
+export declare function createEphemeralMonacoModelUri(): string;
+export declare function resolveMonacoModelUri(monaco: MonacoModule, identity: MonacoModelIdentity): Monaco.Uri;
+export declare function acquireMonacoModel(monaco: MonacoModule, options: OpenMonacoModelOptions): MonacoModelLease;

package/dist/lib/components/code/monaco-model-registry.js

@@ -0,0 +1,76 @@
+const models = new Map();
+let ephemeralModelId = 0;
+export function createEphemeralMonacoModelUri() {
+    ephemeralModelId += 1;
+    return `inmemory://vibeskit/editor/${ephemeralModelId}`;
+}
+export function resolveMonacoModelUri(monaco, identity) {
+    const resourceUri = monaco.Uri.parse(identity.modelUri, true);
+    if (!identity.transactionId)
+        return resourceUri;
+    const query = new URLSearchParams(resourceUri.query);
+    query.set('vibes-transaction', identity.transactionId);
+    return resourceUri.with({ query: query.toString() });
+}
+function scheduleUnusedModelDisposal(key, record) {
+    if (record.disposeScheduled)
+        return;
+    record.disposeScheduled = true;
+    queueMicrotask(() => {
+        record.disposeScheduled = false;
+        const current = models.get(key);
+        if (current !== record || record.owners > 0)
+            return;
+        models.delete(key);
+        if (record.createdByRegistry && !record.model.isDisposed()) {
+            record.model.dispose();
+        }
+    });
+}
+export function acquireMonacoModel(monaco, options) {
+    const uri = resolveMonacoModelUri(monaco, options);
+    const key = uri.toString();
+    let record = models.get(key);
+    if (record?.model.isDisposed()) {
+        models.delete(key);
+        record = undefined;
+    }
+    if (!record) {
+        const existingModel = monaco.editor.getModel(uri);
+        const model = existingModel ?? monaco.editor.createModel(options.initialValue, options.language, uri);
+        record = {
+            model,
+            owners: 0,
+            createdByRegistry: existingModel === null,
+            disposeScheduled: false
+        };
+        models.set(key, record);
+        model.onWillDispose(() => {
+            if (models.get(key) === record)
+                models.delete(key);
+        });
+    }
+    record.owners += 1;
+    if (record.model.getLanguageId() !== options.language) {
+        monaco.editor.setModelLanguage(record.model, options.language);
+    }
+    let released = false;
+    const leasedRecord = record;
+    return {
+        monaco,
+        model: leasedRecord.model,
+        uri: key,
+        createdByRegistry: leasedRecord.createdByRegistry,
+        release() {
+            if (released)
+                return;
+            released = true;
+            const current = models.get(key);
+            if (current !== leasedRecord)
+                return;
+            current.owners = Math.max(0, current.owners - 1);
+            if (current.owners === 0)
+                scheduleUnusedModelDisposal(key, current);
+        }
+    };
+}

package/dist/lib/components/code/monaco-setup.d.ts

@@ -0,0 +1,30 @@
+import type { VibesMonacoThemeProjection } from './monaco-theme.ts';
+type MonacoModule = typeof import('monaco-editor');
+type MonacoTypeScriptApi = MonacoModule['typescript'];
+type MonacoLanguageServiceDefaults = MonacoTypeScriptApi['typescriptDefaults'];
+type MonacoStandaloneEditor = import('monaco-editor').editor.IStandaloneCodeEditor;
+/** The Monaco API surface vibeskit uses: Monaco's own declarations, narrowed to the members it calls. */
+export interface MonacoEditor {
+    editor: Pick<MonacoModule['editor'], 'defineTheme' | 'getModels' | 'setModelLanguage' | 'createModel' | 'getModel'>;
+    typescript: {
+        typescriptDefaults: Pick<MonacoLanguageServiceDefaults, 'setDiagnosticsOptions' | 'setCompilerOptions' | 'setEagerModelSync' | 'addExtraLib'>;
+        javascriptDefaults: Pick<MonacoLanguageServiceDefaults, 'setDiagnosticsOptions' | 'setCompilerOptions' | 'addExtraLib'>;
+        ScriptTarget: Pick<MonacoTypeScriptApi['ScriptTarget'], 'ES2020'>;
+        ModuleKind: Pick<MonacoTypeScriptApi['ModuleKind'], 'ESNext'>;
+        ModuleResolutionKind: Pick<MonacoTypeScriptApi['ModuleResolutionKind'], 'NodeJs'>;
+        getTypeScriptWorker: MonacoTypeScriptApi['getTypeScriptWorker'];
+    };
+    Uri: Pick<MonacoModule['Uri'], 'parse'>;
+}
+/** Detail object passed to monacoSetup callbacks */
+export interface MonacoSetupDetail {
+    monaco: MonacoEditor;
+    editor: MonacoStandaloneEditor;
+}
+export declare function registerVibesMonacoTheme(monaco: MonacoEditor, projection: VibesMonacoThemeProjection): void;
+export declare function setupMonacoForVibes(monaco: MonacoEditor, theme?: VibesMonacoThemeProjection): Promise<void>;
+export declare function finalizeMonacoEditor(monaco: MonacoEditor, editor: Pick<MonacoStandaloneEditor, 'getModel'>, opts?: {
+    language?: string;
+    uri?: string;
+}): Promise<void>;
+export {};