@poe-platform/safe-bash 0.1.630 → 0.1.631

package/dist/safe-bash/opt-in/shell/extensions/jobs/index.js

@@ -0,0 +1,291 @@
+import { commandRuntimeIdentity } from "@poe-platform/safe-bash/contracts/command";
+import { writeText } from "@poe-platform/safe-bash/contracts/io";
+import { concatShellValues, shellValueBytes, shellValueFromBytes } from "@poe-platform/safe-bash/contracts/value";
+import { createJobState } from "./state.js";
+const maximumWaitProcessId = 2147483647;
+function waitProcessId(operand, flexible = false) {
+    let value = 0;
+    let offset = 0;
+    let negative = false;
+    if (flexible) {
+        while (offset < operand.length && (operand.charCodeAt(offset) === 32 || operand.charCodeAt(offset) >= 9 && operand.charCodeAt(offset) <= 13))
+            offset++;
+        if (operand[offset] === "+" || operand[offset] === "-")
+            negative = operand[offset++] === "-";
+    }
+    const firstDigit = offset;
+    while (offset < operand.length) {
+        const code = operand.charCodeAt(offset);
+        if (code < 48 || code > 57)
+            break;
+        value = value * 10 + code - 48;
+        if (value > maximumWaitProcessId + Number(negative))
+            return undefined;
+        offset++;
+    }
+    if (offset === firstDigit)
+        return undefined;
+    while (offset < operand.length) {
+        const code = operand.charCodeAt(offset++);
+        if (code !== 32 && (code < 9 || code > 13))
+            return undefined;
+    }
+    return negative ? -value : value;
+}
+function instance(inherited) {
+    let latest = inherited;
+    let jobs;
+    let failure;
+    const children = new Map();
+    const status = (outcome) => {
+        if (outcome.kind === "failure") {
+            failure ??= { reason: outcome.reason };
+            throw outcome.reason;
+        }
+        return outcome.status;
+    };
+    const wait = async (context) => {
+        let reference;
+        let primary;
+        const ordinaryWait = async (targets) => {
+            if (context.waitInterruptibly)
+                return context.waitInterruptibly(signal => jobs.wait(targets, { signal }));
+            return { kind: "completed", value: await jobs.wait(targets, { signal: context.signal }) };
+        };
+        const execute = async () => {
+            let offset = 0;
+            let next = false;
+            let destination;
+            while (offset < context.args.length) {
+                context.signal.throwIfAborted();
+                const option = shellValueBytes(context.argumentValues[offset]);
+                if (option.length < 2 || option[0] !== 45)
+                    break;
+                offset++;
+                if (option.length === 2 && option[1] === 45)
+                    break;
+                for (let index = 1; index < option.length; index++) {
+                    if (option[index] === 102)
+                        continue;
+                    if (option[index] === 110) {
+                        next = true;
+                        continue;
+                    }
+                    if (option[index] === 112) {
+                        if (index + 1 < option.length)
+                            destination = shellValueFromBytes(option.subarray(index + 1));
+                        else if (offset < context.args.length)
+                            destination = context.argumentValues[offset++];
+                        else {
+                            await context.diagnostic("wait: -p: option requires an argument");
+                            await writeText(context.stderr, "wait: usage: wait [-fn] [-p var] [id ...]\n");
+                            return 2;
+                        }
+                        break;
+                    }
+                    await context.diagnostic(concatShellValues(["wait: -", shellValueFromBytes(option.subarray(index, index + 1)), ": invalid option"]));
+                    await writeText(context.stderr, "wait: usage: wait [-fn] [-p var] [id ...]\n");
+                    return 2;
+                }
+            }
+            if (destination !== undefined) {
+                const prepared = await context.bindings.prepareReference(destination);
+                if (!prepared.ok) {
+                    await context.diagnostic(concatShellValues(["wait: ", prepared.diagnostic]));
+                    return 1;
+                }
+                reference = prepared.value;
+                const removed = await reference.unbindName();
+                if (!removed.ok) {
+                    await context.diagnostic(concatShellValues(["wait: ", removed.diagnostic]));
+                    return 1;
+                }
+            }
+            const publish = async (result, processId) => {
+                if (reference && processId !== undefined) {
+                    const assigned = await reference.assignInteger(processId);
+                    if (!assigned.ok) {
+                        await context.diagnostic(concatShellValues(["wait: ", assigned.diagnostic]));
+                        return 1;
+                    }
+                }
+                return result;
+            };
+            if (next) {
+                for (let index = offset; index < context.args.length; index++) {
+                    context.signal.throwIfAborted();
+                    const processId = waitProcessId(context.args[index], true);
+                    const handle = processId === undefined || processId < 0 ? undefined : children.get(processId);
+                    const saved = handle && jobs.savedStatus(handle);
+                    if (saved !== undefined)
+                        return await publish(saved, processId);
+                }
+                const active = new Set(jobs.snapshot().filter(entry => entry.residency !== "saved").map(entry => entry.handle));
+                const targets = [];
+                for (let index = offset; index < context.args.length; index++) {
+                    context.signal.throwIfAborted();
+                    const operand = context.args[index];
+                    const raw = context.argumentValues[index];
+                    const processId = waitProcessId(operand, true);
+                    const handle = processId === undefined ? undefined : children.get(processId);
+                    if (handle && active.has(handle)) {
+                        targets.push({ handle });
+                        continue;
+                    }
+                    if ((processId === undefined || processId === -1) && operand.length && operand[0] !== "%")
+                        await context.diagnostic(concatShellValues(["wait: warning: ", raw, ": job specification requires leading `%'"]));
+                    await context.diagnostic(concatShellValues(["wait: `", raw, operand[0] === "%" ? "': no such job" : "': not a pid or valid job spec"]));
+                }
+                if (offset < context.args.length && !targets.length)
+                    return 127;
+                const selected = offset === context.args.length ? undefined : targets;
+                const waited = context.waitInterruptibly
+                    ? await context.waitInterruptibly(signal => jobs.waitNext(selected, { signal }))
+                    : { kind: "completed", value: await jobs.waitNext(selected, { signal: context.signal }) };
+                if (waited.kind === "interrupted")
+                    return waited.status;
+                const result = status(waited.value.outcome);
+                const processId = waited.value.handle && [...children].find(([, handle]) => handle === waited.value.handle)?.[0];
+                return await publish(result, processId);
+            }
+            if (offset === context.args.length) {
+                const result = await ordinaryWait();
+                if (result.kind === "interrupted")
+                    return result.status;
+                children.clear();
+                return status(result.value.outcome);
+            }
+            const waitOperands = async (signal) => {
+                let result = 0;
+                let returnedProcessId;
+                for (; offset < context.args.length; offset++) {
+                    signal.throwIfAborted();
+                    const operand = context.args[offset];
+                    const raw = context.argumentValues[offset];
+                    const processId = waitProcessId(operand);
+                    returnedProcessId = undefined;
+                    if (processId === undefined) {
+                        await context.diagnostic(concatShellValues(["wait: `", raw, "': not a pid or valid job spec"]));
+                        if (operand.length && operand[0] >= "0" && operand[0] <= "9")
+                            return { result: 1, processId: undefined };
+                        result = 1;
+                        continue;
+                    }
+                    const handle = children.get(processId);
+                    if (!handle) {
+                        await context.diagnostic(`wait: pid ${processId} is not a child of this shell`);
+                        result = 127;
+                    }
+                    else {
+                        const waited = await jobs.wait([{ handle }], { signal });
+                        result = status(waited.outcome);
+                        returnedProcessId = processId;
+                    }
+                }
+                return { result, processId: returnedProcessId };
+            };
+            const waited = context.waitInterruptibly
+                ? await context.waitInterruptibly(waitOperands)
+                : { kind: "completed", value: await waitOperands(context.signal) };
+            if (waited.kind === "interrupted")
+                return waited.status;
+            return await publish(waited.value.result, waited.value.processId);
+        };
+        let result = 0;
+        try {
+            result = await execute();
+        }
+        catch (reason) {
+            primary = { reason };
+            failure ??= primary;
+        }
+        try {
+            await reference?.close();
+        }
+        catch (reason) {
+            primary ??= { reason };
+            failure ??= primary;
+        }
+        if (primary)
+            throw primary.reason;
+        return result;
+    };
+    return {
+        builtins: [{ name: "wait", execute: wait }],
+        start(context) {
+            const registerExecutionCleanup = context.registerExecutionCleanup;
+            if (typeof registerExecutionCleanup !== "function")
+                throw new TypeError("Jobs require execution-scoped cleanup ownership");
+            let ownerSignal = context.signal;
+            let retired;
+            const retirement = new Promise(resolve => { retired = resolve; });
+            let completion;
+            const finish = () => {
+                retired();
+                if (!completion) {
+                    completion = Promise.resolve().then(async () => {
+                        if (jobs) {
+                            try {
+                                if (ownerSignal.aborted)
+                                    await jobs.close(ownerSignal.reason);
+                                else
+                                    await jobs.finish();
+                            }
+                            catch (reason) {
+                                failure ??= { reason };
+                            }
+                        }
+                        if (failure)
+                            throw failure.reason;
+                    });
+                    void completion.catch(() => undefined);
+                }
+                return completion;
+            };
+            try {
+                const signal = registerExecutionCleanup.call(context, async () => {
+                    try {
+                        await retirement;
+                        await finish();
+                    }
+                    finally {
+                        ownerSignal.removeEventListener("abort", retired);
+                    }
+                });
+                if (!(signal instanceof AbortSignal))
+                    throw new TypeError("Execution cleanup must provide its owner cancellation signal");
+                ownerSignal = signal;
+                ownerSignal.addEventListener("abort", retired, { once: true });
+                if (ownerSignal.aborted)
+                    retired();
+                context.registerCleanup(() => { void finish(); });
+                jobs = createJobState({ signal: ownerSignal });
+            }
+            catch (reason) {
+                void finish();
+                throw reason;
+            }
+        },
+        fork: () => instance(latest),
+        checkpoint() { jobs.retireNotified(); },
+        listTerminators: [{ operator: "&", async execute(context) {
+                    let processId;
+                    const handle = await jobs.start(async (task) => {
+                        const child = await context.prepareChild({ ...task, stdin: "async-default" });
+                        processId = child.processId;
+                        return child;
+                    });
+                    children.set(processId, handle);
+                    latest = processId;
+                    return 0;
+                } }],
+        specialParameters: [{ name: "!", lookup: () => latest === undefined ? undefined : String(latest) }],
+    };
+}
+export function jobsExtension() {
+    return {
+        name: "jobs", runtimeIdentity: commandRuntimeIdentity,
+        syntax: { listTerminators: [{ operator: "&" }], specialParameters: [{ name: "!" }] },
+        create: () => instance(),
+    };
+}

package/dist/safe-bash/opt-in/shell/extensions/jobs/state.js

@@ -0,0 +1,374 @@
+class JobRegistry {
+    limits;
+    #records = new Map();
+    #jobs = new Map();
+    #listeners = new Set();
+    #owner;
+    #abortOwner;
+    #accepting = true;
+    #cancelling = false;
+    #finished = false;
+    #waiters = 0;
+    #terminal;
+    constructor(limits, options) {
+        this.limits = limits;
+        this.#owner = options.signal;
+        this.#abortOwner = () => { void this.close(this.#owner.reason).catch(() => { }); };
+        options.registerCleanup?.(() => this.#terminal ?? this.close());
+        if (this.#owner?.aborted)
+            this.#abortOwner();
+        else
+            this.#owner?.addEventListener("abort", this.#abortOwner, { once: true });
+    }
+    async start(prepare) {
+        this.#owner?.throwIfAborted();
+        if (!this.#accepting)
+            throw new Error("job state is closed to admission");
+        if (typeof prepare !== "function")
+            throw new TypeError("job preparation must be a function");
+        if (this.#records.size >= this.limits.maxJobs)
+            throw new Error("job limit exceeded: maxJobs");
+        const occupied = [...this.#records.values()].filter(record => record.state === "preparing" || record.listed && !this.#canRetire(record));
+        const jobId = Math.max(0, ...occupied.map(record => record.handle.jobId)) + 1;
+        if (!Number.isSafeInteger(jobId))
+            throw new Error("job ID exhausted");
+        let complete;
+        const completion = new Promise(resolve => { complete = resolve; });
+        const handle = Object.freeze({ jobId, completion });
+        const record = {
+            handle, complete, controller: new AbortController(), cleanups: [], cleanupFailures: [],
+            listed: false, notified: false, saved: false, state: "preparing",
+        };
+        this.#records.set(handle, record);
+        this.#notify();
+        const context = Object.freeze({
+            signal: record.controller.signal,
+            registerCleanup: (cleanup) => {
+                if (record.cleaning || record.controller.signal.aborted || record.state === "done")
+                    throw new Error("job cleanup admission is closed");
+                if (typeof cleanup !== "function")
+                    throw new TypeError("job cleanup must be a function");
+                if (record.cleanups.length >= this.limits.maxCleanupsPerJob)
+                    throw new Error("job limit exceeded: maxCleanupsPerJob");
+                record.cleanups.push(cleanup);
+            },
+        });
+        let run;
+        let failure;
+        try {
+            const prepared = await prepare(context);
+            if (!record.controller.signal.aborted) {
+                const runner = prepared?.run;
+                if (typeof runner !== "function")
+                    throw new TypeError("job preparation must return a runner");
+                run = () => Reflect.apply(runner, prepared, []);
+            }
+        }
+        catch (reason) {
+            failure = { reason };
+        }
+        if (failure || record.controller.signal.aborted) {
+            await this.#settle(record, failure);
+            this.#forget(record);
+            throw record.outcome.reason;
+        }
+        this.retireNotified();
+        record.listed = true;
+        this.#jobs.set(jobId, record);
+        this.#notify();
+        queueMicrotask(() => { void this.#execute(record, run); });
+        return handle;
+    }
+    async #execute(record, run) {
+        let result = 0;
+        let failure;
+        if (!record.controller.signal.aborted) {
+            record.state = "running";
+            this.#notify();
+            try {
+                result = await run();
+                if (!Number.isInteger(result) || result < 0 || result > 255)
+                    throw new TypeError("job exit status must be an integer from 0 to 255");
+            }
+            catch (reason) {
+                failure = { reason };
+            }
+        }
+        await this.#settle(record, failure, result);
+    }
+    #clean(record) {
+        if (!record.cleaning) {
+            record.cleaning = Promise.resolve().then(async () => {
+                const results = await Promise.allSettled(record.cleanups.map(async (cleanup) => cleanup()));
+                for (const result of results)
+                    if (result.status === "rejected")
+                        record.cleanupFailures.push(result.reason);
+                record.cleanups.length = 0;
+            });
+        }
+        return record.cleaning;
+    }
+    async #settle(record, failure, result = 0) {
+        await this.#clean(record);
+        let outcome;
+        if (this.#owner?.aborted)
+            outcome = { kind: "failure", reason: this.#owner.reason };
+        else if (failure)
+            outcome = { kind: "failure", reason: failure.reason };
+        else if (record.controller.signal.aborted)
+            outcome = { kind: "failure", reason: record.controller.signal.reason };
+        else if (record.cleanupFailures.length)
+            outcome = { kind: "failure", reason: record.cleanupFailures[0] };
+        else
+            outcome = { kind: "status", status: result };
+        record.outcome = Object.freeze(outcome);
+        record.state = "done";
+        record.complete(record.outcome);
+        this.#notify();
+    }
+    #unlist(record) {
+        record.listed = false;
+        if (this.#jobs.get(record.handle.jobId) === record)
+            this.#jobs.delete(record.handle.jobId);
+    }
+    #forget(record) {
+        this.#unlist(record);
+        this.#records.delete(record.handle);
+        this.#notify();
+    }
+    #notify() {
+        for (const listener of [...this.#listeners])
+            listener();
+    }
+    snapshot() {
+        return Object.freeze([...this.#records.values()].map(record => Object.freeze({
+            handle: record.handle, listed: record.listed, notified: record.notified, state: record.state,
+            residency: record.saved ? "saved" : record.notified ? "active-notified" : "active-unnotified",
+            ...(record.outcome === undefined ? {} : { outcome: record.outcome }),
+        })));
+    }
+    #canRetire(record) {
+        return !record.saved && record.state === "done" && record.notified && record.outcome?.kind === "status";
+    }
+    retireNotified() {
+        let changed = false;
+        for (const record of this.#records.values()) {
+            if (this.#canRetire(record)) {
+                record.saved = true;
+                this.#unlist(record);
+                changed = true;
+            }
+        }
+        if (changed)
+            this.#notify();
+    }
+    savedStatus(handle) {
+        const record = this.#records.get(handle);
+        return record?.saved && record.outcome?.kind === "status" ? record.outcome.status : undefined;
+    }
+    #targets(targets) {
+        if (targets === undefined)
+            return undefined;
+        if (!Array.isArray(targets))
+            throw new TypeError("job targets must be an array");
+        if (targets.length === 0)
+            return undefined;
+        if (targets.length > this.limits.maxJobs)
+            throw new Error("job target limit exceeded");
+        const selected = [];
+        for (let index = 0; index < targets.length; index++) {
+            const target = targets[index];
+            if (!target || typeof target !== "object" || Reflect.ownKeys(target).length !== 1)
+                throw new TypeError("invalid job target");
+            if ("jobId" in target && Number.isSafeInteger(target.jobId) && target.jobId > 0)
+                selected.push(Object.freeze({ jobId: target.jobId }));
+            else if ("handle" in target && target.handle && typeof target.handle === "object")
+                selected.push(Object.freeze({ handle: target.handle }));
+            else
+                throw new TypeError("invalid job target");
+        }
+        return selected;
+    }
+    #lookup(target) {
+        return "handle" in target ? this.#records.get(target.handle) : this.#jobs.get(target.jobId);
+    }
+    #waitSignal(options) {
+        if (!options || typeof options !== "object" || Reflect.ownKeys(options).some(key => key !== "signal"))
+            throw new TypeError("invalid job wait options");
+        if (options.signal !== undefined && !(options.signal instanceof AbortSignal))
+            throw new TypeError("invalid job wait signal");
+        options.signal?.throwIfAborted();
+        return options.signal;
+    }
+    #changed(signal) {
+        return new Promise((resolve, reject) => {
+            const cleanup = () => { this.#listeners.delete(changed); signal?.removeEventListener("abort", aborted); };
+            const changed = () => { cleanup(); resolve(); };
+            const aborted = () => { cleanup(); reject(signal.reason); };
+            this.#listeners.add(changed);
+            if (signal?.aborted)
+                aborted();
+            else
+                signal?.addEventListener("abort", aborted, { once: true });
+        });
+    }
+    async wait(targets, options = {}) {
+        const selected = this.#targets(targets);
+        const signal = this.#waitSignal(options);
+        if (this.#waiters >= this.limits.maxWaiters)
+            throw new Error("job limit exceeded: maxWaiters");
+        this.#waiters++;
+        const unknown = [];
+        let outcome = Object.freeze({ kind: "status", status: 0 });
+        let failure;
+        try {
+            if (selected === undefined) {
+                const records = [...this.#records.values()];
+                for (const record of records) {
+                    while (record.state !== "done") {
+                        signal?.throwIfAborted();
+                        await this.#changed(signal);
+                    }
+                    if (record.outcome.kind === "failure")
+                        failure ??= record.outcome;
+                }
+                signal?.throwIfAborted();
+                for (const record of records)
+                    this.#forget(record);
+            }
+            else
+                for (const target of selected) {
+                    signal?.throwIfAborted();
+                    const record = this.#lookup(target);
+                    if (!record) {
+                        unknown.push(target);
+                        outcome = Object.freeze({ kind: "status", status: 127 });
+                        continue;
+                    }
+                    while (record.state !== "done") {
+                        signal?.throwIfAborted();
+                        await this.#changed(signal);
+                    }
+                    signal?.throwIfAborted();
+                    if (!record.saved)
+                        this.retireNotified();
+                    record.notified = true;
+                    if ("handle" in target)
+                        this.#unlist(record);
+                    outcome = record.outcome;
+                    if (outcome.kind === "failure")
+                        failure ??= outcome;
+                    this.#notify();
+                }
+            return Object.freeze({ outcome: failure ?? outcome, unknown: Object.freeze(unknown) });
+        }
+        finally {
+            this.#waiters--;
+        }
+    }
+    async waitNext(targets, options = {}) {
+        const selected = this.#targets(targets);
+        const signal = this.#waitSignal(options);
+        if (this.#waiters >= this.limits.maxWaiters)
+            throw new Error("job limit exceeded: maxWaiters");
+        this.#waiters++;
+        const unknown = [];
+        const records = new Set();
+        if (selected === undefined) {
+            for (const record of this.#records.values())
+                if (!record.saved)
+                    records.add(record);
+        }
+        else
+            for (const target of selected) {
+                const record = this.#lookup(target);
+                if (!record || record.saved)
+                    unknown.push(target);
+                else
+                    records.add(record);
+            }
+        try {
+            for (;;) {
+                signal?.throwIfAborted();
+                const eligible = [...records].filter(record => !record.saved && !record.notified).sort((first, second) => first.handle.jobId - second.handle.jobId);
+                const ready = eligible.find(record => record.state === "done");
+                if (ready) {
+                    ready.notified = true;
+                    ready.saved = ready.outcome.kind === "status";
+                    this.#unlist(ready);
+                    this.#notify();
+                    return Object.freeze({ outcome: ready.outcome, handle: ready.handle, unknown: Object.freeze(unknown) });
+                }
+                if (!eligible.length)
+                    return Object.freeze({ outcome: Object.freeze({ kind: "status", status: 127 }), unknown: Object.freeze(unknown) });
+                await this.#changed(signal);
+            }
+        }
+        finally {
+            this.#waiters--;
+        }
+    }
+    finish() {
+        this.#accepting = false;
+        return this.#drain();
+    }
+    close(reason = new Error("job state closed")) {
+        this.#accepting = false;
+        if (!this.#finished && !this.#cancelling) {
+            this.#cancelling = true;
+            for (const record of this.#records.values())
+                if (record.state !== "done") {
+                    record.controller.abort(reason);
+                    void this.#clean(record);
+                }
+        }
+        return this.#drain();
+    }
+    #drain() {
+        if (!this.#terminal) {
+            const records = [...this.#records.values()];
+            this.#terminal = (async () => {
+                try {
+                    await Promise.all(records.map(record => record.handle.completion));
+                    if (!this.#cancelling) {
+                        const failure = records.find(record => record.outcome?.kind === "failure");
+                        if (failure?.outcome?.kind === "failure")
+                            throw failure.outcome.reason;
+                    }
+                    const errors = records.flatMap(record => record.cleanupFailures);
+                    if (errors.length)
+                        throw new AggregateError(errors, "job cleanup failed");
+                }
+                finally {
+                    this.#finished = true;
+                    this.#owner?.removeEventListener("abort", this.#abortOwner);
+                }
+            })();
+            void this.#terminal.catch(() => { });
+        }
+        return this.#terminal;
+    }
+}
+export function createJobState(options = {}) {
+    if (!options || typeof options !== "object" || Array.isArray(options))
+        throw new TypeError("invalid job options");
+    const limits = { maxJobs: 256, maxWaiters: 64, maxCleanupsPerJob: 64 };
+    for (const key of Reflect.ownKeys(options)) {
+        if (key === "signal" || key === "registerCleanup")
+            continue;
+        if (typeof key !== "string" || !Object.hasOwn(limits, key))
+            throw new TypeError("unknown job option");
+        const name = key;
+        const value = options[name];
+        if (value === undefined)
+            continue;
+        if (!Number.isSafeInteger(value) || value < 1 || value > limits[name])
+            throw new TypeError(`invalid job limit: ${key}`);
+        limits[name] = value;
+    }
+    if (options.signal !== undefined && !(options.signal instanceof AbortSignal))
+        throw new TypeError("invalid job owner signal");
+    if (options.registerCleanup !== undefined && typeof options.registerCleanup !== "function")
+        throw new TypeError("invalid job owner cleanup registration");
+    return new JobRegistry(Object.freeze(limits), options);
+}

package/dist/safe-bash/opt-in/shell/extensions/mapfile/index.d.ts

@@ -0,0 +1,24 @@
+import { type ShellValue } from "@poe-platform/safe-bash/contracts/value";
+import type { ShellExtension } from "@poe-platform/safe-bash/optional-host";
+export interface MapfileOptions {
+    array: string;
+    clear: boolean;
+    count: number;
+    delimiter: number;
+    descriptor: number;
+    origin: number;
+    quantum: number;
+    skip: number;
+    trim: boolean;
+    callback?: ShellValue;
+}
+export declare class MapfileArgumentError extends Error {
+    readonly detail: ShellValue;
+    readonly status: number;
+    readonly usage: boolean;
+    constructor(detail: ShellValue, status: number, usage?: boolean);
+}
+export declare function parseMapfileArguments(args: readonly ShellValue[], selectDescriptor: (descriptor: number) => Promise<void>): Promise<MapfileOptions | "help">;
+export declare function mapfileExtension(options?: {
+    readonly replace?: boolean;
+}): ShellExtension;