@baron1996/kline-scene-schema 0.2.3 → 0.3.0

package/dist/index.d.ts

@@ -1,11 +1,17 @@
 /** 场景协议包版本；Scene version 仍保持 1。 */
-export declare const SCENE_PACKAGE_VERSION: "0.2.3";
+export declare const SCENE_PACKAGE_VERSION: "0.3.0";
 export * from './canonical-json.js';
 export * from './canonicalize.js';
 export * from './errors.js';
 export * from './generated/chart-scene.js';
 export * from './generated/schemas.js';
 export * from './semantic-validator.js';
+export * from './generated/time-series-scene.js';
+export * from './time-series-canonical-json.js';
+export * from './time-series-canonicalize.js';
+export * from './time-series-errors.js';
+export * from './time-series-semantic-validator.js';
+export * from './time-series-validator.js';
 export * from './validator.js';
 export * from './version.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,mCAAmC;AACnC,eAAO,MAAM,qBAAqB,EAAG,OAAgB,CAAC;AAEtD,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,aAAa,CAAC;AAC5B,cAAc,4BAA4B,CAAC;AAC3C,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,mCAAmC;AACnC,eAAO,MAAM,qBAAqB,EAAG,OAAgB,CAAC;AAEtD,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,aAAa,CAAC;AAC5B,cAAc,4BAA4B,CAAC;AAC3C,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,kCAAkC,CAAC;AACjD,cAAc,iCAAiC,CAAC;AAChD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,yBAAyB,CAAC;AACxC,cAAc,qCAAqC,CAAC;AACpD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC"}

package/dist/index.js

@@ -1,10 +1,16 @@
 /** 场景协议包版本；Scene version 仍保持 1。 */
-export const SCENE_PACKAGE_VERSION = '0.2.3';
+export const SCENE_PACKAGE_VERSION = '0.3.0';
 export * from './canonical-json.js';
 export * from './canonicalize.js';
 export * from './errors.js';
 export * from './generated/chart-scene.js';
 export * from './generated/schemas.js';
 export * from './semantic-validator.js';
+export * from './generated/time-series-scene.js';
+export * from './time-series-canonical-json.js';
+export * from './time-series-canonicalize.js';
+export * from './time-series-errors.js';
+export * from './time-series-semantic-validator.js';
+export * from './time-series-validator.js';
 export * from './validator.js';
 export * from './version.js';

package/dist/time-series-canonical-json.d.ts

@@ -0,0 +1,3 @@
+export declare function serializeCanonicalTimeSeriesScene(scene: unknown): Uint8Array<ArrayBuffer>;
+export declare function hashCanonicalTimeSeriesScene(scene: unknown): Promise<string>;
+//# sourceMappingURL=time-series-canonical-json.d.ts.map

package/dist/time-series-canonical-json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-series-canonical-json.d.ts","sourceRoot":"","sources":["../src/time-series-canonical-json.ts"],"names":[],"mappings":"AAKA,wBAAgB,iCAAiC,CAChD,KAAK,EAAE,OAAO,GACZ,UAAU,CAAC,WAAW,CAAC,CAWzB;AAED,wBAAsB,4BAA4B,CACjD,KAAK,EAAE,OAAO,GACZ,OAAO,CAAC,MAAM,CAAC,CASjB"}

package/dist/time-series-canonical-json.js

@@ -0,0 +1,15 @@
+import canonicalize from 'canonicalize';
+import { TimeSeriesSceneError } from './time-series-errors.js';
+import { parseTimeSeriesScene } from './time-series-validator.js';
+export function serializeCanonicalTimeSeriesScene(scene) {
+    const parsed = parseTimeSeriesScene(scene);
+    const serialized = canonicalize(parsed);
+    if (serialized === undefined) {
+        throw new TimeSeriesSceneError('TIME_SERIES_EXPORT_INVALID', '/', 'TimeSeriesScene could not be serialized.');
+    }
+    return new TextEncoder().encode(serialized);
+}
+export async function hashCanonicalTimeSeriesScene(scene) {
+    const digest = await globalThis.crypto.subtle.digest('SHA-256', serializeCanonicalTimeSeriesScene(scene));
+    return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, '0')).join('');
+}

package/dist/time-series-canonicalize.d.ts

@@ -0,0 +1,3 @@
+import type { TimeSeriesScene } from './generated/time-series-scene.js';
+export declare function canonicalizeTimeSeriesScene(scene: TimeSeriesScene): TimeSeriesScene;
+//# sourceMappingURL=time-series-canonicalize.d.ts.map

package/dist/time-series-canonicalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-series-canonicalize.d.ts","sourceRoot":"","sources":["../src/time-series-canonicalize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEX,eAAe,EACf,MAAM,kCAAkC,CAAC;AAwB1C,wBAAgB,2BAA2B,CAC1C,KAAK,EAAE,eAAe,GACpB,eAAe,CAIjB"}

package/dist/time-series-canonicalize.js

@@ -0,0 +1,19 @@
+function sortTimeSeriesJson(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => sortTimeSeriesJson(item));
+    }
+    if (value !== null && typeof value === 'object') {
+        const sorted = {};
+        for (const key of Object.keys(value).sort()) {
+            const child = value[key];
+            if (child !== undefined) {
+                sorted[key] = sortTimeSeriesJson(child);
+            }
+        }
+        return sorted;
+    }
+    return value;
+}
+export function canonicalizeTimeSeriesScene(scene) {
+    return sortTimeSeriesJson(structuredClone(scene));
+}

package/dist/time-series-errors.d.ts

@@ -0,0 +1,13 @@
+export type TimeSeriesSceneErrorCode = 'TIME_SERIES_SCENE_SCHEMA_INVALID' | 'TIME_SERIES_SCENE_VERSION_UNSUPPORTED' | 'TIME_SERIES_ENGINE_VERSION_MISMATCH' | 'TIME_SERIES_DATA_INVALID' | 'TIME_SERIES_UNKNOWN_SERIES' | 'TIME_SERIES_RUNTIME_DESTROYED' | 'TIME_SERIES_ADAPTER_FAILED' | 'TIME_SERIES_EXPORT_INVALID' | 'TIME_SERIES_BROWSER_NOT_INSTALLED' | 'TIME_SERIES_RENDER_FAILED' | 'TIME_SERIES_RENDER_TIMEOUT';
+export interface TimeSeriesSceneIssue {
+    readonly code: TimeSeriesSceneErrorCode;
+    readonly path: string;
+    readonly message: string;
+}
+export declare class TimeSeriesSceneError extends Error {
+    readonly code: TimeSeriesSceneErrorCode;
+    readonly path: string;
+    readonly issues: readonly TimeSeriesSceneIssue[];
+    constructor(code: TimeSeriesSceneErrorCode, path: string, message: string, issues?: readonly TimeSeriesSceneIssue[]);
+}
+//# sourceMappingURL=time-series-errors.d.ts.map

package/dist/time-series-errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-series-errors.d.ts","sourceRoot":"","sources":["../src/time-series-errors.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,wBAAwB,GACjC,kCAAkC,GAClC,uCAAuC,GACvC,qCAAqC,GACrC,0BAA0B,GAC1B,4BAA4B,GAC5B,+BAA+B,GAC/B,4BAA4B,GAC5B,4BAA4B,GAC5B,mCAAmC,GACnC,2BAA2B,GAC3B,4BAA4B,CAAC;AAEhC,MAAM,WAAW,oBAAoB;IACpC,QAAQ,CAAC,IAAI,EAAE,wBAAwB,CAAC;IACxC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CACzB;AAED,qBAAa,oBAAqB,SAAQ,KAAK;IAC9C,SAAgB,IAAI,EAAE,wBAAwB,CAAC;IAC/C,SAAgB,IAAI,EAAE,MAAM,CAAC;IAC7B,SAAgB,MAAM,EAAE,SAAS,oBAAoB,EAAE,CAAC;gBAGvD,IAAI,EAAE,wBAAwB,EAC9B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,SAAS,oBAAoB,EAAE;CAQzC"}

package/dist/time-series-errors.js

@@ -0,0 +1,12 @@
+export class TimeSeriesSceneError extends Error {
+    code;
+    path;
+    issues;
+    constructor(code, path, message, issues) {
+        super(message);
+        this.name = 'TimeSeriesSceneError';
+        this.code = code;
+        this.path = path;
+        this.issues = issues ?? [{ code, path, message }];
+    }
+}

package/dist/time-series-semantic-validator.d.ts

@@ -0,0 +1,5 @@
+import type { TimeSeriesScene } from './generated/time-series-scene.js';
+import { type TimeSeriesSceneIssue } from './time-series-errors.js';
+export declare function collectTimeSeriesSemanticIssues(scene: TimeSeriesScene): readonly TimeSeriesSceneIssue[];
+export declare function assertSemanticTimeSeriesScene(scene: TimeSeriesScene): void;
+//# sourceMappingURL=time-series-semantic-validator.d.ts.map

package/dist/time-series-semantic-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-series-semantic-validator.d.ts","sourceRoot":"","sources":["../src/time-series-semantic-validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACxE,OAAO,EAEN,KAAK,oBAAoB,EACzB,MAAM,yBAAyB,CAAC;AAMjC,wBAAgB,+BAA+B,CAC9C,KAAK,EAAE,eAAe,GACpB,SAAS,oBAAoB,EAAE,CA4EjC;AAED,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI,CAW1E"}

package/dist/time-series-semantic-validator.js

@@ -0,0 +1,81 @@
+import { TimeSeriesSceneError, } from './time-series-errors.js';
+function pointerToken(value) {
+    return value.replaceAll('~', '~0').replaceAll('/', '~1');
+}
+export function collectTimeSeriesSemanticIssues(scene) {
+    const issues = [];
+    const seriesIds = new Set();
+    const firstSeries = scene.series[0];
+    for (const [index, series] of scene.series.entries()) {
+        if (seriesIds.has(series.id)) {
+            issues.push({
+                code: 'TIME_SERIES_SCENE_SCHEMA_INVALID',
+                path: `/series/${index}/id`,
+                message: `Duplicate time series id: ${series.id}.`,
+            });
+        }
+        seriesIds.add(series.id);
+        if (series.unit !== firstSeries.unit) {
+            issues.push({
+                code: 'TIME_SERIES_SCENE_SCHEMA_INVALID',
+                path: `/series/${index}/unit`,
+                message: 'All time series must use the same unit.',
+            });
+        }
+        if (series.precision !== firstSeries.precision) {
+            issues.push({
+                code: 'TIME_SERIES_SCENE_SCHEMA_INVALID',
+                path: `/series/${index}/precision`,
+                message: 'All time series must use the same precision.',
+            });
+        }
+    }
+    let previousTimestamp;
+    const timestamps = new Set();
+    for (const [index, point] of scene.data.entries()) {
+        if (previousTimestamp !== undefined &&
+            point.timestamp <= previousTimestamp) {
+            issues.push({
+                code: 'TIME_SERIES_SCENE_SCHEMA_INVALID',
+                path: `/data/${index}/timestamp`,
+                message: 'Time series timestamps must be strictly increasing.',
+            });
+        }
+        previousTimestamp = point.timestamp;
+        timestamps.add(point.timestamp);
+        const valueIds = Object.keys(point.values);
+        for (const seriesId of seriesIds) {
+            if (!Object.hasOwn(point.values, seriesId)) {
+                issues.push({
+                    code: 'TIME_SERIES_SCENE_SCHEMA_INVALID',
+                    path: `/data/${index}/values/${pointerToken(seriesId)}`,
+                    message: `Missing value for time series: ${seriesId}.`,
+                });
+            }
+        }
+        for (const valueId of valueIds) {
+            if (!seriesIds.has(valueId)) {
+                issues.push({
+                    code: 'TIME_SERIES_SCENE_SCHEMA_INVALID',
+                    path: `/data/${index}/values/${pointerToken(valueId)}`,
+                    message: `Unknown time series value key: ${valueId}.`,
+                });
+            }
+        }
+    }
+    if (!timestamps.has(scene.viewport.anchorTimestamp)) {
+        issues.push({
+            code: 'TIME_SERIES_SCENE_SCHEMA_INVALID',
+            path: '/viewport/anchorTimestamp',
+            message: 'Viewport anchorTimestamp must reference a data point.',
+        });
+    }
+    return issues;
+}
+export function assertSemanticTimeSeriesScene(scene) {
+    const issues = collectTimeSeriesSemanticIssues(scene);
+    const first = issues[0];
+    if (first !== undefined) {
+        throw new TimeSeriesSceneError(first.code, first.path, first.message, issues);
+    }
+}

package/dist/time-series-validator.d.ts

@@ -0,0 +1,4 @@
+import type { TimeSeriesScene } from './generated/time-series-scene.js';
+export declare function parseStructuralTimeSeriesScene(value: unknown): TimeSeriesScene;
+export declare function parseTimeSeriesScene(value: unknown): TimeSeriesScene;
+//# sourceMappingURL=time-series-validator.d.ts.map

package/dist/time-series-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-series-validator.d.ts","sourceRoot":"","sources":["../src/time-series-validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AA8DxE,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,OAAO,GAAG,eAAe,CAqB9E;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,eAAe,CAIpE"}

package/dist/time-series-validator.js

@@ -0,0 +1,52 @@
+import { validateTimeSeriesScene as generatedValidator } from './generated/validate-time-series-scene.js';
+import { canonicalizeTimeSeriesScene } from './time-series-canonicalize.js';
+import { TimeSeriesSceneError, } from './time-series-errors.js';
+import { assertSemanticTimeSeriesScene } from './time-series-semantic-validator.js';
+const validateStructural = generatedValidator;
+function pointerToken(value) {
+    return value.replaceAll('~', '~0').replaceAll('/', '~1');
+}
+function structuralPath(error) {
+    if (error.keyword === 'additionalProperties' &&
+        error.params?.additionalProperty !== undefined) {
+        return `${error.instancePath}/${pointerToken(error.params.additionalProperty)}` || '/';
+    }
+    if (error.keyword === 'required' &&
+        error.params?.missingProperty !== undefined) {
+        return `${error.instancePath}/${pointerToken(error.params.missingProperty)}` || '/';
+    }
+    return error.instancePath || '/';
+}
+function structuralCode(error) {
+    if (error.instancePath === '/version' && error.keyword === 'const') {
+        return 'TIME_SERIES_SCENE_VERSION_UNSUPPORTED';
+    }
+    if ((error.instancePath === '/runtime/engine' ||
+        error.instancePath === '/runtime/engineVersion') &&
+        error.keyword === 'const') {
+        return 'TIME_SERIES_ENGINE_VERSION_MISMATCH';
+    }
+    return 'TIME_SERIES_SCENE_SCHEMA_INVALID';
+}
+export function parseStructuralTimeSeriesScene(value) {
+    if (!validateStructural(value)) {
+        const errors = validateStructural.errors ?? [];
+        const issues = errors.map((error) => ({
+            code: structuralCode(error),
+            path: structuralPath(error),
+            message: error.message ?? `Schema validation failed at ${error.schemaPath}.`,
+        }));
+        const first = issues[0] ?? {
+            code: 'TIME_SERIES_SCENE_SCHEMA_INVALID',
+            path: '/',
+            message: 'TimeSeriesScene schema validation failed.',
+        };
+        throw new TimeSeriesSceneError(first.code, first.path, first.message, issues);
+    }
+    return structuredClone(value);
+}
+export function parseTimeSeriesScene(value) {
+    const structural = parseStructuralTimeSeriesScene(value);
+    assertSemanticTimeSeriesScene(structural);
+    return canonicalizeTimeSeriesScene(structural);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@baron1996/kline-scene-schema",
-  "version": "0.2.3",
+  "version": "0.3.0",
   "description": "Strict ChartScene schema, types, validation, and canonical serialization.",
   "type": "module",
   "license": "Apache-2.0",

package/schema/time-series-chart-config.schema.json

@@ -0,0 +1,75 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://baron.dev/kline-scene/time-series-chart-config.schema.json",
+  "title": "TimeSeriesChartConfig",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "locale",
+    "timezone",
+    "layout",
+    "grid",
+    "thousandsSeparator",
+    "decimalFold",
+    "zoomAnchor",
+    "dateFormat",
+    "largeNumberFormat"
+  ],
+  "properties": {
+    "locale": {
+      "type": "string",
+      "minLength": 2,
+      "maxLength": 64,
+      "pattern": "^[A-Za-z]{2,3}(?:-[A-Za-z0-9]{2,8})*$"
+    },
+    "timezone": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 128,
+      "pattern": "^[A-Za-z_+-]+(?:/[A-Za-z0-9_+-]+)*$"
+    },
+    "layout": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["backgroundColor", "textColor", "fontFamily", "fontSize"],
+      "properties": {
+        "backgroundColor": {
+          "$ref": "https://baron.dev/kline-scene/common.schema.json#/$defs/rgbaColor"
+        },
+        "textColor": {
+          "$ref": "https://baron.dev/kline-scene/common.schema.json#/$defs/rgbaColor"
+        },
+        "fontFamily": { "type": "string", "minLength": 1, "maxLength": 128 },
+        "fontSize": { "type": "number", "minimum": 8, "maximum": 32 }
+      }
+    },
+    "grid": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["horizontalColor", "verticalColor"],
+      "properties": {
+        "horizontalColor": {
+          "$ref": "https://baron.dev/kline-scene/common.schema.json#/$defs/rgbaColor"
+        },
+        "verticalColor": {
+          "$ref": "https://baron.dev/kline-scene/common.schema.json#/$defs/rgbaColor"
+        }
+      }
+    },
+    "thousandsSeparator": { "enum": ["", ",", " ", "_"] },
+    "decimalFold": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["enabled", "threshold"],
+      "properties": {
+        "enabled": { "type": "boolean" },
+        "threshold": { "type": "integer", "minimum": 1, "maximum": 16 }
+      }
+    },
+    "zoomAnchor": { "enum": ["cursor", "right"] },
+    "dateFormat": {
+      "enum": ["yyyy-MM-dd", "yyyy-MM-dd HH:mm", "yyyy-MM-dd HH:mm:ss"]
+    },
+    "largeNumberFormat": { "enum": ["western", "chinese", "plain"] }
+  }
+}

package/schema/time-series-runtime.schema.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://baron.dev/kline-scene/time-series-runtime.schema.json",
+  "title": "TimeSeriesRuntimeIdentity",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["engine", "engineVersion", "runtimeVersion"],
+  "properties": {
+    "engine": { "const": "klinecharts" },
+    "engineVersion": { "const": "10.0.0" },
+    "runtimeVersion": { "const": "0.1.0" }
+  }
+}

package/schema/time-series-scene.schema.json

@@ -0,0 +1,154 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://baron.dev/kline-scene/time-series-scene.schema.json",
+  "title": "TimeSeriesScene",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "schema",
+    "version",
+    "runtime",
+    "period",
+    "series",
+    "data",
+    "chart",
+    "viewport",
+    "render",
+    "metadata"
+  ],
+  "properties": {
+    "schema": { "const": "@baron1996/time-series-scene" },
+    "version": { "const": 1 },
+    "runtime": {
+      "$ref": "https://baron.dev/kline-scene/time-series-runtime.schema.json"
+    },
+    "period": { "$ref": "#/$defs/timeSeriesPeriod" },
+    "series": {
+      "type": "array",
+      "minItems": 1,
+      "maxItems": 64,
+      "items": { "$ref": "#/$defs/timeSeriesDefinition" }
+    },
+    "data": {
+      "type": "array",
+      "minItems": 1,
+      "maxItems": 1000000,
+      "items": { "$ref": "#/$defs/timeSeriesPoint" }
+    },
+    "chart": {
+      "$ref": "https://baron.dev/kline-scene/time-series-chart-config.schema.json"
+    },
+    "viewport": { "$ref": "#/$defs/timeSeriesViewport" },
+    "render": { "$ref": "#/$defs/timeSeriesRender" },
+    "metadata": { "$ref": "#/$defs/metadata" }
+  },
+  "$defs": {
+    "timeSeriesPeriod": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["span", "type"],
+      "properties": {
+        "span": { "type": "integer", "minimum": 1, "maximum": 100000 },
+        "type": {
+          "enum": ["second", "minute", "hour", "day", "week", "month", "year"]
+        }
+      }
+    },
+    "timeSeriesDefinition": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "name", "type", "unit", "precision", "visible", "style"],
+      "properties": {
+        "id": {
+          "type": "string",
+          "pattern": "^[A-Za-z][A-Za-z0-9_-]{0,63}$"
+        },
+        "name": { "type": "string", "minLength": 1, "maxLength": 256 },
+        "type": { "const": "line" },
+        "unit": { "type": "string", "minLength": 1, "maxLength": 64 },
+        "precision": { "type": "integer", "minimum": 0, "maximum": 16 },
+        "visible": { "type": "boolean" },
+        "style": {
+          "$ref": "https://baron.dev/kline-scene/common.schema.json#/$defs/lineStyle"
+        }
+      }
+    },
+    "timeSeriesPoint": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["timestamp", "values"],
+      "properties": {
+        "timestamp": {
+          "type": "integer",
+          "minimum": 1,
+          "maximum": 9007199254740991
+        },
+        "values": {
+          "type": "object",
+          "minProperties": 1,
+          "maxProperties": 64,
+          "propertyNames": { "pattern": "^[A-Za-z][A-Za-z0-9_-]{0,63}$" },
+          "additionalProperties": {
+            "oneOf": [
+              {
+                "$ref": "https://baron.dev/kline-scene/common.schema.json#/$defs/finiteNumber"
+              },
+              { "type": "null" }
+            ]
+          }
+        }
+      }
+    },
+    "timeSeriesViewport": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["barSpace", "rightOffsetDistance", "anchorTimestamp"],
+      "properties": {
+        "barSpace": { "type": "number", "minimum": 1, "maximum": 100 },
+        "rightOffsetDistance": { "type": "number", "minimum": 0, "maximum": 10000 },
+        "anchorTimestamp": {
+          "type": "integer",
+          "minimum": 1,
+          "maximum": 9007199254740991
+        }
+      }
+    },
+    "timeSeriesRender": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "width",
+        "height",
+        "deviceScaleFactor",
+        "background",
+        "fontFamily",
+        "timeoutMs"
+      ],
+      "properties": {
+        "width": { "type": "integer", "minimum": 320, "maximum": 8192 },
+        "height": { "type": "integer", "minimum": 240, "maximum": 8192 },
+        "deviceScaleFactor": { "type": "number", "minimum": 0.5, "maximum": 4 },
+        "background": {
+          "$ref": "https://baron.dev/kline-scene/common.schema.json#/$defs/rgbaColor"
+        },
+        "fontFamily": { "const": "Baron Sans" },
+        "timeoutMs": { "type": "integer", "minimum": 100, "maximum": 120000 }
+      }
+    },
+    "metadata": {
+      "type": "object",
+      "maxProperties": 64,
+      "propertyNames": { "type": "string", "minLength": 1, "maxLength": 128 },
+      "additionalProperties": {
+        "oneOf": [
+          { "type": "null" },
+          { "type": "boolean" },
+          {
+            "$ref": "https://baron.dev/kline-scene/common.schema.json#/$defs/finiteNumber"
+          },
+          { "type": "string" }
+        ]
+      }
+    }
+  }
+}