@theoremjs/studio 0.0.0-stage → 0.3.2

package/server/save-remove.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Takes a profile or a tool the studio removed out of the project's files: the statement that
+ * registers it, and what only that statement used. A definition something else still reads stays.
+ * Whatever the files do that the studio cannot follow is named, and nothing is planned for it.
+ *
+ * @module
+ */
+import { type ProjectSource } from './project-source.ts';
+import type { SavePlan } from './save-plan.ts';
+/** What the studio took away: the ids of profiles and providers and the names of tools the project has. */
+export interface Removed {
+    profiles: readonly string[];
+    tools: readonly string[];
+    providers: readonly string[];
+}
+export interface RemovalPlan extends SavePlan {
+    /** The files left with nothing of their own, which Save takes away. */
+    gone: string[];
+}
+/** Plans the removal of each profile, tool, and provider the studio took away. */
+export declare function planRemoved(project: ProjectSource, removed: Removed): RemovalPlan;

package/server/save-remove.js

@@ -0,0 +1,528 @@
+/**
+ * Takes a profile or a tool the studio removed out of the project's files: the statement that
+ * registers it, and what only that statement used. A definition something else still reads stays.
+ * Whatever the files do that the studio cannot follow is named, and nothing is planned for it.
+ *
+ * @module
+ */
+import ts from 'typescript';
+import { calleeName, isRead, propertyName, setupExport, sourceOf, unwrapped, } from "./project-source.js";
+/** The calls that register what a profile's or a provider's module holds. */
+const REGISTERS = new Set([
+    'registerProfile',
+    'registerStructured',
+    'registerProvider',
+    'registerTool',
+]);
+/** `node` with the wrappers around it that do not change what it is. */
+function wrapped(node) {
+    let at = node;
+    while (ts.isParenthesizedExpression(at.parent) ||
+        ts.isAsExpression(at.parent) ||
+        ts.isSatisfiesExpression(at.parent) ||
+        ts.isNonNullExpression(at.parent) ||
+        ts.isAwaitExpression(at.parent))
+        at = at.parent;
+    return at;
+}
+/** The statement an expression is the whole of, when it stands in a file or a block. */
+function statementOf(expression) {
+    const { parent } = wrapped(expression);
+    if (!ts.isExpressionStatement(parent))
+        return undefined;
+    return ts.isSourceFile(parent.parent) || ts.isBlock(parent.parent) ? parent : undefined;
+}
+/** A file's top-level declaration that `value` is the whole value of: one `const`, alone in its statement. */
+function declared(value, source) {
+    const { parent } = wrapped(value);
+    if (!ts.isVariableDeclaration(parent) || !ts.isIdentifier(parent.name))
+        return undefined;
+    const statement = parent.parent.parent;
+    if (!ts.isVariableStatement(statement) || statement.parent !== source)
+        return undefined;
+    if (!(statement.declarationList.flags & ts.NodeFlags.Const))
+        return undefined;
+    if (statement.declarationList.declarations.length !== 1)
+        return undefined;
+    return { name: parent.name.text, source, statement };
+}
+/** The top-level function a statement is the whole body of. */
+function wholeBodyOf(statement, source) {
+    const block = statement.parent;
+    if (!ts.isBlock(block) || block.statements.length !== 1)
+        return undefined;
+    const held = block.parent;
+    if (!ts.isFunctionDeclaration(held) || held.parent !== source || !held.name)
+        return undefined;
+    return { name: held.name.text, source, statement: held };
+}
+function readsIn(source, name, declaration) {
+    const reads = [];
+    const visit = (node) => {
+        if (ts.isImportDeclaration(node))
+            return;
+        if (ts.isIdentifier(node) && node.text === name && node.parent !== declaration && isRead(node))
+            reads.push(node);
+        ts.forEachChild(node, visit);
+    };
+    visit(source);
+    return reads;
+}
+/** Each import and re-export of `home` the project's other files write. */
+function* importsOf(project, home) {
+    for (const source of project.files.values()) {
+        if (source === home)
+            continue;
+        for (const statement of source.statements) {
+            if (!ts.isImportDeclaration(statement) && !ts.isExportDeclaration(statement))
+                continue;
+            const specifier = statement.moduleSpecifier;
+            if (!specifier || !ts.isStringLiteralLike(specifier))
+                continue;
+            if (sourceOf(project, source, specifier.text) === home)
+                yield { source, statement };
+        }
+    }
+}
+/** How one import of a definition's file reads the definition, when it brings it in. */
+function importReader(source, statement, named) {
+    const bindings = statement.importClause?.namedBindings;
+    if (!bindings)
+        return undefined;
+    if (ts.isNamespaceImport(bindings)) {
+        const all = readsIn(source, bindings.name.text);
+        const own = (read) => ts.isPropertyAccessExpression(read.parent) &&
+            read.parent.expression === read &&
+            read.parent.name.text === named.name;
+        return {
+            source,
+            reads: all.filter(own),
+            others: all.filter((read) => !own(read)),
+            imported: statement,
+            passesOn: false,
+        };
+    }
+    const element = bindings.elements.find((each) => (each.propertyName ?? each.name).text === named.name);
+    return (element && {
+        source,
+        reads: readsIn(source, element.name.text),
+        others: [],
+        imported: element,
+        passesOn: false,
+    });
+}
+/** Every file of the project that reads `named`, by its own name or through an import of its file. */
+function readersOf(project, named) {
+    const declaration = ts.isVariableStatement(named.statement)
+        ? named.statement.declarationList.declarations[0]
+        : named.statement;
+    const readers = [
+        {
+            source: named.source,
+            reads: readsIn(named.source, named.name, declaration),
+            others: [],
+            passesOn: false,
+        },
+    ];
+    for (const { source, statement } of importsOf(project, named.source)) {
+        const reader = ts.isImportDeclaration(statement)
+            ? importReader(source, statement, named)
+            : { source, reads: [], others: [], passesOn: true };
+        if (reader)
+            readers.push(reader);
+    }
+    return readers;
+}
+/** One plan in the making: what goes, and what could not be followed. */
+/** The statement a call is, when it registers `value` or, for a function, calls it. */
+function callPart(call, value, callable) {
+    const registers = call.arguments.includes(value) && REGISTERS.has(calleeName(call) ?? '');
+    const called = callable && call.expression === value;
+    return registers || called ? statementOf(call) : undefined;
+}
+const SETUP_EXPORTS = ['questions', 'images'];
+/** `value`'s entry in the setup's `questions` or `images`, when that is where it sits. */
+function setupEntry(parent, value, source) {
+    const entry = ts.isShorthandPropertyAssignment(parent) ||
+        (ts.isPropertyAssignment(parent) && parent.initializer === value);
+    if (!entry)
+        return undefined;
+    const held = SETUP_EXPORTS.some((name) => {
+        const value = setupExport(source, name)?.initializer;
+        return value && parent.parent === unwrapped(value);
+    });
+    return held ? parent : undefined;
+}
+class Removal {
+    project;
+    changes = [];
+    cut = new Map();
+    /** The files that define what was removed. */
+    homes = new Set();
+    constructor(project) {
+        this.project = project;
+    }
+    lineOf(node, source) {
+        return source.getLineAndCharacterOfPosition(node.getStart(source)).line + 1;
+    }
+    note(kind, of, status, at) {
+        this.changes.push({
+            kind,
+            of,
+            setting: '',
+            status,
+            ...(at ? { file: at.source.fileName, line: this.lineOf(at.node, at.source) } : {}),
+        });
+    }
+    /**
+     * What a read of a name is there for, when taking it out leaves nothing behind: a statement
+     * that registers it, a statement that calls it when it is a function, or its entry in the
+     * setup's `questions` or `images`.
+     */
+    partOf(read, source, callable = false) {
+        let value = read;
+        // `module.profile` and `module.structured.id` are reads of what the module holds.
+        while (ts.isPropertyAccessExpression(value.parent) && value.parent.expression === value)
+            value = value.parent;
+        value = wrapped(value);
+        const { parent } = value;
+        if (ts.isCallExpression(parent))
+            return callPart(parent, value, callable);
+        return setupEntry(parent, value, source);
+    }
+    /**
+     * Takes a named definition out of every file that only registers it. True when a statement that
+     * registers it was found. The definition itself goes when nothing else reads it.
+     */
+    named(named) {
+        const readers = readersOf(this.project, named);
+        const callable = ts.isFunctionDeclaration(named.statement);
+        const uses = readers.map((reader) => reader.reads.map((read) => this.partOf(read, reader.source, callable)));
+        const registering = uses
+            .flat()
+            .filter((use) => use !== undefined && ts.isExpressionStatement(use));
+        if (!registering.length)
+            return false;
+        // A module that defines one profile holds what goes with it: its reply's shape, its questions.
+        const alone = !callable && this.definedIn(named.source) === 1;
+        let kept = false;
+        readers.forEach((reader, index) => {
+            const held = uses[index] ?? [];
+            for (const use of held)
+                if (use)
+                    this.cut.set(use, reader.source);
+            const beside = reader.others.map((read) => alone ? this.partOf(read, reader.source) : undefined);
+            const whole = !reader.passesOn && [...held, ...beside].every((use) => use !== undefined);
+            if (whole)
+                for (const use of beside)
+                    if (use)
+                        this.cut.set(use, reader.source);
+            if (whole && reader.imported)
+                this.unimport(reader.imported, reader.source);
+            if (!held.every((use) => use !== undefined) || reader.passesOn)
+                kept = true;
+        });
+        if (!kept)
+            this.cut.set(named.statement, named.source);
+        return true;
+    }
+    /** How many profiles a file defines. */
+    definedIn(source) {
+        let count = 0;
+        for (const targets of this.project.profiles.values())
+            count += targets.filter((target) => target.source === source).length;
+        return count;
+    }
+    /** An import's name goes, and the import with it when that was all it brought in. */
+    unimport(imported, source) {
+        if (ts.isImportDeclaration(imported)) {
+            this.cut.set(imported, source);
+            return;
+        }
+        this.cut.set(imported, source);
+        const names = imported.parent;
+        const statement = names.parent.parent;
+        if (!ts.isImportDeclaration(statement))
+            return;
+        const alone = !statement.importClause?.name && names.elements.every((element) => this.cut.has(element));
+        if (alone)
+            this.cut.set(statement, source);
+    }
+    /**
+     * Takes out a profile `register` registers: the statement that registers it where it is written,
+     * or its named definition and each statement that registers the name. True when it went; a way of
+     * registering the studio cannot follow is noted instead.
+     */
+    defined(id, register) {
+        const kind = 'profile';
+        const targets = this.project.profiles.get(id) ?? [];
+        const [target] = targets;
+        const unfollowed = (place) => {
+            this.note(kind, id, 'removed', place);
+            return false;
+        };
+        if (!target)
+            return unfollowed();
+        const at = { node: target.options, source: target.source };
+        // Written twice: the studio cannot tell which one runs.
+        if (targets.length > 1)
+            return unfollowed(at);
+        const defined = wrapped(target.options).parent;
+        const outer = wrapped(defined).parent;
+        // Registered where it is written: with its `define` call inside the call, or without it.
+        const registers = [defined, outer].find((call) => ts.isCallExpression(call) && calleeName(call) === register);
+        const inline = registers && statementOf(registers);
+        const named = inline ? undefined : declared(defined, target.source);
+        if (inline)
+            this.cut.set(inline, target.source);
+        else if (!named || !this.named(named))
+            return unfollowed(at);
+        this.homes.add(target.source);
+        this.note(kind, id, 'written', at);
+        return true;
+    }
+    profile(id) {
+        if (this.defined(id, 'registerProfile'))
+            this.unasked(id);
+    }
+    provider(id) {
+        // Registered under a name, it goes with each statement that reads the name.
+        this.registration('provider', id, this.project.providers, (target) => wrapped(target.options).parent);
+    }
+    /** A removed decision's entries in the setup's `questions` and `images`, under its id. */
+    unasked(id) {
+        for (const source of this.project.files.values()) {
+            for (const name of SETUP_EXPORTS) {
+                const held = setupExport(source, name)?.initializer;
+                const named = held && unwrapped(held);
+                if (!named || !ts.isObjectLiteralExpression(named))
+                    continue;
+                const entry = named.properties.find((property) => propertyName(property) === id);
+                if (entry)
+                    this.cut.set(entry, source);
+            }
+        }
+    }
+    tool(name) {
+        // Written as a constant: it goes with each statement that registers it.
+        this.registration('tool', name, this.project.tools, (target) => target.options);
+    }
+    /**
+     * Takes out the call that registers a tool or a provider. A function that only makes the call
+     * goes with its calls; one nothing here calls is the setup's own, and keeps its name. A call that
+     * is not a statement of its own goes with the name `named` gives it, and each statement that reads it.
+     */
+    registration(kind, id, held, named) {
+        const targets = held.get(id) ?? [];
+        const [target] = targets;
+        if (!target)
+            return this.note(kind, id, 'removed');
+        const at = { node: target.options, source: target.source };
+        if (targets.length > 1)
+            return this.note(kind, id, 'removed', at);
+        const statement = statementOf(wrapped(target.options).parent);
+        if (statement) {
+            const register = wholeBodyOf(statement, target.source);
+            if (!register || !this.named(register))
+                this.cut.set(statement, target.source);
+        }
+        else {
+            const name = declared(named(target), target.source);
+            if (!name || !this.named(name))
+                return this.note(kind, id, 'removed', at);
+        }
+        this.homes.add(target.source);
+        this.note(kind, id, 'written', at);
+    }
+    within(part) {
+        for (let at = part.parent; at; at = at.parent)
+            if (this.cut.has(at))
+                return true;
+        return false;
+    }
+    /**
+     * A file that defined what was removed and that the project no longer reads: nothing imports it
+     * now, and all that is left in it are declarations. Each one it exports was read in the setup, and
+     * only by what is cut. An export the setup never reads, which a test or a server may import, or a
+     * statement that runs, keeps the file.
+     */
+    isGone(source) {
+        if (source.fileName === this.project.entry || !this.homes.has(source))
+            return false;
+        for (const { statement } of importsOf(this.project, source))
+            if (!this.cut.has(statement))
+                return false;
+        const own = source.statements.filter((statement) => !ts.isImportDeclaration(statement));
+        const left = own.filter((statement) => !this.cut.has(statement));
+        return (own.length > left.length &&
+            left.every((statement) => {
+                const names = declaredNames(statement);
+                if (!names)
+                    return false;
+                if (!isExported(statement))
+                    return true;
+                return names.every((name) => this.readOnlyByCut({ name, source, statement }));
+            }));
+    }
+    /** Whether the setup reads `named`, and only in what is cut. */
+    readOnlyByCut(named) {
+        const readers = readersOf(this.project, named);
+        const reads = readers.flatMap((reader) => reader.reads);
+        return (!readers.some((reader) => reader.passesOn) &&
+            reads.length > 0 &&
+            reads.every((read) => this.isCut(read)));
+    }
+    isCut(node) {
+        for (let at = node; at; at = at.parent)
+            if (this.cut.has(at))
+                return true;
+        return false;
+    }
+    /** An import of a file only for what running it registers goes when the file registers nothing now. */
+    unrun() {
+        for (const home of this.homes) {
+            const own = home.statements.filter((statement) => !ts.isImportDeclaration(statement));
+            if (!own.length || !own.every((statement) => this.cut.has(statement)))
+                continue;
+            for (const { source, statement } of importsOf(this.project, home)) {
+                if (ts.isImportDeclaration(statement) && !statement.importClause)
+                    this.cut.set(statement, source);
+            }
+        }
+    }
+    build() {
+        this.unrun();
+        const gone = [...this.project.files.values()].filter((source) => this.isGone(source));
+        const parts = new Map();
+        for (const [part, source] of this.cut) {
+            if (gone.includes(source) || this.within(part))
+                continue;
+            parts.set(source, [...(parts.get(source) ?? []), part]);
+        }
+        const edits = [...parts].flatMap(([source, held]) => cutsOf(held, source).map(({ start, end }) => ({ file: source.fileName, start, end, text: '' })));
+        return { changes: this.changes, edits, gone: gone.map((source) => source.fileName) };
+    }
+}
+/** The names a top-level declaration declares, or undefined for a statement that is not one. */
+function declaredNames(statement) {
+    if (ts.isVariableStatement(statement)) {
+        const names = statement.declarationList.declarations.map((each) => ts.isIdentifier(each.name) ? each.name.text : undefined);
+        return names.every((name) => name !== undefined) ? names : undefined;
+    }
+    const declares = ts.isFunctionDeclaration(statement) ||
+        ts.isClassDeclaration(statement) ||
+        ts.isInterfaceDeclaration(statement) ||
+        ts.isTypeAliasDeclaration(statement) ||
+        ts.isEnumDeclaration(statement);
+    return declares && statement.name ? [statement.name.text] : undefined;
+}
+function isExported(statement) {
+    return (ts.canHaveModifiers(statement) &&
+        (ts
+            .getModifiers(statement)
+            ?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword) ??
+            false));
+}
+const BLANK = /^[ \t]*$/;
+/** The comments right above a part, with no blank line between: they are about it, and go with it. */
+function withComments(part, source) {
+    let start = part.getStart(source);
+    const comments = ts.getLeadingCommentRanges(source.text, part.getFullStart()) ?? [];
+    for (const comment of comments.toReversed()) {
+        const between = source.text.slice(comment.end, start);
+        if (between.trim() !== '' || between.split('\n').length > 2)
+            break;
+        start = comment.pos;
+    }
+    return start;
+}
+/** The lines a part fills, when nothing else is written on them. A listed part's comma is its own. */
+function ownLines(part, source) {
+    const { text } = source;
+    const start = withComments(part, source);
+    const end = !ts.isStatement(part) && text[part.end] === ',' ? part.end + 1 : part.end;
+    const lineStart = text.lastIndexOf('\n', start - 1) + 1;
+    const next = text.indexOf('\n', end);
+    const lineEnd = next === -1 ? text.length : next;
+    if (!BLANK.test(text.slice(lineStart, start)) || !BLANK.test(text.slice(end, lineEnd)))
+        return undefined;
+    return { start: lineStart, end: next === -1 ? text.length : next + 1, lines: true };
+}
+/** The list a part is one entry of: an object's properties, or an import's names. */
+function listOf(part) {
+    if (ts.isImportSpecifier(part))
+        return part.parent.elements;
+    if (ts.isStatement(part))
+        return undefined;
+    return ts.isObjectLiteralExpression(part.parent) ? part.parent.properties : undefined;
+}
+/**
+ * The cut for entries that share their line with others: up to the entry that follows them, or
+ * back to the one before when they are last, so the commas left are the ones the list needs.
+ */
+function inList(list, first, last, source) {
+    const [from, to, after, before] = [list[first], list[last], list[last + 1], list[first - 1]];
+    if (!from || !to)
+        throw new Error('A cut names an entry its list does not hold.');
+    if (after)
+        return { start: from.getStart(source), end: after.getStart(source), lines: false };
+    if (before)
+        return { start: before.end, end: to.end, lines: false };
+    const end = source.text[to.end] === ',' ? to.end + 1 : to.end;
+    return { start: from.getStart(source), end, lines: false };
+}
+/** One blank line stays between what was above a cut and what was below it, not two. */
+function closed(cut, text) {
+    if (!cut.lines)
+        return cut;
+    const above = cut.start === 0 ||
+        BLANK.test(text.slice(text.lastIndexOf('\n', cut.start - 2) + 1, cut.start - 1));
+    const next = text.indexOf('\n', cut.end);
+    const below = next !== -1 && BLANK.test(text.slice(cut.end, next));
+    return above && below ? { ...cut, end: next + 1 } : cut;
+}
+/** What to take out of one file for the parts cut from it: no two cuts touch. */
+function cutsOf(parts, source) {
+    const cuts = [];
+    const listed = new Map();
+    for (const part of parts) {
+        const own = ownLines(part, source);
+        const list = own ? undefined : listOf(part);
+        if (own)
+            cuts.push(own);
+        else if (list)
+            listed.set(list, [...(listed.get(list) ?? []), part]);
+        else
+            cuts.push({ start: withComments(part, source), end: part.end, lines: false });
+    }
+    for (const [list, held] of listed) {
+        const at = held.map((part) => list.indexOf(part)).sort((a, b) => a - b);
+        for (let index = 0; index < at.length; index++) {
+            const first = at[index] ?? 0;
+            while (at[index + 1] === (at[index] ?? 0) + 1)
+                index++;
+            cuts.push(inList(list, first, at[index] ?? first, source));
+        }
+    }
+    cuts.sort((a, b) => a.start - b.start);
+    const joined = [];
+    for (const cut of cuts) {
+        const last = joined.at(-1);
+        if (last && cut.start <= last.end)
+            last.end = Math.max(last.end, cut.end);
+        else
+            joined.push({ ...cut });
+    }
+    return joined.map((cut) => closed(cut, source.text));
+}
+/** Plans the removal of each profile, tool, and provider the studio took away. */
+export function planRemoved(project, removed) {
+    const removal = new Removal(project);
+    for (const id of removed.profiles)
+        removal.profile(id);
+    for (const name of removed.tools)
+        removal.tool(name);
+    for (const id of removed.providers)
+        removal.provider(id);
+    return removal.build();
+}

package/server/save-session.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Save for one open project: the review of what would change, the write with
+ * its three proofs, and the undo. It reaches the disk and the project's process
+ * only through the host it is given, so the rules can be run without either.
+ *
+ * @module
+ */
+import type { ReadStep } from '../read-steps.ts';
+import type { StudioWorkspace } from '../workspace.ts';
+import { type ProjectSource } from './project-source.ts';
+import { type ProjectNames } from './save.ts';
+import type { ProjectOrigins, ProviderPlace, SaveDone, SaveRefusal, SaveRequest, SaveReview, SharedSetting, Unregistered } from './save-wire.ts';
+/** What Save needs from the machine. `Loaded` is one load of the project. */
+export interface SaveHost<Loaded> {
+    /** The folder Save may write in. */
+    root: string;
+    /** The project's setup module, inside `root`. */
+    setupFile: string;
+    /** A project file's text, or undefined when it is missing or leads outside the project. */
+    read(path: string): string | undefined;
+    /** Whether a write to this path lands inside `root`: no link on the way, or at it, leads out. */
+    landsInside(path: string): boolean;
+    /** Writes a file, with the folders that lead to it. */
+    write(path: string, text: string): void;
+    /** Takes away a file: one Save created, or one a removal left with nothing of its own. */
+    remove(path: string): void;
+    /** Whether the project type-checks as it is on disk, and what the checker printed. */
+    typeChecks(): Promise<{
+        ok: boolean;
+        output: string;
+    }>;
+    /** Loads the project from disk. Throws what it printed when it does not start. */
+    load(): Promise<Loaded>;
+    stop(loaded: Loaded): Promise<void>;
+    /** The workspace a load opened as. */
+    opened(loaded: Loaded): StudioWorkspace;
+}
+/** What one read of the project's files says. Each file is named from the project's folder. */
+export interface FilesRead {
+    /** The project's shared settings. */
+    shared: SharedSetting[];
+    /** The settings the files set in code. */
+    origins: ProjectOrigins;
+    /** The profiles and tools the files define that the project did not register. */
+    unregistered: Unregistered[];
+    /** Where the files define each provider the project registered. */
+    providerPlaces: ProviderPlace[];
+    /** What the project printed when the files did not load. */
+    unloaded?: string;
+}
+/** Save for one project, and the load of it that answers requests now. */
+export interface SaveSession<Loaded> {
+    project(): Loaded;
+    /** The absolute path of a file named from the project's folder, when the project's setup reads it. */
+    place(file: string): string | undefined;
+    /** The review when the request has no stamp; the write when it has the review's. */
+    save(request: SaveRequest): Promise<SaveReview | SaveDone | SaveRefusal>;
+    /** Puts the last Save's files back, when they still hold what it wrote. */
+    undo(): Promise<SaveDone | SaveRefusal>;
+    /**
+     * What the project's files say now, from one read of them. Loads the project again first when
+     * they changed outside the studio; when they do not load, the last load that did answers
+     * requests until they do. `said` hears each step of the read as it happens.
+     */
+    read(said?: (step: ReadStep) => void): Promise<FilesRead>;
+    /** Every file the project's setup reads, by absolute path. */
+    watched(): string[];
+    /**
+     * The files that hold something other than what the load that answers was read from, each from
+     * the project's folder. None after a Save or an undo: those are the studio's own writes.
+     */
+    changed(): Promise<string[]>;
+}
+/** Why nothing was done, with what to show for it. */
+export declare const refusal: (reason: SaveRefusal["reason"], detail?: string[]) => SaveRefusal;
+/** What a thrown value says. */
+export declare const message: (error: unknown) => string;
+/** A name for a value that changes when the value does. */
+export declare function stampOf(value: unknown): Promise<string>;
+/** Whether a body is a Save request, or one for the edited load: a workspace with its starts. */
+export declare function isSaveRequest(body: unknown): body is SaveRequest;
+/**
+ * What Save answers a request with, as a status and a body: the review or the write at `base`, and
+ * the undo at `base/undo`. Undefined when the request is not Save's.
+ */
+export declare function answerSave<Loaded>(session: Pick<SaveSession<Loaded>, 'save' | 'undo'>, base: string, request: Request): Promise<{
+    status: number;
+    body: unknown;
+} | undefined>;
+/**
+ * A project's origins as the page reads them: each file from the project's folder, and each
+ * profile and tool the project registers that no file defines marked as one the studio cannot find.
+ */
+export declare function pageOrigins(found: ProjectOrigins, names: ProjectNames, source: Pick<ProjectSource, 'profiles' | 'tools' | 'providers'>, inRoot: (file: string) => string): ProjectOrigins;
+/** Starts Save for a project that `first` loaded. */
+export declare function createSaveSession<Loaded>(host: SaveHost<Loaded>, first: Loaded): SaveSession<Loaded>;