@rebon/cli-win32-x64 1.3.0 → 1.5.0

package/payload/compose-runtime/payload/vendor/dsh/timeout.js

@@ -1,100 +1,100 @@
-// packages/util/timeout/src/index.ts
-var TimeoutReason = class extends Error {
-  /**
-   * @param code Capability-owned timeout code (e.g. `BASH_TIMEOUT`).
-   * @param timeoutMs The deadline that elapsed, in milliseconds.
-   */
-  constructor(code, timeoutMs) {
-    super(`${code} after ${timeoutMs}ms`);
-    this.code = code;
-    this.timeoutMs = timeoutMs;
-  }
-  code;
-  timeoutMs;
-  name = "TimeoutReason";
-};
-var MAX_TIMER_DELAY_MS = 2147483647;
-function assertTimerDelay(timeoutMs, name) {
-  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0 || timeoutMs > MAX_TIMER_DELAY_MS) {
-    throw new Error(`${name} must be a positive finite number no greater than ${MAX_TIMER_DELAY_MS}`);
-  }
-}
-function clampTimeout(requested, def, max, name = "timeoutMs") {
-  if (requested !== void 0 && (!Number.isFinite(requested) || requested <= 0)) {
-    throw new Error(`${name} must be a positive finite number`);
-  }
-  return Math.min(requested ?? def, max);
-}
-function deadline(upstream, timeoutMs, code) {
-  if (timeoutMs <= 0) {
-    return { signal: upstream ?? new AbortController().signal, [Symbol.dispose]() {
-    } };
-  }
-  assertTimerDelay(timeoutMs, "deadline timeoutMs");
-  const timer = new AbortController();
-  const id = setTimeout(() => {
-    timer.abort(new TimeoutReason(code, timeoutMs));
-  }, timeoutMs);
-  return {
-    // AbortSignal.any adopts the reason of whichever source aborts FIRST, so a
-    // race resolves to a single cause: timeoutOf() reads TimeoutReason only
-    // when the timeout won, and upstream-wins leaves an ordinary abort reason.
-    signal: upstream !== void 0 ? AbortSignal.any([upstream, timer.signal]) : timer.signal,
-    [Symbol.dispose]() {
-      clearTimeout(id);
-    }
-  };
-}
-function idleWatchdog(upstream, timeoutMs, code) {
-  assertTimerDelay(timeoutMs, "idleWatchdog timeoutMs");
-  const timeout = new AbortController();
-  const signal = upstream === void 0 ? timeout.signal : AbortSignal.any([upstream, timeout.signal]);
-  let timer;
-  let outstanding = false;
-  let disposed = false;
-  const arm = () => {
-    if (timer !== void 0) clearTimeout(timer);
-    timer = setTimeout(() => {
-      timeout.abort(new TimeoutReason(code, timeoutMs));
-    }, timeoutMs);
-  };
-  return {
-    signal,
-    async next(iterator) {
-      if (disposed) throw new Error("idleWatchdog is disposed");
-      if (outstanding) throw new Error("idleWatchdog next is already outstanding");
-      outstanding = true;
-      arm();
-      try {
-        return await iterator.next();
-      } finally {
-        clearTimeout(timer);
-        timer = void 0;
-        outstanding = false;
-      }
-    },
-    pulse() {
-      if (disposed || !outstanding) return;
-      arm();
-    },
-    [Symbol.dispose]() {
-      if (disposed) return;
-      disposed = true;
-      if (timer !== void 0) clearTimeout(timer);
-      timer = void 0;
-    }
-  };
-}
-function timeoutOf(x, code) {
-  const reason = x.reason;
-  if (!(reason instanceof TimeoutReason)) return void 0;
-  return code === void 0 || reason.code === code ? reason : void 0;
-}
-export {
-  MAX_TIMER_DELAY_MS,
-  TimeoutReason,
-  clampTimeout,
-  deadline,
-  idleWatchdog,
-  timeoutOf
-};
+// packages/util/timeout/src/index.ts
+var TimeoutReason = class extends Error {
+  /**
+   * @param code Capability-owned timeout code (e.g. `BASH_TIMEOUT`).
+   * @param timeoutMs The deadline that elapsed, in milliseconds.
+   */
+  constructor(code, timeoutMs) {
+    super(`${code} after ${timeoutMs}ms`);
+    this.code = code;
+    this.timeoutMs = timeoutMs;
+  }
+  code;
+  timeoutMs;
+  name = "TimeoutReason";
+};
+var MAX_TIMER_DELAY_MS = 2147483647;
+function assertTimerDelay(timeoutMs, name) {
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0 || timeoutMs > MAX_TIMER_DELAY_MS) {
+    throw new Error(`${name} must be a positive finite number no greater than ${MAX_TIMER_DELAY_MS}`);
+  }
+}
+function clampTimeout(requested, def, max, name = "timeoutMs") {
+  if (requested !== void 0 && (!Number.isFinite(requested) || requested <= 0)) {
+    throw new Error(`${name} must be a positive finite number`);
+  }
+  return Math.min(requested ?? def, max);
+}
+function deadline(upstream, timeoutMs, code) {
+  if (timeoutMs <= 0) {
+    return { signal: upstream ?? new AbortController().signal, [Symbol.dispose]() {
+    } };
+  }
+  assertTimerDelay(timeoutMs, "deadline timeoutMs");
+  const timer = new AbortController();
+  const id = setTimeout(() => {
+    timer.abort(new TimeoutReason(code, timeoutMs));
+  }, timeoutMs);
+  return {
+    // AbortSignal.any adopts the reason of whichever source aborts FIRST, so a
+    // race resolves to a single cause: timeoutOf() reads TimeoutReason only
+    // when the timeout won, and upstream-wins leaves an ordinary abort reason.
+    signal: upstream !== void 0 ? AbortSignal.any([upstream, timer.signal]) : timer.signal,
+    [Symbol.dispose]() {
+      clearTimeout(id);
+    }
+  };
+}
+function idleWatchdog(upstream, timeoutMs, code) {
+  assertTimerDelay(timeoutMs, "idleWatchdog timeoutMs");
+  const timeout = new AbortController();
+  const signal = upstream === void 0 ? timeout.signal : AbortSignal.any([upstream, timeout.signal]);
+  let timer;
+  let outstanding = false;
+  let disposed = false;
+  const arm = () => {
+    if (timer !== void 0) clearTimeout(timer);
+    timer = setTimeout(() => {
+      timeout.abort(new TimeoutReason(code, timeoutMs));
+    }, timeoutMs);
+  };
+  return {
+    signal,
+    async next(iterator) {
+      if (disposed) throw new Error("idleWatchdog is disposed");
+      if (outstanding) throw new Error("idleWatchdog next is already outstanding");
+      outstanding = true;
+      arm();
+      try {
+        return await iterator.next();
+      } finally {
+        clearTimeout(timer);
+        timer = void 0;
+        outstanding = false;
+      }
+    },
+    pulse() {
+      if (disposed || !outstanding) return;
+      arm();
+    },
+    [Symbol.dispose]() {
+      if (disposed) return;
+      disposed = true;
+      if (timer !== void 0) clearTimeout(timer);
+      timer = void 0;
+    }
+  };
+}
+function timeoutOf(x, code) {
+  const reason = x.reason;
+  if (!(reason instanceof TimeoutReason)) return void 0;
+  return code === void 0 || reason.code === code ? reason : void 0;
+}
+export {
+  MAX_TIMER_DELAY_MS,
+  TimeoutReason,
+  clampTimeout,
+  deadline,
+  idleWatchdog,
+  timeoutOf
+};

package/payload/compose-runtime/payload/vendor/dsh/timer.js

@@ -1,128 +1,128 @@
-// dsh-vendor/timer/src/index.ts
-import { Service } from "@deepseek-ai/cordis";
-var TimerService = class extends Service {
-  constructor(ctx) {
-    super(ctx, "timer");
-    ctx.mixin("timer", ["timeout", "interval", "throttle", "debounce", "setTimeout", "setInterval"]);
-  }
-  /** @deprecated use `ctx.timeout()` instead */
-  setTimeout(callback, delay) {
-    return this.timeout(callback, delay);
-  }
-  /** @deprecated use `ctx.interval()` instead */
-  setInterval(callback, delay) {
-    return this.interval(callback, delay);
-  }
-  timeout(...args) {
-    const callback = typeof args[0] === "function" ? args.shift() : void 0;
-    const delay = args[0];
-    if (callback) {
-      const dispose = this.ctx.effect(() => {
-        const timer = setTimeout(() => {
-          dispose();
-          callback();
-        }, delay);
-        return () => clearTimeout(timer);
-      }, "ctx.timeout()");
-      return dispose;
-    } else {
-      const { promise, resolve, reject } = Promise.withResolvers();
-      const dispose = this.ctx.effect(() => {
-        const timer = setTimeout(resolve, delay);
-        return () => {
-          clearTimeout(timer);
-          reject(new Error("Context has been disposed"));
-        };
-      }, "ctx.timeout()");
-      return promise.finally(dispose);
-    }
-  }
-  interval(...args) {
-    const callback = typeof args[0] === "function" ? args.shift() : void 0;
-    const delay = args[0];
-    if (callback) {
-      return this.ctx.effect(() => {
-        const timer = setInterval(callback, delay);
-        return () => clearInterval(timer);
-      }, "ctx.interval()");
-    } else {
-      let done;
-      let nextTask;
-      const dispose = this.ctx.effect(() => {
-        const timer = setInterval(() => {
-          nextTask?.resolve({ done: false, value: void 0 });
-        }, delay);
-        return () => {
-          clearInterval(timer);
-          if (done) return;
-          done = { kind: "throw", reason: new Error("Context has been disposed") };
-          nextTask?.reject(done.reason);
-        };
-      }, "ctx.interval()");
-      return {
-        next: () => {
-          if (!done) return (nextTask = Promise.withResolvers()).promise;
-          if (done.kind === "return") return Promise.resolve({ done: true, value: done.value });
-          return Promise.reject(done.reason);
-        },
-        return: (value) => {
-          if (!done) done = { kind: "return", value };
-          nextTask?.resolve({ done: true, value });
-          dispose();
-          return Promise.resolve({ done: true, value });
-        },
-        throw: (reason) => {
-          if (!done) done = { kind: "throw", reason };
-          nextTask?.reject(reason);
-          dispose();
-          return Promise.resolve({ done: true, value: void 0 });
-        },
-        [Symbol.asyncIterator]() {
-          return this;
-        }
-      };
-    }
-  }
-  _schedule(label, trigger, isDisposed = false) {
-    let timer;
-    const dispose = this.ctx.effect(() => () => {
-      isDisposed = true;
-      clearTimeout(timer);
-    }, label);
-    const wrapper = (...args) => {
-      clearTimeout(timer);
-      timer = trigger(args, isDisposed);
-    };
-    wrapper.dispose = dispose;
-    return wrapper;
-  }
-  /** Return a throttled function whose timer is disposed with the current fiber. */
-  throttle(callback, delay, noTrailing) {
-    let lastCall = -Infinity;
-    const execute = (...args) => {
-      lastCall = Date.now();
-      callback(...args);
-    };
-    return this._schedule("ctx.throttle()", (args, isDisposed) => {
-      const now = Date.now();
-      const remaining = delay - now + lastCall;
-      if (remaining <= 0) {
-        execute(...args);
-      } else if (!isDisposed) {
-        return setTimeout(execute, remaining, ...args);
-      }
-    }, noTrailing);
-  }
-  /** Return a debounced function whose timer is disposed with the current fiber. */
-  debounce(callback, delay) {
-    return this._schedule("ctx.debounce()", (args, isDisposed) => {
-      if (isDisposed) return;
-      return setTimeout(callback, delay, ...args);
-    });
-  }
-};
-var index_default = TimerService;
-export {
-  TimerService,
-  index_default as default
-};
+// dsh-vendor/timer/src/index.ts
+import { Service } from "@deepseek-ai/cordis";
+var TimerService = class extends Service {
+  constructor(ctx) {
+    super(ctx, "timer");
+    ctx.mixin("timer", ["timeout", "interval", "throttle", "debounce", "setTimeout", "setInterval"]);
+  }
+  /** @deprecated use `ctx.timeout()` instead */
+  setTimeout(callback, delay) {
+    return this.timeout(callback, delay);
+  }
+  /** @deprecated use `ctx.interval()` instead */
+  setInterval(callback, delay) {
+    return this.interval(callback, delay);
+  }
+  timeout(...args) {
+    const callback = typeof args[0] === "function" ? args.shift() : void 0;
+    const delay = args[0];
+    if (callback) {
+      const dispose = this.ctx.effect(() => {
+        const timer = setTimeout(() => {
+          dispose();
+          callback();
+        }, delay);
+        return () => clearTimeout(timer);
+      }, "ctx.timeout()");
+      return dispose;
+    } else {
+      const { promise, resolve, reject } = Promise.withResolvers();
+      const dispose = this.ctx.effect(() => {
+        const timer = setTimeout(resolve, delay);
+        return () => {
+          clearTimeout(timer);
+          reject(new Error("Context has been disposed"));
+        };
+      }, "ctx.timeout()");
+      return promise.finally(dispose);
+    }
+  }
+  interval(...args) {
+    const callback = typeof args[0] === "function" ? args.shift() : void 0;
+    const delay = args[0];
+    if (callback) {
+      return this.ctx.effect(() => {
+        const timer = setInterval(callback, delay);
+        return () => clearInterval(timer);
+      }, "ctx.interval()");
+    } else {
+      let done;
+      let nextTask;
+      const dispose = this.ctx.effect(() => {
+        const timer = setInterval(() => {
+          nextTask?.resolve({ done: false, value: void 0 });
+        }, delay);
+        return () => {
+          clearInterval(timer);
+          if (done) return;
+          done = { kind: "throw", reason: new Error("Context has been disposed") };
+          nextTask?.reject(done.reason);
+        };
+      }, "ctx.interval()");
+      return {
+        next: () => {
+          if (!done) return (nextTask = Promise.withResolvers()).promise;
+          if (done.kind === "return") return Promise.resolve({ done: true, value: done.value });
+          return Promise.reject(done.reason);
+        },
+        return: (value) => {
+          if (!done) done = { kind: "return", value };
+          nextTask?.resolve({ done: true, value });
+          dispose();
+          return Promise.resolve({ done: true, value });
+        },
+        throw: (reason) => {
+          if (!done) done = { kind: "throw", reason };
+          nextTask?.reject(reason);
+          dispose();
+          return Promise.resolve({ done: true, value: void 0 });
+        },
+        [Symbol.asyncIterator]() {
+          return this;
+        }
+      };
+    }
+  }
+  _schedule(label, trigger, isDisposed = false) {
+    let timer;
+    const dispose = this.ctx.effect(() => () => {
+      isDisposed = true;
+      clearTimeout(timer);
+    }, label);
+    const wrapper = (...args) => {
+      clearTimeout(timer);
+      timer = trigger(args, isDisposed);
+    };
+    wrapper.dispose = dispose;
+    return wrapper;
+  }
+  /** Return a throttled function whose timer is disposed with the current fiber. */
+  throttle(callback, delay, noTrailing) {
+    let lastCall = -Infinity;
+    const execute = (...args) => {
+      lastCall = Date.now();
+      callback(...args);
+    };
+    return this._schedule("ctx.throttle()", (args, isDisposed) => {
+      const now = Date.now();
+      const remaining = delay - now + lastCall;
+      if (remaining <= 0) {
+        execute(...args);
+      } else if (!isDisposed) {
+        return setTimeout(execute, remaining, ...args);
+      }
+    }, noTrailing);
+  }
+  /** Return a debounced function whose timer is disposed with the current fiber. */
+  debounce(callback, delay) {
+    return this._schedule("ctx.debounce()", (args, isDisposed) => {
+      if (isDisposed) return;
+      return setTimeout(callback, delay, ...args);
+    });
+  }
+};
+var index_default = TimerService;
+export {
+  TimerService,
+  index_default as default
+};