@4fu/arbor-interfaces 0.0.0-stage → 2026.1106.0

package/scheduler.d.ts

@@ -0,0 +1,132 @@
+/**
+ * The `Scheduler` interface: insertion timing, backpressure and scheduled
+ * tasks (docs/architecture.md#interfaces, docs/dispatch.md).
+ *
+ * The model sees only input blocks; it never manages timing. The rules below
+ * decide when the host calls the backend's steering:
+ *
+ * - Protection period: when a window starts on a target, only inputs for that
+ *   target enter during it; inputs for the same target do not restart it.
+ *   Environment deltas and conversation updates are not held back.
+ * - After it: an input for the current target that is still being batched goes
+ *   in first; then the others, by priority and age.
+ * - No insertion after the final usage reminder; waiting inputs are dispatched
+ *   again.
+ * - Paused: nothing is inserted.
+ *
+ * Backpressure: there is no cap on windows. How many run at once is bounded by
+ * the backend, so when it reports rate limits new windows wait in a queue
+ * ordered by priority and age.
+ */
+import type { Delivery } from "./agent.ts";
+import type { TaskInput } from "./task.ts";
+import type { Target, TaskRef } from "./refs.ts";
+import type { WindowRuntimeState } from "./windows.ts";
+/** One input waiting to enter a window. */
+export interface QueuedInput {
+    id: string;
+    kind: Delivery["kind"];
+    targets: readonly Target[];
+    /** Higher goes first. */
+    priority: number;
+    /** When it was queued. */
+    time: number;
+    /** Environment deltas and conversation updates are never held back. */
+    unfiltered?: boolean;
+}
+export interface InsertionRequest {
+    state: WindowRuntimeState;
+    queued: readonly QueuedInput[];
+    now: number;
+}
+export interface InsertionPlan {
+    /** Steer in now, at the next tool-call boundary. */
+    insert: readonly QueuedInput[];
+    /** Queue for after the run ends. */
+    followUp: readonly QueuedInput[];
+    /** Keep waiting. */
+    hold: readonly QueuedInput[];
+    /** Dispatch again: the window is past its final reminder. */
+    redispatch: readonly QueuedInput[];
+}
+export interface RateLimitState {
+    limited: boolean;
+    retryAfterMs?: number;
+}
+export interface AdmissionRequest {
+    running: number;
+    queued: readonly TaskInput[];
+    rateLimit?: RateLimitState;
+    now: number;
+}
+export interface AdmissionPlan {
+    /** How many new windows may open now. */
+    open: number;
+    /** Whether the rest must wait in the queue. */
+    wait: boolean;
+    /** When to ask again, in ms, while the backend is limited. */
+    retryAfterMs?: number;
+    reason?: string;
+}
+/** A daily skip period, `HH:MM` to `HH:MM`. */
+export interface SkipPeriod {
+    from: string;
+    to: string;
+}
+export interface ScheduledTaskInput {
+    name?: string;
+    /** The first firing, in epoch milliseconds. */
+    firstAt: number;
+    repeat?: {
+        everyMs: number;
+    } | {
+        dailyAt: string;
+    };
+    skipDaily?: readonly SkipPeriod[];
+    targets?: readonly Target[];
+    task: Omit<TaskInput, "kind">;
+}
+export interface ScheduledTask {
+    ref: TaskRef;
+    name?: string;
+    firstAt: number;
+    nextAt: number;
+    lastAt?: number;
+    repeat?: {
+        everyMs: number;
+    } | {
+        dailyAt: string;
+    };
+    skipDaily?: readonly SkipPeriod[];
+    targets: readonly Target[];
+    paused: boolean;
+    /** What a firing dispatches, so a restart rebuilds the schedule. */
+    task?: Omit<TaskInput, "kind">;
+}
+/**
+ * What a schedule's update may change: anything it was created with. A
+ * schedule's ref, its record of when it last fired and whether it is paused
+ * stay the host's own.
+ */
+export type ScheduledTaskUpdate = Partial<ScheduledTaskInput>;
+export interface Scheduler {
+    /** Which waiting inputs may enter a running window now. */
+    insertion(request: InsertionRequest): Promise<InsertionPlan>;
+    /** How many new windows may open now, given the backend's rate limits. */
+    admission(request: AdmissionRequest): Promise<AdmissionPlan>;
+    schedule(input: ScheduledTaskInput): Promise<TaskRef>;
+    /**
+     * Change a recorded schedule: its name, its first time, its repeat rule, its
+     * skip periods, its targets or the task a firing dispatches. Returns the
+     * changed schedule, or null when the ref names none.
+     */
+    update(ref: TaskRef, changes: ScheduledTaskUpdate): Promise<ScheduledTask | null>;
+    cancel(ref: TaskRef): Promise<void>;
+    list(): Promise<readonly ScheduledTask[]>;
+    /** Rebuild the scheduled tasks after a restart, from the journal's record. */
+    restore?(tasks: readonly ScheduledTask[]): Promise<void>;
+    /** Stop the loop, so a host that closes leaves no timer behind. */
+    close?(): void;
+    /** The tasks whose time has come, in the order they should be dispatched. */
+    due(now: number): Promise<readonly TaskInput[]>;
+}

package/scheduler.js

@@ -0,0 +1,21 @@
+/**
+ * The `Scheduler` interface: insertion timing, backpressure and scheduled
+ * tasks (docs/architecture.md#interfaces, docs/dispatch.md).
+ *
+ * The model sees only input blocks; it never manages timing. The rules below
+ * decide when the host calls the backend's steering:
+ *
+ * - Protection period: when a window starts on a target, only inputs for that
+ *   target enter during it; inputs for the same target do not restart it.
+ *   Environment deltas and conversation updates are not held back.
+ * - After it: an input for the current target that is still being batched goes
+ *   in first; then the others, by priority and age.
+ * - No insertion after the final usage reminder; waiting inputs are dispatched
+ *   again.
+ * - Paused: nothing is inserted.
+ *
+ * Backpressure: there is no cap on windows. How many run at once is bounded by
+ * the backend, so when it reports rate limits new windows wait in a queue
+ * ordered by priority and age.
+ */
+export {};

package/settings.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Settings: identity and general rules, judge modes, thresholds, model tiers
+ * and the limits the framework does enforce (docs/environment.md,
+ * docs/dispatch.md, docs/windows.md).
+ *
+ * The model may change all of it except the value of a secret. A setting names
+ * a secret and never holds its value.
+ */
+import type { JudgeDecisionKind, JudgeMode } from "./judge.ts";
+export interface Settings {
+    /** `<identity>`; omitted when empty, with no default sentence. */
+    identity?: string;
+    /** `<agent>`: the general rules, one per line. */
+    generalRules?: readonly string[];
+    judge?: {
+        /** Each decision is `on` by default; each can be `off` or `shadow`. */
+        modes?: Partial<Record<JudgeDecisionKind, JudgeMode>>;
+        /** The bounded share of the active-set score the judge may add. */
+        activeSetJudgeShare?: number;
+        /** How many candidate windows the route decision may score. At most 8. */
+        maxCandidates?: number;
+        /**
+         * What each configured tier is for, as the `model tier` question reads it:
+         * one line of text per tier name (docs/dispatch.md#model-tiers). A tier
+         * named here with no text falls back to the judge's own description of it.
+         */
+        tierCriteria?: Record<string, string>;
+    };
+    /** Each tier maps to a model from the backend's catalog. */
+    modelTiers?: Record<string, string>;
+    /** The tier a new window gets when the judge does not decide. */
+    defaultTier?: string;
+    window?: {
+        /** How long an ended run stays open for a related input. 300 s. */
+        idleSeconds?: number;
+        /** The context window's token budget. */
+        contextTokens?: number;
+        /** Tokens held back from the model. */
+        reserveTokens?: number;
+        /** How long a window protects the target it started on. 60 s. */
+        protectionSeconds?: number;
+    };
+    snapshot?: {
+        /** The system prompt and memory snapshot rebuild at most this often. 10 min. */
+        minIntervalMs?: number;
+    };
+    notes?: {
+        /** How many notes the active set may hold. */
+        activeCount?: number;
+        /** The active set's token budget, which bounds every prefix. */
+        activeTokenBudget?: number;
+    };
+    schedule?: {
+        /** Spread colliding repeating tasks apart, and their jitter. Off by default. */
+        spreadColliding?: boolean;
+        jitterMs?: number;
+    };
+    workspaces?: {
+        /** How long a chain's directory is kept after its last window ended, before the host reclaims it. */
+        retentionMs?: number;
+    };
+    /** The names of the secrets a configuration may use. Never their values. */
+    secrets?: readonly string[];
+}

package/settings.js

@@ -0,0 +1,9 @@
+/**
+ * Settings: identity and general rules, judge modes, thresholds, model tiers
+ * and the limits the framework does enforce (docs/environment.md,
+ * docs/dispatch.md, docs/windows.md).
+ *
+ * The model may change all of it except the value of a secret. A setting names
+ * a secret and never holds its value.
+ */
+export {};

package/supervisor.d.ts

@@ -0,0 +1,84 @@
+/**
+ * The `Supervisor` interface: run services - start, health checks, restart with
+ * backoff, logs, quotas (docs/architecture.md#interfaces,
+ * docs/environment.md#services).
+ *
+ * A service is an application that keeps running after the window that set it
+ * up has ended. The framework gives supervision, a directory of its own, logs
+ * and secrets injected by name; the agent writes the application and
+ * `svc.json`, and decides when to stop or remove it.
+ */
+import type { Ref } from "./refs.ts";
+import type { Page } from "./events.ts";
+import type { ArborErrorInfo } from "@4fu/arbor-errors";
+export type ServiceState = "starting" | "running" | "unhealthy" | "stopped" | "failed";
+/** One service's configuration, from its `svc.json`. */
+export interface ServiceSpec {
+    name: string;
+    command: string;
+    args?: readonly string[];
+    ports?: readonly number[];
+    /** The health check `reload` waits for before the item is installed. */
+    healthCheck?: {
+        path?: string;
+        port?: number;
+        intervalMs?: number;
+        timeoutMs?: number;
+    };
+    /** The names of the secrets it uses; values are injected by name. */
+    secrets?: readonly string[];
+    restart?: {
+        maxRetries?: number;
+        backoffMs?: number;
+    };
+    /** Resource quotas the supervisor applies. */
+    quota?: {
+        memoryBytes?: number;
+        cpuShares?: number;
+    };
+    env?: Record<string, string>;
+    /**
+     * The directory the service owns, which the command runs in and which no
+     * window ends or reclaims. The environment forks it from the draft.
+     */
+    dir?: string;
+}
+export interface ServiceHandle {
+    name: string;
+    revision: number;
+    state: ServiceState;
+}
+export interface ServiceStatus {
+    name: string;
+    revision: number;
+    state: ServiceState;
+    restarts: number;
+    since: number;
+    ports: readonly number[];
+    lastError?: ArborErrorInfo;
+    /** The events that recorded its state changes. */
+    refs: readonly Ref[];
+}
+export interface LogOptions {
+    /** Follow the log's tail. */
+    tail?: number;
+    since?: number;
+    limit?: number;
+}
+export interface LogPage extends Page<string> {
+    name: string;
+}
+export interface Supervisor {
+    /** Start a service and wait for its health check. */
+    start(spec: ServiceSpec): Promise<ServiceHandle>;
+    status(name: string): Promise<ServiceStatus>;
+    stop(name: string): Promise<void>;
+    restart(name: string): Promise<ServiceHandle>;
+    logs(name: string, options?: LogOptions): Promise<LogPage>;
+    /**
+     * Report every state change, so the host records it in the journal and runs
+     * its hooks (docs/environment.md#services). Optional: an implementation that
+     * reports no changes leaves service failures to `status`.
+     */
+    onStateChange?(handler: (status: ServiceStatus) => void | Promise<void>): void;
+}

package/supervisor.js

@@ -0,0 +1,11 @@
+/**
+ * The `Supervisor` interface: run services - start, health checks, restart with
+ * backoff, logs, quotas (docs/architecture.md#interfaces,
+ * docs/environment.md#services).
+ *
+ * A service is an application that keeps running after the window that set it
+ * up has ended. The framework gives supervision, a directory of its own, logs
+ * and secrets injected by name; the agent writes the application and
+ * `svc.json`, and decides when to stop or remove it.
+ */
+export {};

package/task.d.ts

@@ -0,0 +1,46 @@
+/**
+ * The `TaskSource` interface: turn outside events into tasks, batching them
+ * (docs/architecture.md#interfaces, docs/dispatch.md#tasks).
+ *
+ * A task is one unit of input: a batch of outside events, a scheduled firing,
+ * or a service event. Batching is the source's business - a chat source
+ * debounces per conversation, so several messages sent in a row become one
+ * task. The host makes no tasks of its own for maintenance.
+ */
+import type { Block } from "./blocks.ts";
+import type { OutsideEvent, Unsubscribe } from "./channel.ts";
+import type { EventRef, Ref, Target, TaskRef } from "./refs.ts";
+export type TaskKind = "batch" | "scheduled" | "service";
+/** What a source hands the host. The host assigns the ref. */
+export interface TaskInput {
+    kind: TaskKind;
+    /** Why it is a task, for the board and the judge. */
+    reason: string;
+    targets: readonly Target[];
+    time: number;
+    content: readonly Block[];
+    /** The outside events it batches. */
+    events?: readonly OutsideEvent[];
+    /** The source that made it. */
+    source?: string;
+    /** Higher goes first when insertion timing orders waiting inputs. */
+    priority?: number;
+    /**
+     * The batch names the agent directly, so `filter` always passes it. The
+     * source knows this; the host does not guess it (docs/dispatch.md#routing).
+     */
+    explicit?: boolean;
+}
+export interface Task extends TaskInput {
+    ref: TaskRef;
+    /** The events the batch was made of, once they are in the journal. */
+    eventRefs: readonly EventRef[];
+    refs: readonly Ref[];
+}
+export interface TaskSource {
+    readonly id: string;
+    /** Turn outside events into tasks, batched the way this source batches. */
+    toTasks(events: readonly OutsideEvent[]): readonly TaskInput[];
+    /** Push source. The host may poll instead. */
+    subscribe?(handler: (events: readonly OutsideEvent[]) => void | Promise<void>): Unsubscribe;
+}

package/task.js

@@ -0,0 +1,10 @@
+/**
+ * The `TaskSource` interface: turn outside events into tasks, batching them
+ * (docs/architecture.md#interfaces, docs/dispatch.md#tasks).
+ *
+ * A task is one unit of input: a batch of outside events, a scheduled firing,
+ * or a service event. Batching is the source's business - a chat source
+ * debounces per conversation, so several messages sent in a row become one
+ * task. The host makes no tasks of its own for maintenance.
+ */
+export {};

package/tools.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The `ToolGroup` interface: a set of direct tools and code mode modules
+ * (docs/architecture.md#interfaces, docs/tools.md).
+ *
+ * Decisions and plain commands are direct tools, declared to the model and
+ * called in the turn. Everything else is a module function, called from a
+ * script in `code_exec`. Plugins add no tools of their own; what the model can
+ * do with a plugin is an MCP server and skills in `/env`.
+ */
+import type { DirectToolSpec, FunctionSpec, ModuleSpec, ParameterSpec, ToolCall, ToolResult } from "./agent.ts";
+import type { EventRef, WindowRef } from "./refs.ts";
+import type { WorkspaceMount } from "./workspace.ts";
+/** What a call is made in. The service layer fills it; a group never reaches past it. */
+export interface CallContext {
+    window: WindowRef;
+    task?: string;
+    /** The window's mounted workspace, when it has one. */
+    workspace?: WorkspaceMount;
+    /** The environment revision frozen when the window opened. */
+    envRevision?: string;
+    /** The event this call is recorded at. */
+    call?: EventRef;
+}
+export interface ToolGroup {
+    readonly id: string;
+    /** The direct tools this group declares to the model. */
+    tools(): readonly DirectToolSpec[];
+    /** The modules this group contributes, one line each in the prompt. */
+    modules(): readonly ModuleSpec[];
+    /** Run one call. The same path as a direct tool: same hooks, same errors. */
+    call(request: ToolCall, context: CallContext): Promise<ToolResult>;
+}
+export type { DirectToolSpec, FunctionSpec, ModuleSpec, ParameterSpec, ToolCall, ToolResult };

package/tools.js

@@ -0,0 +1,10 @@
+/**
+ * The `ToolGroup` interface: a set of direct tools and code mode modules
+ * (docs/architecture.md#interfaces, docs/tools.md).
+ *
+ * Decisions and plain commands are direct tools, declared to the model and
+ * called in the turn. Everything else is a module function, called from a
+ * script in `code_exec`. Plugins add no tools of their own; what the model can
+ * do with a plugin is an MCP server and skills in `/env`.
+ */
+export {};

package/windows.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Window shapes (docs/windows.md) and the live view the host keeps of them
+ * (docs/coordination.md#the-board).
+ *
+ * A window is one context window: a model run over one prompt. Windows are
+ * disposable; none of them owns a conversation, a file or a task.
+ */
+import type { Block } from "./blocks.ts";
+import type { Ref, Target, TaskRef, WindowRef } from "./refs.ts";
+export type WindowState = "running" | "idle" | "ended" | "paused";
+/** What the host knows about a live window, for the board and for dispatch. */
+export interface WindowRuntimeState {
+    window: WindowRef;
+    state: WindowState;
+    /** When the window opened. */
+    startedAt: number;
+    /** The task it was opened for. */
+    task?: TaskRef;
+    /** The targets it has touched. */
+    targets: readonly Target[];
+    /** The target it is working on now, for the protection period. */
+    currentTarget?: Target;
+    /** Insertion is paused. */
+    paused: boolean;
+    /** The protection period's end, in epoch milliseconds. */
+    protectionUntil: number | null;
+    /** The final usage reminder has been sent, so nothing more is inserted. */
+    finalReminderSent: boolean;
+    usage: TokenUsage;
+}
+export interface TokenUsage {
+    /** Tokens used in this window. */
+    used: number;
+    /** The context window's token budget. */
+    limit: number;
+    /** Tokens held back from the model. */
+    reserve: number;
+}
+/**
+ * A handoff: the cost of ending a window with unfinished work. Each part
+ * carries refs; the details belong in notes and the journal.
+ */
+export interface Handoff {
+    topics: readonly string[];
+    progress: readonly string[];
+    pending: readonly string[];
+    agreements: readonly string[];
+    refs: readonly Ref[];
+}
+/** One line on the board, per live window. */
+export interface BoardLine {
+    window: WindowRef;
+    /** The first task's title, until the model sets a line with `board.set`. */
+    doing: string;
+    targets: readonly Target[];
+    /** What the window expects to be routed to it. */
+    expects: readonly Expectation[];
+    state: WindowState;
+    usage: TokenUsage;
+}
+/**
+ * What a window expects to arrive, so the input reaches it instead of a new
+ * window. An exact expectation is a rule; a described one joins the window's
+ * profile for the judge.
+ */
+export interface Expectation {
+    kind: "exact" | "described";
+    /** An outside item, thread or whole conversation, for an exact expectation. */
+    item?: Target;
+    /** One sentence, for a described expectation. */
+    description?: string;
+    ref: Ref;
+}
+/** One block entering a window, in the shape the prompt layout uses. */
+export interface InputBlock {
+    kind: string;
+    window?: WindowRef;
+    time: number;
+    refs: readonly Ref[];
+    content: readonly Block[];
+}

package/windows.js

@@ -0,0 +1,8 @@
+/**
+ * Window shapes (docs/windows.md) and the live view the host keeps of them
+ * (docs/coordination.md#the-board).
+ *
+ * A window is one context window: a model run over one prompt. Windows are
+ * disposable; none of them owns a conversation, a file or a task.
+ */
+export {};

package/workspace.d.ts

@@ -0,0 +1,113 @@
+/**
+ * The `Workspace` interface: a directory per window (docs/workspaces.md).
+ *
+ * A workspace is a plain directory, not bound to any repository: the framework
+ * gives isolation and continuity, and the agent does the rest. The default is
+ * a plain directory under one root, which needs nothing a host does not
+ * already have and runs the same way on Windows, Linux and macOS.
+ */
+import type { TextTable } from "./blocks.ts";
+import type { WindowRef, WorkspaceRef } from "./refs.ts";
+import type { ToolGroup } from "./tools.ts";
+/** The result of one command run in a mounted workspace. */
+export interface ExecResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+    /** The streams were cut to fit a bound. An implementation that never cuts them reports `false`. */
+    truncated: boolean;
+}
+/** One file made visible inside a mounted workspace's execution environment. */
+export interface StagedFile {
+    /** The path under the prefix, such as `skills/deploy/SKILL.md`. */
+    path: string;
+    /** The file's text. */
+    text: string;
+}
+/**
+ * A mounted workspace: a path in the host's filesystem, released when done.
+ *
+ * `path` is where the workspace's files are. It is a host path for an
+ * implementation that mounts a directory on the host, and the mounted
+ * directory of an implementation that owns its own execution environment, so a
+ * command runs there through `exec`, not on the host.
+ */
+export interface WorkspaceMount {
+    ref: WorkspaceRef;
+    path: string;
+    /**
+     * Run one command in the workspace's directory. Present when the
+     * implementation owns the execution environment; a host-directory
+     * implementation leaves it out and the caller runs the command itself in
+     * `path`.
+     */
+    exec?(command: string): Promise<ExecResult>;
+    /**
+     * Read one file in the workspace as UTF-8 text, or `null` when it does not
+     * exist. Present when the implementation can hand a file to the host; an
+     * implementation whose `path` is not a host path implements it over its own
+     * transport. A caller falls back to reading `path` on the host when it is
+     * absent.
+     */
+    readFile?(path: string): Promise<string | null>;
+    /**
+     * Write one file in the workspace as UTF-8 text, creating its directory.
+     * The same fallback rule as `readFile` applies.
+     */
+    writeFile?(path: string, text: string): Promise<void>;
+    /**
+     * Make files visible inside the execution environment, and answer the path
+     * they are visible at - which may be `prefix` itself, or somewhere else the
+     * implementation owns.
+     *
+     * For the shared environment, which a window reads at `/env` and which lives
+     * on the host (docs/environment.md#layout): an implementation whose `path` is
+     * not a host path stages the files into its own execution environment, and
+     * the caller rewrites the prefix onto what this answers. A host-directory
+     * implementation leaves it out, because its `path` already reaches the
+     * directory.
+     *
+     * What is staged is not the workspace's own: it sits outside its tree. An
+     * implementation stages it read-only, because a change goes through the
+     * environment's own draft and `reload`.
+     */
+    stage?(prefix: string, files: readonly StagedFile[]): Promise<string>;
+    release(): Promise<void>;
+}
+export interface WorkspaceQuota {
+    bytes: number;
+    used: number;
+    files: number;
+}
+export interface Workspace {
+    /**
+     * Create the window's own directory, on first use. A window that never
+     * touches files has none.
+     */
+    create(window: WindowRef): Promise<WorkspaceRef>;
+    /** Mount a workspace, read-write, at its own path. */
+    mount(ref: WorkspaceRef): Promise<WorkspaceMount>;
+    /** The workspace's size and file count, for a quota a deployment sets. */
+    quota(workspace: WorkspaceRef): Promise<WorkspaceQuota>;
+    /** Reclaim the workspace after the retention period. */
+    reclaim(workspace: WorkspaceRef): Promise<void>;
+    /**
+     * The workspace a window's chain already has, or `undefined` when it has
+     * none - the window never touched files, or the directory was reclaimed. The
+     * host asks for it to reclaim a chain's directory once its last window has
+     * ended and the retention period has passed, which a restart has to survive
+     * (docs/workspaces.md#lifecycle).
+     */
+    refOf(window: WindowRef): Promise<WorkspaceRef | undefined>;
+    /**
+     * What this implementation adds to the catalog: tool groups built from the
+     * table the host renders with.
+     *
+     * A capability the core does not name arrives here. An implementation that
+     * can show another window's workspace declares its own module function or
+     * tool and its own prompt text this way, so the core knows nothing about it;
+     * a host whose implementation contributes nothing shows the model nothing
+     * about it (docs/workspaces.md, docs/architecture.md#plugins).
+     */
+    groups?: (table: TextTable) => readonly ToolGroup[];
+}

package/workspace.js

@@ -0,0 +1,9 @@
+/**
+ * The `Workspace` interface: a directory per window (docs/workspaces.md).
+ *
+ * A workspace is a plain directory, not bound to any repository: the framework
+ * gives isolation and continuity, and the agent does the rest. The default is
+ * a plain directory under one root, which needs nothing a host does not
+ * already have and runs the same way on Windows, Linux and macOS.
+ */
+export {};