stitchkit 0.116.0 → 0.117.0

package/dist/entrypoints/xlsx.js

@@ -0,0 +1,406 @@
+import {
+  DecimalInputSchema2,
+  moneyToDecimal2
+} from "../index-qezhmp51.js";
+
+// src/xlsx/cells.ts
+import { z } from "zod";
+var EXCEL_DIGITS = 15;
+var MAX_TEXT = 32767;
+var MS_PER_DAY = 86400000;
+var EXCEL_EPOCH_DAY = -25569;
+var FIRST_RELIABLE_DAY = Date.UTC(1900, 2, 1) / MS_PER_DAY;
+var LAST_DAY = Date.UTC(9999, 11, 31) / MS_PER_DAY;
+var InstantSchema = z.iso.datetime({ offset: true });
+
+class XlsxCellError extends TypeError {
+  name = "XlsxCellError";
+}
+function refuse(where, expected) {
+  throw new XlsxCellError(`${where}: expected ${expected}`);
+}
+function exactNumber(value, where) {
+  const digits = value.replace(/^-|\./g, "").replace(/^0+/, "").replace(/0+$/, "");
+  if (digits.length > EXCEL_DIGITS) {
+    throw new XlsxCellError(`${where}: ${value} has more significant digits than Excel keeps (${EXCEL_DIGITS})`);
+  }
+  const stored = Number(value);
+  if (!Number.isFinite(stored) || stored === 0 && digits !== "") {
+    throw new XlsxCellError(`${where}: ${value} is outside what Excel can hold`);
+  }
+  return value;
+}
+function numberCell(value, where) {
+  if (typeof value === "number") {
+    if (!Number.isFinite(value))
+      refuse(where, "a finite number");
+    return { kind: "number", value: String(value) };
+  }
+  const text = typeof value === "bigint" ? value.toString() : value;
+  const parsed = DecimalInputSchema2.safeParse(text);
+  if (!parsed.success)
+    refuse(where, "a number or a decimal string");
+  return { kind: "number", value: exactNumber(parsed.data, where) };
+}
+function isMoney(value) {
+  return typeof value === "object" && value !== null && /^-?(?:0|[1-9]\d*)$/.test(String(Reflect.get(value, "minor"))) && typeof Reflect.get(value, "minor") === "string" && typeof Reflect.get(value, "currency") === "string";
+}
+function moneyCell(value, column, where) {
+  if (!isMoney(value))
+    return refuse(where, `Money in ${column.currency}`);
+  if (value.currency !== column.currency) {
+    return refuse(where, `Money in ${column.currency}, not ${value.currency}`);
+  }
+  return {
+    kind: "number",
+    value: exactNumber(moneyToDecimal2(value, column.scale), where)
+  };
+}
+function dateCell(value, where) {
+  const match = typeof value === "string" ? /^(\d{4})-(\d{2})-(\d{2})$/.exec(value) : null;
+  if (!match)
+    return refuse(where, "a date as YYYY-MM-DD");
+  const [, year, month, day] = match;
+  const time = Date.UTC(Number(year), Number(month) - 1, Number(day));
+  if (new Date(time).toISOString().slice(0, 10) !== value) {
+    return refuse(where, "a calendar date that exists");
+  }
+  const unixDay = time / MS_PER_DAY;
+  if (unixDay < FIRST_RELIABLE_DAY)
+    return refuse(where, "a date from 1900-03-01");
+  return { kind: "number", value: String(unixDay - EXCEL_EPOCH_DAY) };
+}
+function instantOf(value) {
+  if (value instanceof Date)
+    return value.getTime();
+  return InstantSchema.safeParse(value).success ? Date.parse(String(value)) : undefined;
+}
+var wallClocks = new Map;
+function wallClockIn(timeZone) {
+  const known = wallClocks.get(timeZone);
+  if (known)
+    return known;
+  const created = new Intl.DateTimeFormat("en-US", {
+    timeZone,
+    hourCycle: "h23",
+    year: "numeric",
+    month: "numeric",
+    day: "numeric",
+    hour: "numeric",
+    minute: "numeric",
+    second: "numeric"
+  });
+  wallClocks.set(timeZone, created);
+  return created;
+}
+function datetimeCell(value, column, where) {
+  const instant = instantOf(value);
+  if (instant === undefined || Number.isNaN(instant)) {
+    return refuse(where, "a Date or an ISO instant with an offset");
+  }
+  if (instant / MS_PER_DAY < FIRST_RELIABLE_DAY || instant / MS_PER_DAY >= LAST_DAY) {
+    return refuse(where, "an instant from 1900-03-01 to 9999-12-30");
+  }
+  const fields = wallClockIn(column.timeZone).formatToParts(instant);
+  const field = (type) => Number(fields.find((part) => part.type === type)?.value);
+  const wallClock = Date.UTC(field("year"), field("month") - 1, field("day"), field("hour"), field("minute"), field("second"));
+  if (wallClock / MS_PER_DAY < FIRST_RELIABLE_DAY) {
+    return refuse(where, "an instant from 1900-03-01 in its time zone");
+  }
+  return { kind: "number", value: String(wallClock / MS_PER_DAY - EXCEL_EPOCH_DAY) };
+}
+function cellOf(value, column, where) {
+  switch (column.type) {
+    case "text":
+      if (typeof value !== "string")
+        return refuse(where, "text");
+      if (value.length > MAX_TEXT)
+        return refuse(where, `at most ${MAX_TEXT} characters`);
+      return { kind: "text", value };
+    case "number":
+      return numberCell(value, where);
+    case "money":
+      return moneyCell(value, column, where);
+    case "date":
+      return dateCell(value, where);
+    case "datetime":
+      return datetimeCell(value, column, where);
+    case "boolean":
+      if (typeof value !== "boolean")
+        return refuse(where, "a boolean");
+      return { kind: "boolean", value };
+  }
+}
+// src/xlsx/schema.ts
+import { z as z2 } from "zod";
+var ColumnBase = {
+  key: z2.string().min(1),
+  header: z2.string().min(1),
+  width: z2.number().positive().max(255).optional()
+};
+var TimeZoneSchema = z2.string().refine((zone) => {
+  try {
+    new Intl.DateTimeFormat("en", { timeZone: zone });
+    return true;
+  } catch {
+    return false;
+  }
+}, "expected an IANA time zone");
+var XlsxColumnSchema = z2.discriminatedUnion("type", [
+  z2.object({ ...ColumnBase, type: z2.literal("text") }),
+  z2.object({
+    ...ColumnBase,
+    type: z2.literal("number"),
+    format: z2.string().min(1).optional()
+  }),
+  z2.object({ ...ColumnBase, type: z2.literal("date") }),
+  z2.object({ ...ColumnBase, type: z2.literal("datetime"), timeZone: TimeZoneSchema }),
+  z2.object({
+    ...ColumnBase,
+    type: z2.literal("money"),
+    currency: z2.string().regex(/^[\p{L}\p{Sc}\d .]{1,12}$/u),
+    scale: z2.number().int().min(0).max(6)
+  }),
+  z2.object({ ...ColumnBase, type: z2.literal("boolean") })
+]);
+var SHEET_NAME = /^(?!')[^\p{Cc}[\]:*?/\\\ufffe\uffff]{1,31}(?<!')$/u;
+var XlsxSheetSchema = z2.object({
+  name: z2.string().regex(SHEET_NAME, "expected a sheet name Excel accepts").max(31).refine((name) => name.toLowerCase() !== "history", "Excel keeps the name History"),
+  columns: z2.array(XlsxColumnSchema).min(1).max(16384).readonly(),
+  rows: z2.array(z2.record(z2.string(), z2.unknown())).max(1048575).readonly()
+});
+var XlsxWorkbookSchema = z2.object({
+  sheets: z2.array(XlsxSheetSchema).min(1).refine((sheets) => new Set(sheets.map((sheet) => sheet.name.toLowerCase())).size === sheets.length, "sheet names must differ, ignoring case").readonly()
+});
+
+// src/xlsx/zip.ts
+var DOS_EPOCH_DATE = 33;
+var VERSION = 20;
+var UTF8_NAMES = 2048;
+var DEFLATE = 8;
+var CRC_TABLE = Uint32Array.from({ length: 256 }, (_, index) => {
+  let value = index;
+  for (let bit = 0;bit < 8; bit += 1) {
+    value = value & 1 ? 3988292384 ^ value >>> 1 : value >>> 1;
+  }
+  return value >>> 0;
+});
+function crc32(bytes) {
+  let crc = 4294967295;
+  for (const byte of bytes) {
+    crc = (CRC_TABLE[(crc ^ byte) & 255] ?? 0) ^ crc >>> 8;
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+async function deflate(bytes) {
+  const stream = new Blob([bytes]).stream().pipeThrough(new CompressionStream("deflate-raw"));
+  return new Uint8Array(await new Response(stream).arrayBuffer());
+}
+function record(length, write) {
+  const buffer = new Uint8Array(length);
+  const view = new DataView(buffer.buffer);
+  let offset = 0;
+  write({
+    u16(value) {
+      view.setUint16(offset, value, true);
+      offset += 2;
+    },
+    u32(value) {
+      view.setUint32(offset, value, true);
+      offset += 4;
+    },
+    bytes(value) {
+      buffer.set(value, offset);
+      offset += value.byteLength;
+    }
+  });
+  return buffer;
+}
+async function zip(entries) {
+  const encoder = new TextEncoder;
+  const parts = [];
+  const directory = [];
+  let offset = 0;
+  for (const entry of entries) {
+    const name = encoder.encode(entry.name);
+    const content = encoder.encode(entry.content);
+    const compressed = await deflate(content);
+    const crc = crc32(content);
+    const common = (fields) => {
+      fields.u16(VERSION);
+      fields.u16(UTF8_NAMES);
+      fields.u16(DEFLATE);
+      fields.u16(0);
+      fields.u16(DOS_EPOCH_DATE);
+      fields.u32(crc);
+      fields.u32(compressed.byteLength);
+      fields.u32(content.byteLength);
+      fields.u16(name.byteLength);
+      fields.u16(0);
+    };
+    const local = record(30 + name.byteLength, (fields) => {
+      fields.u32(67324752);
+      common(fields);
+      fields.bytes(name);
+    });
+    directory.push(record(46 + name.byteLength, (fields) => {
+      fields.u32(33639248);
+      fields.u16(VERSION);
+      common(fields);
+      fields.u16(0);
+      fields.u16(0);
+      fields.u16(0);
+      fields.u32(0);
+      fields.u32(offset);
+      fields.bytes(name);
+    }));
+    parts.push(local, compressed);
+    offset += local.byteLength + compressed.byteLength;
+  }
+  const directorySize = directory.reduce((total, part) => total + part.byteLength, 0);
+  const end = record(22, (fields) => {
+    fields.u32(101010256);
+    fields.u16(0);
+    fields.u16(0);
+    fields.u16(entries.length);
+    fields.u16(entries.length);
+    fields.u32(directorySize);
+    fields.u32(offset);
+    fields.u16(0);
+  });
+  const all = [...parts, ...directory, end];
+  const bytes = new Uint8Array(all.reduce((total, part) => total + part.byteLength, 0));
+  let position = 0;
+  for (const part of all) {
+    bytes.set(part, position);
+    position += part.byteLength;
+  }
+  return bytes;
+}
+
+// src/xlsx/render.ts
+var XLSX_MEDIA_TYPE = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+var SPREADSHEET = "http://schemas.openxmlformats.org/spreadsheetml/2006/main";
+var RELATIONSHIPS = "http://schemas.openxmlformats.org/package/2006/relationships";
+var OFFICE_RELATIONSHIPS = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+var XML_DECLARATION = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+`;
+var FORMULA_START = /^[=+\-@]/;
+var STYLE_HEADER = 1;
+var STYLE_LITERAL_TEXT = 2;
+var FIRST_CUSTOM_STYLE = 3;
+var FIRST_CUSTOM_FORMAT = 164;
+function escapeXml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+}
+function escapeText(value) {
+  return escapeXml(value.replace(/_(?=x[0-9A-Fa-f]{4}_)/g, "_x005F_").replace(/[\u0000-\u0008\u000b-\u001f￾￿]/g, (character) => `_x${character.charCodeAt(0).toString(16).padStart(4, "0")}_`));
+}
+function columnName(index) {
+  let name = "";
+  for (let rest = index + 1;rest > 0; rest = Math.floor((rest - 1) / 26)) {
+    name = String.fromCharCode(65 + (rest - 1) % 26) + name;
+  }
+  return name;
+}
+function numberFormat(column) {
+  switch (column.type) {
+    case "date":
+      return "yyyy\\-mm\\-dd";
+    case "datetime":
+      return "yyyy\\-mm\\-dd\\ hh:mm:ss";
+    case "money":
+      return `#,##0${column.scale > 0 ? `.${"0".repeat(column.scale)}` : ""}\\ "${column.currency}"`;
+    case "number":
+      return column.format;
+    default:
+      return;
+  }
+}
+
+class StyleTable {
+  formats = [];
+  styleOf(column) {
+    const format = numberFormat(column);
+    if (format === undefined)
+      return 0;
+    const known = this.formats.indexOf(format);
+    if (known !== -1)
+      return FIRST_CUSTOM_STYLE + known;
+    this.formats.push(format);
+    return FIRST_CUSTOM_STYLE + this.formats.length - 1;
+  }
+  xml() {
+    const formats = this.formats.map((format, index) => `<numFmt numFmtId="${FIRST_CUSTOM_FORMAT + index}" formatCode="${escapeXml(format)}"/>`).join("");
+    const styles = this.formats.map((_, index) => `<xf numFmtId="${FIRST_CUSTOM_FORMAT + index}" fontId="0" fillId="0" borderId="0" xfId="0" applyNumberFormat="1"/>`).join("");
+    return `${XML_DECLARATION}<styleSheet xmlns="${SPREADSHEET}">${formats ? `<numFmts count="${this.formats.length}">${formats}</numFmts>` : ""}<fonts count="2"><font><sz val="11"/><name val="Calibri"/></font><font><b/><sz val="11"/><name val="Calibri"/></font></fonts><fills count="2"><fill><patternFill patternType="none"/></fill><fill><patternFill patternType="gray125"/></fill></fills><borders count="1"><border><left/><right/><top/><bottom/><diagonal/></border></borders><cellStyleXfs count="1"><xf numFmtId="0" fontId="0" fillId="0" borderId="0"/></cellStyleXfs><cellXfs count="${FIRST_CUSTOM_STYLE + this.formats.length}"><xf numFmtId="0" fontId="0" fillId="0" borderId="0" xfId="0"/><xf numFmtId="0" fontId="1" fillId="0" borderId="0" xfId="0" applyFont="1"/><xf numFmtId="49" fontId="0" fillId="0" borderId="0" xfId="0" quotePrefix="1" applyNumberFormat="1"/>${styles}</cellXfs><cellStyles count="1"><cellStyle name="Normal" xfId="0" builtinId="0"/></cellStyles></styleSheet>`;
+  }
+}
+function textCell(reference, value, style) {
+  const styled = style === 0 ? "" : ` s="${style}"`;
+  return `<c r="${reference}"${styled} t="inlineStr"><is><t xml:space="preserve">${escapeText(value)}</t></is></c>`;
+}
+function cellXml(reference, cell, style) {
+  switch (cell.kind) {
+    case "text":
+      return textCell(reference, cell.value, FORMULA_START.test(cell.value) ? STYLE_LITERAL_TEXT : 0);
+    case "boolean":
+      return `<c r="${reference}" t="b"><v>${cell.value ? 1 : 0}</v></c>`;
+    case "number":
+      return `<c r="${reference}"${style === 0 ? "" : ` s="${style}"`}><v>${cell.value}</v></c>`;
+  }
+}
+function sheetXml(sheet, styles) {
+  const keys = new Set(sheet.columns.map((column) => column.key));
+  if (keys.size !== sheet.columns.length) {
+    throw new TypeError(`sheet "${sheet.name}": a column key repeats`);
+  }
+  const columnStyles = sheet.columns.map((column) => styles.styleOf(column));
+  const widths = sheet.columns.map((column, index) => {
+    const width = column.width ?? Math.max(12, Math.min(column.header.length + 2, 60));
+    return `<col min="${index + 1}" max="${index + 1}" width="${width}" customWidth="1"/>`;
+  }).join("");
+  const header = sheet.columns.map((column, index) => textCell(`${columnName(index)}1`, column.header, STYLE_HEADER)).join("");
+  const rows = sheet.rows.map((row, rowIndex) => {
+    const rowNumber = rowIndex + 2;
+    const cells = sheet.columns.flatMap((column, columnIndex) => {
+      const value = row[column.key];
+      if (value === undefined || value === null)
+        return [];
+      const reference = `${columnName(columnIndex)}${rowNumber}`;
+      const cell = cellOf(value, column, `sheet "${sheet.name}" ${reference}`);
+      return [cellXml(reference, cell, columnStyles[columnIndex] ?? 0)];
+    });
+    return `<row r="${rowNumber}">${cells.join("")}</row>`;
+  });
+  const lastCell = `${columnName(sheet.columns.length - 1)}${sheet.rows.length + 1}`;
+  return `${XML_DECLARATION}<worksheet xmlns="${SPREADSHEET}"><dimension ref="A1:${lastCell}"/><sheetViews><sheetView workbookViewId="0"><pane ySplit="1" topLeftCell="A2" activePane="bottomLeft" state="frozen"/></sheetView></sheetViews><cols>${widths}</cols><sheetData><row r="1">${header}</row>${rows.join("")}</sheetData><autoFilter ref="A1:${lastCell}"/></worksheet>`;
+}
+async function renderXlsx(workbook) {
+  const { sheets } = XlsxWorkbookSchema.parse(workbook);
+  const styles = new StyleTable;
+  const worksheets = sheets.map((sheet, index) => ({
+    name: `xl/worksheets/sheet${index + 1}.xml`,
+    content: sheetXml(sheet, styles)
+  }));
+  const contentTypes = `${XML_DECLARATION}<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types"><Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/><Default Extension="xml" ContentType="application/xml"/><Override PartName="/xl/workbook.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml"/><Override PartName="/xl/styles.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml"/>${worksheets.map(({ name }) => `<Override PartName="/${name}" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"/>`).join("")}</Types>`;
+  const packageRelationships = `${XML_DECLARATION}<Relationships xmlns="${RELATIONSHIPS}"><Relationship Id="rId1" Type="${OFFICE_RELATIONSHIPS}/officeDocument" Target="xl/workbook.xml"/></Relationships>`;
+  const workbookXml = `${XML_DECLARATION}<workbook xmlns="${SPREADSHEET}" xmlns:r="${OFFICE_RELATIONSHIPS}"><bookViews><workbookView/></bookViews><sheets>${sheets.map((sheet, index) => `<sheet name="${escapeXml(sheet.name)}" sheetId="${index + 1}" r:id="rId${index + 1}"/>`).join("")}</sheets></workbook>`;
+  const workbookRelationships = `${XML_DECLARATION}<Relationships xmlns="${RELATIONSHIPS}">${sheets.map((_, index) => `<Relationship Id="rId${index + 1}" Type="${OFFICE_RELATIONSHIPS}/worksheet" Target="worksheets/sheet${index + 1}.xml"/>`).join("")}<Relationship Id="rId${sheets.length + 1}" Type="${OFFICE_RELATIONSHIPS}/styles" Target="styles.xml"/></Relationships>`;
+  return await zip([
+    { name: "[Content_Types].xml", content: contentTypes },
+    { name: "_rels/.rels", content: packageRelationships },
+    { name: "xl/workbook.xml", content: workbookXml },
+    { name: "xl/_rels/workbook.xml.rels", content: workbookRelationships },
+    { name: "xl/styles.xml", content: styles.xml() },
+    ...worksheets
+  ]);
+}
+export {
+  XLSX_MEDIA_TYPE,
+  XlsxCellError,
+  XlsxColumnSchema,
+  XlsxSheetSchema,
+  XlsxWorkbookSchema,
+  renderXlsx
+};

package/dist/{index-fa435yq2.js → index-073nw9qr.js}

@@ -4,22 +4,22 @@ import {
   AgentStoreEventPageSchema2,
   AgentRecoverableDescriptorSchema2,
   AgentRecoverablePageSchema2,
-  canonicalAgentJson2
-} from "./index-fggxgbrk.js";
+  canonicalAgentJson2,
+  AgentRuntimeHeadSchema2,
+  AgentStoredRunSchema2,
+  AgentAdmissionReceiptSchema2,
+  AgentSeedReceiptSchema2,
+  AgentHistoryMutationSchema2
+} from "./index-xx1j310k.js";
 import {
   AgentMessageSchema2,
   AgentRunSchema2
 } from "./index-8kzct1d6.js";
 import {
-  AgentRuntimeHeadSchema2,
-  AgentStoredRunSchema2,
-  AgentAdmissionReceiptSchema2,
-  AgentSeedReceiptSchema2,
-  AgentHistoryMutationSchema2,
   appendEventIn,
   ArchiveProjectionSchema,
   createAgentRuntimeStore2
-} from "./index-jq2ky8fw.js";
+} from "./index-cycp3r3e.js";
 import {
   AgentConversationPageSchema2,
   AgentConversationMessagePageSchema2

package/dist/index-1f40z584.js

@@ -0,0 +1,7 @@
+// src/tracking/server/bot.ts
+var DEFAULT_BOT_USER_AGENT_PATTERN2 = /bot|crawl|spider|slurp|mediapartners|facebookexternalhit|bingpreview|yandex|baidu|duckduckbot|uptimerobot|pingdom|gtmetrix|pagespeed|lighthouse|headlesschrome/i;
+function isBotUserAgent2(userAgent, pattern = DEFAULT_BOT_USER_AGENT_PATTERN2) {
+  return userAgent ? pattern.test(userAgent) : false;
+}
+
+export { DEFAULT_BOT_USER_AGENT_PATTERN2, isBotUserAgent2 };

package/dist/{index-fdk4r4r6.js → index-75ns2ybj.js}

@@ -1,6 +1,6 @@
 import {
   withExclusiveLock2
-} from "./index-zqkz4af9.js";
+} from "./index-nqxrm176.js";
 import {
   readBoundedFile
 } from "./index-m616f0yz.js";