@caplets/pi 0.5.9 → 0.6.1

package/dist/index.js

@@ -1,10 +1,9 @@
+import { o as generatedToolInputJsonSchema, r as createNativeCapletsService } from "./service-D0MwLNyb-eeEfNHql.js";
 import { createRequire } from "node:module";
 import { readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { keyText } from "@earendil-works/pi-coding-agent";
-import { generatedToolInputJsonSchema } from "@caplets/core/generated-tool-input-schema";
-import { createNativeCapletsService, registerNativeCapletsProcessCleanup } from "@caplets/core/native";
 const ambiguousRanges = [
 	161,
 	161,
@@ -682,8 +681,9 @@ function eastAsianWidth(codePoint, { ambiguousAsWide = false } = {}) {
 	return 1;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@earendil-works+pi-tui@0.75.5/node_modules/@earendil-works/pi-tui/dist/utils.js
-const segmenter$1 = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+//#region ../../node_modules/.pnpm/@earendil-works+pi-tui@0.78.0/node_modules/@earendil-works/pi-tui/dist/utils.js
+const graphemeSegmenter$1 = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+new Intl.Segmenter(void 0, { granularity: "word" });
 /**
 * Check if a grapheme cluster (after segmentation) could possibly be an RGI emoji.
 * This is a fast heuristic to avoid the expensive rgiEmojiRegex test.
@@ -723,7 +723,7 @@ function truncateFragmentToWidth(text, maxWidth) {
 	if (!hasAnsi && !hasTabs) {
 		let result = "";
 		let width = 0;
-		for (const { segment } of segmenter$1.segment(text)) {
+		for (const { segment } of graphemeSegmenter$1.segment(text)) {
 			const w = graphemeWidth(segment);
 			if (width + w > maxWidth) break;
 			result += segment;
@@ -761,7 +761,7 @@ function truncateFragmentToWidth(text, maxWidth) {
 			if (extractAnsiCode(text, end)) break;
 			end++;
 		}
-		for (const { segment } of segmenter$1.segment(text.slice(i, end))) {
+		for (const { segment } of graphemeSegmenter$1.segment(text.slice(i, end))) {
 			const w = graphemeWidth(segment);
 			if (width + w > maxWidth) return {
 				text: result,
@@ -833,7 +833,7 @@ function visibleWidth(str) {
 		clean = stripped;
 	}
 	let width = 0;
-	for (const { segment } of segmenter$1.segment(clean)) width += graphemeWidth(segment);
+	for (const { segment } of graphemeSegmenter$1.segment(clean)) width += graphemeWidth(segment);
 	if (widthCache.size >= WIDTH_CACHE_SIZE) {
 		const firstKey = widthCache.keys().next().value;
 		if (firstKey !== void 0) widthCache.delete(firstKey);
@@ -1134,8 +1134,8 @@ function wrapTextWithAnsi(text, width) {
 	const result = [];
 	const tracker = new AnsiCodeTracker();
 	for (const inputLine of inputLines) {
-		const prefix = result.length > 0 ? tracker.getActiveCodes() : "";
-		result.push(...wrapSingleLine(prefix + inputLine, width));
+		const wrappedLines = wrapSingleLine((result.length > 0 ? tracker.getActiveCodes() : "") + inputLine, width);
+		for (const wrappedLine of wrappedLines) result.push(wrappedLine);
 		updateTrackerFromText(inputLine, tracker);
 	}
 	return result.length > 0 ? result : [""];
@@ -1160,7 +1160,7 @@ function wrapSingleLine(line, width) {
 				currentVisibleLength = 0;
 			}
 			const broken = breakLongWord(token, width, tracker);
-			wrapped.push(...broken.slice(0, -1));
+			for (let i = 0; i < broken.length - 1; i++) wrapped.push(broken[i]);
 			currentLine = broken[broken.length - 1];
 			currentVisibleLength = visibleWidth(currentLine);
 			continue;
@@ -1207,7 +1207,7 @@ function breakLongWord(word, width, tracker) {
 				end++;
 			}
 			const textPortion = word.slice(i, end);
-			for (const seg of segmenter$1.segment(textPortion)) segments.push({
+			for (const seg of graphemeSegmenter$1.segment(textPortion)) segments.push({
 				type: "grapheme",
 				value: seg.segment
 			});
@@ -1287,7 +1287,7 @@ function truncateToWidth(text, maxWidth, ellipsis = "...", pad = false) {
 	const hasAnsi = text.includes("\x1B");
 	const hasTabs = text.includes("	");
 	if (!hasAnsi && !hasTabs) {
-		for (const { segment } of segmenter$1.segment(text)) {
+		for (const { segment } of graphemeSegmenter$1.segment(text)) {
 			const width = graphemeWidth(segment);
 			if (keepContiguousPrefix && keptWidth + width <= targetWidth) {
 				result += segment;
@@ -1334,7 +1334,7 @@ function truncateToWidth(text, maxWidth, ellipsis = "...", pad = false) {
 				if (extractAnsiCode(text, end)) break;
 				end++;
 			}
-			for (const { segment } of segmenter$1.segment(text.slice(i, end))) {
+			for (const { segment } of graphemeSegmenter$1.segment(text.slice(i, end))) {
 				const width = graphemeWidth(segment);
 				if (keepContiguousPrefix && keptWidth + width <= targetWidth) {
 					if (pendingAnsi) {
@@ -1363,7 +1363,7 @@ function truncateToWidth(text, maxWidth, ellipsis = "...", pad = false) {
 }
 new AnsiCodeTracker();
 //#endregion
-//#region ../../node_modules/.pnpm/@earendil-works+pi-tui@0.75.5/node_modules/@earendil-works/pi-tui/dist/keys.js
+//#region ../../node_modules/.pnpm/@earendil-works+pi-tui@0.78.0/node_modules/@earendil-works/pi-tui/dist/keys.js
 const MODIFIERS = {
 	shift: 1,
 	alt: 2,
@@ -1416,7 +1416,7 @@ new Map([
 ]);
 MODIFIERS.shift | LOCK_MASK;
 //#endregion
-//#region ../../node_modules/.pnpm/@earendil-works+pi-tui@0.75.5/node_modules/@earendil-works/pi-tui/dist/components/text.js
+//#region ../../node_modules/.pnpm/@earendil-works+pi-tui@0.78.0/node_modules/@earendil-works/pi-tui/dist/components/text.js
 /**
 * Text component - displays multi-line text with word wrapping
 */
@@ -3324,7 +3324,7 @@ marked.parseInline;
 _Parser.parse;
 _Lexer.lex;
 //#endregion
-//#region ../../node_modules/.pnpm/@earendil-works+pi-tui@0.75.5/node_modules/@earendil-works/pi-tui/dist/components/markdown.js
+//#region ../../node_modules/.pnpm/@earendil-works+pi-tui@0.78.0/node_modules/@earendil-works/pi-tui/dist/components/markdown.js
 const STRICT_STRIKETHROUGH_REGEX = /^(~~)(?=[^\s~])((?:\\.|[^\\])*?(?:\\.|[^\s~\\]))\1(?=[^~]|$)/;
 var StrictStrikethroughTokenizer = class extends _Tokenizer {
 	del(src) {
@@ -3341,6 +3341,36 @@ var StrictStrikethroughTokenizer = class extends _Tokenizer {
 };
 new Marked().setOptions({ tokenizer: new StrictStrikethroughTokenizer() });
 createRequire(import.meta.url);
+createRequire(import.meta.url);
+//#endregion
+//#region ../core/dist/native.js
+function registerNativeCapletsProcessCleanup(service, options = {}) {
+	let closed = false;
+	const close = async () => {
+		if (closed) return;
+		closed = true;
+		try {
+			await service.close();
+		} catch (error) {
+			options.writeErr?.(`Failed to close Caplets service: ${errorMessage(error)}\n`);
+			process.exitCode = 1;
+		}
+	};
+	const closeBeforeExit = () => {
+		close();
+	};
+	const closeAndExit = () => {
+		close().finally(() => {
+			process.exit(process.exitCode ?? 0);
+		});
+	};
+	process.once("beforeExit", closeBeforeExit);
+	process.once("SIGINT", closeAndExit);
+	process.once("SIGTERM", closeAndExit);
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
 //#endregion
 //#region src/index.ts
 function createCapletsPiExtension(options) {
@@ -3466,7 +3496,7 @@ function parsePiNativeOptions(value, writeWarning, path = "settings.caplets") {
 	const result = {};
 	const mode = value.mode;
 	if (mode !== void 0) {
-		if (mode !== "auto" && mode !== "local" && mode !== "remote") return void 0;
+		if (mode !== "auto" && mode !== "local" && mode !== "remote" && mode !== "cloud") return;
 		result.mode = mode;
 	}
 	const statusWidget = value.statusWidget;
@@ -3534,7 +3564,7 @@ function nativeServiceOptions(options) {
 function shouldShowStatusWidget(options, statusWidget) {
 	if (statusWidget === false) return false;
 	if (options.mode === "local") return false;
-	return options.mode === "remote" || !!options.server?.url || process.env.CAPLETS_SERVER_URL !== void 0;
+	return options.mode === "remote" || options.mode === "cloud" || !!options.server?.url || process.env.CAPLETS_SERVER_URL !== void 0;
 }
 async function readFileUtf8(path) {
 	return readFile(path, "utf8");
@@ -3696,6 +3726,8 @@ function serializeResult(result) {
 	}
 }
 function agentContent(result) {
+	const codeModeContent = codeModeAgentContent(result);
+	if (codeModeContent) return codeModeContent;
 	const content = arrayProperty(result, "content").filter((item) => stringProperty(item, "type") === "text").map((item) => ({
 		type: "text",
 		text: stringProperty(item, "text")
@@ -3706,6 +3738,120 @@ function agentContent(result) {
 		text: JSON.stringify(result, null, 2) ?? "null"
 	}];
 }
+function codeModeAgentContent(result) {
+	if (!isCodeModeRunEnvelope(result)) return void 0;
+	const ok = Boolean(result.ok);
+	const diagnostics = arrayProperty(result, "diagnostics");
+	const logs = objectProperty(result, "logs");
+	const meta = objectProperty(result, "meta");
+	const value = result.value;
+	const compact = {
+		ok,
+		...ok ? { value: compactCodeModeAgentValue(value) } : { error: result.error }
+	};
+	if (diagnostics.length > 0) compact.diagnostics = diagnostics;
+	const logSummary = codeModeLogSummary(logs);
+	if (logSummary) compact.logs = logSummary;
+	const durationMs = meta?.durationMs;
+	if (typeof durationMs === "number") compact.durationMs = durationMs;
+	return [{
+		type: "text",
+		text: JSON.stringify(compact) ?? "null"
+	}];
+}
+function compactCodeModeAgentValue(value, depth = 0) {
+	if (depth > 16) return "[Max depth reached]";
+	if (Array.isArray(value)) {
+		const items = value.slice(0, 40).map((item) => compactCodeModeAgentValue(item, depth + 1));
+		return value.length > items.length ? [...items, { truncatedItems: value.length - items.length }] : items;
+	}
+	if (!value || typeof value !== "object") return compactCodeModeScalar(value);
+	const record = value;
+	if (isSuccessfulToolCallResultEnvelope(record)) return compactCodeModeAgentValue(record.data, depth + 1);
+	if (isFailedToolCallResultEnvelope(record)) return {
+		ok: false,
+		error: compactCodeModeAgentValue(record.error, depth + 1)
+	};
+	const descriptor = compactCodeModeDescriptor(record, depth);
+	if (descriptor) return descriptor;
+	const entries = Object.entries(record).flatMap(([key, nested]) => {
+		if (isCodeModeAgentNoiseKey(key, nested)) return [];
+		return [[key, compactCodeModeAgentValue(nested, depth + 1)]];
+	});
+	return Object.fromEntries(entries);
+}
+function compactCodeModeScalar(value) {
+	if (typeof value !== "string") return value;
+	const collapsed = value.replace(/\s+/gu, " ").trim();
+	return collapsed.length > 1200 ? `${collapsed.slice(0, 1197).trimEnd()}...` : value;
+}
+function isSuccessfulToolCallResultEnvelope(record) {
+	return record.ok === true && "data" in record && Object.keys(record).every((key) => [
+		"ok",
+		"data",
+		"meta"
+	].includes(key)) && isCapletsToolMeta(record.meta);
+}
+function isFailedToolCallResultEnvelope(record) {
+	return record.ok === false && "error" in record && Object.keys(record).every((key) => [
+		"ok",
+		"error",
+		"meta"
+	].includes(key)) && (record.meta === void 0 || isCapletsToolMeta(record.meta));
+}
+function isCapletsToolMeta(value) {
+	const meta = value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+	if (!meta) return false;
+	const record = meta;
+	return Boolean(typeof record.capletId === "string" || typeof record.tool === "string" || typeof record.status === "string" || typeof record.durationMs === "number" || typeof record.elapsedMs === "number");
+}
+function compactCodeModeDescriptor(record, depth) {
+	if (!("callSignature" in record || "inputTypeScript" in record || "inputSchema" in record)) return;
+	const compact = {};
+	for (const key of [
+		"id",
+		"name",
+		"title",
+		"description",
+		"callSignature",
+		"inputTypeScript"
+	]) if (record[key] !== void 0) compact[key] = compactCodeModeAgentValue(record[key], depth + 1);
+	const tool = objectProperty(record, "tool");
+	if (tool) compact.tool = compactCodeModeAgentValue(Object.fromEntries(Object.entries(tool).filter(([key]) => ![
+		"inputSchema",
+		"outputSchema",
+		"annotations"
+	].includes(key))), depth + 1);
+	return compact;
+}
+function isCodeModeAgentNoiseKey(key, value) {
+	if ([
+		"inputSchema",
+		"outputSchema",
+		"outputTypeScript",
+		"observedOutputShape"
+	].includes(key)) return true;
+	if (key === "examples" && Array.isArray(value)) return value.length > 0;
+	if (key === "fieldSelection") return true;
+	if (key === "meta" && isCapletsToolMeta(value)) return true;
+	return false;
+}
+function isCodeModeRunEnvelope(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+	const record = value;
+	return typeof record.ok === "boolean" && Array.isArray(record.diagnostics) && Boolean(record.logs) && typeof record.logs === "object" && !Array.isArray(record.logs) && Boolean(record.meta) && typeof record.meta === "object" && !Array.isArray(record.meta) && ("value" in record || "error" in record);
+}
+function codeModeLogSummary(logs) {
+	if (!logs) return void 0;
+	const entries = arrayProperty(logs, "entries");
+	const truncated = logs.truncated === true;
+	const logRef = stringProperty(logs, "logRef");
+	const summary = {};
+	if (entries.length > 0) summary.entries = entries;
+	if (truncated) summary.truncated = true;
+	if (logRef) summary.logRef = logRef;
+	return Object.keys(summary).length > 0 ? summary : void 0;
+}
 function compactResultText(result, maxLength = 600) {
 	if (!result || typeof result !== "object" || Array.isArray(result)) return compactText(String(result ?? "null"), maxLength);
 	const payload = objectProperty(objectProperty(result, "structuredContent"), "result");

package/dist/lib.decorators.d.ts

@@ -0,0 +1,382 @@
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0
+
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABILITY OR NON-INFRINGEMENT.
+
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+
+
+/**
+ * The decorator context types provided to class element decorators.
+ */
+type ClassMemberDecoratorContext =
+    | ClassMethodDecoratorContext
+    | ClassGetterDecoratorContext
+    | ClassSetterDecoratorContext
+    | ClassFieldDecoratorContext
+    | ClassAccessorDecoratorContext;
+
+/**
+ * The decorator context types provided to any decorator.
+ */
+type DecoratorContext =
+    | ClassDecoratorContext
+    | ClassMemberDecoratorContext;
+
+type DecoratorMetadataObject = Record<PropertyKey, unknown> & object;
+
+type DecoratorMetadata = typeof globalThis extends { Symbol: { readonly metadata: symbol; }; } ? DecoratorMetadataObject : DecoratorMetadataObject | undefined;
+
+/**
+ * Context provided to a class decorator.
+ * @template Class The type of the decorated class associated with this context.
+ */
+interface ClassDecoratorContext<
+    Class extends abstract new (...args: any) => any = abstract new (...args: any) => any,
+> {
+    /** The kind of element that was decorated. */
+    readonly kind: "class";
+
+    /** The name of the decorated class. */
+    readonly name: string | undefined;
+
+    /**
+     * Adds a callback to be invoked after the class definition has been finalized.
+     *
+     * @example
+     * ```ts
+     * function customElement(name: string): ClassDecoratorFunction {
+     *   return (target, context) => {
+     *     context.addInitializer(function () {
+     *       customElements.define(name, this);
+     *     });
+     *   }
+     * }
+     *
+     * @customElement("my-element")
+     * class MyElement {}
+     * ```
+     */
+    addInitializer(initializer: (this: Class) => void): void;
+
+    readonly metadata: DecoratorMetadata;
+}
+
+/**
+ * Context provided to a class method decorator.
+ * @template This The type on which the class element will be defined. For a static class element, this will be
+ * the type of the constructor. For a non-static class element, this will be the type of the instance.
+ * @template Value The type of the decorated class method.
+ */
+interface ClassMethodDecoratorContext<
+    This = unknown,
+    Value extends (this: This, ...args: any) => any = (this: This, ...args: any) => any,
+> {
+    /** The kind of class element that was decorated. */
+    readonly kind: "method";
+
+    /** The name of the decorated class element. */
+    readonly name: string | symbol;
+
+    /** A value indicating whether the class element is a static (`true`) or instance (`false`) element. */
+    readonly static: boolean;
+
+    /** A value indicating whether the class element has a private name. */
+    readonly private: boolean;
+
+    /** An object that can be used to access the current value of the class element at runtime. */
+    readonly access: {
+        /**
+         * Determines whether an object has a property with the same name as the decorated element.
+         */
+        has(object: This): boolean;
+        /**
+         * Gets the current value of the method from the provided object.
+         *
+         * @example
+         * let fn = context.access.get(instance);
+         */
+        get(object: This): Value;
+    };
+
+    /**
+     * Adds a callback to be invoked either after static methods are defined but before
+     * static initializers are run (when decorating a `static` element), or before instance
+     * initializers are run (when decorating a non-`static` element).
+     *
+     * @example
+     * ```ts
+     * const bound: ClassMethodDecoratorFunction = (value, context) {
+     *   if (context.private) throw new TypeError("Not supported on private methods.");
+     *   context.addInitializer(function () {
+     *     this[context.name] = this[context.name].bind(this);
+     *   });
+     * }
+     *
+     * class C {
+     *   message = "Hello";
+     *
+     *   @bound
+     *   m() {
+     *     console.log(this.message);
+     *   }
+     * }
+     * ```
+     */
+    addInitializer(initializer: (this: This) => void): void;
+
+    readonly metadata: DecoratorMetadata;
+}
+
+/**
+ * Context provided to a class getter decorator.
+ * @template This The type on which the class element will be defined. For a static class element, this will be
+ * the type of the constructor. For a non-static class element, this will be the type of the instance.
+ * @template Value The property type of the decorated class getter.
+ */
+interface ClassGetterDecoratorContext<
+    This = unknown,
+    Value = unknown,
+> {
+    /** The kind of class element that was decorated. */
+    readonly kind: "getter";
+
+    /** The name of the decorated class element. */
+    readonly name: string | symbol;
+
+    /** A value indicating whether the class element is a static (`true`) or instance (`false`) element. */
+    readonly static: boolean;
+
+    /** A value indicating whether the class element has a private name. */
+    readonly private: boolean;
+
+    /** An object that can be used to access the current value of the class element at runtime. */
+    readonly access: {
+        /**
+         * Determines whether an object has a property with the same name as the decorated element.
+         */
+        has(object: This): boolean;
+        /**
+         * Invokes the getter on the provided object.
+         *
+         * @example
+         * let value = context.access.get(instance);
+         */
+        get(object: This): Value;
+    };
+
+    /**
+     * Adds a callback to be invoked either after static methods are defined but before
+     * static initializers are run (when decorating a `static` element), or before instance
+     * initializers are run (when decorating a non-`static` element).
+     */
+    addInitializer(initializer: (this: This) => void): void;
+
+    readonly metadata: DecoratorMetadata;
+}
+
+/**
+ * Context provided to a class setter decorator.
+ * @template This The type on which the class element will be defined. For a static class element, this will be
+ * the type of the constructor. For a non-static class element, this will be the type of the instance.
+ * @template Value The type of the decorated class setter.
+ */
+interface ClassSetterDecoratorContext<
+    This = unknown,
+    Value = unknown,
+> {
+    /** The kind of class element that was decorated. */
+    readonly kind: "setter";
+
+    /** The name of the decorated class element. */
+    readonly name: string | symbol;
+
+    /** A value indicating whether the class element is a static (`true`) or instance (`false`) element. */
+    readonly static: boolean;
+
+    /** A value indicating whether the class element has a private name. */
+    readonly private: boolean;
+
+    /** An object that can be used to access the current value of the class element at runtime. */
+    readonly access: {
+        /**
+         * Determines whether an object has a property with the same name as the decorated element.
+         */
+        has(object: This): boolean;
+        /**
+         * Invokes the setter on the provided object.
+         *
+         * @example
+         * context.access.set(instance, value);
+         */
+        set(object: This, value: Value): void;
+    };
+
+    /**
+     * Adds a callback to be invoked either after static methods are defined but before
+     * static initializers are run (when decorating a `static` element), or before instance
+     * initializers are run (when decorating a non-`static` element).
+     */
+    addInitializer(initializer: (this: This) => void): void;
+
+    readonly metadata: DecoratorMetadata;
+}
+
+/**
+ * Context provided to a class `accessor` field decorator.
+ * @template This The type on which the class element will be defined. For a static class element, this will be
+ * the type of the constructor. For a non-static class element, this will be the type of the instance.
+ * @template Value The type of decorated class field.
+ */
+interface ClassAccessorDecoratorContext<
+    This = unknown,
+    Value = unknown,
+> {
+    /** The kind of class element that was decorated. */
+    readonly kind: "accessor";
+
+    /** The name of the decorated class element. */
+    readonly name: string | symbol;
+
+    /** A value indicating whether the class element is a static (`true`) or instance (`false`) element. */
+    readonly static: boolean;
+
+    /** A value indicating whether the class element has a private name. */
+    readonly private: boolean;
+
+    /** An object that can be used to access the current value of the class element at runtime. */
+    readonly access: {
+        /**
+         * Determines whether an object has a property with the same name as the decorated element.
+         */
+        has(object: This): boolean;
+
+        /**
+         * Invokes the getter on the provided object.
+         *
+         * @example
+         * let value = context.access.get(instance);
+         */
+        get(object: This): Value;
+
+        /**
+         * Invokes the setter on the provided object.
+         *
+         * @example
+         * context.access.set(instance, value);
+         */
+        set(object: This, value: Value): void;
+    };
+
+    /**
+     * Adds a callback to be invoked immediately after the auto `accessor` being
+     * decorated is initialized (regardless if the `accessor` is `static` or not).
+     */
+    addInitializer(initializer: (this: This) => void): void;
+
+    readonly metadata: DecoratorMetadata;
+}
+
+/**
+ * Describes the target provided to class `accessor` field decorators.
+ * @template This The `this` type to which the target applies.
+ * @template Value The property type for the class `accessor` field.
+ */
+interface ClassAccessorDecoratorTarget<This, Value> {
+    /**
+     * Invokes the getter that was defined prior to decorator application.
+     *
+     * @example
+     * let value = target.get.call(instance);
+     */
+    get(this: This): Value;
+
+    /**
+     * Invokes the setter that was defined prior to decorator application.
+     *
+     * @example
+     * target.set.call(instance, value);
+     */
+    set(this: This, value: Value): void;
+}
+
+/**
+ * Describes the allowed return value from a class `accessor` field decorator.
+ * @template This The `this` type to which the target applies.
+ * @template Value The property type for the class `accessor` field.
+ */
+interface ClassAccessorDecoratorResult<This, Value> {
+    /**
+     * An optional replacement getter function. If not provided, the existing getter function is used instead.
+     */
+    get?(this: This): Value;
+
+    /**
+     * An optional replacement setter function. If not provided, the existing setter function is used instead.
+     */
+    set?(this: This, value: Value): void;
+
+    /**
+     * An optional initializer mutator that is invoked when the underlying field initializer is evaluated.
+     * @param value The incoming initializer value.
+     * @returns The replacement initializer value.
+     */
+    init?(this: This, value: Value): Value;
+}
+
+/**
+ * Context provided to a class field decorator.
+ * @template This The type on which the class element will be defined. For a static class element, this will be
+ * the type of the constructor. For a non-static class element, this will be the type of the instance.
+ * @template Value The type of the decorated class field.
+ */
+interface ClassFieldDecoratorContext<
+    This = unknown,
+    Value = unknown,
+> {
+    /** The kind of class element that was decorated. */
+    readonly kind: "field";
+
+    /** The name of the decorated class element. */
+    readonly name: string | symbol;
+
+    /** A value indicating whether the class element is a static (`true`) or instance (`false`) element. */
+    readonly static: boolean;
+
+    /** A value indicating whether the class element has a private name. */
+    readonly private: boolean;
+
+    /** An object that can be used to access the current value of the class element at runtime. */
+    readonly access: {
+        /**
+         * Determines whether an object has a property with the same name as the decorated element.
+         */
+        has(object: This): boolean;
+
+        /**
+         * Gets the value of the field on the provided object.
+         */
+        get(object: This): Value;
+
+        /**
+         * Sets the value of the field on the provided object.
+         */
+        set(object: This, value: Value): void;
+    };
+
+    /**
+     * Adds a callback to be invoked immediately after the field being decorated
+     * is initialized (regardless if the field is `static` or not).
+     */
+    addInitializer(initializer: (this: This) => void): void;
+
+    readonly metadata: DecoratorMetadata;
+}