jialing-code 1.1.0

package/dist/chunk-2nayx6q1.js

@@ -0,0 +1,63 @@
+// @bun
+import {
+  __commonJS,
+  __require
+} from "./chunk-qp2qdcda.js";
+
+// node_modules/.bun/@smithy+is-array-buffer@4.2.2/node_modules/@smithy/is-array-buffer/dist-cjs/index.js
+var require_dist_cjs = __commonJS((exports) => {
+  var isArrayBuffer = (arg) => typeof ArrayBuffer === "function" && arg instanceof ArrayBuffer || Object.prototype.toString.call(arg) === "[object ArrayBuffer]";
+  exports.isArrayBuffer = isArrayBuffer;
+});
+
+// node_modules/.bun/@smithy+util-buffer-from@4.2.2/node_modules/@smithy/util-buffer-from/dist-cjs/index.js
+var require_dist_cjs2 = __commonJS((exports) => {
+  var isArrayBuffer = require_dist_cjs();
+  var buffer = __require("buffer");
+  var fromArrayBuffer = (input, offset = 0, length = input.byteLength - offset) => {
+    if (!isArrayBuffer.isArrayBuffer(input)) {
+      throw new TypeError(`The "input" argument must be ArrayBuffer. Received type ${typeof input} (${input})`);
+    }
+    return buffer.Buffer.from(input, offset, length);
+  };
+  var fromString = (input, encoding) => {
+    if (typeof input !== "string") {
+      throw new TypeError(`The "input" argument must be of type string. Received type ${typeof input} (${input})`);
+    }
+    return encoding ? buffer.Buffer.from(input, encoding) : buffer.Buffer.from(input);
+  };
+  exports.fromArrayBuffer = fromArrayBuffer;
+  exports.fromString = fromString;
+});
+
+// node_modules/.bun/@smithy+util-utf8@4.2.2/node_modules/@smithy/util-utf8/dist-cjs/index.js
+var require_dist_cjs3 = __commonJS((exports) => {
+  var utilBufferFrom = require_dist_cjs2();
+  var fromUtf8 = (input) => {
+    const buf = utilBufferFrom.fromString(input, "utf8");
+    return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength / Uint8Array.BYTES_PER_ELEMENT);
+  };
+  var toUint8Array = (data) => {
+    if (typeof data === "string") {
+      return fromUtf8(data);
+    }
+    if (ArrayBuffer.isView(data)) {
+      return new Uint8Array(data.buffer, data.byteOffset, data.byteLength / Uint8Array.BYTES_PER_ELEMENT);
+    }
+    return new Uint8Array(data);
+  };
+  var toUtf8 = (input) => {
+    if (typeof input === "string") {
+      return input;
+    }
+    if (typeof input !== "object" || typeof input.byteOffset !== "number" || typeof input.byteLength !== "number") {
+      throw new Error("@smithy/util-utf8: toUtf8 encoder function only accepts string | Uint8Array.");
+    }
+    return utilBufferFrom.fromArrayBuffer(input.buffer, input.byteOffset, input.byteLength).toString("utf8");
+  };
+  exports.fromUtf8 = fromUtf8;
+  exports.toUint8Array = toUint8Array;
+  exports.toUtf8 = toUtf8;
+});
+
+export { require_dist_cjs, require_dist_cjs2 as require_dist_cjs1, require_dist_cjs3 as require_dist_cjs2 };

package/dist/chunk-2sd2w2h4.js

@@ -0,0 +1,44 @@
+// @bun
+import {
+  ThemedText,
+  init_ink,
+  require_compiler_runtime
+} from "./chunk-s9mesaw0.js";
+import {
+  require_jsx_dev_runtime
+} from "./chunk-g338npwr.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/components/PressEnterToContinue.tsx
+function PressEnterToContinue() {
+  const $ = import_compiler_runtime.c(1);
+  let t0;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t0 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+      color: "permission",
+      children: [
+        "Press ",
+        /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+          bold: true,
+          children: "Enter"
+        }, undefined, false, undefined, this),
+        " to continue\u2026"
+      ]
+    }, undefined, true, undefined, this);
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  return t0;
+}
+var import_compiler_runtime, jsx_dev_runtime;
+var init_PressEnterToContinue = __esm(() => {
+  init_ink();
+  import_compiler_runtime = __toESM(require_compiler_runtime(), 1);
+  jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+});
+
+export { PressEnterToContinue, init_PressEnterToContinue };

package/dist/chunk-2tw2ve8h.js

@@ -0,0 +1,145 @@
+// @bun
+import {
+  getProjectsDir,
+  getWorktreePathsPortable,
+  init_getWorktreePathsPortable,
+  init_sessionStoragePortable,
+  sanitizePath
+} from "./chunk-vratq94g.js";
+import {
+  init_v4
+} from "./chunk-g0j0t6qk.js";
+import {
+  exports_external,
+  init_lazySchema,
+  lazySchema
+} from "./chunk-55wgxwa9.js";
+import"./chunk-8tnsngw2.js";
+import {
+  init_debug,
+  init_errors,
+  init_slowOperations,
+  isENOENT,
+  jsonParse,
+  jsonStringify,
+  logForDebugging
+} from "./chunk-nxsh6de2.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-3r24h7t6.js";
+import"./chunk-qqfa0dqg.js";
+import"./chunk-hqmz36b3.js";
+import"./chunk-4g3v8y12.js";
+import"./chunk-7739pg2c.js";
+import"./chunk-qp2qdcda.js";
+
+// src/bridge/bridgePointer.ts
+init_v4();
+init_debug();
+init_errors();
+init_getWorktreePathsPortable();
+init_lazySchema();
+init_sessionStoragePortable();
+init_slowOperations();
+import { mkdir, readFile, stat, unlink, writeFile } from "fs/promises";
+import { dirname, join } from "path";
+var MAX_WORKTREE_FANOUT = 50;
+var BRIDGE_POINTER_TTL_MS = 4 * 60 * 60 * 1000;
+var BridgePointerSchema = lazySchema(() => exports_external.object({
+  sessionId: exports_external.string(),
+  environmentId: exports_external.string(),
+  source: exports_external.enum(["standalone", "repl"])
+}));
+function getBridgePointerPath(dir) {
+  return join(getProjectsDir(), sanitizePath(dir), "bridge-pointer.json");
+}
+async function writeBridgePointer(dir, pointer) {
+  const path = getBridgePointerPath(dir);
+  try {
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, jsonStringify(pointer), "utf8");
+    logForDebugging(`[bridge:pointer] wrote ${path}`);
+  } catch (err) {
+    logForDebugging(`[bridge:pointer] write failed: ${err}`, { level: "warn" });
+  }
+}
+async function readBridgePointer(dir) {
+  const path = getBridgePointerPath(dir);
+  let raw;
+  let mtimeMs;
+  try {
+    mtimeMs = (await stat(path)).mtimeMs;
+    raw = await readFile(path, "utf8");
+  } catch {
+    return null;
+  }
+  const parsed = BridgePointerSchema().safeParse(safeJsonParse(raw));
+  if (!parsed.success) {
+    logForDebugging(`[bridge:pointer] invalid schema, clearing: ${path}`);
+    await clearBridgePointer(dir);
+    return null;
+  }
+  const ageMs = Math.max(0, Date.now() - mtimeMs);
+  if (ageMs > BRIDGE_POINTER_TTL_MS) {
+    logForDebugging(`[bridge:pointer] stale (>4h mtime), clearing: ${path}`);
+    await clearBridgePointer(dir);
+    return null;
+  }
+  return { ...parsed.data, ageMs };
+}
+async function readBridgePointerAcrossWorktrees(dir) {
+  const here = await readBridgePointer(dir);
+  if (here) {
+    return { pointer: here, dir };
+  }
+  const worktrees = await getWorktreePathsPortable(dir);
+  if (worktrees.length <= 1)
+    return null;
+  if (worktrees.length > MAX_WORKTREE_FANOUT) {
+    logForDebugging(`[bridge:pointer] ${worktrees.length} worktrees exceeds fanout cap ${MAX_WORKTREE_FANOUT}, skipping`);
+    return null;
+  }
+  const dirKey = sanitizePath(dir);
+  const candidates = worktrees.filter((wt) => sanitizePath(wt) !== dirKey);
+  const results = await Promise.all(candidates.map(async (wt) => {
+    const p = await readBridgePointer(wt);
+    return p ? { pointer: p, dir: wt } : null;
+  }));
+  let freshest = null;
+  for (const r of results) {
+    if (r && (!freshest || r.pointer.ageMs < freshest.pointer.ageMs)) {
+      freshest = r;
+    }
+  }
+  if (freshest) {
+    logForDebugging(`[bridge:pointer] fanout found pointer in worktree ${freshest.dir} (ageMs=${freshest.pointer.ageMs})`);
+  }
+  return freshest;
+}
+async function clearBridgePointer(dir) {
+  const path = getBridgePointerPath(dir);
+  try {
+    await unlink(path);
+    logForDebugging(`[bridge:pointer] cleared ${path}`);
+  } catch (err) {
+    if (!isENOENT(err)) {
+      logForDebugging(`[bridge:pointer] clear failed: ${err}`, {
+        level: "warn"
+      });
+    }
+  }
+}
+function safeJsonParse(raw) {
+  try {
+    return jsonParse(raw);
+  } catch {
+    return null;
+  }
+}
+export {
+  writeBridgePointer,
+  readBridgePointerAcrossWorktrees,
+  readBridgePointer,
+  getBridgePointerPath,
+  clearBridgePointer,
+  BRIDGE_POINTER_TTL_MS
+};

package/dist/chunk-30rst83v.js

@@ -0,0 +1,168 @@
+// @bun
+import {
+  require_dist_cjs
+} from "./chunk-xsq9ae7x.js";
+import {
+  __commonJS
+} from "./chunk-qp2qdcda.js";
+
+// node_modules/.bun/@smithy+protocol-http@5.3.12/node_modules/@smithy/protocol-http/dist-cjs/index.js
+var require_dist_cjs2 = __commonJS((exports) => {
+  var types = require_dist_cjs();
+  var getHttpHandlerExtensionConfiguration = (runtimeConfig) => {
+    return {
+      setHttpHandler(handler) {
+        runtimeConfig.httpHandler = handler;
+      },
+      httpHandler() {
+        return runtimeConfig.httpHandler;
+      },
+      updateHttpClientConfig(key, value) {
+        runtimeConfig.httpHandler?.updateHttpClientConfig(key, value);
+      },
+      httpHandlerConfigs() {
+        return runtimeConfig.httpHandler.httpHandlerConfigs();
+      }
+    };
+  };
+  var resolveHttpHandlerRuntimeConfig = (httpHandlerExtensionConfiguration) => {
+    return {
+      httpHandler: httpHandlerExtensionConfiguration.httpHandler()
+    };
+  };
+
+  class Field {
+    name;
+    kind;
+    values;
+    constructor({ name, kind = types.FieldPosition.HEADER, values = [] }) {
+      this.name = name;
+      this.kind = kind;
+      this.values = values;
+    }
+    add(value) {
+      this.values.push(value);
+    }
+    set(values) {
+      this.values = values;
+    }
+    remove(value) {
+      this.values = this.values.filter((v) => v !== value);
+    }
+    toString() {
+      return this.values.map((v) => v.includes(",") || v.includes(" ") ? `"${v}"` : v).join(", ");
+    }
+    get() {
+      return this.values;
+    }
+  }
+
+  class Fields {
+    entries = {};
+    encoding;
+    constructor({ fields = [], encoding = "utf-8" }) {
+      fields.forEach(this.setField.bind(this));
+      this.encoding = encoding;
+    }
+    setField(field) {
+      this.entries[field.name.toLowerCase()] = field;
+    }
+    getField(name) {
+      return this.entries[name.toLowerCase()];
+    }
+    removeField(name) {
+      delete this.entries[name.toLowerCase()];
+    }
+    getByType(kind) {
+      return Object.values(this.entries).filter((field) => field.kind === kind);
+    }
+  }
+
+  class HttpRequest {
+    method;
+    protocol;
+    hostname;
+    port;
+    path;
+    query;
+    headers;
+    username;
+    password;
+    fragment;
+    body;
+    constructor(options) {
+      this.method = options.method || "GET";
+      this.hostname = options.hostname || "localhost";
+      this.port = options.port;
+      this.query = options.query || {};
+      this.headers = options.headers || {};
+      this.body = options.body;
+      this.protocol = options.protocol ? options.protocol.slice(-1) !== ":" ? `${options.protocol}:` : options.protocol : "https:";
+      this.path = options.path ? options.path.charAt(0) !== "/" ? `/${options.path}` : options.path : "/";
+      this.username = options.username;
+      this.password = options.password;
+      this.fragment = options.fragment;
+    }
+    static clone(request) {
+      const cloned = new HttpRequest({
+        ...request,
+        headers: { ...request.headers }
+      });
+      if (cloned.query) {
+        cloned.query = cloneQuery(cloned.query);
+      }
+      return cloned;
+    }
+    static isInstance(request) {
+      if (!request) {
+        return false;
+      }
+      const req = request;
+      return "method" in req && "protocol" in req && "hostname" in req && "path" in req && typeof req["query"] === "object" && typeof req["headers"] === "object";
+    }
+    clone() {
+      return HttpRequest.clone(this);
+    }
+  }
+  function cloneQuery(query) {
+    return Object.keys(query).reduce((carry, paramName) => {
+      const param = query[paramName];
+      return {
+        ...carry,
+        [paramName]: Array.isArray(param) ? [...param] : param
+      };
+    }, {});
+  }
+
+  class HttpResponse {
+    statusCode;
+    reason;
+    headers;
+    body;
+    constructor(options) {
+      this.statusCode = options.statusCode;
+      this.reason = options.reason;
+      this.headers = options.headers || {};
+      this.body = options.body;
+    }
+    static isInstance(response) {
+      if (!response)
+        return false;
+      const resp = response;
+      return typeof resp.statusCode === "number" && typeof resp.headers === "object";
+    }
+  }
+  function isValidHostname(hostname) {
+    const hostPattern = /^[a-z0-9][a-z0-9\.\-]*[a-z0-9]$/;
+    return hostPattern.test(hostname);
+  }
+  exports.Field = Field;
+  exports.Fields = Fields;
+  exports.HttpRequest = HttpRequest;
+  exports.HttpResponse = HttpResponse;
+  exports.getHttpHandlerExtensionConfiguration = getHttpHandlerExtensionConfiguration;
+  exports.isValidHostname = isValidHostname;
+  exports.resolveHttpHandlerRuntimeConfig = resolveHttpHandlerRuntimeConfig;
+});
+
+export { require_dist_cjs2 as require_dist_cjs };