@thatopen/services 0.18.0 → 0.20.0

package/README.md

@@ -32,6 +32,10 @@ To use beta engine libraries instead of the stable ones, see:
 
 Once scaffolded, open `AGENTS.md` in the scaffolded project root — it has everything needed to start building.
 
+Reading this repository without a scaffolded project (as a person or an AI agent)? The same
+guide lives here: [`resources/AGENTS.md`](./resources/AGENTS.md), alongside
+[`docs/ai-quickstart.md`](./docs/ai-quickstart.md) for the zero-to-running-app path.
+
 ## Beta engine libraries (Founding Members)
 
 Founding Members get early access to the private beta engine libraries (`@thatopen-platform/*-beta`). The CLI configures access automatically — no npm account or manual token needed.

package/dist/built-in/index.d.ts

@@ -1650,6 +1650,64 @@ declare class _GISManager extends OBC.Component {
     private _tilesOpacity;
     private _fadeTarget;
     private _fadeQuad;
+    private _horizonTarget;
+    private _horizonQuad;
+    /**
+     * Fraction (0–1) of the camera's far distance over which the 3D tiles dissolve
+     * into what is behind them, instead of ending in a hard edge at the far plane:
+     * the tiles are fully visible up to `far * (1 - horizonFade)` and fully
+     * transparent at `far`. Default 0.8. `0` turns it off (opaque tiles are drawn
+     * straight into the frame at opacity 1, as before). Combines with
+     * `setTilesOpacity`: final alpha = opacity × fade. Deferred hosts only — where
+     * the tiles are added to the scene directly there is no fade. Vector layers
+     * are not faded.
+     */
+    horizonFade: number;
+    private readonly _far;
+    private _farCameras;
+    /**
+     * Far plane (distance) the world's cameras get while the 3D tiles are loaded, so
+     * the map reaches the horizon. Default `10000`. Changing it while the map is
+     * loaded takes effect immediately. `horizonFade` is a fraction of this far while
+     * the map is loaded (with `0.8`, the map fades from 2 km to 10 km).
+     *
+     * The camera's own far plane (e.g. the Settings panel's "Far plane") is
+     * overridden while the map is loaded: it is remembered, not applied, and comes
+     * back when the map is unloaded. Code that grows the far plane itself while the
+     * map is loaded still works: a larger far than `mapFar` is left alone, and is
+     * kept on unload.
+     */
+    get mapFar(): number;
+    set mapFar(far: number);
+    /** True while the map owns the cameras' far plane (the 3D tiles are loaded). */
+    get farOverridden(): boolean;
+    /** The far plane the user asked for, remembered while `farOverridden` (otherwise the cameras hold it). */
+    get userCameraFar(): number;
+    /** Records the far plane the user wants; not applied until the map is unloaded. Only meaningful while `farOverridden`. */
+    setUserCameraFar(far: number): void;
+    private _resolveFarCameras;
+    /**
+     * Shows a sky gradient behind everything while the 3D tiles are loaded: the
+     * empty background (pixels nothing has drawn to) goes from `skyHorizonColor` at
+     * the horizon to `skyZenithColor` straight up, so the tiles, dissolving with
+     * `horizonFade`, melt into the horizon colour. Below the horizon it is the
+     * horizon colour; an orthographic camera sees one flat colour. Default `true`;
+     * `false` leaves the background untouched. Deferred hosts only — elsewhere
+     * there is no sky. Drawn behind the vector layers and the tiles.
+     */
+    sky: boolean;
+    private readonly _skyHorizon;
+    private readonly _skyZenith;
+    private _skyHorizonColor;
+    private _skyZenithColor;
+    private _skyPass;
+    private static _setSkyRgb;
+    /** Sky colour at the horizon (any CSS colour string, hex number or `THREE.Color`). Default `"#d7e3ee"`, a light hazy blue. */
+    get skyHorizonColor(): THREE.ColorRepresentation;
+    set skyHorizonColor(color: THREE.ColorRepresentation);
+    /** Sky colour straight up. Default `"#6a9bd1"`, a deeper blue. */
+    get skyZenithColor(): THREE.ColorRepresentation;
+    set skyZenithColor(color: THREE.ColorRepresentation);
     private _passRegistered;
     private _ensureOcclusionPass;
     private readonly _occlusion;

package/dist/cli/commands/mcp.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+
+export declare const mcpCommand: Command;

package/dist/cli/lib/cli-client.d.ts

@@ -0,0 +1,13 @@
+import { EngineServicesClient } from '../../core/client';
+
+/**
+ * The one way the CLI builds a client.
+ *
+ * Every CLI client sends its platform token as `Authorization: Bearer`
+ * instead of `?accessToken=`. The CLI holds long-lived API tokens, and the
+ * query form reproduces them in proxy logs, error bodies and anything a user
+ * pastes while asking for help. Requires a backend that accepts bearer
+ * platform tokens (deployed 2026-10); older backends answer 401, in which
+ * case upgrading the platform comes first, not flipping this off.
+ */
+export declare function cliClient(accessToken: string, apiUrl: string): EngineServicesClient;

package/dist/cli/lib/config.d.ts

@@ -15,6 +15,8 @@ export interface ThatOpenLocalConfig {
     itemType?: ProjectType;
     /** Path to an icon file (PNG, WebP, or ICO) uploaded on publish. */
     iconPath?: string;
+    /** Project the first publish lands the app/component in (see `--project-id`). */
+    projectId?: string;
     /** Whether this project uses beta engine libraries (@thatopen-platform/*-beta). */
     beta?: boolean;
 }

package/dist/cli/lib/zip.test.d.ts

@@ -0,0 +1 @@
+export {};