@voltro/plugin-releases 0.0.0-stage → 0.83.0

package/dist/rollout-CGRKMTfv.js

@@ -0,0 +1,55 @@
+//#region src/rollout.ts
+var e = (e) => {
+	let t = /^v?(\d+)(?:\.(\d+))?(?:\.(\d+))?(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/.exec(e.trim());
+	return t ? {
+		parts: [
+			Number(t[1]),
+			Number(t[2] ?? 0),
+			Number(t[3] ?? 0)
+		],
+		pre: t[4] ? t[4].split(".") : []
+	} : null;
+}, t = (t, n) => {
+	let r = e(t), i = e(n);
+	if (!r || !i) return t.localeCompare(n);
+	for (let e = 0; e < 3; e++) {
+		let t = (r.parts[e] ?? 0) - (i.parts[e] ?? 0);
+		if (t !== 0) return t < 0 ? -1 : 1;
+	}
+	if (r.pre.length === 0 && i.pre.length === 0) return 0;
+	if (r.pre.length === 0) return 1;
+	if (i.pre.length === 0) return -1;
+	for (let e = 0; e < Math.max(r.pre.length, i.pre.length); e++) {
+		let t = r.pre[e], n = i.pre[e];
+		if (t === void 0) return -1;
+		if (n === void 0) return 1;
+		let a = Number(t), o = Number(n), s = !Number.isNaN(a) && !Number.isNaN(o) ? a - o : t.localeCompare(n);
+		if (s !== 0) return s < 0 ? -1 : 1;
+	}
+	return 0;
+}, n = (e, n) => t(e, n) > 0, r = (e) => {
+	let t = 2166136261;
+	for (let n = 0; n < e.length; n++) t ^= e.charCodeAt(n), t = Math.imul(t, 16777619) >>> 0;
+	return t >>> 0;
+}, i = (e, t) => r(`${t}:${e}`) % 100, a = (e) => {
+	if (e.releaseCohorts && e.installCohorts) {
+		for (let t of e.installCohorts) if (e.releaseCohorts.includes(t)) return !0;
+	}
+	return e.percent >= 100 ? !0 : e.percent <= 0 ? !1 : i(e.installId, e.salt) < e.percent;
+}, o = (e, r) => {
+	let i = e.minSupportedVersion !== null && t(r.version, e.minSupportedVersion) < 0, o = e.latestVersion !== null && n(e.latestVersion, r.version) && a({
+		installId: r.installId,
+		salt: e.rolloutSalt ?? "",
+		percent: e.rolloutPercent,
+		...r.cohorts === void 0 ? {} : { installCohorts: r.cohorts },
+		releaseCohorts: e.cohorts
+	}), s = Object.entries(e.killSwitches).filter(([, e]) => e.some((e) => t(e, r.version) === 0)).map(([e]) => e);
+	return {
+		blocked: i,
+		updateAvailable: o,
+		latestVersion: e.latestVersion,
+		killed: s
+	};
+}, s = (e) => [...e].sort((e, n) => t(n, e));
+//#endregion
+export { e as a, n as i, o as n, i as o, a as r, s, t };

package/dist/rpc-U7ytx6SC.js

@@ -0,0 +1,217 @@
+import { ReleaseNotFound as e, ReleaseRefused as t } from "./errors.js";
+import { Schema as n } from "effect";
+import { defineMutation as r, defineQuery as i } from "@voltro/protocol";
+//#region src/names.ts
+var a = "_voltro_release_apps", o = "_voltro_release_channels", s = "_voltro_releases", c = "_voltro_release_artifacts", l = "_voltro_release_events", u = "@voltro/plugin-releases", d = "releases:manage", f = n.Struct({
+	app: n.String,
+	channel: n.String,
+	latestVersion: n.NullOr(n.String),
+	minSupportedVersion: n.NullOr(n.String),
+	killSwitches: n.Record({
+		key: n.String,
+		value: n.Array(n.String)
+	}),
+	rolloutPercent: n.Number,
+	rolloutSalt: n.NullOr(n.String),
+	cohorts: n.NullOr(n.Array(n.String))
+}), p = i({
+	name: "releases.policy",
+	input: n.Struct({
+		app: n.String,
+		channel: n.String
+	}),
+	output: f,
+	source: [o, s],
+	openAccess: "the release policy of a channel is what every client — signed in or not — must evaluate before it may continue; it carries versions and feature keys, no data"
+}), m = n.Struct({
+	id: n.String,
+	version: n.String,
+	buildId: n.NullOr(n.String),
+	state: n.String,
+	rolloutPercent: n.Number,
+	channel: n.String,
+	createdAt: n.String,
+	artifacts: n.Number,
+	signed: n.Boolean
+}), h = i({
+	name: "releases.list",
+	input: n.Struct({ app: n.String }),
+	output: n.Array(m),
+	source: [s],
+	guards: [{ scope: d }]
+}), g = r({
+	name: "releases.registerApp",
+	input: n.Struct({
+		app: n.String,
+		platform: n.Literal("web", "ios", "android", "macos", "windows", "linux"),
+		shell: n.Literal("pwa", "expo", "tauri", "electron"),
+		bundleId: n.optional(n.String),
+		updaterPublicKey: n.optional(n.String),
+		runtimeVersion: n.optional(n.String),
+		channels: n.optional(n.Array(n.String))
+	}),
+	output: n.Struct({
+		id: n.String,
+		created: n.Boolean
+	}),
+	error: t,
+	guards: [{ scope: d }]
+}), _ = r({
+	name: "releases.create",
+	input: n.Struct({
+		app: n.String,
+		channel: n.String,
+		version: n.String,
+		buildId: n.optional(n.String),
+		notes: n.optional(n.String),
+		cohorts: n.optional(n.Array(n.String))
+	}),
+	output: n.Struct({ id: n.String }),
+	error: n.Union(t, e),
+	guards: [{ scope: d }]
+}), v = r({
+	name: "releases.upload",
+	input: n.Struct({
+		releaseId: n.String,
+		kind: n.String,
+		target: n.optional(n.String),
+		url: n.String,
+		sha256: n.String,
+		size: n.Number,
+		signature: n.optional(n.String),
+		notarized: n.optional(n.Boolean),
+		assetKey: n.optional(n.String),
+		contentType: n.optional(n.String)
+	}),
+	output: n.Struct({ id: n.String }),
+	error: n.Union(t, e),
+	guards: [{ scope: d }]
+}), y = r({
+	name: "releases.promote",
+	input: n.Struct({
+		app: n.String,
+		version: n.String,
+		to: n.String,
+		rolloutPercent: n.optional(n.Number)
+	}),
+	output: n.Struct({
+		channel: n.String,
+		version: n.String,
+		rolloutPercent: n.Number
+	}),
+	error: n.Union(t, e),
+	guards: [{ scope: d }]
+}), b = r({
+	name: "releases.rollout",
+	input: n.Struct({
+		app: n.String,
+		channel: n.String,
+		percent: n.Number
+	}),
+	output: n.Struct({
+		version: n.String,
+		rolloutPercent: n.Number
+	}),
+	error: n.Union(t, e),
+	guards: [{ scope: d }]
+}), x = r({
+	name: "releases.rollback",
+	input: n.Struct({
+		app: n.String,
+		channel: n.String,
+		reason: n.String
+	}),
+	output: n.Struct({ version: n.NullOr(n.String) }),
+	error: n.Union(t, e),
+	guards: [{ scope: d }]
+}), S = r({
+	name: "releases.setPolicy",
+	input: n.Struct({
+		app: n.String,
+		channel: n.String,
+		minSupportedVersion: n.optional(n.NullOr(n.String)),
+		killSwitches: n.optional(n.Record({
+			key: n.String,
+			value: n.Array(n.String)
+		})),
+		reason: n.String
+	}),
+	output: f,
+	error: n.Union(t, e),
+	guards: [{ scope: d }]
+}), C = [
+	{
+		tag: "releases.policy",
+		kind: "query",
+		import: {
+			module: "@voltro/plugin-releases/rpc",
+			name: "policyDescriptor"
+		}
+	},
+	{
+		tag: "releases.list",
+		kind: "query",
+		import: {
+			module: "@voltro/plugin-releases/rpc",
+			name: "listDescriptor"
+		}
+	},
+	{
+		tag: "releases.registerApp",
+		kind: "mutation",
+		import: {
+			module: "@voltro/plugin-releases/rpc",
+			name: "registerAppDescriptor"
+		}
+	},
+	{
+		tag: "releases.create",
+		kind: "mutation",
+		import: {
+			module: "@voltro/plugin-releases/rpc",
+			name: "createDescriptor"
+		}
+	},
+	{
+		tag: "releases.upload",
+		kind: "mutation",
+		import: {
+			module: "@voltro/plugin-releases/rpc",
+			name: "uploadDescriptor"
+		}
+	},
+	{
+		tag: "releases.promote",
+		kind: "mutation",
+		import: {
+			module: "@voltro/plugin-releases/rpc",
+			name: "promoteDescriptor"
+		}
+	},
+	{
+		tag: "releases.rollout",
+		kind: "mutation",
+		import: {
+			module: "@voltro/plugin-releases/rpc",
+			name: "rolloutDescriptor"
+		}
+	},
+	{
+		tag: "releases.rollback",
+		kind: "mutation",
+		import: {
+			module: "@voltro/plugin-releases/rpc",
+			name: "rollbackDescriptor"
+		}
+	},
+	{
+		tag: "releases.setPolicy",
+		kind: "mutation",
+		import: {
+			module: "@voltro/plugin-releases/rpc",
+			name: "setPolicyDescriptor"
+		}
+	}
+];
+//#endregion
+export { c as _, _ as a, y as c, x as d, b as f, a as g, s as h, m as i, g as l, v as m, f as n, h as o, S as p, d as r, p as s, u as t, C as u, o as v, l as y };

package/dist/rpc.d.ts

@@ -0,0 +1,175 @@
+import { MutationProcedureDescriptor } from '@voltro/protocol';
+import { PluginRpcClientDescriptor } from '@voltro/protocol';
+import { QueryProcedureDescriptor } from '@voltro/protocol';
+import { Schema } from 'effect';
+
+export declare const BASE_NAME = "@voltro/plugin-releases";
+
+export declare const createDescriptor: MutationProcedureDescriptor<"releases.create", Schema.Struct<{
+    app: typeof Schema.String;
+    channel: typeof Schema.String;
+    version: typeof Schema.String;
+    buildId: Schema.optional<typeof Schema.String>;
+    notes: Schema.optional<typeof Schema.String>;
+    cohorts: Schema.optional<Schema.Array$<typeof Schema.String>>;
+}>, Schema.Struct<{
+    id: typeof Schema.String;
+}>, Schema.Union<[typeof ReleaseRefused, typeof ReleaseNotFound]>>;
+
+export declare const listDescriptor: QueryProcedureDescriptor<"releases.list", Schema.Struct<{
+    app: typeof Schema.String;
+}>, Schema.Array$<Schema.Struct<{
+    id: typeof Schema.String;
+    version: typeof Schema.String;
+    buildId: Schema.NullOr<typeof Schema.String>;
+    state: typeof Schema.String;
+    rolloutPercent: typeof Schema.Number;
+    channel: typeof Schema.String;
+    createdAt: typeof Schema.String;
+    artifacts: typeof Schema.Number;
+    signed: typeof Schema.Boolean;
+}>>, typeof Schema.Never>;
+
+/** The reactive policy every client subscribes to. Table-sourced, so a
+ *  promote, rollout change or policy edit reaches every live client. */
+export declare const policyDescriptor: QueryProcedureDescriptor<"releases.policy", Schema.Struct<{
+    app: typeof Schema.String;
+    channel: typeof Schema.String;
+}>, Schema.Struct<{
+    app: typeof Schema.String;
+    channel: typeof Schema.String;
+    latestVersion: Schema.NullOr<typeof Schema.String>;
+    minSupportedVersion: Schema.NullOr<typeof Schema.String>;
+    killSwitches: Schema.Record$<typeof Schema.String, Schema.Array$<typeof Schema.String>>;
+    rolloutPercent: typeof Schema.Number;
+    rolloutSalt: Schema.NullOr<typeof Schema.String>;
+    cohorts: Schema.NullOr<Schema.Array$<typeof Schema.String>>;
+}>, typeof Schema.Never>;
+
+export declare const PolicySchema: Schema.Struct<{
+    app: typeof Schema.String;
+    channel: typeof Schema.String;
+    latestVersion: Schema.NullOr<typeof Schema.String>;
+    minSupportedVersion: Schema.NullOr<typeof Schema.String>;
+    killSwitches: Schema.Record$<typeof Schema.String, Schema.Array$<typeof Schema.String>>;
+    rolloutPercent: typeof Schema.Number;
+    rolloutSalt: Schema.NullOr<typeof Schema.String>;
+    cohorts: Schema.NullOr<Schema.Array$<typeof Schema.String>>;
+}>;
+
+export declare type PolicyWire = typeof PolicySchema.Type;
+
+export declare const promoteDescriptor: MutationProcedureDescriptor<"releases.promote", Schema.Struct<{
+    app: typeof Schema.String;
+    version: typeof Schema.String;
+    to: typeof Schema.String;
+    rolloutPercent: Schema.optional<typeof Schema.Number>;
+}>, Schema.Struct<{
+    channel: typeof Schema.String;
+    version: typeof Schema.String;
+    rolloutPercent: typeof Schema.Number;
+}>, Schema.Union<[typeof ReleaseRefused, typeof ReleaseNotFound]>>;
+
+/** Register an app target at runtime — what a hosted feed (one api serving
+ *  many projects' apps) needs, where `apps:` in the plugin's config cannot
+ *  know them. Idempotent: a target that exists answers with its id. */
+export declare const registerAppDescriptor: MutationProcedureDescriptor<"releases.registerApp", Schema.Struct<{
+    app: typeof Schema.String;
+    platform: Schema.Literal<["web", "ios", "android", "macos", "windows", "linux"]>;
+    shell: Schema.Literal<["pwa", "expo", "tauri", "electron"]>;
+    bundleId: Schema.optional<typeof Schema.String>;
+    updaterPublicKey: Schema.optional<typeof Schema.String>;
+    runtimeVersion: Schema.optional<typeof Schema.String>;
+    channels: Schema.optional<Schema.Array$<typeof Schema.String>>;
+}>, Schema.Struct<{
+    id: typeof Schema.String;
+    created: typeof Schema.Boolean;
+}>, typeof ReleaseRefused>;
+
+declare class ReleaseNotFound extends ReleaseNotFound_base {
+}
+
+declare const ReleaseNotFound_base: Schema.TaggedErrorClass<ReleaseNotFound, "ReleaseNotFound", {
+    readonly _tag: Schema.tag<"ReleaseNotFound">;
+} & {
+    app: typeof Schema.String;
+    version: Schema.optional<typeof Schema.String>;
+    channel: Schema.optional<typeof Schema.String>;
+}>;
+
+declare class ReleaseRefused extends ReleaseRefused_base {
+}
+
+declare const ReleaseRefused_base: Schema.TaggedErrorClass<ReleaseRefused, "ReleaseRefused", {
+    readonly _tag: Schema.tag<"ReleaseRefused">;
+} & {
+    reason: typeof Schema.String;
+}>;
+
+/** The scope that promotes, rolls out, rolls back and changes policy. */
+export declare const RELEASES_MANAGE_SCOPE = "releases:manage";
+
+export declare const releasesRpcClientImports: ReadonlyArray<PluginRpcClientDescriptor>;
+
+export declare const ReleaseSummarySchema: Schema.Struct<{
+    id: typeof Schema.String;
+    version: typeof Schema.String;
+    buildId: Schema.NullOr<typeof Schema.String>;
+    state: typeof Schema.String;
+    rolloutPercent: typeof Schema.Number;
+    channel: typeof Schema.String;
+    createdAt: typeof Schema.String;
+    artifacts: typeof Schema.Number;
+    signed: typeof Schema.Boolean;
+}>;
+
+export declare const rollbackDescriptor: MutationProcedureDescriptor<"releases.rollback", Schema.Struct<{
+    app: typeof Schema.String;
+    channel: typeof Schema.String;
+    reason: typeof Schema.String;
+}>, Schema.Struct<{
+    version: Schema.NullOr<typeof Schema.String>;
+}>, Schema.Union<[typeof ReleaseRefused, typeof ReleaseNotFound]>>;
+
+export declare const rolloutDescriptor: MutationProcedureDescriptor<"releases.rollout", Schema.Struct<{
+    app: typeof Schema.String;
+    channel: typeof Schema.String;
+    percent: typeof Schema.Number;
+}>, Schema.Struct<{
+    version: typeof Schema.String;
+    rolloutPercent: typeof Schema.Number;
+}>, Schema.Union<[typeof ReleaseRefused, typeof ReleaseNotFound]>>;
+
+export declare const setPolicyDescriptor: MutationProcedureDescriptor<"releases.setPolicy", Schema.Struct<{
+    app: typeof Schema.String;
+    channel: typeof Schema.String;
+    minSupportedVersion: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+    killSwitches: Schema.optional<Schema.Record$<typeof Schema.String, Schema.Array$<typeof Schema.String>>>;
+    reason: typeof Schema.String;
+}>, Schema.Struct<{
+    app: typeof Schema.String;
+    channel: typeof Schema.String;
+    latestVersion: Schema.NullOr<typeof Schema.String>;
+    minSupportedVersion: Schema.NullOr<typeof Schema.String>;
+    killSwitches: Schema.Record$<typeof Schema.String, Schema.Array$<typeof Schema.String>>;
+    rolloutPercent: typeof Schema.Number;
+    rolloutSalt: Schema.NullOr<typeof Schema.String>;
+    cohorts: Schema.NullOr<Schema.Array$<typeof Schema.String>>;
+}>, Schema.Union<[typeof ReleaseRefused, typeof ReleaseNotFound]>>;
+
+export declare const uploadDescriptor: MutationProcedureDescriptor<"releases.upload", Schema.Struct<{
+    releaseId: typeof Schema.String;
+    kind: typeof Schema.String;
+    target: Schema.optional<typeof Schema.String>;
+    url: typeof Schema.String;
+    sha256: typeof Schema.String;
+    size: typeof Schema.Number;
+    signature: Schema.optional<typeof Schema.String>;
+    notarized: Schema.optional<typeof Schema.Boolean>;
+    assetKey: Schema.optional<typeof Schema.String>;
+    contentType: Schema.optional<typeof Schema.String>;
+}>, Schema.Struct<{
+    id: typeof Schema.String;
+}>, Schema.Union<[typeof ReleaseRefused, typeof ReleaseNotFound]>>;
+
+export { }

package/dist/rpc.js

@@ -0,0 +1,2 @@
+import { a as e, c as t, d as n, f as r, i, l as a, m as o, n as s, o as c, p as l, r as u, s as d, t as f, u as p } from "./rpc-U7ytx6SC.js";
+export { f as BASE_NAME, s as PolicySchema, u as RELEASES_MANAGE_SCOPE, i as ReleaseSummarySchema, e as createDescriptor, c as listDescriptor, d as policyDescriptor, t as promoteDescriptor, a as registerAppDescriptor, p as releasesRpcClientImports, n as rollbackDescriptor, r as rolloutDescriptor, l as setPolicyDescriptor, o as uploadDescriptor };

package/dist/web.d.ts

@@ -0,0 +1,73 @@
+import { ReactNode } from 'react';
+
+/** Blocks the app until it updates, when the channel's policy says so. */
+export declare const ForcedUpdateGate: (props: ForcedUpdateGateProps) => ReactNode;
+
+export declare interface ForcedUpdateGateProps extends UseReleasePolicyOptions {
+    readonly children: ReactNode;
+    /** Rendered instead of the app while the version is below the minimum.
+     *  Receives the verdict so it can offer the platform's `updates.apply()`. */
+    readonly fallback: (verdict: PolicyVerdict) => ReactNode;
+}
+
+declare interface PolicyVerdict {
+    /** The client must update before it may continue. */
+    readonly blocked: boolean;
+    /** A newer version exists on the channel — and this install is in its rollout. */
+    readonly updateAvailable: boolean;
+    readonly latestVersion: string | null;
+    /** Feature keys the running version must treat as off. */
+    readonly killed: ReadonlyArray<string>;
+}
+
+declare interface ReleasePolicy {
+    readonly app: string;
+    readonly channel: string;
+    /** The channel's current release version, or null before the first promote. */
+    readonly latestVersion: string | null;
+    readonly minSupportedVersion: string | null;
+    /** `{ featureKey: [versions the feature is switched off for] }` */
+    readonly killSwitches: Readonly<Record<string, ReadonlyArray<string>>>;
+    readonly rolloutPercent: number;
+    readonly rolloutSalt: string | null;
+    readonly cohorts: ReadonlyArray<string> | null;
+}
+
+export declare interface ReleasePolicyState {
+    readonly policy: ReleasePolicy | null;
+    readonly verdict: PolicyVerdict | null;
+    readonly loading: boolean;
+}
+
+/** A stable per-install id from the platform's storage (minted once). */
+export declare const useInstallId: (explicit?: string) => string;
+
+/** Is a feature switched off for the running version by a kill switch? */
+export declare const useKillSwitch: (options: UseReleasePolicyOptions & {
+    readonly key: string;
+}) => boolean;
+
+/** The live release policy of a channel and this client's verdict under it. */
+export declare const useReleasePolicy: (options: UseReleasePolicyOptions) => ReleasePolicyState;
+
+export declare interface UseReleasePolicyOptions {
+    readonly app: string;
+    readonly channel: string;
+    /** The running version. Defaults to the platform adapter's `appVersion`. */
+    readonly version?: string;
+    /** A stable per-install id for the rollout bucket. Defaults to a value kept
+     *  in the platform's persisted storage. */
+    readonly installId?: string;
+    readonly cohorts?: ReadonlyArray<string>;
+    readonly apiName?: string;
+}
+
+/**
+ * The update IMPULSE: when the channel's policy says a newer version is
+ * rolled out to this install, ask the platform's update channel to check —
+ * the service worker, the desktop updater, the OTA client — instead of
+ * polling on a timer. Returns the verdict so the caller can also render it.
+ */
+export declare const useUpdateImpulse: (options: UseReleasePolicyOptions) => ReleasePolicyState;
+
+export { }

package/dist/web.js

@@ -0,0 +1,47 @@
+import { n as e } from "./rollout-CGRKMTfv.js";
+import { t } from "./rpc-U7ytx6SC.js";
+import { pluginTag as n } from "@voltro/protocol";
+import { createElement as r, useEffect as i, useRef as a } from "react";
+import { usePlatform as o, useSubscription as s } from "@voltro/client";
+//#region src/web.ts
+var c = (e) => n(t, e), l = "voltro:install-id", u = (e) => {
+	let { storage: t } = o();
+	if (e !== void 0) return e;
+	let n = t("local");
+	if (n === null) return "ephemeral";
+	let r = n.getItem(l);
+	if (r) return r;
+	let i = `inst_${Math.random().toString(36).slice(2)}${Date.now().toString(36)}`;
+	return n.setItem(l, i), i;
+}, d = (t) => {
+	let { platform: n } = o(), r = u(t.installId), { data: i, loading: a } = s(t.apiName ?? "app", c("policy"), {
+		app: t.app,
+		channel: t.channel
+	}), l = t.version ?? n.appVersion, d = i ?? null;
+	return {
+		policy: d,
+		verdict: d !== null && l !== void 0 ? e(d, {
+			version: l,
+			installId: r,
+			...t.cohorts === void 0 ? {} : { cohorts: t.cohorts }
+		}) : null,
+		loading: a
+	};
+}, f = (e) => {
+	let { verdict: t } = d(e);
+	return t?.killed.includes(e.key) ?? !1;
+}, p = (e) => {
+	let { children: t, fallback: n, ...i } = e, { verdict: a } = d(i);
+	return a?.blocked ? r(m, {
+		render: n,
+		verdict: a
+	}) : t;
+}, m = ({ render: e, verdict: t }) => e(t), h = (e) => {
+	let t = d(e), { updates: n } = o(), r = a(null);
+	return i(() => {
+		let e = t.verdict?.updateAvailable ? t.verdict.latestVersion : null;
+		e !== null && e !== r.current && (r.current = e, n?.check());
+	}, [t.verdict, n]), t;
+};
+//#endregion
+export { p as ForcedUpdateGate, u as useInstallId, f as useKillSwitch, d as useReleasePolicy, h as useUpdateImpulse };

package/package.json

@@ -1,6 +1,69 @@
 {
   "name": "@voltro/plugin-releases",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.83.0",
+  "description": "Release channels, artefacts and rollouts for the apps a Voltro api serves — the self-hosted update server behind Tauri, Expo OTA, electron-updater and PWA update feeds, with a reactive release policy every client subscribes to.",
+  "keywords": [
+    "voltro",
+    "typescript",
+    "framework"
+  ],
+  "license": "SEE LICENSE IN LICENSE",
+  "homepage": "https://voltro.dev",
+  "bugs": {
+    "email": "support@voltro.dev"
+  },
+  "author": {
+    "name": "Voltro UG",
+    "url": "https://voltro.dev"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./web": {
+      "types": "./dist/web.d.ts",
+      "import": "./dist/web.js",
+      "default": "./dist/web.js"
+    },
+    "./errors": {
+      "types": "./dist/errors.d.ts",
+      "import": "./dist/errors.js",
+      "default": "./dist/errors.js"
+    },
+    "./rpc": {
+      "types": "./dist/rpc.d.ts",
+      "import": "./dist/rpc.js",
+      "default": "./dist/rpc.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "dependencies": {
+    "@voltro/client": "0.83.0",
+    "@voltro/database": "0.83.0",
+    "@voltro/logger": "0.83.0",
+    "@voltro/protocol": "0.83.0",
+    "@voltro/runtime": "0.83.0"
+  },
+  "peerDependencies": {
+    "effect": "^3.22.2",
+    "react": "^19.0.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}