@ancplua/qyl-api-schema 10.0.1 → 11.0.1

package/README.md

@@ -82,7 +82,7 @@ against the schema, so pair it with the matching type from `./types`.
 
 `scripts/emit-contract-revision.mjs` stamps a deterministic revision — `sha256:` plus
 the first 16 hex characters of the contract's canonical semantic digest — into both
-generated faces during `npm run compile`. A collector reports the revision it was built
+generated faces during `bun run compile`. A collector reports the revision it was built
 against on its health response, so a client can detect a peer built from a different
 contract instead of discovering the mismatch one malformed field at a time. Read the
 current value from a running collector or the generated artifacts; it is derived, never

package/common/types.tsp

@@ -255,7 +255,23 @@ model AttributeKeyValueListValue {
   values: Record<AttributeValue>;
 }
 
-@doc("Lossless JSON projection of an OpenTelemetry AnyValue attribute.")
+@doc("Object-shaped AttributeValue variants. The variant name is the wire `type` tag.")
+@discriminated(#{ envelope: "none", discriminatorPropertyName: "type" })
+union AttributeObjectValue {
+  @doc("Lossless 64-bit integer value")
+  int: AttributeIntValue,
+
+  @doc("Lossless finite or non-finite 64-bit floating point value")
+  double: AttributeDoubleValue,
+
+  @doc("Bytes value projected as an explicit tagged object")
+  bytes: AttributeBytesValue,
+
+  @doc("Recursive key-value-list value")
+  kvlist: AttributeKeyValueListValue,
+}
+
+@doc("Lossless JSON projection of an OpenTelemetry AnyValue attribute. Primitive variants are bare JSON values; object variants carry a `type` tag.")
 union AttributeValue {
   @doc("Empty AnyValue")
   emptyValue: null,
@@ -266,20 +282,11 @@ union AttributeValue {
   @doc("Boolean value")
   boolValue: boolean,
 
-  @doc("Lossless 64-bit integer value")
-  intValue: AttributeIntValue,
-
-  @doc("Lossless finite or non-finite 64-bit floating point value")
-  doubleValue: AttributeDoubleValue,
-
-  @doc("Bytes value projected as an explicit tagged object")
-  bytesValue: AttributeBytesValue,
-
   @doc("Nested and heterogeneous array value")
   arrayValue: AttributeValue[],
 
-  @doc("Recursive key-value-list value")
-  keyValueListValue: AttributeKeyValueListValue,
+  @doc("Tagged object value")
+  objectValue: AttributeObjectValue,
 }
 
 @doc("Key-value attribute pair following OTel conventions")

package/generated/json-schema/qyl-api-schema.json

@@ -142,25 +142,43 @@
       },
       "description": "Tagged recursive OTLP key-value-list, distinct from other object-shaped attribute variants."
     },
-    "Common.AttributeValue": {
-      "anyOf": [
+    "Common.AttributeObjectValue": {
+      "type": "object",
+      "oneOf": [
         {
-          "type": "null"
+          "$ref": "#/$defs/Common.AttributeIntValue"
         },
         {
-          "type": "string"
+          "$ref": "#/$defs/Common.AttributeDoubleValue"
         },
         {
-          "type": "boolean"
+          "$ref": "#/$defs/Common.AttributeBytesValue"
         },
         {
-          "$ref": "#/$defs/Common.AttributeIntValue"
+          "$ref": "#/$defs/Common.AttributeKeyValueListValue"
+        }
+      ],
+      "discriminator": {
+        "propertyName": "type",
+        "mapping": {
+          "int": "#/components/schemas/Common.AttributeIntValue",
+          "double": "#/components/schemas/Common.AttributeDoubleValue",
+          "bytes": "#/components/schemas/Common.AttributeBytesValue",
+          "kvlist": "#/components/schemas/Common.AttributeKeyValueListValue"
+        }
+      },
+      "description": "Object-shaped AttributeValue variants. The variant name is the wire `type` tag."
+    },
+    "Common.AttributeValue": {
+      "anyOf": [
+        {
+          "type": "null"
         },
         {
-          "$ref": "#/$defs/Common.AttributeDoubleValue"
+          "type": "string"
         },
         {
-          "$ref": "#/$defs/Common.AttributeBytesValue"
+          "type": "boolean"
         },
         {
           "type": "array",
@@ -169,10 +187,10 @@
           }
         },
         {
-          "$ref": "#/$defs/Common.AttributeKeyValueListValue"
+          "$ref": "#/$defs/Common.AttributeObjectValue"
         }
       ],
-      "description": "Lossless JSON projection of an OpenTelemetry AnyValue attribute."
+      "description": "Lossless JSON projection of an OpenTelemetry AnyValue attribute. Primitive variants are bare JSON values; object variants carry a `type` tag."
     },
     "Common.Attributes": {
       "type": "object",
@@ -2210,104 +2228,6 @@
       ],
       "description": "Telemetry SDK language"
     },
-    "OTel.Logs.LogBody": {
-      "type": "object",
-      "oneOf": [
-        {
-          "$ref": "#/$defs/OTel.Logs.LogBodyString"
-        },
-        {
-          "$ref": "#/$defs/OTel.Logs.LogBodyKvList"
-        },
-        {
-          "$ref": "#/$defs/OTel.Logs.LogBodyArray"
-        },
-        {
-          "$ref": "#/$defs/OTel.Logs.LogBodyBytes"
-        }
-      ],
-      "discriminator": {
-        "propertyName": "kind",
-        "mapping": {
-          "stringBody": "#/components/schemas/OTel.Logs.LogBodyString",
-          "kvListBody": "#/components/schemas/OTel.Logs.LogBodyKvList",
-          "arrayBody": "#/components/schemas/OTel.Logs.LogBodyArray",
-          "bytesBody": "#/components/schemas/OTel.Logs.LogBodyBytes"
-        }
-      },
-      "description": "Log body content - can be string, structured, or bytes"
-    },
-    "OTel.Logs.LogBodyArray": {
-      "type": "object",
-      "required": [
-        "array_value"
-      ],
-      "properties": {
-        "array_value": {
-          "type": "array",
-          "items": {
-            "$ref": "#/$defs/Common.AttributeValue"
-          },
-          "description": "Array of values"
-        }
-      },
-      "unevaluatedProperties": {
-        "not": {}
-      },
-      "description": "Array log body"
-    },
-    "OTel.Logs.LogBodyBytes": {
-      "type": "object",
-      "required": [
-        "bytes_value"
-      ],
-      "properties": {
-        "bytes_value": {
-          "type": "string",
-          "contentEncoding": "base64",
-          "description": "Binary value (base64 encoded)"
-        }
-      },
-      "unevaluatedProperties": {
-        "not": {}
-      },
-      "description": "Binary log body"
-    },
-    "OTel.Logs.LogBodyKvList": {
-      "type": "object",
-      "required": [
-        "kv_list_value"
-      ],
-      "properties": {
-        "kv_list_value": {
-          "type": "array",
-          "items": {
-            "$ref": "#/$defs/Common.Attribute"
-          },
-          "description": "Key-value pairs"
-        }
-      },
-      "unevaluatedProperties": {
-        "not": {}
-      },
-      "description": "Structured key-value log body"
-    },
-    "OTel.Logs.LogBodyString": {
-      "type": "object",
-      "required": [
-        "string_value"
-      ],
-      "properties": {
-        "string_value": {
-          "type": "string",
-          "description": "String value"
-        }
-      },
-      "unevaluatedProperties": {
-        "not": {}
-      },
-      "description": "String log body"
-    },
     "OTel.Logs.LogRecord": {
       "type": "object",
       "required": [
@@ -2335,8 +2255,8 @@
           "description": "Severity text (DEBUG, INFO, WARN, ERROR, etc.)"
         },
         "body": {
-          "$ref": "#/$defs/OTel.Logs.LogBody",
-          "description": "Log body - the main content"
+          "$ref": "#/$defs/Common.AttributeValue",
+          "description": "Log body: the OTLP AnyValue, projected exactly like an attribute value"
         },
         "attributes": {
           "type": "array",

package/generated/openapi/qyl.openapi.json

@@ -13124,25 +13124,43 @@
         },
         "description": "Tagged recursive OTLP key-value-list, distinct from other object-shaped attribute variants."
       },
-      "Common.AttributeValue": {
-        "anyOf": [
+      "Common.AttributeObjectValue": {
+        "type": "object",
+        "oneOf": [
           {
-            "type": "null"
+            "$ref": "#/components/schemas/Common.AttributeIntValue"
           },
           {
-            "type": "string"
+            "$ref": "#/components/schemas/Common.AttributeDoubleValue"
           },
           {
-            "type": "boolean"
+            "$ref": "#/components/schemas/Common.AttributeBytesValue"
           },
           {
-            "$ref": "#/components/schemas/Common.AttributeIntValue"
+            "$ref": "#/components/schemas/Common.AttributeKeyValueListValue"
+          }
+        ],
+        "discriminator": {
+          "propertyName": "type",
+          "mapping": {
+            "int": "#/components/schemas/Common.AttributeIntValue",
+            "double": "#/components/schemas/Common.AttributeDoubleValue",
+            "bytes": "#/components/schemas/Common.AttributeBytesValue",
+            "kvlist": "#/components/schemas/Common.AttributeKeyValueListValue"
+          }
+        },
+        "description": "Object-shaped AttributeValue variants. The variant name is the wire `type` tag."
+      },
+      "Common.AttributeValue": {
+        "anyOf": [
+          {
+            "type": "null"
           },
           {
-            "$ref": "#/components/schemas/Common.AttributeDoubleValue"
+            "type": "string"
           },
           {
-            "$ref": "#/components/schemas/Common.AttributeBytesValue"
+            "type": "boolean"
           },
           {
             "type": "array",
@@ -13151,10 +13169,10 @@
             }
           },
           {
-            "$ref": "#/components/schemas/Common.AttributeKeyValueListValue"
+            "$ref": "#/components/schemas/Common.AttributeObjectValue"
           }
         ],
-        "description": "Lossless JSON projection of an OpenTelemetry AnyValue attribute."
+        "description": "Lossless JSON projection of an OpenTelemetry AnyValue attribute. Primitive variants are bare JSON values; object variants carry a `type` tag."
       },
       "Common.Attributes": {
         "type": "object",
@@ -15190,104 +15208,6 @@
         ],
         "description": "Telemetry SDK language"
       },
-      "OTel.Logs.LogBody": {
-        "type": "object",
-        "oneOf": [
-          {
-            "$ref": "#/components/schemas/OTel.Logs.LogBodyString"
-          },
-          {
-            "$ref": "#/components/schemas/OTel.Logs.LogBodyKvList"
-          },
-          {
-            "$ref": "#/components/schemas/OTel.Logs.LogBodyArray"
-          },
-          {
-            "$ref": "#/components/schemas/OTel.Logs.LogBodyBytes"
-          }
-        ],
-        "discriminator": {
-          "propertyName": "kind",
-          "mapping": {
-            "stringBody": "#/components/schemas/OTel.Logs.LogBodyString",
-            "kvListBody": "#/components/schemas/OTel.Logs.LogBodyKvList",
-            "arrayBody": "#/components/schemas/OTel.Logs.LogBodyArray",
-            "bytesBody": "#/components/schemas/OTel.Logs.LogBodyBytes"
-          }
-        },
-        "description": "Log body content - can be string, structured, or bytes"
-      },
-      "OTel.Logs.LogBodyArray": {
-        "type": "object",
-        "required": [
-          "array_value"
-        ],
-        "properties": {
-          "array_value": {
-            "type": "array",
-            "items": {
-              "$ref": "#/components/schemas/Common.AttributeValue"
-            },
-            "description": "Array of values"
-          }
-        },
-        "unevaluatedProperties": {
-          "not": {}
-        },
-        "description": "Array log body"
-      },
-      "OTel.Logs.LogBodyBytes": {
-        "type": "object",
-        "required": [
-          "bytes_value"
-        ],
-        "properties": {
-          "bytes_value": {
-            "type": "string",
-            "contentEncoding": "base64",
-            "description": "Binary value (base64 encoded)"
-          }
-        },
-        "unevaluatedProperties": {
-          "not": {}
-        },
-        "description": "Binary log body"
-      },
-      "OTel.Logs.LogBodyKvList": {
-        "type": "object",
-        "required": [
-          "kv_list_value"
-        ],
-        "properties": {
-          "kv_list_value": {
-            "type": "array",
-            "items": {
-              "$ref": "#/components/schemas/Common.Attribute"
-            },
-            "description": "Key-value pairs"
-          }
-        },
-        "unevaluatedProperties": {
-          "not": {}
-        },
-        "description": "Structured key-value log body"
-      },
-      "OTel.Logs.LogBodyString": {
-        "type": "object",
-        "required": [
-          "string_value"
-        ],
-        "properties": {
-          "string_value": {
-            "type": "string",
-            "description": "String value"
-          }
-        },
-        "unevaluatedProperties": {
-          "not": {}
-        },
-        "description": "String log body"
-      },
       "OTel.Logs.LogRecord": {
         "type": "object",
         "required": [
@@ -15315,8 +15235,8 @@
             "description": "Severity text (DEBUG, INFO, WARN, ERROR, etc.)"
           },
           "body": {
-            "$ref": "#/components/schemas/OTel.Logs.LogBody",
-            "description": "Log body - the main content"
+            "$ref": "#/components/schemas/Common.AttributeValue",
+            "description": "Log body: the OTLP AnyValue, projected exactly like an attribute value"
           },
           "attributes": {
             "type": "array",

package/generated/runtime/index.d.ts

@@ -0,0 +1,23 @@
+import type { AttributeValue } from "@ancplua/qyl-api-schema/types";
+export { AttributeObjectValueTags, isAttributeObjectValue, matchAttributeValue, } from "../../generated/ts-runtime/runtime.js";
+export type { AttributeObjectValueTag, AttributeValueHandlers } from "../../generated/ts-runtime/runtime.js";
+/** An AttributeValue with the wire tags removed: what a reader sees, not how it travelled. */
+export type DecodedAttributeValue = null | string | boolean | number | DecodedAttributeValue[] | {
+    readonly type: "bytes";
+    readonly base64: string;
+} | {
+    readonly [key: string]: DecodedAttributeValue;
+};
+/** Strip the tags. int64 stays text so no digit is lost; bytes stay marked so they never read as a string. */
+export declare function decodeAttributeValue(value: AttributeValue): DecodedAttributeValue;
+/** One line of text for any value; never `[object Object]`. */
+export declare function formatAttributeValue(value: AttributeValue): string;
+/** The value when it is a plain string, otherwise undefined. */
+export declare function attributeString(value: AttributeValue | undefined): string | undefined;
+/** A JavaScript number when one can represent the value exactly, otherwise undefined. */
+export declare function attributeNumber(value: AttributeValue | undefined): number | undefined;
+/**
+ * A stable text identity for grouping and hashing: the canonical wire JSON with object keys
+ * sorted. Two values with the same identity are the same attribute value.
+ */
+export declare function attributeIdentity(value: AttributeValue): string;

package/generated/runtime/index.js

@@ -0,0 +1,70 @@
+import { matchAttributeValue } from "../../generated/ts-runtime/runtime.js";
+export { AttributeObjectValueTags, isAttributeObjectValue, matchAttributeValue, } from "../../generated/ts-runtime/runtime.js";
+/** Strip the tags. int64 stays text so no digit is lost; bytes stay marked so they never read as a string. */
+export function decodeAttributeValue(value) {
+    return matchAttributeValue(value, {
+        emptyValue: () => null,
+        stringValue: (text) => text,
+        boolValue: (flag) => flag,
+        arrayValue: (items) => items.map(decodeAttributeValue),
+        int: (tagged) => tagged.value,
+        double: (tagged) => tagged.value,
+        bytes: (tagged) => ({ type: "bytes", base64: tagged.base64 }),
+        kvlist: (tagged) => Object.fromEntries(Object.entries(tagged.values).map(([key, nested]) => [key, decodeAttributeValue(nested)])),
+    });
+}
+/** One line of text for any value; never `[object Object]`. */
+export function formatAttributeValue(value) {
+    const decoded = decodeAttributeValue(value);
+    if (decoded === null)
+        return "null";
+    if (typeof decoded === "string")
+        return decoded;
+    if (typeof decoded === "boolean" || typeof decoded === "number")
+        return String(decoded);
+    return JSON.stringify(decoded);
+}
+/** The value when it is a plain string, otherwise undefined. */
+export function attributeString(value) {
+    return typeof value === "string" ? value : undefined;
+}
+/** A JavaScript number when one can represent the value exactly, otherwise undefined. */
+export function attributeNumber(value) {
+    if (value === undefined)
+        return undefined;
+    return matchAttributeValue(value, {
+        emptyValue: () => undefined,
+        stringValue: () => undefined,
+        boolValue: () => undefined,
+        arrayValue: () => undefined,
+        int: (tagged) => {
+            const parsed = Number(tagged.value);
+            return Number.isSafeInteger(parsed) ? parsed : undefined;
+        },
+        double: (tagged) => Number(tagged.value),
+        bytes: () => undefined,
+        kvlist: () => undefined,
+    });
+}
+/**
+ * A stable text identity for grouping and hashing: the canonical wire JSON with object keys
+ * sorted. Two values with the same identity are the same attribute value.
+ */
+export function attributeIdentity(value) {
+    return JSON.stringify(sortKeys(value));
+}
+function sortKeys(value) {
+    return matchAttributeValue(value, {
+        emptyValue: () => null,
+        stringValue: (text) => text,
+        boolValue: (flag) => flag,
+        arrayValue: (items) => items.map(sortKeys),
+        int: (tagged) => ({ type: "int", value: tagged.value }),
+        double: (tagged) => ({ type: "double", value: tagged.value }),
+        bytes: (tagged) => ({ base64: tagged.base64, type: "bytes" }),
+        kvlist: (tagged) => ({
+            type: "kvlist",
+            values: Object.fromEntries(Object.entries(tagged.values).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)).map(([key, nested]) => [key, sortKeys(nested)])),
+        }),
+    });
+}

package/generated/ts-runtime/api.d.ts

@@ -396,9 +396,9 @@ export declare const FetchTelemetryViewValues: {
 };
 export type FetchTelemetryView = typeof FetchTelemetryViewValues[keyof typeof FetchTelemetryViewValues];
 export type AttributeDouble = number | "NaN" | "Infinity" | "-Infinity";
-export type AttributeValue = null | string | boolean | AttributeIntValue | AttributeDoubleValue | AttributeBytesValue | AttributeValue[] | AttributeKeyValueListValue;
+export type AttributeValue = null | string | boolean | AttributeValue[] | AttributeObjectValue;
+export type AttributeObjectValue = AttributeIntValue | AttributeDoubleValue | AttributeBytesValue | AttributeKeyValueListValue;
 export type ApiError = NotFoundError | ValidationError | UnauthorizedError | ForbiddenError | ConflictError | RateLimitError | InternalServerError | BadGatewayError | ServiceUnavailableError;
-export type LogBody = LogBodyString | LogBodyKvList | LogBodyArray | LogBodyBytes;
 export type RunnerResourceEvents = RunnerResourceState;
 export type RunnerLogEvents = RunnerLogLine;
 export type WorkbenchServerConfiguration = WorkbenchStdioServerConfiguration | WorkbenchStreamableHttpServerConfiguration | WorkbenchBuiltinServerConfiguration;
@@ -643,7 +643,7 @@ export interface LogRecord {
     "observed_time_unix_nano": string;
     "severity_number": SeverityNumber;
     "severity_text"?: SeverityText;
-    "body": LogBody;
+    "body": AttributeValue;
     "attributes"?: Attribute[];
     "dropped_attributes_count"?: number;
     "flags"?: number;
@@ -653,18 +653,6 @@ export interface LogRecord {
     "resource": Resource;
     "instrumentation_scope"?: InstrumentationScope;
 }
-export interface LogBodyString {
-    "string_value": string;
-}
-export interface LogBodyKvList {
-    "kv_list_value": Attribute[];
-}
-export interface LogBodyArray {
-    "array_value": AttributeValue[];
-}
-export interface LogBodyBytes {
-    "bytes_value": string;
-}
 export interface LogTemplate {
     "template": string;
     "parameters": Attribute[];

package/generated/ts-runtime/api.js

@@ -320,4 +320,4 @@ export const FetchTelemetryViewValues = {
 };
 // --- contract revision (scripts/emit-contract-revision.mjs) ---
 /** Revision of the API contract these types were emitted from; compare against HealthReport.contract_revision. */
-export const CONTRACT_REVISION = "sha256:cd69d9c37a41916c";
+export const CONTRACT_REVISION = "sha256:5c1aa27ccdf48067";

package/generated/ts-runtime/runtime.d.ts

@@ -0,0 +1,16 @@
+import type { AttributeBytesValue, AttributeDoubleValue, AttributeIntValue, AttributeKeyValueListValue, AttributeObjectValue, AttributeValue } from "./api.js";
+export declare const AttributeObjectValueTags: readonly ["int", "double", "bytes", "kvlist"];
+export type AttributeObjectValueTag = typeof AttributeObjectValueTags[number];
+export declare function isAttributeObjectValue(value: unknown): value is AttributeObjectValue;
+export interface AttributeValueHandlers<R> {
+    emptyValue: () => R;
+    stringValue: (value: string) => R;
+    boolValue: (value: boolean) => R;
+    arrayValue: (value: AttributeValue[]) => R;
+    int: (value: AttributeIntValue) => R;
+    double: (value: AttributeDoubleValue) => R;
+    bytes: (value: AttributeBytesValue) => R;
+    kvlist: (value: AttributeKeyValueListValue) => R;
+}
+/** Exhaustive over every AttributeValue variant; a handler per variant, no default. */
+export declare function matchAttributeValue<R>(value: AttributeValue, handlers: AttributeValueHandlers<R>): R;

package/generated/ts-runtime/runtime.js

@@ -0,0 +1,26 @@
+// <auto-generated/>
+// Copyright (c) 2025-2026 ancplua
+export const AttributeObjectValueTags = ["int", "double", "bytes", "kvlist"];
+export function isAttributeObjectValue(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        && AttributeObjectValueTags.includes(String(value.type));
+}
+/** Exhaustive over every AttributeValue variant; a handler per variant, no default. */
+export function matchAttributeValue(value, handlers) {
+    if (value === null)
+        return handlers.emptyValue();
+    if (typeof value === "string")
+        return handlers.stringValue(value);
+    if (typeof value === "boolean")
+        return handlers.boolValue(value);
+    if (Array.isArray(value))
+        return handlers.arrayValue(value);
+    switch (value.type) {
+        case "int": return handlers.int(value);
+        case "double": return handlers.double(value);
+        case "bytes": return handlers.bytes(value);
+        case "kvlist": return handlers.kvlist(value);
+        default:
+            throw new TypeError(`AttributeObjectValue has unknown type tag '${String(value.type)}'.`);
+    }
+}

package/otel/logs.tsp

@@ -40,8 +40,8 @@ model LogRecord {
   @encodedName("application/json", "severity_text")
   severityText?: SeverityText;
 
-  @doc("Log body - the main content")
-  body: LogBody;
+  @doc("Log body: the OTLP AnyValue, projected exactly like an attribute value")
+  body: AttributeValue;
 
   @doc("Log attributes")
   attributes?: Attribute[];
@@ -77,50 +77,6 @@ model LogRecord {
 // Log Body Types (Discriminated Union)
 // =============================================================================
 
-@doc("Log body content - can be string, structured, or bytes")
-@discriminated(#{ envelope: "none" })
-union LogBody {
-  @doc("Plain string body")
-  stringBody: LogBodyString,
-
-  @doc("Structured key-value body")
-  kvListBody: LogBodyKvList,
-
-  @doc("Array body")
-  arrayBody: LogBodyArray,
-
-  @doc("Binary body")
-  bytesBody: LogBodyBytes,
-}
-
-@doc("String log body")
-model LogBodyString {
-  @doc("String value")
-  @encodedName("application/json", "string_value")
-  stringValue: string;
-}
-
-@doc("Structured key-value log body")
-model LogBodyKvList {
-  @doc("Key-value pairs")
-  @encodedName("application/json", "kv_list_value")
-  kvListValue: Attribute[];
-}
-
-@doc("Array log body")
-model LogBodyArray {
-  @doc("Array of values")
-  @encodedName("application/json", "array_value")
-  arrayValue: AttributeValue[];
-}
-
-@doc("Binary log body")
-model LogBodyBytes {
-  @doc("Binary value (base64 encoded)")
-  @encodedName("application/json", "bytes_value")
-  bytesValue: bytes;
-}
-
 // =============================================================================
 // Structured Log Templates
 // =============================================================================

package/package.json

@@ -1,8 +1,14 @@
 {
   "name": "@ancplua/qyl-api-schema",
-  "version": "10.0.1",
+  "version": "11.0.1",
   "description": "TypeSpec source of truth for qyl API contracts. Emits OpenAPI, JSON Schema, Qyl.Api.Contracts DTOs, and TypeScript contract types; not an OpenTelemetry package, storage schema, or server implementation.",
   "license": "Apache-2.0",
+  "packageManager": "bun@1.4.2",
+  "workspaces": [
+    "emitters/csharp",
+    "emitters/ts-types",
+    "emitters/qyl-lint"
+  ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ANcpLua/qyl-api-schema.git"
@@ -47,6 +53,11 @@
       "types": "./generated/zod-runtime/index.d.ts",
       "import": "./generated/zod-runtime/index.js",
       "default": "./generated/zod-runtime/index.js"
+    },
+    "./runtime": {
+      "types": "./generated/runtime/index.d.ts",
+      "import": "./generated/runtime/index.js",
+      "default": "./generated/runtime/index.js"
     }
   },
   "files": [
@@ -70,12 +81,15 @@
     "otel/span.tsp",
     "generated/ts-runtime/api.d.ts",
     "generated/ts-runtime/api.js",
+    "generated/ts-runtime/runtime.d.ts",
+    "generated/ts-runtime/runtime.js",
     "generated/openapi/qyl.openapi.json",
     "generated/json-schema/qyl-api-schema.json",
     "generated/zod-runtime/index.d.ts",
     "generated/zod-runtime/index.js",
     "README.md",
-    "LICENSE"
+    "LICENSE",
+    "generated/runtime"
   ],
   "publishConfig": {
     "access": "public",
@@ -89,16 +103,18 @@
     "build:zod-runtime": "tsc -p tsconfig.zod.json",
     "build:json-schema": "node scripts/openapi-to-json-schema.mjs",
     "emit:contract-revision": "node scripts/emit-contract-revision.mjs",
-    "prepare": "npm run build:emitters",
-    "prepack": "npm run compile",
-    "compile": "npm run clean:generated && npm run build:emitters && tsp compile main.tsp && npm run emit:contract-revision && npm run build:json-schema && npm run build:ts-runtime && npm run build:zod-runtime",
+    "prepare": "bun run build:emitters",
+    "prepack": "bun run compile",
+    "compile": "bun run clean:generated && bun run build:emitters && tsp compile main.tsp && bun run emit:contract-revision && bun run build:json-schema && bun run build:ts-runtime && bun run build:runtime && bun run build:zod-runtime",
     "format": "tsp format **/*.tsp",
-    "lint": "npm run build:emitters && tsp compile main.tsp --no-emit --warn-as-error",
-    "lint:public": "npm run build:emitters && tsp compile index.tsp --no-emit --warn-as-error",
+    "lint": "bun run build:emitters && tsp compile main.tsp --no-emit --warn-as-error",
+    "lint:public": "bun run build:emitters && tsp compile index.tsp --no-emit --warn-as-error",
     "verify:routes": "node scripts/verify-route-contracts.mjs",
     "verify:contracts": "node scripts/verify-contract-fixtures.mjs",
-    "verify:zod-contracts": "npm run build:zod-runtime && node scripts/verify-zod-contracts.mjs",
-    "verify:lint-rules": "npm run build:emitters && node scripts/verify-lint-rules.mjs"
+    "verify:zod-contracts": "bun run build:zod-runtime && node scripts/verify-zod-contracts.mjs",
+    "verify:lint-rules": "bun run build:emitters && node scripts/verify-lint-rules.mjs",
+    "lint:js": "oxlint .",
+    "build:runtime": "tsc -p tsconfig.runtime.json"
   },
   "peerDependencies": {
     "@typespec/compiler": "^1.13.0 || >=1.13.0-dev.0",
@@ -133,9 +149,9 @@
     }
   },
   "devDependencies": {
-    "@ancplua/typespec-emit-csharp": "file:./emitters/csharp",
-    "@ancplua/typespec-emit-ts-types": "file:./emitters/ts-types",
-    "@ancplua/typespec-qyl-lint": "file:./emitters/qyl-lint",
+    "@ancplua/typespec-emit-csharp": "*",
+    "@ancplua/typespec-emit-ts-types": "*",
+    "@ancplua/typespec-qyl-lint": "*",
     "@types/node": "26.4.1",
     "@typespec/compiler": "1.16.0",
     "@typespec/events": "0.86.0",
@@ -144,6 +160,8 @@
     "@typespec/openapi3": "1.16.0",
     "@typespec/sse": "0.86.0",
     "ajv": "8.20.0",
+    "oxlint": "^1.83.0",
+    "oxlint-tsgolint": "^7.0.2001",
     "typescript": "7.0.2",
     "zod": "4.5.4"
   }