@rebon/cli-linux-x64 0.17.2 → 0.18.0

package/bin/compose-runtime/payload/vendor/dsh/logger-console.js

@@ -0,0 +1,83 @@
+// dsh-vendor/logger-console/src/shared.ts
+import { Logger } from "@deepseek-ai/cordis";
+import { Time } from "@deepseek-ai/cosmokit";
+import z from "@deepseek-ai/schemastery";
+var ConsoleExporter = class {
+  constructor(ctx, config = {}) {
+    this.ctx = ctx;
+    Object.assign(this, this.getDefaults(), config);
+    this.timestamp = Date.now();
+    ctx.logger.exporter(this);
+  }
+  ctx;
+  static name = "logger-console";
+  static Config = z.object({
+    colors: z.union([z.const(false), z.number()]),
+    maxLength: z.number(),
+    levels: z.dict(z.number()),
+    showDiff: z.boolean().default(false),
+    showTime: z.string().default("yyyy-MM-dd hh:mm:ss "),
+    label: z.object({
+      width: z.number(),
+      margin: z.number(),
+      align: z.union(["left", "right"])
+    })
+  });
+  colors;
+  maxLength;
+  levels;
+  showDiff;
+  showTime;
+  label;
+  timestamp;
+  formatters = {};
+  getDefaults() {
+    return {
+      colors: false,
+      showTime: "yyyy-MM-dd hh:mm:ss ",
+      showDiff: false
+    };
+  }
+  export(message) {
+    console.log(this.render(message));
+  }
+  render(message) {
+    const prefix = `[${message.type[0].toUpperCase()}]`;
+    const space = " ".repeat(this.label?.margin ?? 1);
+    let indent = 3 + space.length, output = "";
+    if (this.showTime) {
+      indent += this.showTime.length;
+      output += Logger.color(this, 8, Time.template(this.showTime));
+    }
+    const code = Logger.code(message.name, this.colors);
+    const label = Logger.color(this, code, message.name, ";1");
+    const padLength = (this.label?.width ?? 0) + label.length - message.name.length;
+    if (this.label?.align === "right") {
+      output += label.padStart(padLength) + space + prefix + space;
+      indent += (this.label.width ?? 0) + space.length;
+    } else {
+      output += prefix + space + label.padEnd(padLength) + space;
+    }
+    output += Logger.format(this, message).replace(/\n/g, "\n" + " ".repeat(indent));
+    if (this.showDiff && this.timestamp) {
+      const diff = message.ts - this.timestamp;
+      output += Logger.color(this, code, " +" + Time.format(diff));
+    }
+    this.timestamp = message.ts;
+    return output;
+  }
+};
+
+// dsh-vendor/logger-console/src/browser.ts
+var ConsoleExporter2 = class extends ConsoleExporter {
+  export(message) {
+    const prefix = `[${message.type[0].toUpperCase()}] ${message.name}`;
+    const method = message.type === "error" ? "error" : message.type === "warn" ? "warn" : "log";
+    console[method](prefix, ...message.args);
+  }
+};
+var browser_default = ConsoleExporter2;
+export {
+  ConsoleExporter2 as ConsoleExporter,
+  browser_default as default
+};

package/bin/compose-runtime/payload/vendor/dsh/scope.js

@@ -0,0 +1,287 @@
+// packages/core/scope/src/index.ts
+import { Context as CordisContext } from "@deepseek-ai/cordis";
+
+// packages/core/scope/src/store.ts
+var NamedEntries = class {
+  constructor(duplicateError) {
+    this.duplicateError = duplicateError;
+  }
+  duplicateError;
+  data = /* @__PURE__ */ new Map();
+  /**
+   * Insert one unique name.
+   * @param name - name unique within this table.
+   * @param value - borrowed value to retain.
+   * @returns an idempotent undo that removes only this insertion.
+   */
+  insert(name, value) {
+    const data = this.data;
+    if (data.has(name)) throw this.duplicateError(name);
+    data.set(name, value);
+    let active = true;
+    return () => {
+      if (!active) return;
+      active = false;
+      data.delete(name);
+      if (data.size === 0 && this.data === data) this.data = /* @__PURE__ */ new Map();
+    };
+  }
+  /**
+   * Read one named value.
+   * @param name - name to resolve.
+   * @returns the retained value, or `undefined` when absent.
+   */
+  get(name) {
+    return this.data.get(name);
+  }
+  /**
+   * Test one name for membership.
+   * @param name - name to test.
+   * @returns whether the table contains that name.
+   */
+  has(name) {
+    return this.data.has(name);
+  }
+  /**
+   * Iterate live names in insertion order.
+   * @returns the native live key iterator.
+   */
+  keys() {
+    return this.data.keys();
+  }
+  /**
+   * Iterate live entries in insertion order.
+   * @returns the native live entry iterator.
+   */
+  entries() {
+    return this.data.entries();
+  }
+  /**
+   * Iterate live values in insertion order.
+   * @returns the native live value iterator.
+   */
+  values() {
+    return this.data.values();
+  }
+  /**
+   * Test whether this table has no entries.
+   * @returns whether the table is empty.
+   */
+  isEmpty() {
+    return this.data.size === 0;
+  }
+};
+var AnonymousEntries = class {
+  data = /* @__PURE__ */ new Map();
+  /**
+   * Append one independently owned value.
+   * @param value - borrowed value to retain.
+   * @returns an idempotent undo for this exact append.
+   */
+  append(value) {
+    const data = this.data;
+    const key = /* @__PURE__ */ Symbol();
+    data.set(key, value);
+    let active = true;
+    return () => {
+      if (!active) return;
+      active = false;
+      data.delete(key);
+      if (data.size === 0 && this.data === data) this.data = /* @__PURE__ */ new Map();
+    };
+  }
+  /**
+   * Iterate live values in insertion order.
+   * @returns the native live value iterator.
+   */
+  values() {
+    return this.data.values();
+  }
+  /**
+   * Test whether this table has no entries.
+   * @returns whether the table is empty.
+   */
+  isEmpty() {
+    return this.data.size === 0;
+  }
+};
+var ScopedLayers = class {
+  constructor(createLayer, onChange) {
+    this.createLayer = createLayer;
+    this.onChange = onChange;
+    this.global = createLayer(void 0);
+  }
+  createLayer;
+  onChange;
+  /** The eagerly constructed context-global layer. */
+  global;
+  scoped = /* @__PURE__ */ new Map();
+  /**
+   * Read an existing exact-scope overlay. Deliberately chain-blind: callers
+   * addressing one scope's OWN contributions (its restrictions, its guards)
+   * must not silently pick up an ancestor's — use {@link chainLayers} where
+   * inheritance is the point.
+   * @param scope - exact scope key; `undefined` denotes no overlay.
+   * @returns the existing scoped layer, or `undefined` without creating one.
+   */
+  peek(scope2) {
+    if (scope2 === void 0) return void 0;
+    return this.scoped.get(scope2);
+  }
+  /**
+   * Existing overlays along the scope's parent chain ({@link scopeChainOf}),
+   * farthest ancestor first and the exact scope last, so a caller layering
+   * them in order gives the nearest scope the final word.
+   * @param scope - viewing scope, or `undefined` for no overlays.
+   * @returns the existing layers, nearest last; absent overlays are skipped.
+   */
+  chainLayers(scope2) {
+    const layers = [];
+    for (const key of scopeChainOf(scope2).reverse()) {
+      const layer = this.scoped.get(key);
+      if (layer !== void 0) layers.push(layer);
+    }
+    return layers;
+  }
+  /**
+   * Materialize global named entries followed by scope-chain shadows,
+   * farthest ancestor first, so the nearest scope's entry wins a name.
+   * @param scope - viewing scope, or `undefined` for the global view.
+   * @param pick - select the named table from a layer.
+   * @returns an insertion-ordered effective map.
+   */
+  merge(scope2, pick) {
+    const merged = new Map(pick(this.global).entries());
+    for (const layer of this.chainLayers(scope2)) {
+      for (const [name, value] of pick(layer).entries()) merged.set(name, value);
+    }
+    return merged;
+  }
+  /**
+   * Attach one synchronous layer mutation to its registration context.
+   * @param ctx - context that determines both scope visibility and effect ownership.
+   * @param action - atomic mutation returning its synchronous undo.
+   * @param options - Cordis effect label and optional change notification.
+   * @returns the exact disposer returned by `ctx.effect()`.
+   */
+  effect(ctx, action, options) {
+    const scope2 = scopeOf(ctx);
+    const notify = options.notify ?? true;
+    const dispose = ctx.effect(function* () {
+      let layer;
+      let created = false;
+      if (scope2 === void 0) {
+        layer = this.global;
+      } else {
+        const existing = this.scoped.get(scope2);
+        if (existing === void 0) {
+          layer = this.createLayer(scope2);
+          this.scoped.set(scope2, layer);
+          created = true;
+        } else {
+          layer = existing;
+        }
+      }
+      let undo;
+      try {
+        undo = action(layer);
+      } catch (error) {
+        if (scope2 !== void 0 && created && layer.isEmpty()) this.scoped.delete(scope2);
+        throw error;
+      }
+      yield () => {
+        undo();
+        if (scope2 !== void 0 && layer.isEmpty()) this.scoped.delete(scope2);
+        if (notify) this.onChange();
+      };
+      if (notify) this.onChange();
+    }.bind(this), options.label);
+    return dispose;
+  }
+};
+
+// packages/core/scope/src/index.ts
+var kScope = /* @__PURE__ */ Symbol("dsh.scope");
+var carrierKeys = /* @__PURE__ */ new WeakMap();
+var scopeParents = /* @__PURE__ */ new WeakMap();
+function linkScopeParent(key, parent) {
+  for (let cursor = parent; cursor !== void 0; cursor = scopeParents.get(cursor)) {
+    if (cursor === key) throw new Error("dsh-scope: scope parent link would form a cycle");
+  }
+  scopeParents.set(key, parent);
+}
+function bindScopeParent(key, parent) {
+  if (scopeParents.has(key)) {
+    throw new Error("dsh-scope: scope key is already bound to a parent; re-linking requires the binding returned by the original bind");
+  }
+  linkScopeParent(key, parent);
+  return {
+    rebind(next) {
+      linkScopeParent(key, next);
+    }
+  };
+}
+function scopeParentOf(key) {
+  return scopeParents.get(key);
+}
+function scopeChainOf(key) {
+  const chain = [];
+  for (let cursor = key; cursor !== void 0; cursor = scopeParents.get(cursor)) chain.push(cursor);
+  return chain;
+}
+async function quiesceFiber(fiber) {
+  await Promise.resolve(fiber.dispose());
+  while (fiber.inertia !== void 0) await fiber.inertia;
+}
+function scope() {
+}
+function createScope(ctx, key, options) {
+  if (options?.parent !== void 0) bindScopeParent(key, options.parent);
+  const fiber = ctx.plugin(scope);
+  const scoped = fiber.ctx.extend({ [kScope]: key });
+  let disposing;
+  return {
+    ctx: scoped,
+    rawDispose: fiber.dispose,
+    dispose: () => disposing ??= quiesceFiber(fiber)
+  };
+}
+function scopeOf(ctx) {
+  return ctx[kScope];
+}
+function scopeTarget(base, key) {
+  const baseFilter = base[CordisContext.filter];
+  const carrier = {
+    [CordisContext.filter](ctx) {
+      if (baseFilter !== void 0 && !baseFilter.call(base, ctx)) return false;
+      const tag = scopeOf(ctx);
+      if (tag === void 0) return true;
+      for (let cursor = key; cursor !== void 0; cursor = scopeParents.get(cursor)) {
+        if (cursor === tag) return true;
+      }
+      return false;
+    }
+  };
+  carrierKeys.set(carrier, key);
+  return carrier;
+}
+function isScopeCarrier(value) {
+  return typeof value === "object" && value !== null && carrierKeys.has(value);
+}
+function carrierKeyOf(value) {
+  if (!isScopeCarrier(value)) return void 0;
+  return carrierKeys.get(value);
+}
+export {
+  AnonymousEntries,
+  NamedEntries,
+  ScopedLayers,
+  bindScopeParent,
+  carrierKeyOf,
+  createScope,
+  isScopeCarrier,
+  scopeChainOf,
+  scopeOf,
+  scopeParentOf,
+  scopeTarget
+};