@astrosheep/keiyaku 4.5.29 → 4.6.2

package/build/src/cli/commands/amend.d.ts

@@ -1,13 +1,12 @@
-import { type ActorId, type Gate, type Keiyaku, type Repo, type WorktreeHooks } from "../../index.js";
-import type { ParsedAmend } from "./contract.js";
+import { type ActorId, type Keiyaku, type Repo } from "../../index.js";
+import type { ParsedAmend } from "./contract-grammar.js";
 type AmendCommandInput = Readonly<{
     command: ParsedAmend;
     repo: Repo;
     contract: Keiyaku;
     markdown?: string;
-    gates: readonly Gate[] | undefined;
+    gates?: readonly string[];
     actor?: ActorId;
-    hooks?: WorktreeHooks;
 }>;
-export declare function amendFromCommand({ command, repo, contract, markdown, gates, actor, hooks, }: AmendCommandInput): ReturnType<Keiyaku["amend"]>;
+export declare function amendFromCommand({ command, repo, contract, markdown, gates, actor, }: AmendCommandInput): ReturnType<Keiyaku["amend"]>;
 export {};

package/build/src/cli/commands/amend.js

@@ -1,10 +1,9 @@
 import { contractFromInput } from "../selectors.js";
-export function amendFromCommand({ command, repo, contract, markdown, gates, actor, hooks, }) {
+export function amendFromCommand({ command, repo, contract, markdown, gates, actor, }) {
     const after = command.clearAfter === true ? [] : command.after?.map((id) => contractFromInput(repo, id).id);
     return contract.amend({
         ...(markdown === undefined ? {} : { markdown }),
         ...(actor === undefined ? {} : { actor }),
-        ...(hooks === undefined ? {} : { hooks }),
         ...(after === undefined ? {} : { after }),
         ...(gates === undefined ? {} : { gates }),
     });

package/build/src/cli/commands/bind.d.ts

@@ -1,12 +1,11 @@
-import { type ActorId, type BindResult, type Gate, type Repo, type WorktreeHooks } from "../../index.js";
-import type { ParsedBind } from "./contract.js";
+import { type ActorId, type BindResult, type KeiyakuLibrary, type Repo } from "../../index.js";
+import type { ParsedBind } from "./contract-grammar.js";
 type BindCommandInput = Readonly<{
     command: ParsedBind;
     repo: Repo;
+    library: KeiyakuLibrary;
     markdown?: string;
-    gates?: readonly Gate[];
     actor?: ActorId;
-    hooks?: WorktreeHooks;
 }>;
-export declare function bindFromCommand({ command, repo, markdown, gates, actor, hooks, }: BindCommandInput): Promise<BindResult>;
+export declare function bindFromCommand({ command, repo, library, markdown, actor, }: BindCommandInput): Promise<BindResult>;
 export {};

package/build/src/cli/commands/bind.js

@@ -1,26 +1,23 @@
-import { Keiyaku, } from "../../index.js";
-import { bindFromCli } from "../../library/contract-bind.js";
 import { contractFromInput } from "../selectors.js";
-export async function bindFromCommand({ command, repo, markdown, gates, actor, hooks, }) {
+export async function bindFromCommand({ command, repo, library, markdown, actor, }) {
     if (command.forkOf !== undefined) {
-        return Keiyaku.with({ ...(actor === undefined ? {} : { actor }), ...(hooks === undefined ? {} : { hooks }) }).bind({
+        return library.bind({
             repo,
             forkOf: contractFromInput(repo, command.forkOf).id,
             ...(command.target === undefined ? {} : { target: command.target }),
+            ...(actor === undefined ? {} : { actor }),
         });
     }
     const after = command.after?.map((id) => contractFromInput(repo, id).id);
-    if (markdown === undefined || gates === undefined)
+    if (markdown === undefined)
         throw new Error("Markdown bind command is missing stdin terms");
-    const library = Keiyaku.with();
-    return bindFromCli({
+    return library.bind({
         repo,
         markdown,
         ...(command.task === undefined ? {} : { task: command.task }),
         ...(command.target === undefined ? {} : { target: command.target }),
         ...(actor === undefined ? {} : { actor }),
-        ...(hooks === undefined ? {} : { hooks }),
         ...(after === undefined ? {} : { after }),
-        gates,
-    }, (id) => library.select({ repo, id }));
+        ...(command.gates === undefined ? {} : { gates: command.gates }),
+    });
 }

package/build/src/cli/commands/contract-grammar.d.ts

@@ -0,0 +1,112 @@
+import { type ContractCommand } from "./contract-help.js";
+type CatalogQuery = Readonly<{
+    kind: "tasks";
+    namespace?: readonly string[];
+    limit?: number;
+}> | Readonly<{
+    kind: "contracts";
+    limit?: number;
+}> | Readonly<{
+    kind: "archetypes";
+    limit?: number;
+}> | Readonly<{
+    kind: "akuma";
+    archetype?: string;
+    limit?: number;
+}>;
+type Output = Readonly<{
+    output: "text" | "json";
+}>;
+type Actor = Readonly<{
+    actor?: string;
+}>;
+export type ParsedBind = Output & Actor & Readonly<{
+    command: "bind";
+    forkOf?: string;
+    task?: string;
+    target?: string;
+    after?: readonly string[];
+    gates?: readonly string[];
+}>;
+export type ParsedAmend = Output & Actor & Readonly<{
+    command: "amend";
+    contract?: string;
+    after?: readonly string[];
+    clearAfter?: true;
+    gates?: readonly string[];
+    stdin?: true;
+}>;
+export type ParsedDeliver = Output & Readonly<{
+    command: "deliver";
+    contract?: string;
+    message?: string;
+    includeDirty: boolean;
+    materializeConflict: boolean;
+    overwrite: boolean;
+}>;
+export type ParsedReview = Output & Readonly<{
+    command: "review";
+    contract?: string;
+    verdict: "satisfied" | "unsatisfied";
+    summary?: string;
+    summaryFromStdin?: true;
+}>;
+export type ParsedArc = Output & Actor & Readonly<{
+    command: "arc";
+    contract?: string;
+}>;
+export type ParsedAbandon = Output & Actor & Readonly<{
+    command: "abandon";
+    contract?: string;
+    note?: string;
+}>;
+export type ParsedStatus = Output & (Readonly<{
+    command: "status";
+    contract?: string;
+    selectors?: readonly string[];
+    akuma?: never;
+    guidance?: true;
+}> | Readonly<{
+    command: "status";
+    contract: string;
+    akuma: true;
+    guidance?: never;
+}>);
+export type ParsedLs = Output & Readonly<{
+    command: "ls";
+    query: CatalogQuery;
+}>;
+export type ParsedAudit = Output & Readonly<{
+    command: "audit";
+    contract?: string;
+    includeDirty: boolean;
+    showDiff: boolean;
+}>;
+export type ParsedReconcile = Output & Readonly<{
+    command: "reconcile";
+    contract?: string;
+    retryHooks: boolean;
+}>;
+export type ParsedNuke = Output & Readonly<{
+    command: "nuke";
+    confirm?: string;
+}>;
+export type ParsedSettings = Output & Readonly<{
+    command: "settings";
+}>;
+export type ParsedRegion = Output & Readonly<{
+    command: "region";
+    contract?: string;
+    paths?: readonly [string, ...string[]];
+}>;
+export type ParsedContractParts = Readonly<{
+    command: ContractCommand;
+    flags: Readonly<Record<string, string | true | readonly string[]>>;
+    positionals: readonly string[];
+    stdin: boolean;
+    output: "text" | "json";
+    actor?: string;
+}>;
+export type ParsedContractCommand = ParsedBind | ParsedAmend | ParsedDeliver | ParsedReview | ParsedArc | ParsedAbandon | ParsedStatus | ParsedLs | ParsedAudit | ParsedReconcile | ParsedNuke | ParsedSettings | ParsedRegion;
+export declare function parseContractCommand(parts: ParsedContractParts): ParsedContractCommand;
+export {};

package/build/src/cli/commands/contract-grammar.js

@@ -0,0 +1,282 @@
+import { archetypeName } from "../../akuma/identity.js";
+import { parseTaskNamespaceSelector } from "../../task/catalog.js";
+import { CliUsageError, commandGuide } from "../usage.js";
+import { CONTRACT_COMMAND_SPECS } from "./contract-help.js";
+function parseAkumaCatalogPath(value) {
+    if (value === "aku" || value === "aku/")
+        return { kind: "archetypes" };
+    if (value === "aku/*/*")
+        return { kind: "akuma" };
+    const scopedGlob = /^aku\/([^/]+)\/\*$/u.exec(value);
+    if (scopedGlob !== null)
+        return { kind: "akuma", archetype: archetypeName(scopedGlob[1]) };
+    const match = /^aku\/([^/]+)\/?$/u.exec(value);
+    if (match === null)
+        return null;
+    return { kind: "akuma", archetype: archetypeName(match[1]) };
+}
+function optionalFlag(flags, name) {
+    const value = flags[name];
+    return typeof value === "string" ? value : undefined;
+}
+function refuse(command, message) {
+    throw new CliUsageError(message, commandGuide(command, CONTRACT_COMMAND_SPECS[command].usage));
+}
+function parseGateNames(parts, command) {
+    const value = optionalFlag(parts.flags, "gates");
+    if (value === undefined)
+        return undefined;
+    if (value === "")
+        return [];
+    const names = value.split(",");
+    if (names.some((name) => name.length === 0)) {
+        refuse(command, '--gates requires comma-separated names or "" to clear gates');
+    }
+    return names;
+}
+function parseBind(parts) {
+    const forkOf = optionalFlag(parts.flags, "fork-of");
+    if (forkOf !== undefined) {
+        if (parts.stdin)
+            refuse("bind", "fork bind reads no stdin");
+        for (const option of ["task", "after", "gates"]) {
+            if (parts.flags[option] !== undefined)
+                refuse("bind", `--${option} is not valid with --fork-of`);
+        }
+        const target = optionalFlag(parts.flags, "target");
+        return {
+            command: "bind",
+            forkOf,
+            ...(target === undefined ? {} : { target }),
+            ...(parts.actor === undefined ? {} : { actor: parts.actor }),
+            output: parts.output,
+        };
+    }
+    if (!parts.stdin)
+        refuse("bind", "bind requires stdin");
+    const task = optionalFlag(parts.flags, "task");
+    const target = optionalFlag(parts.flags, "target");
+    const after = parts.flags.after === undefined ? [] : Array.isArray(parts.flags.after) ? parts.flags.after : [parts.flags.after];
+    const gates = parseGateNames(parts, "bind");
+    return {
+        command: "bind",
+        ...(task === undefined ? {} : { task }),
+        ...(target === undefined ? {} : { target }),
+        ...(parts.flags.after === undefined ? {} : { after }),
+        ...(gates === undefined ? {} : { gates }),
+        ...(parts.actor === undefined ? {} : { actor: parts.actor }),
+        output: parts.output,
+    };
+}
+function parseAmend(parts) {
+    const contract = parts.positionals[0];
+    const after = parts.flags.after === undefined ? [] : Array.isArray(parts.flags.after) ? parts.flags.after : [parts.flags.after];
+    if (parts.flags["clear-after"] === true && after.length > 0)
+        refuse("amend", "--clear-after and --after are mutually exclusive");
+    const gates = parseGateNames(parts, "amend");
+    if (!parts.stdin && parts.flags.after === undefined && parts.flags["clear-after"] !== true && gates === undefined) {
+        refuse("amend", "amend requires stdin or --after, --clear-after, or --gates");
+    }
+    return {
+        command: "amend",
+        ...(contract === undefined ? {} : { contract }),
+        ...(parts.flags.after === undefined ? {} : { after }),
+        ...(parts.flags["clear-after"] === true ? { clearAfter: true } : {}),
+        ...(gates === undefined ? {} : { gates }),
+        ...(parts.actor === undefined ? {} : { actor: parts.actor }),
+        ...(parts.stdin ? { stdin: true } : {}),
+        output: parts.output,
+    };
+}
+function parseDeliver(parts) {
+    const contract = parts.positionals[0];
+    const message = optionalFlag(parts.flags, "message");
+    return {
+        command: "deliver",
+        ...(contract === undefined ? {} : { contract }),
+        ...(message === undefined ? {} : { message }),
+        includeDirty: parts.flags["include-dirty"] === true,
+        materializeConflict: parts.flags["materialize-conflict"] === true,
+        overwrite: parts.flags.overwrite === true,
+        output: parts.output,
+    };
+}
+function parseReview(parts) {
+    if (Number(parts.flags.satisfied === true) + Number(parts.flags.unsatisfied === true) !== 1) {
+        refuse("review", "review requires exactly one verdict flag");
+    }
+    const summary = optionalFlag(parts.flags, "summary");
+    if (parts.stdin === (summary !== undefined)) {
+        refuse("review", "review requires exactly one of --summary <text> or stdin '-'");
+    }
+    const contract = parts.positionals[0];
+    return {
+        command: "review",
+        ...(contract === undefined ? {} : { contract }),
+        verdict: parts.flags.satisfied === true ? "satisfied" : "unsatisfied",
+        ...(summary === undefined ? {} : { summary }),
+        ...(parts.stdin ? { summaryFromStdin: true } : {}),
+        output: parts.output,
+    };
+}
+function parseStatus(parts) {
+    const guidance = parts.flags.guidance === true;
+    if (guidance) {
+        const selected = parts.positionals[0];
+        if (parts.positionals.length > 1)
+            refuse("status", "--guidance accepts at most one Contract selector");
+        if (selected?.startsWith("aku/") === true)
+            refuse("status", "--guidance cannot select an Akuma");
+        return {
+            command: "status",
+            ...(selected === undefined ? {} : { contract: selected }),
+            guidance: true,
+            output: parts.output,
+        };
+    }
+    if (parts.positionals.length > 1) {
+        return { command: "status", selectors: parts.positionals, output: parts.output };
+    }
+    const contract = parts.positionals[0];
+    if (contract?.startsWith("aku/") === true) {
+        return { command: "status", contract, akuma: true, output: parts.output };
+    }
+    return { command: "status", ...(contract === undefined ? {} : { contract }), output: parts.output };
+}
+function parseRegion(parts) {
+    const contract = parts.positionals[0];
+    const pathFlag = parts.flags.path;
+    const paths = pathFlag === undefined ? undefined : Array.isArray(pathFlag) ? pathFlag : [pathFlag];
+    if (paths !== undefined && contract !== undefined)
+        refuse("region", "--path cannot combine with a contract");
+    return {
+        command: "region",
+        ...(contract === undefined ? {} : { contract }),
+        ...(paths === undefined ? {} : { paths: paths }),
+        output: parts.output,
+    };
+}
+function akumaCatalogQuery(query, parts) {
+    const limit = optionalFlag(parts.flags, "limit");
+    if (limit !== undefined && (!/^[1-9][0-9]*$/u.test(limit) || !Number.isSafeInteger(Number(limit))))
+        refuse("ls", "--limit requires a positive safe integer");
+    return {
+        ...query,
+        ...(limit === undefined ? {} : { limit: Number(limit) }),
+    };
+}
+function listLimit(parts) {
+    const limit = optionalFlag(parts.flags, "limit");
+    if (limit !== undefined && (!/^[1-9][0-9]*$/u.test(limit) || !Number.isSafeInteger(Number(limit))))
+        refuse("ls", "--limit requires a positive safe integer");
+    return limit === undefined ? undefined : Number(limit);
+}
+function taskCatalogQuery(path, limit) {
+    if (path === "task" || path === "task/") {
+        return { kind: "tasks", namespace: [], ...(limit === undefined ? {} : { limit }) };
+    }
+    if (!path.startsWith("task/"))
+        return null;
+    if (!path.endsWith("/"))
+        refuse("ls", `invalid Task namespace selector: ${path}`);
+    const body = path.slice("task/".length, -1);
+    if (body.length === 0 || body.split("/").some((segment) => segment.length === 0))
+        refuse("ls", `invalid Task namespace selector: ${path}`);
+    try {
+        const namespace = parseTaskNamespaceSelector(path);
+        return { kind: "tasks", namespace, ...(limit === undefined ? {} : { limit }) };
+    }
+    catch (error) {
+        refuse("ls", error instanceof Error ? error.message : `invalid Task namespace selector: ${path}`);
+    }
+}
+function parseLs(parts) {
+    const path = parts.positionals[0];
+    if (path === undefined)
+        refuse("ls", "ls requires a selector");
+    const limit = listLimit(parts);
+    const taskQuery = taskCatalogQuery(path, limit);
+    if (taskQuery !== null)
+        return { command: "ls", query: taskQuery, output: parts.output };
+    if (path === "kei" || path === "kei/") {
+        return {
+            command: "ls",
+            query: { kind: "contracts", ...(limit === undefined ? {} : { limit }) },
+            output: parts.output,
+        };
+    }
+    try {
+        const query = parseAkumaCatalogPath(path);
+        if (query === null)
+            refuse("ls", "ls requires a supported identity directory selector");
+        return { command: "ls", query: akumaCatalogQuery(query, parts), output: parts.output };
+    }
+    catch (error) {
+        if (error instanceof CliUsageError)
+            throw error;
+        refuse("ls", error instanceof Error ? error.message : "invalid ls directory");
+    }
+}
+export function parseContractCommand(parts) {
+    switch (parts.command) {
+        case "bind":
+            return parseBind(parts);
+        case "amend":
+            return parseAmend(parts);
+        case "deliver":
+            return parseDeliver(parts);
+        case "review":
+            return parseReview(parts);
+        case "arc": {
+            const contract = parts.positionals[0];
+            return {
+                command: "arc",
+                ...(contract === undefined ? {} : { contract }),
+                ...(parts.actor === undefined ? {} : { actor: parts.actor }),
+                output: parts.output,
+            };
+        }
+        case "abandon": {
+            const contract = parts.positionals[0];
+            const note = optionalFlag(parts.flags, "note");
+            return {
+                command: "abandon",
+                ...(contract === undefined ? {} : { contract }),
+                ...(note === undefined ? {} : { note }),
+                ...(parts.actor === undefined ? {} : { actor: parts.actor }),
+                output: parts.output,
+            };
+        }
+        case "status":
+            return parseStatus(parts);
+        case "ls":
+            return parseLs(parts);
+        case "audit": {
+            const contract = parts.positionals[0];
+            return {
+                command: "audit",
+                ...(contract === undefined ? {} : { contract }),
+                includeDirty: parts.flags["include-dirty"] === true,
+                showDiff: parts.flags["show-diff"] === true,
+                output: parts.output,
+            };
+        }
+        case "reconcile": {
+            const contract = parts.positionals[0];
+            return {
+                command: "reconcile",
+                ...(contract === undefined ? {} : { contract }),
+                retryHooks: parts.flags["retry-hooks"] === true,
+                output: parts.output,
+            };
+        }
+        case "nuke": {
+            const confirm = optionalFlag(parts.flags, "confirm");
+            return { command: "nuke", ...(confirm === undefined ? {} : { confirm }), output: parts.output };
+        }
+        case "settings":
+            return { command: "settings", output: parts.output };
+        case "region":
+            return parseRegion(parts);
+    }
+}

package/build/src/cli/commands/contract-help.d.ts

@@ -1,4 +1,4 @@
-export type ContractFlagKind = "boolean" | "value" | "raw-value" | "repeat-value";
+type ContractFlagKind = "boolean" | "value" | "raw-value" | "repeat-value";
 export type ContractCommandSpec = Readonly<{
     positional: "none" | "optional";
     stdin: "none" | "optional" | "required";
@@ -62,7 +62,7 @@ export declare const CONTRACT_COMMAND_SPECS: {
             readonly json: "boolean";
         };
         readonly usage: "review [<contract>|@<contract>] (--satisfied | --unsatisfied) (--summary <text> | -)";
-        readonly purpose: "Record whether a Contract meets its acceptance criteria based on the current work.";
+        readonly purpose: "Record whether a Contract meets its acceptance criteria.";
         readonly details: string;
     };
     readonly arc: {
@@ -73,7 +73,8 @@ export declare const CONTRACT_COMMAND_SPECS: {
             readonly json: "boolean";
         };
         readonly usage: "arc [<contract>|@<contract>] [--actor <actor>] -";
-        readonly purpose: "Add a progress note to a Contract's work history (an Arc).";
+        readonly purpose: "Name the current chapter of a Contract's story (a story arc).";
+        readonly details: string;
     };
     readonly abandon: {
         readonly positional: "optional";
@@ -90,20 +91,12 @@ export declare const CONTRACT_COMMAND_SPECS: {
         readonly positional: "optional";
         readonly stdin: "none";
         readonly flags: {
+            readonly guidance: "boolean";
             readonly json: "boolean";
         };
-        readonly usage: "status [<contract>|@name|<aku/...>]...";
+        readonly usage: "status [<contract>|@name|<aku/...>]...\nstatus --guidance [<contract>|@<contract>]";
         readonly purpose: "Show the world overview or selected Contract and Akuma status.";
-        readonly details: "Akuma entries show the directory each Akuma works in.";
-    };
-    readonly show: {
-        readonly positional: "optional";
-        readonly stdin: "none";
-        readonly flags: {
-            readonly json: "boolean";
-        };
-        readonly usage: "show [<contract>|@<contract>]";
-        readonly purpose: "Show one Contract's requirements, current state, and work guidance.";
+        readonly details: string;
     };
     readonly ls: {
         readonly positional: "optional";
@@ -112,8 +105,9 @@ export declare const CONTRACT_COMMAND_SPECS: {
             readonly limit: "value";
             readonly json: "boolean";
         };
-        readonly usage: "ls task[/] [--limit <count>]\nls kei[/] [--limit <count>]\nls aku[/] [--limit <count>]\nls aku/<akuma>[/] [--limit <count>]\nls \"aku/*/*\" [--limit <count>]";
-        readonly purpose: "List Tasks, Contracts, or Akumas in a selected scope.";
+        readonly usage: "ls task[/] [--limit <count>]\nls kei[/] [--limit <count>]\nls aku[/] [--limit <count>]\nls aku/<name>[/] [--limit <count>]\nls \"aku/<name>/*\" [--limit <count>]\nls \"aku/*/*\" [--limit <count>]";
+        readonly purpose: "List Tasks, Contracts, or Akumas.";
+        readonly details: string;
     };
     readonly audit: {
         readonly positional: "optional";
@@ -124,7 +118,7 @@ export declare const CONTRACT_COMMAND_SPECS: {
             readonly json: "boolean";
         };
         readonly usage: "audit [<contract>|@<contract>] [--include-dirty] [--show-diff]";
-        readonly purpose: "Preview what would happen if you delivered a Contract now; progress is on stderr.";
+        readonly purpose: "Preview what would happen if you delivered a Contract now.";
         readonly details: string;
     };
     readonly reconcile: {
@@ -135,7 +129,7 @@ export declare const CONTRACT_COMMAND_SPECS: {
             readonly json: "boolean";
         };
         readonly usage: "reconcile [<contract>|@<contract>] [--retry-hooks]";
-        readonly purpose: "Restore a Contract's Git workspace from its recorded state, or reconcile workspaces across this World.";
+        readonly purpose: "Restore a Contract's Git workspace from its recorded state, or all of this World's.";
         readonly details: "--retry-hooks reruns configured setup commands even when a Contract workspace already exists; otherwise they run when reconciliation creates it.";
     };
     readonly nuke: {
@@ -146,7 +140,7 @@ export declare const CONTRACT_COMMAND_SPECS: {
             readonly json: "boolean";
         };
         readonly usage: "nuke [--confirm <world-directory>]";
-        readonly purpose: "Remove Keiyaku-owned data from a confirmed World.";
+        readonly purpose: "Remove Keiyaku-owned data from this World.";
         readonly details: "Stops Akumas and removes this World's Tasks and Keiyaku-created worktrees and Git references. --confirm must exactly match this World's directory; source files are not deleted.";
     };
     readonly settings: {
@@ -156,7 +150,7 @@ export declare const CONTRACT_COMMAND_SPECS: {
             readonly json: "boolean";
         };
         readonly usage: "settings";
-        readonly purpose: "Show effective Settings (user + project, read-only)";
+        readonly purpose: "Show effective Settings (user + project, read-only).";
     };
     readonly region: {
         readonly positional: "optional";
@@ -166,9 +160,10 @@ export declare const CONTRACT_COMMAND_SPECS: {
             readonly json: "boolean";
         };
         readonly usage: "region [<contract>]\nregion --path <pattern> [--path <pattern> ...]";
-        readonly purpose: "Show declared Contract file patterns, optionally for selected paths.";
+        readonly purpose: "Show declared Contract write patterns — all, one Contract's, or those overlapping given paths.";
+        readonly details: "Check overlap before starting parallel work.";
     };
 };
 export type ContractCommand = keyof typeof CONTRACT_COMMAND_SPECS;
 export declare function renderContractHelp(command: ContractCommand): string;
-export declare function renderContractUsage(command: ContractCommand): string;
+export {};