@kubohiroya/turbowarp-plus-editor-project-model 0.1.2 → 0.2.0

package/dist/project-search.js

@@ -0,0 +1,282 @@
+// The judgement for broadcast blocks lives in project-messages, which the layout's message
+// section also uses, so the section and this search agree.
+import { messageReference } from "./project-messages.js";
+export const variableAccessLabels = {
+    read: ['読み取り', 'Read'],
+    write: ['変更', 'Write']
+};
+export const literalSearchPattern = (query, flags) => new RegExp(query.trim().replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), flags);
+const headings = {
+    block: ['ブロック', 'Blocks'],
+    variable: ['変数の使用箇所', 'Variable uses'],
+    list: ['リストの使用箇所', 'List uses'],
+    message: ['メッセージの送受信', 'Broadcasts'],
+    argument: ['ブロックの引数値', 'Block argument values'],
+    extension: ['機能拡張の使用箇所', 'Extension uses'],
+    comment: ['コメント', 'Comments'],
+    costume: ['コスチューム', 'Costumes'],
+    backdrop: ['背景', 'Backdrops'],
+    sound: ['音', 'Sounds']
+};
+function* walkBlocks(target) {
+    const pending = target.blocks.getScripts().slice().reverse();
+    const seen = new Set();
+    while (pending.length) {
+        const id = pending.pop();
+        if (seen.has(id))
+            continue;
+        seen.add(id);
+        const block = target.blocks.getBlock(id);
+        if (!block || block.shadow)
+            continue;
+        const inputs = [];
+        for (const [key, input] of Object.entries(block.inputs ?? {})) {
+            const child = input.block && target.blocks.getBlock(input.block);
+            if (child)
+                inputs.push([key, child]);
+        }
+        if (block.next)
+            pending.push(block.next);
+        for (let i = inputs.length - 1; i >= 0; i--) {
+            if (!inputs[i][1].shadow)
+                pending.push(inputs[i][1].id);
+        }
+        yield { block, inputs };
+    }
+}
+const stageProperties = new Set(['background #', 'backdrop #', 'backdrop name', 'volume']);
+const spriteProperties = new Set(['x position', 'y position', 'direction', 'costume #', 'costume name', 'size', 'volume']);
+const listAccesses = new Map([
+    ['data_listcontents', 'read'], ['data_itemoflist', 'read'], ['data_itemnumoflist', 'read'],
+    ['data_lengthoflist', 'read'], ['data_listcontainsitem', 'read'],
+    ['data_addtolist', 'write'], ['data_deleteoflist', 'write'], ['data_deletealloflist', 'write'],
+    ['data_insertatlist', 'write'], ['data_replaceitemoflist', 'write']
+]);
+function variableAccess(target, block, inputs, stage, sprites) {
+    if (block.opcode === 'sensing_of') {
+        const menu = inputs.find(([key]) => key === 'OBJECT')?.[1];
+        if (!menu?.shadow || menu.opcode !== 'sensing_of_object_menu')
+            return;
+        const object = menu.fields?.OBJECT?.value;
+        const name = block.fields?.PROPERTY?.value;
+        if (typeof object !== 'string' || typeof name !== 'string')
+            return;
+        const owner = object === '_stage_' ? stage : sprites.get(object);
+        if (!owner || (owner.isStage ? stageProperties : spriteProperties).has(name))
+            return;
+        const variableId = Object.keys(owner.variables).find(id => {
+            const variable = owner.variables[id];
+            return variable.type === '' && variable.name === name;
+        });
+        if (variableId)
+            return { owner, variableId, access: 'read' };
+        return;
+    }
+    const listAccess = listAccesses.get(block.opcode);
+    const access = listAccess ?? (block.opcode === 'data_variable' ? 'read' :
+        block.opcode === 'data_setvariableto' || block.opcode === 'data_changevariableby' ? 'write' : undefined);
+    const variableId = block.fields?.[listAccess ? 'LIST' : 'VARIABLE']?.id;
+    if (!access || !variableId)
+        return;
+    const owner = Object.hasOwn(target.variables, variableId) ? target : stage;
+    if (owner?.variables[variableId]?.type === (listAccess ? 'list' : ''))
+        return { owner, variableId, access };
+}
+const originalSprites = (project) => new Map(project.targets.filter(target => target.isOriginal && !target.isStage).map(target => [target.getName(), target]));
+export function countVariableAccesses(project, ownerId) {
+    const stage = project.targets.find(target => target.isStage);
+    const sprites = originalSprites(project);
+    const counts = new Map();
+    for (const target of project.targets) {
+        if (!target.isOriginal)
+            continue;
+        for (const { block, inputs } of walkBlocks(target)) {
+            const use = variableAccess(target, block, inputs, stage, sprites);
+            if (use?.owner.id !== ownerId)
+                continue;
+            const count = counts.get(use.variableId) ?? { read: 0, write: 0 };
+            count[use.access]++;
+            counts.set(use.variableId, count);
+        }
+    }
+    return counts;
+}
+export function searchProject(project, messages, query, japanese, kinds = new Set(Object.keys(headings)), variableSearch) {
+    const groups = new Map(Object.entries(headings).map(([kind, titles]) => [
+        kind, { kind: kind, title: titles[japanese ? 0 : 1], results: [] }
+    ]));
+    const search = query.trim().toLocaleLowerCase();
+    if (!search && !variableSearch)
+        return [];
+    const stage = project.targets.find(target => target.isStage);
+    const sprites = variableSearch || kinds.has('variable') ? originalSprites(project) : undefined;
+    const searchBlocks = variableSearch || ['block', 'variable', 'list', 'message', 'argument', 'extension']
+        .some(kind => kinds.has(kind));
+    const templates = new Map();
+    const matches = (value) => value.toLocaleLowerCase().includes(search);
+    const describeOpcode = (opcode) => {
+        const cached = templates.get(opcode);
+        if (cached)
+            return cached;
+        const key = opcode.toUpperCase();
+        const alternate = key.replace(/^OPERATOR_/, 'OPERATORS_').replace(/_AS_CLONE$/, 'ASCLONE');
+        const vmLabel = project.getLabelForOpcode?.(opcode);
+        const vmText = vmLabel?.label;
+        const separator = vmLabel?.category === 'extension' ? vmText?.indexOf(': ') ?? -1 : -1;
+        const template = {
+            text: messages[key] ?? messages[alternate] ??
+                (vmText && separator > 0 ? vmText.slice(separator + 2) : vmText) ?? opcode.replaceAll('_', ' '),
+            extension: vmText && separator > 0 ? vmText.slice(0, separator) : undefined
+        };
+        templates.set(opcode, template);
+        return template;
+    };
+    const fieldText = (target, key, field) => {
+        const variable = field.id && (key === 'VARIABLE' || key === 'LIST') ?
+            target.variables[field.id] ?? stage?.variables[field.id] : undefined;
+        return String(variable?.name ?? field.value ?? '');
+    };
+    const describe = (target, block, inputs, template) => {
+        const values = [
+            ...Object.entries(block.fields ?? {}).map(([key, field]) => fieldText(target, key, field)),
+            ...inputs.filter(([key]) => !key.startsWith('SUBSTACK')).map(([, child]) => child.shadow ? Object.values(child.fields ?? {}).map(field => String(field.value ?? '')).join(' ') :
+                Object.entries(child.fields ?? {}).map(([key, field]) => fieldText(target, key, field)).join(' ') || '…')
+        ];
+        if (block.opcode === 'event_whenflagclicked')
+            values.unshift(japanese ? '緑の旗' : 'green flag');
+        if (/%\d+/.test(template))
+            return template.replace(/%(\d+)/g, (_, index) => values[Number(index) - 1] ?? '…').trim();
+        return [template, ...values].filter(Boolean).join(' ');
+    };
+    for (const target of project.targets) {
+        if (!target.isOriginal)
+            continue;
+        for (const { block, inputs } of searchBlocks ? walkBlocks(target) : []) {
+            const use = sprites && variableAccess(target, block, inputs, stage, sprites);
+            if (variableSearch && (!use || use.owner.id !== variableSearch.ownerId ||
+                use.variableId !== variableSearch.variableId || use.access !== variableSearch.access))
+                continue;
+            const variable = block.fields?.VARIABLE;
+            const list = block.fields?.LIST;
+            const message = messageReference(target, block, stage);
+            const kind = variable ? 'variable' : list ? 'list' : 'message';
+            const reference = variable ?? list ?? (message && { id: message.id, value: message.fieldValue });
+            const name = variable || list ? fieldText(target, variable ? 'VARIABLE' : 'LIST', reference) : message?.name;
+            const opcode = describeOpcode(block.opcode);
+            const procedure = block.mutation?.proccode ??
+                inputs.find(([key]) => key === 'custom_block')?.[1].mutation?.proccode;
+            const customLabel = block.mutation?.blockInfo?.text;
+            const template = procedure ? procedure.replace(/%[sbn]/g, '…') :
+                typeof customLabel === 'string' ? customLabel : opcode.text;
+            const label = procedure ? template : describe(target, block, inputs, template);
+            const add = (kind, label, detail, edit, access) => groups.get(kind).results.push({ kind, target, block, label, detail, edit, variableAccess: access });
+            if (variableSearch && use) {
+                add(list ? 'list' : 'variable', label, use.owner.variables[use.variableId].name, undefined, use.access);
+                continue;
+            }
+            if (kinds.has('block') && (matches(template) || matches(block.opcode) ||
+                (block.opcode === 'event_whenflagclicked' && matches(japanese ? '緑の旗' : 'green flag')))) {
+                add('block', label, undefined, procedure ? { type: 'procedure', name: procedure } : undefined);
+            }
+            if (kinds.has(kind) && name && matches(name)) {
+                const referenceId = reference?.id;
+                const owner = referenceId &&
+                    (target.variables[referenceId] ? target : stage?.variables[referenceId] ? stage : undefined);
+                const scope = (variable || list) && owner &&
+                    (owner.isStage ? (japanese ? '全体' : 'Global') : (japanese ? 'このスプライト' : 'Local'));
+                const model = owner && referenceId ? owner.variables[referenceId] : undefined;
+                const edit = owner && referenceId && model && !model.isCloud ? {
+                    type: 'name', id: referenceId, owner, name: model.name,
+                    variableType: model.type ?? (list ? 'list' : message ? 'broadcast_msg' : '')
+                } : undefined;
+                add(kind, name, scope || label, edit, use?.access);
+            }
+            else if (use && !variable && !list && kinds.has('variable') && matches(use.owner.variables[use.variableId].name)) {
+                add('variable', use.owner.variables[use.variableId].name, label, undefined, use.access);
+            }
+            if (kinds.has('extension') && opcode.extension && matches(opcode.extension))
+                add('extension', opcode.extension, label);
+            if (kinds.has('argument')) {
+                const addArguments = (owner) => {
+                    for (const [key, field] of Object.entries(owner.fields ?? {})) {
+                        if (field === reference || (message && key === 'BROADCAST_OPTION'))
+                            continue;
+                        const value = String(field.value ?? '');
+                        if (value && matches(value))
+                            add('argument', value, label, { type: 'field', id: owner.id, field: key, value });
+                    }
+                };
+                addArguments(block);
+                for (const [, child] of inputs) {
+                    if (child.shadow)
+                        addArguments(child);
+                }
+            }
+        }
+        if (variableSearch)
+            continue;
+        if (kinds.has('comment')) {
+            for (const [commentId, comment] of Object.entries(target.comments ?? {})) {
+                if (matches(comment.text))
+                    groups.get('comment').results.push({
+                        kind: 'comment', target, comment, commentId, label: comment.text, edit: { type: 'comment', text: comment.text }
+                    });
+            }
+        }
+        const assets = [
+            [target.isStage ? 'backdrop' : 'costume', target.getCostumes()],
+            ['sound', target.getSounds()]
+        ];
+        for (const [kind, items] of assets) {
+            if (!kinds.has(kind))
+                continue;
+            for (const asset of items) {
+                if (matches(asset.name))
+                    groups.get(kind).results.push({ kind, asset, label: asset.name, target });
+            }
+        }
+    }
+    return [...groups.values()].filter(group => group.results.length);
+}
+export function searchYamlDocuments(documents, query, japanese) {
+    const results = [];
+    const search = query.trim();
+    if (!search)
+        return results;
+    const pattern = literalSearchPattern(search, 'giu');
+    const seen = new Set();
+    const duplicates = new Set();
+    for (const { filename } of documents) {
+        if (seen.has(filename))
+            duplicates.add(filename);
+        seen.add(filename);
+    }
+    for (const document of documents) {
+        let line = 1;
+        let lineStart = 0;
+        let newline = document.source.indexOf('\n');
+        for (const match of document.source.matchAll(pattern)) {
+            const start = match.index;
+            const end = start + match[0].length;
+            while (newline >= 0 && newline < start) {
+                line++;
+                lineStart = newline + 1;
+                newline = document.source.indexOf('\n', lineStart);
+            }
+            const column = start - lineStart + 1;
+            const nextNewline = document.source.indexOf('\n', end);
+            const before = Math.max(lineStart, start - 48);
+            const lineEnd = nextNewline < 0 ? document.source.length : nextNewline;
+            const after = Math.min(lineEnd, end + 48);
+            const position = japanese ? `${line} 行 ${column} 列` : `Line ${line}, column ${column}`;
+            const identity = duplicates.has(document.filename) ?
+                `${document.reference.providerId}/${document.reference.documentId}` : '';
+            results.push({
+                kind: 'yaml', document, label: `${before > lineStart ? '…' : ''}${document.source.slice(before, after)}${after < lineEnd ? '…' : ''}`,
+                detail: [position, identity].filter(Boolean).join(' · '),
+                range: { start, end, expectedText: match[0] }
+            });
+        }
+    }
+    return results;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubohiroya/turbowarp-plus-editor-project-model",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "UI-free reads and edits of a running Scratch project for TurboWarp Plus Editor",
   "type": "module",
   "license": "MPL-2.0",
@@ -21,6 +21,18 @@
     "./sprite-variable-edit": {
       "types": "./dist/sprite-variable-edit.d.ts",
       "default": "./dist/sprite-variable-edit.js"
+    },
+    "./project-search": {
+      "types": "./dist/project-search.d.ts",
+      "default": "./dist/project-search.js"
+    },
+    "./project-search-replace": {
+      "types": "./dist/project-search-replace.d.ts",
+      "default": "./dist/project-search-replace.js"
+    },
+    "./project-search-connections": {
+      "types": "./dist/project-search-connections.d.ts",
+      "default": "./dist/project-search-connections.js"
     }
   },
   "files": [

package/src/index.ts

@@ -1,2 +1,5 @@
 export * from './project-messages.ts';
 export * from './sprite-variable-edit.ts';
+export * from './project-search.ts';
+export * from './project-search-replace.ts';
+export * from './project-search-connections.ts';

package/src/project-search-connections.ts

@@ -0,0 +1,127 @@
+import type {ProjectSearchResult, SearchProject, VariableSearch, YamlSearchDocument, YamlSearchResult} from './project-search.ts';
+import type {ReplaceBlockly, ReplaceWorkspace} from './project-search-replace.ts';
+
+export type SearchDocuments = {
+    getSearchableYamlDocuments(): readonly YamlSearchDocument[];
+    openYamlPreview(reference: YamlSearchDocument['reference'], range: YamlSearchResult['range']): boolean;
+    stageYamlReplacement?(reference: YamlSearchDocument['reference'], range: YamlSearchResult['range'],
+        source: string, text: string): boolean;
+};
+
+type SearchView = {id: string; groupId: string; targetId: string; section: number};
+type SearchViews = {
+    views(): SearchView[];
+    currentView(): SearchView | undefined;
+    activateView(id: string): boolean;
+    select(id: string): void;
+    setViewSection(id: string, section: number): boolean;
+    selectAsset(id: string, kind: 'costumes' | 'sounds', index: number): void;
+};
+type Target = ProjectSearchResult['target'];
+export type SearchNavigation = {
+    getViews(): SearchViews | null;
+    getTarget(id: string): Target | undefined;
+    getEditingTarget(): Target | undefined;
+    centerBlock(id: string): void;
+    centerComment(id: string, blockId?: string | null): void;
+    replacementContext?(): {workspace: ReplaceWorkspace; Blockly: ReplaceBlockly} | undefined;
+};
+
+type SearchConnection = {
+    navigation?: SearchNavigation;
+    documents?: SearchDocuments;
+    openReplace?: () => void;
+    openVariable?: (filter: VariableSearch) => void;
+    listeners: Set<() => void>;
+};
+
+const connections = new WeakMap<SearchProject, SearchConnection>();
+
+export function connectionFor(project: SearchProject) {
+    let connection = connections.get(project);
+    if (!connection) {
+        connection = {listeners: new Set()};
+        connections.set(project, connection);
+    }
+    return connection;
+}
+
+/** Open a target's view in the active group and switch it to a section. */
+export function activateTargetView(navigation: SearchNavigation, targetId: string, section: number) {
+    const views = navigation.getViews();
+    if (!views) return undefined;
+    const groupId = views.currentView()?.groupId;
+    const local = views.views().find(view => view.groupId === groupId && view.targetId === targetId);
+    if (local) views.activateView(local.id);
+    else views.select(targetId);
+    const destination = views.currentView();
+    if (destination?.targetId !== targetId) return undefined;
+    views.setViewSection(destination.id, section);
+    return {views, viewId: destination.id, section};
+}
+
+export function connectProjectSearchNavigation(project: SearchProject, navigation: SearchNavigation) {
+    const connection = connectionFor(project);
+    connection.navigation = navigation;
+    connection.listeners.forEach(listener => listener());
+    return () => {
+        if (connection.navigation !== navigation) return;
+        connection.navigation = undefined;
+        connection.listeners.forEach(listener => listener());
+    };
+}
+
+export function connectProjectSearchDocuments(project: SearchProject, documents: SearchDocuments) {
+    const connection = connectionFor(project);
+    connection.documents = documents;
+    connection.listeners.forEach(listener => listener());
+    return () => {
+        if (connection.documents !== documents) return;
+        connection.documents = undefined;
+        connection.listeners.forEach(listener => listener());
+    };
+}
+
+export function connectProjectReplaceOpener(project: SearchProject, open: () => void) {
+    const connection = connectionFor(project);
+    connection.openReplace = open;
+    return () => {
+        if (connection.openReplace === open) connection.openReplace = undefined;
+    };
+}
+
+export function projectReplaceOpener(project?: SearchProject) {
+    return project && connections.get(project)?.openReplace;
+}
+
+export function connectVariableSearchOpener(project: SearchProject, open: (filter: VariableSearch) => void) {
+    const connection = connectionFor(project);
+    connection.openVariable = open;
+    return () => {
+        if (connection.openVariable === open) connection.openVariable = undefined;
+    };
+}
+
+export function openVariableSearch(project: SearchProject, filter: VariableSearch) {
+    connections.get(project)?.openVariable?.(filter);
+}
+
+const replaceKey = 'F';
+
+export function isMacPlatform() {
+    return typeof navigator !== 'undefined' && /^(Mac|iP)/.test(navigator.platform ?? '');
+}
+
+// Search is the platform's own find shortcut, so replace is the shifted form of it: ⇧⌘F on macOS
+// and Ctrl+Shift+F elsewhere.
+export const projectReplaceShortcut = {
+    keys: `Control+Shift+${replaceKey}`,
+    macKeys: `Meta+Shift+${replaceKey}`,
+    label: `Ctrl+Shift+${replaceKey}`,
+    macLabel: `⇧⌘${replaceKey}`,
+    matches(event: KeyboardEvent) {
+        const primary = isMacPlatform() ? event.metaKey && !event.ctrlKey : event.ctrlKey && !event.metaKey;
+        return primary && event.shiftKey && !event.altKey && !event.isComposing &&
+            event.key.toUpperCase() === replaceKey;
+    }
+};

package/src/project-search-replace.ts

@@ -0,0 +1,189 @@
+import {literalSearchPattern, type ProjectSearchResult, type SearchProject, type SearchResult} from './project-search.ts';
+
+type Field = {
+    getValue(): unknown;
+    setValue(value: string): void;
+    callValidator(value: string): unknown;
+    getOptions?(): ReadonlyArray<readonly [unknown, unknown]>;
+};
+type Comment = {getText(): string; setText(value: string): void};
+type Block = {
+    isEditable(): boolean;
+    getField(name: string): Field | undefined;
+    comment?: Comment;
+    mutationToDom(): Element;
+};
+type RenameEvent = {type: string; varId?: string; newName?: string};
+export type ReplaceWorkspace = {
+    options: {readOnly: boolean};
+    isDragging(): boolean;
+    getBlockById(id: string): Block | null;
+    getCommentById(id: string): Comment | null;
+    getVariableById(id: string): {name: string} | null;
+    renameVariableById(id: string, name: string): void;
+    addChangeListener(listener: (event: RenameEvent) => void): void;
+};
+export type ReplaceBlockly = {
+    FieldTextInput: abstract new (...args: never[]) => Field;
+    FieldDropdown: abstract new (...args: never[]) => Field;
+    FieldNumber: abstract new (...args: never[]) => Field;
+    Procedures: {
+        getPrototypeBlock(name: string, workspace: ReplaceWorkspace): Block | null;
+        mutateCallersAndPrototype(name: string, workspace: ReplaceWorkspace, mutation: Element): void;
+    };
+};
+export type ReplaceOutcome = 'applied' | 'staged' | 'stale' | 'conflict' | 'invalid' | 'read-only';
+
+function spliceMatch(value: string, pattern: RegExp, replacement: string) {
+    const match = pattern.exec(value);
+    if (match) return value.slice(0, match.index) + replacement + value.slice(match.index + match[0].length);
+}
+
+function replaceProcedureLabel(name: string, pattern: RegExp, replacement: string) {
+    if (/%[sbn]/.test(replacement)) return;
+    const parts = name.split(/(%[sbn])/);
+    for (let i = 0; i < parts.length; i += 2) {
+        const changed = spliceMatch(parts[i], pattern, replacement);
+        if (changed === undefined) continue;
+        parts[i] = changed;
+        const next = parts.join('');
+        if (JSON.stringify(next.match(/%[sbn]/g)) === JSON.stringify(name.match(/%[sbn]/g))) return next;
+        return;
+    }
+}
+
+export function replacementText(result: SearchResult, query: string, replacement: string) {
+    if (!query.trim()) return;
+    if (result.kind === 'yaml') return replacement !== result.range.expectedText ? replacement : undefined;
+    const edit = result.edit;
+    if (!edit) return;
+    const pattern = literalSearchPattern(query, 'iu');
+    const source = edit.type === 'name' || edit.type === 'procedure' ? edit.name : edit.type === 'comment' ? edit.text : edit.value;
+    const next = edit.type === 'procedure' ? replaceProcedureLabel(source, pattern, replacement) :
+        spliceMatch(source, pattern, replacement);
+    return next !== source ? next : undefined;
+}
+
+const watchedBroadcasts = new WeakMap<ReplaceWorkspace, Set<string>>();
+function maintainBroadcastReferences(project: SearchProject, workspace: ReplaceWorkspace, id: string) {
+    let ids = watchedBroadcasts.get(workspace);
+    if (!ids) {
+        const watched = new Set<string>();
+        watchedBroadcasts.set(workspace, watched);
+        ids = watched;
+        workspace.addChangeListener(event => {
+            if (event.type !== 'var_rename' || !event.varId || !watched.has(event.varId)) return;
+            const variable = project.targets.find(target => target.isStage)?.variables[event.varId];
+            if (variable?.type !== 'broadcast_msg' || variable.name !== event.newName || variable.value === variable.name) return;
+            variable.value = variable.name;
+            for (const blocks of new Set(project.targets.map(target => target.blocks))) {
+                const pending = [...blocks.getScripts()];
+                const seen = new Set<string>();
+                while (pending.length) {
+                    const id = pending.pop();
+                    if (!id || seen.has(id)) continue;
+                    seen.add(id);
+                    const block = blocks.getBlock(id);
+                    if (!block) continue;
+                    const field = block.fields?.BROADCAST_OPTION;
+                    if (field?.id === event.varId) field.value = variable.name;
+                    if (block.next) pending.push(block.next);
+                    for (const input of Object.values(block.inputs ?? {})) {
+                        if (input.block) pending.push(input.block);
+                        if (input.shadow) pending.push(input.shadow);
+                    }
+                }
+            }
+            project.resetAllCaches?.();
+            project.emitProjectChanged?.();
+        });
+    }
+    ids.add(id);
+}
+
+function validName(value: string) {
+    return Boolean(value.trim()) && value === value.trim() && !/[\u0000-\u001f\u007f]/u.test(value);
+}
+
+/** Rename a message from the message section, where no block result carries the edit. */
+export function renameProjectMessage(project: SearchProject, workspace: ReplaceWorkspace,
+    id: string, next: string): ReplaceOutcome {
+    if (workspace.options.readOnly || workspace.isDragging()) return 'read-only';
+    const owner = project.targets.find(target => Object.hasOwn(target.variables, id));
+    const variable = owner?.variables[id];
+    if (variable?.type !== 'broadcast_msg' || workspace.getVariableById(id)?.name !== variable.name) return 'stale';
+    if (!validName(next)) return 'invalid';
+    const match = next.toLocaleLowerCase();
+    if (project.targets.some(target => Object.entries(target.variables).some(([other, candidate]) =>
+        other !== id && candidate.type === 'broadcast_msg' && candidate.name.toLocaleLowerCase() === match))) {
+        return 'conflict';
+    }
+    maintainBroadcastReferences(project, workspace, id);
+    workspace.renameVariableById(id, next);
+    return workspace.getVariableById(id)?.name === next ? 'applied' : 'conflict';
+}
+
+export function applyProjectSearchReplacement(project: SearchProject, workspace: ReplaceWorkspace,
+    Blockly: ReplaceBlockly, result: ProjectSearchResult, next: string): ReplaceOutcome {
+    if (workspace.options.readOnly || workspace.isDragging() || !result.edit) return 'read-only';
+    const {target, edit} = result;
+    if (!project.targets.includes(target) || ('block' in result && target.blocks.getBlock(result.block.id) !== result.block)) return 'stale';
+    if (edit.type === 'comment' && result.kind === 'comment') {
+        const current = target.comments?.[result.commentId];
+        if (current !== result.comment || current.text !== edit.text) return 'stale';
+        const comment = current.blockId ? workspace.getBlockById(current.blockId)?.comment : workspace.getCommentById(result.commentId);
+        if (!comment || comment.getText() !== edit.text) return 'stale';
+        comment.setText(next);
+        return 'applied';
+    }
+    if (edit.type === 'name') {
+        if (!('block' in result)) return 'stale';
+        const fieldName = result.kind === 'variable' ? 'VARIABLE' : result.kind === 'list' ? 'LIST' : 'BROADCAST_OPTION';
+        const field = result.block.fields?.[fieldName] ??
+            target.blocks.getBlock(result.block.inputs?.BROADCAST_INPUT?.block)?.fields?.[fieldName];
+        if (field?.id !== edit.id) return 'stale';
+        const variable = edit.owner.variables[edit.id];
+        const model = workspace.getVariableById(edit.id);
+        if (!project.targets.includes(edit.owner) || !variable || variable.name !== edit.name || model?.name !== edit.name) return 'stale';
+        if (!validName(next) || variable.isCloud) return 'invalid';
+        const scope = edit.owner.isStage ? project.targets.filter(target => target.isOriginal) :
+            project.targets.filter(target => target === edit.owner || target.isStage);
+        const match = next.toLocaleLowerCase();
+        if (scope.some(target => Object.entries(target.variables).some(([id, candidate]) =>
+            id !== edit.id && (candidate.type ?? '') === edit.variableType && candidate.name.toLocaleLowerCase() === match))) return 'conflict';
+        if (edit.variableType === 'broadcast_msg') maintainBroadcastReferences(project, workspace, edit.id);
+        workspace.renameVariableById(edit.id, next);
+        return workspace.getVariableById(edit.id)?.name === next ? 'applied' : 'conflict';
+    }
+    if (edit.type === 'procedure') {
+        if (!('block' in result)) return 'stale';
+        const procedure = result.block.mutation?.proccode ??
+            target.blocks.getBlock(result.block.inputs?.custom_block?.block)?.mutation?.proccode;
+        if (procedure !== edit.name) return 'stale';
+        if (!validName(next) || !next.replace(/%[sbn]/g, '').trim()) return 'invalid';
+        const prototype = Blockly.Procedures.getPrototypeBlock(edit.name, workspace);
+        if (!prototype) return 'stale';
+        if (next !== edit.name && Blockly.Procedures.getPrototypeBlock(next, workspace)) return 'conflict';
+        const mutation = prototype.mutationToDom();
+        mutation.setAttribute('proccode', next);
+        Blockly.Procedures.mutateCallersAndPrototype(edit.name, workspace, mutation);
+        return 'applied';
+    }
+    if (edit.type === 'field' && 'block' in result) {
+        const {id, field: name, value} = edit;
+        if (id !== result.block.id && !Object.values(result.block.inputs ?? {}).some(input => input.block === id)) return 'stale';
+        const block = workspace.getBlockById(id);
+        const field = block?.getField(name);
+        if (!field || String(field.getValue()) !== value || String(target.blocks.getBlock(id)?.fields?.[name]?.value) !== value) return 'stale';
+        const text = Boolean(field instanceof Blockly.FieldTextInput);
+        const dropdown = Boolean(field instanceof Blockly.FieldDropdown);
+        if (!block?.isEditable() || !(text || dropdown)) return 'read-only';
+        if (field instanceof Blockly.FieldNumber && (!next.trim() || !Number.isFinite(Number(next)))) return 'invalid';
+        if (dropdown && !field.getOptions?.().some(option => String(option[1]) === next)) return 'invalid';
+        const validated = field.callValidator(next);
+        if (validated === null || (validated !== undefined && String(validated) !== next)) return 'invalid';
+        field.setValue(next);
+        return String(field.getValue()) === next ? 'applied' : 'invalid';
+    }
+    return 'read-only';
+}