@jitsusama/agentic-harness.core 0.1.0

package/dist/work/publish.js

@@ -0,0 +1,139 @@
+/**
+ * Publishing a branch, which is the step between committing and proposing.
+ *
+ * It was missing, and its absence was the one place this surface made you
+ * leave it: `work record` committed, `review_offer propose` needed the branch
+ * on the remote, and nothing in between was a tool. Every other seam here is
+ * something you can call.
+ *
+ * Two rules are built in rather than offered. A first push sets upstream,
+ * because a branch that pushes without one has to be told its own name every
+ * time afterwards and eventually gets told the wrong one. And a force is
+ * always a lease: `--force` overwrites whatever arrived while you were
+ * rebasing, which on a shared branch is somebody else's work, and the honest
+ * version of "I know what is there" is to say what you think is there and be
+ * refused when you are wrong.
+ */
+/** The remote a tree pushes to when nothing says otherwise. */
+const DEFAULT_REMOTE = "origin";
+/**
+ * Read one git value, or undefined when git says nothing.
+ *
+ * Every call is scoped with `-C`, because the exec seam has no working
+ * directory of its own: an unscoped git call runs wherever the process
+ * happens to sit and answers confidently about the wrong repository.
+ */
+async function ask(exec, treePath, args) {
+    const result = await exec("git", ["-C", treePath, ...args]);
+    if (result.code !== 0)
+        return undefined;
+    const said = result.stdout.trim();
+    return said === "" ? undefined : said;
+}
+/** Publish with plain git. */
+export function createGitPublisher(deps) {
+    const { exec } = deps;
+    return {
+        async push(treePath, options = {}) {
+            const branch = await ask(exec, treePath, [
+                "rev-parse",
+                "--abbrev-ref",
+                "HEAD",
+            ]);
+            if (branch === undefined || branch === "HEAD") {
+                return {
+                    kind: "refused",
+                    reason: "This tree is not on a branch, so there is nothing to publish. Check one out, or make one with a branch action.",
+                };
+            }
+            // An existing upstream is the honest default: pushing a tracked
+            // branch somewhere else is how a fork ends up with a copy of a
+            // branch nobody is watching.
+            const upstream = await ask(exec, treePath, [
+                "rev-parse",
+                "--abbrev-ref",
+                `${branch}@{upstream}`,
+            ]);
+            const tracked = upstream !== undefined;
+            const remote = options.remote ?? upstream?.split("/")[0] ?? DEFAULT_REMOTE;
+            const known = await ask(exec, treePath, ["remote"]);
+            if (known === undefined || !known.split("\n").includes(remote)) {
+                return {
+                    kind: "refused",
+                    branch,
+                    reason: `This tree has no remote called ${remote}${known === undefined ? " and no remotes at all" : `, only ${known.split("\n").join(", ")}`}, so ${branch} has nowhere to go.`,
+                };
+            }
+            const args = ["-C", treePath, "push"];
+            // Lease, never bare force. The lease is what turns "overwrite it"
+            // into "overwrite it if it is still what I last saw".
+            if (options.replace)
+                args.push("--force-with-lease");
+            if (!tracked)
+                args.push("--set-upstream");
+            args.push(remote, branch);
+            const result = await exec("git", args);
+            if (result.code !== 0) {
+                const said = [result.stderr.trim(), result.stdout.trim()]
+                    .filter((stream) => stream !== "")
+                    .join("\n");
+                const stale = said.includes("stale info");
+                if (stale) {
+                    return {
+                        kind: "refused",
+                        branch,
+                        reason: `${remote}/${branch} moved since this tree last fetched it, so the lease was refused rather than overwriting work that arrived in the meantime. Fetch, look at what landed, then push again.\n\n${said}`,
+                    };
+                }
+                // A branch that has diverged from its remote, which git reports with a
+                // hint to run `git pull`. That hint is the reason this case is handled
+                // rather than passed along: the commonest way to arrive here is having
+                // rebased, and pulling then merges the old history back into the
+                // rewritten one, producing exactly the tangle the rebase was for. The
+                // right move is the lease, and this layer knows that because it is the
+                // layer that does the rebasing.
+                //
+                // Which of the two happened is not knowable from here: a rewritten
+                // history and somebody else's push look the same at the ref. So both
+                // are named, with the counts, and the reader picks. Saying only the
+                // likelier one would be the same mistake git's hint makes.
+                if (!options.replace && said.includes("[rejected]")) {
+                    const counts = await ask(exec, treePath, [
+                        "rev-list",
+                        "--left-right",
+                        "--count",
+                        `${branch}...${remote}/${branch}`,
+                    ]);
+                    const [mine, theirs] = (counts ?? "").split(/\s+/);
+                    const apart = mine && theirs
+                        ? `${remote}/${branch} has ${theirs} ${theirs === "1" ? "commit" : "commits"} this branch does not, and ${branch} has ${mine} ${mine === "1" ? "commit" : "commits"} it does not. `
+                        : `${branch} and ${remote}/${branch} have diverged. `;
+                    return {
+                        kind: "refused",
+                        branch,
+                        reason: `${apart}Git refused rather than dropping either side.\n\nIf you rebased this branch, that is your own history rewritten: push again with replace, which is a lease and still refuses if the remote moved since this tree last fetched. If somebody else pushed, fetch and read what landed first. Git's own hint below suggests pulling, which would merge their work into your rebase.\n\n${said}`,
+                    };
+                }
+                return {
+                    kind: "refused",
+                    branch,
+                    reason: said || `git push exited ${result.code}`,
+                };
+            }
+            // Git says this on stdout or stderr depending on version, and it
+            // is the difference between a push that did something and one that
+            // politely did nothing.
+            const said = `${result.stdout}\n${result.stderr}`;
+            if (said.includes("Everything up-to-date")) {
+                return { kind: "already-there", branch, remote };
+            }
+            return {
+                kind: "published",
+                branch,
+                remote,
+                tracked: !tracked,
+                replaced: options.replace === true,
+            };
+        },
+    };
+}

package/dist/work/rebase.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Replaying a branch onto a new base.
+ *
+ * The interesting outcome is not success, it is the halt. A rebase that stops
+ * on a conflict leaves the tree in a state that is neither where it was nor
+ * where it was going, and a tool that reports "failed" and says no more has
+ * handed back a repository the caller now has to diagnose from scratch. So a
+ * halt is a first-class answer that names the commit it stopped on, the paths
+ * that disagree, and the two ways out.
+ *
+ * Nothing here decides for you. Continuing needs the conflicts resolved, which
+ * is work only a person or an agent reading the code can do, and abandoning
+ * throws away whatever replaying had achieved so far. Both are refusals to
+ * guess rather than missing features.
+ */
+import type { Exec } from "../exec/index.js";
+/** Where a replay got to. */
+export type RebaseOutcome = {
+    kind: "replayed";
+    branch: string;
+    onto: string;
+    commits: number;
+} | {
+    kind: "already-there";
+    branch: string;
+    onto: string;
+} | {
+    kind: "halted";
+    branch: string;
+    onto: string;
+    /** The commit being replayed when it stopped, when git says. */
+    at?: string;
+    /** Paths that disagree, which is what has to be settled. */
+    conflicted: readonly string[];
+} | {
+    kind: "refused";
+    reason: string;
+};
+/** How a halted replay ends. */
+export type ResumeOutcome = {
+    kind: "replayed";
+    branch: string;
+} | {
+    kind: "halted";
+    /**
+     * Which branch stopped, and onto what, when git's replay state says.
+     *
+     * Optional because a halt is reported from a tree whose HEAD is detached,
+     * so this is read from the replay in progress rather than from the tree,
+     * and a state git has half torn down may no longer say. It went unread
+     * for a while and the second halt of a stack printed no branch at all,
+     * which is the moment a reader most needs to know which one.
+     */
+    branch?: string;
+    onto?: string;
+    at?: string;
+    conflicted: readonly string[];
+} | {
+    kind: "abandoned";
+    branch: string;
+} | {
+    kind: "refused";
+    reason: string;
+};
+/** Replaying work in a tree. */
+export interface WorkRebaser {
+    rebase(treePath: string, onto: string): Promise<RebaseOutcome>;
+    /** Carry on a halted replay, once the conflicts are settled. */
+    resume(treePath: string): Promise<ResumeOutcome>;
+    /** Put the tree back the way it was before the replay started. */
+    abandon(treePath: string): Promise<ResumeOutcome>;
+    /** Whether a replay is part-way through, which changes what is safe. */
+    halted(treePath: string): Promise<boolean>;
+}
+/** Replay with plain git. */
+export declare function createGitRebaser(deps: {
+    exec: Exec;
+}): WorkRebaser;

package/dist/work/rebase.js

@@ -0,0 +1,261 @@
+/**
+ * Replaying a branch onto a new base.
+ *
+ * The interesting outcome is not success, it is the halt. A rebase that stops
+ * on a conflict leaves the tree in a state that is neither where it was nor
+ * where it was going, and a tool that reports "failed" and says no more has
+ * handed back a repository the caller now has to diagnose from scratch. So a
+ * halt is a first-class answer that names the commit it stopped on, the paths
+ * that disagree, and the two ways out.
+ *
+ * Nothing here decides for you. Continuing needs the conflicts resolved, which
+ * is work only a person or an agent reading the code can do, and abandoning
+ * throws away whatever replaying had achieved so far. Both are refusals to
+ * guess rather than missing features.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { isAbsolute, join } from "node:path";
+import { unattended } from "./unattended.js";
+/** Read one git value, scoped to the tree, or undefined when git says nothing. */
+async function ask(exec, treePath, args) {
+    const result = await exec("git", ["-C", treePath, ...args]);
+    if (result.code !== 0)
+        return undefined;
+    const said = result.stdout.trim();
+    return said === "" ? undefined : said;
+}
+/** Paths git reports as unmerged. */
+async function conflictedIn(exec, treePath) {
+    const said = await ask(exec, treePath, [
+        "diff",
+        "--name-only",
+        "--diff-filter=U",
+    ]);
+    return said === undefined ? [] : said.split("\n").filter((one) => one !== "");
+}
+/** Replay with plain git. */
+export function createGitRebaser(deps) {
+    const { exec } = deps;
+    async function isHalted(treePath) {
+        // Git keeps a directory while a rebase is in progress, and asking for it
+        // is cheaper and more certain than parsing status output.
+        //
+        // Looked at directly rather than through `test -d`. A subprocess runs in
+        // the process's own working directory, and git reports this path relative
+        // to the tree, so the probe was asking about a directory beside whatever
+        // directory pi happened to be started in. It answered "not rebasing" for
+        // a tree that was mid-rebase, which is the answer that makes resume and
+        // abandon refuse to work at the exact moment they are needed.
+        for (const what of ["rebase-merge", "rebase-apply"]) {
+            const said = await ask(exec, treePath, ["rev-parse", "--git-path", what]);
+            if (said === undefined)
+                continue;
+            if (existsSync(isAbsolute(said) ? said : join(treePath, said)))
+                return true;
+        }
+        return false;
+    }
+    /**
+     * What the replay in progress is doing, as far as git's state says.
+     *
+     * Read from the replay rather than from the tree, because a tree part-way
+     * through one has a detached HEAD: every ordinary way of asking which branch
+     * you are on answers "HEAD", which is why this went unreported for so long.
+     * Git writes the answer down, so the fix is to read what it wrote.
+     *
+     * Every field is best-effort. Nothing here is worth failing a halt over: a
+     * halt with no branch named is thin, and a halt that errored while trying to
+     * name one is worse.
+     */
+    async function replaying(treePath) {
+        const read = async (what) => {
+            const said = await ask(exec, treePath, [
+                "rev-parse",
+                "--git-path",
+                `rebase-merge/${what}`,
+            ]);
+            if (said === undefined)
+                return undefined;
+            const where = isAbsolute(said) ? said : join(treePath, said);
+            if (!existsSync(where))
+                return undefined;
+            try {
+                const text = readFileSync(where, "utf8").trim();
+                return text === "" ? undefined : text;
+            }
+            catch {
+                // Unreadable is the same as unsaid here: the halt is still a halt.
+                return undefined;
+            }
+        };
+        const head = await read("head-name");
+        const onto = await read("onto");
+        const at = await ask(exec, treePath, [
+            "rev-parse",
+            "--short",
+            "REBASE_HEAD",
+        ]);
+        return {
+            // Git records the full ref; a reader wants the branch.
+            ...(head ? { branch: head.replace(/^refs\/heads\//, "") } : {}),
+            ...(onto ? { onto: await nameFor(treePath, onto) } : {}),
+            ...(at ? { at } : {}),
+        };
+    }
+    /**
+     * What to call the commit a replay is heading for.
+     *
+     * Git records the target as a commit, because by then the ref that named it is
+     * beside the point: the replay is onto that commit whatever anybody does to the
+     * branch afterwards. But a halt reported from a resume then said "onto fc00dccd"
+     * where the same halt from starting the replay said "onto main", and the two are
+     * the same event to the person reading them.
+     *
+     * So the commit is named after a branch when exactly one branch is sitting on it.
+     * Exactly one, because more than one is genuinely ambiguous: the replay was onto
+     * some ref and nothing here records which, so picking one would be inventing the
+     * answer rather than reading it. The commit is the honest fallback, and it is
+     * what git had.
+     */
+    async function nameFor(treePath, commit) {
+        const short = commit.slice(0, 8);
+        const said = await ask(exec, treePath, [
+            "for-each-ref",
+            "--format=%(refname:short)",
+            "--points-at",
+            commit,
+            "refs/heads",
+        ]);
+        if (said === undefined)
+            return short;
+        const names = said.split("\n").filter((one) => one !== "");
+        return names.length === 1 && names[0] !== undefined ? names[0] : short;
+    }
+    return {
+        halted: isHalted,
+        async rebase(treePath, onto) {
+            if (await isHalted(treePath)) {
+                return {
+                    kind: "refused",
+                    reason: "A replay is already part-way through in this tree. Settle it first: resume it once the conflicts are resolved, or abandon it to put the tree back.",
+                };
+            }
+            const branch = await ask(exec, treePath, [
+                "rev-parse",
+                "--abbrev-ref",
+                "HEAD",
+            ]);
+            if (branch === undefined || branch === "HEAD") {
+                return {
+                    kind: "refused",
+                    reason: "This tree is not on a branch, so there is nothing to replay.",
+                };
+            }
+            // Uncommitted work and a rebase do not mix, and git's own autostash
+            // would hide the problem rather than state it. A caller who wants
+            // the changes kept should commit them; one who does not should say
+            // so out loud.
+            const dirty = await ask(exec, treePath, ["status", "--porcelain"]);
+            if (dirty !== undefined) {
+                return {
+                    kind: "refused",
+                    reason: `This tree has uncommitted changes, and replaying would have to move them. Record them first, or set them aside deliberately.\n\n${dirty}`,
+                };
+            }
+            const before = await ask(exec, treePath, [
+                "rev-list",
+                "--count",
+                `${onto}..HEAD`,
+            ]);
+            if (before === "0") {
+                return { kind: "already-there", branch, onto };
+            }
+            const result = await exec("git", unattended(["-C", treePath, "rebase", onto]));
+            if (result.code === 0) {
+                return {
+                    kind: "replayed",
+                    branch,
+                    onto,
+                    commits: Number.parseInt(before ?? "0", 10) || 0,
+                };
+            }
+            const conflicted = await conflictedIn(exec, treePath);
+            if (conflicted.length > 0 || (await isHalted(treePath))) {
+                const at = await ask(exec, treePath, [
+                    "rev-parse",
+                    "--short",
+                    "REBASE_HEAD",
+                ]);
+                return {
+                    kind: "halted",
+                    branch,
+                    onto,
+                    ...(at === undefined ? {} : { at }),
+                    conflicted,
+                };
+            }
+            const said = [result.stderr.trim(), result.stdout.trim()]
+                .filter((stream) => stream !== "")
+                .join("\n");
+            return {
+                kind: "refused",
+                reason: said || `git rebase exited ${result.code}`,
+            };
+        },
+        async resume(treePath) {
+            if (!(await isHalted(treePath))) {
+                return {
+                    kind: "refused",
+                    reason: "No replay is part-way through in this tree.",
+                };
+            }
+            const left = await conflictedIn(exec, treePath);
+            if (left.length > 0) {
+                return {
+                    kind: "halted",
+                    conflicted: left,
+                    ...(await replaying(treePath)),
+                };
+            }
+            // The call that hung. Continuing a conflicted pick commits with `-e`,
+            // so without this git opens an editor on a stdin nobody is attached to
+            // and waits for a human who will never arrive.
+            const result = await exec("git", unattended(["-C", treePath, "rebase", "--continue"]));
+            if (result.code !== 0) {
+                const still = await conflictedIn(exec, treePath);
+                if (still.length > 0)
+                    return {
+                        kind: "halted",
+                        conflicted: still,
+                        ...(await replaying(treePath)),
+                    };
+                return {
+                    kind: "refused",
+                    reason: result.stderr.trim() ||
+                        `git rebase --continue exited ${result.code}`,
+                };
+            }
+            const branch = (await ask(exec, treePath, ["rev-parse", "--abbrev-ref", "HEAD"])) ??
+                "HEAD";
+            return { kind: "replayed", branch };
+        },
+        async abandon(treePath) {
+            if (!(await isHalted(treePath))) {
+                return {
+                    kind: "refused",
+                    reason: "No replay is part-way through in this tree.",
+                };
+            }
+            const result = await exec("git", unattended(["-C", treePath, "rebase", "--abort"]));
+            if (result.code !== 0) {
+                return {
+                    kind: "refused",
+                    reason: result.stderr.trim() || `git rebase --abort exited ${result.code}`,
+                };
+            }
+            const branch = (await ask(exec, treePath, ["rev-parse", "--abbrev-ref", "HEAD"])) ??
+                "HEAD";
+            return { kind: "abandoned", branch };
+        },
+    };
+}

package/dist/work/reclaim.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Taking back a tree nothing owns any more.
+ *
+ * This is the one cleanup verb here that acts rather than reporting,
+ * and the asymmetry with {@link tidyPlan} is deliberate. Deleting a
+ * branch destroys the only name a commit had, so tidy refuses to do
+ * it. Removing a worktree destroys a directory and git's bookkeeping
+ * for it, and leaves the branch exactly where it was: the commits stay
+ * reachable, and re-cutting the tree at the same branch puts a person
+ * back where they were. A report whose only follow-through is the
+ * `git worktree` call the guide says never to make is not a path, so
+ * this supplies the path.
+ *
+ * What may be taken back is {@link orphanedTrees}'s decision, and this
+ * removes nothing it did not offer. The dirty tree and the tree whose
+ * work trunk cannot vouch for stay where they are.
+ */
+import { type Exec } from "../exec/index.js";
+import type { Reclaimable } from "./tidy.js";
+/** What became of one tree. */
+export type ReclaimedTree = {
+    kind: "reclaimed";
+    path: string;
+    branch?: string;
+}
+/**
+ * Git would not let go of it, and the tree is still there.
+ *
+ * Reported per tree rather than thrown, because the whole point of
+ * this verb is a backlog: one tree git objects to must not strand
+ * the fourteen behind it.
+ */
+ | {
+    kind: "refused";
+    path: string;
+    why: string;
+};
+/** What a sweep did, tree by tree, in the order it went. */
+export interface ReclaimOutcome {
+    trees: ReclaimedTree[];
+}
+/** Where a reclaim runs and what it runs with. */
+export interface ReclaimDeps {
+    exec: Exec;
+    /** The checkout git's worktree bookkeeping lives in. */
+    mainPath: string;
+}
+/**
+ * Take back each tree offered, and say what happened to every one.
+ *
+ * The branch is never touched. `git worktree remove` takes the
+ * directory and the administrative files; whatever was checked out
+ * there is still a branch afterwards, which is what makes this
+ * recoverable and therefore allowed to act.
+ */
+export declare function reclaimTrees(deps: ReclaimDeps, offered: readonly Reclaimable[]): Promise<ReclaimOutcome>;

package/dist/work/reclaim.js

@@ -0,0 +1,52 @@
+/**
+ * Taking back a tree nothing owns any more.
+ *
+ * This is the one cleanup verb here that acts rather than reporting,
+ * and the asymmetry with {@link tidyPlan} is deliberate. Deleting a
+ * branch destroys the only name a commit had, so tidy refuses to do
+ * it. Removing a worktree destroys a directory and git's bookkeeping
+ * for it, and leaves the branch exactly where it was: the commits stay
+ * reachable, and re-cutting the tree at the same branch puts a person
+ * back where they were. A report whose only follow-through is the
+ * `git worktree` call the guide says never to make is not a path, so
+ * this supplies the path.
+ *
+ * What may be taken back is {@link orphanedTrees}'s decision, and this
+ * removes nothing it did not offer. The dirty tree and the tree whose
+ * work trunk cannot vouch for stay where they are.
+ */
+import { run } from "../exec/index.js";
+import { displayPath } from "../ui/path.js";
+/**
+ * Take back each tree offered, and say what happened to every one.
+ *
+ * The branch is never touched. `git worktree remove` takes the
+ * directory and the administrative files; whatever was checked out
+ * there is still a branch afterwards, which is what makes this
+ * recoverable and therefore allowed to act.
+ */
+export async function reclaimTrees(deps, offered) {
+    const trees = [];
+    for (const tree of offered) {
+        try {
+            await run(deps.exec, "git", ["-C", deps.mainPath, "worktree", "remove", tree.path], `Taking back ${displayPath(tree.path)}`);
+            trees.push({
+                kind: "reclaimed",
+                path: tree.path,
+                ...(tree.branch ? { branch: tree.branch } : {}),
+            });
+        }
+        catch (error) {
+            // Git's own words. It refuses a tree with anything untracked in
+            // it even when status called the tree clean, since an ignored
+            // build directory is untracked too, and hearing that from git
+            // beats being told the tree "could not be removed".
+            trees.push({
+                kind: "refused",
+                path: tree.path,
+                why: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    return { trees };
+}

package/dist/work/register.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Tree provider registration.
+ *
+ * Process-global and keyed by id, so a provider in another package
+ * registers itself and is used, whichever order the two happened to
+ * load in. Mirrors the review and tree registries and uses the same
+ * shared globalThis-slot helper, so a module reimport does not lose
+ * registrations.
+ *
+ * Listing sorts by specificity rather than registration order,
+ * because the order providers are consulted in is part of the
+ * contract and no caller should have to re-sort to get it right.
+ */
+import type { TreeProvider } from "./broker.js";
+/**
+ * Register a tree provider, replacing any provider already
+ * registered under the same id.
+ *
+ * Replacing rather than adding matters: a provider re-registers
+ * after a reload, and the host announces itself again, so
+ * registering twice is the ordinary case rather than a mistake.
+ */
+export declare function registerTreeProvider(provider: TreeProvider): void;
+/** Remove a provider from the registry. Idempotent. */
+export declare function unregisterTreeProvider(id: string): void;
+/** Every registered provider, most specific first. */
+export declare function listTreeProviders(): TreeProvider[];
+/** Empty the registry. Intended for tests. */
+export declare function clearTreeProviders(): void;

package/dist/work/register.js

@@ -0,0 +1,41 @@
+/**
+ * Tree provider registration.
+ *
+ * Process-global and keyed by id, so a provider in another package
+ * registers itself and is used, whichever order the two happened to
+ * load in. Mirrors the review and tree registries and uses the same
+ * shared globalThis-slot helper, so a module reimport does not lose
+ * registrations.
+ *
+ * Listing sorts by specificity rather than registration order,
+ * because the order providers are consulted in is part of the
+ * contract and no caller should have to re-sort to get it right.
+ */
+import { createGlobalSymbolRegistry } from "../internal/registry/global-symbol-registry.js";
+const registry = createGlobalSymbolRegistry({
+    slot: "pi:agentic-harness:work-tree-providers",
+    getId: (provider) => provider.id,
+});
+/**
+ * Register a tree provider, replacing any provider already
+ * registered under the same id.
+ *
+ * Replacing rather than adding matters: a provider re-registers
+ * after a reload, and the host announces itself again, so
+ * registering twice is the ordinary case rather than a mistake.
+ */
+export function registerTreeProvider(provider) {
+    registry.register(provider);
+}
+/** Remove a provider from the registry. Idempotent. */
+export function unregisterTreeProvider(id) {
+    registry.unregister(id);
+}
+/** Every registered provider, most specific first. */
+export function listTreeProviders() {
+    return [...registry.list()].sort((a, b) => b.specificity - a.specificity);
+}
+/** Empty the registry. Intended for tests. */
+export function clearTreeProviders() {
+    registry.clear();
+}