durability 4.1.1 → 4.2.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.
@@ -0,0 +1,61 @@
1
+ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
2
+ if (kind === "m") throw new TypeError("Private method is not writable");
3
+ if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
4
+ if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
5
+ return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
6
+ };
7
+ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
8
+ if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
9
+ if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
10
+ return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
11
+ };
12
+ var _SemaphoreClient_instances, _SemaphoreClient_config, _SemaphoreClient_nextRequestAt, _SemaphoreClient_address;
13
+ import { SemaphoreProtocolError } from './errors.js';
14
+ import { permitGrantSchema, permitSyncResultSchema, } from './semaphore-protocol.js';
15
+ /**
16
+ * Transport-independent protocol core. Validates responses and remembers each
17
+ * key's `nextRequestAt` so callers can pace requests the way the holder asked.
18
+ */
19
+ export class SemaphoreClient {
20
+ constructor(config) {
21
+ _SemaphoreClient_instances.add(this);
22
+ _SemaphoreClient_config.set(this, void 0);
23
+ _SemaphoreClient_nextRequestAt.set(this, new Map());
24
+ __classPrivateFieldSet(this, _SemaphoreClient_config, config, "f");
25
+ }
26
+ /** Earliest time the holder of `key` accepts another request, if known. */
27
+ nextRequestAt(key) {
28
+ return __classPrivateFieldGet(this, _SemaphoreClient_nextRequestAt, "f").get(key);
29
+ }
30
+ async request(key, message) {
31
+ const response = await __classPrivateFieldGet(this, _SemaphoreClient_config, "f").invoke(__classPrivateFieldGet(this, _SemaphoreClient_instances, "m", _SemaphoreClient_address).call(this, key), message);
32
+ const parsed = permitGrantSchema.safeParse(response);
33
+ if (!parsed.success) {
34
+ throw new SemaphoreProtocolError(`Unexpected response to a permit request for "${key}"`);
35
+ }
36
+ __classPrivateFieldGet(this, _SemaphoreClient_nextRequestAt, "f").set(key, parsed.data.nextRequestAt);
37
+ // Advisory state must stay bounded for high-cardinality keys.
38
+ if (__classPrivateFieldGet(this, _SemaphoreClient_nextRequestAt, "f").size > 1024) {
39
+ const oldest = __classPrivateFieldGet(this, _SemaphoreClient_nextRequestAt, "f").keys().next().value;
40
+ if (oldest !== undefined) {
41
+ __classPrivateFieldGet(this, _SemaphoreClient_nextRequestAt, "f").delete(oldest);
42
+ }
43
+ }
44
+ return parsed.data;
45
+ }
46
+ async sync(key, message) {
47
+ const response = await __classPrivateFieldGet(this, _SemaphoreClient_config, "f").invoke(__classPrivateFieldGet(this, _SemaphoreClient_instances, "m", _SemaphoreClient_address).call(this, key), message);
48
+ const parsed = permitSyncResultSchema.safeParse(response);
49
+ if (!parsed.success) {
50
+ throw new SemaphoreProtocolError(`Unexpected response to a permit sync for "${key}"`);
51
+ }
52
+ return parsed.data;
53
+ }
54
+ }
55
+ _SemaphoreClient_config = new WeakMap(), _SemaphoreClient_nextRequestAt = new WeakMap(), _SemaphoreClient_instances = new WeakSet(), _SemaphoreClient_address = function _SemaphoreClient_address(key) {
56
+ if (typeof key !== 'string' || key.length === 0) {
57
+ throw new SemaphoreProtocolError('Semaphore keys must be non-empty strings');
58
+ }
59
+ const locationHint = __classPrivateFieldGet(this, _SemaphoreClient_config, "f").locationHint?.(key);
60
+ return locationHint === undefined ? { key } : { key, locationHint };
61
+ };
@@ -0,0 +1,109 @@
1
+ import type { LeaseGrant, LeaseReport, SemaphoreBlockedReason } from './semaphore-protocol.js';
2
+ import type { HolderStore, LeaseRow } from './semaphore-store.js';
3
+ /**
4
+ * Where lease capacity comes from.
5
+ *
6
+ * - `over`: leases draw from a separate budget above the limit, so the
7
+ * ceiling is `limit + extra` (the original gatekeeper behaviour).
8
+ * - `under`: a slice of the limit is reserved for leases; grants may use at
9
+ * most `limit - reserve`, and always at least one permit. Nothing ever
10
+ * exceeds the limit and leases have guaranteed headroom.
11
+ * - `strict`: grants and live lease footprint share the limit, grants first.
12
+ */
13
+ export type SemaphoreProvisioning = {
14
+ mode: 'strict';
15
+ } | {
16
+ mode: 'under';
17
+ reserve: number | {
18
+ ratio: number;
19
+ };
20
+ } | {
21
+ mode: 'over';
22
+ extra: number | {
23
+ ratio: number;
24
+ };
25
+ };
26
+ export type SemaphoreLeaseOptions = {
27
+ provisioning: SemaphoreProvisioning;
28
+ /** Permits per lease. Defaults to 64. */
29
+ permitsPerLease?: number;
30
+ /** A lease not reported for this long is swept. Defaults to 30 minutes. */
31
+ ttlMs?: number;
32
+ /** Groups that may receive new leases in one round, oldest demand first. Defaults to 100. */
33
+ maxGroups?: number;
34
+ /** Clients per group that may receive new leases in one round. Defaults to 100. */
35
+ maxClientsPerGroup?: number;
36
+ /**
37
+ * Groups with a `groupLimit`: `exclude` them from leases (exact steady
38
+ * state only, as gatekeeper does) or lease `withinGroupLimit`. Defaults to
39
+ * `exclude`.
40
+ */
41
+ limitedGroups?: 'exclude' | 'withinGroupLimit';
42
+ };
43
+ export type LeasePolicy = Required<SemaphoreLeaseOptions>;
44
+ export type LeaseEvent = {
45
+ entityKind: 'semaphore';
46
+ type: 'lease_granted' | 'lease_retired';
47
+ timestamp: number;
48
+ leaseId: string;
49
+ clientId: string;
50
+ group: string;
51
+ permits: number;
52
+ };
53
+ type GroupPolicy = {
54
+ limit?: number;
55
+ blocked?: SemaphoreBlockedReason;
56
+ };
57
+ export declare const resolveLeasePolicy: (options: SemaphoreLeaseOptions) => LeasePolicy;
58
+ /** Permits grants may use, and permits leases may hold, for one limit. */
59
+ export declare const budgets: (provisioning: SemaphoreProvisioning, limit: number) => {
60
+ grants: number;
61
+ leases: number;
62
+ shared: boolean;
63
+ };
64
+ export declare const leaseFootprint: (lease: LeaseRow) => number;
65
+ export declare const leaseEligible: (policy: LeasePolicy, group: GroupPolicy) => boolean;
66
+ export type LeaseReportOutcome = {
67
+ /** Echoed grants: refreshed live leases and retired (`expiresAt = now`) ones. */
68
+ echoes: LeaseGrant[];
69
+ /** Live footprint of leases the holder no longer knows, charged this round. */
70
+ unknownDebt: number;
71
+ /** Reported `drawn` per lease, so undrawn headroom can be seen. */
72
+ drawn: Map<string, number>;
73
+ };
74
+ /**
75
+ * Applies one client's lease reports: heartbeats live leases, advances the
76
+ * release high-water mark, retires leases the holder forgot or that expired,
77
+ * and charges their reported live footprint so a forgotten lease cannot
78
+ * over-admit for the rest of this round.
79
+ */
80
+ export declare const applyLeaseReports: (store: HolderStore, policy: LeasePolicy, clientId: string, reports: LeaseReport[], now: number) => LeaseReportOutcome;
81
+ export type LeaseCandidate = {
82
+ clientId: string;
83
+ group: string;
84
+ oldestAt: number;
85
+ };
86
+ export type LeaseAllocation = {
87
+ /** New and retired leases per client. */
88
+ grants: Map<string, LeaseGrant[]>;
89
+ footprint: number;
90
+ events: LeaseEvent[];
91
+ /** Some eligible candidate received no lease this round. */
92
+ unserved: boolean;
93
+ };
94
+ /**
95
+ * One round's lease pass: sweeps expired leases, retires leases of groups no
96
+ * longer eligible, computes the live footprint, and shares the lease budget
97
+ * equally among candidates that do not already hold usable headroom.
98
+ */
99
+ export declare const allocateLeases: (store: HolderStore, policy: LeasePolicy, input: {
100
+ budget: number;
101
+ unknownDebt: number;
102
+ drawn: ReadonlyMap<string, number>;
103
+ candidates: LeaseCandidate[];
104
+ policies: ReadonlyMap<string, GroupPolicy>;
105
+ /** Group permits already used by grants, for `withinGroupLimit`. */
106
+ groupUsed: ReadonlyMap<string, number>;
107
+ now: number;
108
+ }) => LeaseAllocation;
109
+ export {};
@@ -0,0 +1,266 @@
1
+ import { assertPositiveInteger } from './policy.js';
2
+ const maxDelayMs = 2 ** 31 - 1;
3
+ export const resolveLeasePolicy = (options) => {
4
+ const policy = {
5
+ provisioning: options.provisioning,
6
+ permitsPerLease: options.permitsPerLease ?? 64,
7
+ ttlMs: options.ttlMs ?? 30 * 60000,
8
+ maxGroups: options.maxGroups ?? 100,
9
+ maxClientsPerGroup: options.maxClientsPerGroup ?? 100,
10
+ limitedGroups: options.limitedGroups ?? 'exclude',
11
+ };
12
+ for (const name of [
13
+ 'permitsPerLease',
14
+ 'ttlMs',
15
+ 'maxGroups',
16
+ 'maxClientsPerGroup',
17
+ ]) {
18
+ assertPositiveInteger(`leases.${name}`, policy[name]);
19
+ }
20
+ if (policy.ttlMs > maxDelayMs) {
21
+ throw new RangeError(`leases.ttlMs must be at most ${maxDelayMs}`);
22
+ }
23
+ const amount = policy.provisioning.mode === 'under'
24
+ ? policy.provisioning.reserve
25
+ : policy.provisioning.mode === 'over'
26
+ ? policy.provisioning.extra
27
+ : undefined;
28
+ if (amount !== undefined) {
29
+ const value = typeof amount === 'number' ? amount : amount.ratio;
30
+ if (!Number.isFinite(value) || value < 0) {
31
+ throw new RangeError('lease provisioning amounts must be non-negative');
32
+ }
33
+ }
34
+ return policy;
35
+ };
36
+ const scaled = (amount, limit) => typeof amount === 'number' ? amount : Math.floor(limit * amount.ratio);
37
+ /** Permits grants may use, and permits leases may hold, for one limit. */
38
+ export const budgets = (provisioning, limit) => {
39
+ if (provisioning.mode === 'over') {
40
+ return {
41
+ grants: limit,
42
+ leases: scaled(provisioning.extra, limit),
43
+ shared: false,
44
+ };
45
+ }
46
+ if (provisioning.mode === 'under') {
47
+ // The reserve never takes the last permit: groups excluded from leases and
48
+ // clients without lease support would otherwise never be admitted.
49
+ const reserve = Math.min(Math.max(0, limit - 1), scaled(provisioning.reserve, limit));
50
+ return { grants: limit - reserve, leases: reserve, shared: false };
51
+ }
52
+ return { grants: limit, leases: limit, shared: true };
53
+ };
54
+ export const leaseFootprint = (lease) => Math.max(0, lease.permits - lease.released);
55
+ /** A retired lease is echoed as expired so the client stops drawing at once. */
56
+ const toLeaseGrant = (lease, now) => ({
57
+ leaseId: lease.lease_id,
58
+ group: lease.grp,
59
+ permits: lease.permits,
60
+ expiresAt: lease.retired ? now : lease.expires_at,
61
+ });
62
+ export const leaseEligible = (policy, group) => group.blocked === undefined &&
63
+ (group.limit === undefined || policy.limitedGroups === 'withinGroupLimit');
64
+ /**
65
+ * Applies one client's lease reports: heartbeats live leases, advances the
66
+ * release high-water mark, retires leases the holder forgot or that expired,
67
+ * and charges their reported live footprint so a forgotten lease cannot
68
+ * over-admit for the rest of this round.
69
+ */
70
+ export const applyLeaseReports = (store, policy, clientId, reports, now) => {
71
+ const outcome = {
72
+ echoes: [],
73
+ unknownDebt: 0,
74
+ drawn: new Map(),
75
+ };
76
+ for (const report of reports) {
77
+ const lease = store.getLease(report.leaseId);
78
+ if (!lease || lease.client_id !== clientId || lease.expires_at <= now) {
79
+ outcome.echoes.push({
80
+ leaseId: report.leaseId,
81
+ group: lease?.grp ?? '',
82
+ permits: lease?.permits ?? 0,
83
+ expiresAt: now,
84
+ });
85
+ // Client-reported usage is untrusted: clamp before it can affect budget.
86
+ const live = Math.max(0, report.drawn - Math.max(0, report.released));
87
+ outcome.unknownDebt += Math.min(live, policy.permitsPerLease);
88
+ continue;
89
+ }
90
+ const drawn = Math.min(Math.max(0, report.drawn), lease.permits);
91
+ outcome.drawn.set(lease.lease_id, drawn);
92
+ const released = Math.max(lease.released, Math.min(Math.max(0, report.released), drawn));
93
+ // Only the client's own retired report shrinks a lease to what it drew:
94
+ // until then it may still be drawing, whoever asked it to stop.
95
+ const retired = lease.retired === 1 || report.retired === true;
96
+ const permits = report.retired === true ? Math.max(released, drawn) : lease.permits;
97
+ if (released >= permits) {
98
+ store.removeLease(lease.lease_id);
99
+ outcome.echoes.push({ ...toLeaseGrant(lease, now), expiresAt: now });
100
+ continue;
101
+ }
102
+ const refreshed = {
103
+ ...lease,
104
+ permits,
105
+ released,
106
+ retired: retired ? 1 : 0,
107
+ expires_at: now + policy.ttlMs,
108
+ };
109
+ store.updateLease(refreshed);
110
+ outcome.echoes.push(toLeaseGrant(refreshed, now));
111
+ }
112
+ return outcome;
113
+ };
114
+ /**
115
+ * One round's lease pass: sweeps expired leases, retires leases of groups no
116
+ * longer eligible, computes the live footprint, and shares the lease budget
117
+ * equally among candidates that do not already hold usable headroom.
118
+ */
119
+ export const allocateLeases = (store, policy, input) => {
120
+ const { now } = input;
121
+ const grants = new Map();
122
+ const events = [];
123
+ const echo = (clientId, grant) => {
124
+ grants.set(clientId, [...(grants.get(clientId) ?? []), grant]);
125
+ };
126
+ let footprint = 0;
127
+ const groupFootprint = new Map();
128
+ const usable = new Set();
129
+ for (const lease of store.listLeases()) {
130
+ if (lease.expires_at <= now) {
131
+ store.removeLease(lease.lease_id);
132
+ continue;
133
+ }
134
+ const group = input.policies.get(lease.grp) ?? {};
135
+ let current = lease;
136
+ if (!lease.retired && !leaseEligible(policy, group)) {
137
+ // Stop draws now; the full footprint stays until the client confirms.
138
+ current = { ...lease, retired: 1 };
139
+ store.updateLease(current);
140
+ echo(lease.client_id, toLeaseGrant(current, now));
141
+ events.push({
142
+ entityKind: 'semaphore',
143
+ type: 'lease_retired',
144
+ timestamp: now,
145
+ leaseId: lease.lease_id,
146
+ clientId: lease.client_id,
147
+ group: lease.grp,
148
+ permits: lease.permits - (input.drawn.get(lease.lease_id) ?? lease.permits),
149
+ });
150
+ }
151
+ const live = leaseFootprint(current);
152
+ footprint += live;
153
+ groupFootprint.set(lease.grp, (groupFootprint.get(lease.grp) ?? 0) + live);
154
+ // An unreported lease is assumed fully drawn, as gatekeeper does.
155
+ if (!current.retired &&
156
+ (input.drawn.get(lease.lease_id) ?? lease.permits) < lease.permits) {
157
+ usable.add(JSON.stringify([lease.client_id, lease.grp]));
158
+ }
159
+ }
160
+ const byGroup = new Map();
161
+ for (const candidate of input.candidates) {
162
+ if (!leaseEligible(policy, input.policies.get(candidate.group) ?? {}) ||
163
+ usable.has(JSON.stringify([candidate.clientId, candidate.group]))) {
164
+ continue;
165
+ }
166
+ const existing = byGroup.get(candidate.group) ?? [];
167
+ const prior = existing.find((c) => c.clientId === candidate.clientId);
168
+ if (prior) {
169
+ prior.oldestAt = Math.min(prior.oldestAt, candidate.oldestAt);
170
+ }
171
+ else {
172
+ existing.push({ ...candidate });
173
+ }
174
+ byGroup.set(candidate.group, existing);
175
+ }
176
+ const chosen = [...byGroup.entries()]
177
+ .map(([group, clients]) => ({
178
+ group,
179
+ clients: clients
180
+ .sort((a, b) => a.oldestAt - b.oldestAt || a.clientId.localeCompare(b.clientId))
181
+ .slice(0, policy.maxClientsPerGroup),
182
+ oldestAt: Math.min(...clients.map((c) => c.oldestAt)),
183
+ }))
184
+ .sort((a, b) => a.oldestAt - b.oldestAt || a.group.localeCompare(b.group))
185
+ .slice(0, policy.maxGroups)
186
+ .flatMap(({ clients }) => clients);
187
+ // A lowered budget retires leases with undrawn headroom, newest first, until
188
+ // the headroom their clients reported covers the excess. Their footprint
189
+ // stays until each client confirms what it actually drew.
190
+ let excess = footprint + input.unknownDebt - input.budget;
191
+ if (excess > 0) {
192
+ const live = store
193
+ .listLeases()
194
+ .filter((lease) => lease.expires_at > now && !lease.retired)
195
+ .sort((a, b) => b.created_at - a.created_at);
196
+ for (const lease of live) {
197
+ if (excess <= 0) {
198
+ break;
199
+ }
200
+ const drawn = input.drawn.get(lease.lease_id);
201
+ if (drawn === undefined || drawn >= lease.permits) {
202
+ continue;
203
+ }
204
+ const retired = { ...lease, retired: 1 };
205
+ store.updateLease(retired);
206
+ excess -= lease.permits - drawn;
207
+ echo(lease.client_id, toLeaseGrant(retired, now));
208
+ events.push({
209
+ entityKind: 'semaphore',
210
+ type: 'lease_retired',
211
+ timestamp: now,
212
+ leaseId: lease.lease_id,
213
+ clientId: lease.client_id,
214
+ group: lease.grp,
215
+ permits: lease.permits - drawn,
216
+ });
217
+ }
218
+ }
219
+ const eligible = [...byGroup.values()].reduce((n, clients) => n + clients.length, 0);
220
+ let remaining = Math.max(0, input.budget - footprint - input.unknownDebt);
221
+ // With fewer permits than candidates, the oldest demand gets one each
222
+ // rather than everyone getting a rounded-down share of nothing.
223
+ const share = Math.min(policy.permitsPerLease, Math.max(1, Math.floor(remaining / Math.max(1, chosen.length))));
224
+ let issued = 0;
225
+ for (const candidate of chosen) {
226
+ if (remaining <= 0) {
227
+ break;
228
+ }
229
+ const group = input.policies.get(candidate.group) ?? {};
230
+ const groupRoom = group.limit === undefined
231
+ ? share
232
+ : group.limit -
233
+ (input.groupUsed.get(candidate.group) ?? 0) -
234
+ (groupFootprint.get(candidate.group) ?? 0);
235
+ const permits = Math.min(share, groupRoom, remaining);
236
+ if (permits <= 0) {
237
+ continue;
238
+ }
239
+ remaining -= permits;
240
+ issued += 1;
241
+ const lease = {
242
+ lease_id: crypto.randomUUID(),
243
+ client_id: candidate.clientId,
244
+ grp: candidate.group,
245
+ permits,
246
+ released: 0,
247
+ created_at: now,
248
+ expires_at: now + policy.ttlMs,
249
+ retired: 0,
250
+ };
251
+ store.insertLease(lease);
252
+ footprint += permits;
253
+ groupFootprint.set(candidate.group, (groupFootprint.get(candidate.group) ?? 0) + permits);
254
+ echo(candidate.clientId, toLeaseGrant(lease, now));
255
+ events.push({
256
+ entityKind: 'semaphore',
257
+ type: 'lease_granted',
258
+ timestamp: now,
259
+ leaseId: lease.lease_id,
260
+ clientId: lease.client_id,
261
+ group: lease.grp,
262
+ permits,
263
+ });
264
+ }
265
+ return { grants, footprint, events, unserved: issued < eligible };
266
+ };
@@ -0,0 +1,231 @@
1
+ import { z } from 'zod';
2
+ /** Bounds one message's work so a client cannot monopolize the holder. */
3
+ export declare const maxDemandEntries = 100;
4
+ export declare const maxGrantReports = 200;
5
+ /** Cumulative counts for one grant. Replaying a report can never free capacity twice. */
6
+ export declare const grantReportSchema: z.ZodObject<{
7
+ grantId: z.ZodString;
8
+ claimed: z.ZodNumber;
9
+ released: z.ZodNumber;
10
+ }, z.core.$strip>;
11
+ export type GrantReport = z.infer<typeof grantReportSchema>;
12
+ /** Cumulative counts for one lease the client holds. */
13
+ export declare const leaseReportSchema: z.ZodObject<{
14
+ leaseId: z.ZodString;
15
+ drawn: z.ZodNumber;
16
+ released: z.ZodNumber;
17
+ retired: z.ZodOptional<z.ZodBoolean>;
18
+ }, z.core.$strip>;
19
+ export type LeaseReport = z.infer<typeof leaseReportSchema>;
20
+ export declare const leaseGrantSchema: z.ZodObject<{
21
+ leaseId: z.ZodString;
22
+ group: z.ZodString;
23
+ permits: z.ZodNumber;
24
+ expiresAt: z.ZodNumber;
25
+ }, z.core.$strip>;
26
+ export type LeaseGrant = z.infer<typeof leaseGrantSchema>;
27
+ export declare const permitRequestSchema: z.ZodObject<{
28
+ type: z.ZodLiteral<"request">;
29
+ v: z.ZodLiteral<1>;
30
+ clientId: z.ZodString;
31
+ demand: z.ZodArray<z.ZodObject<{
32
+ group: z.ZodString;
33
+ count: z.ZodNumber;
34
+ oldestAt: z.ZodNumber;
35
+ }, z.core.$strip>>;
36
+ grants: z.ZodArray<z.ZodObject<{
37
+ grantId: z.ZodString;
38
+ claimed: z.ZodNumber;
39
+ released: z.ZodNumber;
40
+ }, z.core.$strip>>;
41
+ leases: z.ZodOptional<z.ZodArray<z.ZodObject<{
42
+ leaseId: z.ZodString;
43
+ drawn: z.ZodNumber;
44
+ released: z.ZodNumber;
45
+ retired: z.ZodOptional<z.ZodBoolean>;
46
+ }, z.core.$strip>>>;
47
+ }, z.core.$strip>;
48
+ export type PermitRequest = z.infer<typeof permitRequestSchema>;
49
+ export declare const permitSyncSchema: z.ZodObject<{
50
+ type: z.ZodLiteral<"sync">;
51
+ v: z.ZodLiteral<1>;
52
+ clientId: z.ZodString;
53
+ grants: z.ZodArray<z.ZodObject<{
54
+ grantId: z.ZodString;
55
+ claimed: z.ZodNumber;
56
+ released: z.ZodNumber;
57
+ }, z.core.$strip>>;
58
+ leases: z.ZodOptional<z.ZodArray<z.ZodObject<{
59
+ leaseId: z.ZodString;
60
+ drawn: z.ZodNumber;
61
+ released: z.ZodNumber;
62
+ retired: z.ZodOptional<z.ZodBoolean>;
63
+ }, z.core.$strip>>>;
64
+ }, z.core.$strip>;
65
+ export type PermitSync = z.infer<typeof permitSyncSchema>;
66
+ export declare const semaphoreRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
67
+ type: z.ZodLiteral<"request">;
68
+ v: z.ZodLiteral<1>;
69
+ clientId: z.ZodString;
70
+ demand: z.ZodArray<z.ZodObject<{
71
+ group: z.ZodString;
72
+ count: z.ZodNumber;
73
+ oldestAt: z.ZodNumber;
74
+ }, z.core.$strip>>;
75
+ grants: z.ZodArray<z.ZodObject<{
76
+ grantId: z.ZodString;
77
+ claimed: z.ZodNumber;
78
+ released: z.ZodNumber;
79
+ }, z.core.$strip>>;
80
+ leases: z.ZodOptional<z.ZodArray<z.ZodObject<{
81
+ leaseId: z.ZodString;
82
+ drawn: z.ZodNumber;
83
+ released: z.ZodNumber;
84
+ retired: z.ZodOptional<z.ZodBoolean>;
85
+ }, z.core.$strip>>>;
86
+ }, z.core.$strip>, z.ZodObject<{
87
+ type: z.ZodLiteral<"sync">;
88
+ v: z.ZodLiteral<1>;
89
+ clientId: z.ZodString;
90
+ grants: z.ZodArray<z.ZodObject<{
91
+ grantId: z.ZodString;
92
+ claimed: z.ZodNumber;
93
+ released: z.ZodNumber;
94
+ }, z.core.$strip>>;
95
+ leases: z.ZodOptional<z.ZodArray<z.ZodObject<{
96
+ leaseId: z.ZodString;
97
+ drawn: z.ZodNumber;
98
+ released: z.ZodNumber;
99
+ retired: z.ZodOptional<z.ZodBoolean>;
100
+ }, z.core.$strip>>>;
101
+ }, z.core.$strip>], "type">;
102
+ export type SemaphoreRequest = z.infer<typeof semaphoreRequestSchema>;
103
+ export declare const semaphoreBlockedReasonSchema: z.ZodEnum<{
104
+ limit: "limit";
105
+ group_limit: "group_limit";
106
+ limit_resolution_error: "limit_resolution_error";
107
+ not_permitted: "not_permitted";
108
+ }>;
109
+ export type SemaphoreBlockedReason = z.infer<typeof semaphoreBlockedReasonSchema>;
110
+ export declare const grantResultSchema: z.ZodObject<{
111
+ grantId: z.ZodString;
112
+ claimed: z.ZodNumber;
113
+ status: z.ZodEnum<{
114
+ not_found: "not_found";
115
+ ok: "ok";
116
+ expired: "expired";
117
+ }>;
118
+ }, z.core.$strip>;
119
+ export type GrantResult = z.infer<typeof grantResultSchema>;
120
+ export declare const permitGrantSchema: z.ZodObject<{
121
+ type: z.ZodLiteral<"grant">;
122
+ v: z.ZodLiteral<1>;
123
+ grants: z.ZodArray<z.ZodObject<{
124
+ grantId: z.ZodString;
125
+ group: z.ZodString;
126
+ permits: z.ZodNumber;
127
+ }, z.core.$strip>>;
128
+ blocked: z.ZodArray<z.ZodObject<{
129
+ group: z.ZodString;
130
+ reason: z.ZodEnum<{
131
+ limit: "limit";
132
+ group_limit: "group_limit";
133
+ limit_resolution_error: "limit_resolution_error";
134
+ not_permitted: "not_permitted";
135
+ }>;
136
+ }, z.core.$strip>>;
137
+ nextRequestAt: z.ZodNumber;
138
+ grantResults: z.ZodArray<z.ZodObject<{
139
+ grantId: z.ZodString;
140
+ claimed: z.ZodNumber;
141
+ status: z.ZodEnum<{
142
+ not_found: "not_found";
143
+ ok: "ok";
144
+ expired: "expired";
145
+ }>;
146
+ }, z.core.$strip>>;
147
+ leases: z.ZodOptional<z.ZodArray<z.ZodObject<{
148
+ leaseId: z.ZodString;
149
+ group: z.ZodString;
150
+ permits: z.ZodNumber;
151
+ expiresAt: z.ZodNumber;
152
+ }, z.core.$strip>>>;
153
+ contended: z.ZodOptional<z.ZodBoolean>;
154
+ }, z.core.$strip>;
155
+ export type PermitGrant = z.infer<typeof permitGrantSchema>;
156
+ export declare const permitSyncResultSchema: z.ZodObject<{
157
+ type: z.ZodLiteral<"synced">;
158
+ v: z.ZodLiteral<1>;
159
+ grantResults: z.ZodArray<z.ZodObject<{
160
+ grantId: z.ZodString;
161
+ claimed: z.ZodNumber;
162
+ status: z.ZodEnum<{
163
+ not_found: "not_found";
164
+ ok: "ok";
165
+ expired: "expired";
166
+ }>;
167
+ }, z.core.$strip>>;
168
+ leases: z.ZodOptional<z.ZodArray<z.ZodObject<{
169
+ leaseId: z.ZodString;
170
+ group: z.ZodString;
171
+ permits: z.ZodNumber;
172
+ expiresAt: z.ZodNumber;
173
+ }, z.core.$strip>>>;
174
+ contended: z.ZodOptional<z.ZodBoolean>;
175
+ }, z.core.$strip>;
176
+ export type PermitSyncResult = z.infer<typeof permitSyncResultSchema>;
177
+ export declare const semaphoreResponseSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
178
+ type: z.ZodLiteral<"grant">;
179
+ v: z.ZodLiteral<1>;
180
+ grants: z.ZodArray<z.ZodObject<{
181
+ grantId: z.ZodString;
182
+ group: z.ZodString;
183
+ permits: z.ZodNumber;
184
+ }, z.core.$strip>>;
185
+ blocked: z.ZodArray<z.ZodObject<{
186
+ group: z.ZodString;
187
+ reason: z.ZodEnum<{
188
+ limit: "limit";
189
+ group_limit: "group_limit";
190
+ limit_resolution_error: "limit_resolution_error";
191
+ not_permitted: "not_permitted";
192
+ }>;
193
+ }, z.core.$strip>>;
194
+ nextRequestAt: z.ZodNumber;
195
+ grantResults: z.ZodArray<z.ZodObject<{
196
+ grantId: z.ZodString;
197
+ claimed: z.ZodNumber;
198
+ status: z.ZodEnum<{
199
+ not_found: "not_found";
200
+ ok: "ok";
201
+ expired: "expired";
202
+ }>;
203
+ }, z.core.$strip>>;
204
+ leases: z.ZodOptional<z.ZodArray<z.ZodObject<{
205
+ leaseId: z.ZodString;
206
+ group: z.ZodString;
207
+ permits: z.ZodNumber;
208
+ expiresAt: z.ZodNumber;
209
+ }, z.core.$strip>>>;
210
+ contended: z.ZodOptional<z.ZodBoolean>;
211
+ }, z.core.$strip>, z.ZodObject<{
212
+ type: z.ZodLiteral<"synced">;
213
+ v: z.ZodLiteral<1>;
214
+ grantResults: z.ZodArray<z.ZodObject<{
215
+ grantId: z.ZodString;
216
+ claimed: z.ZodNumber;
217
+ status: z.ZodEnum<{
218
+ not_found: "not_found";
219
+ ok: "ok";
220
+ expired: "expired";
221
+ }>;
222
+ }, z.core.$strip>>;
223
+ leases: z.ZodOptional<z.ZodArray<z.ZodObject<{
224
+ leaseId: z.ZodString;
225
+ group: z.ZodString;
226
+ permits: z.ZodNumber;
227
+ expiresAt: z.ZodNumber;
228
+ }, z.core.$strip>>>;
229
+ contended: z.ZodOptional<z.ZodBoolean>;
230
+ }, z.core.$strip>], "type">;
231
+ export type SemaphoreResponse = z.infer<typeof semaphoreResponseSchema>;