@poetic-ai/poetic 1.42.0

package/dist/chunk-RZY7RKM5.js

@@ -0,0 +1,500 @@
+import {
+  withPlanningLock
+} from "./chunk-OPYFYTWQ.js";
+import {
+  findRepoRoot
+} from "./chunk-L7JZLXQL.js";
+import {
+  emitCustomWarning,
+  emitWarning
+} from "./chunk-EJGCZGUF.js";
+
+// src/planning/writeback.ts
+import { randomUUID } from "crypto";
+import * as fs from "fs";
+import * as path from "path";
+function appendJsonLineSync(filePath, line) {
+  const fd = fs.openSync(filePath, "a");
+  try {
+    fs.writeSync(fd, line, void 0, "utf-8");
+    fs.fsyncSync(fd);
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+function emitWritebackWarning(message, metadata, options = {}) {
+  emitCustomWarning(
+    "WARN" /* WARN */,
+    "workspace_edits" /* WORKSPACE_EDITS */,
+    message,
+    {
+      taskId: "writeback",
+      subsystem: "planning/writeback",
+      executionPhase: "execution"
+    },
+    { metadata, skipConsole: options.skipConsole ?? true }
+  );
+}
+function formatActivityEntry(activity) {
+  const lines = [];
+  const statusLabel = {
+    started: "Started",
+    completed: "Completed",
+    failed: "Failed",
+    blocked: "Blocked",
+    progress: "Progress"
+  }[activity.type];
+  lines.push(`- **${activity.timestamp}** - ${statusLabel}: ${activity.description}`);
+  const meta = activity.metadata;
+  if (meta) {
+    if (meta.durationSeconds !== void 0) {
+      const minutes = Math.floor(meta.durationSeconds / 60);
+      const seconds = meta.durationSeconds % 60;
+      const duration = minutes > 0 ? `${minutes}m ${seconds}s` : `${seconds}s`;
+      lines.push(`  - Duration: ${duration}`);
+    }
+    if (meta.iterations !== void 0) {
+      lines.push(`  - Iterations: ${meta.iterations}`);
+    }
+    if (meta.costStatus === "available" && typeof meta.totalCost === "number" && Number.isFinite(meta.totalCost)) {
+      lines.push(`  - Cost: $${meta.totalCost.toFixed(4)}`);
+    } else if (meta.costStatus === "unavailable") {
+      const reason = meta.costUnavailableReason ?? "provider_not_reported";
+      lines.push(`  - Cost: unavailable (${reason})`);
+    }
+    if (meta.branch) {
+      lines.push(`  - Branch: \`${meta.branch}\``);
+    }
+    if (meta.planPath) {
+      lines.push(`  - Plan: \`${meta.planPath}\``);
+    }
+    if (meta.filesChanged && meta.filesChanged.length > 0) {
+      lines.push(`  - Files changed: ${meta.filesChanged.length}`);
+      if (meta.filesChanged.length <= 5) {
+        for (const file of meta.filesChanged) {
+          lines.push(`    - \`${file}\``);
+        }
+      }
+    }
+    if (meta.prNumber) {
+      lines.push(`  - PR: #${meta.prNumber}`);
+    }
+    if (meta.qualityGate) {
+      const qg = meta.qualityGate;
+      const status = qg.passed ? "passed" : "failed";
+      lines.push(`  - Quality gate (${qg.preset}): ${status}`);
+      if (qg.failedChecks && qg.failedChecks.length > 0) {
+        lines.push(`    - Failed: ${qg.failedChecks.join(", ")}`);
+      }
+    }
+    if (meta.error) {
+      lines.push(`  - Error: ${meta.error}`);
+    }
+  }
+  return lines.join("\n");
+}
+var writeLocks = /* @__PURE__ */ new Map();
+var CROSS_PROCESS_LOCK_TIMEOUT_MS = 5e3;
+var CROSS_PROCESS_LOCK_STALE_MS = 3e4;
+function isOwnerProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function sleep(milliseconds) {
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+function lockSnapshotStillMatchesSync(lockPath, snapshot) {
+  try {
+    const stat = fs.statSync(lockPath);
+    const contents = fs.readFileSync(lockPath, "utf-8");
+    return stat.dev === snapshot.dev && stat.ino === snapshot.ino && contents === snapshot.rawContent;
+  } catch {
+    return false;
+  }
+}
+function unlinkLockIfSnapshotMatchesSync(lockPath, snapshot) {
+  if (!lockSnapshotStillMatchesSync(lockPath, snapshot)) {
+    return false;
+  }
+  fs.unlinkSync(lockPath);
+  return true;
+}
+async function acquireCrossProcessLock(itemPath) {
+  const lockPath = `${itemPath}.lock`;
+  const startedAt = Date.now();
+  const raceRetryDeadlineMs = Date.now() + 250;
+  while (Date.now() - startedAt < CROSS_PROCESS_LOCK_TIMEOUT_MS) {
+    try {
+      const fd = fs.openSync(lockPath, "wx");
+      const ownerToken = `${process.pid}:${randomUUID()}`;
+      const lockContent = `${ownerToken}
+${(/* @__PURE__ */ new Date()).toISOString()}
+`;
+      try {
+        fs.writeFileSync(fd, lockContent, "utf-8");
+      } catch (writeError) {
+        try {
+          fs.closeSync(fd);
+        } catch {
+        }
+        try {
+          fs.unlinkSync(lockPath);
+        } catch {
+        }
+        throw writeError;
+      }
+      fs.closeSync(fd);
+      const lockStat = fs.statSync(lockPath);
+      const snapshot = {
+        dev: lockStat.dev,
+        ino: lockStat.ino,
+        rawContent: lockContent
+      };
+      return () => {
+        unlinkLockIfSnapshotMatchesSync(lockPath, snapshot);
+      };
+    } catch (error) {
+      const errno = error;
+      if (errno.code !== "EEXIST") {
+        throw error;
+      }
+      let shouldClearStaleLock = false;
+      let staleSnapshot = null;
+      try {
+        const stat = fs.statSync(lockPath);
+        const lockAgeMs = Date.now() - stat.mtimeMs;
+        if (lockAgeMs >= CROSS_PROCESS_LOCK_STALE_MS) {
+          const contents = fs.readFileSync(lockPath, "utf-8");
+          const ownerPid = Number.parseInt(contents.trim().split("\n")[0] ?? "0", 10);
+          shouldClearStaleLock = ownerPid > 0 ? !isOwnerProcessAlive(ownerPid) : lockAgeMs >= CROSS_PROCESS_LOCK_STALE_MS;
+          if (shouldClearStaleLock) {
+            staleSnapshot = { dev: stat.dev, ino: stat.ino, rawContent: contents };
+          }
+        }
+      } catch (lockError) {
+        if (lockError.code === "ENOENT") {
+          continue;
+        }
+      }
+      if (shouldClearStaleLock) {
+        try {
+          if (staleSnapshot && unlinkLockIfSnapshotMatchesSync(lockPath, staleSnapshot)) {
+            if (Date.now() < raceRetryDeadlineMs) {
+              await sleep(10);
+            }
+            continue;
+          }
+        } catch {
+        }
+      }
+      if (Date.now() < raceRetryDeadlineMs) {
+        await sleep(10);
+        continue;
+      }
+      await sleep(25);
+    }
+  }
+  throw new Error(`Timed out waiting for writeback lock: ${itemPath}`);
+}
+function appendActivity(itemPath, activity) {
+  const previous = (writeLocks.get(itemPath) ?? Promise.resolve()).catch((err) => {
+    const error = err instanceof Error ? err.message : String(err);
+    emitWritebackWarning(`[writeback] Prior write to ${itemPath} failed: ${error}`, {
+      itemPath,
+      error,
+      operation: "append-activity-prior-write"
+    });
+  });
+  let releaseLock;
+  const nextLock = new Promise((resolve) => {
+    releaseLock = resolve;
+  });
+  const lockTail = previous.then(() => nextLock);
+  writeLocks.set(itemPath, lockTail);
+  return previous.then(() => {
+    const rootDir = findRepoRoot(path.dirname(itemPath));
+    return withPlanningLock(rootDir, async () => {
+      const releaseCrossProcessLock = await acquireCrossProcessLock(itemPath);
+      try {
+        let content;
+        try {
+          content = fs.readFileSync(itemPath, "utf-8");
+        } catch (error) {
+          if (error.code === "ENOENT") {
+            throw new Error(`Work item file not found: ${itemPath}`);
+          }
+          throw error;
+        }
+        const formattedActivity = formatActivityEntry(activity);
+        const activitySectionRegex = /^## Activity\s*$/m;
+        const match = content.match(activitySectionRegex);
+        if (match && match.index !== void 0) {
+          const afterActivity = content.slice(match.index + match[0].length);
+          const nextSectionMatch = afterActivity.match(/^## /m);
+          const insertPosition = nextSectionMatch && nextSectionMatch.index !== void 0 ? match.index + match[0].length + nextSectionMatch.index : content.length;
+          const activityContent = content.slice(match.index + match[0].length, insertPosition);
+          const trimmedActivityContent = activityContent.trimEnd();
+          const newActivitySection = trimmedActivityContent.length > 0 ? `${trimmedActivityContent}
+
+${formattedActivity}` : `
+${formattedActivity}`;
+          content = content.slice(0, match.index + match[0].length) + newActivitySection + (nextSectionMatch ? `
+
+${content.slice(insertPosition)}` : "\n");
+        } else {
+          content = `${content.trimEnd()}
+
+## Activity
+
+${formattedActivity}
+`;
+        }
+        let tmpPath = `${itemPath}.tmp-${process.pid}`;
+        try {
+          fs.writeFileSync(tmpPath, content, "utf-8");
+          fs.renameSync(tmpPath, itemPath);
+          tmpPath = void 0;
+          fs.utimesSync(itemPath, /* @__PURE__ */ new Date(), /* @__PURE__ */ new Date());
+        } finally {
+          if (tmpPath) {
+            try {
+              fs.unlinkSync(tmpPath);
+            } catch {
+            }
+          }
+        }
+      } finally {
+        releaseCrossProcessLock();
+      }
+    });
+  }).finally(() => {
+    releaseLock?.();
+    if (writeLocks.get(itemPath) === lockTail) {
+      writeLocks.delete(itemPath);
+    }
+  });
+}
+var DEFAULT_QUEUE_PATH = ".poetic/writeback-queue.jsonl";
+var DEFAULT_DEAD_LETTER_PATH = ".poetic/writeback-dead-letter.jsonl";
+function getQueuePath(repoRoot = findRepoRoot(process.cwd())) {
+  return path.join(repoRoot, DEFAULT_QUEUE_PATH);
+}
+function getDeadLetterPath(repoRoot = findRepoRoot(process.cwd())) {
+  return path.join(repoRoot, DEFAULT_DEAD_LETTER_PATH);
+}
+async function appendToQueue(queuePath, entry) {
+  const rootDir = findRepoRoot(path.dirname(queuePath));
+  await withPlanningLock(rootDir, async () => {
+    const dir = path.dirname(queuePath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    const line = `${JSON.stringify(entry)}
+`;
+    appendJsonLineSync(queuePath, line);
+  });
+}
+function readQueue(queuePath) {
+  if (!fs.existsSync(queuePath)) {
+    return [];
+  }
+  const content = fs.readFileSync(queuePath, "utf-8");
+  const entries = [];
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed) {
+      try {
+        entries.push(JSON.parse(trimmed));
+      } catch {
+      }
+    }
+  }
+  return entries;
+}
+function writeQueue(queuePath, entries) {
+  const dir = path.dirname(queuePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  const content = entries.map((e) => JSON.stringify(e)).join("\n");
+  const tempPath = path.join(
+    dir,
+    `.${path.basename(queuePath)}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`
+  );
+  const fd = fs.openSync(tempPath, "w");
+  try {
+    fs.writeSync(fd, content ? `${content}
+` : "", void 0, "utf-8");
+    fs.fsyncSync(fd);
+  } finally {
+    fs.closeSync(fd);
+  }
+  try {
+    fs.renameSync(tempPath, queuePath);
+  } catch (error) {
+    try {
+      fs.unlinkSync(tempPath);
+    } catch {
+    }
+    throw error;
+  }
+}
+function appendToDeadLetter(queuePath, entry) {
+  const rootDir = findRepoRoot(path.dirname(queuePath));
+  const deadLetterPath = getDeadLetterPath(rootDir);
+  const dir = path.dirname(deadLetterPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  const deadLettered = {
+    ...entry,
+    deadLetteredAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  appendJsonLineSync(deadLetterPath, `${JSON.stringify(deadLettered)}
+`);
+  emitWarning(
+    "WB-001",
+    {
+      taskId: path.basename(entry.itemPath),
+      subsystem: "planning-writeback",
+      executionPhase: "cleanup"
+    },
+    {
+      severity: "WARN" /* WARN */,
+      metadata: {
+        operation: "writeback-dead-letter",
+        itemPath: entry.itemPath,
+        deadLetterPath,
+        retryCount: entry.retryCount,
+        error: entry.error
+      }
+    }
+  );
+}
+async function removeFromQueue(queuePath, entry) {
+  const rootDir = findRepoRoot(path.dirname(queuePath));
+  await withPlanningLock(rootDir, async () => {
+    const entries = readQueue(queuePath);
+    const filtered = entries.filter(
+      (e) => e.itemPath !== entry.itemPath || e.attemptedAt !== entry.attemptedAt || e.activity.timestamp !== entry.activity.timestamp
+    );
+    writeQueue(queuePath, filtered);
+  });
+}
+async function writeback(itemPath, activity, options = {}) {
+  const cwdOrRepoRoot = options.poeticDir || process.cwd();
+  const queuePath = getQueuePath(findRepoRoot(cwdOrRepoRoot));
+  try {
+    await appendActivity(itemPath, activity);
+    return { success: true, queued: false };
+  } catch (error) {
+    const queuedEntry = {
+      itemPath,
+      activity,
+      attemptedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      error: error instanceof Error ? error.message : String(error),
+      retryCount: 0
+    };
+    await appendToQueue(queuePath, queuedEntry);
+    if (options.verbose) {
+      emitWritebackWarning(
+        `Writeback failed for ${itemPath}: ${queuedEntry.error}`,
+        {
+          itemPath,
+          queuePath,
+          error: queuedEntry.error,
+          operation: "writeback-queued"
+        },
+        { skipConsole: false }
+      );
+      emitWritebackWarning(
+        `Queued for retry in ${queuePath}`,
+        {
+          itemPath,
+          queuePath,
+          operation: "writeback-queued-location"
+        },
+        { skipConsole: false }
+      );
+    }
+    return { success: false, queued: true };
+  }
+}
+async function retryPendingWritebacks(options = {}) {
+  const cwdOrRepoRoot = options.poeticDir || process.cwd();
+  const queuePath = getQueuePath(findRepoRoot(cwdOrRepoRoot));
+  const maxRetries = options.maxRetries || 5;
+  return withPlanningLock(findRepoRoot(cwdOrRepoRoot), async () => {
+    const entries = readQueue(queuePath);
+    const remaining = [];
+    let succeeded = 0;
+    let failed = 0;
+    for (const entry of entries) {
+      try {
+        await appendActivity(entry.itemPath, entry.activity);
+        succeeded++;
+        if (options.verbose) {
+          console.log(`Writeback retry succeeded: ${entry.itemPath}`);
+        }
+      } catch (error) {
+        const newRetryCount = entry.retryCount + 1;
+        if (newRetryCount >= maxRetries) {
+          failed++;
+          appendToDeadLetter(queuePath, {
+            ...entry,
+            retryCount: newRetryCount,
+            error: error instanceof Error ? error.message : String(error)
+          });
+          if (options.verbose) {
+            emitWritebackWarning(
+              `Writeback permanently failed after ${maxRetries} retries: ${entry.itemPath}`,
+              {
+                itemPath: entry.itemPath,
+                maxRetries,
+                error: error instanceof Error ? error.message : String(error),
+                operation: "writeback-permanent-failure"
+              },
+              { skipConsole: false }
+            );
+          }
+        } else {
+          remaining.push({
+            ...entry,
+            retryCount: newRetryCount,
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
+      }
+    }
+    writeQueue(queuePath, remaining);
+    return {
+      processed: entries.length,
+      succeeded,
+      failed,
+      remaining: remaining.length
+    };
+  });
+}
+function getPendingWritebackCount(poeticDir = process.cwd()) {
+  const queuePath = getQueuePath(findRepoRoot(poeticDir));
+  return readQueue(queuePath).length;
+}
+
+export {
+  formatActivityEntry,
+  appendActivity,
+  getQueuePath,
+  getDeadLetterPath,
+  appendToQueue,
+  readQueue,
+  writeQueue,
+  removeFromQueue,
+  writeback,
+  retryPendingWritebacks,
+  getPendingWritebackCount
+};
+//# sourceMappingURL=chunk-RZY7RKM5.js.map

package/dist/chunk-S2MNWFAG.js

@@ -0,0 +1,52 @@
+// src/core/synthesis/synthesis-result-status.ts
+function hasDeliveredWinnerMaterial(fields) {
+  if (typeof fields.code === "string" && fields.code.trim().length > 0) return true;
+  const merged = Array.isArray(fields.mergedVariants) ? fields.mergedVariants : [];
+  return merged.length > 0;
+}
+function uniqueVariantCount(fields) {
+  const ids = [
+    ...Array.isArray(fields.contributingVariants) ? fields.contributingVariants : [],
+    ...Array.isArray(fields.mergedVariants) ? fields.mergedVariants : []
+  ].filter((value) => typeof value === "string" && value.trim().length > 0).map((value) => value.trim());
+  return new Set(ids).size;
+}
+function isSynthesisResultDelivered(fields) {
+  if (fields.deliverySucceeded === true) return true;
+  if (fields.winnerFallback === true) return true;
+  if (fields.winnerClone === true) return true;
+  if (fields.synthesisOutcomeStatus === "winner_carry_forward") return true;
+  if (fields.synthesisApplied === true) return true;
+  if (fields.success === true && hasDeliveredWinnerMaterial(fields)) return true;
+  return false;
+}
+function resolveSynthesisResultStatus(fields) {
+  if (!isSynthesisResultDelivered(fields)) return null;
+  if (fields.synthesisApplied === true && uniqueVariantCount(fields) > 1) {
+    return "synthesized";
+  }
+  return "winner_retained";
+}
+function resolveSynthesisDeliveryProjection(fields) {
+  const delivered = isSynthesisResultDelivered(fields);
+  return {
+    success: delivered,
+    resultStatus: resolveSynthesisResultStatus(fields)
+  };
+}
+function withSynthesisDeliveryFields(result) {
+  const projection = resolveSynthesisDeliveryProjection(result);
+  return {
+    ...result,
+    success: projection.success,
+    resultStatus: projection.resultStatus ?? void 0
+  };
+}
+
+export {
+  isSynthesisResultDelivered,
+  resolveSynthesisResultStatus,
+  resolveSynthesisDeliveryProjection,
+  withSynthesisDeliveryFields
+};
+//# sourceMappingURL=chunk-S2MNWFAG.js.map

package/dist/chunk-S2VQCZO4.js

@@ -0,0 +1,22 @@
+// src/utils/safe-path-component.ts
+var SAFE_PATH_COMPONENT_PATTERN = /^[A-Za-z0-9._-]+$/;
+function assertSafePathComponent(value, label) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    throw new Error(`${label} must not be empty`);
+  }
+  if (trimmed === "." || trimmed === "..") {
+    throw new Error(`${label} must not be "." or ".."`);
+  }
+  if (!SAFE_PATH_COMPONENT_PATTERN.test(trimmed)) {
+    throw new Error(
+      `${label} contains unsupported characters. Only letters, numbers, ".", "_", and "-" are allowed.`
+    );
+  }
+  return trimmed;
+}
+
+export {
+  assertSafePathComponent
+};
+//# sourceMappingURL=chunk-S2VQCZO4.js.map

package/dist/chunk-S54MKU6V.js

@@ -0,0 +1,117 @@
+// src/core/providers/shared/safe-json-parser.ts
+var JsonParseError = class extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "JsonParseError";
+  }
+  code;
+  details;
+};
+function calculateDepth(value, currentDepth = 0) {
+  if (typeof value !== "object" || value === null) {
+    return currentDepth;
+  }
+  const values = Array.isArray(value) ? value : Object.values(value);
+  if (values.length === 0) {
+    return currentDepth;
+  }
+  let maxDepth = currentDepth;
+  for (const child of values) {
+    const childDepth = calculateDepth(child, currentDepth + 1);
+    if (childDepth > maxDepth) {
+      maxDepth = childDepth;
+    }
+  }
+  return maxDepth;
+}
+function safeJsonParse(input, options = {}) {
+  const envMaxSizeRaw = typeof process !== "undefined" ? process.env?.POETIC_MAX_VARIANT_SIZE : void 0;
+  const parsedEnvMaxSize = typeof envMaxSizeRaw === "string" && envMaxSizeRaw.trim().length > 0 ? Number(envMaxSizeRaw) : void 0;
+  const envMaxSize = typeof parsedEnvMaxSize === "number" && Number.isFinite(parsedEnvMaxSize) && parsedEnvMaxSize > 0 ? parsedEnvMaxSize : void 0;
+  const DEFAULT_MAX_SIZE = envMaxSize ?? 1e6;
+  const {
+    maxSize = DEFAULT_MAX_SIZE,
+    maxDepth = 15,
+    debug = false,
+    validator,
+    context = "JSON input"
+  } = options;
+  const inputBytes = Buffer.byteLength(input, "utf8");
+  if (inputBytes > maxSize) {
+    throw new JsonParseError(
+      `${context} exceeds size limit: ${inputBytes} bytes (max: ${maxSize})`,
+      "SIZE_LIMIT",
+      { size: inputBytes, maxSize }
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(input);
+  } catch (error) {
+    if (debug && typeof process !== "undefined" && process.env?.POETIC_DEBUG === "1") {
+      console.debug(`Failed to parse ${context}: ${input.substring(0, 100)}`);
+    }
+    throw new JsonParseError(
+      `Failed to parse ${context}: ${error instanceof Error ? error.message : String(error)}`,
+      "PARSE_ERROR",
+      { originalError: error, preview: input.substring(0, 100) }
+    );
+  }
+  const actualDepth = calculateDepth(parsed);
+  if (actualDepth > maxDepth) {
+    throw new JsonParseError(
+      `JSON exceeds maximum nesting depth of ${maxDepth} (actual depth: ${actualDepth})`,
+      "DEPTH_LIMIT",
+      { depth: actualDepth, maxDepth }
+    );
+  }
+  if (validator && !validator(parsed)) {
+    throw new JsonParseError(`${context} failed validation`, "VALIDATION_ERROR", { parsed });
+  }
+  return parsed;
+}
+function safeParseJsonLines(input, options = {}) {
+  return safeParseJsonLinesWithStats(input, options).entries;
+}
+function safeParseJsonLinesWithStats(input, options = {}) {
+  const debug = options.debug ?? false;
+  let droppedCount = 0;
+  const lines = input.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  const entries = lines.map((line, index) => {
+    try {
+      return safeJsonParse(line, {
+        ...options,
+        context: `JSON line ${index + 1}`
+      });
+    } catch (error) {
+      droppedCount++;
+      if (typeof process !== "undefined" && process.env?.POETIC_DEBUG === "1") {
+        console.debug(
+          `Skipping invalid JSON on line ${index + 1}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      } else if (debug) {
+        console.debug(
+          `Skipping invalid JSON on line ${index + 1}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+      return void 0;
+    }
+  }).filter((entry) => entry != null);
+  if (droppedCount > 0 && typeof process !== "undefined" && process.env?.POETIC_DEBUG === "1") {
+    console.debug(`safeParseJsonLines: dropped ${droppedCount} invalid line(s)`);
+  }
+  return { entries, totalLines: lines.length, droppedCount };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export {
+  JsonParseError,
+  safeJsonParse,
+  safeParseJsonLines,
+  isRecord
+};
+//# sourceMappingURL=chunk-S54MKU6V.js.map