@qvac/harness 1.0.0-rc.0 → 1.0.0-rc.2

package/dist-lib/lib/office/engine/xlsx/write.d.ts

@@ -0,0 +1,2 @@
+export type EmbeddedValue = string | number | null | undefined;
+export declare function writeWorkbook(rows: EmbeddedValue[][], sheet?: string): Uint8Array;

package/dist-lib/lib/office/engine/xlsx/write.js

@@ -0,0 +1,42 @@
+import { Package } from '../opc/package.js';
+import * as xml from '../xml.js';
+import { cell } from './refs.js';
+const SML = 'http://schemas.openxmlformats.org/spreadsheetml/2006/main';
+const REL_BASE = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/';
+const TYPES = {
+    workbook: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml',
+    worksheet: 'application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml',
+    styles: 'application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml'
+};
+const STYLES = `<styleSheet xmlns="${SML}"><fonts count="1"><font><sz val="11"/><name val="Calibri"/></font></fonts><fills count="2"><fill><patternFill patternType="none"/></fill><fill><patternFill patternType="gray125"/></fill></fills><borders count="1"><border><left/><right/><top/><bottom/><diagonal/></border></borders><cellStyleXfs count="1"><xf numFmtId="0" fontId="0" fillId="0" borderId="0"/></cellStyleXfs><cellXfs count="1"><xf numFmtId="0" fontId="0" fillId="0" borderId="0" xfId="0"/></cellXfs><cellStyles count="1"><cellStyle name="Normal" xfId="0" builtinId="0"/></cellStyles></styleSheet>`;
+function escape(value) {
+    return value
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}
+function cellXml(value, ref) {
+    if (value === null || value === undefined || value === '')
+        return '';
+    if (typeof value === 'number')
+        return `<c r="${ref}"><v>${value}</v></c>`;
+    return `<c r="${ref}" t="inlineStr"><is><t xml:space="preserve">${escape(value)}</t></is></c>`;
+}
+function sheetXml(rows) {
+    const data = rows
+        .map((row, r) => `<row r="${r + 1}">${row.map((value, c) => cellXml(value, cell(r, c))).join('')}</row>`)
+        .join('');
+    return `<worksheet xmlns="${SML}"><sheetData>${data}</sheetData></worksheet>`;
+}
+export function writeWorkbook(rows, sheet = 'Sheet1') {
+    const pkg = Package.create();
+    const workbook = `<workbook xmlns="${SML}" xmlns:r="${xml.ns.r}"><sheets><sheet name="${escape(sheet)}" sheetId="1" r:id="rId1"/></sheets></workbook>`;
+    pkg.add('/xl/workbook.xml', xml.parse(workbook), TYPES.workbook);
+    pkg.add('/xl/worksheets/sheet1.xml', xml.parse(sheetXml(rows)), TYPES.worksheet);
+    pkg.add('/xl/styles.xml', xml.parse(STYLES), TYPES.styles);
+    pkg.rels('/').add(REL_BASE + 'officeDocument', '/xl/workbook.xml');
+    pkg.rels('/xl/workbook.xml').add(REL_BASE + 'worksheet', '/xl/worksheets/sheet1.xml');
+    pkg.rels('/xl/workbook.xml').add(REL_BASE + 'styles', '/xl/styles.xml');
+    return pkg.save();
+}

package/dist-lib/lib/office/engine/xml.d.ts

@@ -0,0 +1,45 @@
+import { Element, type Document, type Node } from '@xmldom/xmldom';
+export type { Document, Element, Node };
+export declare const ns: {
+    readonly a: 'http://schemas.openxmlformats.org/drawingml/2006/main';
+    readonly p: 'http://schemas.openxmlformats.org/presentationml/2006/main';
+    readonly r: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships';
+    readonly w: 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
+    readonly p14: 'http://schemas.microsoft.com/office/powerpoint/2010/main';
+    readonly wp: 'http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing';
+    readonly pic: 'http://schemas.openxmlformats.org/drawingml/2006/picture';
+    readonly c: 'http://schemas.openxmlformats.org/drawingml/2006/chart';
+    readonly xdr: 'http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing';
+    readonly x: 'http://schemas.openxmlformats.org/spreadsheetml/2006/main';
+    readonly rels: 'http://schemas.openxmlformats.org/package/2006/relationships';
+    readonly ct: 'http://schemas.openxmlformats.org/package/2006/content-types';
+};
+export type Attributes = Record<string, string | number | undefined | null>;
+export type Build = (local: string, attributes?: Attributes) => Element;
+export declare function decode(bytes: Uint8Array): string;
+export declare function parse(input: Uint8Array | string, name?: string): Document;
+export declare function toString(doc: Document): string;
+export declare function serialize(doc: Document): Uint8Array;
+export declare function root(doc: Document): Element;
+export declare function owner(node: Node): Document;
+export declare function isElement(node: Node | null, namespace?: string, local?: string): node is Element;
+export declare function children(el: Node, namespace?: string, local?: string): Element[];
+export declare function child(el: Node, namespace?: string, local?: string): Element | null;
+export declare function descendants(el: Element | Document, namespace: string, local: string): Element[];
+export declare function text(node: Node | null): string;
+export declare function clean(value: string): string;
+export declare function setText(el: Element, value: string): void;
+export declare function attr(el: Element, name: string): string;
+export declare function setAttributes(el: Element, attributes?: Attributes): Element;
+export declare function named(doc: Document, qualifiedName: string, namespace: string): Element;
+export declare function qualify(doc: Document, namespace: string, local: string): string;
+export declare function builder(doc: Document, namespace: string): Build;
+export interface QualifiedName {
+    namespace: string;
+    local: string;
+}
+export declare function setNsAttribute(el: Element, name: QualifiedName, value: string): void;
+export declare function insertOrdered(parent: Element, el: Element, order: readonly string[]): Element;
+export declare function remove(node: Node): void;
+export declare function append(parent: Node, node: Element): Element;
+export declare function clone(el: Element): Element;

package/dist-lib/lib/office/engine/xml.js

@@ -0,0 +1,258 @@
+import { DOMParser, XMLSerializer, Element } from '@xmldom/xmldom';
+import { DocsError } from './errors.js';
+import { errorMessage } from '../../guards.js';
+import * as utf8 from './utf8.js';
+export const ns = {
+    a: 'http://schemas.openxmlformats.org/drawingml/2006/main',
+    p: 'http://schemas.openxmlformats.org/presentationml/2006/main',
+    r: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships',
+    w: 'http://schemas.openxmlformats.org/wordprocessingml/2006/main',
+    p14: 'http://schemas.microsoft.com/office/powerpoint/2010/main',
+    wp: 'http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing',
+    pic: 'http://schemas.openxmlformats.org/drawingml/2006/picture',
+    c: 'http://schemas.openxmlformats.org/drawingml/2006/chart',
+    xdr: 'http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing',
+    x: 'http://schemas.openxmlformats.org/spreadsheetml/2006/main',
+    rels: 'http://schemas.openxmlformats.org/package/2006/relationships',
+    ct: 'http://schemas.openxmlformats.org/package/2006/content-types'
+};
+const MAX_DEPTH = 256;
+const NOT_XML = /[\u0000-\u0008\u000B\u000C\u000E-\u001F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g;
+const DECLARATION = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n';
+const UNPREFIXED = [ns.rels, ns.ct, ns.x];
+const PREFIXES = new Map(Object.entries(ns)
+    .filter(([, uri]) => !UNPREFIXED.includes(uri))
+    .map(([prefix, uri]) => [uri, prefix]));
+const SKIPPED = [
+    ['<!--', '-->'],
+    ['<![CDATA[', ']]>'],
+    ['<?', '?>'],
+    ['<!', '>']
+];
+function skipped(text, at) {
+    for (const [open, close] of SKIPPED) {
+        if (text.startsWith(open, at)) {
+            const end = text.indexOf(close, at + open.length);
+            return end === -1 ? -1 : end + close.length;
+        }
+    }
+    return null;
+}
+function tagEnd(text, at) {
+    let quote = '';
+    for (let i = at; i < text.length; i++) {
+        const c = text[i];
+        if (quote) {
+            quote = c === quote ? '' : quote;
+        }
+        else if (c === '"' || c === "'") {
+            quote = c;
+        }
+        else if (c === '>') {
+            return i;
+        }
+    }
+    return -1;
+}
+function checkDepth(text, name) {
+    let depth = 0;
+    for (let i = text.indexOf('<'); i !== -1; i = text.indexOf('<', i)) {
+        const after = skipped(text, i);
+        if (after === -1) {
+            return;
+        }
+        if (after !== null) {
+            i = after;
+            continue;
+        }
+        const end = tagEnd(text, i + 1);
+        if (end === -1) {
+            return;
+        }
+        if (text[i + 1] === '/') {
+            depth--;
+        }
+        else if (text[end - 1] !== '/') {
+            depth++;
+        }
+        if (depth > MAX_DEPTH) {
+            throw new DocsError('UNSAFE_XML', `${name} nests elements more than ${MAX_DEPTH} levels deep`);
+        }
+        i = end + 1;
+    }
+}
+function decodeUtf16(bytes, endian) {
+    const littleEndian = endian === 'le';
+    let out = '';
+    for (let i = 2; i + 1 < bytes.length; i += 2) {
+        const code = littleEndian ? bytes[i] | (bytes[i + 1] << 8) : (bytes[i] << 8) | bytes[i + 1];
+        out += String.fromCharCode(code);
+    }
+    return out;
+}
+export function decode(bytes) {
+    if (bytes[0] === 0xef && bytes[1] === 0xbb && bytes[2] === 0xbf) {
+        return utf8.decode(bytes.subarray(3));
+    }
+    if (bytes[0] === 0xff && bytes[1] === 0xfe) {
+        return decodeUtf16(bytes, 'le');
+    }
+    if (bytes[0] === 0xfe && bytes[1] === 0xff) {
+        return decodeUtf16(bytes, 'be');
+    }
+    return utf8.decode(bytes);
+}
+function causeOf(err) {
+    return err instanceof Error ? err.cause : undefined;
+}
+export function parse(input, name = 'part') {
+    const text = (typeof input === 'string' ? input : decode(input)).replace(/^/, '');
+    if (/<!DOCTYPE/i.test(text)) {
+        throw new DocsError('UNSAFE_XML', `${name} declares a DOCTYPE, which Office files never do`);
+    }
+    checkDepth(text, name);
+    const invalid = (message) => new DocsError('INVALID_XML', `${name} is not well-formed XML: ${message}`);
+    const parser = new DOMParser({
+        onError(level, message) {
+            if (level !== 'warning') {
+                throw invalid(message);
+            }
+        }
+    });
+    let doc;
+    try {
+        doc = parser.parseFromString(text, 'application/xml');
+    }
+    catch (err) {
+        if (err instanceof DocsError) {
+            throw err;
+        }
+        const cause = causeOf(err);
+        if (cause instanceof DocsError) {
+            throw cause;
+        }
+        throw invalid(errorMessage(err));
+    }
+    if (!doc.documentElement) {
+        throw new DocsError('INVALID_XML', `${name} has no root element`);
+    }
+    return doc;
+}
+export function toString(doc) {
+    return new XMLSerializer().serializeToString(doc);
+}
+export function serialize(doc) {
+    const text = toString(doc);
+    if (!text.startsWith('<?xml')) {
+        return utf8.encode(DECLARATION + text);
+    }
+    return utf8.encode(text.replace(/^(<\?xml[^?]*?encoding=)(["'])[^"']*\2/i, '$1$2UTF-8$2'));
+}
+export function root(doc) {
+    const el = doc.documentElement;
+    if (!el) {
+        throw new DocsError('INVALID_XML', 'the part has no root element');
+    }
+    return el;
+}
+export function owner(node) {
+    const doc = node.ownerDocument;
+    if (!doc) {
+        throw new DocsError('INVALID_XML', 'the element belongs to no document');
+    }
+    return doc;
+}
+export function isElement(node, namespace, local) {
+    return (node instanceof Element &&
+        (namespace === undefined || node.namespaceURI === namespace) &&
+        (local === undefined || node.localName === local));
+}
+export function children(el, namespace, local) {
+    const out = [];
+    for (let n = el.firstChild; n; n = n.nextSibling) {
+        if (isElement(n, namespace, local)) {
+            out.push(n);
+        }
+    }
+    return out;
+}
+export function child(el, namespace, local) {
+    for (let n = el.firstChild; n; n = n.nextSibling) {
+        if (isElement(n, namespace, local))
+            return n;
+    }
+    return null;
+}
+export function descendants(el, namespace, local) {
+    return Array.from(el.getElementsByTagNameNS(namespace, local));
+}
+export function text(node) {
+    return node?.textContent ?? '';
+}
+export function clean(value) {
+    return value.replace(NOT_XML, '');
+}
+export function setText(el, value) {
+    while (el.firstChild) {
+        el.removeChild(el.firstChild);
+    }
+    el.appendChild(owner(el).createTextNode(clean(value)));
+}
+export function attr(el, name) {
+    return el.getAttribute(name) ?? '';
+}
+export function setAttributes(el, attributes = {}) {
+    for (const [key, value] of Object.entries(attributes)) {
+        if (value !== undefined && value !== null) {
+            el.setAttribute(key, String(value));
+        }
+    }
+    return el;
+}
+export function named(doc, qualifiedName, namespace) {
+    return doc.createElementNS(namespace, qualifiedName);
+}
+export function qualify(doc, namespace, local) {
+    const top = root(doc);
+    if (top.namespaceURI === namespace && !top.prefix) {
+        return local;
+    }
+    const prefix = top.lookupPrefix(namespace) ?? PREFIXES.get(namespace);
+    return prefix ? `${prefix}:${local}` : local;
+}
+export function builder(doc, namespace) {
+    return (local, attributes) => setAttributes(named(doc, qualify(doc, namespace, local), namespace), attributes);
+}
+export function setNsAttribute(el, name, value) {
+    const doc = owner(el);
+    const prefix = root(doc).lookupPrefix(name.namespace) ?? PREFIXES.get(name.namespace) ?? name.local;
+    el.setAttributeNS(name.namespace, `${prefix}:${name.local}`, value);
+}
+export function insertOrdered(parent, el, order) {
+    const rank = order.indexOf(el.localName ?? '');
+    for (let n = parent.firstChild; n; n = n.nextSibling) {
+        if (!(n instanceof Element))
+            continue;
+        const other = order.indexOf(n.localName ?? '');
+        if (other > rank || other === -1) {
+            parent.insertBefore(el, n);
+            return el;
+        }
+    }
+    parent.appendChild(el);
+    return el;
+}
+export function remove(node) {
+    node.parentNode?.removeChild(node);
+}
+export function append(parent, node) {
+    parent.appendChild(node);
+    return node;
+}
+export function clone(el) {
+    const copy = el.cloneNode(true);
+    if (!(copy instanceof Element)) {
+        throw new DocsError('INVALID_XML', 'cloning an element produced no element');
+    }
+    return copy;
+}

package/dist-lib/lib/office/extract.d.ts

@@ -0,0 +1,9 @@
+import type { AbortSignal } from 'bare-abort-controller';
+export type Extract = (bytes: Uint8Array) => string;
+export interface ExtractJob {
+    readonly fileName: string;
+    readonly signal: AbortSignal | undefined;
+    readonly extract: Extract;
+}
+export declare function extractWith(bytes: Uint8Array, { fileName, signal, extract }: ExtractJob): string;
+export declare function cellText(value: unknown): string;

package/dist-lib/lib/office/extract.js

@@ -0,0 +1,19 @@
+import { errorMessage } from '../guards.js';
+const MAX_OFFICE_BYTES = 20 * 1024 * 1024;
+export function extractWith(bytes, { fileName, signal, extract }) {
+    if (bytes.byteLength > MAX_OFFICE_BYTES) {
+        throw new Error(`document is too large to extract: ${bytes.byteLength} bytes, limit ${MAX_OFFICE_BYTES}`);
+    }
+    if (signal?.aborted) {
+        throw new Error(`${fileName}: extraction aborted`);
+    }
+    try {
+        return extract(bytes);
+    }
+    catch (err) {
+        throw new Error(`${fileName}: ${errorMessage(err)}`);
+    }
+}
+export function cellText(value) {
+    return value === null || value === undefined ? '' : String(value).replaceAll('\n', ' ');
+}

package/dist-lib/lib/office/index.d.ts

@@ -1,7 +1,7 @@
 import type { AbortSignal } from 'bare-abort-controller';
-export { closePythonWorker as closeOfficeWorker } from '../tools/exec/adapters/python/worker/active.ts';
 export interface OfficeExtractOptions {
     readonly signal?: AbortSignal | undefined;
     readonly mimeType?: string | undefined;
 }
+export declare function closeOfficeWorker(): Promise<void>;
 export declare function extractOfficeText(bytes: Uint8Array, fileName: string, options?: OfficeExtractOptions): Promise<string>;

package/dist-lib/lib/office/index.js

@@ -1,14 +1,81 @@
 import path from 'path';
 import { extractDocxText } from '../docx/index.js';
-import { extractWithPython } from './python.js';
-import { XLSX_EXTRACT } from './xlsx.js';
-import { PPTX_EXTRACT } from './pptx.js';
-export { closePythonWorker as closeOfficeWorker } from '../tools/exec/adapters/python/worker/active.js';
+import { pptx, xlsx } from './engine/index.js';
+import { cellText, extractWith } from './extract.js';
 const OFFICE_MIME_EXTENSIONS = {
     'application/vnd.openxmlformats-officedocument.wordprocessingml.document': '.docx',
     'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': '.xlsx',
     'application/vnd.openxmlformats-officedocument.presentationml.presentation': '.pptx'
 };
+const EXTRACT_CELL_LIMIT = 1_000_000;
+function columnIndex(letters) {
+    let index = 0;
+    for (const char of letters) {
+        index = index * 26 + char.charCodeAt(0) - 64;
+    }
+    return index;
+}
+function columnName(index) {
+    let name = '';
+    for (let n = index; n > 0; n = Math.floor((n - 1) / 26)) {
+        name = String.fromCharCode(65 + ((n - 1) % 26)) + name;
+    }
+    return name;
+}
+function trimmedRow(values) {
+    const row = [...values];
+    while (row.length && !cellText(row.at(-1)).trim()) {
+        row.pop();
+    }
+    return row;
+}
+function workbookText(bytes) {
+    const book = xlsx.open(bytes);
+    let output = '';
+    let budget = EXTRACT_CELL_LIMIT;
+    for (const sheet of book.sheets()) {
+        if (sheet.kind !== 'worksheet' || budget <= 0)
+            continue;
+        const { range, rows, formulas } = book.read(sheet.index, { limit: budget });
+        budget -= rows.length * (rows[0]?.length ?? 0);
+        const [, letters = 'A', digits = '1'] = /^([A-Z]+)(\d+)/.exec(range ?? 'A1') ?? [];
+        const firstColumn = columnIndex(letters);
+        const firstRow = Number(digits);
+        const lines = rows
+            .map((row, r) => trimmedRow(row.map((value, c) => value ?? formulas[`${columnName(firstColumn + c)}${firstRow + r}`] ?? null)))
+            .filter((row) => row.length)
+            .map((row) => row.map(cellText).join(' | '));
+        if (lines.length) {
+            output += `Sheet: ${sheet.name}\n${lines.join('\n')}\n`;
+        }
+    }
+    return output;
+}
+function shapeBlocks(shape) {
+    if (shape.paragraphs) {
+        const text = shape.paragraphs.map((paragraph) => paragraph.text).join('\n');
+        return text.trim() ? [text] : [];
+    }
+    return (shape.rows ?? [])
+        .map((row) => row.map(cellText))
+        .filter((cells) => cells.some((cell) => cell.trim()))
+        .map((cells) => cells.join(' | '));
+}
+function deckText(bytes) {
+    let output = '';
+    for (const slide of pptx.open(bytes).read()) {
+        const blocks = slide.shapes.flatMap(shapeBlocks);
+        if (blocks.length) {
+            output += `Slide ${slide.index + 1}\n${blocks.join('\n')}\n`;
+        }
+    }
+    return output;
+}
+const EXTRACTORS = new Map([
+    ['.xlsx', workbookText],
+    ['.pptx', deckText]
+]);
+export async function closeOfficeWorker() { }
 export async function extractOfficeText(bytes, fileName, options = {}) {
     const mimeType = options.mimeType?.split(';')[0]?.trim().toLowerCase();
     const suffix = path.extname(fileName).toLowerCase();
@@ -18,21 +85,9 @@ export async function extractOfficeText(bytes, fileName, options = {}) {
     if (extension === '.docx') {
         return extractDocxText(bytes, fileName, options);
     }
-    if (extension === '.xlsx') {
-        return extractWithPython(bytes, fileName, {
-            format: 'XLSX',
-            packages: ['openpyxl==3.1.5'],
-            source: XLSX_EXTRACT,
-            signal: options.signal
-        });
-    }
-    if (extension === '.pptx') {
-        return extractWithPython(bytes, fileName, {
-            format: 'PPTX',
-            packages: ['python-pptx==1.0.2'],
-            source: PPTX_EXTRACT,
-            signal: options.signal
-        });
+    const extract = EXTRACTORS.get(extension ?? '');
+    if (extract) {
+        return extractWith(bytes, { fileName, signal: options.signal, extract });
     }
     throw new Error(`Unsupported Office document: ${fileName}`);
 }

package/dist-lib/lib/plugins/addons.d.ts

@@ -0,0 +1,2 @@
+import type { AddonLoaders } from '../contract/index.ts';
+export declare function loadAddons(owner: string, addons?: AddonLoaders): Promise<void>;

package/dist-lib/lib/plugins/addons.js

@@ -0,0 +1,12 @@
+export async function loadAddons(owner, addons = {}) {
+    if (typeof globalThis.Bare === 'undefined') {
+        return;
+    }
+    await Promise.all(Object.entries(addons).map(([name, load]) => Promise.resolve()
+        .then(load)
+        .catch((error) => {
+        throw new Error(`${owner} could not load addon '${name}': ${error.message}`, {
+            cause: error
+        });
+    })));
+}

package/dist-lib/lib/plugins/context.d.ts

@@ -0,0 +1,16 @@
+import type { Scope, Dispose } from './scope.ts';
+export interface Services {
+}
+export type ServiceName = keyof Services & string;
+export interface Context extends Readonly<Services> {
+}
+export declare class Context {
+    private readonly _root;
+    private readonly _scope;
+    private readonly _values;
+    constructor(scope: Scope);
+    get<K extends ServiceName>(name: K): Services[K];
+    provide<K extends ServiceName>(name: K, value: Services[K]): void;
+    onDispose(dispose: Dispose): void;
+}
+export declare function createContext(scope: Scope, root?: Context): Context;

package/dist-lib/lib/plugins/context.js

@@ -0,0 +1,48 @@
+export class Context {
+    _root;
+    _scope;
+    _values;
+    constructor(scope) {
+        this._root = this;
+        this._scope = scope;
+        this._values = Object.create(null);
+    }
+    get(name) {
+        this._scope.assertActive();
+        const value = this._root._values[name];
+        if (value === undefined) {
+            throw new Error(`Service "${name}" is not available`);
+        }
+        return value;
+    }
+    provide(name, value) {
+        this._scope.assertOpen();
+        const root = this._root;
+        if (name in root) {
+            throw new Error(`Context property "${name}" is already registered or reserved`);
+        }
+        if (value === undefined) {
+            throw new Error(`Service "${name}" cannot be undefined`);
+        }
+        root._values[name] = value;
+        Object.defineProperty(root, name, {
+            configurable: true,
+            get() {
+                return this.get(name);
+            }
+        });
+        this._scope.onRelease(() => {
+            delete root._values[name];
+            Reflect.deleteProperty(root, name);
+        });
+    }
+    onDispose(dispose) {
+        this._scope.onDispose(dispose);
+    }
+}
+export function createContext(scope, root) {
+    if (!root) {
+        return new Context(scope);
+    }
+    return Object.create(root, { _scope: { value: scope } });
+}

package/dist-lib/lib/plugins/index.d.ts

@@ -0,0 +1,3 @@
+export type { Context, ServiceName, Services } from './context.ts';
+export type { Dispose } from './scope.ts';
+export { PluginRegistry, type HarnessPlugin, type PluginContext, type PluginSetup, type PluginExec, type PluginStartOptions, type PluginRegistryOptions, type StartedPlugins, type StartedExec, type FetchFor } from './registry.ts';

package/dist-lib/lib/plugins/index.js

@@ -0,0 +1 @@
+export { PluginRegistry } from './registry.js';