cloving 0.3.19 → 1.0.1

package/dist/src/daemon/ticket-registration.js

@@ -0,0 +1,177 @@
+import { createHash } from "node:crypto";
+import { admitCompiled } from "../cli/validate.js";
+import { ticketCommandText, ticketText } from "./ticket-source.js";
+export const ticketWorkflow = "develop-ticket";
+export const promptWorkflow = "develop-prompt";
+export const issueWorkflow = "develop-issue";
+export const ticketCapabilities = ["claude", "github"];
+const ticketIdentifier = /^[A-Za-z0-9._:-]{1,64}$/;
+function rejected(code, detail) {
+    return { kind: "rejected", code, detail };
+}
+function digest(commandId) {
+    return createHash("sha256").update(commandId).digest("hex");
+}
+async function ticket(source, request) {
+    const { command, repository } = source;
+    const ticketId = String(request.submission["ticket"]);
+    if (ticketId === "next")
+        return nextTicket(source, request);
+    if (!ticketIdentifier.test(ticketId))
+        return rejected("invalid-ticket-id", "A ticket ID has letters, digits and the characters . _ : - only.");
+    if (command === undefined)
+        return rejected("ticket-source-not-configured", "The daemon has no ticket command. Set CLOVING_TICKET_COMMAND, or use the workflow develop-prompt.");
+    const read = await ticketText(command, { ticketId, signal: request.signal });
+    if (read.kind === "failed")
+        return rejected("ticket-not-available", read.detail);
+    const name = ticketId.toLowerCase().replace(/[^a-z0-9-]/g, "-");
+    return {
+        kind: "resolved",
+        input: {
+            cycleId: `${name}-${digest(request.commandId).slice(0, 8)}`,
+            ticketId,
+            ticket: read.text,
+            repository,
+        },
+    };
+}
+async function nextTicket(source, request) {
+    if (source.nextCommand === undefined)
+        return rejected("next-source-not-configured", "The daemon has no next-ticket command. Set CLOVING_NEXT_COMMAND.");
+    const selected = await ticketCommandText(source.nextCommand, request.signal);
+    if (selected.kind === "failed")
+        return rejected("next-ticket-not-available", selected.detail);
+    if (selected.text === "")
+        return rejected("no-ready-ticket", "The next-ticket command printed no ticket ID.");
+    if (!ticketIdentifier.test(selected.text) || selected.text === "next")
+        return rejected("invalid-ticket-id", "The next-ticket command must print one valid ticket ID other than next.");
+    return ticket(source, { ...request, submission: { ticket: selected.text } });
+}
+export function ticketResolver(source) {
+    return {
+        id: "ticket-command",
+        version: "1",
+        resolve: (request) => ticket(source, request),
+    };
+}
+export function issueResolver(source) {
+    return {
+        id: "issue-command",
+        version: "1",
+        resolve: async (request) => {
+            const resolution = await ticket(source, request);
+            if (resolution.kind === "rejected")
+                return resolution;
+            return {
+                kind: "resolved",
+                input: { ...Object(resolution.input), delivery: "pull-request" },
+            };
+        },
+    };
+}
+export function promptResolver(repository) {
+    return {
+        id: "ticket-prompt",
+        version: "1",
+        resolve: (request) => Promise.resolve({
+            kind: "resolved",
+            input: {
+                cycleId: `task-${digest(request.commandId).slice(0, 12)}`,
+                ticket: String(request.submission["prompt"]),
+                repository,
+            },
+        }),
+    };
+}
+export function ticketRegistrationTable(source, declarations = []) {
+    return [
+        {
+            workflowId: ticketWorkflow,
+            functionName: "developTicket",
+            effectLimit: 8,
+            submission: { maximumBytes: 4_096, fields: { ticket: "string" } },
+            resolver: ticketResolver(source),
+        },
+        {
+            workflowId: issueWorkflow,
+            functionName: "developTicket",
+            effectLimit: 20,
+            submission: { maximumBytes: 4_096, fields: { ticket: "string" } },
+            resolver: issueResolver(source),
+        },
+        {
+            workflowId: "develop-prd",
+            functionName: "developPrd",
+            effectLimit: 8,
+            submission: { maximumBytes: 65_536, fields: { prompt: "string" } },
+            resolver: promptResolver(source.repository),
+        },
+        {
+            workflowId: promptWorkflow,
+            functionName: "developTicket",
+            effectLimit: 8,
+            submission: { maximumBytes: 65_536, fields: { prompt: "string" } },
+            resolver: promptResolver(source.repository),
+        },
+        ...declarations.map((declaration) => ({
+            workflowId: declaration.workflowId,
+            functionName: declaration.functionName,
+            effectLimit: declaration.effectLimit,
+            capabilities: declaration.capabilities,
+            submission: declaration.input,
+            resolver: declaredResolver(source.repository),
+        })),
+    ];
+}
+function declaredResolver(repository) {
+    return {
+        id: "declared-input",
+        version: "1",
+        resolve: (request) => Promise.resolve({
+            kind: "resolved",
+            input: {
+                cycleId: `task-${digest(request.commandId).slice(0, 12)}`,
+                repository,
+                input: request.submission,
+            },
+        }),
+    };
+}
+export async function ticketRegistrations(manifests, options) {
+    const ids = new Set();
+    for (const row of options.table) {
+        if (ids.has(row.workflowId))
+            return {
+                kind: "rejected",
+                detail: `duplicate-workflow-id: ${row.workflowId}`,
+            };
+        ids.add(row.workflowId);
+    }
+    const registrations = [];
+    for (const row of options.table) {
+        const manifest = manifests[row.functionName];
+        if (manifest === undefined)
+            return {
+                kind: "rejected",
+                detail: `Missing manifest for workflow function ${row.functionName}.`,
+            };
+        const admission = await admitCompiled(manifest, {
+            file: manifest,
+            capabilities: row.capabilities ?? ticketCapabilities,
+        });
+        if (admission.kind === "rejected")
+            return {
+                kind: "rejected",
+                detail: `${admission.error.code}: ${admission.error.detail}`,
+            };
+        registrations.push({
+            workflowId: row.workflowId,
+            manifest: admission.manifest,
+            availability: "available",
+            effectLimit: row.effectLimit,
+            submission: row.submission,
+            resolver: row.resolver,
+        });
+    }
+    return { kind: "admitted", registrations };
+}

package/dist/src/daemon/ticket-source.d.ts

@@ -0,0 +1,17 @@
+export declare const ticketLimits: {
+    textBytes: number;
+    detailCharacters: number;
+};
+export type TicketRead = {
+    readonly kind: "read";
+    readonly text: string;
+} | {
+    readonly kind: "failed";
+    readonly detail: string;
+};
+export interface TicketRequest {
+    readonly ticketId: string;
+    readonly signal: AbortSignal;
+}
+export declare function ticketText(command: readonly string[], request: TicketRequest): Promise<TicketRead>;
+export declare function ticketCommandText(command: readonly string[], signal: AbortSignal): Promise<TicketRead>;

package/dist/src/daemon/ticket-source.js

@@ -0,0 +1,36 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+export const ticketLimits = { textBytes: 48_000, detailCharacters: 300 };
+function failed(detail) {
+    return { kind: "failed", detail };
+}
+function printed(output) {
+    const text = output.trim();
+    if (text === "")
+        return failed("The ticket command printed no text.");
+    if (Buffer.byteLength(text) > ticketLimits.textBytes)
+        return failed(`The ticket text has more than ${String(ticketLimits.textBytes)} bytes.`);
+    return { kind: "read", text };
+}
+function ended(error) {
+    const code = Reflect.get(Object(error), "code");
+    const cause = String(Reflect.get(Object(error), "stderr"))
+        .trim()
+        .slice(0, ticketLimits.detailCharacters);
+    return typeof code === "number"
+        ? failed(`The ticket command ended with the code ${String(code)}: ${cause}`)
+        : failed(`The ticket command did not complete: ${String(code)}`);
+}
+const executed = promisify(execFile);
+export function ticketText(command, request) {
+    const [executable = "", ...fixed] = command;
+    return ticketCommandText([executable, ...fixed, request.ticketId], request.signal).then((result) => result.kind === "failed" ? result : printed(result.text));
+}
+export function ticketCommandText(command, signal) {
+    const [executable = "", ...fixed] = command;
+    return executed(executable, fixed, {
+        signal,
+        maxBuffer: 4 * ticketLimits.textBytes,
+        encoding: "utf8",
+    }).then((output) => ({ kind: "read", text: output.stdout.trim() }), ended);
+}

package/dist/src/daemon/work-tree.d.ts

@@ -0,0 +1,26 @@
+export interface WorkTree {
+    readonly path: string;
+    readonly branch: string;
+    readonly startCommit: string;
+}
+export interface TreeRequest {
+    readonly repository: string;
+    readonly worktrees: string;
+    readonly target: string;
+    readonly signal: AbortSignal;
+    readonly base?: string;
+}
+export interface Changes {
+    readonly branch: string;
+    readonly commits: readonly string[];
+    readonly files: readonly string[];
+    readonly uncommitted: readonly string[];
+}
+export declare function treeName(target: string): string;
+export declare function treePlace(request: Pick<TreeRequest, "worktrees" | "target">): {
+    readonly path: string;
+    readonly branch: string;
+};
+export declare function workTree(request: TreeRequest): Promise<WorkTree>;
+export declare function treeFailure(error: unknown): string;
+export declare function changes(tree: WorkTree): Promise<Changes>;

package/dist/src/daemon/work-tree.js

@@ -0,0 +1,206 @@
+import { execFile, spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { mkdir, realpath } from "node:fs/promises";
+import { join, relative, resolve, sep } from "node:path";
+import { promisify } from "node:util";
+const executed = promisify(execFile);
+const lineLimit = 30;
+const lineLength = 120;
+async function git(call) {
+    const { directory, parts, signal } = call;
+    const { stdout } = await executed("git", ["-C", directory, ...parts], {
+        ...(signal === undefined ? {} : { signal }),
+    });
+    return stdout;
+}
+export function treeName(target) {
+    return target
+        .replace(/[^A-Za-z0-9._-]/g, "-")
+        .replace(/\.{2,}/g, "-")
+        .replace(/^\.|\.$/g, "-")
+        .replace(/\.lock$/, "-lock");
+}
+async function added(request, tree) {
+    const { repository, worktrees, signal } = request;
+    const call = (parts) => git({ directory: repository, parts, signal });
+    await call(["worktree", "prune"]);
+    await mkdir(worktrees, { recursive: true });
+    const known = await call([
+        "rev-parse",
+        "--verify",
+        "--quiet",
+        `refs/heads/${tree.branch}`,
+    ]).then(() => true, () => false);
+    await call(known
+        ? ["worktree", "add", tree.path, tree.branch]
+        : [
+            "worktree",
+            "add",
+            "-b",
+            tree.branch,
+            tree.path,
+            request.base ?? "HEAD",
+        ]);
+}
+export function treePlace(request) {
+    const name = treeName(request.target);
+    return { path: join(request.worktrees, name), branch: `cloving/${name}` };
+}
+export async function workTree(request) {
+    if (request.target.startsWith("branch:"))
+        return branchTree(request).catch((error) => {
+            const reason = treeFailure(error);
+            throw new Error(reason === "work-tree-not-available"
+                ? "branch-worktree-not-found"
+                : reason);
+        });
+    const { path, branch } = treePlace(request);
+    if (!existsSync(join(path, ".git")))
+        await added(request, { path, branch });
+    const head = await git({
+        directory: path,
+        parts: ["rev-parse", "HEAD"],
+        signal: request.signal,
+    });
+    return { path, branch, startCommit: head.trim() };
+}
+async function branchTree(request) {
+    const branch = request.target.slice("branch:".length);
+    if (branch.startsWith("cloving/"))
+        throw new Error("branch-reserved");
+    const listing = await git({
+        directory: request.repository,
+        parts: ["worktree", "list", "--porcelain", "-z"],
+        signal: request.signal,
+    });
+    const entry = listing
+        .split("\0\0")
+        .slice(1)
+        .find((record) => record.split("\0").includes(`branch refs/heads/${branch}`));
+    const path = entry?.split("\0")[0]?.slice("worktree ".length);
+    if (path === undefined)
+        throw new Error("branch-worktree-not-found");
+    await sameBranch(request, { path, branch });
+    await outsideManaged(request, path);
+    await cleanBranch({ directory: path, signal: request.signal });
+    const head = await git({
+        directory: path,
+        parts: ["rev-parse", "HEAD"],
+        signal: request.signal,
+    });
+    return { path, branch, startCommit: head.trim() };
+}
+async function outsideManaged(request, path) {
+    const folder = await realpath(request.worktrees).catch((error) => {
+        if (typeof error !== "object" ||
+            error === null ||
+            !("code" in error) ||
+            error.code !== "ENOENT")
+            throw error;
+        return resolve(request.worktrees);
+    });
+    const location = relative(folder, await realpath(path));
+    if (location !== ".." && !location.startsWith(`..${sep}`))
+        throw new Error("branch-reserved");
+}
+async function sameBranch(request, tree) {
+    const common = async (directory) => {
+        const folder = await git({
+            directory,
+            parts: ["rev-parse", "--git-common-dir"],
+            signal: request.signal,
+        });
+        return realpath(resolve(directory, folder.trim()));
+    };
+    if ((await common(request.repository)) !== (await common(tree.path)))
+        throw new Error("branch-worktree-not-found");
+    const head = await git({
+        directory: tree.path,
+        parts: ["symbolic-ref", "--quiet", "HEAD"],
+        signal: request.signal,
+    });
+    if (head.trim() !== `refs/heads/${tree.branch}`)
+        throw new Error("branch-worktree-not-found");
+}
+async function cleanBranch(place) {
+    await cleanOutput({
+        ...place,
+        parts: [
+            "-c",
+            "core.fileMode=true",
+            "status",
+            "--porcelain",
+            "--untracked-files=all",
+            "--ignore-submodules=none",
+        ],
+    }, hasOutput);
+    await cleanOutput({ ...place, parts: ["ls-files", "-v", "-z"] }, hiddenIndex);
+}
+async function hasOutput(output) {
+    let present = false;
+    for await (const chunk of output) {
+        if (chunk.length > 0)
+            present = true;
+    }
+    return present;
+}
+async function hiddenIndex(output) {
+    let entryStart = true;
+    let hidden = false;
+    for await (const chunk of output) {
+        for (const character of chunk.toString()) {
+            if (entryStart && /[a-zS]/.test(character))
+                hidden = true;
+            entryStart = character === "\0";
+        }
+    }
+    return hidden;
+}
+async function cleanOutput(call, inspect) {
+    const child = spawn("git", ["-C", call.directory, ...call.parts], {
+        stdio: ["ignore", "pipe", "ignore"],
+        ...(call.signal === undefined ? {} : { signal: call.signal }),
+    });
+    const ended = new Promise((resolve) => {
+        child.once("error", () => {
+            resolve(false);
+        });
+        child.once("close", (code) => {
+            resolve(code === 0);
+        });
+    });
+    const dirty = await inspect(child.stdout);
+    if (!(await ended))
+        throw new Error("branch-worktree-not-found");
+    if (dirty)
+        throw new Error("branch-worktree-not-clean");
+}
+export function treeFailure(error) {
+    const reason = error instanceof Error ? error.message : "";
+    return [
+        "branch-worktree-not-found",
+        "branch-worktree-not-clean",
+        "branch-reserved",
+    ].includes(reason)
+        ? reason
+        : "work-tree-not-available";
+}
+export async function changes(tree) {
+    const lines = async (parts) => (await git({ directory: tree.path, parts }).catch(() => ""))
+        .split("\n")
+        .filter((line) => line.trim() !== "")
+        .slice(0, lineLimit)
+        .map((line) => line.slice(0, lineLength));
+    const range = `${tree.startCommit}..HEAD`;
+    const [branch = tree.branch] = await lines([
+        "rev-parse",
+        "--abbrev-ref",
+        "HEAD",
+    ]);
+    return {
+        branch,
+        commits: await lines(["log", "--oneline", range]),
+        files: await lines(["diff", "--stat", range]),
+        uncommitted: await lines(["status", "--short"]),
+    };
+}

package/dist/src/effect-authorization.d.ts

@@ -0,0 +1,21 @@
+export interface EffectBudget {
+    readonly limit: number;
+    readonly spent: number;
+}
+export interface EffectRequest {
+    readonly capability: string;
+    readonly units: number;
+}
+export type EffectAuthorization = {
+    readonly kind: "authorized";
+    readonly spent: number;
+} | {
+    readonly kind: "rejected";
+    readonly reason: string;
+};
+export declare function authorizeEffect(manifest: {
+    readonly capabilities: readonly string[];
+}, effect: {
+    readonly budget: EffectBudget;
+    readonly request: EffectRequest;
+}): EffectAuthorization;

package/dist/src/effect-authorization.js

@@ -0,0 +1,14 @@
+export function authorizeEffect(manifest, effect) {
+    const { budget, request } = effect;
+    if (![budget.limit, budget.spent].every((value) => Number.isSafeInteger(value) && value >= 0) ||
+        !Number.isSafeInteger(request.units) ||
+        request.units < 1 ||
+        budget.spent > budget.limit)
+        return { kind: "rejected", reason: "invalid-effect-request" };
+    if (!manifest.capabilities.includes(request.capability))
+        return { kind: "rejected", reason: "unadmitted-capability" };
+    const spent = budget.spent + request.units;
+    if (spent > budget.limit)
+        return { kind: "rejected", reason: "budget-exhausted" };
+    return { kind: "authorized", spent };
+}

package/dist/src/execution-pin.d.ts

@@ -0,0 +1,4 @@
+import type { AdmissionResult, ExecutionManifest } from "./workflow-admission.ts";
+export declare function pinnedIdentity(manifest: ExecutionManifest): string;
+export declare function resumePinned(pinned: ExecutionManifest, available: ExecutionManifest): AdmissionResult;
+export declare function readExecutionManifest(value: unknown): ExecutionManifest;

package/dist/src/execution-pin.js

@@ -0,0 +1,68 @@
+const canonical = {
+    name: (manifest) => JSON.stringify(manifest.name),
+    workflowId: (manifest) => JSON.stringify(manifest.workflowId),
+    steps: (manifest) => JSON.stringify([...manifest.steps].sort()),
+    capabilities: (manifest) => JSON.stringify([...manifest.capabilities].sort()),
+    artifacts: (manifest) => JSON.stringify(Object.keys(manifest.artifacts)
+        .sort()
+        .map((name) => [name, manifest.artifacts[name]])),
+    resources: (manifest) => JSON.stringify(Object.keys(manifest.resources)
+        .sort()
+        .map((name) => [name, manifest.resources[name]])),
+    toolchain: (manifest) => JSON.stringify(["sdk", "world", "builder", "node", "dependencies"].map((key) => manifest.toolchain[key])),
+};
+const fields = [
+    "name",
+    "workflowId",
+    "steps",
+    "capabilities",
+    "artifacts",
+    "resources",
+    "toolchain",
+];
+export function pinnedIdentity(manifest) {
+    return JSON.stringify(fields.map((field) => canonical[field](manifest)));
+}
+export function resumePinned(pinned, available) {
+    const changed = fields.find((field) => canonical[field](pinned) !== canonical[field](available));
+    if (changed !== undefined)
+        return {
+            kind: "rejected",
+            reason: "pinned-manifest-mismatch",
+            detail: changed,
+        };
+    return { kind: "admitted", manifest: pinned };
+}
+export function readExecutionManifest(value) {
+    const fields = record(value);
+    const toolchain = record(fields["toolchain"]);
+    return {
+        name: text(fields["name"]),
+        workflowId: text(fields["workflowId"]),
+        steps: texts(fields["steps"]),
+        capabilities: texts(fields["capabilities"]),
+        artifacts: textRecord(fields["artifacts"]),
+        resources: textRecord(fields["resources"]),
+        toolchain: {
+            sdk: text(toolchain["sdk"]),
+            world: text(toolchain["world"]),
+            builder: text(toolchain["builder"]),
+            node: text(toolchain["node"]),
+            dependencies: text(toolchain["dependencies"]),
+        },
+    };
+}
+function record(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return {};
+    return Object.fromEntries(Object.entries(value));
+}
+function text(value) {
+    return typeof value === "string" ? value : "";
+}
+function texts(value) {
+    return Array.isArray(value) ? value.map(text) : [];
+}
+function textRecord(value) {
+    return Object.fromEntries(Object.entries(record(value)).map(([key, item]) => [key, text(item)]));
+}

package/dist/src/host/start-delivery.d.ts

@@ -0,0 +1,41 @@
+import { type TaggedRun } from "./world-runs.ts";
+export type WorkflowFunction = (input: unknown, continuation?: Continuation) => Promise<unknown>;
+export interface Continuation {
+    readonly gateId: string;
+    readonly decision: string;
+    readonly answer: string | null;
+}
+export interface RunIntent extends Partial<Continuation> {
+    readonly kind: string;
+    readonly runId: string;
+    readonly operationId: string;
+}
+export type RunOutcome = {
+    readonly kind: "accepted";
+    readonly receipt: string;
+} | {
+    readonly kind: "stopped";
+    readonly receipt: string;
+} | {
+    readonly kind: "absent";
+} | {
+    readonly kind: "unknown";
+    readonly evidence: string;
+};
+type OperationRun = Pick<TaggedRun, "receipt" | "operationId" | "status">;
+export interface StartParts {
+    readonly runs: () => Promise<readonly OperationRun[]>;
+    readonly input: (runId: string) => Promise<string | undefined>;
+    readonly document: (digest: string) => Promise<string | undefined>;
+    readonly workflow: (runId: string) => Promise<WorkflowFunction | undefined>;
+    readonly cancel: (receipt: string) => Promise<string>;
+}
+export interface StartDelivery {
+    readonly reconcile: (intent: RunIntent) => Promise<RunOutcome>;
+    readonly deliver: (intent: RunIntent) => Promise<{
+        readonly receipt: string;
+    }>;
+    readonly stop: (intent: RunIntent) => Promise<RunOutcome>;
+}
+export declare function startDelivery(parts: StartParts): StartDelivery;
+export {};

package/dist/src/host/start-delivery.js

@@ -0,0 +1,68 @@
+import { start } from "workflow/api";
+import { operationTag, runTag } from "./world-runs.js";
+const ends = ["cancelled", "completed", "failed"];
+async function segments(parts, intent) {
+    return (await parts.runs()).filter((run) => run.operationId === intent.operationId);
+}
+async function reconciled(parts, intent) {
+    const found = await segments(parts, intent);
+    const [first, ...others] = found;
+    if (first === undefined)
+        return { kind: "absent" };
+    if (others.length === 0)
+        return { kind: "accepted", receipt: first.receipt };
+    return {
+        kind: "unknown",
+        evidence: found.map((run) => `world-run:${run.receipt}`).join(" "),
+    };
+}
+async function continuation(parts, intent) {
+    const { kind, gateId, decision, answer } = intent;
+    if (kind === "start-run")
+        return undefined;
+    if (kind !== "continue-run" || gateId === undefined || decision === undefined)
+        throw new Error(`unsupported-intent: ${kind}`);
+    if (answer === undefined || answer === null)
+        return { gateId, decision, answer: null };
+    const text = await parts.document(answer);
+    if (text === undefined)
+        throw new Error(`answer-not-available: ${gateId}`);
+    return { gateId, decision, answer: text };
+}
+async function delivered(parts, intent) {
+    const continued = await continuation(parts, intent);
+    const workflow = await parts.workflow(intent.runId);
+    const input = await parts.input(intent.runId);
+    if (workflow === undefined || input === undefined)
+        throw new Error(`start-not-available: ${intent.runId}`);
+    const argument = JSON.parse(input);
+    const started = await start(workflow, [argument, continued], {
+        attributes: {
+            [runTag]: intent.runId,
+            [operationTag]: intent.operationId,
+        },
+    });
+    return { receipt: started.runId };
+}
+async function stopped(parts, intent) {
+    const found = await segments(parts, intent);
+    const [first] = found;
+    if (first === undefined)
+        return { kind: "absent" };
+    const alive = [];
+    for (const run of found.filter((run) => !ends.includes(run.status))) {
+        const status = await parts.cancel(run.receipt);
+        if (!ends.includes(status))
+            alive.push(`world-run:${run.receipt} ${status}`);
+    }
+    if (alive.length > 0)
+        return { kind: "unknown", evidence: alive.join(" ") };
+    return { kind: "stopped", receipt: first.receipt };
+}
+export function startDelivery(parts) {
+    return {
+        reconcile: (intent) => reconciled(parts, intent),
+        deliver: (intent) => delivered(parts, intent),
+        stop: (intent) => stopped(parts, intent),
+    };
+}