@agentdocumentformat/cli 0.7.2

package/dist/chunks/WavPackParser-WQAGT7TC.mjs

@@ -0,0 +1,171 @@
+import { createRequire as __adfCreateRequire } from 'node:module';
+import { fileURLToPath as __adfFileURLToPath } from 'node:url';
+import { dirname as __adfDirname } from 'node:path';
+const require = __adfCreateRequire(import.meta.url);
+const __filename = __adfFileURLToPath(import.meta.url);
+const __dirname = __adfDirname(__filename);
+import {
+  FourCcToken,
+  tryParseApeHeader
+} from "./chunk-NBTUWMGP.mjs";
+import {
+  uint8ArrayToHex
+} from "./chunk-XX7OSWTO.mjs";
+import "./chunk-HBUENVQL.mjs";
+import {
+  BasicParser,
+  UINT16_LE,
+  UINT24_LE,
+  UINT32_LE,
+  UINT8,
+  Uint8ArrayType,
+  makeUnexpectedFileContentError
+} from "./chunk-I2HJYHFT.mjs";
+import {
+  require_src
+} from "./chunk-AUYKRQPJ.mjs";
+import "./chunk-NZ7JTHEO.mjs";
+import {
+  __toESM
+} from "./chunk-M2RX3S2T.mjs";
+
+// node_modules/music-metadata/lib/wavpack/WavPackToken.js
+var SampleRates = [
+  6e3,
+  8e3,
+  9600,
+  11025,
+  12e3,
+  16e3,
+  22050,
+  24e3,
+  32e3,
+  44100,
+  48e3,
+  64e3,
+  88200,
+  96e3,
+  192e3,
+  -1
+], BlockHeaderToken = {
+  len: 32,
+  get: (buf, off) => {
+    let flags = UINT32_LE.get(buf, off + 24), res = {
+      // should equal 'wvpk'
+      BlockID: FourCcToken.get(buf, off),
+      //  0x402 to 0x410 are valid for decode
+      blockSize: UINT32_LE.get(buf, off + 4),
+      //  0x402 (1026) to 0x410 are valid for decode
+      version: UINT16_LE.get(buf, off + 8),
+      //  40-bit total samples for entire file (if block_index == 0 and a value of -1 indicates an unknown length)
+      totalSamples: (
+        /* replace with bigint? (Token.UINT8.get(buf, off + 11) << 32) + */
+        UINT32_LE.get(buf, off + 12)
+      ),
+      // 40-bit block_index
+      blockIndex: (
+        /* replace with bigint? (Token.UINT8.get(buf, off + 10) << 32) + */
+        UINT32_LE.get(buf, off + 16)
+      ),
+      // 40-bit total samples for entire file (if block_index == 0 and a value of -1 indicates an unknown length)
+      blockSamples: UINT32_LE.get(buf, off + 20),
+      // various flags for id and decoding
+      flags: {
+        bitsPerSample: (1 + getBitAllignedNumber(flags, 0, 2)) * 8,
+        isMono: isBitSet(flags, 2),
+        isHybrid: isBitSet(flags, 3),
+        isJointStereo: isBitSet(flags, 4),
+        crossChannel: isBitSet(flags, 5),
+        hybridNoiseShaping: isBitSet(flags, 6),
+        floatingPoint: isBitSet(flags, 7),
+        samplingRate: SampleRates[getBitAllignedNumber(flags, 23, 4)],
+        isDSD: isBitSet(flags, 31)
+      },
+      // crc for actual decoded data
+      crc: new Uint8ArrayType(4).get(buf, off + 28)
+    };
+    return res.flags.isDSD && (res.totalSamples *= 8), res;
+  }
+}, MetadataIdToken = {
+  len: 1,
+  get: (buf, off) => ({
+    functionId: getBitAllignedNumber(buf[off], 0, 6),
+    // functionId overlaps with isOptional flag
+    isOptional: isBitSet(buf[off], 5),
+    isOddSize: isBitSet(buf[off], 6),
+    largeBlock: isBitSet(buf[off], 7)
+  })
+};
+function isBitSet(flags, bitOffset) {
+  return getBitAllignedNumber(flags, bitOffset, 1) === 1;
+}
+function getBitAllignedNumber(flags, bitOffset, len) {
+  return flags >>> bitOffset & 4294967295 >>> 32 - len;
+}
+
+// node_modules/music-metadata/lib/wavpack/WavPackParser.js
+var import_debug = __toESM(require_src(), 1);
+var debug = (0, import_debug.default)("music-metadata:parser:WavPack"), WavPackContentError = class extends makeUnexpectedFileContentError("WavPack") {
+}, WavPackParser = class extends BasicParser {
+  constructor() {
+    super(...arguments), this.audioDataSize = 0;
+  }
+  async parse() {
+    return this.metadata.setAudioOnly(), this.audioDataSize = 0, await this.parseWavPackBlocks(), tryParseApeHeader(this.metadata, this.tokenizer, this.options);
+  }
+  async parseWavPackBlocks() {
+    do {
+      if (await this.tokenizer.peekToken(FourCcToken) !== "wvpk")
+        break;
+      let header = await this.tokenizer.readToken(BlockHeaderToken);
+      if (header.BlockID !== "wvpk")
+        throw new WavPackContentError("Invalid WavPack Block-ID");
+      debug(`WavPack header blockIndex=${header.blockIndex}, len=${BlockHeaderToken.len}`), header.blockIndex === 0 && !this.metadata.format.container && (this.metadata.setFormat("container", "WavPack"), this.metadata.setFormat("lossless", !header.flags.isHybrid), this.metadata.setFormat("bitsPerSample", header.flags.bitsPerSample), header.flags.isDSD || (this.metadata.setFormat("sampleRate", header.flags.samplingRate), this.metadata.setFormat("duration", header.totalSamples / header.flags.samplingRate)), this.metadata.setFormat("numberOfChannels", header.flags.isMono ? 1 : 2), this.metadata.setFormat("numberOfSamples", header.totalSamples), this.metadata.setFormat("codec", header.flags.isDSD ? "DSD" : "PCM"));
+      let ignoreBytes = header.blockSize - (BlockHeaderToken.len - 8);
+      await (header.blockIndex === 0 ? this.parseMetadataSubBlock(header, ignoreBytes) : this.tokenizer.ignore(ignoreBytes)), header.blockSamples > 0 && (this.audioDataSize += header.blockSize);
+    } while (!this.tokenizer.fileInfo.size || this.tokenizer.fileInfo.size - this.tokenizer.position >= BlockHeaderToken.len);
+    this.metadata.format.duration && this.metadata.setFormat("bitrate", this.audioDataSize * 8 / this.metadata.format.duration);
+  }
+  /**
+   * Ref: http://www.wavpack.com/WavPack5FileFormat.pdf, 3.0 Metadata Sub-blocks
+   * @param header Header
+   * @param remainingLength Remaining length
+   */
+  async parseMetadataSubBlock(header, remainingLength) {
+    let remaining = remainingLength;
+    for (; remaining > MetadataIdToken.len; ) {
+      let id = await this.tokenizer.readToken(MetadataIdToken), dataSizeInWords = await this.tokenizer.readNumber(id.largeBlock ? UINT24_LE : UINT8), data = new Uint8Array(dataSizeInWords * 2 - (id.isOddSize ? 1 : 0));
+      switch (await this.tokenizer.readBuffer(data), debug(`Metadata Sub-Blocks functionId=0x${id.functionId.toString(16)}, id.largeBlock=${id.largeBlock},data-size=${data.length}`), id.functionId) {
+        case 0:
+          break;
+        case 14: {
+          debug("ID_DSD_BLOCK");
+          let mp = 1 << UINT8.get(data, 0), samplingRate = header.flags.samplingRate * mp * 8;
+          if (!header.flags.isDSD)
+            throw new WavPackContentError("Only expect DSD block if DSD-flag is set");
+          this.metadata.setFormat("sampleRate", samplingRate), this.metadata.setFormat("duration", header.totalSamples / samplingRate);
+          break;
+        }
+        case 36:
+          debug("ID_ALT_TRAILER: trailer for non-wav files");
+          break;
+        case 38:
+          this.metadata.setFormat("audioMD5", data);
+          break;
+        case 47:
+          debug(`ID_BLOCK_CHECKSUM: checksum=${uint8ArrayToHex(data)}`);
+          break;
+        default:
+          debug(`Ignore unsupported meta-sub-block-id functionId=0x${id.functionId.toString(16)}`);
+          break;
+      }
+      remaining -= MetadataIdToken.len + (id.largeBlock ? UINT24_LE.len : UINT8.len) + dataSizeInWords * 2, debug(`remainingLength=${remaining}`), id.isOddSize && this.tokenizer.ignore(1);
+    }
+    if (remaining !== 0)
+      throw new WavPackContentError("metadata-sub-block should fit it remaining length");
+  }
+};
+export {
+  WavPackContentError,
+  WavPackParser
+};

package/dist/chunks/WaveParser-EWLQVDX4.mjs

@@ -0,0 +1,238 @@
+import { createRequire as __adfCreateRequire } from 'node:module';
+import { fileURLToPath as __adfFileURLToPath } from 'node:url';
+import { dirname as __adfDirname } from 'node:path';
+const require = __adfCreateRequire(import.meta.url);
+const __filename = __adfFileURLToPath(import.meta.url);
+const __dirname = __adfDirname(__filename);
+import {
+  ID3v2Parser
+} from "./chunk-XYTWGHFS.mjs";
+import "./chunk-VAUOM3IN.mjs";
+import "./chunk-DXWDD5XJ.mjs";
+import {
+  FourCcToken
+} from "./chunk-NBTUWMGP.mjs";
+import {
+  stripNulls
+} from "./chunk-XX7OSWTO.mjs";
+import {
+  EndOfStreamError,
+  fromBuffer
+} from "./chunk-HBUENVQL.mjs";
+import {
+  BasicParser,
+  StringType,
+  UINT16_LE,
+  UINT32_LE,
+  Uint8ArrayType,
+  makeUnexpectedFileContentError
+} from "./chunk-I2HJYHFT.mjs";
+import {
+  require_src
+} from "./chunk-AUYKRQPJ.mjs";
+import "./chunk-NZ7JTHEO.mjs";
+import {
+  __toESM
+} from "./chunk-M2RX3S2T.mjs";
+
+// node_modules/music-metadata/lib/wav/WaveParser.js
+var import_debug = __toESM(require_src(), 1);
+
+// node_modules/music-metadata/lib/riff/RiffChunk.js
+var Header = {
+  len: 8,
+  get: (buf, off) => ({
+    // Group-ID
+    chunkID: new StringType(4, "latin1").get(buf, off),
+    // Size
+    chunkSize: UINT32_LE.get(buf, off + 4)
+  })
+}, ListInfoTagValue = class {
+  constructor(tagHeader) {
+    this.tagHeader = tagHeader, this.len = tagHeader.chunkSize, this.len += this.len & 1;
+  }
+  get(buf, off) {
+    return new StringType(this.tagHeader.chunkSize, "ascii").get(buf, off);
+  }
+};
+
+// node_modules/music-metadata/lib/wav/WaveChunk.js
+var WaveContentError = class extends makeUnexpectedFileContentError("Wave") {
+}, WaveFormat = {
+  PCM: 1,
+  ADPCM: 2,
+  IEEE_FLOAT: 3,
+  ALAW: 6,
+  MULAW: 7,
+  DVI_ADPCM: 17,
+  GSM610: 49,
+  // MPEG-4 and AAC Audio Types
+  MPEG_ADTS_AAC: 5632,
+  MPEG_LOAS: 5634,
+  RAW_AAC1: 255,
+  // Dolby Audio Types
+  DOLBY_AC3_SPDIF: 146,
+  DVM: 8192,
+  RAW_SPORT: 576,
+  ESST_AC3: 577,
+  DRM: 9,
+  DTS2: 8193,
+  MPEG: 80,
+  MPEGLAYER3: 85
+}, WaveFormatNameMap = {
+  [WaveFormat.PCM]: "PCM",
+  [WaveFormat.ADPCM]: "ADPCM",
+  [WaveFormat.IEEE_FLOAT]: "IEEE_FLOAT",
+  [WaveFormat.ALAW]: "ALAW",
+  [WaveFormat.MULAW]: "MULAW",
+  [WaveFormat.DVI_ADPCM]: "DVI_ADPCM",
+  [WaveFormat.GSM610]: "GSM610",
+  [WaveFormat.MPEG_ADTS_AAC]: "MPEG_ADTS_AAC",
+  [WaveFormat.MPEG_LOAS]: "MPEG_LOAS",
+  [WaveFormat.RAW_AAC1]: "RAW_AAC1",
+  [WaveFormat.DOLBY_AC3_SPDIF]: "DOLBY_AC3_SPDIF",
+  [WaveFormat.DVM]: "DVM",
+  [WaveFormat.RAW_SPORT]: "RAW_SPORT",
+  [WaveFormat.ESST_AC3]: "ESST_AC3",
+  [WaveFormat.DRM]: "DRM",
+  [WaveFormat.DTS2]: "DTS2",
+  [WaveFormat.MPEG]: "MPEG",
+  [WaveFormat.MPEGLAYER3]: "MPEGLAYER3"
+}, Format = class {
+  constructor(header) {
+    if (header.chunkSize < 16)
+      throw new WaveContentError("Invalid chunk size");
+    this.len = header.chunkSize;
+  }
+  get(buf, off) {
+    return {
+      wFormatTag: UINT16_LE.get(buf, off),
+      nChannels: UINT16_LE.get(buf, off + 2),
+      nSamplesPerSec: UINT32_LE.get(buf, off + 4),
+      nAvgBytesPerSec: UINT32_LE.get(buf, off + 8),
+      nBlockAlign: UINT16_LE.get(buf, off + 12),
+      wBitsPerSample: UINT16_LE.get(buf, off + 14)
+    };
+  }
+}, FactChunk = class {
+  constructor(header) {
+    if (header.chunkSize < 4)
+      throw new WaveContentError("Invalid fact chunk size.");
+    this.len = header.chunkSize;
+  }
+  get(buf, off) {
+    return {
+      dwSampleLength: UINT32_LE.get(buf, off)
+    };
+  }
+};
+
+// node_modules/music-metadata/lib/wav/BwfChunk.js
+var BroadcastAudioExtensionChunk = {
+  len: 420,
+  get: (uint8array, off) => ({
+    description: stripNulls(new StringType(256, "ascii").get(uint8array, off)).trim(),
+    originator: stripNulls(new StringType(32, "ascii").get(uint8array, off + 256)).trim(),
+    originatorReference: stripNulls(new StringType(32, "ascii").get(uint8array, off + 288)).trim(),
+    originationDate: stripNulls(new StringType(10, "ascii").get(uint8array, off + 320)).trim(),
+    originationTime: stripNulls(new StringType(8, "ascii").get(uint8array, off + 330)).trim(),
+    timeReferenceLow: UINT32_LE.get(uint8array, off + 338),
+    timeReferenceHigh: UINT32_LE.get(uint8array, off + 342),
+    version: UINT16_LE.get(uint8array, off + 346),
+    umid: new Uint8ArrayType(64).get(uint8array, off + 348),
+    loudnessValue: UINT16_LE.get(uint8array, off + 412),
+    maxTruePeakLevel: UINT16_LE.get(uint8array, off + 414),
+    maxMomentaryLoudness: UINT16_LE.get(uint8array, off + 416),
+    maxShortTermLoudness: UINT16_LE.get(uint8array, off + 418)
+  })
+};
+
+// node_modules/music-metadata/lib/wav/WaveParser.js
+var debug = (0, import_debug.default)("music-metadata:parser:RIFF"), WaveParser = class extends BasicParser {
+  constructor() {
+    super(...arguments), this.blockAlign = 0, this.avgBytesPerSec = 0;
+  }
+  async parse() {
+    let riffHeader = await this.tokenizer.readToken(Header);
+    if (debug(`pos=${this.tokenizer.position}, parse: chunkID=${riffHeader.chunkID}`), riffHeader.chunkID === "RIFF")
+      return this.metadata.setAudioOnly(), this.parseRiffChunk(riffHeader.chunkSize).catch((err) => {
+        if (!(err instanceof EndOfStreamError))
+          throw err;
+      });
+  }
+  async parseRiffChunk(chunkSize) {
+    let type = await this.tokenizer.readToken(FourCcToken);
+    if (this.metadata.setFormat("container", type), type === "WAVE")
+      return this.readWaveChunk(chunkSize - FourCcToken.len);
+    throw new WaveContentError(`Unsupported RIFF format: RIFF/${type}`);
+  }
+  async readWaveChunk(remaining) {
+    for (; remaining >= Header.len; ) {
+      let header = await this.tokenizer.readToken(Header);
+      switch (remaining -= Header.len + header.chunkSize, header.chunkSize > remaining && this.metadata.addWarning("Data chunk size exceeds file size"), this.header = header, debug(`pos=${this.tokenizer.position}, readChunk: chunkID=RIFF/WAVE/${header.chunkID}`), header.chunkID) {
+        case "LIST":
+          await this.parseListTag(header);
+          break;
+        case "fact":
+          this.metadata.setFormat("lossless", !1), this.fact = await this.tokenizer.readToken(new FactChunk(header));
+          break;
+        case "fmt ": {
+          let fmt = await this.tokenizer.readToken(new Format(header)), subFormat = WaveFormatNameMap[fmt.wFormatTag];
+          subFormat || (debug(`WAVE/non-PCM format=${fmt.wFormatTag}`), subFormat = `non-PCM (${fmt.wFormatTag})`), this.metadata.setFormat("codec", subFormat), this.metadata.setFormat("bitsPerSample", fmt.wBitsPerSample), this.metadata.setFormat("sampleRate", fmt.nSamplesPerSec), this.metadata.setFormat("numberOfChannels", fmt.nChannels), this.blockAlign = fmt.nBlockAlign, this.avgBytesPerSec = fmt.nAvgBytesPerSec;
+          break;
+        }
+        case "id3 ":
+        // The way Picard, FooBar currently stores, ID3 meta-data
+        case "ID3 ": {
+          let id3_data = await this.tokenizer.readToken(new Uint8ArrayType(header.chunkSize)), rst = fromBuffer(id3_data);
+          await new ID3v2Parser().parse(this.metadata, rst, this.options);
+          break;
+        }
+        case "data": {
+          this.metadata.format.lossless !== !1 && this.metadata.setFormat("lossless", !0);
+          let chunkSize = header.chunkSize;
+          if (this.tokenizer.fileInfo.size) {
+            let calcRemaining = this.tokenizer.fileInfo.size - this.tokenizer.position;
+            calcRemaining < chunkSize && (this.metadata.addWarning("data chunk length exceeding file length"), chunkSize = calcRemaining);
+          }
+          let numberOfSamples = this.fact ? this.fact.dwSampleLength : chunkSize === 4294967295 ? void 0 : chunkSize / this.blockAlign;
+          numberOfSamples && (this.metadata.setFormat("numberOfSamples", numberOfSamples), this.metadata.format.sampleRate && this.metadata.setFormat("duration", numberOfSamples / this.metadata.format.sampleRate)), this.avgBytesPerSec > 0 ? this.metadata.setFormat("bitrate", this.avgBytesPerSec * 8) : this.metadata.format.duration && this.metadata.setFormat("bitrate", chunkSize * 8 / this.metadata.format.duration), await this.tokenizer.ignore(header.chunkSize);
+          break;
+        }
+        case "bext": {
+          let bext = await this.tokenizer.readToken(BroadcastAudioExtensionChunk);
+          Object.keys(bext).forEach((key) => {
+            this.metadata.addTag("exif", `bext.${key}`, bext[key]);
+          });
+          let bextRemaining = header.chunkSize - BroadcastAudioExtensionChunk.len;
+          await this.tokenizer.ignore(bextRemaining);
+          break;
+        }
+        case "\0\0\0\0":
+          debug(`Ignore padding chunk: RIFF/${header.chunkID} of ${header.chunkSize} bytes`), this.metadata.addWarning(`Ignore chunk: RIFF/${header.chunkID}`), await this.tokenizer.ignore(header.chunkSize);
+          break;
+        default:
+          debug(`Ignore chunk: RIFF/${header.chunkID} of ${header.chunkSize} bytes`), this.metadata.addWarning(`Ignore chunk: RIFF/${header.chunkID}`), await this.tokenizer.ignore(header.chunkSize);
+      }
+      this.header.chunkSize % 2 === 1 && (debug("Read odd padding byte"), await this.tokenizer.ignore(1));
+    }
+  }
+  async parseListTag(listHeader) {
+    let listType = await this.tokenizer.readToken(new StringType(4, "latin1"));
+    return debug("pos=%s, parseListTag: chunkID=RIFF/WAVE/LIST/%s", this.tokenizer.position, listType), listType === "INFO" ? this.parseRiffInfoTags(listHeader.chunkSize - 4) : (this.metadata.addWarning(`Ignore chunk: RIFF/WAVE/LIST/${listType}`), debug(`Ignoring chunkID=RIFF/WAVE/LIST/${listType}`), this.tokenizer.ignore(listHeader.chunkSize - 4).then());
+  }
+  async parseRiffInfoTags(chunkSize) {
+    for (; chunkSize >= 8; ) {
+      let header = await this.tokenizer.readToken(Header), valueToken = new ListInfoTagValue(header), value = await this.tokenizer.readToken(valueToken);
+      this.addTag(header.chunkID, stripNulls(value)), chunkSize -= 8 + valueToken.len;
+    }
+    if (chunkSize !== 0)
+      throw new WaveContentError(`Illegal remaining size: ${chunkSize}`);
+  }
+  addTag(id, value) {
+    this.metadata.addTag("exif", id, value);
+  }
+};
+export {
+  WaveParser
+};

package/dist/chunks/adf-schema-JRU2BTOG.mjs

@@ -0,0 +1,62 @@
+import { createRequire as __adfCreateRequire } from 'node:module';
+import { fileURLToPath as __adfFileURLToPath } from 'node:url';
+import { dirname as __adfDirname } from 'node:path';
+const require = __adfCreateRequire(import.meta.url);
+const __filename = __adfFileURLToPath(import.meta.url);
+const __dirname = __adfDirname(__filename);
+import {
+  AdapterInstanceConfigSchema,
+  AgentConfigSchema,
+  BindOptionsSchema,
+  LOOP_GOAL_MAX_CHARS,
+  LOOP_NAME_PATTERN,
+  LOOP_NAME_RULE,
+  LOOP_TOOLS_MAX,
+  LoopConfigSchema,
+  LoopsConfigSchema,
+  MAX_SIDE_LOOPS,
+  ModelConfigSchema,
+  PreLlmHookConfigSchema,
+  ServingApiRouteSchema,
+  ServingConfigSchema,
+  ServingPublicConfigSchema,
+  ServingSharedConfigSchema,
+  StreamBindConfigSchema,
+  StreamBindEndpointSchema,
+  StreamBindingDeclarationSchema,
+  TimerScheduleSchema,
+  ToolDeclarationSchema,
+  TriggersConfigV3Schema,
+  UmbilicalFilterSchema,
+  WsConnectionConfigSchema
+} from "./chunk-HWLWPXQ7.mjs";
+import "./chunk-ZJKXHM4Q.mjs";
+import "./chunk-RIX34QHC.mjs";
+import "./chunk-WFQUVXML.mjs";
+import "./chunk-M2RX3S2T.mjs";
+export {
+  AdapterInstanceConfigSchema,
+  AgentConfigSchema,
+  BindOptionsSchema,
+  LOOP_GOAL_MAX_CHARS,
+  LOOP_NAME_PATTERN,
+  LOOP_NAME_RULE,
+  LOOP_TOOLS_MAX,
+  LoopConfigSchema,
+  LoopsConfigSchema,
+  MAX_SIDE_LOOPS,
+  ModelConfigSchema,
+  PreLlmHookConfigSchema,
+  ServingApiRouteSchema,
+  ServingConfigSchema,
+  ServingPublicConfigSchema,
+  ServingSharedConfigSchema,
+  StreamBindConfigSchema,
+  StreamBindEndpointSchema,
+  StreamBindingDeclarationSchema,
+  TimerScheduleSchema,
+  ToolDeclarationSchema,
+  TriggersConfigV3Schema,
+  UmbilicalFilterSchema,
+  WsConnectionConfigSchema
+};

package/dist/chunks/build-QF5W473T.mjs

@@ -0,0 +1,60 @@
+import { createRequire as __adfCreateRequire } from 'node:module';
+import { fileURLToPath as __adfFileURLToPath } from 'node:url';
+import { dirname as __adfDirname } from 'node:path';
+const require = __adfCreateRequire(import.meta.url);
+const __filename = __adfFileURLToPath(import.meta.url);
+const __dirname = __adfDirname(__filename);
+import {
+  Box_default,
+  Newline,
+  Spacer,
+  Static,
+  Text,
+  Transform,
+  kittyFlags,
+  kittyModifiers,
+  measure_element_default,
+  render_default,
+  render_to_string_default,
+  useAnimation,
+  use_app_default,
+  use_box_metrics_default,
+  use_cursor_default,
+  use_focus_default,
+  use_focus_manager_default,
+  use_input_default,
+  use_is_screen_reader_enabled_default,
+  use_paste_default,
+  use_stderr_default,
+  use_stdin_default,
+  use_stdout_default,
+  use_window_size_default
+} from "./chunk-3AT7IIP7.mjs";
+import "./chunk-6GJ4QHRI.mjs";
+import "./chunk-M2RX3S2T.mjs";
+export {
+  Box_default as Box,
+  Newline,
+  Spacer,
+  Static,
+  Text,
+  Transform,
+  kittyFlags,
+  kittyModifiers,
+  measure_element_default as measureElement,
+  render_default as render,
+  render_to_string_default as renderToString,
+  useAnimation,
+  use_app_default as useApp,
+  use_box_metrics_default as useBoxMetrics,
+  use_cursor_default as useCursor,
+  use_focus_default as useFocus,
+  use_focus_manager_default as useFocusManager,
+  use_input_default as useInput,
+  use_is_screen_reader_enabled_default as useIsScreenReaderEnabled,
+  use_paste_default as usePaste,
+  use_stderr_default as useStderr,
+  use_stdin_default as useStdin,
+  use_stdout_default as useStdout,
+  use_window_size_default as useWindowSize
+};

package/dist/chunks/chatgpt-subscription-BQGWYZXE.mjs

@@ -0,0 +1,23 @@
+import { createRequire as __adfCreateRequire } from 'node:module';
+import { fileURLToPath as __adfFileURLToPath } from 'node:url';
+import { dirname as __adfDirname } from 'node:path';
+const require = __adfCreateRequire(import.meta.url);
+const __filename = __adfFileURLToPath(import.meta.url);
+const __dirname = __adfDirname(__filename);
+import {
+  CHATGPT_SUBSCRIPTION_MODELS,
+  INSTRUCTIONS_ID_HEADER,
+  createChatGPTSubscriptionProvider,
+  describeCodexRequest,
+  patchCodexRequestBody
+} from "./chunk-LAZIXV2F.mjs";
+import "./chunk-LFMB4PAA.mjs";
+import "./chunk-RIX34QHC.mjs";
+import "./chunk-M2RX3S2T.mjs";
+export {
+  CHATGPT_SUBSCRIPTION_MODELS,
+  INSTRUCTIONS_ID_HEADER,
+  createChatGPTSubscriptionProvider,
+  describeCodexRequest,
+  patchCodexRequestBody
+};

package/dist/chunks/chunk-2DIECGFL.mjs

@@ -0,0 +1,6 @@
+import { createRequire as __adfCreateRequire } from 'node:module';
+import { fileURLToPath as __adfFileURLToPath } from 'node:url';
+import { dirname as __adfDirname } from 'node:path';
+const require = __adfCreateRequire(import.meta.url);
+const __filename = __adfFileURLToPath(import.meta.url);
+const __dirname = __adfDirname(__filename);

package/dist/chunks/chunk-2NAP2ZF7.mjs

@@ -0,0 +1,60 @@
+import { createRequire as __adfCreateRequire } from 'node:module';
+import { fileURLToPath as __adfFileURLToPath } from 'node:url';
+import { dirname as __adfDirname } from 'node:path';
+const require = __adfCreateRequire(import.meta.url);
+const __filename = __adfFileURLToPath(import.meta.url);
+const __dirname = __adfDirname(__filename);
+
+// src/main/providers/chatgpt-subscription/callback-server.ts
+import http from "http";
+import { URL } from "url";
+var PREFERRED_PORT = 1455, DEFAULT_TIMEOUT_MS = 12e4, SUCCESS_HTML = `<!DOCTYPE html>
+<html><head><title>Authentication Complete</title></head>
+<body style="font-family:system-ui;display:flex;align-items:center;justify-content:center;height:100vh;margin:0;background:#f5f5f5">
+<div style="text-align:center"><h2>Authentication complete.</h2><p>You can close this tab.</p></div>
+</body></html>`;
+function startCallbackServer(timeoutMs = DEFAULT_TIMEOUT_MS) {
+  return new Promise((resolveServer, rejectServer) => {
+    let callbackResolve = null, callbackReject = null, timeout = null, server = http.createServer((req, res) => {
+      if (!req.url) {
+        res.writeHead(404), res.end();
+        return;
+      }
+      let parsed = new URL(req.url, "http://127.0.0.1");
+      if (parsed.pathname !== "/auth/callback") {
+        res.writeHead(404), res.end();
+        return;
+      }
+      let code = parsed.searchParams.get("code"), state = parsed.searchParams.get("state");
+      res.writeHead(200, { "Content-Type": "text/html" }), res.end(SUCCESS_HTML), code && state && callbackResolve && (callbackResolve({ code, state }), callbackResolve = null, callbackReject = null);
+    }), cleanup = () => {
+      timeout && (clearTimeout(timeout), timeout = null);
+      try {
+        server.close();
+      } catch {
+      }
+    }, callbackPromise = new Promise((resolve, reject) => {
+      callbackResolve = resolve, callbackReject = reject;
+    });
+    server.on("error", (err) => {
+      err.code === "EADDRINUSE" ? server.listen(0, "127.0.0.1") : rejectServer(err);
+    }), server.on("listening", () => {
+      let addr = server.address();
+      if (!addr || typeof addr == "string") {
+        cleanup(), rejectServer(new Error("Failed to get server address"));
+        return;
+      }
+      timeout = setTimeout(() => {
+        callbackReject && (callbackReject(new Error(`OAuth callback timed out after ${Math.round(timeoutMs / 1e3)}s`)), callbackResolve = null, callbackReject = null), cleanup();
+      }, timeoutMs), resolveServer({
+        port: addr.port,
+        waitForCallback: () => callbackPromise,
+        close: cleanup
+      });
+    }), server.listen(PREFERRED_PORT, "127.0.0.1");
+  });
+}
+
+export {
+  startCallbackServer
+};