@sparkelf/dsh-artifact-app 0.0.0-stage → 0.1.0

package/lib/index.d.ts

@@ -0,0 +1,638 @@
+import { Context } from "@deepseek-ai/cordis";
+import { IncomingMessage, ServerResponse } from "node:http";
+//#region ../../node_modules/.pnpm/@deepseek-ai+cosmokit@1.8.5/node_modules/@deepseek-ai/cosmokit/lib/types/types.d.ts
+declare function isArrayBufferLike(value: any): value is ArrayBufferLike;
+declare function isArrayBufferSource(value: any): value is Binary.Source;
+/** Binary source detection and base64/hex conversion helpers. */
+declare namespace Binary {
+  type Source<T extends ArrayBufferLike = ArrayBufferLike> = T | ArrayBufferView<T>;
+  const is: typeof isArrayBufferLike;
+  const isSource: typeof isArrayBufferSource;
+  function fromSource<T extends ArrayBufferLike>(source: Source<T>): T;
+  function toBase64(source: Source): string;
+  function fromBase64(source: string): ArrayBuffer | Uint8Array<ArrayBuffer>;
+  function toHex(source: Source): string;
+  function fromHex(source: string): ArrayBuffer;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@deepseek-ai+cosmokit@1.8.5/node_modules/@deepseek-ai/cosmokit/lib/types/misc.d.ts
+/** String/symbol keyed dictionary type. */
+type Dict<T = any, K extends string | symbol = string> = { [key in K]: T; };
+//#endregion
+//#region ../../node_modules/.pnpm/@deepseek-ai+cosmokit@1.8.5/node_modules/@deepseek-ai/cosmokit/lib/types/volatile.d.ts
+/** Shared config references used by schema validators and plugin runtimes. */
+/** Recursively readonly data returned by a volatile config reference. */
+type VolatileSnapshot<T> = T extends object ? { readonly [K in keyof T]: VolatileSnapshot<T[K]>; } : T;
+/** A stable reference; keep the reference, or capture its value for one operation only. */
+interface Volatile<T> {
+  /** @returns the current immutable snapshot, including undefined for an absent value. */
+  get(): VolatileSnapshot<T>;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@standard-schema+spec@1.1.0/node_modules/@standard-schema/spec/dist/index.d.ts
+/** The Standard Typed interface. This is a base type extended by other specs. */
+interface StandardTypedV1<Input = unknown, Output = Input> {
+  /** The Standard properties. */
+  readonly "~standard": StandardTypedV1.Props<Input, Output>;
+}
+declare namespace StandardTypedV1 {
+  /** The Standard Typed properties interface. */
+  interface Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  /** The Standard Typed types interface. */
+  interface Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+  }
+  /** Infers the input type of a Standard Typed. */
+  type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+  /** Infers the output type of a Standard Typed. */
+  type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+/** The Standard Schema interface. */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard Schema properties. */
+  readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+  /** The Standard Schema properties interface. */
+  interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+    /** Validates unknown input values. */
+    readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
+  }
+  /** The result interface of the validate function. */
+  type Result<Output> = SuccessResult<Output> | FailureResult;
+  /** The result interface if validation succeeds. */
+  interface SuccessResult<Output> {
+    /** The typed output value. */
+    readonly value: Output;
+    /** A falsy value for `issues` indicates success. */
+    readonly issues?: undefined;
+  }
+  interface Options {
+    /** Explicit support for additional vendor-specific parameters, if needed. */
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+  }
+  /** The result interface if validation fails. */
+  interface FailureResult {
+    /** The issues of failed validation. */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  /** The issue interface of the failure output. */
+  interface Issue {
+    /** The error message of the issue. */
+    readonly message: string;
+    /** The path of the issue, if any. */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+  /** The path segment interface of the issue. */
+  interface PathSegment {
+    /** The key representing a path segment. */
+    readonly key: PropertyKey;
+  }
+  /** The Standard types interface. */
+  interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
+  /** Infers the input type of a Standard. */
+  type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+  /** Infers the output type of a Standard. */
+  type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@deepseek-ai+schemastery@3.18.4/node_modules/@deepseek-ai/schemastery/lib/types/index.d.ts
+declare const kSchema: unique symbol;
+declare global {
+  namespace Schemastery {
+    /** Convert primitive constructors, constants, and existing schemas into a schema type. */
+    type From<X> = X extends string | number | boolean ? Schema<X> : X extends Schema<any, any, SchemaMode> ? X : X extends typeof String ? Schema<string> : X extends typeof Number ? Schema<number> : X extends typeof Boolean ? Schema<boolean> : X extends typeof Function ? Schema<Function, (...args: any[]) => any> : X extends Constructor<infer S> ? Schema<S> : never;
+    type TypeS1<X> = X extends Schema<infer S, infer _T, infer _M> ? S : never;
+    type Inverse<X> = X extends Schema<infer _S, infer T, infer M> ? (arg: SchemaOutput<T, M>) => void : never;
+    /** Input type accepted by a schema-like value. */
+    type TypeS<X> = TypeS1<From<X>>;
+    /** Output type returned by a schema-like value after validation. */
+    type TypeT<X> = ReturnType<From<X>>;
+    /** Resolver callback used by custom schema types registered with `Schema.extend()`. */
+    type Resolve = (data: any, schema: Schema, options: Options, strict?: boolean) => [any, any?];
+    /** Input type accepted by one schema in an intersection. */
+    type IntersectS<X> = From<X> extends Schema<infer S, infer _T, infer _M> ? S : never;
+    /** Output type returned by one schema in an intersection. */
+    type IntersectT<X> = Inverse<From<X>> extends ((arg: infer T) => void) ? T : never;
+    type TupleS<X extends readonly any[]> = X extends readonly [infer L, ...infer R] ? [TypeS<L>?, ...TupleS<R>] : any[];
+    type TupleT<X extends readonly any[]> = X extends readonly [infer L, ...infer R] ? [TypeT<L>?, ...TupleT<R>] : any[];
+    type ObjectS<X extends Dict> = { [K in keyof X]?: TypeS<X[K]> | null; } & Dict;
+    type ObjectT<X extends Dict> = { [K in keyof X]: TypeT<X[K]>; } & Dict;
+    type Constructor<T = any> = new (...args: any[]) => T;
+    /** Static constructor and factory methods exposed by the default `Schema` export. */
+    interface Static {
+      <T = any>(options: Partial<Schema<T>>): Schema<T>;
+      new <T = any>(options: Partial<Schema<T>>): Schema<T>;
+      prototype: Schema;
+      /** Validate a value against a schema node and return `[output, adaptedInput?]`. */
+      resolve: Resolve;
+      /** Infer a schema from a primitive value, constructor, or existing schema. */
+      from<X = any>(source?: X): From<X>;
+      /** Register a resolver for a custom schema `type`. */
+      extend(type: string, resolve: Resolve): void;
+      /** Accept any value without validation. */
+      any<T = any>(): Schema<T>;
+      /** Accept only nullable input. */
+      never(): Schema<never>;
+      /** Accept exactly one constant value. */
+      const<const T>(value: T): Schema<T>;
+      /** Accept strings, with optional metadata constraints added by instance methods. */
+      string(): Schema<string>;
+      /** Accept numbers, with optional range and step constraints. */
+      number(): Schema<number>;
+      /** Accept non-negative integer numbers. */
+      natural(): Schema<number>;
+      /** Accept a number between 0 and 1 and mark it as a slider. */
+      percent(): Schema<number>;
+      /** Accept booleans. */
+      boolean(): Schema<boolean>;
+      /** Accept `Date` instances or parse datetime strings into `Date` objects. */
+      date(): Schema<string | Date, Date>;
+      /** Accept `RegExp` instances or parse strings into regular expressions. */
+      regExp(flag?: string): Schema<string | RegExp, RegExp>;
+      /** Accept binary sources and normalize them to `ArrayBufferLike`. */
+      arrayBuffer(): Schema<Binary.Source, ArrayBufferLike>;
+      arrayBuffer(encoding: 'hex' | 'base64'): Schema<Binary.Source | string, ArrayBufferLike>;
+      /** Accept a numeric bitset or string keys and normalize to a number. */
+      bitset<K extends string>(bits: Partial<Record<K, number>>): Schema<number | readonly K[], number>;
+      /** Accept functions. */
+      function(): Schema<Function, (...args: any[]) => any>;
+      /** Accept instances of a constructor or objects whose constructor name matches. */
+      is(constructor: string): Schema;
+      is<T>(constructor: Constructor<T>): Schema<T>;
+      /** Accept arrays whose elements match `inner`. */
+      array<X>(inner: X): Schema<TypeS<X>[], TypeT<X>[]>;
+      /** Accept plain objects with values matching `inner` and optional key schema. */
+      dict<X, Y extends Schema<any, string> = Schema<string>>(inner: X, sKey?: Y): Schema<Dict<TypeS<X>, TypeS<Y>>, Dict<TypeT<X>, TypeT<Y>>>;
+      /** Accept tuple arrays where each index matches the corresponding schema. */
+      tuple<const X extends readonly any[]>(list: X): Schema<TupleS<X>, TupleT<X>>;
+      /** Accept plain objects; infer fields from the dictionary, not the enclosing schema's output type. */
+      object<X extends Dict>(dict: X): Schema<ObjectS<NoInfer<X>>, ObjectT<NoInfer<X>>>;
+      /** Accept values matching at least one schema in `list`. */
+      union<const X>(list: readonly X[]): Schema<TypeS<X>, TypeT<X>>;
+      /** Accept values matching every schema in `list`, merging object outputs. */
+      intersect<const X>(list: readonly X[]): Schema<IntersectS<X>, IntersectT<X>>;
+      /** Validate with `inner`, then convert the result with `callback`. */
+      transform<X, T>(inner: X, callback: (value: TypeS<X>, options: Schemastery.Options) => T, preserve?: boolean): Schema<TypeS<X>, T>;
+      /** Defer construction of a recursive schema until validation or serialization. */
+      lazy<X extends Schema<any, any, SchemaMode>>(callback: () => X): X;
+      ValidationError: typeof ValidationError;
+    }
+    /** Runtime validation options shared by all schema calls. */
+    interface Options {
+      /** Remove invalid object properties instead of throwing when possible. */
+      autofix?: boolean;
+      /** Skip validation for selected values and schema nodes. */
+      ignore?(data: any, schema: Schema): boolean;
+      /** Path used to format nested validation errors. */
+      path?: (keyof any)[];
+    }
+    /** UI and validation metadata attached by schema builder methods. */
+    interface Meta<T = any> {
+      default?: T extends {} ? Partial<T> : T;
+      required?: boolean;
+      /** Parse this node as a stable config reference; its type and UI metadata remain unchanged. */
+      volatile?: boolean;
+      disabled?: boolean;
+      collapse?: boolean;
+      badges?: {
+        text: string;
+        type: string;
+      }[];
+      hidden?: boolean;
+      loose?: boolean;
+      role?: string;
+      extra?: any;
+      link?: string;
+      description?: string | Dict<string>;
+      comment?: string;
+      pattern?: {
+        source: string;
+        flags?: string;
+      };
+      max?: number;
+      min?: number;
+      step?: number;
+    }
+  }
+  /** Callable schema instance that validates input and returns normalized output. */
+  interface Schemastery<S = any, T = S, Mode extends SchemaMode = 'plain'> {
+    (data?: S | null, options?: Schemastery.Options): SchemaOutput<T, Mode>;
+    new (data?: S | null, options?: Schemastery.Options): SchemaOutput<T, Mode>;
+    [kSchema]: true;
+    uid: number;
+    meta: Schemastery.Meta<T>;
+    type: string;
+    sKey?: Schema;
+    inner?: Schema;
+    list?: Schema[];
+    dict?: Dict<Schema>;
+    bits?: Dict<number>;
+    callback?: Function;
+    constructor?: string | Function;
+    builder?: Function;
+    value?: T;
+    refs?: Dict<Schema>;
+    preserve?: boolean;
+    '~standard': StandardSchemaV1.Props;
+    /** Format this schema as a compact TypeScript-like type string. */
+    toString(inline?: boolean): string;
+    /** Serialize this schema, preserving shared and recursive references. */
+    toJSON(): Schema<S, T, Mode>;
+    /** Mark nullable input as invalid unless a default supplies a fallback. */
+    required<R extends boolean = true>(value?: R): Schema<S, T, SetRequired<Mode, R>>;
+    /**
+     * Parse this config field as a stable reference containing immutable data.
+     * @returns a schema whose output supports get(), including when the field is absent.
+     */
+    volatile(): Schema<NoInfer<S>, NoInfer<T>, Mode extends 'defined' | 'volatile-defined' ? 'volatile-defined' : 'volatile'>;
+    /** Hide this schema node from UI renderers. */
+    hidden(value?: boolean): Schema<S, T, Mode>;
+    /** Return the default value instead of throwing when validation fails. */
+    loose(value?: boolean): Schema<S, T, Mode>;
+    /** Attach a renderer role and optional role-specific metadata. */
+    role(text: string, extra?: any): Schema<S, T, Mode>;
+    /** Attach an external documentation link. */
+    link(link: string): Schema<S, T, Mode>;
+    /** Set the fallback value used for nullable input. */
+    default(value: T | NoInfer<Partial<S>>): Schema<S, T, SetRequired<Mode, true>>;
+    /** Attach an auxiliary comment for documentation or form UIs. */
+    comment(text: string): Schema<S, T, Mode>;
+    /** Attach a localized or plain description for documentation or form UIs. */
+    description(text: string): Schema<S, T, Mode>;
+    /** Mark this schema node as disabled for form UIs. */
+    disabled(value?: boolean): Schema<S, T, Mode>;
+    /** Request collapsed rendering for nested form UIs. */
+    collapse(value?: boolean): Schema<S, T, Mode>;
+    /** Add a deprecated badge to this schema node. */
+    deprecated(): Schema<S, T, Mode>;
+    /** Add an experimental badge to this schema node. */
+    experimental(): Schema<S, T, Mode>;
+    /** Require strings to match a regular expression. */
+    pattern(regexp: RegExp): Schema<S, T, Mode>;
+    /** Set an inclusive maximum for numbers or collection lengths. */
+    max(value: number): Schema<S, T, Mode>;
+    /** Set an inclusive minimum for numbers or collection lengths. */
+    min(value: number): Schema<S, T, Mode>;
+    /** Set the numeric increment constraint. */
+    step(value: number): Schema<S, T, Mode>;
+    /** Add or replace an object property schema. */
+    set(key: string, value: Schema): Schema<S, T, Mode>;
+    /** Append a tuple, union, or intersection member schema. */
+    push(value: Schema): Schema<S, T, Mode>;
+    /** Remove values equal to schema defaults from normalized output. */
+    simplify(value?: any): any;
+    /** Return a schema clone with descriptions merged from locale messages. */
+    i18n(messages: Dict): Schema<S, T, Mode>;
+    /** Attach arbitrary metadata consumed by form renderers and downstream tools. */
+    extra<K extends keyof Schemastery.Meta>(key: K, value: Schemastery.Meta[K]): Schema<S, T, Mode>;
+  }
+}
+declare class ValidationError extends TypeError {
+  options: Schemastery.Options;
+  name: string;
+  constructor(message: string, options: Schemastery.Options);
+  static is(error: any): error is ValidationError;
+}
+type SchemaMode = 'plain' | 'defined' | 'volatile' | 'volatile-defined';
+type SchemaOutput<T, M extends SchemaMode> = M extends 'volatile' ? Volatile<T | undefined> : M extends 'volatile-defined' ? Volatile<T> : T;
+type SetRequired<M extends SchemaMode, R extends boolean> = M extends 'volatile' | 'volatile-defined' ? R extends true ? 'volatile-defined' : 'volatile' : R extends true ? 'defined' : 'plain';
+type Schema<S = any, T = S, Mode extends SchemaMode = 'plain'> = Schemastery<S, T, Mode>;
+declare const Schema: Schemastery.Static;
+//#endregion
+//#region src/config.d.ts
+/** Host-side artifact-app settings. */
+interface Config$1 {
+  /** DataOps API origin, e.g. `http://host.docker.internal:3101`. */
+  baseUrl: string;
+  /** Browser-reachable DataOps frontend origin; empty derives it from the request. */
+  webBaseUrl: string;
+  /** Credential reference holding the workspace's DataOps JWT. */
+  credentialRef: string;
+  /** Maximum accepted cockpit HTML size. */
+  htmlMaxBytes: number;
+  /** Inject ECharts with the runtime; false only for tests. */
+  injectRuntime: boolean;
+  /** Root the `html_path` tool arguments resolve against. */
+  workspaceRoot: string;
+  /** Upstream timeout for one DataOps call. */
+  requestTimeoutMs: number;
+}
+/** Schemastery parser for the artifact-app config. */
+declare const Config$1: Schema<Config$1>;
+//#endregion
+//#region src/api.d.ts
+/**
+ * DataOps artifact API client.
+ *
+ * Every call carries the workspace credential; the browser never sees it. Errors
+ * keep the server's own `message` so a tool result explains what DataOps said
+ * instead of a generic "request failed".
+ *
+ * @module api
+ */
+/** Minimal credential surface this client needs. */
+interface TokenSource {
+  resolve(): Promise<string | undefined>;
+}
+/** One artifact row as the list endpoint returns it. */
+interface ArtifactAppRow {
+  id: string;
+  name: string;
+  description?: string | null;
+  catalog?: string | null;
+  status: string;
+  currentVersion: number;
+  publishedVersion: number;
+  refreshIntervalSeconds?: number;
+  keepConnection?: boolean;
+  updatedAt: string;
+  canManage?: boolean;
+}
+/** One template row from `/api/artifact-templates`. */
+interface ArtifactTemplateRow {
+  id: string;
+  name: string;
+  description?: string | null;
+  catalog?: string | null;
+  appType?: string;
+  status?: string;
+  currentVersion?: number;
+  contract?: {
+    slots?: string[];
+    question?: string;
+  } | null;
+  updatedAt?: string;
+}
+/** Publish request body. */
+interface PublishInput {
+  artifactId?: string;
+  name?: string;
+  description?: string;
+  catalog?: string;
+  html?: string;
+  templateId?: string;
+  templateVersion?: string;
+}
+/** Preview request body. */
+interface PreviewInput extends PublishInput {
+  html: string;
+  baseVersion?: number;
+}
+/** Grants payload. */
+interface GrantInput {
+  principalType: 'USER' | 'ROLE' | 'DEPARTMENT';
+  principalId: string;
+  action: 'READ' | 'MANAGE';
+}
+/** Server error carrying the DataOps status. */
+declare class DataOpsError extends Error {
+  readonly status: number;
+  constructor(message: string, status: number);
+}
+/** Client for the DataOps artifact endpoints. */
+declare class ArtifactApi {
+  private readonly baseUrl;
+  private readonly tokens;
+  private readonly timeoutMs;
+  constructor(baseUrl: string, tokens: TokenSource, timeoutMs: number);
+  /** Read the workspace token or explain why the call cannot run. */
+  token(): Promise<string>;
+  private request;
+  /** Read the current DataOps principal and roles. */
+  me(): Promise<{
+    user?: {
+      roles?: Array<{
+        code?: string;
+        name?: string;
+      }>;
+    };
+  }>;
+  /** List published cockpit templates. */
+  listTemplates(): Promise<ArtifactTemplateRow[]>;
+  /** Read one template's metadata and contract. */
+  getTemplate(id: string): Promise<ArtifactTemplateRow>;
+  /** Read one template's HTML. */
+  getTemplateHtml(id: string): Promise<{
+    id: string;
+    version: number;
+    html: string;
+  }>;
+  /** List visible cockpit apps. */
+  listApps(query?: {
+    q?: string;
+    catalog?: string;
+    status?: string;
+    page?: number;
+    pageSize?: number;
+  }): Promise<{
+    items: ArtifactAppRow[];
+    total: number;
+    page: number;
+    pageSize: number;
+  }>;
+  /** Catalog counts for the tab's folder filter. */
+  catalogs(): Promise<Array<{
+    catalog: string | null;
+    count: number;
+  }>>;
+  /** Read one app's metadata. */
+  getApp(id: string): Promise<ArtifactAppRow>;
+  /** Read one app's HTML (current for managers, published for viewers). */
+  getAppHtml(id: string, version?: number): Promise<{
+    id: string;
+    version: number;
+    html: string;
+  }>;
+  /** Patch metadata only. */
+  patchApp(id: string, patch: {
+    name?: string;
+    description?: string;
+    catalog?: string;
+    refreshIntervalSeconds?: number;
+    keepConnection?: boolean;
+  }): Promise<unknown>;
+  /** Soft-delete one app. */
+  deleteApp(id: string): Promise<{
+    success: boolean;
+  }>;
+  /** Read one app's grants. */
+  getGrants(id: string): Promise<{
+    ownerId: string;
+    grants: GrantInput[];
+  }>;
+  /** Replace one app's grants. */
+  putGrants(id: string, grants: GrantInput[]): Promise<{
+    ownerId: string;
+    grants: GrantInput[];
+  }>;
+  /** Create or update a draft without publishing. */
+  preview(input: PreviewInput): Promise<{
+    id: string;
+    version: number;
+    created: boolean;
+  }>;
+  /** Publish a new app or a new version of an existing one. */
+  publish(input: PublishInput): Promise<{
+    id: string;
+    version: number;
+    publishedVersion: number;
+    created: boolean;
+  }>;
+  /** Public runtime script served by DataOps. */
+  runtimeScript(): Promise<string>;
+  /** Public ECharts bundle served by DataOps. */
+  echartsScript(): Promise<string>;
+  /** Proxy one gateway call with the caller's own Authorization header. */
+  /**
+   * 批量解析素材逻辑名 → 可用 URL。
+   *
+   * 渲染时把 HTML 里的 `asset://<逻辑名>` 换成这里的地址；解析不到的名字保持原样，
+   * 由页面自己降级（不阻断渲染）。
+   * @param names - 逻辑名列表。
+   * @param scope - shared 或 template（默认 template，ownerId 为模板 id）。
+   * @param ownerId - 模板 id。
+   */
+  /**
+   * 发布模板包：把打包好的 zip 交给后端解压、校验、落素材并建模板版本。
+   * @param zipBase64 - zip 的 base64。
+   * @returns 模板 id 与版本。
+   */
+  publishTemplatePackage(zipBase64: string): Promise<{
+    templateId: string;
+    version: number;
+    assets: number;
+  }>;
+  resolveAssets(names: string[], scope: 'shared' | 'template', ownerId?: string): Promise<Record<string, string>>;
+  gateway(path: string, init: RequestInit, authorization: string | undefined): Promise<{
+    status: number;
+    body: string;
+    contentType: string;
+  }>;
+}
+//#endregion
+//#region src/open-hub.d.ts
+/** SSE route the client subscribes to. */
+declare const OPEN_EVENTS_PATH = "/dsh-artifact-app/open/events";
+/** Same-origin route the client uses to read render and gateway addresses. */
+declare const CONFIG_PATH = "/dsh-artifact-app/config";
+/** Same-origin route the client uses to read the workspace token for postMessage. */
+declare const TOKEN_PATH = "/dsh-artifact-app/token";
+/** Same-origin app-list proxy used by the sidebar tab. */
+declare const APPS_PATH = "/dsh-artifact-app/apps";
+/** Same-origin preview creation used by the HTML file viewer. */
+declare const PREVIEW_PATH = "/dsh-artifact-app/preview";
+/** Render route prefix; `:id` follows it. */
+declare const RENDER_PATH = "/dsh-artifact-app/render";
+/** Gateway prefix the sandboxed cockpit HTML may call. */
+declare const GATEWAY_PATH = "/dsh-artifact-app/gateway";
+/** Tab type registered by the client half. */
+declare const ARTIFACT_TAB_TYPE = "dataops-artifact-apps";
+/** One navigation request delivered to every connected client. */
+interface OpenCockpitEvent {
+  type: 'open_cockpit';
+  requestId: string;
+  cockpitId: string;
+  cockpitName: string | null;
+  mode: 'focus' | 'detail';
+  nonce: string;
+}
+/** One refresh request for an already-open viewer. */
+interface CockpitUpdatedEvent {
+  type: 'cockpit_updated';
+  cockpitId: string;
+  nonce: string;
+}
+/** Minimal logger surface used by the hub. */
+interface HubLogger {
+  warn(message: string): void;
+}
+/** Fan-out registry for the workspace's live SSE subscribers. */
+declare class OpenCockpitHub {
+  private readonly logger;
+  private readonly clients;
+  private heartbeat;
+  constructor(logger: HubLogger);
+  /** Accept one SSE subscription and own its response until the client disconnects. */
+  subscribe(request: IncomingMessage, response: ServerResponse): void;
+  /** Send one navigation event to every connected client. */
+  broadcastOpen(event: Omit<OpenCockpitEvent, 'type' | 'requestId'> & {
+    requestId?: string;
+  }): OpenCockpitEvent;
+  /** Ask open viewers of one cockpit to reload it. */
+  broadcastUpdated(event: Omit<CockpitUpdatedEvent, 'type'>): CockpitUpdatedEvent;
+  /** Number of live subscribers, used by a tool result to explain a missing browser. */
+  size(): number;
+  /** Close every subscriber; called by the plugin disposer. */
+  dispose(): void;
+  private write;
+  private ensureHeartbeat;
+}
+//#endregion
+//#region src/templates.d.ts
+/**
+ * Cockpit HTML contract, validation and runtime injection.
+ *
+ * The HTML is untrusted content rendered in an opaque-origin iframe. The plugin
+ * never "sanitizes" it; instead it refuses files that cannot be rendered safely
+ * (missing SDK markers or external resources) and injects the SDK, ECharts and a
+ * small theme reset before the bytes leave the host.
+ *
+ * @module templates
+ */
+/** One failed contract check. */
+declare class TemplateContractError extends Error {
+  readonly missing: string[];
+  readonly code = "TEMPLATE_CONTRACT_MISSING";
+  constructor(missing: string[]);
+}
+/**
+ * Validate one cockpit HTML document against the template contract.
+ * @param html - document bytes as text.
+ * @param maxBytes - configured size ceiling.
+ * @throws TemplateContractError when a required marker is missing or an external resource is present.
+ * @throws Error when the document is too large.
+ */
+declare function assertCockpitHtml(html: string, maxBytes: number): void;
+/**
+ * Inject the theme reset, ECharts and the artifact runtime into a cockpit document.
+ * @param html - validated document.
+ * @param options - runtime sources; `echartsJs` is omitted when ECharts injection is off.
+ * @returns the document the render route serves.
+ */
+declare function injectCockpitRuntime(html: string, options: {
+  runtimeJs: string;
+  echartsJs?: string;
+}): string;
+/**
+ * Build the CSP header for a rendered cockpit.
+ * @param origin - the DSH origin the sandboxed page may call for gateway traffic.
+ * @returns the header value.
+ */
+declare function cockpitCsp(origin: string): string;
+//#endregion
+//#region src/index.d.ts
+declare const Config: Schema<Config$1>;
+type Config = Config$1;
+/** Cordis plugin name. */
+declare const name = "artifact-app";
+/** Host services this plugin needs. */
+declare const inject: string[];
+/**
+ * Register the host routes, the model tools and the authoring skill.
+ * @param ctx - DSH host context with web routes, tools, approval and credentials.
+ * @param config - DataOps origin, credential ref and HTML limits.
+ */
+declare function apply(ctx: Context, config: Config$1): void;
+//#endregion
+export { APPS_PATH, ARTIFACT_TAB_TYPE, ArtifactApi, ArtifactAppRow, ArtifactTemplateRow, CONFIG_PATH, CockpitUpdatedEvent, Config, DataOpsError, GATEWAY_PATH, GrantInput, OPEN_EVENTS_PATH, OpenCockpitEvent, OpenCockpitHub, PREVIEW_PATH, PreviewInput, PublishInput, RENDER_PATH, TOKEN_PATH, TemplateContractError, TokenSource, apply, assertCockpitHtml, cockpitCsp, inject, injectCockpitRuntime, name };