@owlmeans/viable-sdk 0.1.18-rc.1

package/build/executor/index.js

@@ -0,0 +1,173 @@
+import p from 'node:path';
+import { commandDeadline, SlotCommandType, SlotFileCommand, SlotGitCommand, SlotShellCommand } from '@owlmeans/viable-common';
+import { createLocalFileHelper } from './files.js';
+import { dispatchGitCommand } from './git.js';
+import { forgetIntegrity, verifyTarget } from './integrity.js';
+import { targetPaths } from './layout.js';
+import { createLocalShellHelper } from './shell.js';
+import { withDeadline } from './spawn.js';
+export * from './errors.js';
+export * from './layout.js';
+export * from './integrity.js';
+export * from './files.js';
+export * from './env.js';
+export * from './health.js';
+export * from './boot-check.js';
+export * from './shell.js';
+export * from './git.js';
+export { BUILD_TIMEOUT, MAX_OUTPUT_BUFFER, failureOutput, isAlive, killGroupAndWait, probeListening, runCommand, runScript, signalGroup, waitForPortFree, withDeadline } from './spawn.js';
+/**
+ * Answer the platform's slot commands against a directory on this machine.
+ *
+ * The dispatcher is the publisher's, switch for switch, and that is the point: the platform's
+ * remote helpers parse the ANSWERS, and they have no way to know whether a pod or a laptop
+ * produced one. So an ordinary failure is never thrown here — it comes back in the same shape the
+ * publisher would have sent, error text and all — and only an unknown command, which is a
+ * protocol fault rather than a project fault, escapes as an exception.
+ *
+ * Everything is resolved per call rather than closed over: a re-initialization replaces the tree
+ * under a running connector, and a remembered layout would then resolve every path into a
+ * directory that no longer exists.
+ */
+export const makeLocalSlotExecutor = (dir, opts = {}) => {
+    const root = p.resolve(dir);
+    const log = opts.log ?? (() => undefined);
+    const execute = async ({ type, command, args }) => {
+        const fileHelper = createLocalFileHelper(root);
+        const shellHelper = createLocalShellHelper(fileHelper, args?.subproject);
+        log(`Executing command [${type}]: ${command}`);
+        return await withDeadline(`${type}:${command}`, commandDeadline(type, command), async () => {
+            switch (type) {
+                case SlotCommandType.Files:
+                    switch (command) {
+                        case SlotFileCommand.EmptyProject:
+                            await fileHelper.emptyProject(args?.ignore);
+                            forgetIntegrity();
+                            return {};
+                        case SlotFileCommand.DeleteProject:
+                            await fileHelper.deleteProject();
+                            forgetIntegrity();
+                            return {};
+                        case SlotFileCommand.InitializeProject:
+                            await fileHelper.initializeProject();
+                            forgetIntegrity();
+                            return {};
+                        case SlotFileCommand.GetSourceList:
+                            return await fileHelper.getSourceList(args?.pattern, args?.options);
+                        case SlotFileCommand.GetStructuredList:
+                            return await fileHelper.getStructuredList(args?.patterns);
+                        case SlotFileCommand.ReadFile:
+                            return { result: await fileHelper.readFile(args?.filePath, args?.noThrow) };
+                        case SlotFileCommand.ReadSource:
+                            return await fileHelper.readSource(args?.filePath);
+                        case SlotFileCommand.ReadPossibleSource:
+                            return await fileHelper.readPossibleSource(args?.filePath);
+                        case SlotFileCommand.ReadSources:
+                            return await fileHelper.readSources(args?.files);
+                        case SlotFileCommand.WriteFile:
+                            await fileHelper.writeFile(args?.filePath, args?.content);
+                            forgetIntegrity();
+                            return {};
+                        case SlotFileCommand.WriteSource:
+                            await fileHelper.writeSource(args?.file);
+                            forgetIntegrity();
+                            return {};
+                        case SlotFileCommand.DeleteFile:
+                            await fileHelper.deleteFile(args?.filePath, args?.noThrow);
+                            forgetIntegrity();
+                            return {};
+                        case SlotFileCommand.StatTree:
+                            return await fileHelper.statTree(args?.dir, args?.limit);
+                        case SlotFileCommand.ReadHead:
+                            // `{ result }`, exactly like ReadFile: the platform's remote helper reads one field
+                            // for "the text of a file", and a second shape for the same thing would be a second
+                            // parser to keep in step.
+                            return { result: await fileHelper.readHead(args?.path, args?.bytes) };
+                        case SlotFileCommand.Relocate: {
+                            const result = await fileHelper.relocate(args?.dir, args?.keep);
+                            forgetIntegrity();
+                            return result;
+                        }
+                        case SlotFileCommand.RemoveTree:
+                            await fileHelper.removeTree(args?.dir);
+                            forgetIntegrity();
+                            return {};
+                        case SlotFileCommand.FindFilesWithEnvVars:
+                            return await fileHelper.findFilesWithEnvVars(args?.frontend);
+                        case SlotFileCommand.GetRootPath:
+                            return { result: fileHelper.getRootPath(args?.subproject) };
+                        default:
+                            throw new Error(`Unknown command: ${command}`);
+                    }
+                case SlotCommandType.Shell:
+                    switch (command) {
+                        case SlotShellCommand.Bun:
+                            return { result: await shellHelper.bun(args?.args, args?.options) };
+                        case SlotShellCommand.Reinstall:
+                            // Lockfile cleared, then installed. A plain `bun install` here would reinstall
+                            // exactly the versions already pinned on disk, which is the whole problem.
+                            return { result: await shellHelper.reinstall() };
+                        case SlotShellCommand.BuildCommon:
+                            return { result: await shellHelper.buildCommon() };
+                        case SlotShellCommand.Validate:
+                            return { result: await shellHelper.validate(args?.subproject) };
+                        case SlotShellCommand.ValidateWithRenderer:
+                            return { result: await shellHelper.validateWithRenderer() };
+                        case SlotShellCommand.Build: {
+                            const result = await shellHelper.build();
+                            // The tree changed, so the next spawn re-reads it rather than trusting the verdict
+                            // this build was admitted on.
+                            forgetIntegrity();
+                            return { result };
+                        }
+                        case SlotShellCommand.ValidateBackend:
+                            return { result: await shellHelper.validateBackend() };
+                        case SlotShellCommand.DbSync:
+                            return { result: await shellHelper.dbSync() };
+                        case SlotShellCommand.BootCheck: {
+                            const report = await shellHelper.bootCheck({
+                                skipBuild: args?.skipBuild === true, wait: args?.wait === true,
+                            });
+                            // The shell contract is "error text or null", so a healthy boot reports null exactly
+                            // like a clean build; `started` is what tells a caller to begin polling.
+                            return report == null
+                                ? { result: null, started: true }
+                                : { result: report.ok ? null : report.error, phase: report.phase };
+                        }
+                        case SlotShellCommand.BootCheckStatus: {
+                            const status = await shellHelper.bootCheckStatus();
+                            return {
+                                running: status.running,
+                                startedAt: status.startedAt,
+                                done: !status.running && status.report != null,
+                                result: status.report == null || status.report.ok ? null : status.report.error,
+                                phase: status.report?.phase ?? null,
+                            };
+                        }
+                        case SlotShellCommand.Integrity:
+                            return await shellHelper.integrity();
+                        default:
+                            throw new Error(`Unknown command: ${command}`);
+                    }
+                case SlotCommandType.Git: {
+                    const result = await dispatchGitCommand(root, command, args);
+                    if (command === SlotGitCommand.Discard || command === SlotGitCommand.RevertTo) {
+                        // Both rewrite the working tree wholesale, so the memoized verdict describes a tree
+                        // that no longer exists.
+                        forgetIntegrity();
+                    }
+                    return result;
+                }
+                default:
+                    throw new Error(`Unknown command type: ${String(type)}`);
+            }
+        });
+    };
+    return {
+        execute,
+        layout: () => targetPaths(root),
+        integrity: async () => await verifyTarget(root),
+        dir: root,
+    };
+};
+//# sourceMappingURL=index.js.map

package/build/executor/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/executor/index.ts"],"names":[],"mappings":"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"}

package/build/executor/integrity.d.ts

@@ -0,0 +1,17 @@
+import type { TargetFileMap, TargetIntegrityReport } from '@owlmeans/viable-common';
+/** Read the manifest's files from a tree; a path that cannot be read comes back as `null`. */
+export declare const readTargetFiles: (dir: string) => Promise<TargetFileMap>;
+/** Verify the tree, reusing a verdict from the last couple of seconds. */
+export declare const verifyTarget: (dir: string) => Promise<TargetIntegrityReport>;
+/** Drop the memoized verdict — called wherever the connector itself changes the tree. */
+export declare const forgetIntegrity: () => void;
+/**
+ * The refusal text a build or shell command answers with, or `null` when the tree is fine.
+ *
+ * Text and not an exception, because "error text or null" is the contract every shell command
+ * already answers with — a caller needs no new branch to notice a refusal, and the diagnostics
+ * reach the person whose tree they belong to through the channel that already carries a failed
+ * build.
+ */
+export declare const integrityRefusal: (dir: string, prefix?: string) => Promise<string | null>;
+//# sourceMappingURL=integrity.d.ts.map

package/build/executor/integrity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integrity.d.ts","sourceRoot":"","sources":["../../src/executor/integrity.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAA;AA6BnF,8FAA8F;AAC9F,eAAO,MAAM,eAAe,QAAe,MAAM,KAAG,OAAO,CAAC,aAAa,CAKxE,CAAA;AAED,0EAA0E;AAC1E,eAAO,MAAM,YAAY,QAAe,MAAM,KAAG,OAAO,CAAC,qBAAqB,CAS7E,CAAA;AAED,yFAAyF;AACzF,eAAO,MAAM,eAAe,QAAO,IAA0B,CAAA;AAE7D;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,QAAe,MAAM,sBAAuB,OAAO,CAAC,MAAM,GAAG,IAAI,CAO7F,CAAA"}

package/build/executor/integrity.js

@@ -0,0 +1,59 @@
+import fs from 'fs-extra';
+import p from 'node:path';
+import { formatIntegrityReport, TARGET_INTEGRITY_FILES, verifyTargetShape } from '@owlmeans/viable-common';
+/**
+ * Whether this directory still holds the generated application.
+ *
+ * The publisher is authoritative for a slot because it is the only process holding the volume at
+ * the moment of a spawn; on a developer's machine the connector is in exactly that position. What
+ * gets EXECUTED comes out of the tree — `bun run build` reads `scripts.build` from a
+ * `package.json` on disk, `bun install` runs whatever lifecycle hooks it declares, and
+ * `bun dist/index.js` runs whatever the build emitted — and here it runs as the developer, with
+ * their environment and their credentials in scope. So the check sits in front of every spawn,
+ * not in front of the callers somebody remembered to guard.
+ *
+ * Deliberately structural and model-free: thirty-odd file reads and a list of exact strings. The
+ * question is not whether a program is good; it is whether this tree is the one we generated.
+ */
+/**
+ * How long a clean verdict is reused.
+ *
+ * Short on purpose. The check runs before every spawn — the build, the backend start, the boot
+ * check, every `bun` invocation — and several of those run back to back inside one operation. A
+ * longer window would let a write land between the check and the spawn it was meant to guard, so
+ * this is a de-duplication of one burst, not a cache.
+ */
+const VERDICT_TTL_MS = 2_000;
+let _cached = null;
+/** Read the manifest's files from a tree; a path that cannot be read comes back as `null`. */
+export const readTargetFiles = async (dir) => {
+    const entries = await Promise.all(TARGET_INTEGRITY_FILES.map(async (file) => [file, await fs.readFile(p.join(dir, file), 'utf-8').catch(() => null)]));
+    return Object.fromEntries(entries);
+};
+/** Verify the tree, reusing a verdict from the last couple of seconds. */
+export const verifyTarget = async (dir) => {
+    if (_cached != null && _cached.root === dir && Date.now() - _cached.at < VERDICT_TTL_MS) {
+        return _cached.report;
+    }
+    const report = verifyTargetShape(await readTargetFiles(dir));
+    _cached = { at: Date.now(), root: dir, report };
+    return report;
+};
+/** Drop the memoized verdict — called wherever the connector itself changes the tree. */
+export const forgetIntegrity = () => { _cached = null; };
+/**
+ * The refusal text a build or shell command answers with, or `null` when the tree is fine.
+ *
+ * Text and not an exception, because "error text or null" is the contract every shell command
+ * already answers with — a caller needs no new branch to notice a refusal, and the diagnostics
+ * reach the person whose tree they belong to through the channel that already carries a failed
+ * build.
+ */
+export const integrityRefusal = async (dir, prefix = 'Refused') => {
+    const report = await verifyTarget(dir);
+    return report.ok
+        ? null
+        : `${prefix}: the project in this directory is not a Viable application\n`
+            + formatIntegrityReport(report);
+};
+//# sourceMappingURL=integrity.js.map

package/build/executor/integrity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"integrity.js","sourceRoot":"","sources":["../../src/executor/integrity.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,UAAU,CAAA;AACzB,OAAO,CAAC,MAAM,WAAW,CAAA;AAEzB,OAAO,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAA;AAG1G;;;;;;;;;;;;;GAaG;AAEH;;;;;;;GAOG;AACH,MAAM,cAAc,GAAG,KAAK,CAAA;AAE5B,IAAI,OAAO,GAAuE,IAAI,CAAA;AAEtF,8FAA8F;AAC9F,MAAM,CAAC,MAAM,eAAe,GAAG,KAAK,EAAE,GAAW,EAA0B,EAAE;IAC3E,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,sBAAsB,CAAC,GAAG,CAAC,KAAK,EAAC,IAAI,EAAC,EAAE,CACxE,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,EAAE,OAAO,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAU,CAAC,CAAC,CAAA;IAEpF,OAAO,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,CAAA;AACpC,CAAC,CAAA;AAED,0EAA0E;AAC1E,MAAM,CAAC,MAAM,YAAY,GAAG,KAAK,EAAE,GAAW,EAAkC,EAAE;IAChF,IAAI,OAAO,IAAI,IAAI,IAAI,OAAO,CAAC,IAAI,KAAK,GAAG,IAAI,IAAI,CAAC,GAAG,EAAE,GAAG,OAAO,CAAC,EAAE,GAAG,cAAc,EAAE,CAAC;QACxF,OAAO,OAAO,CAAC,MAAM,CAAA;IACvB,CAAC;IAED,MAAM,MAAM,GAAG,iBAAiB,CAAC,MAAM,eAAe,CAAC,GAAG,CAAC,CAAC,CAAA;IAC5D,OAAO,GAAG,EAAE,EAAE,EAAE,IAAI,CAAC,GAAG,EAAE,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,CAAA;IAE/C,OAAO,MAAM,CAAA;AACf,CAAC,CAAA;AAED,yFAAyF;AACzF,MAAM,CAAC,MAAM,eAAe,GAAG,GAAS,EAAE,GAAG,OAAO,GAAG,IAAI,CAAA,CAAC,CAAC,CAAA;AAE7D;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,KAAK,EAAE,GAAW,EAAE,MAAM,GAAG,SAAS,EAA0B,EAAE;IAChG,MAAM,MAAM,GAAG,MAAM,YAAY,CAAC,GAAG,CAAC,CAAA;IAEtC,OAAO,MAAM,CAAC,EAAE;QACd,CAAC,CAAC,IAAI;QACN,CAAC,CAAC,GAAG,MAAM,+DAA+D;cACtE,qBAAqB,CAAC,MAAM,CAAC,CAAA;AACrC,CAAC,CAAA"}

package/build/executor/layout.d.ts

@@ -0,0 +1,61 @@
+import { TargetLayout } from '@owlmeans/viable-common';
+import type { SubProject, TargetPaths } from '@owlmeans/viable-common';
+/**
+ * Read the directory and say which layout its target project has.
+ *
+ * An empty or half-installed tree answers `V1`, matching the publisher: a project that has not
+ * been initialized yet resolves the paths it always did, and the answer flips by itself the
+ * moment a v2 tree lands.
+ *
+ * Deliberately un-memoized. It is two `stat`s against a page cache the process touches
+ * constantly, while a re-initialization replaces the tree wholesale under a running connector —
+ * a remembered verdict would then resolve every path into a directory that no longer exists,
+ * with a `posix_spawn` ENOENT as the only symptom.
+ */
+export declare const detectLayout: (dir: string) => TargetLayout;
+/** Where every role lives in this directory's target project. */
+export declare const targetPaths: (dir: string) => TargetPaths;
+/** Absolute path of the package that runs as the target's HTTP server. */
+export declare const apiPath: (dir: string) => string;
+/** Absolute path of the package whose `dist/` is served to a browser. */
+export declare const webPath: (dir: string) => string;
+/**
+ * Absolute path of the package that runs as the target's queue worker, or `null` when this
+ * layout has no such package at all.
+ *
+ * A path, not a verdict: it answers where a worker WOULD live and says nothing about whether one
+ * is there. {@link hasWorker} is the disk read.
+ */
+export declare const workerPath: (dir: string) => string | null;
+/**
+ * Whether this target project has a queue worker.
+ *
+ * Read from disk rather than from a record, for the same reason the layout is: what runs is
+ * whatever was generated, a re-initialization can replace it under a running connector, and a
+ * remembered answer would supervise a package that is no longer there — or miss one that has
+ * just arrived. The manifest and not the directory, because a half-finished install leaves the
+ * directory behind.
+ */
+export declare const hasWorker: (dir: string) => boolean;
+/**
+ * Resolve a wire-level subproject role to the directory it names in this tree.
+ *
+ * `SubProject` is a ROLE and stays one: the vocabulary on the wire is not rewritten, it is
+ * mapped, per layout. An unknown value — a role from a platform newer than this connector —
+ * falls back to the role's own name, which fails visibly rather than resolving to some other
+ * package's directory.
+ */
+export declare const subprojectDir: (dir: string, role: SubProject) => string;
+/**
+ * Absolute paths of the packages that must be built before anything that imports them, in
+ * dependency order — see `TargetPaths.libraries`.
+ *
+ * Every bundled package keeps its dependencies external, so `<slug>-common` and (on v2)
+ * `<slug>-backend` are resolved from `node_modules` at RUN time and followed to their `main`.
+ * Nothing else builds them: the api, web and worker builds each run inside their own directory.
+ * Missing directories are dropped — a build spawned into one that does not exist reports
+ * `ENOENT … posix_spawn '/bin/sh'`, which blames the toolchain for a tree that is simply
+ * incomplete.
+ */
+export declare const libraryPaths: (dir: string) => string[];
+//# sourceMappingURL=layout.d.ts.map

package/build/executor/layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout.d.ts","sourceRoot":"","sources":["../../src/executor/layout.ts"],"names":[],"mappings":"AAGA,OAAO,EAA4C,YAAY,EAAE,MAAM,yBAAyB,CAAA;AAChG,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AAkBtE;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,YAAY,QAAS,MAAM,KAAG,YAQ1C,CAAA;AAED,iEAAiE;AACjE,eAAO,MAAM,WAAW,QAAS,MAAM,KAAG,WAAyC,CAAA;AAEnF,0EAA0E;AAC1E,eAAO,MAAM,OAAO,QAAS,MAAM,KAAG,MAIrC,CAAA;AAED,yEAAyE;AACzE,eAAO,MAAM,OAAO,QAAS,MAAM,KAAG,MAIrC,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,QAAS,MAAM,KAAG,MAAM,GAAG,IAIjD,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,SAAS,QAAS,MAAM,KAAG,OAIvC,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa,QAAS,MAAM,QAAQ,UAAU,KAAG,MACpB,CAAA;AAE1C;;;;;;;;;;GAUG;AACH,eAAO,MAAM,YAAY,QAAS,MAAM,KAAG,MAAM,EAMhD,CAAA"}

package/build/executor/layout.js

@@ -0,0 +1,98 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { LAYOUT_MARKERS, LAYOUTS, subprojectDirOf, TargetLayout } from '@owlmeans/viable-common';
+/**
+ * Where a target project's packages live, in THIS directory.
+ *
+ * The tables — which role is which directory, what a full build runs, which packages must be
+ * built before anything imports them — belong to `@owlmeans/viable-common`, because the publisher
+ * answers the same questions over a pod volume. What lives here is the pair of filesystem probes
+ * that pick a layout and turn a package name into an absolute path.
+ *
+ * Platform vs target: this describes a TARGET project's directory shape. Nothing about the SDK's
+ * own repository is v1 or v2.
+ */
+const MARKERS = LAYOUT_MARKERS.map(([layout, marker]) => [layout, path.join(...marker.split('/'))]);
+/**
+ * Read the directory and say which layout its target project has.
+ *
+ * An empty or half-installed tree answers `V1`, matching the publisher: a project that has not
+ * been initialized yet resolves the paths it always did, and the answer flips by itself the
+ * moment a v2 tree lands.
+ *
+ * Deliberately un-memoized. It is two `stat`s against a page cache the process touches
+ * constantly, while a re-initialization replaces the tree wholesale under a running connector —
+ * a remembered verdict would then resolve every path into a directory that no longer exists,
+ * with a `posix_spawn` ENOENT as the only symptom.
+ */
+export const detectLayout = (dir) => {
+    for (const [layout, marker] of MARKERS) {
+        if (fs.existsSync(path.join(dir, marker))) {
+            return layout;
+        }
+    }
+    return TargetLayout.V1;
+};
+/** Where every role lives in this directory's target project. */
+export const targetPaths = (dir) => LAYOUTS[detectLayout(dir)];
+/** Absolute path of the package that runs as the target's HTTP server. */
+export const apiPath = (dir) => {
+    const paths = targetPaths(dir);
+    return path.resolve(dir, paths.dir, paths.api);
+};
+/** Absolute path of the package whose `dist/` is served to a browser. */
+export const webPath = (dir) => {
+    const paths = targetPaths(dir);
+    return path.resolve(dir, paths.dir, paths.web);
+};
+/**
+ * Absolute path of the package that runs as the target's queue worker, or `null` when this
+ * layout has no such package at all.
+ *
+ * A path, not a verdict: it answers where a worker WOULD live and says nothing about whether one
+ * is there. {@link hasWorker} is the disk read.
+ */
+export const workerPath = (dir) => {
+    const paths = targetPaths(dir);
+    return paths.worker == null ? null : path.resolve(dir, paths.dir, paths.worker);
+};
+/**
+ * Whether this target project has a queue worker.
+ *
+ * Read from disk rather than from a record, for the same reason the layout is: what runs is
+ * whatever was generated, a re-initialization can replace it under a running connector, and a
+ * remembered answer would supervise a package that is no longer there — or miss one that has
+ * just arrived. The manifest and not the directory, because a half-finished install leaves the
+ * directory behind.
+ */
+export const hasWorker = (dir) => {
+    const worker = workerPath(dir);
+    return worker != null && fs.existsSync(path.join(worker, 'package.json'));
+};
+/**
+ * Resolve a wire-level subproject role to the directory it names in this tree.
+ *
+ * `SubProject` is a ROLE and stays one: the vocabulary on the wire is not rewritten, it is
+ * mapped, per layout. An unknown value — a role from a platform newer than this connector —
+ * falls back to the role's own name, which fails visibly rather than resolving to some other
+ * package's directory.
+ */
+export const subprojectDir = (dir, role) => subprojectDirOf(detectLayout(dir), role);
+/**
+ * Absolute paths of the packages that must be built before anything that imports them, in
+ * dependency order — see `TargetPaths.libraries`.
+ *
+ * Every bundled package keeps its dependencies external, so `<slug>-common` and (on v2)
+ * `<slug>-backend` are resolved from `node_modules` at RUN time and followed to their `main`.
+ * Nothing else builds them: the api, web and worker builds each run inside their own directory.
+ * Missing directories are dropped — a build spawned into one that does not exist reports
+ * `ENOENT … posix_spawn '/bin/sh'`, which blames the toolchain for a tree that is simply
+ * incomplete.
+ */
+export const libraryPaths = (dir) => {
+    const paths = targetPaths(dir);
+    return paths.libraries
+        .map(pkg => path.resolve(dir, paths.dir, pkg))
+        .filter(library => fs.existsSync(library));
+};
+//# sourceMappingURL=layout.js.map

package/build/executor/layout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout.js","sourceRoot":"","sources":["../../src/executor/layout.ts"],"names":[],"mappings":"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"}

package/build/executor/shell.d.ts

@@ -0,0 +1,89 @@
+import { SubProject } from '@owlmeans/viable-common';
+import type { SlotShellResult } from '@owlmeans/viable-common';
+import type { BootCheckReport, BootCheckStatus } from './boot-check.js';
+import type { LocalFileHelper } from './files.js';
+/**
+ * The shell half of the local executor — every `SlotShellCommand`, against a directory.
+ *
+ * The contract every method answers with is the publisher's: **error text, or `null` for
+ * success**. It is not a transcript — a command that fails returns the diagnostics a fixer or a
+ * person can act on, and a command that succeeds returns nothing at all.
+ */
+/**
+ * The one reason a script refuses that is NOT a verdict about the code.
+ *
+ * A build with nothing to build on is an ordinary no-op that the next trigger repeats correctly —
+ * it happens between attaching to a fresh clone and the first install. It must not be reported as
+ * a failed build, or the connector announces broken code during a window in which nothing was
+ * even attempted.
+ */
+export declare const NOT_INSTALLED_REASON = "cannot run: the target's dependencies are not installed yet";
+/** Whether a refusal describes the code, or merely a window in which nothing ran. */
+export declare const isBuildVerdict: (reason: string | null) => boolean;
+export declare const createLocalShellHelper: (fileHelper: LocalFileHelper, subproject?: SubProject) => {
+    bun: (args?: string, options?: {
+        subproject?: SubProject;
+    }) => Promise<string | null>;
+    /**
+     * Throw the lockfile away and install again.
+     *
+     * The truncate is the point. `bun install` on its own reproduces whatever the lockfile says,
+     * and a target's lockfile was written the day the project was created — so a framework
+     * package republished afterwards is invisible to it no matter how often the target is
+     * rebuilt. Emptied rather than deleted, matching initialization: bun reads an empty file as
+     * "no lockfile", so a failed install leaves a state the next attempt resolves cleanly instead
+     * of one where a stale lock has come back.
+     */
+    reinstall: () => Promise<string | null>;
+    buildCommon: () => Promise<string | null>;
+    validate: (subprojectOverride?: SubProject) => Promise<string | null>;
+    /** The buildability check for the UI: the browser bundle really built, or the reason it did not. */
+    validateWithRenderer: () => Promise<string | null>;
+    /**
+     * Rebuild the whole target, in dependency order.
+     *
+     * The libraries first, because everything else resolves them from `node_modules` at RUN time
+     * and follows each to its `build/index.js` — a bundle built before them starts with
+     * `Cannot find package '<slug>-backend'`, a message about a dependency for a build that never
+     * happened. The remaining three are independent, so all of them run and their problems are
+     * reported together rather than one round trip at a time.
+     */
+    build: () => Promise<string | null>;
+    /** Build the api only — the type check the frontend renderer build cannot give it. */
+    validateBackend: () => Promise<string | null>;
+    /**
+     * Reconcile the target's database with its code.
+     *
+     * The target owns its own structure: every `@owlmeans/postgres` resource creates and updates
+     * its table while the context initializes. So a sync is not a command run against the source
+     * tree — it is *check that the database is there, then restart the backend* — and there is
+     * nothing to generate and no migration file to apply.
+     *
+     * A local target's database is the developer's. The platform provisions none, so an absent
+     * URL is reported by NAME rather than repaired: it is a line the person has to write, and
+     * "database unavailable" would send them looking at a server instead.
+     */
+    dbSync: () => Promise<string | null>;
+    /**
+     * Answering, not enforcing.
+     *
+     * The connector refuses on its own before every spawn regardless; this exists so a caller can
+     * ask BEFORE letting a merge reach a build, and report the violations to the person whose
+     * repository they belong to.
+     */
+    integrity: () => Promise<SlotShellResult>;
+    /**
+     * Start a real boot in isolation and return at once.
+     *
+     * A second start joins the running check rather than spawning another instance onto the port.
+     * The verdict is read with {@link bootCheckStatus}; `wait` is the legacy blocking path for a
+     * caller that predates the job.
+     */
+    bootCheck: (options?: {
+        skipBuild?: boolean;
+        wait?: boolean;
+    }) => Promise<BootCheckReport | null>;
+    bootCheckStatus: () => Promise<BootCheckStatus>;
+};
+export type LocalShellHelper = ReturnType<typeof createLocalShellHelper>;
+//# sourceMappingURL=shell.d.ts.map

package/build/executor/shell.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shell.d.ts","sourceRoot":"","sources":["../../src/executor/shell.ts"],"names":[],"mappings":"AAIA,OAAO,EACkB,UAAU,EAElC,MAAM,yBAAyB,CAAA;AAChC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAA;AAK9D,OAAO,KAAK,EAAgB,eAAe,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAErF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAKjD;;;;;;GAMG;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,gEAAgE,CAAA;AAEjG,qFAAqF;AACrF,eAAO,MAAM,cAAc,WAAY,MAAM,GAAG,IAAI,KAAG,OACG,CAAA;AAqB1D,eAAO,MAAM,sBAAsB,eAAgB,eAAe,eAAe,UAAU;iBA+EpE,MAAM,YAAY;QAAE,UAAU,CAAC,EAAE,UAAU,CAAA;KAAE,KAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IASzF;;;;;;;;;OASG;qBACkB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;uBAapB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;oCAOP,UAAU,KAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAgBzE,oGAAoG;gCACpE,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAGtD;;;;;;;;OAQG;iBACc,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAevC,sFAAsF;2BAC3D,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAGjD;;;;;;;;;;;OAWG;kBACe,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAoBxC;;;;;;OAMG;qBACkB,OAAO,CAAC,eAAe,CAAC;IAU7C;;;;;;OAMG;0BAEQ;QAAE,SAAS,CAAC,EAAE,OAAO,CAAC;QAAC,IAAI,CAAC,EAAE,OAAO,CAAA;KAAE,KAC/C,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC;2BA0CP,OAAO,CAAC,eAAe,CAAC;CAItD,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG,UAAU,CAAC,OAAO,sBAAsB,CAAC,CAAA"}