@cortexkit/antigravity-auth-core 2.2.1 → 3.0.0

package/dist/common-auth-embedded/commands/pi.js

@@ -0,0 +1,206 @@
+// The Pi renderer: walks the same menu model the OpenCode dialog draws, with
+// Pi's extension UI (`select`, `confirm`, `input`, `notify`). It sees only the
+// payloads the menu's seam produces, and applies actions through the menu,
+// so the confirmation and input checks are the same as on OpenCode.
+/**
+ * Shows `entries` with `select` and returns the chosen value. Labels are made
+ * unique, since `select` answers with the label.
+ */
+async function pick(ui, title, entries) {
+    const byLabel = new Map();
+    const labels = [];
+    for (const entry of entries) {
+        let label = entry.label;
+        for (let n = 2; byLabel.has(label); n++)
+            label = `${entry.label} (${n})`;
+        byLabel.set(label, entry.value);
+        labels.push(label);
+    }
+    const chosen = await ui.select(title, labels);
+    return chosen === undefined ? undefined : byLabel.get(chosen);
+}
+function withLines(title, lines) {
+    return lines.length > 0 ? `${title}\n${lines.join('\n')}` : title;
+}
+/** A row as one line of text: its label, then its status when it has one. */
+function rowText(item) {
+    return item.status ? `${item.label} · ${item.status}` : item.label;
+}
+/**
+ * The read-only part of a section's select title: its lines, then each item
+ * that has no actions, under its group's header. Such an item does nothing
+ * when chosen, so it is shown as text rather than offered as an option. Pi's
+ * `select` cannot put text between options, so the headers of groups whose
+ * rows are all selectable are not shown.
+ */
+function sectionText(section) {
+    const text = [...section.lines];
+    let header;
+    for (const item of section.items) {
+        if (item.actions.length > 0)
+            continue;
+        if (item.group !== undefined && item.group !== header)
+            text.push(item.group);
+        header = item.group;
+        text.push(item.group !== undefined ? `  ${rowText(item)}` : rowText(item));
+    }
+    return text;
+}
+function itemTitle(item) {
+    const lines = item.detail ? [item.detail] : [];
+    for (const [name, value] of Object.entries(item.facts ?? {}))
+        lines.push(`${name}: ${String(value)}`);
+    return withLines(rowText(item), lines);
+}
+/** One knob's value, or undefined when the user backed out or typed nonsense. */
+async function askKnob(ui, knob) {
+    switch (knob.kind) {
+        case 'choice': {
+            const value = await pick(ui, knob.label, knob.choices.map((choice) => ({
+                label: choice.value === knob.value
+                    ? `${choice.label} (current)`
+                    : choice.label,
+                value: choice.value,
+            })));
+            return value === undefined ? undefined : { value };
+        }
+        case 'toggle': {
+            const value = await pick(ui, knob.label, [
+                { label: knob.value ? 'On (current)' : 'On', value: true },
+                { label: knob.value ? 'Off' : 'Off (current)', value: false },
+            ]);
+            return value === undefined ? undefined : { value };
+        }
+        case 'number': {
+            const range = knob.min !== undefined && knob.max !== undefined
+                ? ` (${knob.min}-${knob.max}${knob.required ? '' : ', empty clears'})`
+                : knob.required
+                    ? ''
+                    : ' (empty clears)';
+            const typed = await ui.input(`${knob.label}${range}`, knob.value !== undefined ? String(knob.value) : undefined);
+            if (typed === undefined)
+                return undefined;
+            const text = typed.trim();
+            if (text === '')
+                return knob.required && knob.value !== undefined
+                    ? { value: knob.value }
+                    : { value: null };
+            const number = Number(text);
+            if (!Number.isFinite(number)) {
+                ui.notify(`${knob.label} needs a number.`, 'error');
+                return undefined;
+            }
+            return { value: number };
+        }
+        case 'text': {
+            const typed = await ui.input(knob.label, knob.value ?? knob.placeholder);
+            if (typed === undefined)
+                return undefined;
+            const text = typed.trim();
+            if (text === '')
+                return knob.required && knob.value !== undefined
+                    ? { value: knob.value }
+                    : { value: null };
+            return { value: text };
+        }
+    }
+}
+async function askValues(ui, action) {
+    const values = {};
+    for (const knob of action.knobs) {
+        const answer = await askKnob(ui, knob);
+        if (!answer)
+            return undefined;
+        values[knob.id] = answer.value;
+    }
+    return values;
+}
+/**
+ * Runs one invocation of the slash command on Pi: sections, then an item or
+ * a section action, then the action's inputs and confirmation; after each
+ * apply the user is back in the same section with the refreshed menu. Each
+ * section's list ends with Back, which returns to the section list; backing
+ * out of the section list ends the invocation.
+ */
+export async function runPiCommandMenu(menu, ui, options = {}) {
+    const invocation = {
+        ...(options.sessionId !== undefined
+            ? { sessionId: options.sessionId }
+            : {}),
+        notify: (message, kind) => ui.notify(message, kind),
+    };
+    let model = (await menu.open(invocation)).menu;
+    for (;;) {
+        const chosen = await pick(ui, model.title, model.sections.map((section) => ({
+            label: section.lines[0]
+                ? `${section.title}: ${section.lines[0]}`
+                : section.title,
+            value: section.id,
+        })));
+        if (chosen === undefined)
+            return;
+        for (;;) {
+            const section = model.sections.find((entry) => entry.id === chosen);
+            if (!section)
+                break;
+            // Only rows that do something are options; the rest is title text.
+            const entries = [
+                ...section.items
+                    .filter((item) => item.actions.length > 0)
+                    .map((item) => ({
+                    label: rowText(item),
+                    value: { kind: 'item', item },
+                })),
+                ...section.actions.map((action) => ({
+                    label: action.label,
+                    value: { kind: 'action', action },
+                })),
+            ];
+            const text = sectionText(section);
+            if (entries.length === 0 && text.length === 0) {
+                ui.notify('Nothing to do here.');
+                break;
+            }
+            const choice = await pick(ui, withLines(section.title, text), [
+                ...entries,
+                { label: 'Back', value: { kind: 'back' } },
+            ]);
+            if (!choice || choice.kind === 'back')
+                break;
+            let action;
+            let item;
+            if (choice.kind === 'item') {
+                item = choice.item;
+                action = await pick(ui, itemTitle(item), item.actions.map((entry) => ({ label: entry.label, value: entry })));
+                if (!action)
+                    continue;
+            }
+            else {
+                action = choice.action;
+            }
+            const values = await askValues(ui, action);
+            if (!values)
+                continue;
+            if (action.confirm) {
+                const yes = await ui.confirm(action.label, action.confirm.message);
+                if (!yes) {
+                    ui.notify('Cancelled.');
+                    continue;
+                }
+            }
+            const result = await menu.apply({
+                command: model.command,
+                sectionId: section.id,
+                ...(item ? { itemId: item.id } : {}),
+                actionId: action.id,
+                values,
+                ...(action.confirm ? { confirmed: true } : {}),
+                ...(options.sessionId !== undefined
+                    ? { sessionId: options.sessionId }
+                    : {}),
+            }, invocation);
+            ui.notify(result.text, result.ok ? 'info' : 'error');
+            model = result.menu;
+        }
+    }
+}

package/dist/common-auth-embedded/commands/seam.d.ts

@@ -0,0 +1,72 @@
+import { type RedactionOptions } from '../logger/index.js';
+import type { ActionDefinition, CommandApplyResult, CommandDialogPayload, ItemDefinition, MenuAccount, MenuConfirmation, SectionContent, SectionSlot } from './model.js';
+/** Where a dropped field is reported. Names only, never values. */
+export interface SeamLogger {
+    warn(message: string, data?: unknown): void;
+}
+/** Masks the secret-shaped parts of one string. */
+export type TextRedactor = (text: string) => string;
+/** The string redactor every value crossing the seam goes through. */
+export declare function createTextRedactor(options?: RedactionOptions): TextRedactor;
+/**
+ * A failure whose message was written for the user. An action throws it to
+ * show `message` with the stable `code`; any other thrown value is shown only
+ * as a generic message, because its text may quote a request, a response or
+ * a credential. `code` is lowercase letters, digits and dashes; anything else
+ * is reported as `action-failed`.
+ */
+export declare class CommandError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string, options?: {
+        cause?: unknown;
+    });
+}
+/** What a failed action shows: a stable code and a message safe to display. */
+export interface ProjectedFailure {
+    code: string;
+    text: string;
+}
+/** The code and message shown for an exception the seam cannot vouch for. */
+export declare const ACTION_FAILED: ProjectedFailure;
+/** The code and display text for a thrown value; never its raw text. */
+export declare function projectFailure(error: unknown): ProjectedFailure;
+/** A built-in item may carry the account it shows; plugin items cannot. */
+export interface ResolvedItem extends ItemDefinition {
+    account?: MenuAccount;
+}
+/** A section with its bodies, as the menu holds it between builds. */
+export interface ResolvedSection {
+    id: string;
+    slot: SectionSlot;
+    title: string;
+    content: Omit<SectionContent, 'items'> & {
+        items?: ResolvedItem[];
+    };
+}
+/** The confirmation shown when an irreversible action names none. */
+export declare const DEFAULT_IRREVERSIBLE_CONFIRMATION = "This cannot be undone. Continue?";
+/** What every payload builder needs besides the payload itself. */
+export interface SeamContext {
+    logger: SeamLogger;
+    redact: TextRedactor;
+}
+/**
+ * The confirmation an action must pass before it runs, or undefined. An
+ * irreversible action always has one, even when its definition (built
+ * outside the type checker) names none.
+ */
+export declare function confirmationOf(action: ActionDefinition): MenuConfirmation | undefined;
+/** The account fields a renderer may show; see `MenuAccount`. */
+export declare function projectAccount(account: MenuAccount): MenuAccount;
+/** The payload a host's TUI receives when the slash command opens. */
+export declare function dialogPayload(command: string, title: string, sections: readonly ResolvedSection[], seam: SeamContext): CommandDialogPayload;
+/** How an apply ended, before the seam turns it into a payload. */
+export interface ApplyOutcome {
+    ok: boolean;
+    text: string;
+    /** Present on every failure. */
+    code?: string;
+    needsConfirmation?: boolean;
+}
+/** An apply's result: the message and the refreshed menu. */
+export declare function applyResult(command: string, title: string, sections: readonly ResolvedSection[], outcome: ApplyOutcome, seam: SeamContext): CommandApplyResult;

package/dist/common-auth-embedded/commands/seam.js

@@ -0,0 +1,301 @@
+// The one way out of the process for anything the command menu shows. Every
+// payload a renderer receives (the dialog payload and every apply result) is
+// produced here: each part is projected field by field from its definition,
+// so action bodies and stray properties never travel, and the whole payload
+// is then scrubbed as a backstop: credential-shaped property names are
+// dropped and every string value is passed through the redactor. Nothing
+// outside this module can build a payload without passing through
+// `dialogPayload` or `applyResult`. A failed action never shows its raw
+// exception text: `projectFailure` turns it into a stable code and a message
+// the library or the plugin wrote for the user.
+import { createRedactor } from '../logger/index.js';
+import { PoolOperationError } from '../store/index.js';
+/**
+ * Secret shapes the seam masks on top of the logger's (bearer tokens, `sk-`
+ * keys, JWTs, vault host tokens): a value assigned to a secret-named field
+ * (`client_secret=…`, `"api_key": "…"`, `Authorization: …`), and a run of 32
+ * or more hex digits, the shape of a minted request secret. A plugin adds its
+ * provider's key shapes through `RedactionOptions.extraValuePatterns`.
+ */
+const SEAM_VALUE_PATTERNS = [
+    /\b[\w-]*(?:secret|token|password|passwd|api[_-]?key|authorization|verifier)["']?\s*[:=]\s*["']?(?:(?:Bearer|Basic)\s+)?[^\s"'&,;}]+/gi,
+    /\b[0-9a-fA-F]{32,}\b/g,
+];
+/** The string redactor every value crossing the seam goes through. */
+export function createTextRedactor(options = {}) {
+    const { redactStrings } = createRedactor({
+        ...options,
+        extraValuePatterns: [
+            ...SEAM_VALUE_PATTERNS,
+            ...(options.extraValuePatterns ?? []),
+        ],
+    });
+    return (text) => redactStrings(text);
+}
+/**
+ * A failure whose message was written for the user. An action throws it to
+ * show `message` with the stable `code`; any other thrown value is shown only
+ * as a generic message, because its text may quote a request, a response or
+ * a credential. `code` is lowercase letters, digits and dashes; anything else
+ * is reported as `action-failed`.
+ */
+export class CommandError extends Error {
+    code;
+    constructor(code, message, options) {
+        super(message, options);
+        this.name = 'CommandError';
+        this.code = code;
+    }
+}
+const CODE_SHAPE = /^[a-z][a-z0-9-]{0,63}$/;
+/** The code and message shown for an exception the seam cannot vouch for. */
+export const ACTION_FAILED = {
+    code: 'action-failed',
+    text: 'That action failed.',
+};
+/**
+ * Store failure kinds whose message the store composes itself from row ids
+ * and the plugin's own refusal reasons (`protect`). Other kinds can carry a
+ * lock or filesystem error's text, or an arbitrary exception from a hook, so
+ * they show a generic message with the kind as the code.
+ */
+const STORE_KINDS_WITH_OWN_MESSAGE = new Set([
+    'unknown-row',
+    'invalid-row',
+    'invalid-input',
+    'id-exists',
+    'id-removed',
+    'type-mismatch',
+    'no-credential',
+    'row-disabled',
+    'row-protected',
+    'duplicate-identity',
+    'row-key-changed',
+    'invalid-order',
+    'pending-migration',
+    'provider',
+    'pull',
+    'attribution',
+]);
+/** The code and display text for a thrown value; never its raw text. */
+export function projectFailure(error) {
+    if (error instanceof CommandError)
+        return {
+            code: CODE_SHAPE.test(error.code) ? error.code : ACTION_FAILED.code,
+            text: error.message,
+        };
+    if (error instanceof PoolOperationError)
+        return {
+            code: `pool-${error.kind}`,
+            text: STORE_KINDS_WITH_OWN_MESSAGE.has(error.kind)
+                ? error.message
+                : `The account pool could not do that (${error.kind}).`,
+        };
+    return ACTION_FAILED;
+}
+/** The confirmation shown when an irreversible action names none. */
+export const DEFAULT_IRREVERSIBLE_CONFIRMATION = 'This cannot be undone. Continue?';
+const CREDENTIAL_NAMES = new Set([
+    'access',
+    'refresh',
+    'apikey',
+    'password',
+    'authheader',
+    'credential',
+    'credentials',
+]);
+/**
+ * True for a property name that looks like it holds a secret. Case, `-` and
+ * `_` are ignored, so `api_key`, `API-Key` and `apiKey` all match. Any name
+ * ending in `token`, `key` or `secret` matches: no menu field is named that
+ * way, so a match is a leak whatever the rest of the name says.
+ */
+function isCredentialName(name) {
+    const normalized = name.toLowerCase().replace(/[-_]/g, '');
+    return (CREDENTIAL_NAMES.has(normalized) ||
+        normalized.endsWith('token') ||
+        normalized.endsWith('key') ||
+        normalized.endsWith('secret'));
+}
+function isPlainRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+/**
+ * A copy of `value` without credential-shaped properties and with every
+ * string redacted; the paths of both go to `report`.
+ */
+function scrub(value, path, report) {
+    if (typeof value === 'string') {
+        const clean = report.redact(value);
+        if (clean !== value)
+            report.redacted.push(path);
+        return clean;
+    }
+    if (Array.isArray(value))
+        return value.map((entry, index) => scrub(entry, `${path}[${index}]`, report));
+    if (!isPlainRecord(value))
+        return value;
+    const out = {};
+    for (const [name, entry] of Object.entries(value)) {
+        if (isCredentialName(name)) {
+            report.dropped.push(`${path}.${name}`);
+            continue;
+        }
+        Object.defineProperty(out, name, {
+            value: scrub(entry, `${path}.${name}`, report),
+            enumerable: true,
+            writable: true,
+            configurable: true,
+        });
+    }
+    return out;
+}
+function sealed(payload, command, seam) {
+    const report = {
+        redact: seam.redact,
+        dropped: [],
+        redacted: [],
+    };
+    const clean = scrub(payload, 'payload', report);
+    if (report.dropped.length > 0)
+        seam.logger.warn('credential-shaped field dropped from a command payload', {
+            command,
+            fields: report.dropped,
+        });
+    if (report.redacted.length > 0)
+        seam.logger.warn('secret-shaped text masked in a command payload', {
+            command,
+            fields: report.redacted,
+        });
+    return clean;
+}
+function projectChoice(choice) {
+    return { value: String(choice.value), label: String(choice.label) };
+}
+function projectKnob(knob) {
+    switch (knob.kind) {
+        case 'choice':
+            return {
+                kind: 'choice',
+                id: knob.id,
+                label: knob.label,
+                choices: (knob.choices ?? []).map(projectChoice),
+                ...(knob.value !== undefined ? { value: knob.value } : {}),
+            };
+        case 'toggle':
+            return {
+                kind: 'toggle',
+                id: knob.id,
+                label: knob.label,
+                value: knob.value === true,
+            };
+        case 'number':
+            return {
+                kind: 'number',
+                id: knob.id,
+                label: knob.label,
+                ...(knob.value !== undefined ? { value: knob.value } : {}),
+                ...(knob.min !== undefined ? { min: knob.min } : {}),
+                ...(knob.max !== undefined ? { max: knob.max } : {}),
+                ...(knob.required ? { required: true } : {}),
+            };
+        case 'text':
+            // A masked input holds a secret, so its current value is never shown;
+            // the action still receives it when the user leaves the input alone.
+            return {
+                kind: 'text',
+                id: knob.id,
+                label: knob.label,
+                ...(knob.value !== undefined && !knob.masked
+                    ? { value: knob.value }
+                    : {}),
+                ...(knob.placeholder !== undefined
+                    ? { placeholder: knob.placeholder }
+                    : {}),
+                ...(knob.masked ? { masked: true } : {}),
+                ...(knob.required ? { required: true } : {}),
+            };
+    }
+}
+/**
+ * The confirmation an action must pass before it runs, or undefined. An
+ * irreversible action always has one, even when its definition (built
+ * outside the type checker) names none.
+ */
+export function confirmationOf(action) {
+    if (action.irreversible === true)
+        return {
+            message: action.confirm || DEFAULT_IRREVERSIBLE_CONFIRMATION,
+            irreversible: true,
+        };
+    if (action.confirm)
+        return { message: action.confirm, irreversible: false };
+    return undefined;
+}
+function projectAction(action) {
+    const confirm = confirmationOf(action);
+    return {
+        id: action.id,
+        label: action.label,
+        ...(action.description !== undefined
+            ? { description: action.description }
+            : {}),
+        ...(action.group !== undefined ? { group: String(action.group) } : {}),
+        knobs: (action.knobs ?? []).map(projectKnob),
+        ...(confirm ? { confirm } : {}),
+    };
+}
+/** The account fields a renderer may show; see `MenuAccount`. */
+export function projectAccount(account) {
+    return {
+        id: account.id,
+        ...(account.label !== undefined ? { label: account.label } : {}),
+        enabled: account.enabled,
+        type: account.type,
+        ...(account.identity !== undefined ? { identity: account.identity } : {}),
+    };
+}
+function projectItem(item) {
+    return {
+        id: item.id,
+        label: item.label,
+        ...(item.detail !== undefined ? { detail: item.detail } : {}),
+        ...(item.group !== undefined ? { group: String(item.group) } : {}),
+        ...(item.status !== undefined ? { status: String(item.status) } : {}),
+        ...(item.account ? { account: projectAccount(item.account) } : {}),
+        ...(item.facts !== undefined ? { facts: item.facts } : {}),
+        actions: (item.actions ?? []).map(projectAction),
+    };
+}
+function projectSection(section) {
+    const { content } = section;
+    return {
+        id: section.id,
+        slot: section.slot,
+        title: section.title,
+        lines: (content.lines ?? []).map(String),
+        items: (content.items ?? []).map(projectItem),
+        actions: (content.actions ?? []).map(projectAction),
+        ...(content.facts !== undefined ? { facts: content.facts } : {}),
+    };
+}
+function projectMenu(command, title, sections) {
+    return { command, title, sections: sections.map(projectSection) };
+}
+/** The payload a host's TUI receives when the slash command opens. */
+export function dialogPayload(command, title, sections, seam) {
+    return sealed({ command, menu: projectMenu(command, title, sections) }, command, seam);
+}
+/** An apply's result: the message and the refreshed menu. */
+export function applyResult(command, title, sections, outcome, seam) {
+    return sealed({
+        command,
+        ok: outcome.ok,
+        text: String(outcome.text),
+        ...(!outcome.ok && outcome.code !== undefined
+            ? { code: CODE_SHAPE.test(outcome.code) ? outcome.code : 'refused' }
+            : {}),
+        ...(outcome.needsConfirmation ? { needsConfirmation: true } : {}),
+        menu: projectMenu(command, title, sections),
+    }, command, seam);
+}

package/dist/common-auth-embedded/fs/atomic-write.d.ts

@@ -0,0 +1,20 @@
+export interface AtomicWriteOptions {
+    serialize?: (value: unknown) => string;
+    beforeRename?: () => Promise<void>;
+    /** Test seam for forcing staging-name collisions; defaults to randomUUID. */
+    stageName?: () => string;
+    /** Sync the staged file and, after rename, its parent directory. Opt-in. */
+    durable?: boolean;
+}
+/** Internal classification of fsync failures, including a failure after rename. */
+export declare class AtomicSyncError extends Error {
+    constructor(cause: unknown);
+}
+export declare function writeJsonAtomic(path: string, value: unknown, options?: AtomicWriteOptions): Promise<void>;
+/**
+ * Notify internal callers at the rename. The store records committed writes
+ * and removed ids here, because a later directory sync cannot undo the rename.
+ */
+export declare function writeJsonAtomicTracked(path: string, value: unknown, options: AtomicWriteOptions, onRenamed?: () => void): Promise<void>;
+/** Make an already renamed file and its directory durable without rewriting bytes. */
+export declare function syncJsonFile(path: string): Promise<void>;

package/dist/common-auth-embedded/fs/atomic-write.js

@@ -0,0 +1,80 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, open, rename, rm } from 'node:fs/promises';
+import { dirname } from 'node:path';
+/** Internal classification of fsync failures, including a failure after rename. */
+export class AtomicSyncError extends Error {
+    constructor(cause) {
+        super('file or directory sync failed', { cause });
+        this.name = 'AtomicSyncError';
+    }
+}
+export async function writeJsonAtomic(path, value, options = {}) {
+    await writeJsonAtomicTracked(path, value, options);
+}
+/**
+ * Notify internal callers at the rename. The store records committed writes
+ * and removed ids here, because a later directory sync cannot undo the rename.
+ */
+export async function writeJsonAtomicTracked(path, value, options, onRenamed) {
+    await mkdir(dirname(path), { recursive: true });
+    const tempPath = `${path}.${(options.stageName ?? randomUUID)()}.tmp`;
+    let handle;
+    let created = false;
+    try {
+        handle = await open(tempPath, 'wx', 0o600);
+        created = true;
+        await handle.writeFile(options.serialize
+            ? options.serialize(value)
+            : `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+        await handle.chmod(0o600);
+        if (options.durable) {
+            try {
+                await handle.sync();
+            }
+            catch (cause) {
+                throw new AtomicSyncError(cause);
+            }
+        }
+        await handle.close();
+        handle = undefined;
+        await options.beforeRename?.();
+        await rename(tempPath, path);
+        created = false;
+        onRenamed?.();
+        if (options.durable) {
+            const directory = await open(dirname(path), 'r');
+            try {
+                await directory.sync();
+            }
+            catch (cause) {
+                throw new AtomicSyncError(cause);
+            }
+            finally {
+                await directory.close();
+            }
+        }
+    }
+    finally {
+        await handle?.close().catch(() => { });
+        // A failed write can leave partial bytes, but a collision is not ours to remove.
+        if (created)
+            await rm(tempPath, { force: true }).catch(() => { });
+    }
+}
+/** Make an already renamed file and its directory durable without rewriting bytes. */
+export async function syncJsonFile(path) {
+    const file = await open(path, 'r');
+    try {
+        await file.sync();
+    }
+    finally {
+        await file.close();
+    }
+    const directory = await open(dirname(path), 'r');
+    try {
+        await directory.sync();
+    }
+    finally {
+        await directory.close();
+    }
+}

package/dist/common-auth-embedded/fs/index.d.ts

@@ -0,0 +1,7 @@
+export type { AtomicWriteOptions } from './atomic-write.js';
+export { writeJsonAtomic } from './atomic-write.js';
+export { WRITER_LOCK_CONSTANTS } from './lock-constants.js';
+export type { LockLoss, RefreshFileLock } from './refresh-file-lock.js';
+export { acquireRefreshFileLock, isLostMarkerRaceError, } from './refresh-file-lock.js';
+export type { LockOptions, LockOwnershipDetails } from './with-lock.js';
+export { LockContentionError, LockOwnershipError, lockPathFor, withLock, } from './with-lock.js';