@phreshos/server 0.1.11 → 0.1.13

package/README.md

@@ -124,11 +124,9 @@ on `host`:
 const programs = await host.program.list()
 const program = await host.program.find("counter")
 const processes = await host.process.list()
-const serviceKeys = await host.service.list()
 
 const stopPrograms = host.program.subscribe("create", value => undefined)
 const stopProcesses = host.process.subscribe("exit", value => undefined)
-const stopServices = host.service.subscribe("enable", key => undefined)
 ```
 
 A Program owns its scoped Process capability:
@@ -137,12 +135,44 @@ A Program owns its scoped Process capability:
 const processes = await program.process.list()
 const process = await program.process.find("worker")
 const created = await program.process.create({ name: "worker" })
+const shared = await program.process.findOrCreate({
+  name: "shared-server",
+  server: true,
+  client: false
+})
 ```
 
-`host.service.prepare(key)` creates the exact opaque service handle. The
+`findOrCreate()` is atomic at the authoritative Core. Concurrent equivalent
+launches converge on one named Process; a different launch for that name
+rejects instead of reconfiguring the existing Process.
+
+`host.service(key)` creates the exact opaque service handle. The
 handler exposes its authored `name`, `enabled()`, `waitReady()`, lifecycle
 subscriptions, and channel; it does not expose its Program or Endpoint as
-separate fields.
+separate fields. Services are not a second public registry: inspect Programs
+and their Endpoint declarations. `program.server?.hasService()` identifies a
+declared Service capability, while `await program.server?.docs()` reads its
+installed policy and API documentation before the Endpoint starts.
+
+Server-side Service handles can create their dedicated providing Process and
+wait for readiness without reproducing Program-specific launch rules:
+
+```ts
+await serverService.createAndWaitReady()
+await clientService.createAndWaitReady({ minimize: true })
+```
+
+Both readiness operations accept an optional timeout directly and expose an
+immutable timed view. A direct argument on the timed view takes precedence:
+
+```ts
+await service.waitReady(10_000)
+await service.timeout(5_000).waitReady()
+await service.timeout(5_000).waitReady(10_000)
+```
+
+The System owns the single deadline across Process creation, Endpoint startup,
+and Service readiness. The creation capability exists only in the Server SDK.
 
 `program.icon()` requests a guaranteed PNG `Blob` in `small`, `medium`, or
 `large` form without exposing the Program's source path or the system's private

package/dist/channel.d.ts

@@ -1,9 +1,9 @@
-import type { Channel as CoreChannel, ChannelMessage, Cleanup, ServerServiceDefinition } from "@phreshos/core";
+import type { Channel as CoreChannel, ChannelMessage, Cleanup } from "@phreshos/core";
 import { type Endpoint } from "./domain.js";
 /** Handles one question addressed to the current Server. */
 export type Answerer<Payload = unknown, Result = undefined> = (message: ChannelMessage<Payload>) => Result | Promise<Result>;
 /** Events and questions explicitly accepted by the current Server. */
-export interface Channel<Events extends object = {}> extends CoreChannel<Events, Endpoint, ServerServiceDefinition> {
+export interface Channel<Events extends object = {}> extends CoreChannel<Events, Endpoint> {
     /** Registers one answerer; omitting its return produces `undefined`. */
     answer<Payload = unknown, Result = undefined>(event: string, answerer: Answerer<Payload, Result>): Cleanup;
 }

package/dist/channel.js

@@ -12,7 +12,7 @@ class ServerChannel extends Events {
     publish(event, payload = undefined) {
         wire.send("end-host", "emit", event, payload);
     }
-    async enableService(definition) { await enableCurrentService(definition); }
+    async enableService(name) { await enableCurrentService(name); }
     async disableService() { await disableCurrentService(); }
     answer(event, answerer) {
         return wire.answer("end-end", event, value => answerer(message(value)));

package/dist/domain.d.ts

@@ -1,6 +1,7 @@
-import { Client as CoreClient, Endpoint as CoreEndpoint, Process as CoreProcess, Program as CoreProgram, Server as CoreServer, type AnswerCapture, type AskCapture, type Cleanup, type ClientDeclaration, type EndpointDeclaration, type Exit, type Launch, type ProgramPermission, type ProgramProcess as CoreProgramProcess, type ProgramArea as CoreProgramArea, type TrafficMessage, type Window as CoreWindow, type WindowState } from "@phreshos/core";
+import { Client as CoreClient, Endpoint as CoreEndpoint, Process as CoreProcess, Program as CoreProgram, Server as CoreServer, type AnswerCapture, type AskCapture, type Cleanup, type ClientDeclaration, type Exit, type Launch, type Position, type ProgramPermission, type ProgramProcess as CoreProgramProcess, type ProgramArea as CoreProgramArea, type Size, type TrafficMessage, type Window as CoreWindow, type WindowState } from "@phreshos/core";
 import Events from "./events.js";
 import { type ProgramStartup } from "./startup.js";
+import { type ClientServiceHandler, type ServerServiceHandler } from "./service.js";
 export interface HandleAddress {
     identity: string;
     reference: string;
@@ -13,6 +14,17 @@ export interface ProgramArea extends CoreProgramArea {
     resolve(...path: string[]): Promise<string>;
 }
 /** Client-safe Program data transported by the authoritative host. */
+export interface EndpointDeclarationRecord {
+    start: boolean;
+    hasService: boolean;
+}
+export interface ClientDeclarationRecord extends EndpointDeclarationRecord {
+    title: string | null;
+    size: Size | null;
+    position: Position | null;
+    layer: ClientDeclaration["layer"];
+    minimize: boolean | null;
+}
 export interface ProgramRecord {
     reference: string;
     identity: string;
@@ -20,8 +32,8 @@ export interface ProgramRecord {
     name: string;
     version: string | null;
     description: string | null;
-    server: EndpointDeclaration | null;
-    client: ClientDeclaration | null;
+    server: EndpointDeclarationRecord | null;
+    client: ClientDeclarationRecord | null;
 }
 /** Process data transported with every Endpoint reference. */
 export interface ProcessRecord {
@@ -57,7 +69,7 @@ export interface Program<Events extends object = {}> extends Omit<CoreProgram<Ev
     fork(identity: string): Promise<Program>;
 }
 /** Server-visible Process operations scoped to one Program. */
-export interface ProgramProcess extends Omit<CoreProgramProcess, "list" | "first" | "last" | "find" | "create"> {
+export interface ProgramProcess extends Omit<CoreProgramProcess, "list" | "first" | "last" | "find" | "create" | "findOrCreate"> {
     /** Returns every live Process of this Program. */
     list(): Promise<Process[]>;
     /** Returns the earliest-started live Process, or `null` when none exist. */
@@ -68,6 +80,10 @@ export interface ProgramProcess extends Omit<CoreProgramProcess, "list" | "first
     find(identityOrName: string): Promise<Process | null>;
     /** Creates one Process of this Program. */
     create(launch?: Launch): Promise<Process>;
+    /** Finds the named Process or atomically creates it with the same resolved launch. */
+    findOrCreate(launch: Launch & Readonly<{
+        name: string;
+    }>): Promise<Process>;
 }
 /** Server-visible Process handle. */
 export interface Process<Events extends object = {}> extends CoreProcess<Events> {
@@ -89,6 +105,8 @@ export interface Endpoint<Events extends object = {}> extends CoreEndpoint<Event
 export interface Server<Events extends object = {}> extends CoreServer<Events> {
     /** Returns the Process that owns this Server. */
     process(): Promise<Process>;
+    /** Returns the Service currently exposed by this Server Endpoint. */
+    service<ServiceEvents extends object = {}>(): Promise<ServerServiceHandler<ServiceEvents> | null>;
 }
 /** Server-visible Client handle. */
 export interface Client<Events extends object = {}> extends CoreClient<Events> {
@@ -96,6 +114,8 @@ export interface Client<Events extends object = {}> extends CoreClient<Events> {
     readonly window: Window;
     /** Returns the Process that owns this Client. */
     process(): Promise<Process>;
+    /** Returns the Service currently exposed by this Client Endpoint. */
+    service<ServiceEvents extends object = {}>(): Promise<ClientServiceHandler<ServiceEvents> | null>;
 }
 /** Server-visible Client-owned Window capability. */
 export type Window = CoreWindow;

package/dist/domain.js

@@ -43,8 +43,12 @@ class ProgramHandle extends ProgramBase {
     get name() { return this.record.name; }
     get version() { return this.record.version; }
     get description() { return this.record.description; }
-    get server() { return this.record.server; }
-    get client() { return this.record.client; }
+    get server() {
+        return this.record.server ? declaration(this.address, "server", this.record.server) : null;
+    }
+    get client() {
+        return this.record.client ? clientDeclaration(this.address, this.record.client) : null;
+    }
     get address() { return { identity: this.identity, reference: this.reference }; }
     update(record) {
         if (record.reference !== this.reference)
@@ -74,6 +78,29 @@ class ProgramHandle extends ProgramBase {
         await wire.request(["forget", this.address]);
     }
 }
+function declaration(address, endpoint, record) {
+    return Object.freeze({
+        start: record.start,
+        hasService: () => record.hasService,
+        docs: () => endpointDocs(address, endpoint, record.hasService)
+    });
+}
+function clientDeclaration(address, record) {
+    return Object.freeze({
+        ...declaration(address, "client", record),
+        title: record.title,
+        size: record.size,
+        position: record.position,
+        layer: record.layer,
+        minimize: record.minimize
+    });
+}
+async function endpointDocs(address, endpoint, declared) {
+    if (!declared)
+        return null;
+    const answer = await wire.request(["endpoint-docs", address, endpoint]);
+    return answer[0];
+}
 class ProgramProcessHandle {
     address;
     constructor(address, reference) {
@@ -98,6 +125,10 @@ class ProgramProcessHandle {
         const answer = await wire.request(["program-process-create", this.address, launch]);
         return process(answer[0]);
     }
+    async findOrCreate(launch) {
+        const answer = await wire.request(["program-process-find-or-create", this.address, launch]);
+        return process(answer[0]);
+    }
     async exitAll() {
         const answer = await wire.request(["program-process-exit-all", this.address]);
         return answer[0];

package/dist/host.d.ts

@@ -1,4 +1,5 @@
-import type { DesktopWallpaper, Exit, FileWallpaper, Layer, Position, ServedFile, ClientServiceHandler, ServerServiceHandler, ServiceKey, ServiceRegistryEvents, Size, Subscribable, ThemeProperties, WritableTheme } from "@phreshos/core";
+import type { DesktopWallpaper, Exit, FileWallpaper, Layer, Position, ServedFile, ServiceKey, Size, Subscribable, ThemeProperties, WritableTheme } from "@phreshos/core";
+import type { ClientServiceHandler, ServerServiceHandler } from "./service.js";
 import { type Client, type Process, type Program, type Server } from "./domain.js";
 /** Resolved production description for a Program's Server. */
 export type ServerDescription = Readonly<{
@@ -6,6 +7,8 @@ export type ServerDescription = Readonly<{
     location: string;
     /** Whether newly created Processes start this Server by default. */
     start?: boolean;
+    /** Absolute Markdown file documenting the Service this Server may expose. */
+    serviceDocs?: string;
     /** Command used to install the Server's production dependencies. */
     installCommand?: string;
     /** Command used to start the Server from its production directory. */
@@ -17,6 +20,8 @@ export type ClientDescription = Readonly<{
     location: string;
     /** Whether newly created Processes start this Client by default. */
     start?: boolean;
+    /** Absolute Markdown file documenting the Service this Client may expose. */
+    serviceDocs?: string;
     /** Default Window title. */
     title?: string;
     /** Default Window size. */
@@ -99,16 +104,6 @@ export interface HostProcess extends Subscribable<ProcessHostEvents, never> {
     list(): Promise<Process[]>;
     find(identity: string): Promise<Process | null>;
 }
-/** Authoritative public service registry available to a Server endpoint. */
-export interface HostService extends Subscribable<ServiceRegistryEvents, never> {
-    list(): Promise<readonly ServiceKey[]>;
-    prepare<ServiceEvents extends object = {}>(key: ServiceKey & {
-        endpoint: "server";
-    }): ServerServiceHandler<ServiceEvents>;
-    prepare<ServiceEvents extends object = {}>(key: ServiceKey & {
-        endpoint: "client";
-    }): ClientServiceHandler<ServiceEvents>;
-}
 /** Authoritative system capabilities available to a Server endpoint. */
 export interface Host {
     /** Observable system Theme authority. */
@@ -119,7 +114,13 @@ export interface Host {
     readonly desktopWallpaper: DesktopWallpaper;
     readonly program: HostProgram;
     readonly process: HostProcess;
-    readonly service: HostService;
+    /** Returns a stable handle for one exact Service identity. */
+    service<ServiceEvents extends object = {}>(key: ServiceKey & {
+        endpoint: "server";
+    }): ServerServiceHandler<ServiceEvents>;
+    service<ServiceEvents extends object = {}>(key: ServiceKey & {
+        endpoint: "client";
+    }): ClientServiceHandler<ServiceEvents>;
     /** Publishes a value through the host and returns its public file metadata. */
     serve(value: unknown): Promise<ServedFile>;
 }

package/dist/host.js

@@ -11,7 +11,7 @@ class ServerHost {
     desktopWallpaper = new ServerDesktopWallpaper();
     program = new ServerHostProgram();
     process = new ServerHostProcess();
-    service = new ServerHostService();
+    service(key) { return prepareService(key); }
     serve(value) { return serve(value); }
 }
 class ServerHostProgram extends Events {
@@ -50,21 +50,6 @@ class ServerHostProcess extends Events {
         return answer[0] ? process(answer[0]) : null;
     }
 }
-class ServerHostService extends Events {
-    constructor() {
-        super((event, listener) => wire.followServiceRegistry(event, listener), observer => wire.followServiceRegistry(null, (event, key) => {
-            if (typeof event === "string")
-                observer(event, key);
-        }));
-    }
-    async list() {
-        const answer = await wire.request(["host-service-list"]);
-        return Object.freeze(answer[0]);
-    }
-    prepare(key) {
-        return prepareService(key);
-    }
-}
 function hostProcessEvent(event, values) {
     if (event === "endpointStart" || event === "endpointStop")
         return lifecycleEndpoint(values[1], values[2]);

package/dist/main.d.ts

@@ -1,7 +1,8 @@
-export { host, type Host, type HostProcess, type HostProgram, type HostService, type ClientDescription, type ProcessHostEvents, type ProcessHostExit, type ProgramHostEvents, type ProgramHostUninstall, type ProgramDescription, type ServerDescription } from "./host.js";
+export { host, type Host, type HostProcess, type HostProgram, type ClientDescription, type ProcessHostEvents, type ProcessHostExit, type ProgramHostEvents, type ProgramHostUninstall, type ProgramDescription, type ServerDescription } from "./host.js";
 export { current, type Current, type CurrentClient } from "./current.js";
 export { type Answerer, type Channel } from "./channel.js";
 export { type ProgramStartup } from "./startup.js";
-export { ClientServiceHandler, ServerServiceHandler, ServiceHandler, type ClientServiceChannel, type ServerServiceChannel, type ServiceChannel, type ServiceKey, type ServiceLifecycleEvents } from "@phreshos/core";
+export { ClientServiceHandler, ServerServiceHandler, type TimedClientServiceHandler, type TimedServerServiceHandler } from "./service.js";
+export { ServiceHandler, type ClientServiceChannel, type ServerServiceChannel, type ServiceChannel, type ServiceKey, type ServiceLifecycleEvents } from "@phreshos/core";
 export { Client, Endpoint, Process, Program, Server, type Window, type ProgramArea, type ProgramProcess } from "./domain.js";
 export type { AnswerCapture, AnswerMessage, AnswerObserver, Askable, AskCapture, AskMessage, AskObserver, Capture, Captures, ChannelCapture, ChannelEvents, ChannelMessage, ClientTraffic, ClientDeclaration, Cleanup, DirectoryStat, EndpointDeclaration, EndpointTraffic, EntryStat, EventMessage, EventName, EventObserver, EventOptions, EventSubscriber, Exit, FileStat, Launch, LaunchClient, Layer, LogKind, LogRecord, LogSource, Message, OtherStat, Outcome, Position, ProgramEvents, ProgramPermission, ProgramProcessEvents, ProgramProcessExit, ProgramSql, ProgramStore, ProcessEvents, Publishable, ServedFile, ServerTraffic, Size, Subscribable, SubscribableEvents, SubscribableFallback, TimedAskable, TrafficCapture, TrafficEvents, TrafficMessage, Value, Theme, ThemeEvents, ThemeProperties, WallpaperLaunch, FileWallpaper, DesktopWallpaper, WritableTheme, WindowEvents, WindowGeometry, WindowLayer, WindowState } from "@phreshos/core";

package/dist/main.js

@@ -2,5 +2,6 @@ export { host } from "./host.js";
 export { current } from "./current.js";
 export {} from "./channel.js";
 export {} from "./startup.js";
-export { ClientServiceHandler, ServerServiceHandler, ServiceHandler } from "@phreshos/core";
+export { ClientServiceHandler, ServerServiceHandler } from "./service.js";
+export { ServiceHandler } from "@phreshos/core";
 export { Client, Endpoint, Process, Program, Server } from "./domain.js";

package/dist/service.d.ts

@@ -1,5 +1,31 @@
-import { type ClientServiceHandler, type ServerServiceDefinition, type ServerServiceHandler, type ServiceHandler, type ServiceKey } from "@phreshos/core";
+import { ClientServiceHandler as CoreClientServiceHandler, ServerServiceHandler as CoreServerServiceHandler, type LaunchClient, type ServiceHandler, type ServiceKey, type Timeoutable } from "@phreshos/core";
 import type { HandleAddress } from "./domain.js";
+/** Timed view of a Server Endpoint Service available through the Server SDK. */
+export interface TimedServerServiceHandler {
+    waitReady(timeout?: number): Promise<void>;
+    createAndWaitReady(timeout?: number): Promise<void>;
+}
+/** Timed view of a Client Endpoint Service available through the Server SDK. */
+export interface TimedClientServiceHandler {
+    waitReady(timeout?: number): Promise<void>;
+    createAndWaitReady(client?: LaunchClient, timeout?: number): Promise<void>;
+}
+/** Server-SDK handle for a Service provided by a Server Endpoint. */
+export declare class ServerServiceHandler<Events extends object = {}> extends CoreServerServiceHandler<Events> {
+    protected constructor();
+}
+export interface ServerServiceHandler<Events extends object = {}> extends Timeoutable<TimedServerServiceHandler> {
+    createAndWaitReady(timeout?: number): Promise<void>;
+    timeout(milliseconds: number): TimedServerServiceHandler;
+}
+/** Server-SDK handle for a Service provided by a Client Endpoint. */
+export declare class ClientServiceHandler<Events extends object = {}> extends CoreClientServiceHandler<Events> {
+    protected constructor();
+}
+export interface ClientServiceHandler<Events extends object = {}> extends Timeoutable<TimedClientServiceHandler> {
+    createAndWaitReady(client?: LaunchClient, timeout?: number): Promise<void>;
+    timeout(milliseconds: number): TimedClientServiceHandler;
+}
 export declare function prepareService<EventsMap extends object = {}>(key: ServiceKey & {
     endpoint: "server";
 }): ServerServiceHandler<EventsMap>;
@@ -7,7 +33,7 @@ export declare function prepareService<EventsMap extends object = {}>(key: Servi
     endpoint: "client";
 }): ClientServiceHandler<EventsMap>;
 export declare function prepareService(key: ServiceKey): ServiceHandler;
-export declare function enableCurrentService(definition: ServerServiceDefinition): Promise<void>;
+export declare function enableCurrentService(name: string): Promise<void>;
 export declare function disableCurrentService(): Promise<void>;
 export declare function endpointService<EventsMap extends object = {}>(target: HandleAddress | null, endpoint: "server"): Promise<ServerServiceHandler<EventsMap> | null>;
 export declare function endpointService<EventsMap extends object = {}>(target: HandleAddress | null, endpoint: "client"): Promise<ClientServiceHandler<EventsMap> | null>;

package/dist/service.js

@@ -5,8 +5,14 @@ import Events from "./events.js";
 import HandleRegistry from "./handle-registry.js";
 import wire from "./wire.js";
 const handles = new HandleRegistry();
-const ServerServiceBase = CoreServerServiceHandler;
-const ClientServiceBase = CoreClientServiceHandler;
+/** Server-SDK handle for a Service provided by a Server Endpoint. */
+export class ServerServiceHandler extends CoreServerServiceHandler {
+    constructor() { super(); }
+}
+/** Server-SDK handle for a Service provided by a Client Endpoint. */
+export class ClientServiceHandler extends CoreClientServiceHandler {
+    constructor() { super(); }
+}
 class ServerChannelHandle extends Events {
     key;
     constructor(key) {
@@ -45,7 +51,7 @@ class ClientChannelHandle extends Events {
         super(...serviceEvents(key, "channel"));
     }
 }
-class ServerHandler extends ServerServiceBase {
+class ServerHandler extends ServerServiceHandler {
     key;
     name;
     channel;
@@ -63,12 +69,17 @@ class ServerHandler extends ServerServiceBase {
     async waitReady(timeout) {
         await wire.request(["service-wait-ready", this.key, timeout], timeout);
     }
-    async docs() {
-        const answer = await wire.request(["service-docs", this.key]);
-        return answer[0];
+    async createAndWaitReady(timeout) {
+        await wire.request(["service-create-and-wait-ready", this.key, undefined, timeout], timeout);
+    }
+    timeout(milliseconds) {
+        return Object.freeze({
+            waitReady: (timeout) => this.waitReady(timeout ?? milliseconds),
+            createAndWaitReady: (timeout) => this.createAndWaitReady(timeout ?? milliseconds)
+        });
     }
 }
-class ClientHandler extends ClientServiceBase {
+class ClientHandler extends ClientServiceHandler {
     key;
     name;
     channel;
@@ -86,6 +97,17 @@ class ClientHandler extends ClientServiceBase {
     async waitReady(timeout) {
         await wire.request(["service-wait-ready", this.key, timeout], timeout);
     }
+    async createAndWaitReady(client, timeout) {
+        await wire.request(["service-create-and-wait-ready", this.key, client, timeout], timeout);
+    }
+    timeout(milliseconds) {
+        return Object.freeze({
+            waitReady: (timeout) => this.waitReady(timeout ?? milliseconds),
+            createAndWaitReady: (client, timeout) => {
+                return this.createAndWaitReady(client, timeout ?? milliseconds);
+            }
+        });
+    }
 }
 export function prepareService(key) {
     if (!isServiceKey(key))
@@ -98,8 +120,8 @@ export function prepareService(key) {
             : new ClientHandler(normalized);
     });
 }
-export async function enableCurrentService(definition) {
-    await wire.request(["enable-service", definition]);
+export async function enableCurrentService(name) {
+    await wire.request(["enable-service", name]);
 }
 export async function disableCurrentService() {
     await wire.request(["disable-service"]);

package/dist/wire.d.ts

@@ -32,8 +32,6 @@ declare class Wire {
     follow(target: HandleAddress | null, half: "server" | "client", event: string | null, handler: Handler, impossible?: Failure): Cleanup;
     /** Follow one exact service lifecycle or application event route. */
     followService(key: ServiceKey, scope: "lifecycle" | "channel", event: string | null, handler: Handler): Cleanup;
-    /** Follow lifecycle changes across the authoritative service registry. */
-    followServiceRegistry(event: string | null, handler: Handler): Cleanup;
     private register;
     private unregister;
     private deliver;

package/dist/wire.js

@@ -176,16 +176,6 @@ class Wire {
             this.send("end-host", "service-unfollow", subscription);
         });
     }
-    /** Follow lifecycle changes across the authoritative service registry. */
-    followServiceRegistry(event, handler) {
-        const subscription = randomUUID();
-        const stop = this.on("service-registry-event", subscription, handler);
-        this.send("end-host", "service-registry-follow", subscription, event);
-        return once(() => {
-            stop();
-            this.send("end-host", "service-registry-unfollow", subscription);
-        });
-    }
     register(kind, route, event, subject, impossible) {
         const subscription = randomUUID();
         if (impossible)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phreshos/server",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "The SDK used by a Program's server endpoint.",
   "type": "module",
   "main": "dist/main.js",
@@ -46,13 +46,13 @@
     "prepack": "node --run build"
   },
   "peerDependencies": {
-    "@phreshos/core": "^0.1.9"
+    "@phreshos/core": "^0.1.11"
   },
   "dependencies": {
     "@msgpack/msgpack": "^3.1.3"
   },
   "devDependencies": {
-    "@phreshos/core": "^0.1.9",
+    "@phreshos/core": "^0.1.11",
     "@types/node": "^26.2.0",
     "typescript": "^6.0.3"
   }