arcane-os 0.64.0 → 0.66.0

package/src/core/repositories.mjs

@@ -1,10 +1,13 @@
-import {mkdir, readdir} from 'node:fs/promises';
+import {mkdir, readdir, writeFile} from 'node:fs/promises';
 import {homedir} from 'node:os';
 import path from 'node:path';
 import Is from 'strong-type';
 import {ArcaneError, throwIfAborted} from '../errors.mjs';
 import {runProcess} from '../process.mjs';
 import {repositoryPull, repositoryPush, repositoryStatus} from '../repository.mjs';
+import {createGitIdentityRunner} from '../git-identity.mjs';
+
+export {readGitIdentity} from '../git-identity.mjs';
 
 const is = new Is(false);
 const directoryOperations = new Map();
@@ -41,7 +44,7 @@ export function resolveArcaneDataPaths({dataRoot} = {}) {
 
 /** One connected checkout, composed into an application's own Core service. */
 export function createRepositoryWorkspace(
-    {name, directory, dataRoot, remote, branch, onEvent, run = runProcess} = {}
+    {name, directory, dataRoot, remote, branch, gitIdentity, onEvent, run = runProcess} = {}
 ) {
     let selected = directory;
     if (selected === undefined) {
@@ -55,12 +58,13 @@ export function createRepositoryWorkspace(
     if (remote !== undefined) requireString(remote, 'remote');
     if (branch !== undefined) requireString(branch, 'branch');
     if (!is.function(run)) throw new TypeError('run must implement the SDK process adapter.');
+    const execute = createGitIdentityRunner(run, gitIdentity);
     const repositoryDirectory = path.resolve(selected);
     const pending = new Set();
     let opened = false;
     let closing = null;
 
-    async function prepare(signal) {
+    async function prepare(signal, prepareRun = execute) {
         throwIfAborted(signal);
         if (opened) return {directory: repositoryDirectory, cloned: false};
         let entries;
@@ -74,7 +78,7 @@ export function createRepositoryWorkspace(
         if (entries.length) {
             // A parent checkout or a bare object cache is not this connection's
             // working root. Inspection never changes an existing destination.
-            const result = await run(
+            const result = await prepareRun(
                 'git',
                 ['rev-parse', '--is-inside-work-tree', '--show-prefix'],
                 {cwd: repositoryDirectory, signal, onEvent}
@@ -97,7 +101,7 @@ export function createRepositoryWorkspace(
         const arguments_ = ['clone', '--progress'];
         if (branch !== undefined) arguments_.push('--branch', branch);
         arguments_.push('--', remote, repositoryDirectory);
-        const result = await run(
+        const result = await prepareRun(
             'git',
             arguments_,
             {cwd: path.dirname(repositoryDirectory), signal, onEvent}
@@ -142,7 +146,7 @@ export function createRepositoryWorkspace(
         return accept(
             async function readRepositoryStatus() {
                 await prepare(signal);
-                return repositoryStatus({workspaceRoot: repositoryDirectory, signal, onEvent, run});
+                return repositoryStatus({workspaceRoot: repositoryDirectory, signal, onEvent, run: execute});
             },
             signal
         );
@@ -152,7 +156,7 @@ export function createRepositoryWorkspace(
         return accept(
             async function pullRepository() {
                 await prepare(signal);
-                return repositoryPull({workspaceRoot: repositoryDirectory, signal, onEvent, run});
+                return repositoryPull({workspaceRoot: repositoryDirectory, signal, onEvent, run: execute});
             },
             signal
         );
@@ -162,7 +166,172 @@ export function createRepositoryWorkspace(
         return accept(
             async function pushRepository() {
                 await prepare(signal);
-                return repositoryPush({workspaceRoot: repositoryDirectory, signal, onEvent, run});
+                return repositoryPush({workspaceRoot: repositoryDirectory, signal, onEvent, run: execute});
+            },
+            signal
+        );
+    }
+
+    function write({files, message, signal} = {}) {
+        let selectedFiles;
+        try {
+            requireString(message, 'message');
+            if (!message.isWellFormed()) throw new TypeError('message cannot be represented completely as UTF-8 text.');
+            if (!is.array(files) || files.length === 0) {
+                throw new TypeError('write requires at least one explicitly selected file.');
+            }
+            selectedFiles = Array.from(
+                files,
+                function snapshotFile(file) {
+                    const {path: filename, content} = file;
+                    requireString(filename, 'file.path');
+                    if (!filename.isWellFormed() || filename.includes('\0')) {
+                        throw new TypeError('file.path cannot be represented completely as a native filename.');
+                    }
+                    if (!is.string(content) || !content.isWellFormed()) {
+                        throw new TypeError('file.content must be complete UTF-8-representable text.');
+                    }
+                    const destination = path.resolve(repositoryDirectory, filename);
+                    const relative = path.relative(repositoryDirectory, destination);
+                    const first = relative.split(path.sep)[0];
+                    if (path.isAbsolute(filename) || !relative || relative === '..'
+                        || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)
+                        || first.toLowerCase() === '.git') {
+                        throw new TypeError('file.path must name a working file relative to this repository, outside Git metadata.');
+                    }
+                    return {path: filename, content, destination};
+                }
+            );
+        } catch (error) {
+            return Promise.reject(error);
+        }
+
+        return accept(
+            async function writeRepositoryFiles() {
+                const outcome = {
+                    directory: repositoryDirectory,
+                    state: 'local',
+                    stage: 'prepare',
+                    paths: selectedFiles.map(function selectedPath(file) { return file.path; }),
+                    writtenPaths: [],
+                    written: false,
+                    staged: false,
+                    committed: false,
+                    pushed: false,
+                    outputs: []
+                };
+                let pendingWrite = false;
+
+                async function executeGit(stage, args, input, options = {}) {
+                    throwIfAborted(signal);
+                    outcome.stage = stage;
+                    const output = {stage, stdout: '', stderr: ''};
+                    const observed = {stdout: false, stderr: false};
+                    outcome.outputs.push(output);
+                    let beforeStartFailed = false;
+
+                    function consumeOutput({stream, chunk}) {
+                        observed[stream] = true;
+                        output[stream] += chunk;
+                    }
+
+                    async function observeEvent(event) {
+                        try {
+                            await onEvent?.(event);
+                        } catch (error) {
+                            if (event.type === 'process.starting') beforeStartFailed = true;
+                            throw error;
+                        }
+                    }
+
+                    function recordCompletion(result) {
+                        if (!result || !is.integer(result.code)) return;
+                        output.code = result.code;
+                        output.signal = result.signal ?? null;
+                        for (const stream of ['stdout', 'stderr']) {
+                            if (!observed[stream] && is.string(result[stream])) output[stream] = result[stream];
+                        }
+                        if (result.code !== 0) return;
+                        if (stage === 'stage') outcome.staged = true;
+                        if (stage === 'commit') {
+                            outcome.committed = true;
+                            outcome.state = 'committed';
+                        }
+                        if (stage === 'push') {
+                            outcome.pushed = true;
+                            outcome.state = 'pushed';
+                        }
+                    }
+
+                    try {
+                        const result = await execute(
+                            'git',
+                            args,
+                            {cwd: options.cwd ?? repositoryDirectory, signal, onEvent: observeEvent,
+                                onOutput: consumeOutput, captureOutput: false, input}
+                        );
+                        recordCompletion(result);
+                        if (result.code !== 0) {
+                            throw new ArcaneError(
+                                'ARCANE_OPERATION_FAILED',
+                                `Git ${stage} exited with code ${String(result.code)}.`,
+                                {details: result}
+                            );
+                        }
+                        return {...result, stdout: output.stdout, stderr: output.stderr};
+                    } catch (error) {
+                        if (!beforeStartFailed) recordCompletion(error?.details);
+                        const notStarted = beforeStartFailed
+                            || (error?.code === 'ARCANE_PREREQUISITE_MISSING' && !error?.details)
+                            || (error?.code === 'ARCANE_CANCELLED' && !error?.details);
+                        if (!notStarted && output.code !== 0 && (stage === 'commit' || stage === 'push')) {
+                            outcome.state = 'uncertain';
+                        }
+                        throw error;
+                    }
+                }
+
+                async function* commitMessage() {
+                    yield message;
+                }
+
+                try {
+                    await prepare(
+                        signal,
+                        function prepareGit(command, args, options) {
+                            return executeGit('prepare', args, undefined, options);
+                        }
+                    );
+                    outcome.stage = 'write';
+                    for (const file of selectedFiles) {
+                        throwIfAborted(signal);
+                        outcome.path = file.path;
+                        await mkdir(path.dirname(file.destination), {recursive: true});
+                        throwIfAborted(signal);
+                        pendingWrite = true;
+                        await writeFile(file.destination, file.content, {encoding: 'utf8', signal});
+                        pendingWrite = false;
+                        outcome.writtenPaths.push(file.path);
+                    }
+                    outcome.written = true;
+                    delete outcome.path;
+                    await executeGit('stage', ['--literal-pathspecs', 'add', '--', ...outcome.paths]);
+                    await executeGit(
+                        'commit',
+                        ['--literal-pathspecs', 'commit', '--only', '--cleanup=verbatim', '--file', '-', '--', ...outcome.paths],
+                        commitMessage()
+                    );
+                    await executeGit('push', ['push']);
+                    outcome.stage = 'complete';
+                    return outcome;
+                } catch (cause) {
+                    if (pendingWrite) outcome.state = 'uncertain';
+                    throw new ArcaneError(
+                        cause?.code ?? 'ARCANE_REPOSITORY_WRITE_FAILED',
+                        cause instanceof Error ? cause.message : String(cause),
+                        {cause, details: outcome, exitCode: cause?.exitCode}
+                    );
+                }
             },
             signal
         );
@@ -188,7 +357,7 @@ export function createRepositoryWorkspace(
         return closing;
     }
 
-    return {directory: repositoryDirectory, open, status, pull, push, close, drain: close, dispose: close};
+    return {directory: repositoryDirectory, open, status, pull, push, write, close, drain: close, dispose: close};
 }
 
 function requireString(value, name) {

package/src/core/services/local-ai.mjs

@@ -208,17 +208,54 @@ export function createLocalAIService(configuration, {appRoot, runtimes = [], sig
         publish();
     }
 
+    function beginOllamaObservation(engine) {
+        return {revision: ++engine.ollamaRevision, signal: engine.signal};
+    }
+
+    function ownsOllamaObservation(engine, observation) {
+        return observation.signal === engine.signal && !observation.signal.aborted
+            && engine.server.current.available && observation.revision >= engine.ollamaAppliedRevision;
+    }
+
+    function recordOllamaFailure(engine, error, observation) {
+        if (!ownsOllamaObservation(engine, observation)) return;
+        engine.ollamaAppliedRevision = observation.revision;
+        recordFailure(engine, error);
+    }
+
+    function recordOllamaModels(engine, catalog, running, observation) {
+        if (!ownsOllamaObservation(engine, observation)) return;
+        engine.ollamaAppliedRevision = observation.revision;
+        engine.state = {...engine.state, ...engine.server.current, error: null};
+        const resident = new Map((running.models ?? []).map(function residentModel(model) {
+            return [model.model ?? model.name, model];
+        }));
+        const models = new Map((catalog.models ?? []).map(function catalogModel(model) {
+            const id = model.model ?? model.name ?? model.id;
+            return [id, {...model, id, loaded: resident.has(id)}];
+        }));
+        for (const [id, model] of resident) {
+            if (!models.has(id)) models.set(id, {...model, id, loaded: true});
+        }
+        engine.models = [...models.values()];
+    }
+
     async function refreshModels(engine, signal) {
         const revision = engine.revision;
         if (engine.id === 'ollama') {
-            const [catalog, running] = await Promise.all([
-                requestLocalJSON({url: engine.server.url, path: '/api/tags', signal}),
-                requestLocalJSON({url: engine.server.url, path: '/api/ps', signal})
-            ]);
-            const loaded = new Set((running.models ?? []).map(function loadedId(model) { return model.model ?? model.name; }));
-            engine.models = (catalog.models ?? []).map(function ollamaModel(model) {
-                return {...model, id: model.model ?? model.name, loaded: loaded.has(model.model ?? model.name)};
-            });
+            const observation = beginOllamaObservation(engine);
+            const observationSignal = signal ? AbortSignal.any([signal, observation.signal]) : observation.signal;
+            try {
+                const [catalog, running] = await Promise.all([
+                    requestLocalJSON({url: engine.server.url, path: '/api/tags', signal: observationSignal}),
+                    requestLocalJSON({url: engine.server.url, path: '/api/ps', signal: observationSignal})
+                ]);
+                observationSignal.throwIfAborted();
+                recordOllamaModels(engine, catalog, running, observation);
+            } catch (error) {
+                if (!observationSignal.aborted) recordOllamaFailure(engine, error, observation);
+                throw error;
+            }
         } else {
             const properties = await requestLocalJSON({url: engine.server.url, path: '/props', signal});
             engine.router = properties.role === 'router';
@@ -427,6 +464,34 @@ export function createLocalAIService(configuration, {appRoot, runtimes = [], sig
 
     async function ollamaRequest(operation, parameters = {}, request, method = 'POST') {
         const engine = await engineReady('ollama', request.signal);
+        const engineSignal = engine.signal;
+        const observation = operation === 'ps' ? beginOllamaObservation(engine) : null;
+        try {
+            const result = await ollamaResponse(engine, operation, parameters, request, method);
+            if (operation === 'ps') {
+                recordOllamaModels(engine, {models: engine.models}, result, observation);
+                publish();
+            }
+            return result;
+        } catch (error) {
+            if (operation === 'ps' && !request.signal.aborted) recordOllamaFailure(engine, error, observation);
+            throw error;
+        } finally {
+            // Every owned operation that can change residency/catalog leaves
+            // a real upstream observation, including cancellation or failure.
+            if (['chat', 'generate', 'embed', 'pull', 'create', 'copy', 'delete'].includes(operation)
+                && engine.signal === engineSignal && !engineSignal.aborted) {
+                try {
+                    await refreshModels(engine, engineSignal);
+                } catch {
+                    // The refresh publishes only its current owned failure;
+                    // retain the operation's original result or error.
+                }
+            }
+        }
+    }
+
+    async function ollamaResponse(engine, operation, parameters, request, method) {
         const signal = AbortSignal.any([request.signal, engine.signal]);
         const {streamId, ...payload} = parameters;
         if (payload.stream !== true) {
@@ -472,6 +537,8 @@ export function createLocalAIService(configuration, {appRoot, runtimes = [], sig
     function startEngine(engine) {
         engine.controller = new AbortController();
         engine.signal = AbortSignal.any([lifetimeSignal, engine.controller.signal]);
+        engine.ollamaRevision = 0;
+        engine.ollamaAppliedRevision = 0;
         const signal = engine.signal;
         engine.server = createLocalAIServer({
             id: engine.id, appRoot, runtime: runtimes.find(function runtimeRecord(record) { return record.id === engine.id; }),
@@ -487,7 +554,10 @@ export function createLocalAIService(configuration, {appRoot, runtimes = [], sig
             }
             return engine;
         });
-        engine.ready.catch(function startupFailed(error) { if (!signal.aborted) recordFailure(engine, error); });
+        engine.ready.catch(function startupFailed(error) {
+            // Ollama refreshes and the server already publish their own failures.
+            if (!signal.aborted && engine.id !== 'ollama') recordFailure(engine, error);
+        });
     }
 
     const service = {
@@ -557,7 +627,7 @@ export function createLocalAIService(configuration, {appRoot, runtimes = [], sig
                         await refreshModels(engine, request.signal);
                     } catch (error) {
                         request.signal.throwIfAborted();
-                        recordFailure(engine, error);
+                        if (engine.id !== 'ollama') recordFailure(engine, error);
                     }
                 }));
                 return snapshot();

package/src/dev-server.mjs

@@ -855,6 +855,7 @@ async function startOwnedDevServer({
     certPath,
     keyPath,
     localAI,
+    core = localAI,
     signal,
     sdkRuntimeSourceRoot
 }={},events,releaseSignal){
@@ -1261,7 +1262,7 @@ async function startOwnedDevServer({
                 response.end();
                 return;
             }
-            if (localAI && await localAI.handler(request, response)) return;
+            if (core && await core.handler(request, response)) return;
             if(request.method!=='GET'&&request.method!=='HEAD'){
                 deny(response,405,'Method not allowed.');
                 return;
@@ -1558,7 +1559,7 @@ async function startOwnedDevServer({
         }
         if(!closeInitiated){
             closeInitiated=true;
-            localAIClosing=Promise.resolve().then(function closeLocalAI(){return localAI?.close(error);});
+            localAIClosing=Promise.resolve().then(function closeCore(){return core?.close(error);});
             localAIClosing.catch(function observeLocalAICloseFailure(closeError){operationalError??=closeError;});
             try{
                 closeDevelopmentListeners(fileServer, tlsServer).then(

package/src/git-identity.mjs

@@ -0,0 +1,132 @@
+import path from 'node:path';
+import Is from 'strong-type';
+import {ArcaneError, throwIfAborted} from './errors.mjs';
+import {runProcess} from './process.mjs';
+import {createEventQueue} from './event-queue.mjs';
+
+const is = new Is(false);
+
+/** Read only non-secret identity configuration through ordinary Git scopes. */
+export async function readGitIdentity({directory, signal, onEvent, run = runProcess} = {}) {
+    const cwd = directory === undefined ? undefined : path.resolve(directory);
+    throwIfAborted(signal);
+    const events = createEventQueue(onEvent);
+
+    async function observeScope(scope) {
+        const args = ['config'];
+        if (scope !== 'effective') args.push(`--${scope}`);
+        args.push('--includes', '--null', '--get-regexp', '^(user[.](name|email)|github[.]user)$');
+        const chunks = [];
+        try {
+            const result = await run('git', args, {
+                cwd, signal, onEvent: events.send, allowNonzero: true,
+                outputEncoding: {stdout: null},
+                captureOutput: {stdout: false},
+                emitOutputEvents: {stdout: false},
+                // Git configuration may contain non-UTF-8 values. Keep its raw
+                // output until close rather than silently replacing characters.
+                onOutput: function observeOutput({stream, chunk}) {
+                    if (stream === 'stdout') chunks.push(chunk);
+                }
+            });
+            try { throwIfAborted(signal); }
+            catch (error) { error.details = result; throw error; }
+            const identity = {name: null, email: null, githubUser: null};
+            if (result.code === 1) return identity;
+            if (result.code !== 0) {
+                throw new ArcaneError('ARCANE_OPERATION_FAILED',
+                    `Git ${scope} identity lookup exited with code ${String(result.code)}.`, {details: result});
+            }
+            let output;
+            try { output = new TextDecoder('utf-8', {fatal: true, ignoreBOM: true}).decode(Buffer.concat(chunks)); }
+            catch (cause) {
+                throw new ArcaneError('ARCANE_GIT_IDENTITY_NOT_TEXT',
+                    `Git ${scope} identity configuration cannot be represented as UTF-8 text.`, {cause, details: result});
+            }
+            const fields = {'user.name': 'name', 'user.email': 'email', 'github.user': 'githubUser'};
+            // Git's NUL record framing preserves complete values, including newlines
+            // and empty strings. The last occurrence is the effective scalar value.
+            for (const record of output.split('\0')) {
+                if (record === '') continue;
+                const separator = record.indexOf('\n');
+                const key = separator === -1 ? record : record.slice(0, separator);
+                if (Object.hasOwn(fields, key)) {
+                    identity[fields[key]] = separator === -1 ? '' : record.slice(separator + 1);
+                }
+            }
+            return identity;
+        } catch (error) {
+            // Keep the process error and its native details intact. Raw stdout
+            // belongs to this reader because the process owner did not decode it.
+            const rawStdout = Buffer.concat(chunks);
+            let attached = false;
+            let attachmentError;
+            try {
+                if (error !== null && (is.object(error) || is.function(error)) && !('rawStdout' in error)) {
+                    Object.defineProperty(error, 'rawStdout', {
+                        value: rawStdout, writable: true, enumerable: true, configurable: true
+                    });
+                    attached = true;
+                }
+            } catch (cause) { attachmentError = cause; }
+            if (attached) throw error;
+            const failure = new ArcaneError(error?.code ?? 'ARCANE_OPERATION_FAILED',
+                error instanceof Error ? error.message : String(error),
+                {cause: error, details: error?.details, exitCode: error?.exitCode});
+            failure.rawStdout = rawStdout;
+            if (attachmentError) failure.attachmentError = attachmentError;
+            throw failure;
+        }
+    }
+
+    const scopes = cwd === undefined ? ['global'] : ['global', 'local', 'effective'];
+    const observations = await Promise.allSettled(scopes.map(observeScope));
+    const failures = observations.filter(function failed(result) {
+        return result.status === 'rejected';
+    }).map(function cause(result) { return result.reason; });
+    try { await events.drain(); }
+    catch (error) {
+        const visited = new Set();
+        function containsObserverFailure(failure) {
+            if (failure === error) return true;
+            if (failure === null || failure === undefined || visited.has(failure)) return false;
+            visited.add(failure);
+            return containsObserverFailure(failure.cause)
+                || (is.array(failure.errors) && failure.errors.some(containsObserverFailure));
+        }
+        const represented = failures.some(containsObserverFailure);
+        if (!represented) failures.push(error);
+    }
+    if (failures.length === 1) throw failures[0];
+    if (failures.length) throw new AggregateError(failures, 'Git identity observations failed.');
+    const result = {global: null, local: null, effective: null};
+    for (const [index, scope] of scopes.entries()) result[scope] = observations[index].value;
+    return result;
+}
+
+/** Capture one factory's selection without changing Git files or process.env. */
+export function createGitIdentityRunner(run, {name, email, username} = {}) {
+    const configuration = [];
+    const environment = {};
+    for (const [field, value] of Object.entries({name, email, username})) {
+        if (value === undefined) continue;
+        if (!is.string(value) || !value.isWellFormed() || value.includes('\0')) {
+            throw new TypeError(`gitIdentity.${field} must be text representable as a native process argument.`);
+        }
+        configuration.push('-c', `${field === 'username' ? 'credential.username' : `user.${field}`}=${value}`);
+        if (field === 'name') {
+            environment.GIT_AUTHOR_NAME = value;
+            environment.GIT_COMMITTER_NAME = value;
+        } else if (field === 'email') {
+            environment.GIT_AUTHOR_EMAIL = value;
+            environment.GIT_COMMITTER_EMAIL = value;
+        }
+    }
+    if (!configuration.length) return run;
+    const selectsAuthor = name !== undefined || email !== undefined;
+    return function runSelectedGit(command, args, options = {}) {
+        return run(command, [...configuration, ...args], selectsAuthor
+            ? {...options, env: {...options.env, ...environment}}
+            : options);
+    };
+}

package/src/git-text-snapshot.mjs

@@ -4,6 +4,7 @@ import path from 'node:path';
 import {runProcess} from './process.mjs';
 import {ArcaneError, ERROR_CODES, throwIfAborted} from './errors.mjs';
 import {createEventQueue} from './event-queue.mjs';
+import {createGitIdentityRunner} from './git-identity.mjs';
 
 const is = new Is(false);
 const snapshotRef = 'refs/arcane/text-snapshot';
@@ -13,11 +14,12 @@ const snapshotRef = 'refs/arcane/text-snapshot';
  * One application service owns each dedicated cache directory. Construction
  * performs no I/O; refresh coalesces callers and close drains accepted work.
  */
-export function createGitTextSnapshot({cacheDirectory, remote, ref, selectPath, onEvent, run = runProcess} = {}) {
+export function createGitTextSnapshot({cacheDirectory, remote, ref, selectPath, gitIdentity, onEvent, run = runProcess} = {}) {
     for (const [name, value] of Object.entries({cacheDirectory, remote, ref})) {
         if (!is.string(value) || value === '') throw new TypeError(`${name} must be a nonempty string.`);
     }
     if (!is.function(selectPath)) throw new TypeError('selectPath must be a function.');
+    const execute = createGitIdentityRunner(run, gitIdentity);
     const directory = path.resolve(cacheDirectory);
     let prepared = false;
     let retained = null;
@@ -34,7 +36,7 @@ export function createGitTextSnapshot({cacheDirectory, remote, ref, selectPath,
             };
         }
         try {
-            return await run('git', ['--git-dir', directory, ...args], execution);
+            return await execute('git', ['--git-dir', directory, ...args], execution);
         } catch (error) {
             // runProcess first drains its child and preserves complete transport
             // failures. Keep the Git parser's public code with that full cause.
@@ -50,7 +52,7 @@ export function createGitTextSnapshot({cacheDirectory, remote, ref, selectPath,
         if (prepared) return;
         await mkdir(directory, {recursive: true});
         if ((await readdir(directory)).length === 0) {
-            await run('git', ['init', '--bare', directory], {onEvent: events.send});
+            await execute('git', ['init', '--bare', directory], {onEvent: events.send});
         }
         const result = await git(['rev-parse', '--is-bare-repository'], {onEvent: events.send});
         // This is the selected cache's functional role: never reinterpret an

package/src/index.mjs

@@ -146,6 +146,7 @@ export {
 } from './workspace.mjs';
 export {materializeInstalledSdkRuntime} from './installed-sdk-runtime.mjs';
 export {startDevServer} from './dev-server.mjs';
+export {createDevelopmentCore} from './core/development.mjs';
 export {startSourceExampleServer} from './source-server.mjs';
 export {acceptWebSocket} from './websocket.mjs';
 export {WS} from '../browser-runtime/websocket-client.mjs';