@voltro/plugin-releases 0.84.0 → 0.86.0

package/dist/names.js

@@ -0,0 +1,4 @@
+//#region src/names.ts
+var e = "_voltro_release_apps", t = "_voltro_release_channels", n = "_voltro_releases", r = "_voltro_release_artifacts", i = "_voltro_release_events";
+//#endregion
+export { n as RELEASES_TABLE, e as RELEASE_APPS_TABLE, r as RELEASE_ARTIFACTS_TABLE, t as RELEASE_CHANNELS_TABLE, i as RELEASE_EVENTS_TABLE };

package/dist/retention.js

@@ -0,0 +1,13 @@
+import { compareVersions as e } from "./rollout.js";
+var t = (t, n, r) => {
+	let i = /* @__PURE__ */ new Set();
+	for (let e of n) e.currentReleaseId !== null && i.add(e.currentReleaseId);
+	let a = [];
+	for (let o of n) {
+		let n = r(o.name), s = Number.isFinite(n) ? Math.max(1, Math.floor(n)) : 10, c = t.filter((e) => e.channelId === o.id).sort((t, n) => e(n.version, t.version));
+		for (let e of c.slice(s)) i.has(e.id) || a.push(e);
+	}
+	return a;
+};
+//#endregion
+export { t as planRetention };

package/dist/{rollout-CGRKMTfv.js → rollout.js}

@@ -52,4 +52,4 @@ var e = (e) => {
 	};
 }, 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 };
+export { t as compareVersions, o as evaluatePolicy, a as inRollout, n as isNewerVersion, e as parseVersion, i as rolloutBucket, s as sortVersionsDesc };

package/dist/rpc.d.ts

@@ -2,117 +2,131 @@ import { MutationProcedureDescriptor } from '@voltro/protocol';
 import { PluginRpcClientDescriptor } from '@voltro/protocol';
 import { QueryProcedureDescriptor } from '@voltro/protocol';
 import { Schema } from 'effect';
+import { YieldableError } from 'effect/Cause';
 
 export declare const BASE_NAME = "@voltro/plugin-releases";
 
 export declare const createDescriptor: MutationProcedureDescriptor<"releases.create", Schema.Struct<{
-    expectedTarget: Schema.optional<Schema.Struct<{
-        id: typeof Schema.String;
-        revision: Schema.filter<Schema.filter<typeof Schema.Number>>;
+    readonly expectedTarget: Schema.optional<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly revision: Schema.Number;
     }>>;
-    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>>;
+    readonly app: Schema.String;
+    readonly channel: Schema.String;
+    readonly version: Schema.String;
+    readonly buildId: Schema.optional<Schema.String>;
+    readonly notes: Schema.optional<Schema.String>;
+    readonly cohorts: Schema.optional<Schema.$Array<Schema.String>>;
 }>, Schema.Struct<{
-    id: typeof Schema.String;
-}>, Schema.Union<[typeof ReleaseRefused, typeof ReleaseNotFound]>>;
+    readonly id: Schema.String;
+}>, Schema.Union<readonly [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>;
+    readonly app: Schema.String;
+}>, Schema.$Array<Schema.Struct<{
+    readonly id: Schema.String;
+    readonly version: Schema.String;
+    readonly buildId: Schema.NullOr<Schema.String>;
+    readonly state: Schema.String;
+    readonly rolloutPercent: Schema.Number;
+    readonly channel: Schema.String;
+    readonly createdAt: Schema.String;
+    readonly artifacts: Schema.Number;
+    readonly signed: Schema.Boolean;
+}>>, 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;
+    readonly app: Schema.String;
+    readonly channel: 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>;
+    readonly app: Schema.String;
+    readonly channel: Schema.String;
+    readonly latestVersion: Schema.NullOr<Schema.String>;
+    readonly minSupportedVersion: Schema.NullOr<Schema.String>;
+    readonly killSwitches: Schema.$Record<Schema.String, Schema.$Array<Schema.String>>;
+    readonly rolloutPercent: Schema.Number;
+    readonly rolloutSalt: Schema.NullOr<Schema.String>;
+    readonly cohorts: Schema.NullOr<Schema.$Array<Schema.String>>;
+}>, 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>>;
+    readonly app: Schema.String;
+    readonly channel: Schema.String;
+    readonly latestVersion: Schema.NullOr<Schema.String>;
+    readonly minSupportedVersion: Schema.NullOr<Schema.String>;
+    readonly killSwitches: Schema.$Record<Schema.String, Schema.$Array<Schema.String>>;
+    readonly rolloutPercent: Schema.Number;
+    readonly rolloutSalt: Schema.NullOr<Schema.String>;
+    readonly cohorts: Schema.NullOr<Schema.$Array<Schema.String>>;
 }>;
 
 export declare type PolicyWire = typeof PolicySchema.Type;
 
+export declare const prepareUploadDescriptor: QueryProcedureDescriptor<"releases.prepareUpload", Schema.Struct<{
+    readonly operationId: Schema.optionalKey<Schema.String>;
+    readonly expectedTarget: Schema.optional<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly revision: Schema.Number;
+    }>>;
+    readonly appPrefix: Schema.optional<Schema.NonEmptyString>;
+    readonly releaseId: Schema.String;
+    readonly app: Schema.optional<Schema.String>;
+    readonly version: Schema.optional<Schema.String>;
+}>, Schema.Struct<{
+    readonly releaseId: Schema.String;
+    readonly app: Schema.String;
+    readonly version: Schema.String;
+}>, Schema.Union<readonly [typeof ReleaseRefused, typeof ReleaseNotFound]>>;
+
 export declare const promoteDescriptor: MutationProcedureDescriptor<"releases.promote", Schema.Struct<{
-    expectedTarget: Schema.optional<Schema.Struct<{
-        id: typeof Schema.String;
-        revision: Schema.filter<Schema.filter<typeof Schema.Number>>;
+    readonly expectedTarget: Schema.optional<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly revision: Schema.Number;
     }>>;
-    app: typeof Schema.String;
-    version: typeof Schema.String;
-    to: typeof Schema.String;
-    rolloutPercent: Schema.optional<Schema.filter<typeof Schema.Number>>;
+    readonly app: Schema.String;
+    readonly version: Schema.String;
+    readonly to: Schema.String;
+    readonly rolloutPercent: Schema.optional<Schema.Number>;
 }>, Schema.Struct<{
-    channel: typeof Schema.String;
-    version: typeof Schema.String;
-    rolloutPercent: typeof Schema.Number;
-}>, Schema.Union<[typeof ReleaseRefused, typeof ReleaseNotFound]>>;
+    readonly channel: Schema.String;
+    readonly version: Schema.String;
+    readonly rolloutPercent: Schema.Number;
+}>, Schema.Union<readonly [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>>;
+    readonly app: Schema.String;
+    readonly platform: Schema.Literals<readonly ["web", "ios", "android", "macos", "windows", "linux"]>;
+    readonly shell: Schema.Literals<readonly ["pwa", "expo", "tauri", "electron"]>;
+    readonly bundleId: Schema.optional<Schema.String>;
+    readonly updaterPublicKey: Schema.optional<Schema.String>;
+    readonly runtimeVersion: Schema.optional<Schema.String>;
+    readonly channels: Schema.optional<Schema.$Array<Schema.String>>;
 }>, Schema.Struct<{
-    id: typeof Schema.String;
-    created: typeof Schema.Boolean;
+    readonly id: Schema.String;
+    readonly created: 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 const ReleaseNotFound_base: Schema.Class<ReleaseNotFound, Schema.TaggedStruct<"ReleaseNotFound", {
+    readonly app: Schema.String;
+    readonly version: Schema.optional<Schema.String>;
+    readonly channel: Schema.optional<Schema.String>;
+}>, YieldableError>;
 
 declare class ReleaseRefused extends ReleaseRefused_base {
+    get message(): string;
 }
 
-declare const ReleaseRefused_base: Schema.TaggedErrorClass<ReleaseRefused, "ReleaseRefused", {
-    readonly _tag: Schema.tag<"ReleaseRefused">;
-} & {
-    reason: typeof Schema.String;
-}>;
+declare const ReleaseRefused_base: Schema.Class<ReleaseRefused, Schema.TaggedStruct<"ReleaseRefused", {
+    readonly reason: Schema.String;
+}>, YieldableError>;
 
 /** The scope that promotes, rolls out, rolls back and changes policy. */
 export declare const RELEASES_MANAGE_SCOPE = "releases:manage";
@@ -120,80 +134,96 @@ 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;
+    readonly id: Schema.String;
+    readonly version: Schema.String;
+    readonly buildId: Schema.NullOr<Schema.String>;
+    readonly state: Schema.String;
+    readonly rolloutPercent: Schema.Number;
+    readonly channel: Schema.String;
+    readonly createdAt: Schema.String;
+    readonly artifacts: Schema.Number;
+    readonly signed: Schema.Boolean;
+}>;
+
+export declare const ReleaseUploadPreparationInput: Schema.Struct<{
+    readonly operationId: Schema.optionalKey<Schema.String>;
+    readonly expectedTarget: Schema.optional<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly revision: Schema.Number;
+    }>>;
+    readonly appPrefix: Schema.optional<Schema.NonEmptyString>;
+    readonly releaseId: Schema.String;
+    readonly app: Schema.optional<Schema.String>;
+    readonly version: Schema.optional<Schema.String>;
 }>;
 
 export declare const rollbackDescriptor: MutationProcedureDescriptor<"releases.rollback", Schema.Struct<{
-    app: typeof Schema.String;
-    channel: typeof Schema.String;
-    reason: typeof Schema.String;
-    expectedTarget: Schema.optional<Schema.Struct<{
-        id: typeof Schema.String;
-        revision: Schema.filter<Schema.filter<typeof Schema.Number>>;
+    readonly app: Schema.String;
+    readonly channel: Schema.String;
+    readonly reason: Schema.String;
+    readonly expectedTarget: Schema.optional<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly revision: Schema.Number;
     }>>;
 }>, Schema.Struct<{
-    version: Schema.NullOr<typeof Schema.String>;
-}>, Schema.Union<[typeof ReleaseRefused, typeof ReleaseNotFound]>>;
+    readonly version: Schema.NullOr<Schema.String>;
+}>, Schema.Union<readonly [typeof ReleaseRefused, typeof ReleaseNotFound]>>;
 
 export declare const rolloutDescriptor: MutationProcedureDescriptor<"releases.rollout", Schema.Struct<{
-    app: typeof Schema.String;
-    channel: typeof Schema.String;
-    percent: Schema.filter<typeof Schema.Number>;
-    expectedTarget: Schema.optional<Schema.Struct<{
-        id: typeof Schema.String;
-        revision: Schema.filter<Schema.filter<typeof Schema.Number>>;
+    readonly app: Schema.String;
+    readonly channel: Schema.String;
+    readonly percent: Schema.Number;
+    readonly expectedTarget: Schema.optional<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly revision: Schema.Number;
     }>>;
 }>, Schema.Struct<{
-    version: typeof Schema.String;
-    rolloutPercent: typeof Schema.Number;
-}>, Schema.Union<[typeof ReleaseRefused, typeof ReleaseNotFound]>>;
+    readonly version: Schema.String;
+    readonly rolloutPercent: Schema.Number;
+}>, Schema.Union<readonly [typeof ReleaseRefused, typeof ReleaseNotFound]>>;
 
 export declare const setPolicyDescriptor: MutationProcedureDescriptor<"releases.setPolicy", Schema.Struct<{
-    expectedTarget: Schema.optional<Schema.Struct<{
-        id: typeof Schema.String;
-        revision: Schema.filter<Schema.filter<typeof Schema.Number>>;
+    readonly expectedTarget: Schema.optional<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly revision: Schema.Number;
     }>>;
-    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;
+    readonly app: Schema.String;
+    readonly channel: Schema.String;
+    readonly minSupportedVersion: Schema.optional<Schema.NullOr<Schema.String>>;
+    readonly killSwitches: Schema.optional<Schema.$Record<Schema.String, Schema.$Array<Schema.String>>>;
+    readonly reason: 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]>>;
+    readonly app: Schema.String;
+    readonly channel: Schema.String;
+    readonly latestVersion: Schema.NullOr<Schema.String>;
+    readonly minSupportedVersion: Schema.NullOr<Schema.String>;
+    readonly killSwitches: Schema.$Record<Schema.String, Schema.$Array<Schema.String>>;
+    readonly rolloutPercent: Schema.Number;
+    readonly rolloutSalt: Schema.NullOr<Schema.String>;
+    readonly cohorts: Schema.NullOr<Schema.$Array<Schema.String>>;
+}>, Schema.Union<readonly [typeof ReleaseRefused, typeof ReleaseNotFound]>>;
 
 export declare const uploadDescriptor: MutationProcedureDescriptor<"releases.upload", Schema.Struct<{
-    expectedTarget: Schema.optional<Schema.Struct<{
-        id: typeof Schema.String;
-        revision: Schema.filter<Schema.filter<typeof Schema.Number>>;
+    readonly kind: Schema.String;
+    readonly target: Schema.optional<Schema.String>;
+    readonly url: Schema.String;
+    readonly sha256: Schema.String;
+    readonly size: Schema.Number;
+    readonly signature: Schema.optional<Schema.String>;
+    readonly notarized: Schema.optional<Schema.Boolean>;
+    readonly assetKey: Schema.optional<Schema.String>;
+    readonly contentType: Schema.optional<Schema.String>;
+    readonly operationId: Schema.optionalKey<Schema.String>;
+    readonly expectedTarget: Schema.optional<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly revision: Schema.Number;
     }>>;
-    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>;
+    readonly appPrefix: Schema.optional<Schema.NonEmptyString>;
+    readonly releaseId: Schema.String;
+    readonly app: Schema.optional<Schema.String>;
+    readonly version: Schema.optional<Schema.String>;
 }>, Schema.Struct<{
-    id: typeof Schema.String;
-}>, Schema.Union<[typeof ReleaseRefused, typeof ReleaseNotFound]>>;
+    readonly id: Schema.String;
+}>, Schema.Union<readonly [typeof ReleaseRefused, typeof ReleaseNotFound]>>;
 
 export { }

package/dist/rpc.js

@@ -1,2 +1,263 @@
-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-DeEV8l3U.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 };
+import { artifactHash as e, artifactOperationId as t, artifactSize as n, artifactText as r, hasArtifactSignature as i } from "./artifactMetadata.js";
+import { ReleaseNotFound as a, ReleaseRefused as o } from "./errors.js";
+import { RELEASES_TABLE as s, RELEASE_APPS_TABLE as c, RELEASE_ARTIFACTS_TABLE as l, RELEASE_CHANNELS_TABLE as u } from "./names.js";
+import { Schema as d } from "effect";
+import { defineMutation as f, defineQuery as p } from "@voltro/protocol";
+//#region src/rpc.ts
+var m = "@voltro/plugin-releases", h = "releases:manage", g = d.optional(d.Struct({
+	id: d.String,
+	revision: d.Number.pipe(d.check(d.isInt()), d.check(d.isGreaterThanOrEqualTo(0)))
+})), _ = d.Struct({
+	app: d.String,
+	channel: d.String,
+	latestVersion: d.NullOr(d.String),
+	minSupportedVersion: d.NullOr(d.String),
+	killSwitches: d.Record(d.String, d.Array(d.String)),
+	rolloutPercent: d.Number,
+	rolloutSalt: d.NullOr(d.String),
+	cohorts: d.NullOr(d.Array(d.String))
+}), v = p({
+	name: "releases.policy",
+	input: d.Struct({
+		app: d.String,
+		channel: d.String
+	}),
+	output: _,
+	source: [u, 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"
+}), y = d.Struct({
+	id: d.String,
+	version: d.String,
+	buildId: d.NullOr(d.String),
+	state: d.String,
+	rolloutPercent: d.Number,
+	channel: d.String,
+	createdAt: d.String,
+	artifacts: d.Number,
+	signed: d.Boolean
+}), b = p({
+	name: "releases.list",
+	input: d.Struct({ app: d.String }),
+	output: d.Array(y),
+	source: [s],
+	guards: [{ scope: h }]
+}), x = f({
+	name: "releases.registerApp",
+	input: d.Struct({
+		app: d.String,
+		platform: d.Literals([
+			"web",
+			"ios",
+			"android",
+			"macos",
+			"windows",
+			"linux"
+		]),
+		shell: d.Literals([
+			"pwa",
+			"expo",
+			"tauri",
+			"electron"
+		]),
+		bundleId: d.optional(d.String),
+		updaterPublicKey: d.optional(d.String),
+		runtimeVersion: d.optional(d.String),
+		channels: d.optional(d.Array(d.String))
+	}),
+	output: d.Struct({
+		id: d.String,
+		created: d.Boolean
+	}),
+	error: o,
+	guards: [{ scope: h }]
+}), S = f({
+	name: "releases.create",
+	input: d.Struct({
+		expectedTarget: g,
+		app: d.String,
+		channel: d.String,
+		version: d.String,
+		buildId: d.optional(d.String),
+		notes: d.optional(d.String),
+		cohorts: d.optional(d.Array(d.String))
+	}),
+	output: d.Struct({ id: d.String }),
+	error: d.Union([o, a]),
+	guards: [{ scope: h }]
+}), C = d.String.check(d.makeFilter(r, { message: "Artifact metadata must be nonblank text without control characters" })), w = d.String.check(d.makeFilter(e, { message: "Artifact sha256 must contain exactly 64 hexadecimal characters" })), T = d.Number.check(d.makeFilter(n, { message: "Artifact size must be a positive safe integer" })), E = d.String.check(d.makeFilter(i, { message: "Artifact signature must not be blank or contain NUL" })), D = d.String.check(d.makeFilter(t, { message: "Artifact operationId must be nonblank text without control characters and at most 200 characters" })), O = d.Struct({
+	operationId: d.optionalKey(D),
+	expectedTarget: g,
+	appPrefix: d.optional(d.NonEmptyString),
+	releaseId: C,
+	app: d.optional(C),
+	version: d.optional(C)
+}), k = p({
+	name: "releases.prepareUpload",
+	input: O,
+	output: d.Struct({
+		releaseId: d.String,
+		app: d.String,
+		version: d.String
+	}),
+	source: [
+		c,
+		s,
+		l
+	],
+	error: d.Union([o, a]),
+	guards: [{ scope: h }]
+}), A = f({
+	name: "releases.upload",
+	input: d.Struct({
+		...O.fields,
+		kind: C,
+		target: d.optional(C),
+		url: C,
+		sha256: w,
+		size: T,
+		signature: d.optional(E),
+		notarized: d.optional(d.Boolean),
+		assetKey: d.optional(C),
+		contentType: d.optional(C)
+	}),
+	output: d.Struct({ id: d.String }),
+	error: d.Union([o, a]),
+	guards: [{ scope: h }]
+}), j = f({
+	name: "releases.promote",
+	input: d.Struct({
+		expectedTarget: g,
+		app: d.String,
+		version: d.String,
+		to: d.String,
+		rolloutPercent: d.optional(d.Number.pipe(d.check(d.isInt())))
+	}),
+	output: d.Struct({
+		channel: d.String,
+		version: d.String,
+		rolloutPercent: d.Number
+	}),
+	error: d.Union([o, a]),
+	guards: [{ scope: h }]
+}), M = f({
+	name: "releases.rollout",
+	input: d.Struct({
+		app: d.String,
+		channel: d.String,
+		percent: d.Number.pipe(d.check(d.isInt())),
+		expectedTarget: g
+	}),
+	output: d.Struct({
+		version: d.String,
+		rolloutPercent: d.Number
+	}),
+	error: d.Union([o, a]),
+	guards: [{ scope: h }]
+}), N = f({
+	name: "releases.rollback",
+	input: d.Struct({
+		app: d.String,
+		channel: d.String,
+		reason: d.String,
+		expectedTarget: g
+	}),
+	output: d.Struct({ version: d.NullOr(d.String) }),
+	error: d.Union([o, a]),
+	guards: [{ scope: h }]
+}), P = f({
+	name: "releases.setPolicy",
+	input: d.Struct({
+		expectedTarget: g,
+		app: d.String,
+		channel: d.String,
+		minSupportedVersion: d.optional(d.NullOr(d.String)),
+		killSwitches: d.optional(d.Record(d.String, d.Array(d.String))),
+		reason: d.String
+	}),
+	output: _,
+	error: d.Union([o, a]),
+	guards: [{ scope: h }]
+}), F = [
+	{
+		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.prepareUpload",
+		kind: "query",
+		import: {
+			module: "@voltro/plugin-releases/rpc",
+			name: "prepareUploadDescriptor"
+		}
+	},
+	{
+		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 { m as BASE_NAME, _ as PolicySchema, h as RELEASES_MANAGE_SCOPE, y as ReleaseSummarySchema, O as ReleaseUploadPreparationInput, S as createDescriptor, b as listDescriptor, v as policyDescriptor, k as prepareUploadDescriptor, j as promoteDescriptor, x as registerAppDescriptor, F as releasesRpcClientImports, N as rollbackDescriptor, M as rolloutDescriptor, P as setPolicyDescriptor, A as uploadDescriptor };