@voltro/plugin-releases 0.83.1 → 0.85.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (11) hide show
  1. package/CHANGELOG.md +1191 -0
  2. package/THIRD-PARTY-NOTICES.md +123 -577
  3. package/dist/errors.d.ts +10 -12
  4. package/dist/errors.js +5 -1
  5. package/dist/index.d.ts +22 -20
  6. package/dist/index.js +342 -287
  7. package/dist/{rpc-U7ytx6SC.js → rpc-DrfZqJIA.js} +50 -35
  8. package/dist/rpc.d.ts +136 -114
  9. package/dist/rpc.js +1 -1
  10. package/dist/web.js +1 -1
  11. package/package.json +7 -7
package/dist/{rpc-U7ytx6SC.js → rpc-DrfZqJIA.js} RENAMED
@@ -2,28 +2,28 @@ import { ReleaseNotFound as e, ReleaseRefused as t } from "./errors.js";
2
2
  import { Schema as n } from "effect";
3
3
  import { defineMutation as r, defineQuery as i } from "@voltro/protocol";
4
4
  //#region src/names.ts
5
- 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({
5
+ 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.optional(n.Struct({
6
+ id: n.String,
7
+ revision: n.Number.pipe(n.check(n.isInt()), n.check(n.isGreaterThanOrEqualTo(0)))
8
+ })), p = n.Struct({
6
9
  app: n.String,
7
10
  channel: n.String,
8
11
  latestVersion: n.NullOr(n.String),
9
12
  minSupportedVersion: n.NullOr(n.String),
10
- killSwitches: n.Record({
11
- key: n.String,
12
- value: n.Array(n.String)
13
- }),
13
+ killSwitches: n.Record(n.String, n.Array(n.String)),
14
14
  rolloutPercent: n.Number,
15
15
  rolloutSalt: n.NullOr(n.String),
16
16
  cohorts: n.NullOr(n.Array(n.String))
17
- }), p = i({
17
+ }), m = i({
18
18
  name: "releases.policy",
19
19
  input: n.Struct({
20
20
  app: n.String,
21
21
  channel: n.String
22
22
  }),
23
- output: f,
23
+ output: p,
24
24
  source: [o, s],
25
25
  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"
26
- }), m = n.Struct({
26
+ }), h = n.Struct({
27
27
  id: n.String,
28
28
  version: n.String,
29
29
  buildId: n.NullOr(n.String),
@@ -33,18 +33,30 @@ var a = "_voltro_release_apps", o = "_voltro_release_channels", s = "_voltro_rel
33
33
  createdAt: n.String,
34
34
  artifacts: n.Number,
35
35
  signed: n.Boolean
36
- }), h = i({
36
+ }), g = i({
37
37
  name: "releases.list",
38
38
  input: n.Struct({ app: n.String }),
39
- output: n.Array(m),
39
+ output: n.Array(h),
40
40
  source: [s],
41
41
  guards: [{ scope: d }]
42
- }), g = r({
42
+ }), _ = r({
43
43
  name: "releases.registerApp",
44
44
  input: n.Struct({
45
45
  app: n.String,
46
- platform: n.Literal("web", "ios", "android", "macos", "windows", "linux"),
47
- shell: n.Literal("pwa", "expo", "tauri", "electron"),
46
+ platform: n.Literals([
47
+ "web",
48
+ "ios",
49
+ "android",
50
+ "macos",
51
+ "windows",
52
+ "linux"
53
+ ]),
54
+ shell: n.Literals([
55
+ "pwa",
56
+ "expo",
57
+ "tauri",
58
+ "electron"
59
+ ]),
48
60
  bundleId: n.optional(n.String),
49
61
  updaterPublicKey: n.optional(n.String),
50
62
  runtimeVersion: n.optional(n.String),
@@ -56,9 +68,10 @@ var a = "_voltro_release_apps", o = "_voltro_release_channels", s = "_voltro_rel
56
68
  }),
57
69
  error: t,
58
70
  guards: [{ scope: d }]
59
- }), _ = r({
71
+ }), v = r({
60
72
  name: "releases.create",
61
73
  input: n.Struct({
74
+ expectedTarget: f,
62
75
  app: n.String,
63
76
  channel: n.String,
64
77
  version: n.String,
@@ -67,11 +80,12 @@ var a = "_voltro_release_apps", o = "_voltro_release_channels", s = "_voltro_rel
67
80
  cohorts: n.optional(n.Array(n.String))
68
81
  }),
69
82
  output: n.Struct({ id: n.String }),
70
- error: n.Union(t, e),
83
+ error: n.Union([t, e]),
71
84
  guards: [{ scope: d }]
72
- }), v = r({
85
+ }), y = r({
73
86
  name: "releases.upload",
74
87
  input: n.Struct({
88
+ expectedTarget: f,
75
89
  releaseId: n.String,
76
90
  kind: n.String,
77
91
  target: n.optional(n.String),
@@ -84,62 +98,63 @@ var a = "_voltro_release_apps", o = "_voltro_release_channels", s = "_voltro_rel
84
98
  contentType: n.optional(n.String)
85
99
  }),
86
100
  output: n.Struct({ id: n.String }),
87
- error: n.Union(t, e),
101
+ error: n.Union([t, e]),
88
102
  guards: [{ scope: d }]
89
- }), y = r({
103
+ }), b = r({
90
104
  name: "releases.promote",
91
105
  input: n.Struct({
106
+ expectedTarget: f,
92
107
  app: n.String,
93
108
  version: n.String,
94
109
  to: n.String,
95
- rolloutPercent: n.optional(n.Number)
110
+ rolloutPercent: n.optional(n.Number.pipe(n.check(n.isInt())))
96
111
  }),
97
112
  output: n.Struct({
98
113
  channel: n.String,
99
114
  version: n.String,
100
115
  rolloutPercent: n.Number
101
116
  }),
102
- error: n.Union(t, e),
117
+ error: n.Union([t, e]),
103
118
  guards: [{ scope: d }]
104
- }), b = r({
119
+ }), x = r({
105
120
  name: "releases.rollout",
106
121
  input: n.Struct({
107
122
  app: n.String,
108
123
  channel: n.String,
109
- percent: n.Number
124
+ percent: n.Number.pipe(n.check(n.isInt())),
125
+ expectedTarget: f
110
126
  }),
111
127
  output: n.Struct({
112
128
  version: n.String,
113
129
  rolloutPercent: n.Number
114
130
  }),
115
- error: n.Union(t, e),
131
+ error: n.Union([t, e]),
116
132
  guards: [{ scope: d }]
117
- }), x = r({
133
+ }), S = r({
118
134
  name: "releases.rollback",
119
135
  input: n.Struct({
120
136
  app: n.String,
121
137
  channel: n.String,
122
- reason: n.String
138
+ reason: n.String,
139
+ expectedTarget: f
123
140
  }),
124
141
  output: n.Struct({ version: n.NullOr(n.String) }),
125
- error: n.Union(t, e),
142
+ error: n.Union([t, e]),
126
143
  guards: [{ scope: d }]
127
- }), S = r({
144
+ }), C = r({
128
145
  name: "releases.setPolicy",
129
146
  input: n.Struct({
147
+ expectedTarget: f,
130
148
  app: n.String,
131
149
  channel: n.String,
132
150
  minSupportedVersion: n.optional(n.NullOr(n.String)),
133
- killSwitches: n.optional(n.Record({
134
- key: n.String,
135
- value: n.Array(n.String)
136
- })),
151
+ killSwitches: n.optional(n.Record(n.String, n.Array(n.String))),
137
152
  reason: n.String
138
153
  }),
139
- output: f,
140
- error: n.Union(t, e),
154
+ output: p,
155
+ error: n.Union([t, e]),
141
156
  guards: [{ scope: d }]
142
- }), C = [
157
+ }), w = [
143
158
  {
144
159
  tag: "releases.policy",
145
160
  kind: "query",
@@ -214,4 +229,4 @@ var a = "_voltro_release_apps", o = "_voltro_release_channels", s = "_voltro_rel
214
229
  }
215
230
  ];
216
231
  //#endregion
217
- 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 };
232
+ export { c as _, v as a, b as c, S as d, x as f, a as g, s as h, h as i, _ as l, y as m, p as n, g as o, C as p, d as r, m as s, u as t, w as u, o as v, l as y };
package/dist/rpc.d.ts CHANGED
@@ -2,109 +2,115 @@ import { MutationProcedureDescriptor } from '@voltro/protocol';
2
2
  import { PluginRpcClientDescriptor } from '@voltro/protocol';
3
3
  import { QueryProcedureDescriptor } from '@voltro/protocol';
4
4
  import { Schema } from 'effect';
5
+ import { YieldableError } from 'effect/Cause';
5
6
 
6
7
  export declare const BASE_NAME = "@voltro/plugin-releases";
7
8
 
8
9
  export declare const createDescriptor: MutationProcedureDescriptor<"releases.create", Schema.Struct<{
9
- app: typeof Schema.String;
10
- channel: typeof Schema.String;
11
- version: typeof Schema.String;
12
- buildId: Schema.optional<typeof Schema.String>;
13
- notes: Schema.optional<typeof Schema.String>;
14
- cohorts: Schema.optional<Schema.Array$<typeof Schema.String>>;
10
+ readonly expectedTarget: Schema.optional<Schema.Struct<{
11
+ readonly id: Schema.String;
12
+ readonly revision: Schema.Number;
13
+ }>>;
14
+ readonly app: Schema.String;
15
+ readonly channel: Schema.String;
16
+ readonly version: Schema.String;
17
+ readonly buildId: Schema.optional<Schema.String>;
18
+ readonly notes: Schema.optional<Schema.String>;
19
+ readonly cohorts: Schema.optional<Schema.$Array<Schema.String>>;
15
20
  }>, Schema.Struct<{
16
- id: typeof Schema.String;
17
- }>, Schema.Union<[typeof ReleaseRefused, typeof ReleaseNotFound]>>;
21
+ readonly id: Schema.String;
22
+ }>, Schema.Union<readonly [typeof ReleaseRefused, typeof ReleaseNotFound]>>;
18
23
 
19
24
  export declare const listDescriptor: QueryProcedureDescriptor<"releases.list", Schema.Struct<{
20
- app: typeof Schema.String;
21
- }>, Schema.Array$<Schema.Struct<{
22
- id: typeof Schema.String;
23
- version: typeof Schema.String;
24
- buildId: Schema.NullOr<typeof Schema.String>;
25
- state: typeof Schema.String;
26
- rolloutPercent: typeof Schema.Number;
27
- channel: typeof Schema.String;
28
- createdAt: typeof Schema.String;
29
- artifacts: typeof Schema.Number;
30
- signed: typeof Schema.Boolean;
31
- }>>, typeof Schema.Never>;
25
+ readonly app: Schema.String;
26
+ }>, Schema.$Array<Schema.Struct<{
27
+ readonly id: Schema.String;
28
+ readonly version: Schema.String;
29
+ readonly buildId: Schema.NullOr<Schema.String>;
30
+ readonly state: Schema.String;
31
+ readonly rolloutPercent: Schema.Number;
32
+ readonly channel: Schema.String;
33
+ readonly createdAt: Schema.String;
34
+ readonly artifacts: Schema.Number;
35
+ readonly signed: Schema.Boolean;
36
+ }>>, Schema.Never>;
32
37
 
33
38
  /** The reactive policy every client subscribes to. Table-sourced, so a
34
39
  * promote, rollout change or policy edit reaches every live client. */
35
40
  export declare const policyDescriptor: QueryProcedureDescriptor<"releases.policy", Schema.Struct<{
36
- app: typeof Schema.String;
37
- channel: typeof Schema.String;
41
+ readonly app: Schema.String;
42
+ readonly channel: Schema.String;
38
43
  }>, Schema.Struct<{
39
- app: typeof Schema.String;
40
- channel: typeof Schema.String;
41
- latestVersion: Schema.NullOr<typeof Schema.String>;
42
- minSupportedVersion: Schema.NullOr<typeof Schema.String>;
43
- killSwitches: Schema.Record$<typeof Schema.String, Schema.Array$<typeof Schema.String>>;
44
- rolloutPercent: typeof Schema.Number;
45
- rolloutSalt: Schema.NullOr<typeof Schema.String>;
46
- cohorts: Schema.NullOr<Schema.Array$<typeof Schema.String>>;
47
- }>, typeof Schema.Never>;
44
+ readonly app: Schema.String;
45
+ readonly channel: Schema.String;
46
+ readonly latestVersion: Schema.NullOr<Schema.String>;
47
+ readonly minSupportedVersion: Schema.NullOr<Schema.String>;
48
+ readonly killSwitches: Schema.$Record<Schema.String, Schema.$Array<Schema.String>>;
49
+ readonly rolloutPercent: Schema.Number;
50
+ readonly rolloutSalt: Schema.NullOr<Schema.String>;
51
+ readonly cohorts: Schema.NullOr<Schema.$Array<Schema.String>>;
52
+ }>, Schema.Never>;
48
53
 
49
54
  export declare const PolicySchema: Schema.Struct<{
50
- app: typeof Schema.String;
51
- channel: typeof Schema.String;
52
- latestVersion: Schema.NullOr<typeof Schema.String>;
53
- minSupportedVersion: Schema.NullOr<typeof Schema.String>;
54
- killSwitches: Schema.Record$<typeof Schema.String, Schema.Array$<typeof Schema.String>>;
55
- rolloutPercent: typeof Schema.Number;
56
- rolloutSalt: Schema.NullOr<typeof Schema.String>;
57
- cohorts: Schema.NullOr<Schema.Array$<typeof Schema.String>>;
55
+ readonly app: Schema.String;
56
+ readonly channel: Schema.String;
57
+ readonly latestVersion: Schema.NullOr<Schema.String>;
58
+ readonly minSupportedVersion: Schema.NullOr<Schema.String>;
59
+ readonly killSwitches: Schema.$Record<Schema.String, Schema.$Array<Schema.String>>;
60
+ readonly rolloutPercent: Schema.Number;
61
+ readonly rolloutSalt: Schema.NullOr<Schema.String>;
62
+ readonly cohorts: Schema.NullOr<Schema.$Array<Schema.String>>;
58
63
  }>;
59
64
 
60
65
  export declare type PolicyWire = typeof PolicySchema.Type;
61
66
 
62
67
  export declare const promoteDescriptor: MutationProcedureDescriptor<"releases.promote", Schema.Struct<{
63
- app: typeof Schema.String;
64
- version: typeof Schema.String;
65
- to: typeof Schema.String;
66
- rolloutPercent: Schema.optional<typeof Schema.Number>;
68
+ readonly expectedTarget: Schema.optional<Schema.Struct<{
69
+ readonly id: Schema.String;
70
+ readonly revision: Schema.Number;
71
+ }>>;
72
+ readonly app: Schema.String;
73
+ readonly version: Schema.String;
74
+ readonly to: Schema.String;
75
+ readonly rolloutPercent: Schema.optional<Schema.Number>;
67
76
  }>, Schema.Struct<{
68
- channel: typeof Schema.String;
69
- version: typeof Schema.String;
70
- rolloutPercent: typeof Schema.Number;
71
- }>, Schema.Union<[typeof ReleaseRefused, typeof ReleaseNotFound]>>;
77
+ readonly channel: Schema.String;
78
+ readonly version: Schema.String;
79
+ readonly rolloutPercent: Schema.Number;
80
+ }>, Schema.Union<readonly [typeof ReleaseRefused, typeof ReleaseNotFound]>>;
72
81
 
73
82
  /** Register an app target at runtime — what a hosted feed (one api serving
74
83
  * many projects' apps) needs, where `apps:` in the plugin's config cannot
75
84
  * know them. Idempotent: a target that exists answers with its id. */
76
85
  export declare const registerAppDescriptor: MutationProcedureDescriptor<"releases.registerApp", Schema.Struct<{
77
- app: typeof Schema.String;
78
- platform: Schema.Literal<["web", "ios", "android", "macos", "windows", "linux"]>;
79
- shell: Schema.Literal<["pwa", "expo", "tauri", "electron"]>;
80
- bundleId: Schema.optional<typeof Schema.String>;
81
- updaterPublicKey: Schema.optional<typeof Schema.String>;
82
- runtimeVersion: Schema.optional<typeof Schema.String>;
83
- channels: Schema.optional<Schema.Array$<typeof Schema.String>>;
86
+ readonly app: Schema.String;
87
+ readonly platform: Schema.Literals<readonly ["web", "ios", "android", "macos", "windows", "linux"]>;
88
+ readonly shell: Schema.Literals<readonly ["pwa", "expo", "tauri", "electron"]>;
89
+ readonly bundleId: Schema.optional<Schema.String>;
90
+ readonly updaterPublicKey: Schema.optional<Schema.String>;
91
+ readonly runtimeVersion: Schema.optional<Schema.String>;
92
+ readonly channels: Schema.optional<Schema.$Array<Schema.String>>;
84
93
  }>, Schema.Struct<{
85
- id: typeof Schema.String;
86
- created: typeof Schema.Boolean;
94
+ readonly id: Schema.String;
95
+ readonly created: Schema.Boolean;
87
96
  }>, typeof ReleaseRefused>;
88
97
 
89
98
  declare class ReleaseNotFound extends ReleaseNotFound_base {
90
99
  }
91
100
 
92
- declare const ReleaseNotFound_base: Schema.TaggedErrorClass<ReleaseNotFound, "ReleaseNotFound", {
93
- readonly _tag: Schema.tag<"ReleaseNotFound">;
94
- } & {
95
- app: typeof Schema.String;
96
- version: Schema.optional<typeof Schema.String>;
97
- channel: Schema.optional<typeof Schema.String>;
98
- }>;
101
+ declare const ReleaseNotFound_base: Schema.Class<ReleaseNotFound, Schema.TaggedStruct<"ReleaseNotFound", {
102
+ readonly app: Schema.String;
103
+ readonly version: Schema.optional<Schema.String>;
104
+ readonly channel: Schema.optional<Schema.String>;
105
+ }>, YieldableError>;
99
106
 
100
107
  declare class ReleaseRefused extends ReleaseRefused_base {
108
+ get message(): string;
101
109
  }
102
110
 
103
- declare const ReleaseRefused_base: Schema.TaggedErrorClass<ReleaseRefused, "ReleaseRefused", {
104
- readonly _tag: Schema.tag<"ReleaseRefused">;
105
- } & {
106
- reason: typeof Schema.String;
107
- }>;
111
+ declare const ReleaseRefused_base: Schema.Class<ReleaseRefused, Schema.TaggedStruct<"ReleaseRefused", {
112
+ readonly reason: Schema.String;
113
+ }>, YieldableError>;
108
114
 
109
115
  /** The scope that promotes, rolls out, rolls back and changes policy. */
110
116
  export declare const RELEASES_MANAGE_SCOPE = "releases:manage";
@@ -112,64 +118,80 @@ export declare const RELEASES_MANAGE_SCOPE = "releases:manage";
112
118
  export declare const releasesRpcClientImports: ReadonlyArray<PluginRpcClientDescriptor>;
113
119
 
114
120
  export declare const ReleaseSummarySchema: Schema.Struct<{
115
- id: typeof Schema.String;
116
- version: typeof Schema.String;
117
- buildId: Schema.NullOr<typeof Schema.String>;
118
- state: typeof Schema.String;
119
- rolloutPercent: typeof Schema.Number;
120
- channel: typeof Schema.String;
121
- createdAt: typeof Schema.String;
122
- artifacts: typeof Schema.Number;
123
- signed: typeof Schema.Boolean;
121
+ readonly id: Schema.String;
122
+ readonly version: Schema.String;
123
+ readonly buildId: Schema.NullOr<Schema.String>;
124
+ readonly state: Schema.String;
125
+ readonly rolloutPercent: Schema.Number;
126
+ readonly channel: Schema.String;
127
+ readonly createdAt: Schema.String;
128
+ readonly artifacts: Schema.Number;
129
+ readonly signed: Schema.Boolean;
124
130
  }>;
125
131
 
126
132
  export declare const rollbackDescriptor: MutationProcedureDescriptor<"releases.rollback", Schema.Struct<{
127
- app: typeof Schema.String;
128
- channel: typeof Schema.String;
129
- reason: typeof Schema.String;
133
+ readonly app: Schema.String;
134
+ readonly channel: Schema.String;
135
+ readonly reason: Schema.String;
136
+ readonly expectedTarget: Schema.optional<Schema.Struct<{
137
+ readonly id: Schema.String;
138
+ readonly revision: Schema.Number;
139
+ }>>;
130
140
  }>, Schema.Struct<{
131
- version: Schema.NullOr<typeof Schema.String>;
132
- }>, Schema.Union<[typeof ReleaseRefused, typeof ReleaseNotFound]>>;
141
+ readonly version: Schema.NullOr<Schema.String>;
142
+ }>, Schema.Union<readonly [typeof ReleaseRefused, typeof ReleaseNotFound]>>;
133
143
 
134
144
  export declare const rolloutDescriptor: MutationProcedureDescriptor<"releases.rollout", Schema.Struct<{
135
- app: typeof Schema.String;
136
- channel: typeof Schema.String;
137
- percent: typeof Schema.Number;
145
+ readonly app: Schema.String;
146
+ readonly channel: Schema.String;
147
+ readonly percent: Schema.Number;
148
+ readonly expectedTarget: Schema.optional<Schema.Struct<{
149
+ readonly id: Schema.String;
150
+ readonly revision: Schema.Number;
151
+ }>>;
138
152
  }>, Schema.Struct<{
139
- version: typeof Schema.String;
140
- rolloutPercent: typeof Schema.Number;
141
- }>, Schema.Union<[typeof ReleaseRefused, typeof ReleaseNotFound]>>;
153
+ readonly version: Schema.String;
154
+ readonly rolloutPercent: Schema.Number;
155
+ }>, Schema.Union<readonly [typeof ReleaseRefused, typeof ReleaseNotFound]>>;
142
156
 
143
157
  export declare const setPolicyDescriptor: MutationProcedureDescriptor<"releases.setPolicy", Schema.Struct<{
144
- app: typeof Schema.String;
145
- channel: typeof Schema.String;
146
- minSupportedVersion: Schema.optional<Schema.NullOr<typeof Schema.String>>;
147
- killSwitches: Schema.optional<Schema.Record$<typeof Schema.String, Schema.Array$<typeof Schema.String>>>;
148
- reason: typeof Schema.String;
158
+ readonly expectedTarget: Schema.optional<Schema.Struct<{
159
+ readonly id: Schema.String;
160
+ readonly revision: Schema.Number;
161
+ }>>;
162
+ readonly app: Schema.String;
163
+ readonly channel: Schema.String;
164
+ readonly minSupportedVersion: Schema.optional<Schema.NullOr<Schema.String>>;
165
+ readonly killSwitches: Schema.optional<Schema.$Record<Schema.String, Schema.$Array<Schema.String>>>;
166
+ readonly reason: Schema.String;
149
167
  }>, Schema.Struct<{
150
- app: typeof Schema.String;
151
- channel: typeof Schema.String;
152
- latestVersion: Schema.NullOr<typeof Schema.String>;
153
- minSupportedVersion: Schema.NullOr<typeof Schema.String>;
154
- killSwitches: Schema.Record$<typeof Schema.String, Schema.Array$<typeof Schema.String>>;
155
- rolloutPercent: typeof Schema.Number;
156
- rolloutSalt: Schema.NullOr<typeof Schema.String>;
157
- cohorts: Schema.NullOr<Schema.Array$<typeof Schema.String>>;
158
- }>, Schema.Union<[typeof ReleaseRefused, typeof ReleaseNotFound]>>;
168
+ readonly app: Schema.String;
169
+ readonly channel: Schema.String;
170
+ readonly latestVersion: Schema.NullOr<Schema.String>;
171
+ readonly minSupportedVersion: Schema.NullOr<Schema.String>;
172
+ readonly killSwitches: Schema.$Record<Schema.String, Schema.$Array<Schema.String>>;
173
+ readonly rolloutPercent: Schema.Number;
174
+ readonly rolloutSalt: Schema.NullOr<Schema.String>;
175
+ readonly cohorts: Schema.NullOr<Schema.$Array<Schema.String>>;
176
+ }>, Schema.Union<readonly [typeof ReleaseRefused, typeof ReleaseNotFound]>>;
159
177
 
160
178
  export declare const uploadDescriptor: MutationProcedureDescriptor<"releases.upload", Schema.Struct<{
161
- releaseId: typeof Schema.String;
162
- kind: typeof Schema.String;
163
- target: Schema.optional<typeof Schema.String>;
164
- url: typeof Schema.String;
165
- sha256: typeof Schema.String;
166
- size: typeof Schema.Number;
167
- signature: Schema.optional<typeof Schema.String>;
168
- notarized: Schema.optional<typeof Schema.Boolean>;
169
- assetKey: Schema.optional<typeof Schema.String>;
170
- contentType: Schema.optional<typeof Schema.String>;
179
+ readonly expectedTarget: Schema.optional<Schema.Struct<{
180
+ readonly id: Schema.String;
181
+ readonly revision: Schema.Number;
182
+ }>>;
183
+ readonly releaseId: Schema.String;
184
+ readonly kind: Schema.String;
185
+ readonly target: Schema.optional<Schema.String>;
186
+ readonly url: Schema.String;
187
+ readonly sha256: Schema.String;
188
+ readonly size: Schema.Number;
189
+ readonly signature: Schema.optional<Schema.String>;
190
+ readonly notarized: Schema.optional<Schema.Boolean>;
191
+ readonly assetKey: Schema.optional<Schema.String>;
192
+ readonly contentType: Schema.optional<Schema.String>;
171
193
  }>, Schema.Struct<{
172
- id: typeof Schema.String;
173
- }>, Schema.Union<[typeof ReleaseRefused, typeof ReleaseNotFound]>>;
194
+ readonly id: Schema.String;
195
+ }>, Schema.Union<readonly [typeof ReleaseRefused, typeof ReleaseNotFound]>>;
174
196
 
175
197
  export { }
package/dist/rpc.js CHANGED
@@ -1,2 +1,2 @@
1
- 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";
1
+ 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-DrfZqJIA.js";
2
2
  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.js CHANGED
@@ -1,5 +1,5 @@
1
1
  import { n as e } from "./rollout-CGRKMTfv.js";
2
- import { t } from "./rpc-U7ytx6SC.js";
2
+ import { t } from "./rpc-DrfZqJIA.js";
3
3
  import { pluginTag as n } from "@voltro/protocol";
4
4
  import { createElement as r, useEffect as i, useRef as a } from "react";
5
5
  import { usePlatform as o, useSubscription as s } from "@voltro/client";
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@voltro/plugin-releases",
3
- "version": "0.83.1",
3
+ "version": "0.85.0",
4
4
  "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.",
5
5
  "keywords": [
6
6
  "voltro",
@@ -48,14 +48,14 @@
48
48
  "node": ">=24.0.0"
49
49
  },
50
50
  "dependencies": {
51
- "@voltro/client": "0.83.1",
52
- "@voltro/database": "0.83.1",
53
- "@voltro/logger": "0.83.1",
54
- "@voltro/protocol": "0.83.1",
55
- "@voltro/runtime": "0.83.1"
51
+ "@voltro/client": "0.85.0",
52
+ "@voltro/database": "0.85.0",
53
+ "@voltro/logger": "0.85.0",
54
+ "@voltro/protocol": "0.85.0",
55
+ "@voltro/runtime": "0.85.0"
56
56
  },
57
57
  "peerDependencies": {
58
- "effect": "^3.22.2",
58
+ "effect": "4.0.1",
59
59
  "react": "^19.0.0"
60
60
  },
61
61
  "peerDependenciesMeta": {