@devicerail/tool-adapter 0.1.0

package/dist/errors.js

@@ -0,0 +1,39 @@
+export class ToolAdapterError extends Error {
+    code;
+    constructor(code, message, options) {
+        super(message, options);
+        this.name = new.target.name;
+        this.code = code;
+    }
+}
+export class InvalidActionSpaceError extends ToolAdapterError {
+    constructor(message, options) {
+        super("invalid_action_space", message, options);
+    }
+}
+export class UnknownToolError extends ToolAdapterError {
+    toolName;
+    constructor(toolName) {
+        super("unknown_tool", `unknown DeviceRail tool: ${toolName}`);
+        this.toolName = toolName;
+    }
+}
+export class InvalidToolArgumentsError extends ToolAdapterError {
+    toolName;
+    constructor(toolName, message, options) {
+        super("invalid_tool_arguments", `${toolName}: ${message}`, options);
+        this.toolName = toolName;
+    }
+}
+export class InvalidToolOptionsError extends ToolAdapterError {
+    constructor(message) {
+        super("invalid_tool_options", message);
+    }
+}
+export class InvalidToolResultError extends ToolAdapterError {
+    toolName;
+    constructor(toolName, message) {
+        super("invalid_tool_result", `${toolName}: ${message}`);
+        this.toolName = toolName;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./catalog.js";
+export * from "./errors.js";
+export { actionToolName, OBSERVATION_TOOL_NAME } from "./naming.js";
+export type * from "./types.js";

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from "./catalog.js";
+export * from "./errors.js";
+export { actionToolName, OBSERVATION_TOOL_NAME } from "./naming.js";

package/dist/json.d.ts

@@ -0,0 +1,4 @@
+type FailureFactory = (message: string) => Error;
+export declare function clonePureJson(value: unknown, failure: FailureFactory): unknown;
+export declare function deepFreezeJson<T>(value: T): T;
+export {};

package/dist/json.js

@@ -0,0 +1,127 @@
+import { types as utilTypes } from "node:util";
+const MAX_JSON_NODES = 100_000;
+const MAX_JSON_DEPTH = 256;
+function isPlainObject(value) {
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+export function clonePureJson(value, failure) {
+    const seen = new Set();
+    const pending = [];
+    let nodeCount = 0;
+    const cloneNode = (source, path, depth) => {
+        nodeCount += 1;
+        if (nodeCount > MAX_JSON_NODES) {
+            throw failure(`JSON value exceeds ${MAX_JSON_NODES} nodes`);
+        }
+        if (depth > MAX_JSON_DEPTH) {
+            throw failure(`JSON value exceeds ${MAX_JSON_DEPTH} levels`);
+        }
+        if (source === null || typeof source === "string" || typeof source === "boolean") {
+            return source;
+        }
+        if (typeof source === "number") {
+            if (!Number.isFinite(source) || (Number.isInteger(source) && !Number.isSafeInteger(source))) {
+                throw failure(`${path} contains a non-finite or unsafe number`);
+            }
+            return source;
+        }
+        if (typeof source !== "object") {
+            throw failure(`${path} is not a pure JSON value`);
+        }
+        if (utilTypes.isProxy(source)) {
+            throw failure(`${path} must not be a Proxy`);
+        }
+        if (seen.has(source)) {
+            throw failure(`${path} contains a repeated or cyclic object`);
+        }
+        seen.add(source);
+        if (Array.isArray(source)) {
+            for (const key of Reflect.ownKeys(source)) {
+                if (key === "length") {
+                    continue;
+                }
+                if (typeof key !== "string" || !/^(0|[1-9][0-9]*)$/u.test(key)) {
+                    throw failure(`${path} contains a non-JSON array property`);
+                }
+                const index = Number(key);
+                if (!Number.isSafeInteger(index) || index < 0 || index >= source.length) {
+                    throw failure(`${path} contains an invalid array index`);
+                }
+                const descriptor = Object.getOwnPropertyDescriptor(source, key);
+                if (!descriptor?.enumerable || !("value" in descriptor)) {
+                    throw failure(`${path}[${key}] is not a plain JSON property`);
+                }
+            }
+            for (let index = 0; index < source.length; index += 1) {
+                if (!Object.hasOwn(source, index)) {
+                    throw failure(`${path} contains a sparse array slot`);
+                }
+            }
+            const target = new Array(source.length);
+            pending.push({ depth, kind: "array", path, source, target });
+            return target;
+        }
+        if (!isPlainObject(source)) {
+            throw failure(`${path} must use a plain JSON object`);
+        }
+        const ownKeys = Reflect.ownKeys(source);
+        if (ownKeys.some((key) => typeof key !== "string")) {
+            throw failure(`${path} contains a symbol property`);
+        }
+        const descriptors = Object.getOwnPropertyDescriptors(source);
+        for (const key of ownKeys) {
+            const descriptor = descriptors[key];
+            if (!descriptor?.enumerable || !("value" in descriptor)) {
+                throw failure(`${path}.${key} is not a plain JSON property`);
+            }
+        }
+        const target = {};
+        pending.push({ depth, descriptors, kind: "object", path, source, target });
+        return target;
+    };
+    const root = cloneNode(value, "$", 0);
+    while (pending.length > 0) {
+        const work = pending.pop();
+        if (!work) {
+            continue;
+        }
+        if (work.kind === "array") {
+            for (let index = 0; index < work.source.length; index += 1) {
+                work.target[index] = cloneNode(work.source[index], `${work.path}[${index}]`, work.depth + 1);
+            }
+            continue;
+        }
+        for (const [key, descriptor] of Object.entries(work.descriptors)) {
+            const child = cloneNode(descriptor.value, `${work.path}.${key}`, work.depth + 1);
+            Object.defineProperty(work.target, key, {
+                configurable: true,
+                enumerable: true,
+                value: child,
+                writable: true,
+            });
+        }
+    }
+    return root;
+}
+export function deepFreezeJson(value) {
+    if (value === null || typeof value !== "object") {
+        return value;
+    }
+    const pending = [value];
+    const seen = new Set();
+    while (pending.length > 0) {
+        const current = pending.pop();
+        if (!current || seen.has(current)) {
+            continue;
+        }
+        seen.add(current);
+        for (const child of Object.values(current)) {
+            if (child !== null && typeof child === "object") {
+                pending.push(child);
+            }
+        }
+        Object.freeze(current);
+    }
+    return value;
+}

package/dist/naming.d.ts

@@ -0,0 +1,2 @@
+export declare const OBSERVATION_TOOL_NAME = "devicerail_observe";
+export declare function actionToolName(actionName: string): string;

package/dist/naming.js

@@ -0,0 +1,21 @@
+import { createHash } from "node:crypto";
+import { InvalidActionSpaceError } from "./errors.js";
+const ACTION_TOOL_PREFIX = "devicerail_action_";
+const MAX_TOOL_NAME_LENGTH = 64;
+export const OBSERVATION_TOOL_NAME = "devicerail_observe";
+export function actionToolName(actionName) {
+    if (typeof actionName !== "string" || actionName.trim().length === 0) {
+        throw new InvalidActionSpaceError("action names must be non-empty strings");
+    }
+    const raw = `${ACTION_TOOL_PREFIX}raw_${actionName}`;
+    if (/^[A-Za-z0-9_-]+$/u.test(actionName) && raw.length <= MAX_TOOL_NAME_LENGTH) {
+        return raw;
+    }
+    const encoded = Buffer.from(actionName, "utf8").toString("base64url");
+    const base64 = `${ACTION_TOOL_PREFIX}b64_${encoded}`;
+    if (base64.length <= MAX_TOOL_NAME_LENGTH) {
+        return base64;
+    }
+    const digest = createHash("sha256").update(actionName, "utf8").digest("hex").slice(0, 32);
+    return `${ACTION_TOOL_PREFIX}sha256_${digest}`;
+}

package/dist/result.d.ts

@@ -0,0 +1,3 @@
+import type { ActionResult, Observation } from "@devicerail/protocol";
+export declare function validateObservationResult(toolName: string, value: unknown): Observation;
+export declare function validateActionResult(toolName: string, actionCallId: string, value: unknown, protection?: "protected"): ActionResult;

package/dist/result.js

@@ -0,0 +1,163 @@
+import { ProtocolViolationError, validateRpcResult } from "@devicerail/client";
+import { InvalidToolResultError } from "./errors.js";
+import { clonePureJson, deepFreezeJson } from "./json.js";
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu;
+const NIL_UUID = "00000000-0000-0000-0000-000000000000";
+const SHA256_PATTERN = /^[0-9a-f]{64}$/iu;
+const MAX_U32 = 4_294_967_295;
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function fail(toolName, message) {
+    throw new InvalidToolResultError(toolName, message);
+}
+function requiredSafeInteger(toolName, value, name, minimum, maximum = Number.MAX_SAFE_INTEGER) {
+    if (typeof value !== "number" ||
+        !Number.isSafeInteger(value) ||
+        value < minimum ||
+        value > maximum) {
+        fail(toolName, `${name} must be a safe integer between ${minimum} and ${maximum}`);
+    }
+    return value;
+}
+function validateAsset(toolName, value, name) {
+    if (!isRecord(value)) {
+        fail(toolName, `${name} must be an evidence object`);
+    }
+    if (typeof value.id !== "string" || value.id.trim().length === 0) {
+        fail(toolName, `${name}.id must be a non-empty string`);
+    }
+    if (typeof value.mediaType !== "string" ||
+        !value.mediaType.includes("/") ||
+        /\s/u.test(value.mediaType)) {
+        fail(toolName, `${name}.mediaType must be a valid media type`);
+    }
+    if (typeof value.uri !== "string" || value.uri.trim().length === 0) {
+        fail(toolName, `${name}.uri must be a non-empty string`);
+    }
+    if (value.sha256 !== undefined &&
+        value.sha256 !== null &&
+        (typeof value.sha256 !== "string" || !SHA256_PATTERN.test(value.sha256))) {
+        fail(toolName, `${name}.sha256 must be 64 hexadecimal characters when present`);
+    }
+    return value;
+}
+function validateObservation(toolName, value, name) {
+    if (!isRecord(value)) {
+        fail(toolName, `${name} must be an observation object`);
+    }
+    if (typeof value.id !== "string" ||
+        !UUID_PATTERN.test(value.id) ||
+        value.id.toLowerCase() === NIL_UUID) {
+        fail(toolName, `${name}.id must be a non-nil UUID`);
+    }
+    if (typeof value.deviceId !== "string" || value.deviceId.trim().length === 0) {
+        fail(toolName, `${name}.deviceId must be a non-empty string`);
+    }
+    requiredSafeInteger(toolName, value.capturedAtMs, `${name}.capturedAtMs`, 1);
+    if (!isRecord(value.viewport)) {
+        fail(toolName, `${name}.viewport must be an object`);
+    }
+    requiredSafeInteger(toolName, value.viewport.width, `${name}.viewport.width`, 1, MAX_U32);
+    requiredSafeInteger(toolName, value.viewport.height, `${name}.viewport.height`, 1, MAX_U32);
+    if (typeof value.viewport.scaleFactor !== "number" ||
+        !Number.isFinite(value.viewport.scaleFactor) ||
+        value.viewport.scaleFactor <= 0) {
+        fail(toolName, `${name}.viewport.scaleFactor must be a positive finite number`);
+    }
+    if (value.metadata !== undefined && !isRecord(value.metadata)) {
+        fail(toolName, `${name}.metadata must be an object when present`);
+    }
+    const hasScreenshot = value.screenshot !== undefined && value.screenshot !== null;
+    if (hasScreenshot) {
+        validateAsset(toolName, value.screenshot, `${name}.screenshot`);
+    }
+    const omission = value.screenshotOmission;
+    if (omission !== undefined &&
+        omission !== "policy" &&
+        omission !== "protectedAction") {
+        fail(toolName, `${name}.screenshotOmission must be policy or protectedAction when present`);
+    }
+    if (hasScreenshot && omission !== undefined) {
+        fail(toolName, `${name} must not contain both a screenshot and screenshotOmission`);
+    }
+    return {
+        hasScreenshot,
+        omission,
+        value: value,
+    };
+}
+function pureResult(toolName, method, value) {
+    const cloned = deepFreezeJson(clonePureJson(value, (message) => new InvalidToolResultError(toolName, `result ${message}`)));
+    try {
+        validateRpcResult(method, cloned);
+    }
+    catch (cause) {
+        if (cause instanceof ProtocolViolationError) {
+            throw new InvalidToolResultError(toolName, cause.message);
+        }
+        throw cause;
+    }
+    return cloned;
+}
+export function validateObservationResult(toolName, value) {
+    const cloned = pureResult(toolName, "device.observe", value);
+    return validateObservation(toolName, cloned, "observation").value;
+}
+export function validateActionResult(toolName, actionCallId, value, protection) {
+    const cloned = pureResult(toolName, "device.execute", value);
+    if (!isRecord(cloned)) {
+        fail(toolName, "device.execute must return an ActionResult object");
+    }
+    if (cloned.callId !== actionCallId) {
+        fail(toolName, "device.execute returned a result for a different Action call");
+    }
+    const startedAtMs = requiredSafeInteger(toolName, cloned.startedAtMs, "action.startedAtMs", 1);
+    const finishedAtMs = requiredSafeInteger(toolName, cloned.finishedAtMs, "action.finishedAtMs", 1);
+    if (finishedAtMs < startedAtMs) {
+        fail(toolName, "action.finishedAtMs must not precede action.startedAtMs");
+    }
+    if (!Object.hasOwn(cloned, "output")) {
+        fail(toolName, "action.output is required");
+    }
+    const before = cloned.before === undefined || cloned.before === null
+        ? undefined
+        : validateObservation(toolName, cloned.before, "action.before");
+    if (cloned.after === undefined || cloned.after === null) {
+        fail(toolName, "action.after observation is required");
+    }
+    const after = validateObservation(toolName, cloned.after, "action.after");
+    if (before !== undefined && before.value.deviceId !== after.value.deviceId) {
+        fail(toolName, "action.before and action.after must identify the same device");
+    }
+    if (protection === "protected") {
+        if (before === undefined) {
+            fail(toolName, "protected action.before observation is required");
+        }
+        const observations = [before, after];
+        if (observations.some((observation) => observation.omission !== "protectedAction")) {
+            fail(toolName, "protected action observations must explicitly omit screenshots as protectedAction");
+        }
+    }
+    if (!Array.isArray(cloned.evidence)) {
+        fail(toolName, "action.evidence must be an array");
+    }
+    if (protection === "protected" && cloned.evidence.length !== 0) {
+        fail(toolName, "protected action.evidence must be empty");
+    }
+    if (cloned.evidence.length === 0) {
+        const observations = before === undefined ? [after] : [before, after];
+        if (observations.some((observation) => observation.omission === undefined)) {
+            fail(toolName, "action.evidence may be empty only when every observation explicitly omits its screenshot");
+        }
+    }
+    const evidenceIds = new Set();
+    cloned.evidence.forEach((asset, index) => {
+        const validated = validateAsset(toolName, asset, `action.evidence[${index}]`);
+        if (evidenceIds.has(validated.id)) {
+            fail(toolName, `action.evidence contains duplicate id ${validated.id}`);
+        }
+        evidenceIds.add(validated.id);
+    });
+    return cloned;
+}

package/dist/schema.d.ts

@@ -0,0 +1,2 @@
+import type { ToolInputSchema } from "./types.js";
+export declare function validateToolInputSchema(actionName: string, value: unknown): ToolInputSchema;

package/dist/schema.js

@@ -0,0 +1,240 @@
+import { InvalidActionSpaceError } from "./errors.js";
+import { clonePureJson, deepFreezeJson } from "./json.js";
+const JSON_TYPES = new Set([
+    "array",
+    "boolean",
+    "integer",
+    "null",
+    "number",
+    "object",
+    "string",
+]);
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function fail(actionName, path, message) {
+    throw new InvalidActionSpaceError(`inputSchema for ${actionName} ${path}: ${message}`);
+}
+function canonicalJson(value) {
+    if (value === null || typeof value !== "object") {
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => canonicalJson(item)).join(",")}]`;
+    }
+    const record = value;
+    return `{${Object.keys(record)
+        .sort()
+        .map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`)
+        .join(",")}}`;
+}
+function stringArray(actionName, path, value) {
+    if (!Array.isArray(value) ||
+        value.some((item) => typeof item !== "string") ||
+        new Set(value).size !== value.length) {
+        fail(actionName, path, "must contain unique strings");
+    }
+    return value;
+}
+function schemaAt(actionName, path, value, pending) {
+    if (typeof value !== "boolean" && !isRecord(value)) {
+        fail(actionName, path, "must be a boolean or object schema");
+    }
+    pending.push({ path, schema: value });
+}
+function schemaMapAt(actionName, path, value, pending) {
+    if (!isRecord(value)) {
+        fail(actionName, path, "must be an object");
+    }
+    for (const [key, child] of Object.entries(value)) {
+        schemaAt(actionName, `${path}.${key}`, child, pending);
+    }
+}
+function schemaArrayAt(actionName, path, value, pending) {
+    if (!Array.isArray(value)) {
+        fail(actionName, path, "must be an array of schemas");
+    }
+    value.forEach((child, index) => schemaAt(actionName, `${path}[${index}]`, child, pending));
+}
+function nonNegativeInteger(actionName, path, value) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+        fail(actionName, path, "must be a non-negative safe integer");
+    }
+}
+function numberKeyword(actionName, path, value, positive = false) {
+    if (typeof value !== "number" || !Number.isFinite(value) || (positive && value <= 0)) {
+        fail(actionName, path, positive ? "must be a positive finite number" : "must be a finite number");
+    }
+}
+function validateSchemaNode(actionName, task, pending) {
+    if (typeof task.schema === "boolean") {
+        return;
+    }
+    const schema = task.schema;
+    for (const keyword of [
+        "$schema",
+        "$id",
+        "$anchor",
+        "$dynamicAnchor",
+        "$ref",
+        "$dynamicRef",
+        "$recursiveRef",
+    ]) {
+        if (schema[keyword] !== undefined && typeof schema[keyword] !== "string") {
+            fail(actionName, `${task.path}.${keyword}`, "must be a string");
+        }
+    }
+    if (schema.$recursiveAnchor !== undefined && typeof schema.$recursiveAnchor !== "boolean") {
+        fail(actionName, `${task.path}.$recursiveAnchor`, "must be a boolean");
+    }
+    if (schema.type !== undefined) {
+        const types = Array.isArray(schema.type) ? schema.type : [schema.type];
+        if (types.length === 0 ||
+            types.some((type) => typeof type !== "string" || !JSON_TYPES.has(type)) ||
+            new Set(types).size !== types.length) {
+            fail(actionName, `${task.path}.type`, "must be a JSON Schema type or unique type array");
+        }
+    }
+    if (schema.required !== undefined) {
+        stringArray(actionName, `${task.path}.required`, schema.required);
+    }
+    if (schema.enum !== undefined) {
+        if (!Array.isArray(schema.enum) || schema.enum.length === 0) {
+            fail(actionName, `${task.path}.enum`, "must be a non-empty array");
+        }
+        const values = new Set(schema.enum.map((value) => canonicalJson(value)));
+        if (values.size !== schema.enum.length) {
+            fail(actionName, `${task.path}.enum`, "must contain unique JSON values");
+        }
+    }
+    if (schema.examples !== undefined && !Array.isArray(schema.examples)) {
+        fail(actionName, `${task.path}.examples`, "must be an array");
+    }
+    for (const keyword of [
+        "$comment",
+        "title",
+        "description",
+        "format",
+        "contentEncoding",
+        "contentMediaType",
+        "pattern",
+    ]) {
+        if (schema[keyword] !== undefined && typeof schema[keyword] !== "string") {
+            fail(actionName, `${task.path}.${keyword}`, "must be a string");
+        }
+    }
+    for (const keyword of [
+        "readOnly",
+        "writeOnly",
+        "deprecated",
+        "uniqueItems",
+    ]) {
+        if (schema[keyword] !== undefined && typeof schema[keyword] !== "boolean") {
+            fail(actionName, `${task.path}.${keyword}`, "must be a boolean");
+        }
+    }
+    for (const keyword of ["minimum", "maximum", "exclusiveMinimum", "exclusiveMaximum"]) {
+        if (schema[keyword] !== undefined) {
+            numberKeyword(actionName, `${task.path}.${keyword}`, schema[keyword]);
+        }
+    }
+    if (schema.multipleOf !== undefined) {
+        numberKeyword(actionName, `${task.path}.multipleOf`, schema.multipleOf, true);
+    }
+    for (const keyword of [
+        "minLength",
+        "maxLength",
+        "minItems",
+        "maxItems",
+        "minContains",
+        "maxContains",
+        "minProperties",
+        "maxProperties",
+    ]) {
+        if (schema[keyword] !== undefined) {
+            nonNegativeInteger(actionName, `${task.path}.${keyword}`, schema[keyword]);
+        }
+    }
+    for (const keyword of [
+        "$defs",
+        "definitions",
+        "properties",
+        "patternProperties",
+        "dependentSchemas",
+    ]) {
+        if (schema[keyword] !== undefined) {
+            schemaMapAt(actionName, `${task.path}.${keyword}`, schema[keyword], pending);
+        }
+    }
+    for (const keyword of ["allOf", "anyOf", "oneOf", "prefixItems"]) {
+        if (schema[keyword] !== undefined) {
+            schemaArrayAt(actionName, `${task.path}.${keyword}`, schema[keyword], pending);
+        }
+    }
+    for (const keyword of [
+        "additionalItems",
+        "additionalProperties",
+        "unevaluatedProperties",
+        "propertyNames",
+        "contains",
+        "unevaluatedItems",
+        "not",
+        "if",
+        "then",
+        "else",
+        "contentSchema",
+    ]) {
+        if (schema[keyword] !== undefined) {
+            schemaAt(actionName, `${task.path}.${keyword}`, schema[keyword], pending);
+        }
+    }
+    if (schema.items !== undefined) {
+        if (Array.isArray(schema.items)) {
+            schemaArrayAt(actionName, `${task.path}.items`, schema.items, pending);
+        }
+        else {
+            schemaAt(actionName, `${task.path}.items`, schema.items, pending);
+        }
+    }
+    if (schema.dependencies !== undefined) {
+        if (!isRecord(schema.dependencies)) {
+            fail(actionName, `${task.path}.dependencies`, "must be an object");
+        }
+        for (const [key, dependency] of Object.entries(schema.dependencies)) {
+            if (Array.isArray(dependency)) {
+                stringArray(actionName, `${task.path}.dependencies.${key}`, dependency);
+            }
+            else {
+                schemaAt(actionName, `${task.path}.dependencies.${key}`, dependency, pending);
+            }
+        }
+    }
+    if (schema.dependentRequired !== undefined) {
+        if (!isRecord(schema.dependentRequired)) {
+            fail(actionName, `${task.path}.dependentRequired`, "must be an object");
+        }
+        for (const [key, required] of Object.entries(schema.dependentRequired)) {
+            stringArray(actionName, `${task.path}.dependentRequired.${key}`, required);
+        }
+    }
+    if (schema.$vocabulary !== undefined) {
+        if (!isRecord(schema.$vocabulary) ||
+            Object.values(schema.$vocabulary).some((required) => typeof required !== "boolean")) {
+            fail(actionName, `${task.path}.$vocabulary`, "must map vocabulary URIs to booleans");
+        }
+    }
+}
+export function validateToolInputSchema(actionName, value) {
+    const cloned = clonePureJson(value, (message) => new InvalidActionSpaceError(`inputSchema for ${actionName}: ${message}`));
+    if (!isRecord(cloned) || cloned.type !== "object") {
+        throw new InvalidActionSpaceError(`inputSchema for ${actionName} must be a JSON object with type: object`);
+    }
+    const pending = [{ path: "$", schema: cloned }];
+    while (pending.length > 0) {
+        const task = pending.pop();
+        if (task) {
+            validateSchemaNode(actionName, task, pending);
+        }
+    }
+    return deepFreezeJson(cloned);
+}