@monosmith/plugin-sdk 0.0.0-stage → 0.2.0

package/host/start-plugin.use-case.js

@@ -0,0 +1,57 @@
+import { spawn } from 'node:child_process';
+import { PluginClient } from './plugin-client.client.js';
+/**
+ * Launches a plugin process and performs the handshake, as smith does: the
+ * plugin's argv, `SMITH_PLUGIN=1` in its environment, its standard input and
+ * output as the protocol's channel, its standard error forwarded to this
+ * process's. Close the client when done: it asks the plugin to shut down and
+ * kills it if it does not go.
+ */
+export async function startPlugin(options) {
+    const [program, ...args] = options.command;
+    if (program === undefined)
+        throw new Error('plugin command is empty');
+    const env = { ...(options.env ?? process.env) };
+    env.SMITH_PLUGIN ??= '1';
+    const child = spawn(program, args, { env, cwd: options.cwd, stdio: ['pipe', 'pipe', options.stderr ?? 'inherit'], windowsHide: true });
+    const exited = new Promise((resolve) => {
+        child.once('close', (code, signal) => { resolve({ code, signal }); });
+    });
+    // A program that cannot be started never answers: its streams just end.
+    let spawnFailure;
+    child.once('error', (cause) => { spawnFailure = cause; });
+    // Writing to a plugin that has gone raises EPIPE on stdin; the call that wrote sees the error.
+    child.stdin.on('error', () => { });
+    const connection = {
+        input: child.stdout,
+        output: { write: (chunk, callback) => child.stdin.write(chunk, callback), end: () => child.stdin.end() },
+        kill: () => { child.kill(); },
+        finish: (graceMs) => waitForExit(child, exited, graceMs),
+    };
+    try {
+        return await PluginClient.open(connection, options);
+    }
+    catch (error) {
+        child.kill();
+        await exited;
+        if (spawnFailure === undefined)
+            throw error;
+        throw new Error(`starting plugin ${JSON.stringify(options.command)}: ${spawnFailure.message}`, { cause: error });
+    }
+}
+async function waitForExit(child, exited, graceMs) {
+    let timer;
+    const timeout = new Promise((resolve) => {
+        timer = setTimeout(() => {
+            resolve('timeout');
+        }, graceMs);
+    });
+    const outcome = await Promise.race([exited, timeout]);
+    clearTimeout(timer);
+    if (outcome === 'timeout') {
+        child.kill();
+        await exited;
+        return 'plugin did not exit after shutdown; killed';
+    }
+    return outcome.code === 0 ? null : `plugin exited with ${outcome.signal ?? `status ${outcome.code}`}`;
+}

package/index.d.ts

@@ -0,0 +1,16 @@
+export * from './protocol/index.ts';
+export * from './serve/index.ts';
+export * from './concurrency/index.ts';
+export * from './tasks/index.ts';
+export * from './scaffold/index.ts';
+export * from './ci/index.ts';
+export * from './build-dir/index.ts';
+export * from './plugin-roles/index.ts';
+export * from './plugin-refs/index.ts';
+export * from './projects/index.ts';
+export * from './templating/index.ts';
+export * from './jsondoc/index.ts';
+export * from './host/index.ts';
+export * from './conformance/index.ts';
+export { decodeParams, decodeResult, encodeParams, encodeResult, EncodeError, MessageParseError, ParamsError } from './codec/index.ts';
+export { FrameReader, FramingError, frameMessage } from './framing/index.ts';

package/index.js

@@ -0,0 +1,21 @@
+// The public API of @monosmith/plugin-sdk.
+// The protocol: every message as a type, generated from the JSON Schema.
+export * from './protocol/index.js';
+// Writing a plugin.
+export * from './serve/index.js';
+export * from './concurrency/index.js';
+export * from './tasks/index.js';
+export * from './scaffold/index.js';
+export * from './ci/index.js';
+export * from './build-dir/index.js';
+export * from './plugin-roles/index.js';
+export * from './plugin-refs/index.js';
+export * from './projects/index.js';
+export * from './templating/index.js';
+export * from './jsondoc/index.js';
+// Testing a plugin.
+export * from './host/index.js';
+export * from './conformance/index.js';
+// Building blocks: the wire form of the messages, for tools that speak the protocol themselves.
+export { decodeParams, decodeResult, encodeParams, encodeResult, EncodeError, MessageParseError, ParamsError } from './codec/index.js';
+export { FrameReader, FramingError, frameMessage } from './framing/index.js';

package/jsondoc/indent-raw-json.algorithm.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Formats JSON text as Go's `json.Indent(dst, src, prefix, "  ")` does: the
+ * insignificant whitespace is dropped and every element goes on its own line,
+ * indented two spaces per level and starting with `prefix`; an empty array or
+ * object stays `[]` or `{}`. Text that is not an array is returned as it is. The text
+ * of leaves (numbers, strings) is kept exactly.
+ */
+export declare function indentRawJson(raw: string, prefix: string): string;

package/jsondoc/indent-raw-json.algorithm.js

@@ -0,0 +1,60 @@
+/** A string literal (escapes included), a bracket, a comma or colon, or a run of any other characters (a number, `true`, `null`). */
+const TOKEN = /"(?:[^"\\]|\\.)*"|[{}[\],:]|[^\s{}[\],:"]+/g;
+/**
+ * Formats JSON text as Go's `json.Indent(dst, src, prefix, "  ")` does: the
+ * insignificant whitespace is dropped and every element goes on its own line,
+ * indented two spaces per level and starting with `prefix`; an empty array or
+ * object stays `[]` or `{}`. Text that is not an array is returned as it is. The text
+ * of leaves (numbers, strings) is kept exactly.
+ */
+export function indentRawJson(raw, prefix) {
+    if (!raw.startsWith('['))
+        return raw;
+    let out = '';
+    let depth = 0;
+    // Right after an opening bracket: the line break is held back until it is known whether the container is empty.
+    let needIndent = false;
+    const newline = () => {
+        out += `\n${prefix}${'  '.repeat(depth)}`;
+    };
+    const open = (token) => {
+        needIndent = true;
+        out += token;
+    };
+    const close = (token) => {
+        if (needIndent) {
+            needIndent = false;
+        }
+        else {
+            depth--;
+            newline();
+        }
+        out += token;
+    };
+    const handlers = {
+        '{': open,
+        '[': open,
+        '}': close,
+        ']': close,
+        ',': (token) => {
+            out += token;
+            newline();
+        },
+        ':': () => {
+            out += ': ';
+        },
+    };
+    for (const [token] of raw.matchAll(TOKEN)) {
+        if (needIndent && token !== '}' && token !== ']') {
+            needIndent = false;
+            depth++;
+            newline();
+        }
+        const handler = Object.hasOwn(handlers, token) ? handlers[token] : undefined;
+        if (handler === undefined)
+            out += token;
+        else
+            handler(token);
+    }
+    return out;
+}

package/jsondoc/index.d.ts

@@ -0,0 +1,2 @@
+export { JsonDocument } from './json-document.model.ts';
+export { JsonDocumentError } from './json-document.error.ts';

package/jsondoc/index.js

@@ -0,0 +1,2 @@
+export { JsonDocument } from './json-document.model.js';
+export { JsonDocumentError } from './json-document.error.js';

package/jsondoc/json-document.error.d.ts

@@ -0,0 +1,4 @@
+/** The text is not a JSON object, or not JSON at all. */
+export declare class JsonDocumentError extends Error {
+    constructor(message: string, options?: ErrorOptions);
+}

package/jsondoc/json-document.error.js

@@ -0,0 +1,7 @@
+/** The text is not a JSON object, or not JSON at all. */
+export class JsonDocumentError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = 'JsonDocumentError';
+    }
+}

package/jsondoc/json-document.model.d.ts

@@ -0,0 +1,38 @@
+/**
+ * A JSON object that keeps its key order and the text of everything you do not
+ * touch, so editing a `package.json` changes only what was edited: set a
+ * member and it keeps its place, add one and it goes last, delete one and the
+ * others stay where they were. Port of the Go SDK's `jsondoc.Document`.
+ *
+ * ```ts
+ * const doc = JsonDocument.parse(text)
+ * doc.setString('version', '1.2.3')
+ * writeFileSync(path, doc.render())
+ * ```
+ */
+export declare class JsonDocument {
+    #private;
+    /** Reads a JSON object. Throws {@link JsonDocumentError} for anything else. */
+    static parse(text: string): JsonDocument;
+    /** Whether the key exists. */
+    has(key: string): boolean;
+    /** The keys, in order. */
+    keys(): string[];
+    /** The number of keys. */
+    get size(): number;
+    /** The object under a key, editable in place; `create` adds an empty one (last) when there is none. Undefined for a key that holds something else. */
+    object(key: string, create?: boolean): JsonDocument | undefined;
+    /** A string value; undefined when the key is missing or does not hold a string. */
+    getString(key: string): string | undefined;
+    /** Any value under a key as JavaScript sees it, or undefined for a missing key. */
+    getValue(key: string): unknown;
+    /** Sets a string, keeping the key's position. */
+    setString(key: string, value: string): void;
+    /** Sets any JSON-encodable value, keeping the key's position. A plain object becomes an editable document, with its members in the order you wrote them. */
+    setJson(key: string, value: unknown): void;
+    /** Removes a key. */
+    delete(key: string): void;
+    /** The document as npm writes a package.json: two-space indentation, a final newline. */
+    render(): string;
+    toString(): string;
+}

package/jsondoc/json-document.model.js

@@ -0,0 +1,113 @@
+var _a;
+import { indentRawJson } from './indent-raw-json.algorithm.js';
+import { JsonDocumentError } from './json-document.error.js';
+import { scanJsonObject } from './scan-json-object.algorithm.js';
+/** A string as Go's JSON encoder writes it without HTML escaping: JSON, with U+2028 and U+2029 escaped. */
+function quote(text) {
+    return JSON.stringify(text)
+        .replaceAll('\u{2028}', String.raw `\u2028`)
+        .replaceAll('\u{2029}', String.raw `\u2029`);
+}
+/**
+ * A JSON object that keeps its key order and the text of everything you do not
+ * touch, so editing a `package.json` changes only what was edited: set a
+ * member and it keeps its place, add one and it goes last, delete one and the
+ * others stay where they were. Port of the Go SDK's `jsondoc.Document`.
+ *
+ * ```ts
+ * const doc = JsonDocument.parse(text)
+ * doc.setString('version', '1.2.3')
+ * writeFileSync(path, doc.render())
+ * ```
+ */
+export class JsonDocument {
+    /** Reads a JSON object. Throws {@link JsonDocumentError} for anything else. */
+    static parse(text) {
+        return _a.#fromNode(scanJsonObject(text));
+    }
+    static #fromNode(node) {
+        const doc = new _a();
+        for (const [key, value] of node.members)
+            doc.#entries.set(key, value.kind === 'object' ? _a.#fromNode(value) : { raw: value.text });
+        return doc;
+    }
+    /** In the order the keys were first set: a Map keeps it, whatever the keys look like. */
+    #entries = new Map();
+    #write(indent) {
+        if (this.#entries.size === 0)
+            return '{}';
+        const inner = `${indent}  `;
+        const lines = [...this.#entries].map(([key, entry]) => {
+            const value = entry instanceof _a ? entry.#write(inner) : indentRawJson(entry.raw, inner);
+            return `${inner}${quote(key)}: ${value}`;
+        });
+        return `{\n${lines.join(',\n')}\n${indent}}`;
+    }
+    /** Whether the key exists. */
+    has(key) {
+        return this.#entries.has(key);
+    }
+    /** The keys, in order. */
+    keys() {
+        // The es2023 lib this package compiles with has no Iterator#toArray.
+        // eslint-disable-next-line unicorn/prefer-spread
+        return Array.from(this.#entries.keys());
+    }
+    /** The number of keys. */
+    get size() {
+        return this.#entries.size;
+    }
+    /** The object under a key, editable in place; `create` adds an empty one (last) when there is none. Undefined for a key that holds something else. */
+    object(key, create = false) {
+        const entry = this.#entries.get(key);
+        if (entry instanceof _a)
+            return entry;
+        if (!create)
+            return undefined;
+        const child = new _a();
+        this.#entries.set(key, child);
+        return child;
+    }
+    /** A string value; undefined when the key is missing or does not hold a string. */
+    getString(key) {
+        const entry = this.#entries.get(key);
+        if (entry === undefined || entry instanceof _a)
+            return undefined;
+        const value = JSON.parse(entry.raw);
+        return typeof value === 'string' ? value : undefined;
+    }
+    /** Any value under a key as JavaScript sees it, or undefined for a missing key. */
+    getValue(key) {
+        const entry = this.#entries.get(key);
+        if (entry === undefined)
+            return undefined;
+        return JSON.parse(entry instanceof _a ? entry.render() : entry.raw);
+    }
+    /** Sets a string, keeping the key's position. */
+    setString(key, value) {
+        this.#entries.set(key, { raw: quote(value) });
+    }
+    /** Sets any JSON-encodable value, keeping the key's position. A plain object becomes an editable document, with its members in the order you wrote them. */
+    setJson(key, value) {
+        if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+            this.#entries.set(key, _a.parse(JSON.stringify(value)));
+            return;
+        }
+        const raw = JSON.stringify(value);
+        if (raw === undefined)
+            throw new JsonDocumentError(`${key}: a ${typeof value} cannot be written as JSON`);
+        this.#entries.set(key, { raw });
+    }
+    /** Removes a key. */
+    delete(key) {
+        this.#entries.delete(key);
+    }
+    /** The document as npm writes a package.json: two-space indentation, a final newline. */
+    render() {
+        return `${this.#write('')}\n`;
+    }
+    toString() {
+        return this.render();
+    }
+}
+_a = JsonDocument;

package/jsondoc/scan-json-object.algorithm.d.ts

@@ -0,0 +1,17 @@
+/** A JSON value as the document keeps it: an object edited member by member, anything else as the text it was written in. */
+export type JsonNode = {
+    kind: 'object';
+    members: Array<[string, JsonNode]>;
+} | {
+    kind: 'raw';
+    text: string;
+};
+/**
+ * Reads the text of a JSON object into a tree that keeps the order of its
+ * members and the exact text of every leaf and array (`1.0` stays `1.0`). A
+ * duplicate key keeps its first position and takes its last value, as the Go
+ * SDK's document does.
+ */
+export declare function scanJsonObject(text: string): Extract<JsonNode, {
+    kind: 'object';
+}>;

package/jsondoc/scan-json-object.algorithm.js

@@ -0,0 +1,132 @@
+import { JsonDocumentError } from './json-document.error.js';
+const WHITESPACE = new Set([' ', '\t', '\n', '\r']);
+/**
+ * Reads the text of a JSON object into a tree that keeps the order of its
+ * members and the exact text of every leaf and array (`1.0` stays `1.0`). A
+ * duplicate key keeps its first position and takes its last value, as the Go
+ * SDK's document does.
+ */
+export function scanJsonObject(text) {
+    const scanner = new Scanner(text);
+    scanner.skip();
+    if (text[scanner.position] !== '{')
+        throw new JsonDocumentError('not a JSON object');
+    const root = scanner.object();
+    scanner.skip();
+    if (scanner.position < text.length)
+        throw new JsonDocumentError(`unexpected "${text[scanner.position]}" after the object, at ${scanner.position}`);
+    return root;
+}
+class Scanner {
+    #text;
+    position = 0;
+    constructor(text) {
+        this.#text = text;
+    }
+    skip() {
+        while (this.position < this.#text.length && WHITESPACE.has(this.#text[this.position]))
+            this.position++;
+    }
+    object() {
+        const members = [];
+        const index = new Map();
+        this.position++; // {
+        this.skip();
+        if (this.#text[this.position] === '}') {
+            this.position++;
+            return { kind: 'object', members };
+        }
+        for (;;) {
+            this.skip();
+            if (this.#text[this.position] !== '"')
+                throw this.fail('an object key');
+            const key = JSON.parse(this.string());
+            this.skip();
+            if (this.#text[this.position] !== ':')
+                throw this.fail('":"');
+            this.position++;
+            const value = this.value();
+            const at = index.get(key);
+            if (at === undefined) {
+                index.set(key, members.length);
+                members.push([key, value]);
+            }
+            else {
+                members[at] = [key, value];
+            }
+            this.skip();
+            const next = this.#text[this.position];
+            if (next === '}') {
+                this.position++;
+                return { kind: 'object', members };
+            }
+            if (next !== ',')
+                throw this.fail('"," or "}"');
+            this.position++;
+        }
+    }
+    value() {
+        this.skip();
+        const first = this.#text[this.position];
+        if (first === '{')
+            return this.object();
+        const start = this.position;
+        if (first === '[')
+            this.array();
+        else if (first === '"')
+            this.string();
+        else
+            this.literal();
+        const text = this.#text.slice(start, this.position);
+        try {
+            JSON.parse(text);
+        }
+        catch (error) {
+            throw new JsonDocumentError(`invalid JSON value "${text.slice(0, 40)}" at ${start}`, { cause: error });
+        }
+        return { kind: 'raw', text };
+    }
+    /** Moves past an array, whose elements stay text. */
+    array() {
+        let depth = 0;
+        while (this.position < this.#text.length) {
+            const c = this.#text[this.position];
+            if (c === '"') {
+                this.string();
+                continue;
+            }
+            if (c === '[' || c === '{')
+                depth++;
+            else if (c === ']' || c === '}')
+                depth--;
+            this.position++;
+            if (depth === 0)
+                return;
+        }
+        throw new JsonDocumentError('unterminated array');
+    }
+    /** Moves past a string literal and returns its text, quotes included. */
+    string() {
+        const start = this.position;
+        this.position++;
+        while (this.position < this.#text.length) {
+            const c = this.#text[this.position++];
+            if (c === '\\')
+                this.position++;
+            else if (c === '"')
+                return this.#text.slice(start, this.position);
+        }
+        throw new JsonDocumentError('unterminated string');
+    }
+    literal() {
+        const start = this.position;
+        while (this.position < this.#text.length && !WHITESPACE.has(this.#text[this.position]) && !',}]'.includes(this.#text[this.position]))
+            this.position++;
+        if (this.position === start)
+            throw this.fail('a value');
+    }
+    fail(expected) {
+        const found = this.position < this.#text.length ? `"${this.#text[this.position]}"` : 'the end of the text';
+        return new JsonDocumentError(`expected ${expected}, found ${found} at ${this.position}`);
+    }
+}

package/package.json

@@ -1,6 +1,36 @@
 {
   "name": "@monosmith/plugin-sdk",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "description": "The TypeScript SDK for writing smith plugins: the protocol's types, the serve loop, a test host, the conformance checks, templating and key-order-keeping JSON editing. No runtime dependencies.",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    "default": "./index.js",
+    "types": "./index.d.ts"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "keywords": [
+    "smith",
+    "monosmith",
+    "plugin",
+    "sdk",
+    "json-rpc"
+  ],
+  "author": "Eduardo Russo",
+  "homepage": "https://github.com/monosmith-app/monosmith/tree/main/packages/plugin-sdk-ts#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/monosmith-app/monosmith.git",
+    "directory": "packages/plugin-sdk-ts"
+  },
+  "bugs": {
+    "url": "https://github.com/monosmith-app/monosmith/issues"
+  },
+  "main": "./index.js",
+  "types": "./index.d.ts"
+}

package/plugin-refs/index.d.ts

@@ -0,0 +1 @@
+export { conflictsWith, describeRef, isEmptyRef, requiresLanguage } from './plugin-ref.policy.ts';

package/plugin-refs/index.js

@@ -0,0 +1 @@
+export { conflictsWith, describeRef, isEmptyRef, requiresLanguage } from './plugin-ref.policy.js';

package/plugin-refs/plugin-ref.policy.d.ts

@@ -0,0 +1,9 @@
+import type { PluginRef } from '../protocol/index.ts';
+/** A requirement on the project's language plugin: `requiresLanguage('node')`. */
+export declare function requiresLanguage(name: string): PluginRef;
+/** A plugin that must not be in the same project. */
+export declare function conflictsWith(name: string): PluginRef;
+/** Whether the reference names nothing: every member of a reference is optional, and at least one must be set. */
+export declare function isEmptyRef(ref: PluginRef): boolean;
+/** How a message names it: `language plugin node`, `plugin providing test`. */
+export declare function describeRef(ref: PluginRef): string;

package/plugin-refs/plugin-ref.policy.js

@@ -0,0 +1,22 @@
+/** A requirement on the project's language plugin: `requiresLanguage('node')`. */
+export function requiresLanguage(name) {
+    return { level: 'language', name };
+}
+/** A plugin that must not be in the same project. */
+export function conflictsWith(name) {
+    return { name };
+}
+/** Whether the reference names nothing: every member of a reference is optional, and at least one must be set. */
+export function isEmptyRef(ref) {
+    return (ref.level ?? '') === '' && (ref.name ?? '') === '' && (ref.slot ?? '') === '';
+}
+/** How a message names it: `language plugin node`, `plugin providing test`. */
+export function describeRef(ref) {
+    const level = ref.level ?? '';
+    const parts = [level === '' ? 'plugin' : `${level} plugin`];
+    if (ref.name !== undefined && ref.name !== '')
+        parts.push(ref.name);
+    if (ref.slot !== undefined && ref.slot !== '')
+        parts.push(`providing ${ref.slot}`);
+    return parts.join(' ');
+}

package/plugin-roles/index.d.ts

@@ -0,0 +1 @@
+export { ROLES, defaultRoles, effectiveRoles, isAdditiveRole, isExclusiveRole, isKnownRole } from './plugin-role.policy.ts';

package/plugin-roles/index.js

@@ -0,0 +1 @@
+export { ROLES, defaultRoles, effectiveRoles, isAdditiveRole, isExclusiveRole, isKnownRole } from './plugin-role.policy.js';

package/plugin-roles/plugin-role.policy.d.ts

@@ -0,0 +1,16 @@
+import type { InitializeResult, PluginKind, Role } from '../protocol/index.ts';
+/** Every known role, in the order a project's make-up lists them. */
+export declare const ROLES: readonly Role[];
+/** Whether the role is one of {@link ROLES}. */
+export declare function isKnownRole(role: string): role is Role;
+/** Whether a project has at most one plugin at this level (language, scaffold). A toolchain is exclusive per slot instead. */
+export declare function isExclusiveRole(role: Role): boolean;
+/** Whether any number of plugins can share the level, each only adding (structure, deploy). */
+export declare function isAdditiveRole(role: Role): boolean;
+/**
+ * The roles of a plugin that declares none: a language plugin brings its own
+ * default toolchain and scaffold; any other kind of plugin is a structure rule.
+ */
+export declare function defaultRoles(kind: PluginKind): Role[];
+/** The plugin's roles, or the default of its kind. */
+export declare function effectiveRoles(info: Pick<InitializeResult, 'kind' | 'roles'>): Role[];

package/plugin-roles/plugin-role.policy.js

@@ -0,0 +1,30 @@
+import { protocolSchema } from '../protocol/index.js';
+/** Every known role, in the order a project's make-up lists them. */
+export const ROLES = protocolSchema['x-roles'].map(row => row.name);
+/** Whether the role is one of {@link ROLES}. */
+export function isKnownRole(role) {
+    return ROLES.includes(role);
+}
+/** Whether a project has at most one plugin at this level (language, scaffold). A toolchain is exclusive per slot instead. */
+export function isExclusiveRole(role) {
+    return cardinalityOf(role) === 'exclusive';
+}
+/** Whether any number of plugins can share the level, each only adding (structure, deploy). */
+export function isAdditiveRole(role) {
+    return cardinalityOf(role) === 'additive';
+}
+function cardinalityOf(role) {
+    return protocolSchema['x-roles'].find(row => row.name === role)?.cardinality;
+}
+/**
+ * The roles of a plugin that declares none: a language plugin brings its own
+ * default toolchain and scaffold; any other kind of plugin is a structure rule.
+ */
+export function defaultRoles(kind) {
+    const wanted = kind === 'language' ? 'language' : 'convention';
+    return protocolSchema['x-roles'].filter(row => row.defaultFor.includes(wanted)).map(row => row.name);
+}
+/** The plugin's roles, or the default of its kind. */
+export function effectiveRoles(info) {
+    return info.roles !== undefined && info.roles.length > 0 ? info.roles : defaultRoles(info.kind);
+}

package/projects/audit-settings.policy.d.ts

@@ -0,0 +1,5 @@
+import type { AuditSettings } from '../protocol/index.ts';
+/** Whether the ecosystem's (`node`, `go`, `python`, `rust`) audit policy checks are on. */
+export declare function auditEnabled(audit: AuditSettings | undefined, policy: string): boolean;
+/** Whether a failing check of the policy fails the audit: it does unless the workspace made the policy only warn. */
+export declare function auditBlocks(audit: AuditSettings | undefined, policy: string): boolean;

package/projects/audit-settings.policy.js

@@ -0,0 +1,8 @@
+/** Whether the ecosystem's (`node`, `go`, `python`, `rust`) audit policy checks are on. */
+export function auditEnabled(audit, policy) {
+    return audit?.policies?.includes(policy) ?? false;
+}
+/** Whether a failing check of the policy fails the audit: it does unless the workspace made the policy only warn. */
+export function auditBlocks(audit, policy) {
+    return !(audit?.warn?.includes(policy) ?? false);
+}

package/projects/index.d.ts

@@ -0,0 +1,6 @@
+export { auditBlocks, auditEnabled } from './audit-settings.policy.ts';
+export { isManifest } from './manifest-match.algorithm.ts';
+export { projectKindDirectory, resolveProjectKind } from './project-kind.policy.ts';
+export { publishes } from './publishes.policy.ts';
+export { setToolchain } from './set-toolchain.algorithm.ts';
+export { stackPlugins } from './stack-plugins.algorithm.ts';