@remotion/studio-server 4.0.437 → 4.0.439

package/dist/client-render-queue.js

@@ -26,10 +26,10 @@ const addCompletedClientRender = ({ render, remotionRoot, }) => {
     const filePath = (0, resolve_output_path_1.resolveOutputPath)(remotionRoot, render.outName);
     const { unwatch } = (0, file_watcher_1.installFileWatcher)({
         file: filePath,
-        onChange: (type) => {
-            if (type === 'created' || type === 'deleted') {
+        onChange: (event) => {
+            if (event.type === 'created' || event.type === 'deleted') {
                 updateCompletedClientRender(render.id, {
-                    deletedOutputLocation: type === 'deleted',
+                    deletedOutputLocation: event.type === 'deleted',
                 });
             }
         },

package/dist/codemods/apply-visual-control.js

@@ -68,7 +68,14 @@ const applyVisualControl = ({ file, transformation, changesMade, }) => {
                 if (change.id !== str) {
                     continue;
                 }
-                const parsed = (0, parse_ast_1.parseAst)(`a = ${(0, studio_shared_1.stringifyDefaultProps)({ props: JSON.parse(change.newValueSerialized), enumPaths: change.enumPaths })}`).program.body[0].expression.right;
+                let parsed;
+                if (change.newValueIsUndefined) {
+                    parsed = (0, parse_ast_1.parseAst)('a = undefined').program
+                        .body[0].expression.right;
+                }
+                else {
+                    parsed = (0, parse_ast_1.parseAst)(`a = ${(0, studio_shared_1.stringifyDefaultProps)({ props: JSON.parse(change.newValueSerialized), enumPaths: change.enumPaths })}`).program.body[0].expression.right;
+                }
                 node.arguments[1] = parsed;
                 changesMade.push({
                     description: `Applied visual control ${change.id}`,

package/dist/codemods/format-inline-content.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Instead of running prettier on the entire file (which is slow),
+ * format only a small snippet of inline content (e.g. stringified defaultProps).
+ *
+ * @param inlineContent - The raw content to format (e.g. stringified props)
+ * @param linePrefix - Everything from the start of the line to where
+ *   inlineContent will appear (used to calculate column offset and indentation)
+ * @param endOfLine - Prettier endOfLine option
+ *
+ * We wrap the content in `const __x__ = CONTENT;` and adjust printWidth
+ * so prettier makes the same line-breaking decisions as if the content
+ * were at its actual column position in the file.
+ */
+export declare const formatInlineContent: ({ inlineContent, linePrefix, endOfLine, }: {
+    inlineContent: string;
+    linePrefix: string;
+    endOfLine: "auto" | "lf";
+}) => Promise<{
+    formatted: string;
+    didFormat: boolean;
+}>;

package/dist/codemods/format-inline-content.js

@@ -0,0 +1,108 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatInlineContent = void 0;
+/**
+ * Instead of running prettier on the entire file (which is slow),
+ * format only a small snippet of inline content (e.g. stringified defaultProps).
+ *
+ * @param inlineContent - The raw content to format (e.g. stringified props)
+ * @param linePrefix - Everything from the start of the line to where
+ *   inlineContent will appear (used to calculate column offset and indentation)
+ * @param endOfLine - Prettier endOfLine option
+ *
+ * We wrap the content in `const __x__ = CONTENT;` and adjust printWidth
+ * so prettier makes the same line-breaking decisions as if the content
+ * were at its actual column position in the file.
+ */
+const formatInlineContent = async ({ inlineContent, linePrefix, endOfLine, }) => {
+    var _a;
+    var _b, _c, _d;
+    let prettier = null;
+    try {
+        prettier = await Promise.resolve().then(() => __importStar(require('prettier')));
+    }
+    catch (_e) {
+        return { formatted: inlineContent, didFormat: false };
+    }
+    const { format, resolveConfig, resolveConfigFile } = prettier;
+    const configFilePath = await resolveConfigFile();
+    if (!configFilePath) {
+        return { formatted: inlineContent, didFormat: false };
+    }
+    const prettierConfig = await resolveConfig(configFilePath);
+    if (!prettierConfig) {
+        return { formatted: inlineContent, didFormat: false };
+    }
+    const tabWidth = (_b = prettierConfig.tabWidth) !== null && _b !== void 0 ? _b : 2;
+    const baseIndent = (_c = (_a = linePrefix.match(/^(\s*)/)) === null || _a === void 0 ? void 0 : _a[1]) !== null && _c !== void 0 ? _c : '';
+    // Calculate visual column offset (tabs expand to tabWidth columns)
+    const columnOffset = [...linePrefix].reduce((col, ch) => (ch === '\t' ? col + tabWidth : col + 1), 0);
+    // Adjust printWidth so the wrapper prefix occupies the same visual
+    // width as the actual file prefix, ensuring identical line breaks.
+    const configPrintWidth = (_d = prettierConfig.printWidth) !== null && _d !== void 0 ? _d : 80;
+    const wrapperPrefix = 'const __x__ = ';
+    const effectivePrintWidth = Math.max(configPrintWidth - columnOffset + wrapperPrefix.length, 20);
+    const wrappedSource = `${wrapperPrefix}${inlineContent};\n`;
+    const formattedWrapped = await format(wrappedSource, {
+        ...prettierConfig,
+        printWidth: effectivePrintWidth,
+        filepath: 'test.tsx',
+        plugins: [],
+        endOfLine,
+    });
+    // Extract the formatted value from the wrapper
+    const withoutSemicolon = formattedWrapped.replace(/;\s*$/, '');
+    let formattedProps;
+    if (withoutSemicolon.startsWith(wrapperPrefix)) {
+        formattedProps = withoutSemicolon.slice(wrapperPrefix.length);
+    }
+    else {
+        // Prettier broke the line after `=` — extract and dedent one level
+        const lines = withoutSemicolon.split('\n').slice(1);
+        const useTabs = prettierConfig.useTabs;
+        const oneIndent = useTabs ? '\t' : ' '.repeat(tabWidth);
+        formattedProps = lines
+            .map((l) => (l.startsWith(oneIndent) ? l.slice(oneIndent.length) : l))
+            .join('\n');
+    }
+    // Add base indentation to all lines except the first
+    const indentedProps = formattedProps
+        .split('\n')
+        .map((line, i) => i === 0 ? line : line.length > 0 ? baseIndent + line : line)
+        .join('\n');
+    return { formatted: indentedProps, didFormat: true };
+};
+exports.formatInlineContent = formatInlineContent;

package/dist/codemods/read-visual-control-values.d.ts

@@ -0,0 +1,7 @@
+import type { File } from '@babel/types';
+export type VisualControlValueFromCode = {
+    id: string;
+    value: unknown;
+    isUndefined: boolean;
+};
+export declare const readVisualControlValues: (file: File) => VisualControlValueFromCode[];

package/dist/codemods/read-visual-control-values.js

@@ -0,0 +1,166 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readVisualControlValues = void 0;
+const recast = __importStar(require("recast"));
+const getStringValue = (node) => {
+    if (node.type === 'StringLiteral') {
+        return node.value;
+    }
+    if (node.type === 'TemplateLiteral') {
+        const tl = node;
+        if (tl.expressions.length > 0) {
+            return null;
+        }
+        return tl.quasis[0].value.raw;
+    }
+    return null;
+};
+const evaluateExpression = (node) => {
+    switch (node.type) {
+        case 'NumericLiteral':
+            return node.value;
+        case 'StringLiteral':
+            return node.value;
+        case 'BooleanLiteral':
+            return node.value;
+        case 'NullLiteral':
+            return null;
+        case 'Identifier': {
+            const { name } = node;
+            if (name === 'undefined') {
+                return undefined;
+            }
+            throw new Error(`Cannot evaluate identifier: ${name}`);
+        }
+        case 'UnaryExpression': {
+            const unary = node;
+            if (unary.operator === '-') {
+                const arg = evaluateExpression(unary.argument);
+                if (typeof arg === 'number') {
+                    return -arg;
+                }
+            }
+            if (unary.operator === '+') {
+                const arg = evaluateExpression(unary.argument);
+                if (typeof arg === 'number') {
+                    return arg;
+                }
+            }
+            throw new Error(`Cannot evaluate unary: ${unary.operator}`);
+        }
+        case 'ObjectExpression': {
+            const obj = {};
+            const { properties } = node;
+            for (const prop of properties) {
+                if (prop.type !== 'ObjectProperty') {
+                    continue;
+                }
+                let key = null;
+                if (prop.key.type === 'Identifier') {
+                    key = prop.key.name;
+                }
+                else if (prop.key.type === 'StringLiteral') {
+                    key = prop.key.value;
+                }
+                else if (prop.key.type === 'NumericLiteral') {
+                    key = String(prop.key.value);
+                }
+                if (key !== null) {
+                    obj[key] = evaluateExpression(prop.value);
+                }
+            }
+            return obj;
+        }
+        case 'ArrayExpression': {
+            const { elements } = node;
+            return elements.map((el) => {
+                if (el === null) {
+                    return null;
+                }
+                return evaluateExpression(el);
+            });
+        }
+        case 'TemplateLiteral': {
+            const tl = node;
+            if (tl.expressions.length === 0) {
+                return tl.quasis[0].value.cooked;
+            }
+            throw new Error('Cannot evaluate template literal with expressions');
+        }
+        default:
+            throw new Error(`Cannot evaluate AST node: ${node.type}`);
+    }
+};
+const readVisualControlValues = (file) => {
+    const values = [];
+    recast.types.visit(file.program, {
+        visitCallExpression(path) {
+            const { node } = path;
+            if (node.callee.type !== 'Identifier' ||
+                node.callee.name !== 'visualControl') {
+                return this.traverse(path);
+            }
+            const firstArg = node.arguments[0];
+            const id = getStringValue(firstArg);
+            if (id === null) {
+                return this.traverse(path);
+            }
+            if (node.arguments.length < 2) {
+                return this.traverse(path);
+            }
+            const valueNode = node.arguments[1];
+            try {
+                if (valueNode.type === 'Identifier' &&
+                    valueNode.name === 'undefined') {
+                    values.push({ id, value: null, isUndefined: true });
+                }
+                else {
+                    values.push({
+                        id,
+                        value: evaluateExpression(valueNode),
+                        isUndefined: false,
+                    });
+                }
+            }
+            catch (_a) {
+                // Skip values we can't evaluate statically
+            }
+            return this.traverse(path);
+        },
+    });
+    return values;
+};
+exports.readVisualControlValues = readVisualControlValues;

package/dist/codemods/update-default-props.d.ts

@@ -4,4 +4,7 @@ export declare const updateDefaultProps: ({ input, compositionId, newDefaultProp
     compositionId: string;
     newDefaultProps: Record<string, unknown>;
     enumPaths: EnumPath[];
-}) => Promise<Promise<Promise<Promise<string>>>>;
+}) => Promise<{
+    output: string;
+    formatted: boolean;
+}>;

package/dist/codemods/update-default-props.js

@@ -36,9 +36,37 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.updateDefaultProps = void 0;
 const studio_shared_1 = require("@remotion/studio-shared");
 const recast = __importStar(require("recast"));
+const format_inline_content_1 = require("./format-inline-content");
 const parse_ast_1 = require("./parse-ast");
+// Recast uses tabWidth=4 for column counting, so columns don't
+// correspond to character indices when tabs are present.
+// This converts a recast loc (line/column) to a character offset.
+const RECAST_TAB_WIDTH = 4;
+const recastLocToOffset = (input, loc) => {
+    const lines = input.split('\n');
+    let offset = 0;
+    for (let i = 0; i < loc.line - 1; i++) {
+        offset += lines[i].length + 1;
+    }
+    // Convert recast's tab-expanded column to character index
+    const line = lines[loc.line - 1];
+    let col = 0;
+    for (let i = 0; i < line.length; i++) {
+        if (col >= loc.column) {
+            return offset + i;
+        }
+        col += line[i] === '\t' ? RECAST_TAB_WIDTH : 1;
+    }
+    return offset + line.length;
+};
 const updateDefaultProps = async ({ input, compositionId, newDefaultProps, enumPaths, }) => {
     const ast = (0, parse_ast_1.parseAst)(input);
+    const stringified = (0, studio_shared_1.stringifyDefaultProps)({
+        props: newDefaultProps,
+        enumPaths,
+    });
+    let replaceStart;
+    let replaceEnd;
     recast.types.visit(ast, {
         visitJSXElement(path) {
             var _a, _b;
@@ -110,33 +138,34 @@ const updateDefaultProps = async ({ input, compositionId, newDefaultProps, enumP
                 defaultPropsValue.type !== 'TSAsExpression') {
                 throw new Error(`\`defaultProps\` prop must be a hardcoded value in the <Composition/> tag with the ID "${compositionId}".`);
             }
-            defaultPropsAttr.value.expression = recast.types.builders.identifier((0, studio_shared_1.stringifyDefaultProps)({ props: newDefaultProps, enumPaths }));
+            // Capture source positions for direct string replacement
+            // instead of modifying the AST and serializing (avoids recast artifacts)
+            const valueLoc = defaultPropsAttr.value.loc;
+            if (!valueLoc) {
+                throw new Error('Could not determine source location of defaultProps');
+            }
+            replaceStart = recastLocToOffset(input, valueLoc.start);
+            replaceEnd = recastLocToOffset(input, valueLoc.end);
             this.traverse(path); // Continue traversing the AST
         },
     });
-    let prettier = null;
-    try {
-        prettier = await Promise.resolve().then(() => __importStar(require('prettier')));
-    }
-    catch (_a) {
-        throw new Error('Prettier cannot be found in the current project.');
-    }
-    const { format, resolveConfig, resolveConfigFile } = prettier;
-    const configFilePath = await resolveConfigFile();
-    if (!configFilePath) {
-        throw new Error('The Prettier config file was not found');
-    }
-    const prettierConfig = await resolveConfig(configFilePath);
-    if (!prettierConfig) {
-        throw new Error('The Prettier config file was not found. For this feature, the "prettier" package must be installed and a .prettierrc file must exist.');
+    if (replaceStart === undefined || replaceEnd === undefined) {
+        throw new Error(`Could not find defaultProps for composition "${compositionId}"`);
     }
-    const finalfile = (0, parse_ast_1.serializeAst)(ast);
-    const prettified = await format(finalfile, {
-        ...prettierConfig,
-        filepath: 'test.tsx',
-        plugins: [],
+    // linePrefix includes the JSX container opening brace
+    const lineStart = input.lastIndexOf('\n', replaceStart) + 1;
+    const linePrefix = input.substring(lineStart, replaceStart + 1);
+    const { formatted, didFormat } = await (0, format_inline_content_1.formatInlineContent)({
+        inlineContent: stringified,
+        linePrefix,
         endOfLine: 'auto',
     });
-    return prettified;
+    // Replace the JSX expression container in the original input
+    const output = input.substring(0, replaceStart) +
+        '{' +
+        formatted +
+        '}' +
+        input.substring(replaceEnd);
+    return { output, formatted: didFormat };
 };
 exports.updateDefaultProps = updateDefaultProps;

package/dist/file-watcher.d.ts

@@ -1,9 +1,26 @@
-type FileChangeType = 'created' | 'deleted' | 'changed';
-export declare const installFileWatcher: ({ file, onChange, }: {
-    file: string;
-    onChange: (type: FileChangeType) => void;
-}) => {
-    exists: boolean;
-    unwatch: () => void;
+export type FileChangeEvent = {
+    type: 'created';
+    content: string;
+} | {
+    type: 'deleted';
+} | {
+    type: 'changed';
+    content: string;
 };
+type OnChange = (event: FileChangeEvent) => void;
+export type FileWatcherRegistry = {
+    installFileWatcher: (options: {
+        file: string;
+        onChange: OnChange;
+    }) => {
+        exists: boolean;
+        unwatch: () => void;
+    };
+    writeFileAndNotifyFileWatchers: (file: string, content: string) => void;
+};
+export declare const createFileWatcherRegistry: () => FileWatcherRegistry;
+export declare const setFileWatcherRegistry: (registry: FileWatcherRegistry) => () => void;
+export declare const getFileWatcherRegistry: () => FileWatcherRegistry;
+export declare const installFileWatcher: FileWatcherRegistry['installFileWatcher'];
+export declare const writeFileAndNotifyFileWatchers: FileWatcherRegistry['writeFileAndNotifyFileWatchers'];
 export {};

package/dist/file-watcher.js

@@ -1,40 +1,159 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.installFileWatcher = void 0;
-const node_fs_1 = __importDefault(require("node:fs"));
-const installFileWatcher = ({ file, onChange, }) => {
-    const existedAtBeginning = node_fs_1.default.existsSync(file);
-    let existedBefore = existedAtBeginning;
-    const listener = () => {
-        const existsNow = node_fs_1.default.existsSync(file);
-        if (!existedBefore && existsNow) {
-            onChange('created');
-            existedBefore = true;
-            return;
+exports.writeFileAndNotifyFileWatchers = exports.installFileWatcher = exports.getFileWatcherRegistry = exports.setFileWatcherRegistry = exports.createFileWatcherRegistry = void 0;
+const node_fs_1 = __importStar(require("node:fs"));
+const createFileWatcherRegistry = () => {
+    const sharedWatchers = new Map();
+    const _installFileWatcher = ({ file, onChange, }) => {
+        const existing = sharedWatchers.get(file);
+        if (existing) {
+            existing.subscribers.add(onChange);
+            return {
+                exists: existing.existedBefore,
+                unwatch: () => {
+                    existing.subscribers.delete(onChange);
+                    if (existing.subscribers.size === 0) {
+                        existing.unwatch();
+                        sharedWatchers.delete(file);
+                    }
+                },
+            };
         }
-        if (existedBefore && !existsNow) {
-            onChange('deleted');
-            existedBefore = false;
-            return;
-        }
-        if (existsNow) {
-            if (typeof Deno !== 'undefined') {
-                // Deno always goes here, even if the file has not changed.
-                // Don't support this for now.
+        const existedAtBeginning = node_fs_1.default.existsSync(file);
+        const shared = {
+            subscribers: new Set([onChange]),
+            existedBefore: existedAtBeginning,
+            lastKnownContent: null,
+            unwatch: () => {
+                node_fs_1.default.unwatchFile(file, listener);
+            },
+        };
+        const listener = () => {
+            const existsNow = node_fs_1.default.existsSync(file);
+            let event = null;
+            if (!shared.existedBefore && existsNow) {
+                const content = (0, node_fs_1.readFileSync)(file, 'utf-8');
+                shared.existedBefore = true;
+                shared.lastKnownContent = content;
+                event = { type: 'created', content };
+            }
+            else if (shared.existedBefore && !existsNow) {
+                shared.existedBefore = false;
+                shared.lastKnownContent = null;
+                event = { type: 'deleted' };
+            }
+            else if (existsNow) {
+                if (typeof Deno !== 'undefined') {
+                    return;
+                }
+                const content = (0, node_fs_1.readFileSync)(file, 'utf-8');
+                if (shared.lastKnownContent !== null &&
+                    content === shared.lastKnownContent) {
+                    return;
+                }
+                shared.lastKnownContent = content;
+                event = { type: 'changed', content };
+            }
+            if (!event) {
                 return;
             }
-            onChange('changed');
+            for (const subscriber of shared.subscribers) {
+                subscriber(event);
+            }
+        };
+        node_fs_1.default.watchFile(file, { interval: 100 }, listener);
+        sharedWatchers.set(file, shared);
+        return {
+            exists: existedAtBeginning,
+            unwatch: () => {
+                shared.subscribers.delete(onChange);
+                if (shared.subscribers.size === 0) {
+                    shared.unwatch();
+                    sharedWatchers.delete(file);
+                }
+            },
+        };
+    };
+    const _writeFileAndNotifyFileWatchers = (file, content) => {
+        (0, node_fs_1.writeFileSync)(file, content);
+        const shared = sharedWatchers.get(file);
+        if (!shared) {
+            return;
+        }
+        shared.lastKnownContent = content;
+        shared.existedBefore = true;
+        for (const subscriber of shared.subscribers) {
+            subscriber({ type: 'changed', content });
         }
     };
-    node_fs_1.default.watchFile(file, { interval: 100 }, listener);
     return {
-        exists: existedAtBeginning,
-        unwatch: () => {
-            node_fs_1.default.unwatchFile(file, listener);
-        },
+        installFileWatcher: _installFileWatcher,
+        writeFileAndNotifyFileWatchers: _writeFileAndNotifyFileWatchers,
     };
 };
+exports.createFileWatcherRegistry = createFileWatcherRegistry;
+let currentRegistry = null;
+const setFileWatcherRegistry = (registry) => {
+    currentRegistry = registry;
+    return () => {
+        currentRegistry = null;
+    };
+};
+exports.setFileWatcherRegistry = setFileWatcherRegistry;
+const getFileWatcherRegistry = () => {
+    if (!currentRegistry) {
+        throw new Error('File watcher registry not initialized');
+    }
+    return currentRegistry;
+};
+exports.getFileWatcherRegistry = getFileWatcherRegistry;
+const installFileWatcher = (options) => {
+    if (!currentRegistry) {
+        return {
+            exists: false,
+            unwatch: () => { },
+        };
+    }
+    return (0, exports.getFileWatcherRegistry)().installFileWatcher(options);
+};
 exports.installFileWatcher = installFileWatcher;
+const writeFileAndNotifyFileWatchers = (file, content) => {
+    if (!currentRegistry) {
+        return;
+    }
+    (0, exports.getFileWatcherRegistry)().writeFileAndNotifyFileWatchers(file, content);
+};
+exports.writeFileAndNotifyFileWatchers = writeFileAndNotifyFileWatchers;