opencode-courier 0.2.3 → 0.4.0

package/dist/courier.d.ts

@@ -1,95 +0,0 @@
-import type { Plugin } from "@opencode/plugin";
-import { type Prompt } from "./notices.js";
-import { type RosterStorage } from "./roster.js";
-type Context = Plugin.Context;
-/** The slice of the plugin context the courier tools use; tests pass a fake. */
-export interface CourierPorts {
-    readonly session: Pick<Context["session"], "create" | "prompt" | "synthetic" | "get" | "context">;
-    readonly agent: Pick<Context["agent"], "get">;
-    readonly worktree: Pick<Context["worktree"], "create" | "remove">;
-    /** The project of the plugin's location; an isolated child's worktree is made in it, and removed from it. */
-    readonly projectID: string;
-    /** The commit a directory's checkout is on, or undefined; recorded as an isolated child's base. */
-    readonly head: (directory: string) => Promise<string | undefined>;
-    readonly storage: RosterStorage;
-    readonly directory: string;
-    readonly now: () => number;
-    /** The permission requests and questions a session waits on, wherever they are pending. */
-    readonly pending: (sessionID: string) => Promise<ReadonlyArray<Pending>>;
-}
-/** A request a session waits on until someone answers it: a permission request, or a question it asked. */
-export type Pending = {
-    readonly type: "permission";
-    readonly requestID: string;
-    readonly action: string;
-    readonly resources: ReadonlyArray<string>;
-    readonly save?: ReadonlyArray<string>;
-} | {
-    readonly type: "question";
-    readonly requestID: string;
-    readonly questions: ReadonlyArray<Prompt>;
-    /** Its question call was cut off; the answer reaches it as a message. */
-    readonly stopped?: true;
-};
-export interface SpawnInput {
-    readonly task: string;
-    readonly title?: string;
-    readonly agent?: string;
-    readonly isolate?: boolean;
-}
-export interface SendInput {
-    readonly sessionID: string;
-    readonly message: string;
-    readonly queue?: boolean;
-}
-export interface StatusInput {
-    readonly sessionID: string;
-}
-export interface ChildrenInput {
-    readonly sessionID?: string;
-}
-/** Creates a child session, hands it the task and returns at once; the child reports back with courier_send. */
-export declare function spawn(ports: CourierPorts, parentID: string, input: SpawnInput): Promise<{
-    rosterError?: string | undefined;
-    sessionID: string;
-    directory: string;
-}>;
-/** Drops a message into another session's inbox; OpenCode wakes that session if it is idle. */
-export declare function send(ports: CourierPorts, from: string, input: SendInput): Promise<{
-    messageID: string;
-}>;
-/** A one-off look at a session, for check-ins; not meant to be called in a loop. */
-export declare function status(ports: CourierPorts, input: StatusInput): Promise<Partial<{
-    sessionID: string;
-    title: string | undefined;
-    parentID: string | undefined;
-    outcome: "failed" | "succeeded" | "interrupted" | undefined;
-    updated: number;
-    idle: number | undefined;
-    lastText: string | undefined;
-    pending: readonly Pending[] | undefined;
-}>>;
-/** The sessions a parent started, each with what courier_status reports, or the error it gave. */
-export declare function listChildren(ports: CourierPorts, parentID: string): Promise<({
-    directory: string;
-    isolated: boolean;
-    created: number;
-    sessionID?: string | undefined;
-    title?: string | undefined;
-    parentID?: string | undefined;
-    outcome?: "failed" | "succeeded" | "interrupted" | undefined;
-    updated?: number | undefined;
-    idle?: number | undefined;
-    lastText?: string | undefined;
-    pending?: readonly Pending[] | undefined;
-} | {
-    error: string;
-    directory: string;
-    isolated: boolean;
-    created: number;
-    sessionID: string;
-    title: string;
-})[]>;
-/** A readable message for a failed courier call; OpenCode's own errors can carry an empty message. */
-export declare function describeFailure(tool: string, error: unknown): Error;
-export {};

package/dist/courier.js

@@ -1,131 +0,0 @@
-import { childBrief, envelope } from "./notices.js";
-import { current, record } from "./roster.js";
-function titleOf(task) {
-    const line = task.trim().split("\n")[0] ?? "";
-    return line.length > 60 ? `${line.slice(0, 57)}...` : line;
-}
-/**
- * The model a child runs on: its parent's, so it does not fall back to OpenCode's default, which
- * the parent may have been moved off for a reason. An agent that names its own model keeps it.
- */
-async function inheritedModel(ports, parentID, agent) {
-    const parent = await ports.session.get({ sessionID: parentID });
-    if (!parent.model || !agent)
-        return parent.model;
-    const named = await ports.agent.get({ agentID: agent, location: { directory: ports.directory } });
-    return named.data.model ? undefined : parent.model;
-}
-/** Removes a worktree made for a child that was never created; one that cannot be removed stays. */
-async function dropWorktree(ports, directory) {
-    try {
-        await ports.worktree.remove({ projectID: ports.projectID, directory, force: false });
-    }
-    catch {
-        // The spawn's own failure is the one to report.
-    }
-}
-/** Creates a child session, hands it the task and returns at once; the child reports back with courier_send. */
-export async function spawn(ports, parentID, input) {
-    // A failed lookup must not keep the child from starting; it then runs on OpenCode's default.
-    const model = await inheritedModel(ports, parentID, input.agent).catch(() => undefined);
-    const directory = input.isolate
-        ? (await ports.worktree.create({ projectID: ports.projectID })).directory
-        : undefined;
-    const base = directory ? await ports.head(directory) : undefined;
-    const title = input.title ?? titleOf(input.task);
-    const child = await ports.session
-        .create({
-        title,
-        ...(input.agent ? { agent: input.agent } : {}),
-        ...(model ? { model } : {}),
-        ...(directory ? { location: { directory } } : {}),
-        metadata: { courier: { parentID } },
-    })
-        .catch(async (error) => {
-        // No session will ever use the fresh worktree, and nothing records it, so it goes now.
-        if (directory)
-            await dropWorktree(ports, directory);
-        throw error;
-    });
-    // Recorded before the prompt, so a child that exists is on the roster even if prompting fails. A
-    // failed write must not keep the child from its task, so it is reported instead of thrown.
-    const rosterError = await record(ports.storage, {
-        sessionID: child.id,
-        parentID,
-        title,
-        directory: directory ?? child.location.directory,
-        isolated: directory !== undefined,
-        createdAt: ports.now(),
-        ...(directory ? { source: ports.directory, project: ports.projectID } : {}),
-        ...(base ? { base } : {}),
-    }).then(() => undefined, (error) => describeFailure("roster", error).message);
-    await ports.session.prompt({ sessionID: child.id, text: childBrief(parentID, input.task) });
-    return {
-        sessionID: child.id,
-        directory: directory ?? child.location.directory,
-        ...(rosterError ? { rosterError } : {}),
-    };
-}
-/** Drops a message into another session's inbox; OpenCode wakes that session if it is idle. */
-export async function send(ports, from, input) {
-    const delivered = await ports.session.synthetic({
-        sessionID: input.sessionID,
-        text: envelope(from, input.message),
-        description: `Message from ${from}`,
-        metadata: { source: "courier", from },
-        delivery: input.queue ? "queue" : "steer",
-    });
-    return { messageID: delivered.id };
-}
-/** A one-off look at a session, for check-ins; not meant to be called in a loop. */
-export async function status(ports, input) {
-    const [info, messages, pending] = await Promise.all([
-        ports.session.get({ sessionID: input.sessionID }),
-        ports.session.context({ sessionID: input.sessionID }),
-        ports.pending(input.sessionID),
-    ]);
-    const last = messages.findLast((message) => message.type === "assistant");
-    const lastText = last?.type === "assistant"
-        ? last.content.flatMap((part) => (part.type === "text" ? [part.text] : [])).join("")
-        : undefined;
-    return withoutUndefined({
-        sessionID: info.id,
-        title: info.title,
-        parentID: info.parentID,
-        outcome: info.outcome,
-        updated: info.time.updated,
-        idle: info.time.idle,
-        lastText,
-        pending: pending.length ? pending : undefined,
-    });
-}
-/** The sessions a parent started, each with what courier_status reports, or the error it gave. */
-export async function listChildren(ports, parentID) {
-    const entries = await current(ports.storage, parentID, ports.now());
-    return Promise.all(entries.map(async (entry) => {
-        const roster = { directory: entry.directory, isolated: entry.isolated, created: entry.createdAt };
-        try {
-            return { ...(await status(ports, { sessionID: entry.sessionID })), ...roster };
-        }
-        catch (error) {
-            return {
-                sessionID: entry.sessionID,
-                title: entry.title,
-                ...roster,
-                error: describeFailure("courier_status", error).message,
-            };
-        }
-    }));
-}
-/** OpenCode leaves a tool call hanging when its metadata holds `undefined`, so results drop those keys. */
-function withoutUndefined(value) {
-    return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined));
-}
-/** A readable message for a failed courier call; OpenCode's own errors can carry an empty message. */
-export function describeFailure(tool, error) {
-    const tagged = error;
-    const message = (typeof tagged?.message === "string" && tagged.message) ||
-        [tagged?._tag, tagged?.sessionID].filter((item) => typeof item === "string").join(" ") ||
-        String(error);
-    return new Error(`${tool} failed: ${message}`);
-}

package/dist/hub.d.ts

@@ -1,325 +0,0 @@
-import type { Plugin } from "@opencode/plugin";
-import type { Server } from "node:http";
-import { type LaterPorts } from "./later.js";
-import type { Asked, Outcome, Withdrawal } from "./notices.js";
-import type { Permissions, Waiting } from "./relay.js";
-import type { RosterStorage } from "./roster.js";
-import { type Registry } from "./storage.js";
-import type { WebhookConfig, WebhookPorts } from "./webhook.js";
-type Context = Plugin.Context;
-/**
- * The plugin's process-wide state, in one place. OpenCode sets the plugin up once per location
- * (project or worktree), all in one process, and after an update loads the new copy of the package
- * next to the old one until the old one unloads; so the state every instance shares lives on
- * `globalThis`, outside the module graph, and this is the only module that puts it there.
- *
- * The hub is versioned by `HUB_VERSION`, not by the package's version: copies whose hub has the
- * same shape share one hub, however far apart their releases, and only a change to the hub's shape
- * (the ports a `Member` carries included) or to the meaning of one of its fields bumps it. An
- * optional field that a copy without it gets along without, such as `Member.location` or
- * `Scheduler.running`, is added without a bump while no release has the hub (the latest is 0.2.2).
- *
- * Version skew: a copy that finds a hub of another version under `opencode-courier.hub` logs that
- * once and runs its own hub under `opencode-courier.hub@<version>`. Whatever its version, a hub
- * takes the claim sets and the other shared objects of the copies before the hub from their own
- * keys (`opencode-courier.claimed`, `.watched`, `.forms`, `.questions`, `.receiver`, `.locations`),
- * making each when it is missing, so every copy in the process, with a hub or without, claims an
- * event or a delivery in the same set, and an old and a new copy never both act on it. Those keys'
- * shapes and meanings are therefore fixed: a hub version that needs other ones makes new keys, and
- * keeps claiming in the old ones too while a copy that uses them may still be loaded. `members` is
- * the one thing each version keeps to itself, so a job a hub runs once for its members runs once
- * per hub version, and still claims what it acts on in the shared sets, which keep it from acting
- * twice.
- */
-export declare const HUB_VERSION = 1;
-/** The key of the hub; a copy that finds another version there keeps its own under `${HUB_KEY}@<version>`. */
-export declare const HUB_KEY = "opencode-courier.hub";
-/**
- * A question this process knows: one whose call waits (`call`), or one whose call was cut off,
- * which is answered by message. `link` withdraws the top session's question call that passes its
- * answer on, once the question is settled without that call.
- */
-export interface Question extends Asked {
-    /** The directory of the location the call runs in, whose shutdown withdraws its form. */
-    directory?: string;
-    /** Hands the waiting call the top session's outcome; true once the call has ended with it. */
-    call?: (outcome: Outcome) => Promise<boolean>;
-    link?: (how: Withdrawal) => void;
-    /** Storing the question and telling the top session, while that is under way. */
-    relaying?: Promise<boolean>;
-    /** Working out what became of it once its call ended without the top session's answer. */
-    settling?: Promise<void>;
-}
-/**
- * The relay's timings, carried by its ports: how long a question cut off by a closing location
- * waits before an instance still loaded tells its top session, how long an answer waits for another
- * one to it that is still being passed on, how long what follows a call's end waits for the notice
- * of the question to go out, and how long a dismissal is held to see whether the location is
- * shutting down.
- */
-export interface QuestionTiming {
-    readonly closingGraceMs: number;
-    readonly passingWaitMs: number;
-    readonly relayWaitMs: number;
-    readonly dismissalGraceMs: number;
-}
-export interface QuestionPorts {
-    readonly storage: RosterStorage;
-    readonly session: Pick<Context["session"], "synthetic">;
-    /** The directory of the instance's location. */
-    readonly directory: string;
-    /** The clock, in epoch milliseconds, as OpenCode's location shutdowns are recorded. */
-    readonly now: () => number;
-    readonly timing: QuestionTiming;
-    readonly newID: () => string;
-    readonly log: (message: string) => void;
-}
-export interface WatchPorts {
-    readonly storage: RosterStorage;
-    readonly session: Pick<Context["session"], "synthetic">;
-    readonly event: Pick<Context["event"], "subscribe">;
-    /**
-     * The permission domains of every loaded location, whose pending requests are relayed when the
-     * watcher (re)subscribes: one watcher serves them all, and an isolated child's are in its worktree's.
-     */
-    readonly permissions: () => Iterable<Pick<Context["permission"], "list">>;
-    /** The clock a location shutdown is recorded by: the question relay's, which judges it. */
-    readonly now: () => number;
-    readonly log: (message: string) => void;
-}
-/**
- * What every plugin instance in the process shares. A hub follows OpenCode's events through two of
- * its members, one a standby, and a copy of another hub version, or one from before the hub, follows
- * them too, all sent the same events; so an event id is claimed synchronously and handled once.
- * `waiting` holds the permission requests a session was told about and has not answered;
- * `answered`, requests answered before anyone was told, so a notice whose roster lookup was
- * overtaken by the answer is not sent. `forms` does the same for the forms of spawned sessions.
- */
-export interface WatchState {
-    readonly seen: Set<string>;
-    readonly waiting: Waiting;
-    readonly answered: Set<string>;
-    readonly forms: FormsTold;
-}
-/** The forms sessions were told about, kept apart from the permission requests. */
-export interface FormsTold {
-    /** Forms still shown whose notice went out, or is going out: the notice's delivery. */
-    readonly told: Map<string, Promise<unknown>>;
-    /** Forms settled before anyone was told, so a notice whose roster lookup was overtaken is not sent. */
-    readonly settled: Set<string>;
-}
-/**
- * The webhook receiver, one per process: every instance configured with a `webhook` option joins
- * `instances`, the first one starts the server, and the last one to unload stops it.
- */
-export interface Receiver {
-    readonly config: WebhookConfig;
-    readonly instances: Set<WebhookPorts>;
-    readonly server: Promise<Server | undefined>;
-}
-/** The current receiver, if any, and the previous one while it closes, which a new one waits for. */
-export interface Receivers {
-    current?: Receiver;
-    closing?: Promise<void>;
-}
-/**
- * The question relay's state, shared by every instance, since a child and the session it asks can
- * be in different locations: the questions told to a top session and not yet settled, the cut-off
- * ones whose top session has been told so, and the question calls waiting for their form to be shown.
- */
-export interface QuestionState {
-    readonly questions: Map<string, Question>;
-    readonly noticed: Set<string>;
-    readonly shown: Map<string, () => void>;
-    /** The questions whose answer is being passed on, each until that is done, and those whose answer went out. */
-    readonly passing: Map<string, Promise<unknown>>;
-    readonly answered: Set<string>;
-    /**
-     * The ports of the loaded instances, of every copy of the plugin. A release before the hub picks
-     * one here to tell a cut-off question through, so every copy keeps it filled; this copy reads its
-     * hub's members, and this only for an instance of another copy, when it has none.
-     */
-    readonly loaded: Set<QuestionPorts>;
-    /** How many instances follow OpenCode's events now, and whether any has since the process started. */
-    following: number;
-    followed: boolean;
-    /**
-     * When OpenCode last reported each location shutting down (`location.shutdown`), by directory
-     * in epoch milliseconds by the clock of the watcher that saw it; under `""` when the event named no location.
-     */
-    readonly shutdowns: Map<string, number>;
-    /** Woken when a location shuts down or an instance unloads: dismissals held to see whether one follows. */
-    readonly closingWaiters: Set<() => void>;
-}
-/**
- * A loaded plugin instance: its location's directory and permission domain, and the ports a job
- * run once for the whole process would run it through.
- */
-export interface Member {
-    readonly directory: string;
-    /**
-     * The location OpenCode set the instance up with, the very object the instance's Effect half is
-     * handed too, which finds its member by it (`portsAt`). A member of a copy before it has none.
-     */
-    readonly location?: object;
-    readonly permission: Permissions;
-    readonly later: LaterPorts;
-    readonly watch: WatchPorts;
-    readonly questions: QuestionPorts;
-    readonly log: (message: string) => void;
-}
-/**
- * A tick under way: the member it runs through, when it started, by the wall clock every member's
- * `now` reads (the next ticks compare it with another member's), and its end.
- */
-export interface Tick {
-    readonly member: Member;
-    readonly since: number;
-    /** Settles once the tick has ended, the owner key released if its loop stopped meanwhile; never rejects. */
-    readonly done: Promise<void>;
-}
-/**
- * The scheduler's loop, one per hub: it runs while the hub has members, and each tick delivers the
- * due `courier_later` messages through the ports of the member that joined first and is still loaded.
- */
-export interface Scheduler {
-    /** The loop's interval, while it runs. */
-    timer?: unknown;
-    /**
-     * The tick under way, if any, whichever copy of the plugin started it and whether or not its
-     * member is still loaded. A tick that falls due meanwhile renews the owner key for it, for up to a
-     * minute from its start, and is skipped; past that minute one whose member has left holds up
-     * nothing, and the next tick starts. Optional, since a copy of the same hub version made before it
-     * existed keeps only `ticking`.
-     */
-    running?: Tick;
-    /**
-     * The member the tick under way runs through, if any, set and cleared with `running`, for a copy
-     * that reads only this: a tick that falls due meanwhile is skipped, unless that member has left.
-     */
-    ticking?: Member;
-    /** One tick, by the copy of the plugin that joined last, so a copy loaded after an update runs its own code. */
-    tick?: () => Promise<void>;
-}
-/** How the hub starts and stops the scheduler's loop, and waits before re-reading the owner key; tests pass their own. */
-export interface Timers {
-    readonly every: (run: () => void, ms: number) => unknown;
-    readonly stop: (timer: unknown) => void;
-    readonly wait: (ms: number) => Promise<void>;
-}
-/**
- * The key in the plugin's storage, shared by every OpenCode server on one data directory, naming
- * the server whose scheduler delivers the `courier_later` messages: `{ server, at }`, its id and
- * when it last wrote the key, in epoch milliseconds. Outside `later/`, which the schedulers scan
- * for messages, those of copies before the key included.
- */
-export declare const OWNER_KEY = "scheduler/owner";
-/** How long the owner key holds without being renewed; the owner renews it every tick, four times as often. */
-export declare const OWNER_EXPIRY_MS: number;
-/**
- * How old the owner's own key may be for it to renew the key and deliver at once. An older one,
- * which it may no longer hold by the time it writes, is taken again like a free one, with the wait.
- */
-export declare const OWNER_RENEW_MS: number;
-/** The wait between writing the owner key and reading it back, at least `OWNER_WAIT_MS` and up to twice that. */
-export declare const OWNER_WAIT_MS = 500;
-/**
- * This server's id in the owner key: the same for every copy of the plugin in the process, and
- * different in every other process, a restart of this one included.
- */
-export declare const SERVER: string;
-/**
- * How long an unloading instance waits, before it lets go, for the work it leaves behind: what it
- * started itself, a tick or an event's notice still under way through it, and on the last leave the
- * owner key's release.
- */
-export declare const LEAVE_MS = 2000;
-/** How many subscriptions to OpenCode's events a hub keeps, each through another member: one, and a standby. */
-export declare const WATCHERS = 2;
-/** One of the hub's subscriptions to OpenCode's events: the member whose ports it runs through, and how it ends. */
-export interface Watcher {
-    readonly member: Member;
-    readonly stop: AbortController;
-    /** Settles once the subscription has ended, after `stop`: after the event it is handling, not the stream's close. */
-    readonly done: Promise<void>;
-}
-export interface Hub {
-    readonly version: typeof HUB_VERSION;
-    /** The instances loaded now, in the order they joined. */
-    readonly members: Set<Member>;
-    readonly scheduler: Scheduler;
-    /**
-     * The hub's subscriptions to OpenCode's events, each through another member: two while two members
-     * are loaded, so one is always connected when the other's member leaves.
-     */
-    readonly watchers: Watcher[];
-    /**
-     * Starts a subscription through a member, by the copy of the plugin that set it last; until one
-     * has, the hub follows no events.
-     */
-    subscribe?: (member: Member) => Watcher;
-    /** The ids of the `courier_later` messages being delivered. */
-    readonly claimed: Set<string>;
-    /** The events handled, and the permission requests a session was told about or that were answered first. */
-    readonly watched: Omit<WatchState, "forms">;
-    /** The forms sessions were told about, and those settled first. */
-    readonly forms: FormsTold;
-    /**
-     * The permission domain of every loaded instance, by instance. OpenCode keeps a request where its
-     * session runs, so a request of an isolated child is answered through the instance loaded in its worktree.
-     */
-    readonly locations: Map<object, Permissions>;
-    readonly receivers: Receivers;
-    readonly questions: QuestionState;
-    /** Whether the hub of another version found under `HUB_KEY` has been logged. */
-    skewLogged: boolean;
-}
-/** A hub, as `open` finds or makes it, and how instances join it. */
-export interface Opened {
-    readonly hub: Hub;
-    /**
-     * Adds a loaded instance to the hub and its permission domain to `locations`; returns its leave,
-     * which takes both out again. The first instance to join logs a hub of another version found
-     * under `HUB_KEY`. An instance joining a hub without members starts the scheduler's loop, with a
-     * tick at once; the last one to leave stops it. An instance joining while the hub has fewer than
-     * `WATCHERS` subscriptions to OpenCode's events starts one through itself; when one leaves that
-     * has one, another member without one starts its replacement before it ends. The last leave
-     * settles once the scheduler's owner key is released, after the tick under way, whichever copy
-     * started it. Every leave first waits for the work its member leaves behind: what was handed to
-     * `track`, a tick under way through it, and the subscription it ran, which ends after the event
-     * it is handling; all of it, the release included, for up to `LEAVE_MS`. The question relay's
-     * own work is not waited for: it outlives the instance on purpose.
-     */
-    readonly join: (member: Member) => () => Promise<void>;
-    /** Hands the hub work a member started, which its leave waits for; the member's own background work. */
-    readonly track: (member: Member, work: Promise<unknown>) => void;
-}
-/**
- * Finds or makes this copy's hub in `registry`: the one under `HUB_KEY`, or its own under a
- * versioned key when a hub of another version holds that. Either way, its claim sets and shared
- * objects are the ones under the keys of the copies before the hub, made when missing.
- */
-export declare function open(registry: Registry, timers?: Timers, server?: string): Opened;
-/** This copy's hub, in the process. */
-export declare const hub: Hub;
-/** Joins this copy's hub; see `Opened.join`. */
-export declare const join: (member: Member) => () => Promise<void>;
-/** Hands this copy's hub work a member started; see `Opened.track`. */
-export declare const track: (member: Member, work: Promise<unknown>) => void;
-/** The member of this copy's hub set up with `location` that joined last, while it is loaded. */
-export declare function memberAt(location: object): Member | undefined;
-/**
- * The question ports of the member that has just joined at `location`, the newest there, for as long
- * as it stays loaded: resolved once, so an instance joining later at the same location, while this
- * one is still loaded, does not take its place.
- */
-export declare function portsAt(location: object): () => QuestionPorts | undefined;
-/** The permission domains of the loaded instances. */
-export declare const permissions: () => MapIterator<Permissions>;
-/**
- * For tests: forgets every remembered id and the question relay's state, the relay's loaded
- * instances and its count of watchers included. The hub's members, the locations and the webhook
- * receiver are left alone; leaving and unloading take them out.
- */
-export declare function resetHub(): void;
-export {};

package/dist/json.d.ts

@@ -1,4 +0,0 @@
-/** Readers for untyped JSON, such as a webhook payload or a plugin option: the value when it has the type, else nothing. */
-export declare const str: (value: unknown) => string | undefined;
-export declare const num: (value: unknown) => number | undefined;
-export declare const obj: (value: unknown) => Record<string, any>;

package/dist/json.js

@@ -1,4 +0,0 @@
-/** Readers for untyped JSON, such as a webhook payload or a plugin option: the value when it has the type, else nothing. */
-export const str = (value) => (typeof value === "string" ? value : undefined);
-export const num = (value) => (typeof value === "number" && Number.isInteger(value) ? value : undefined);
-export const obj = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};