@astralyn/sash 0.1.0 → 0.1.2

package/dist/contracts.js

@@ -1,412 +1,248 @@
 import { isCanonicalIsoTimestamp, isPlainObject } from "./json-shape.js";
+import { parseProfileMeta } from "./profile-model.js";
+export { parseProfilesIndex } from "./profile-model.js";
 export const WEB_SOCKET_AUTH_PROTOCOL = "sash";
 export const WEB_SOCKET_TOKEN_PROTOCOL_PREFIX = "sash-token.";
-export function apiErrorBody(code, message) {
-    return { error: { code, message } };
-}
-export function parseApiErrorBody(value) {
-    if (!isPlainObject(value) || !isPlainObject(value.error))
-        return undefined;
-    const { code, message } = value.error;
-    if (typeof code !== "string" || typeof message !== "string")
-        return undefined;
-    return { code, message };
-}
-function invalid(contract, path, expected) {
-    throw new TypeError(`${contract} response is invalid: ${path} must be ${expected}`);
-}
-function objectValue(value, contract, path) {
+function object(value, name) {
     if (!isPlainObject(value))
-        invalid(contract, path, "a plain object");
-    return value;
-}
-function required(source, key, contract, path) {
-    if (!Object.hasOwn(source, key))
-        invalid(contract, path, "present");
-    return source[key];
-}
-function booleanValue(value, contract, path) {
-    if (typeof value !== "boolean")
-        invalid(contract, path, "a boolean");
-    return value;
-}
-function stringValue(value, contract, path, nonEmpty = false) {
-    if (typeof value !== "string" || (nonEmpty && !value.trim())) {
-        invalid(contract, path, nonEmpty ? "a non-empty string" : "a string");
-    }
+        throw new TypeError(`${name} must be a plain object`);
     return value;
 }
-function finiteNumber(value, contract, path) {
-    if (typeof value !== "number" || !Number.isFinite(value)) {
-        invalid(contract, path, "a finite number");
-    }
+function string(value, name, allowEmpty = false) {
+    if (typeof value !== "string" || (!allowEmpty && !value.trim()))
+        throw new TypeError(`${name} must be a string${allowEmpty ? "" : " with content"}`);
     return value;
 }
-function positiveSafeInteger(value, contract, path) {
-    if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) {
-        invalid(contract, path, "a positive safe integer");
-    }
-    return value;
-}
-function nonNegativeSafeInteger(value, contract, path) {
-    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
-        invalid(contract, path, "a non-negative safe integer");
-    }
+function boolean(value, name) {
+    if (typeof value !== "boolean")
+        throw new TypeError(`${name} must be a boolean`);
     return value;
 }
-function portValue(value, contract, path) {
-    if (typeof value !== "number" || !Number.isInteger(value) || value < 1 || value > 65_535) {
-        invalid(contract, path, "an integer port from 1 to 65535");
-    }
+function integer(value, name, min = 0, max = Number.MAX_SAFE_INTEGER) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < min || value > max)
+        throw new TypeError(`${name} must be an integer from ${min} to ${max}`);
     return value;
 }
-function timestampValue(value, contract, path) {
+function timestamp(value, name) {
     if (!isCanonicalIsoTimestamp(value))
-        invalid(contract, path, "a canonical ISO timestamp");
+        throw new TypeError(`${name} must be a canonical timestamp`);
     return value;
 }
-function optionalString(source, key, contract, path) {
-    return Object.hasOwn(source, key) ? stringValue(source[key], contract, path) : undefined;
+function optionalString(source, key) {
+    return Object.hasOwn(source, key) ? string(source[key], key, true) : undefined;
 }
-function knownFlag(source, key, contract, path) {
-    return Object.hasOwn(source, key) ? booleanValue(source[key], contract, path) : false;
-}
-function parseSystemProxyState(value, contract, path) {
-    const source = objectValue(value, contract, path);
-    const server = optionalString(source, "server", contract, `${path}.server`);
-    const details = optionalString(source, "details", contract, `${path}.details`);
-    return {
-        supported: booleanValue(required(source, "supported", contract, `${path}.supported`), contract, `${path}.supported`),
-        enabled: booleanValue(required(source, "enabled", contract, `${path}.enabled`), contract, `${path}.enabled`),
-        ...(server !== undefined ? { server } : {}),
-        ...(details !== undefined ? { details } : {}),
-    };
+export function apiErrorBody(code, message) {
+    return { error: { code, message } };
 }
-function parseCoreState(value, contract) {
-    const source = objectValue(value, contract, "core");
-    const pid = Object.hasOwn(source, "pid")
-        ? positiveSafeInteger(source.pid, contract, "core.pid")
-        : undefined;
-    const startedAt = Object.hasOwn(source, "startedAt")
-        ? timestampValue(source.startedAt, contract, "core.startedAt")
-        : undefined;
-    const healthy = Object.hasOwn(source, "healthy")
-        ? booleanValue(source.healthy, contract, "core.healthy")
-        : undefined;
-    const version = optionalString(source, "version", contract, "core.version");
-    const tunActive = Object.hasOwn(source, "tunActive")
-        ? booleanValue(source.tunActive, contract, "core.tunActive")
-        : undefined;
-    return {
-        running: booleanValue(required(source, "running", contract, "core.running"), contract, "core.running"),
-        ...(pid !== undefined ? { pid } : {}),
-        ...(startedAt !== undefined ? { startedAt } : {}),
-        ...(healthy !== undefined ? { healthy } : {}),
-        ...(version !== undefined ? { version } : {}),
-        ...(tunActive !== undefined ? { tunActive } : {}),
-    };
+export function parseApiErrorBody(value) {
+    if (!isPlainObject(value) ||
+        !isPlainObject(value.error) ||
+        typeof value.error.code !== "string" ||
+        typeof value.error.message !== "string")
+        return undefined;
+    return { code: value.error.code, message: value.error.message };
 }
-export function parsePublicSettings(value) {
-    const contract = "sashd settings";
-    const source = objectValue(value, contract, "settings");
+export function parseHealthInfo(value) {
+    const source = object(value, "health");
     return {
-        mixedPort: portValue(required(source, "mixedPort", contract, "settings.mixedPort"), contract, "settings.mixedPort"),
-        controller: stringValue(required(source, "controller", contract, "settings.controller"), contract, "settings.controller", true),
-        tun: booleanValue(required(source, "tun", contract, "settings.tun"), contract, "settings.tun"),
-        allowLan: booleanValue(required(source, "allowLan", contract, "settings.allowLan"), contract, "settings.allowLan"),
-        daemonPort: portValue(required(source, "daemonPort", contract, "settings.daemonPort"), contract, "settings.daemonPort"),
-        systemProxy: booleanValue(required(source, "systemProxy", contract, "settings.systemProxy"), contract, "settings.systemProxy"),
+        token: string(source.token, "token"),
+        pid: integer(source.pid, "pid", 1),
+        startedAt: timestamp(source.startedAt, "startedAt"),
     };
 }
-function parseProfileMeta(value, contract, path) {
-    const source = objectValue(value, contract, path);
-    const subInfoValue = Object.hasOwn(source, "subInfo")
-        ? objectValue(source.subInfo, contract, `${path}.subInfo`)
-        : undefined;
-    const subInfo = subInfoValue
-        ? {
-            upload: finiteNumber(required(subInfoValue, "upload", contract, `${path}.subInfo.upload`), contract, `${path}.subInfo.upload`),
-            download: finiteNumber(required(subInfoValue, "download", contract, `${path}.subInfo.download`), contract, `${path}.subInfo.download`),
-            total: finiteNumber(required(subInfoValue, "total", contract, `${path}.subInfo.total`), contract, `${path}.subInfo.total`),
-            ...(Object.hasOwn(subInfoValue, "expire")
-                ? {
-                    expire: finiteNumber(subInfoValue.expire, contract, `${path}.subInfo.expire`),
-                }
-                : {}),
-        }
-        : undefined;
-    const homePage = optionalString(source, "homePage", contract, `${path}.homePage`);
-    const lastError = optionalString(source, "lastError", contract, `${path}.lastError`);
+export function parseWebBootstrapInfo(value) {
+    const source = object(value, "bootstrap");
     return {
-        id: stringValue(required(source, "id", contract, `${path}.id`), contract, `${path}.id`, true),
-        name: stringValue(required(source, "name", contract, `${path}.name`), contract, `${path}.name`),
-        url: stringValue(required(source, "url", contract, `${path}.url`), contract, `${path}.url`),
-        intervalHours: nonNegativeSafeInteger(required(source, "intervalHours", contract, `${path}.intervalHours`), contract, `${path}.intervalHours`),
-        createdAt: timestampValue(required(source, "createdAt", contract, `${path}.createdAt`), contract, `${path}.createdAt`),
-        updatedAt: timestampValue(required(source, "updatedAt", contract, `${path}.updatedAt`), contract, `${path}.updatedAt`),
-        ...(subInfo !== undefined ? { subInfo } : {}),
-        ...(homePage !== undefined ? { homePage } : {}),
-        ...(lastError !== undefined ? { lastError } : {}),
+        token: string(source.token, "token"),
+        expiresAt: timestamp(source.expiresAt, "expiresAt"),
     };
 }
-function optionalProxyCount(source, contract, path) {
-    return Object.hasOwn(source, "proxyCount")
-        ? { proxyCount: nonNegativeSafeInteger(source.proxyCount, contract, `${path}.proxyCount`) }
-        : {};
-}
-export function parseHealthInfo(value) {
-    const contract = "sashd health";
-    const source = objectValue(value, contract, "response");
+export function parseWebSessionInfo(value) {
+    const source = object(value, "session");
     return {
-        token: stringValue(required(source, "token", contract, "token"), contract, "token", true),
-        pid: positiveSafeInteger(required(source, "pid", contract, "pid"), contract, "pid"),
-        startedAt: timestampValue(required(source, "startedAt", contract, "startedAt"), contract, "startedAt"),
+        token: string(source.token, "token"),
+        daemonToken: string(source.daemonToken, "daemonToken"),
     };
 }
 export function parseCoreStartResult(value) {
-    const contract = "sashd core start";
-    const source = objectValue(value, contract, "response");
-    const version = optionalString(source, "version", contract, "version");
-    const tunActive = Object.hasOwn(source, "tunActive")
-        ? booleanValue(source.tunActive, contract, "tunActive")
-        : undefined;
-    return {
-        pid: positiveSafeInteger(required(source, "pid", contract, "pid"), contract, "pid"),
-        ...(version !== undefined ? { version } : {}),
-        ...(tunActive !== undefined ? { tunActive } : {}),
-    };
-}
-export function parseCoreReloadResult(value) {
-    const contract = "sashd core reload";
-    const source = objectValue(value, contract, "response");
-    const sourceKind = stringValue(required(source, "source", contract, "source"), contract, "source");
-    if (sourceKind !== "subscription" && sourceKind !== "default") {
-        invalid(contract, "source", `"subscription" or "default"`);
-    }
-    return {
-        proxyCount: nonNegativeSafeInteger(required(source, "proxyCount", contract, "proxyCount"), contract, "proxyCount"),
-        source: sourceKind,
-    };
+    const source = object(value, "Core start");
+    const version = optionalString(source, "version");
+    return { pid: integer(source.pid, "pid", 1), ...(version !== undefined ? { version } : {}) };
 }
-export function parseShutdownResult(value) {
-    const contract = "sashd shutdown";
-    const source = objectValue(value, contract, "response");
-    return {
-        coreWasRunning: booleanValue(required(source, "coreWasRunning", contract, "coreWasRunning"), contract, "coreWasRunning"),
-    };
+export function parseCoreUpdateResponse(value) {
+    return { version: string(object(value, "Core update").version, "version") };
 }
-export function parseSystemProxyStatusResponse(value) {
-    const contract = "sashd system proxy";
-    const source = objectValue(value, contract, "response");
-    const state = parseSystemProxyState(source, contract, "response");
-    const queryError = optionalString(source, "queryError", contract, "queryError");
+export function parsePublicSettings(value) {
+    const source = object(value, "settings");
     return {
-        desired: booleanValue(required(source, "desired", contract, "desired"), contract, "desired"),
-        applied: booleanValue(required(source, "applied", contract, "applied"), contract, "applied"),
-        ...state,
-        appliedKnown: knownFlag(source, "appliedKnown", contract, "appliedKnown"),
-        stateKnown: knownFlag(source, "stateKnown", contract, "stateKnown"),
-        ...(queryError !== undefined ? { queryError } : {}),
+        mixedPort: integer(source.mixedPort, "mixedPort", 1, 65535),
+        controller: string(source.controller, "controller"),
+        allowLan: boolean(source.allowLan, "allowLan"),
+        daemonPort: integer(source.daemonPort, "daemonPort", 1, 65535),
+        systemProxy: boolean(source.systemProxy, "systemProxy"),
     };
 }
-export function parseSettingsPatch(value, direction = "response") {
-    const subject = `sashd settings patch ${direction}`;
-    const fail = (path, expected) => {
-        throw new TypeError(`${subject} is invalid: ${path} must be ${expected}`);
-    };
-    if (!isPlainObject(value))
-        fail("body", "a plain object");
-    const source = value;
-    const allowed = new Set([
-        "mixedPort",
-        "allowLan",
-        "tun",
-        "systemProxy",
-        "daemonPort",
-        "daemonSecret",
-    ]);
+export function parseSettingsPatch(value) {
+    const source = object(value, "settings patch");
     for (const key of Object.keys(source)) {
-        if (!allowed.has(key))
-            fail(key, "a known settings patch field");
+        if (!["mixedPort", "allowLan", "systemProxy"].includes(key))
+            throw new TypeError(`Unknown settings field: ${key}`);
     }
-    const portField = (key) => {
-        if (!Object.hasOwn(source, key))
-            return undefined;
-        const field = source[key];
-        if (typeof field !== "number" || !Number.isInteger(field) || field < 1 || field > 65_535) {
-            return fail(key, "an integer port from 1 to 65535");
-        }
-        return field;
-    };
-    const boolField = (key) => {
-        if (!Object.hasOwn(source, key))
-            return undefined;
-        const field = source[key];
-        if (typeof field !== "boolean")
-            return fail(key, "a boolean");
-        return field;
+    return {
+        ...(Object.hasOwn(source, "mixedPort")
+            ? { mixedPort: integer(source.mixedPort, "mixedPort", 1, 65535) }
+            : {}),
+        ...(Object.hasOwn(source, "allowLan")
+            ? { allowLan: boolean(source.allowLan, "allowLan") }
+            : {}),
+        ...(Object.hasOwn(source, "systemProxy")
+            ? { systemProxy: boolean(source.systemProxy, "systemProxy") }
+            : {}),
     };
-    const patch = {};
-    const mixedPort = portField("mixedPort");
-    if (mixedPort !== undefined)
-        patch.mixedPort = mixedPort;
-    const daemonPort = portField("daemonPort");
-    if (daemonPort !== undefined)
-        patch.daemonPort = daemonPort;
-    const allowLan = boolField("allowLan");
-    if (allowLan !== undefined)
-        patch.allowLan = allowLan;
-    const tun = boolField("tun");
-    if (tun !== undefined)
-        patch.tun = tun;
-    const systemProxy = boolField("systemProxy");
-    if (systemProxy !== undefined)
-        patch.systemProxy = systemProxy;
-    if (Object.hasOwn(source, "daemonSecret")) {
-        const secret = source.daemonSecret;
-        if (typeof secret !== "string" || !secret.trim()) {
-            fail("daemonSecret", "a non-empty string");
-        }
-        patch.daemonSecret = secret;
-    }
-    return patch;
 }
 export function parseSettingsWriteResult(value) {
-    const contract = "sashd settings write";
-    const source = objectValue(value, contract, "response");
+    const source = object(value, "settings write");
     return {
-        restartRequired: booleanValue(required(source, "restartRequired", contract, "restartRequired"), contract, "restartRequired"),
-        settings: parsePublicSettings(required(source, "settings", contract, "settings")),
+        restartRequired: boolean(source.restartRequired, "restartRequired"),
+        settings: parsePublicSettings(source.settings),
     };
 }
-export function parseSettingsFileContent(value) {
-    const contract = "sashd settings file";
-    const source = objectValue(value, contract, "response");
+function parseSystemProxyState(value) {
+    const source = object(value, "system proxy");
+    const server = optionalString(source, "server");
+    const details = optionalString(source, "details");
     return {
-        content: stringValue(required(source, "content", contract, "content"), contract, "content"),
+        supported: boolean(source.supported, "supported"),
+        enabled: boolean(source.enabled, "enabled"),
+        ...(server !== undefined ? { server } : {}),
+        ...(details !== undefined ? { details } : {}),
     };
 }
-export function parseProfilesIndex(value) {
-    const contract = "sashd profiles";
-    const source = objectValue(value, contract, "response");
-    const activeValue = required(source, "activeId", contract, "activeId");
-    const profilesValue = required(source, "profiles", contract, "profiles");
-    if (!Array.isArray(profilesValue))
-        invalid(contract, "profiles", "an array");
-    return {
-        activeId: activeValue === null ? null : stringValue(activeValue, contract, "activeId", true),
-        profiles: profilesValue.map((entry, index) => parseProfileMeta(entry, contract, `profiles[${index}]`)),
+export function parseSystemProxyStatusResponse(value) {
+    const source = object(value, "system proxy status");
+    const queryError = optionalString(source, "queryError");
+    return {
+        ...parseSystemProxyState(source),
+        desired: boolean(source.desired, "desired"),
+        applied: boolean(source.applied, "applied"),
+        appliedKnown: boolean(source.appliedKnown, "appliedKnown"),
+        stateKnown: boolean(source.stateKnown, "stateKnown"),
+        ...(queryError !== undefined ? { queryError } : {}),
     };
 }
 export function parseProfileActionResponse(value) {
-    const contract = "sashd profile action";
-    const source = objectValue(value, contract, "response");
+    const source = object(value, "profile action");
     return {
-        profile: parseProfileMeta(required(source, "profile", contract, "profile"), contract, "profile"),
-        activated: booleanValue(required(source, "activated", contract, "activated"), contract, "activated"),
-        ...optionalProxyCount(source, contract, "response"),
+        profile: parseProfileMeta(source.profile),
+        activated: boolean(source.activated, "activated"),
     };
 }
 export function parseProfileUpdateResponse(value) {
-    const contract = "sashd profile update";
-    const source = objectValue(value, contract, "response");
-    return {
-        profile: parseProfileMeta(required(source, "profile", contract, "profile"), contract, "profile"),
-        ...optionalProxyCount(source, contract, "response"),
-    };
-}
-export function parseProfilesUpdateAllResponse(value) {
-    const contract = "sashd profiles update-all";
-    const source = objectValue(value, contract, "response");
-    const failedValue = required(source, "failed", contract, "failed");
-    if (!Array.isArray(failedValue))
-        invalid(contract, "failed", "an array");
-    return {
-        updated: nonNegativeSafeInteger(required(source, "updated", contract, "updated"), contract, "updated"),
-        failed: failedValue.map((entry, index) => {
-            const path = `failed[${index}]`;
-            const failure = objectValue(entry, contract, path);
-            return {
-                id: stringValue(required(failure, "id", contract, `${path}.id`), contract, `${path}.id`),
-                name: stringValue(required(failure, "name", contract, `${path}.name`), contract, `${path}.name`),
-                error: stringValue(required(failure, "error", contract, `${path}.error`), contract, `${path}.error`),
-            };
-        }),
-        ...optionalProxyCount(source, contract, "response"),
-    };
+    return { profile: parseProfileMeta(object(value, "profile").profile) };
 }
+export { parseProfileUpdateResponse as parseProfileRenameResponse };
 export function parseProfileContentResponse(value) {
-    const contract = "sashd profile content";
-    const source = objectValue(value, contract, "response");
+    const source = object(value, "profile content");
     return {
-        name: stringValue(required(source, "name", contract, "name"), contract, "name"),
-        content: stringValue(required(source, "content", contract, "content"), contract, "content"),
+        name: string(source.name, "name"),
+        content: string(source.content, "content", true),
+        revision: integer(source.revision, "revision", 1),
     };
 }
 export function parseProfileActivateResponse(value) {
-    const contract = "sashd profile activate";
-    const source = objectValue(value, contract, "response");
-    const activeValue = required(source, "activeId", contract, "activeId");
+    const source = object(value, "profile selection");
     return {
-        activeId: activeValue === null ? null : stringValue(activeValue, contract, "activeId", true),
-        proxyCount: nonNegativeSafeInteger(required(source, "proxyCount", contract, "proxyCount"), contract, "proxyCount"),
+        activeId: source.activeId === null ? null : string(source.activeId, "activeId"),
+        proxyCount: integer(source.proxyCount, "proxyCount"),
     };
 }
 export function parseProfileRemoveResponse(value) {
-    const contract = "sashd profile remove";
-    const source = objectValue(value, contract, "response");
-    return {
-        wasActive: booleanValue(required(source, "wasActive", contract, "wasActive"), contract, "wasActive"),
-        ...optionalProxyCount(source, contract, "response"),
-    };
+    return { wasActive: boolean(object(value, "profile removal").wasActive, "wasActive") };
 }
-export function parseProfileRenameResponse(value) {
-    const contract = "sashd profile rename";
-    const source = objectValue(value, contract, "response");
+export function parseProfilesUpdateAllResponse(value) {
+    const source = object(value, "profiles update");
+    if (!Array.isArray(source.failed))
+        throw new TypeError("failed must be an array");
     return {
-        profile: parseProfileMeta(required(source, "profile", contract, "profile"), contract, "profile"),
+        updated: integer(source.updated, "updated"),
+        failed: source.failed.map((item) => {
+            const failure = object(item, "profile error");
+            return {
+                id: string(failure.id, "id"),
+                name: string(failure.name, "name"),
+                error: string(failure.error, "error"),
+            };
+        }),
     };
 }
 export function parseDaemonStatus(value) {
-    const contract = "sashd status";
-    const source = objectValue(value, contract, "response");
-    const daemonSource = objectValue(required(source, "daemon", contract, "daemon"), contract, "daemon");
-    const revisionsSource = objectValue(required(source, "revisions", contract, "revisions"), contract, "revisions");
-    const proxySource = objectValue(required(source, "systemProxy", contract, "systemProxy"), contract, "systemProxy");
-    const actual = Object.hasOwn(proxySource, "actual")
-        ? parseSystemProxyState(proxySource.actual, contract, "systemProxy.actual")
-        : undefined;
-    const queryError = optionalString(proxySource, "queryError", contract, "systemProxy.queryError");
-    const activeValue = required(source, "activeProfile", contract, "activeProfile");
-    const activeProfile = activeValue === null
+    const source = object(value, "status");
+    const daemon = object(source.daemon, "daemon");
+    const revisions = object(source.revisions, "revisions");
+    const core = object(source.core, "core");
+    const proxy = object(source.systemProxy, "systemProxy");
+    const configuration = object(source.configuration, "configuration");
+    const selected = source.activeProfile === null ? null : object(source.activeProfile, "activeProfile");
+    const applied = configuration.appliedProfile === null
         ? null
-        : (() => {
-            const active = objectValue(activeValue, contract, "activeProfile");
-            return {
-                id: stringValue(required(active, "id", contract, "activeProfile.id"), contract, "activeProfile.id", true),
-                name: stringValue(required(active, "name", contract, "activeProfile.name"), contract, "activeProfile.name"),
-                url: stringValue(required(active, "url", contract, "activeProfile.url"), contract, "activeProfile.url"),
-            };
-        })();
+        : object(configuration.appliedProfile, "appliedProfile");
+    const appliedSettings = configuration.appliedSettings === null
+        ? null
+        : object(configuration.appliedSettings, "appliedSettings");
+    const version = optionalString(core, "version");
+    const queryError = optionalString(proxy, "queryError");
     return {
         daemon: {
-            pid: positiveSafeInteger(required(daemonSource, "pid", contract, "daemon.pid"), contract, "daemon.pid"),
-            startedAt: timestampValue(required(daemonSource, "startedAt", contract, "daemon.startedAt"), contract, "daemon.startedAt"),
-            port: portValue(required(daemonSource, "port", contract, "daemon.port"), contract, "daemon.port"),
+            pid: integer(daemon.pid, "daemon.pid", 1),
+            bootId: string(daemon.bootId, "daemon.bootId"),
+            startedAt: timestamp(daemon.startedAt, "daemon.startedAt"),
+            port: integer(daemon.port, "daemon.port", 1, 65535),
         },
         revisions: {
-            profiles: nonNegativeSafeInteger(required(revisionsSource, "profiles", contract, "revisions.profiles"), contract, "revisions.profiles"),
+            profiles: integer(revisions.profiles, "revisions.profiles"),
+            runtime: integer(revisions.runtime, "revisions.runtime"),
+        },
+        core: {
+            running: boolean(core.running, "core.running"),
+            ...(Object.hasOwn(core, "pid") ? { pid: integer(core.pid, "core.pid", 1) } : {}),
+            ...(Object.hasOwn(core, "startedAt")
+                ? { startedAt: timestamp(core.startedAt, "core.startedAt") }
+                : {}),
+            ...(Object.hasOwn(core, "healthy") ? { healthy: boolean(core.healthy, "core.healthy") } : {}),
+            ...(version !== undefined ? { version } : {}),
+        },
+        configuration: {
+            pending: boolean(configuration.pending, "configuration.pending"),
+            appliedProfile: applied
+                ? {
+                    id: string(applied.id, "appliedProfile.id"),
+                    revision: integer(applied.revision, "appliedProfile.revision", 1),
+                    name: string(applied.name, "appliedProfile.name"),
+                    url: string(applied.url, "appliedProfile.url", true),
+                }
+                : null,
+            appliedSettings: appliedSettings
+                ? {
+                    mixedPort: integer(appliedSettings.mixedPort, "appliedSettings.mixedPort", 1, 65535),
+                    allowLan: boolean(appliedSettings.allowLan, "appliedSettings.allowLan"),
+                }
+                : null,
         },
-        core: parseCoreState(required(source, "core", contract, "core"), contract),
         systemProxy: {
-            desired: booleanValue(required(proxySource, "desired", contract, "systemProxy.desired"), contract, "systemProxy.desired"),
-            applied: booleanValue(required(proxySource, "applied", contract, "systemProxy.applied"), contract, "systemProxy.applied"),
-            ...(actual !== undefined ? { actual } : {}),
-            appliedKnown: knownFlag(proxySource, "appliedKnown", contract, "systemProxy.appliedKnown"),
-            stateKnown: knownFlag(proxySource, "stateKnown", contract, "systemProxy.stateKnown"),
+            desired: boolean(proxy.desired, "systemProxy.desired"),
+            applied: boolean(proxy.applied, "systemProxy.applied"),
+            appliedKnown: boolean(proxy.appliedKnown, "systemProxy.appliedKnown"),
+            stateKnown: boolean(proxy.stateKnown, "systemProxy.stateKnown"),
+            ...(Object.hasOwn(proxy, "actual") ? { actual: parseSystemProxyState(proxy.actual) } : {}),
             ...(queryError !== undefined ? { queryError } : {}),
         },
-        settings: parsePublicSettings(required(source, "settings", contract, "settings")),
-        activeProfile,
+        settings: parsePublicSettings(source.settings),
+        activeProfile: selected
+            ? {
+                id: string(selected.id, "activeProfile.id"),
+                name: string(selected.name, "activeProfile.name"),
+                url: string(selected.url, "activeProfile.url", true),
+            }
+            : null,
     };
 }