@sigrun/provider-ollama 0.0.0-stage → 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,42 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-10-18
+### Changed
+- Renamed to `@sigrun/provider-ollama` for the 0.1.0 release (GitHub
+  repo `sigrun-ai/sigrun-provider-ollama`): published package metadata
+  (`publishConfig` access/provenance), host modules
+  (`@earendil-works/pi-ai`, `@earendil-works/pi-durable`) moved to
+  `peerDependencies` mirrored in `devDependencies` at exact `1.3.0`,
+  CHANGELOG.md joined the files whitelist, and a manifest hygiene check
+  wired into `npm test`. The contributor identity follows the package
+  slug: the factory result's `name` becomes `provider-ollama` and the
+  scoped settings file `settings/provider-ollama.json` (the loader
+  pre-keys the two-phase host from the package name; a stale declared
+  name would split the factory-time settings scope).
+
+### Added
+- Deployment-configurable base URL: the (now async) factory reads
+  `baseUrl` from the plugin's scoped settings
+  (`settings/provider-ollama.json`) with the constant as fallback; a
+  malformed override fails the factory loudly instead of silently
+  falling back (mirrors sigrun-pareto; restart-required).
+- Reference sigrun provider plugin: Ollama Cloud (`https://ollama.com/v1`)
+  as one dynamic OpenAI-compatible provider (`provider: "ollama"` stamped on
+  every catalog entry so persisted catalogs survive cold-boot restore).
+- Provider-only contributor factory: `{ name: "provider-ollama", providers:
+  [{ provider, readiness }], health }` — no pi-durable extension surface.
+- Credential resolution through sigrun's auth.json bridge with
+  `OLLAMA_API_KEY` as the ambient fallback (bridge credential always wins).
+- Three-state readiness tracker (`not_configured` / `degraded` / `ready`)
+  seeded from credential resolution and updated per refresh outcome;
+  `console.warn` on state transitions only. `health()` maps `not_configured`
+  to `"ok"` and configured-and-failing to `"degraded"`.
+- `fetchModels` throws on unconfigured and on failure — never returns `[]`
+  (an empty array would publish and wipe the persisted catalog).

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Michael MacLeod
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,75 @@
-# Temporary Holding Version
+# @sigrun/provider-ollama
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The reference [sigrun](https://github.com/sigrun-ai/sigrun) provider
+plugin: [Ollama Cloud](https://ollama.com) (`https://ollama.com/v1`,
+OpenAI-compatible) as one dynamic chat provider.
+
+## What it contributes
+
+A **provider-only contributor** — the default export is a factory
+returning `{ name: "provider-ollama", providers: [{ provider, readiness }],
+health }` with no pi-durable extension surface. Sigrun's loader merges
+the provider into its `Models` store at boot.
+
+- **Provider** `ollama` — dynamic catalog fetched from `<base>/models`
+  (OpenAI `[OI]` list shape) over `openai-completions`; boots with an
+  empty baseline and publishes the fetched catalog.
+- **Readiness** (`not_configured` / `degraded` / `ready`, surfaced on
+  sigrun's `/v1/auth/check`) — seeded from credential resolution and
+  updated per refresh outcome; state transitions log via `console.warn`
+  (transitions only, never per failure). On the first configured boot
+  the provider announces `startup → ready` at credential *resolution* —
+  before any refresh has run (`ready` there means "credential resolved,
+  refresh not yet attempted", not "catalog verified").
+- **Health** — `degraded` only when the provider is configured and its
+  last refresh failed; an unconfigured optional plugin reports `ok`.
+
+## Credentials
+
+Resolved per request through sigrun's auth.json bridge, falling back to
+the ambient environment:
+
+1. the bridged auth.json credential (`"default"` entry, then the
+   `"ollama"` entry), then
+2. `OLLAMA_API_KEY`.
+
+The plugin never reads auth.json or `process.env` itself. Rotating the
+key applies on the next resolution — no restart needed (there are no
+plugin settings; the endpoint is fixed).
+
+## Failure semantics
+
+`fetchModels` **throws** when unconfigured or when the catalog fetch
+fails — it never returns an empty array, which pi-ai would publish and
+persist, wiping the catalog. A failed refresh retains the previous
+catalog and records a per-provider error.
+
+## Install
+
+```jsonc
+// settings.json (sigrun config dir) — the UNIFIED extensions list:
+// install + load in one place; npm and git specifiers are the same list
+// npm ("@sigrun/provider-ollama@^0.1.0"), git
+// ("git:github.com/sigrun-ai/sigrun-provider-ollama", or any
+// https git URL with an optional @ref), or the file: form below.
+{
+	"extensions": ["file:/path/to/sigrun-ollama"]
+}
+```
+
+The committed `dist/` is the load target for git installs; pi-ai and
+pi-durable are peerDependencies (sigrun supplies them at runtime);
+they are mirrored in devDependencies for this repo's own build and tests.
+
+## Development
+
+```sh
+npm install        # also builds dist/ via prepare
+npm test           # vitest — hermetic fixture HTTP server, no network
+npm run typecheck
+npm run build
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,111 @@
+/**
+ * @sigrun/provider-ollama — the reference sigrun provider plugin (provider plugins
+ * Task 7): Ollama Cloud (`https://ollama.com/v1`) as one dynamic
+ * OpenAI-compatible provider.
+ *
+ * The default export is the sigrun extension-package factory returning a
+ * PROVIDER-ONLY contributor — `{ name, providers, health }` with no
+ * `extension` field — consumed structurally by sigrun's loader (Task 1
+ * pathway). Credentials resolve through sigrun's auth.json bridge (the
+ * stored credential arrives as `credential` on the auth resolver, ambient
+ * env as `ctx.env`) with `OLLAMA_API_KEY` as the fallback; the plugin
+ * never reads auth.json or `process.env` itself.
+ *
+ * Runtime imports from pi-ai are deliberate (`createProvider` + the
+ * OpenAI-completions api); the package still declares pi-ai/pi-durable as
+ * devDependencies only, because sigrun (the host) ships them and
+ * `syncPackages` installs with `--omit=dev` — the provider-plugins spec's
+ * dependency posture.
+ */
+import { type Provider } from "@earendil-works/pi-ai/models";
+import type { Model } from "@earendil-works/pi-ai";
+/** The provider id models are registered (and stamped) under. */
+export declare const OLLAMA_PROVIDER_ID = "ollama";
+/**
+ * Ollama Cloud's OpenAI-compatible endpoint. The operator can override
+ * per deployment via the plugin's scoped settings (`baseUrl`) — see
+ * {@link resolveOllamaBaseUrl}.
+ */
+export declare const OLLAMA_BASE_URL = "https://ollama.com/v1";
+/** Ambient fallback when auth.json holds no credential. */
+export declare const OLLAMA_API_KEY_ENV = "OLLAMA_API_KEY";
+/**
+ * Structural slice of sigrun's seam host (src/harness/seam-host.ts) a
+ * provider plugin may consume. Declared here — structurally, like the
+ * bridge's pi-ai re-declarations — because the plugin cannot import
+ * sigrun core. The scoped settings store is async-only, which is why the
+ * loader awaits factory results.
+ */
+export interface SigrunPluginHost {
+    readonly stores: {
+        /** This plugin's own `settings/<slug>.json`; absent file → `{}`. */
+        readonly settings: {
+            get(): Promise<Record<string, unknown>>;
+            set(value: Record<string, unknown>): Promise<void>;
+        };
+    };
+}
+/** Sigrun's three-state per-provider readiness vocabulary (Task 6). */
+export type ProviderReadinessStatus = "not_configured" | "degraded" | "ready";
+/** One tracker report: the status plus optional operator-facing detail. */
+export interface ProviderReadiness {
+    readonly status: ProviderReadinessStatus;
+    readonly detail?: string;
+}
+/** Sigrun's §3 health vocabulary. */
+export type HealthStatus = "ok" | "degraded";
+/**
+ * The provider-plugin factory result (the loader's Task 1 contract):
+ * a provider-only contributor — `{ name, providers, health? }`, no
+ * `extension`. Structural, like the host slice above.
+ */
+export interface ProviderPluginResult {
+    readonly name: string;
+    readonly providers: readonly {
+        readonly provider: Provider;
+        readonly readiness?: () => ProviderReadiness;
+    }[];
+    readonly health?: () => HealthStatus;
+}
+/**
+ * Parse an OpenAI-compatible `[OI]` `/models` body into pi-ai chat models.
+ * Every entry is stamped `provider: "ollama"` — pi-ai's restore path drops
+ * stored models whose `provider` field differs from the registered id, so
+ * an unstamped catalog silently vanishes on cold boot. Malformed bodies
+ * throw (a refresh failure retains the previous catalog; garbage must
+ * never publish).
+ */
+export declare function parseOllamaCatalog(body: unknown, baseUrl: string): Model<"openai-completions">[];
+/** One built plugin: the contribution's parts, sharing the tracker closure. */
+export interface OllamaPlugin {
+    readonly provider: Provider;
+    /** Synchronous read over plugin-owned state (never network/storage). */
+    readonly readiness: () => ProviderReadiness;
+    readonly health: () => HealthStatus;
+}
+/**
+ * Build the Ollama Cloud provider plus its readiness/health trackers.
+ * `baseUrl` is overridable so hermetic tests drive a fixture server; the
+ * default is the real cloud endpoint.
+ */
+export declare function createOllamaPlugin(baseUrl?: string): OllamaPlugin;
+/**
+ * Resolve the plugin's base URL from its scoped settings: `baseUrl`
+ * (string) overrides the {@link OLLAMA_BASE_URL} constant. Absent → the
+ * constant; present-but-not-a-non-empty-string → throw (a malformed
+ * override must quarantine loudly, not silently fall back to a possibly
+ * wrong constant).
+ */
+export declare function resolveOllamaBaseUrl(settings: Record<string, unknown>): string;
+/**
+ * The sigrun extension-package factory (provider-only contributor).
+ * Arity 1 declares the host-taking signature — sigrun's loader passes the
+ * seam host only to factories that declare one (`factory.length > 0`) —
+ * and the factory is ASYNC because the scoped settings store is
+ * async-only; sigrun's loader awaits factory results. The base URL is
+ * deployment-configurable through the scoped settings (`baseUrl` in
+ * `settings/provider-ollama.json`, constant fallback): deployments behind a
+ * proxy or mirror — and hermetic test fixtures — redirect the endpoint
+ * that way (restart-required, exactly like sigrun-pareto/sigrun-bifrost).
+ */
+export default function sigrunOllama(host: SigrunPluginHost): Promise<ProviderPluginResult>;

package/dist/index.js

@@ -0,0 +1,243 @@
+/**
+ * @sigrun/provider-ollama — the reference sigrun provider plugin (provider plugins
+ * Task 7): Ollama Cloud (`https://ollama.com/v1`) as one dynamic
+ * OpenAI-compatible provider.
+ *
+ * The default export is the sigrun extension-package factory returning a
+ * PROVIDER-ONLY contributor — `{ name, providers, health }` with no
+ * `extension` field — consumed structurally by sigrun's loader (Task 1
+ * pathway). Credentials resolve through sigrun's auth.json bridge (the
+ * stored credential arrives as `credential` on the auth resolver, ambient
+ * env as `ctx.env`) with `OLLAMA_API_KEY` as the fallback; the plugin
+ * never reads auth.json or `process.env` itself.
+ *
+ * Runtime imports from pi-ai are deliberate (`createProvider` + the
+ * OpenAI-completions api); the package still declares pi-ai/pi-durable as
+ * devDependencies only, because sigrun (the host) ships them and
+ * `syncPackages` installs with `--omit=dev` — the provider-plugins spec's
+ * dependency posture.
+ */
+import { createProvider } from "@earendil-works/pi-ai/models";
+import { openAICompletionsApi } from "@earendil-works/pi-ai/api/openai-completions.lazy";
+/** The provider id models are registered (and stamped) under. */
+export const OLLAMA_PROVIDER_ID = "ollama";
+/**
+ * Ollama Cloud's OpenAI-compatible endpoint. The operator can override
+ * per deployment via the plugin's scoped settings (`baseUrl`) — see
+ * {@link resolveOllamaBaseUrl}.
+ */
+export const OLLAMA_BASE_URL = "https://ollama.com/v1";
+/** Ambient fallback when auth.json holds no credential. */
+export const OLLAMA_API_KEY_ENV = "OLLAMA_API_KEY";
+/**
+ * Conservative placeholders for catalog entries Ollama's `/models` shape
+ * gives no metadata for (no window, no limits, no rates). Same values as
+ * sigrun's degenerate env provider (`DEFAULT_OPENAI_*`), keeping context
+ * management deterministic against unknown windows.
+ */
+const DEFAULT_CONTEXT_WINDOW = 128_000;
+const DEFAULT_MAX_TOKENS = 16_384;
+/**
+ * Parse an OpenAI-compatible `[OI]` `/models` body into pi-ai chat models.
+ * Every entry is stamped `provider: "ollama"` — pi-ai's restore path drops
+ * stored models whose `provider` field differs from the registered id, so
+ * an unstamped catalog silently vanishes on cold boot. Malformed bodies
+ * throw (a refresh failure retains the previous catalog; garbage must
+ * never publish).
+ */
+export function parseOllamaCatalog(body, baseUrl) {
+    if (typeof body !== "object" || body === null) {
+        throw new Error("ollama /models body is not a JSON object");
+    }
+    const data = body.data;
+    if (!Array.isArray(data)) {
+        throw new Error("ollama /models body has no data array");
+    }
+    return data.map((entry) => {
+        const id = entry?.id;
+        if (typeof id !== "string" || id.length === 0) {
+            throw new Error("ollama /models entry without a string id");
+        }
+        const model = {
+            id,
+            name: id,
+            api: "openai-completions",
+            // THE stamp — see the doc comment above.
+            provider: OLLAMA_PROVIDER_ID,
+            baseUrl,
+            // Ollama's /models carries no modality metadata; text is the
+            // safe floor (claiming image without evidence would ship image
+            // parts to models that cannot read them).
+            input: ["text"],
+            // Unknown rates: zeroed, usage tracking stays structural.
+            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+            reasoning: false,
+            contextWindow: DEFAULT_CONTEXT_WINDOW,
+            maxTokens: DEFAULT_MAX_TOKENS,
+        };
+        return model;
+    });
+}
+/**
+ * Build the Ollama Cloud provider plus its readiness/health trackers.
+ * `baseUrl` is overridable so hermetic tests drive a fixture server; the
+ * default is the real cloud endpoint.
+ */
+export function createOllamaPlugin(baseUrl = OLLAMA_BASE_URL) {
+    // Tracker state: seeded from credential resolution (pi-ai never
+    // refreshes an unconfigured provider, so refresh outcomes alone cannot
+    // express not_configured), updated per refresh outcome. Readiness and
+    // health are synchronous derivations over this state.
+    let credentialResolved = false;
+    let lastRefreshFailed = false;
+    let lastRefreshDetail;
+    let lastAnnounced;
+    function status() {
+        if (!credentialResolved)
+            return "not_configured";
+        return lastRefreshFailed ? "degraded" : "ready";
+    }
+    /** Apply a state change; `console.warn` on transitions only. */
+    function announce() {
+        const next = status();
+        if (next === lastAnnounced)
+            return;
+        console.warn(`provider-ollama: ollama ${lastAnnounced ?? "startup"} → ${next}` +
+            (lastRefreshDetail !== undefined && next === "degraded"
+                ? ` (${lastRefreshDetail})`
+                : ""));
+        lastAnnounced = next;
+    }
+    function noteCredential(resolved) {
+        credentialResolved = resolved;
+        announce();
+    }
+    function noteRefresh(ok, detail) {
+        lastRefreshFailed = !ok;
+        lastRefreshDetail = ok ? undefined : detail;
+        announce();
+    }
+    const provider = createProvider({
+        id: OLLAMA_PROVIDER_ID,
+        name: "Ollama Cloud",
+        baseUrl,
+        // REQUIRED baseline: createProvider iterates it (omitting throws
+        // "baselineModels is not iterable"); empty = purely dynamic.
+        models: [],
+        auth: {
+            apiKey: {
+                name: "Ollama Cloud API key (auth.json or OLLAMA_API_KEY)",
+                resolve: async ({ credential, ctx }) => {
+                    // Bridged auth.json credential (sigrun's bridge: the
+                    // "default" entry first, then the provider's own) wins;
+                    // the env var is the ambient fallback.
+                    const stored = credential?.key?.trim() || undefined;
+                    if (stored !== undefined) {
+                        noteCredential(true);
+                        return { auth: { apiKey: stored }, source: "auth.json" };
+                    }
+                    const envKey = (await ctx.env(OLLAMA_API_KEY_ENV))?.trim() || undefined;
+                    if (envKey !== undefined) {
+                        noteCredential(true);
+                        return { auth: { apiKey: envKey }, source: OLLAMA_API_KEY_ENV };
+                    }
+                    // Unconfigured: undefined makes pi-ai skip the refresh
+                    // phase entirely and requests fail loud.
+                    noteCredential(false);
+                    return undefined;
+                },
+            },
+        },
+        fetchModels: async (context) => {
+            // The context credential is whatever auth resolution produced —
+            // for this plugin always the merged api key; narrow rather than
+            // trust the union.
+            const key = context.credential?.type === "api_key"
+                ? context.credential.key?.trim() || undefined
+                : undefined;
+            if (key === undefined) {
+                noteCredential(false);
+                // NEVER return [] — the createProvider wrapper publishes +
+                // persists whatever fetchModels returns; an empty array
+                // would wipe the catalog.
+                throw new Error(`provider-ollama: Ollama Cloud is not configured ` +
+                    `(no auth.json credential and no ${OLLAMA_API_KEY_ENV}); ` +
+                    "refusing to publish an empty catalog");
+            }
+            const effectiveBase = context.baseUrl ?? baseUrl;
+            // URL-join needs the trailing slash ("models" against a
+            // slash-less base would resolve to the host root).
+            const root = effectiveBase.endsWith("/") ? effectiveBase : `${effectiveBase}/`;
+            try {
+                const response = await fetch(new URL("models", root), {
+                    headers: { Authorization: `Bearer ${key}` },
+                    signal: context.signal,
+                });
+                if (!response.ok) {
+                    throw new Error(`HTTP ${response.status}`);
+                }
+                const models = parseOllamaCatalog(await response.json(), effectiveBase);
+                noteRefresh(true);
+                return models;
+            }
+            catch (cause) {
+                // An aborted refresh is not a failed one: pi-ai discards
+                // the outcome anyway, so the tracker must not move.
+                if (context.signal.aborted)
+                    throw cause;
+                const message = cause instanceof Error ? cause.message : String(cause);
+                noteRefresh(false, message);
+                throw new Error(`provider-ollama: Ollama Cloud catalog refresh failed: ${message}`);
+            }
+        },
+        api: openAICompletionsApi(),
+    });
+    return {
+        provider,
+        readiness: () => ({
+            status: status(),
+            ...(lastRefreshDetail !== undefined && status() === "degraded"
+                ? { detail: lastRefreshDetail }
+                : {}),
+        }),
+        // not_configured → ok (an unconfigured optional plugin is not a
+        // degraded process); configured-and-failing → degraded; else ok.
+        health: () => (status() === "degraded" ? "degraded" : "ok"),
+    };
+}
+/**
+ * Resolve the plugin's base URL from its scoped settings: `baseUrl`
+ * (string) overrides the {@link OLLAMA_BASE_URL} constant. Absent → the
+ * constant; present-but-not-a-non-empty-string → throw (a malformed
+ * override must quarantine loudly, not silently fall back to a possibly
+ * wrong constant).
+ */
+export function resolveOllamaBaseUrl(settings) {
+    if (!("baseUrl" in settings))
+        return OLLAMA_BASE_URL;
+    const value = settings.baseUrl;
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error("provider-ollama: settings/provider-ollama.json baseUrl must be a non-empty string when present");
+    }
+    return value.trim();
+}
+/**
+ * The sigrun extension-package factory (provider-only contributor).
+ * Arity 1 declares the host-taking signature — sigrun's loader passes the
+ * seam host only to factories that declare one (`factory.length > 0`) —
+ * and the factory is ASYNC because the scoped settings store is
+ * async-only; sigrun's loader awaits factory results. The base URL is
+ * deployment-configurable through the scoped settings (`baseUrl` in
+ * `settings/provider-ollama.json`, constant fallback): deployments behind a
+ * proxy or mirror — and hermetic test fixtures — redirect the endpoint
+ * that way (restart-required, exactly like sigrun-pareto/sigrun-bifrost).
+ */
+export default async function sigrunOllama(host) {
+    const settings = await host.stores.settings.get();
+    const plugin = createOllamaPlugin(resolveOllamaBaseUrl(settings));
+    return {
+        name: "provider-ollama",
+        providers: [{ provider: plugin.provider, readiness: plugin.readiness }],
+        health: plugin.health,
+    };
+}

package/package.json

@@ -1,6 +1,51 @@
 {
-  "name": "@sigrun/provider-ollama",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+	"name": "@sigrun/provider-ollama",
+	"version": "0.1.0",
+	"description": "Reference sigrun provider plugin: Ollama Cloud (OpenAI-compatible /v1) as a dynamic provider",
+	"type": "module",
+	"engines": {
+		"node": ">=22.19.0"
+	},
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"default": "./dist/index.js"
+		}
+	},
+	"files": [
+		"dist",
+		"CHANGELOG.md"
+	],
+	"scripts": {
+		"test": "node scripts/check-manifest.mjs --expect-name @sigrun/provider-ollama && vitest run",
+		"typecheck": "tsc --noEmit",
+		"build": "tsc -p tsconfig.build.json",
+		"prepare": "npm run build"
+	},
+	"devDependencies": {
+		"@earendil-works/pi-ai": "1.3.0",
+		"@earendil-works/pi-durable": "1.3.0",
+		"@types/node": "^26.6.4",
+		"typescript": "^7.0.2",
+		"vitest": "^5.0.3"
+	},
+	"license": "MIT",
+	"repository": {
+		"type": "github",
+		"url": "git+https://github.com/sigrun-ai/sigrun-provider-ollama.git"
+	},
+	"bugs": {
+		"url": "https://github.com/sigrun-ai/sigrun-provider-ollama/issues"
+	},
+	"homepage": "https://github.com/sigrun-ai/sigrun-provider-ollama#readme",
+	"publishConfig": {
+		"access": "public",
+		"provenance": true
+	},
+	"peerDependencies": {
+		"@earendil-works/pi-ai": "1.3.0",
+		"@earendil-works/pi-durable": "1.3.0"
+	}
+}