@fusionkit/model-gateway 0.1.0

package/dist/fusion-gateway.js

@@ -0,0 +1,355 @@
+/**
+ * Fusion Harness Gateway — the provider-facing front door that lets a coding
+ * tool (Codex, Claude Code, Cursor via Cursorkit) be the entrypoint. A prompt
+ * sent from the tool hits this gateway, which translates the request into a
+ * dialect-agnostic prompt, runs the unified HandoffKit/FusionKit harness
+ * ensemble through an injected runner, then translates the synthesized final
+ * answer back into the tool's native wire format.
+ *
+ * The runner is injected (not imported) so this package stays free of a
+ * dependency on `@fusionkit/ensemble`, which already depends on this package.
+ */
+import { once } from "node:events";
+import { createServer } from "node:http";
+import { newTraceId, TRACE_ID_HEADER } from "@fusionkit/protocol";
+import { chatToAnthropicMessage, openAiSseToAnthropic } from "./adapters/anthropic.js";
+import { chatToResponses, openAiSseToResponses } from "./adapters/responses.js";
+export const FUSION_RUN_ID_HEADER = "x-fusion-run-id";
+export const FUSION_STATUS_HEADER = "x-fusion-status";
+export const FUSION_EVIDENCE_HEADER = "x-fusion-evidence";
+export const FUSION_REPORT_HEADER = "x-fusion-report";
+const DEFAULT_MODEL = "fusion-panel";
+function partText(part) {
+    if (typeof part.text === "string")
+        return part.text;
+    return "";
+}
+function contentToText(content) {
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        return content.map((part) => partText(part)).join("");
+    }
+    return "";
+}
+export function promptFromResponses(body) {
+    const parts = [];
+    if (typeof body.instructions === "string" && body.instructions.length > 0) {
+        parts.push(body.instructions);
+    }
+    const input = body.input;
+    if (typeof input === "string") {
+        parts.push(input);
+    }
+    else if (Array.isArray(input)) {
+        for (const item of input) {
+            const type = item.type;
+            if (type === "function_call" || type === "function_call_output")
+                continue;
+            const content = item.content;
+            const text = contentToText(content);
+            if (text.length > 0)
+                parts.push(text);
+        }
+    }
+    return parts.join("\n\n").trim();
+}
+export function promptFromAnthropic(body) {
+    const parts = [];
+    if (typeof body.system === "string" && body.system.length > 0) {
+        parts.push(body.system);
+    }
+    else if (Array.isArray(body.system)) {
+        parts.push(body.system.map((block) => block.text).join("\n"));
+    }
+    for (const message of body.messages ?? []) {
+        if (message.role !== "user")
+            continue;
+        const text = contentToText(message.content);
+        if (text.length > 0)
+            parts.push(text);
+    }
+    return parts.join("\n\n").trim();
+}
+export function promptFromChat(body) {
+    const parts = [];
+    for (const message of body.messages ?? []) {
+        if (message.role !== "user" && message.role !== "system")
+            continue;
+        const text = contentToText(message.content);
+        if (text.length > 0)
+            parts.push(text);
+    }
+    return parts.join("\n\n").trim();
+}
+// ---- response formatting ----
+function syntheticOpenAiResponse(finalOutput) {
+    return {
+        id: Math.random().toString(36).slice(2, 12),
+        choices: [{ message: { content: finalOutput }, finish_reason: "stop" }],
+        usage: { prompt_tokens: 0, completion_tokens: 0 }
+    };
+}
+export function formatResponses(finalOutput, model) {
+    return chatToResponses(syntheticOpenAiResponse(finalOutput), model);
+}
+export function formatAnthropic(finalOutput, model) {
+    return chatToAnthropicMessage(syntheticOpenAiResponse(finalOutput), model);
+}
+export function formatChat(finalOutput, model) {
+    return {
+        id: `chatcmpl_${Math.random().toString(36).slice(2, 12)}`,
+        object: "chat.completion",
+        created: Math.floor(Date.now() / 1000),
+        model,
+        choices: [
+            {
+                index: 0,
+                message: { role: "assistant", content: finalOutput },
+                finish_reason: "stop"
+            }
+        ],
+        usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 }
+    };
+}
+// ---- streaming ----
+const SSE_ENCODER = new TextEncoder();
+/**
+ * Build a synthetic OpenAI Chat Completions SSE stream carrying a single
+ * already-complete answer. The existing Responses/Anthropic SSE translators
+ * consume this to emit each dialect's native streamed event sequence.
+ */
+function openAiChatSseFromText(finalOutput) {
+    const frames = [
+        `data: ${JSON.stringify({
+            choices: [{ index: 0, delta: { role: "assistant", content: finalOutput }, finish_reason: null }]
+        })}\n\n`,
+        `data: ${JSON.stringify({
+            choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
+            usage: { prompt_tokens: 0, completion_tokens: 0 }
+        })}\n\n`,
+        "data: [DONE]\n\n"
+    ];
+    let index = 0;
+    return new ReadableStream({
+        pull(controller) {
+            if (index < frames.length) {
+                controller.enqueue(SSE_ENCODER.encode(frames[index]));
+                index += 1;
+            }
+            else {
+                controller.close();
+            }
+        }
+    });
+}
+async function pipeSse(res, stream) {
+    res.statusCode = 200;
+    res.setHeader("content-type", "text/event-stream");
+    res.setHeader("cache-control", "no-cache");
+    const reader = stream.getReader();
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            if (value !== undefined && !res.write(Buffer.from(value)))
+                await once(res, "drain");
+        }
+    }
+    finally {
+        res.end();
+    }
+}
+function writeChatSse(res, finalOutput, model) {
+    res.statusCode = 200;
+    res.setHeader("content-type", "text/event-stream");
+    res.setHeader("cache-control", "no-cache");
+    const id = `chatcmpl_${Math.random().toString(36).slice(2, 12)}`;
+    const created = Math.floor(Date.now() / 1000);
+    res.write(`data: ${JSON.stringify({
+        id,
+        object: "chat.completion.chunk",
+        created,
+        model,
+        choices: [{ index: 0, delta: { role: "assistant", content: finalOutput }, finish_reason: null }]
+    })}\n\n`);
+    res.write(`data: ${JSON.stringify({
+        id,
+        object: "chat.completion.chunk",
+        created,
+        model,
+        choices: [{ index: 0, delta: {}, finish_reason: "stop" }]
+    })}\n\n`);
+    res.write("data: [DONE]\n\n");
+    res.end();
+}
+function openAiModels(model) {
+    return { object: "list", data: [{ id: model, object: "model", owned_by: "fusion-gateway" }] };
+}
+function anthropicModels(model) {
+    return {
+        object: "list",
+        data: [{ type: "model", id: model, display_name: model }],
+        has_more: false
+    };
+}
+// ---- server ----
+const NO_BODY = Symbol("no-body");
+async function readBody(req) {
+    const chunks = [];
+    for await (const chunk of req)
+        chunks.push(chunk);
+    return Buffer.concat(chunks);
+}
+async function readJson(req, res) {
+    const buffer = await readBody(req);
+    if (buffer.length === 0)
+        return {};
+    try {
+        return JSON.parse(buffer.toString("utf8"));
+    }
+    catch {
+        writeJson(res, 400, { error: { message: "invalid JSON body", type: "bad_request" } });
+        return NO_BODY;
+    }
+}
+function writeJson(res, status, value) {
+    const payload = Buffer.from(JSON.stringify(value), "utf8");
+    res.statusCode = status;
+    res.setHeader("content-type", "application/json");
+    res.setHeader("content-length", String(payload.byteLength));
+    res.end(payload);
+}
+function authorized(req, token) {
+    const auth = req.headers.authorization;
+    if (typeof auth === "string" && auth === `Bearer ${token}`)
+        return true;
+    const apiKey = req.headers["x-api-key"];
+    return typeof apiKey === "string" && apiKey === token;
+}
+function requestId(prefix) {
+    return `${prefix}_${Math.random().toString(36).slice(2, 12)}`;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export async function startFusionGateway(options) {
+    const host = options.host ?? "127.0.0.1";
+    const defaultModel = options.defaultModel ?? DEFAULT_MODEL;
+    const { runner, authToken } = options;
+    async function runFrontDoor(res, dialect, prompt, requestedModel, stream, format, traceId) {
+        const id = requestId(dialect);
+        res.setHeader(TRACE_ID_HEADER, traceId);
+        const result = await runner({ dialect, prompt, requestedModel, requestId: id, traceId });
+        res.setHeader(FUSION_RUN_ID_HEADER, result.runId);
+        res.setHeader(FUSION_STATUS_HEADER, result.status);
+        res.setHeader(FUSION_EVIDENCE_HEADER, JSON.stringify(result.evidence));
+        if (result.reportPath !== undefined)
+            res.setHeader(FUSION_REPORT_HEADER, result.reportPath);
+        const model = requestedModel ?? defaultModel;
+        if (!stream) {
+            writeJson(res, 200, format(result.finalOutput, model));
+            return;
+        }
+        switch (dialect) {
+            case "openai-responses":
+                await pipeSse(res, openAiSseToResponses(openAiChatSseFromText(result.finalOutput), model));
+                return;
+            case "anthropic-messages":
+                await pipeSse(res, openAiSseToAnthropic(openAiChatSseFromText(result.finalOutput), model));
+                return;
+            case "openai-chat":
+                writeChatSse(res, result.finalOutput, model);
+                return;
+            default: {
+                const exhaustive = dialect;
+                throw new Error(`unhandled dialect ${String(exhaustive)}`);
+            }
+        }
+    }
+    function traceIdFor(req) {
+        const incoming = req.headers[TRACE_ID_HEADER];
+        if (typeof incoming === "string" && incoming.length > 0)
+            return incoming;
+        if (Array.isArray(incoming) && incoming.length > 0 && incoming[0])
+            return incoming[0];
+        return newTraceId();
+    }
+    async function handle(req, res) {
+        const method = req.method ?? "GET";
+        const path = new URL(req.url ?? "/", "http://localhost").pathname;
+        if (path === "/health") {
+            writeJson(res, 200, { status: "ok", service: "fusion-harness-gateway" });
+            return;
+        }
+        if (authToken !== undefined && !authorized(req, authToken)) {
+            writeJson(res, 401, { error: { message: "unauthorized", type: "auth_error" } });
+            return;
+        }
+        if (method === "GET" && (path === "/v1/models" || path === "/models")) {
+            if (req.headers["anthropic-version"] !== undefined) {
+                writeJson(res, 200, anthropicModels(defaultModel));
+                return;
+            }
+            writeJson(res, 200, openAiModels(defaultModel));
+            return;
+        }
+        if (method === "POST" && (path === "/v1/responses" || path === "/responses")) {
+            const raw = await readJson(req, res);
+            if (raw === NO_BODY)
+                return;
+            const body = raw;
+            await runFrontDoor(res, "openai-responses", promptFromResponses(body), body.model, body.stream === true, formatResponses, traceIdFor(req));
+            return;
+        }
+        if (method === "POST" && path === "/v1/messages/count_tokens") {
+            const raw = await readJson(req, res);
+            if (raw === NO_BODY)
+                return;
+            const body = raw;
+            const text = promptFromAnthropic(body);
+            writeJson(res, 200, { input_tokens: Math.max(1, Math.ceil(text.length / 4)) });
+            return;
+        }
+        if (method === "POST" && (path === "/v1/messages" || path === "/messages")) {
+            const raw = await readJson(req, res);
+            if (raw === NO_BODY)
+                return;
+            const body = raw;
+            await runFrontDoor(res, "anthropic-messages", promptFromAnthropic(body), body.model, body.stream === true, formatAnthropic, traceIdFor(req));
+            return;
+        }
+        if (method === "POST" && (path === "/v1/chat/completions" || path === "/chat/completions")) {
+            const raw = await readJson(req, res);
+            if (raw === NO_BODY)
+                return;
+            const body = raw;
+            await runFrontDoor(res, "openai-chat", promptFromChat(body), body.model, body.stream === true, formatChat, traceIdFor(req));
+            return;
+        }
+        writeJson(res, 404, { error: { message: `no route for ${method} ${path}`, type: "not_found" } });
+    }
+    const server = createServer((req, res) => {
+        void handle(req, res).catch((error) => {
+            writeJson(res, 502, { error: { message: errorMessage(error), type: "front_door_error" } });
+        });
+    });
+    await new Promise((resolve, reject) => {
+        const onError = (error) => reject(error);
+        server.once("error", onError);
+        server.listen(options.port ?? 0, host, () => {
+            server.off("error", onError);
+            resolve();
+        });
+    });
+    const address = server.address();
+    const port = typeof address === "object" && address !== null ? address.port : options.port ?? 0;
+    return {
+        url: () => `http://${host}:${port}`,
+        port: () => port,
+        close: () => new Promise((resolve, reject) => {
+            server.close((error) => (error ? reject(error) : resolve()));
+        })
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @fusionkit/model-gateway — a native local-model gateway.
+ *
+ * It fronts a single OpenAI Chat Completions backend (the owned
+ * `velum-labs/mlx-lm` fork by default — "mlx_lm.server first") and exposes the
+ * wire dialects each agent harness needs so a local model can transparently
+ * back them with no change to the user's workflow:
+ *
+ *  - OpenAI Chat Completions (`/v1/chat/completions`) — opencode, Cursor IDE
+ *    plan panel. Implemented (M1).
+ *  - Anthropic Messages (`/v1/messages`) — Claude Code. Planned (M2).
+ *  - OpenAI Responses (`/v1/responses`) — Codex. Planned (M3).
+ *
+ * See spec/2026-06-13-local-model-harness-bridge-spec.md.
+ */
+export { startGateway } from "./server.js";
+export type { Gateway, GatewayOptions } from "./server.js";
+export { joinPath, OpenAiBackend } from "./backend.js";
+export type { Backend, BackendRequestOptions, OpenAiBackendOptions } from "./backend.js";
+export { FusionBackend } from "./fusion-backend.js";
+export type { ChatMessageLike, FusionBackendOptions, PanelRunInput, PanelRunner, WireTrajectory } from "./fusion-backend.js";
+export { MlxBackend } from "./mlx-backend.js";
+export type { MlxBackendOptions } from "./mlx-backend.js";
+export { createBackend, DEFAULT_MLX_MODEL, resolveBackendConfig } from "./config.js";
+export type { BackendConfig } from "./config.js";
+export { effectiveModel, isStream, withDefaultModel } from "./adapters/chat.js";
+export { anthropicModelsResponse, anthropicToChat, chatToAnthropicMessage, countTokensEstimate, handleAnthropicMessages, handleCountTokens, mapStopReason, openAiSseToAnthropic } from "./adapters/anthropic.js";
+export type { AnthropicRequest } from "./adapters/anthropic.js";
+export { chatToResponses, handleResponses, openAiSseToResponses, responsesToChat } from "./adapters/responses.js";
+export type { ResponsesRequest } from "./adapters/responses.js";
+export { FUSION_EVIDENCE_HEADER, FUSION_REPORT_HEADER, FUSION_RUN_ID_HEADER, FUSION_STATUS_HEADER, formatAnthropic, formatChat, formatResponses, promptFromAnthropic, promptFromChat, promptFromResponses, startFusionGateway } from "./fusion-gateway.js";
+export type { ChatRequest, FrontDoorDialect, FrontDoorRunner, FrontDoorRunnerInput, FrontDoorRunnerResult, FusionGateway, FusionGatewayOptions } from "./fusion-gateway.js";
+export { ACP_PROTOCOL_VERSION, runAcpAgent } from "./acp-agent.js";
+export type { AcpAgentOptions, AcpRunner, AcpRunnerInput, AcpRunnerResult } from "./acp-agent.js";
+export { runFrontDoorAcceptance } from "./front-door-acceptance.js";
+export type { FrontDoorAcceptanceOptions, FrontDoorAcceptanceReport, FrontDoorOutcome, FrontDoorOutcomeProducer, FrontDoorStatus } from "./front-door-acceptance.js";
+export { ACP_REGISTRY_URL, fetchAcpRegistry, installAcpAdapters } from "./acp-registry.js";
+export type { AcpRegistry, AcpRegistryAgent, AcpRegistryFetcher, InstallAcpAdaptersOptions, InstalledAcpAdapter } from "./acp-registry.js";
+export { buildModelCallRecord, MODEL_CALL_ID_HEADER, modelCallId, responseBodyHash } from "./provenance.js";
+export type { GatewayDialect, ModelCallRecord, ModelGatewayCallContext, ModelGatewayCallResult, ProvenanceSink } from "./provenance.js";

package/dist/index.js

@@ -0,0 +1,28 @@
+/**
+ * @fusionkit/model-gateway — a native local-model gateway.
+ *
+ * It fronts a single OpenAI Chat Completions backend (the owned
+ * `velum-labs/mlx-lm` fork by default — "mlx_lm.server first") and exposes the
+ * wire dialects each agent harness needs so a local model can transparently
+ * back them with no change to the user's workflow:
+ *
+ *  - OpenAI Chat Completions (`/v1/chat/completions`) — opencode, Cursor IDE
+ *    plan panel. Implemented (M1).
+ *  - Anthropic Messages (`/v1/messages`) — Claude Code. Planned (M2).
+ *  - OpenAI Responses (`/v1/responses`) — Codex. Planned (M3).
+ *
+ * See spec/2026-06-13-local-model-harness-bridge-spec.md.
+ */
+export { startGateway } from "./server.js";
+export { joinPath, OpenAiBackend } from "./backend.js";
+export { FusionBackend } from "./fusion-backend.js";
+export { MlxBackend } from "./mlx-backend.js";
+export { createBackend, DEFAULT_MLX_MODEL, resolveBackendConfig } from "./config.js";
+export { effectiveModel, isStream, withDefaultModel } from "./adapters/chat.js";
+export { anthropicModelsResponse, anthropicToChat, chatToAnthropicMessage, countTokensEstimate, handleAnthropicMessages, handleCountTokens, mapStopReason, openAiSseToAnthropic } from "./adapters/anthropic.js";
+export { chatToResponses, handleResponses, openAiSseToResponses, responsesToChat } from "./adapters/responses.js";
+export { FUSION_EVIDENCE_HEADER, FUSION_REPORT_HEADER, FUSION_RUN_ID_HEADER, FUSION_STATUS_HEADER, formatAnthropic, formatChat, formatResponses, promptFromAnthropic, promptFromChat, promptFromResponses, startFusionGateway } from "./fusion-gateway.js";
+export { ACP_PROTOCOL_VERSION, runAcpAgent } from "./acp-agent.js";
+export { runFrontDoorAcceptance } from "./front-door-acceptance.js";
+export { ACP_REGISTRY_URL, fetchAcpRegistry, installAcpAdapters } from "./acp-registry.js";
+export { buildModelCallRecord, MODEL_CALL_ID_HEADER, modelCallId, responseBodyHash } from "./provenance.js";

package/dist/mlx-backend.d.ts

@@ -0,0 +1,42 @@
+import { mlxServer } from "@fusionkit/adapter-ai-sdk";
+import type { ManagedServerEvent } from "@fusionkit/adapter-ai-sdk";
+import type { Backend } from "./backend.js";
+/**
+ * The first-class gateway backend: the owned `velum-labs/mlx-lm` fork run as
+ * `mlx_lm.server`, provisioned and supervised by `mlxServer`
+ * (`@fusionkit/adapter-ai-sdk`). The gateway does not speak the AI SDK model
+ * interface to it — it proxies raw HTTP to the server's OpenAI-compatible
+ * `/v1` surface — so this wrapper only needs the process lifecycle and the
+ * resolved base URL. A long-lived gateway keeps the server up
+ * (`idleShutdownMs: 0` by default) rather than scaling to zero between calls.
+ */
+export type MlxBackendOptions = {
+    /** Hugging Face repo id the mlx server loads. */
+    model: string;
+    /**
+     * Provision the structured-decoding fork (`response_format`, `guided_json`,
+     * …). Defaults to true: structured output is the reason we own the fork.
+     */
+    structured?: boolean;
+    /**
+     * Idle period after which the underlying server scales to zero; defaults to
+     * 0 (stay up) since the gateway is a long-lived front door.
+     */
+    idleShutdownMs?: number;
+    onEvent?: (event: ManagedServerEvent) => void;
+};
+export declare class MlxBackend implements Backend {
+    #private;
+    constructor(options: MlxBackendOptions);
+    get defaultModel(): string;
+    /** The owned MLX footprint (verify/info/destroy). */
+    get env(): ReturnType<typeof mlxServer>["env"];
+    /** Provision (if needed), spawn, and health-check the mlx server. */
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    /** Backend lifecycle hook: a gateway owning this backend tears the server down. */
+    close(): Promise<void>;
+    chat(body: unknown, signal?: AbortSignal): Promise<Response>;
+    models(signal?: AbortSignal): Promise<Response>;
+    embeddings(body: unknown, signal?: AbortSignal): Promise<Response>;
+}

package/dist/mlx-backend.js

@@ -0,0 +1,71 @@
+import { mlxServer } from "@fusionkit/adapter-ai-sdk";
+import { OpenAiBackend } from "./backend.js";
+export class MlxBackend {
+    #server;
+    #model;
+    #inner;
+    #startPromise;
+    constructor(options) {
+        this.#model = options.model;
+        this.#server = mlxServer({
+            model: options.model,
+            idleShutdownMs: options.idleShutdownMs ?? 0,
+            structured: options.structured ?? true,
+            ...(options.onEvent ? { onEvent: options.onEvent } : {})
+        });
+    }
+    get defaultModel() {
+        return this.#model;
+    }
+    /** The owned MLX footprint (verify/info/destroy). */
+    get env() {
+        return this.#server.env;
+    }
+    /** Provision (if needed), spawn, and health-check the mlx server. */
+    start() {
+        if (!this.#startPromise) {
+            this.#startPromise = (async () => {
+                await this.#server.start();
+                const base = this.#server.baseURL();
+                if (base === undefined) {
+                    throw new Error("mlx server did not report a base URL after start");
+                }
+                // The server's base URL omits the OpenAI prefix; the fork serves the
+                // OpenAI routes under /v1 (see mlx_lm.server).
+                this.#inner = new OpenAiBackend({
+                    baseUrl: `${base}/v1`,
+                    defaultModel: this.#model
+                });
+            })().catch((error) => {
+                this.#startPromise = undefined;
+                throw error;
+            });
+        }
+        return this.#startPromise;
+    }
+    async stop() {
+        await this.#server.stop();
+        this.#inner = undefined;
+        this.#startPromise = undefined;
+    }
+    /** Backend lifecycle hook: a gateway owning this backend tears the server down. */
+    async close() {
+        await this.stop();
+    }
+    async #ready() {
+        await this.start();
+        if (this.#inner === undefined) {
+            throw new Error("mlx backend is not ready");
+        }
+        return this.#inner;
+    }
+    async chat(body, signal) {
+        return (await this.#ready()).chat(body, signal);
+    }
+    async models(signal) {
+        return (await this.#ready()).models(signal);
+    }
+    async embeddings(body, signal) {
+        return (await this.#ready()).embeddings(body, signal);
+    }
+}

package/dist/provenance.d.ts

@@ -0,0 +1,29 @@
+import type { ModelCallRecordV1 } from "@fusionkit/protocol";
+/** The wire dialect a request arrived on. */
+export type GatewayDialect = "openai-chat" | "anthropic-messages" | "openai-responses";
+export declare const MODEL_CALL_ID_HEADER = "x-velum-model-call-id";
+export type ModelGatewayCallContext = {
+    callId: string;
+    dialect: GatewayDialect;
+    requestedModel: string | undefined;
+    model: string | undefined;
+    stream: boolean;
+    requestBody: unknown;
+    startedAt: string;
+    endpointId?: string;
+};
+export type ModelGatewayCallResult = {
+    statusCode: number;
+    responseBody?: Buffer;
+    durationMs: number;
+    error?: unknown;
+};
+/** One recorded model call observed at the gateway boundary. */
+export type ModelCallRecord = ModelCallRecordV1;
+/** Sink for gateway observations. All methods are optional. */
+export type ProvenanceSink = {
+    onModelCall?(record: ModelCallRecord): void;
+};
+export declare function buildModelCallRecord(context: ModelGatewayCallContext, result: ModelGatewayCallResult): ModelCallRecord;
+export declare function modelCallId(): string;
+export declare function responseBodyHash(body: Buffer): string;