function createUnfiledCaptures({
  storage,
  attachmentStore = null,
  getCaptureLogin = () => '',
  getCurrentLogin = () => '',
  createId = () => globalThis.crypto?.randomUUID?.() || String(Date.now()) + '-' + Math.random().toString(16).slice(2),
  now = () => Date.now(),
  maxItems = 20,
}) {
  const storageKey = 'stackchain.unfiled-issues.v1';
  const listeners = new Set();
  const onChange = (id, removed) => listeners.forEach(listener => listener(id, removed));

  function read() {
    try {
      const record = JSON.parse(storage?.getItem(storageKey) || 'null');
      if (record?.version !== 1 || !Array.isArray(record.items)) return [];
      return record.items.filter(item =>
        item && typeof item.id === 'string' && typeof item.ownerLogin === 'string' &&
        typeof item.title === 'string' && item.title.trim() && typeof item.body === 'string'
      );
    } catch (_error) { return []; }
  }

  function write(items) {
    storage?.setItem(storageKey, JSON.stringify({version:1, items}));
  }

  function list() {
    const currentLogin = String(getCurrentLogin() || '').trim();
    return read().slice().sort((left, right) => Number(right.savedAt) - Number(left.savedAt))
      .map(item => ({...item, quarantined: !currentLogin || currentLogin !== item.ownerLogin}));
  }

  function capacity() {
    const items = read().slice().sort((left, right) => Number(right.savedAt) - Number(left.savedAt));
    return {full:items.length >= maxItems, count:items.length, maxItems, oldest:items.at(-1) || null};
  }

  function prepare(note) {
    const title = String(note?.title || '').trim().slice(0, 255);
    const body = String(note?.body || '').trim().slice(0, 10000);
    if (!title) throw new Error('Add a title before saving.');
    const ownerLogin = String(getCaptureLogin() || '').trim();
    if (!ownerLogin) throw new Error('Offline identity is unavailable. Reconnect once before saving private work.');
    const attachment = note?.attachment;
    const attachments = note?.attachments;
    if (Array.isArray(attachments) && attachments.length > 5) {
      throw new Error('You can attach up to 5 screenshots.');
    }
    const validAttachments = Array.isArray(attachments) && attachments.length > 0 &&
      attachments.every(value => value?.blob && value?.filename &&
        ['image/png', 'image/jpeg', 'image/webp'].includes(String(value?.contentType || '')));
    if (attachments && !validAttachments) {
      throw new Error('One or more screenshots are unavailable. Choose them again before saving.');
    }
    const hasAttachment = Boolean(attachment?.blob && attachment?.filename &&
      ['image/png', 'image/jpeg', 'image/webp'].includes(String(attachment?.contentType || '')));
    if (attachment && !hasAttachment) throw new Error('The screenshot is unavailable. Choose it again before saving.');
    if ((hasAttachment || validAttachments) && !attachmentStore) {
      throw new Error('Screenshot storage is unavailable. Your capture is still open; retry after reloading.');
    }
    const seenBlockers = new Set();
    const blockers = (Array.isArray(note?.blockers) ? note.blockers : []).reduce((items, blocker) => {
      const repository = String(blocker?.repository || '').trim();
      const number = Number(blocker?.number);
      const key = repository + '#' + number;
      if (items.length >= 5 || seenBlockers.has(key) ||
          !/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(repository) ||
          !Number.isInteger(number) || number < 1) return items;
      seenBlockers.add(key);
      items.push({repository, number,
        title:String(blocker?.title || '').replace(/\s+/g, ' ').trim().slice(0, 255)});
      return items;
    }, []);
    return {
      title, body, ownerLogin, attachment, attachments, blockers,
      hasAttachment:hasAttachment || validAttachments,
      attachmentCount:validAttachments ? attachments.length : (hasAttachment ? 1 : 0),
    };
  }

  function persist(prepared, existing, removed = null) {
    const item = {
      id:String(createId()), ownerLogin:prepared.ownerLogin, title:prepared.title, body:prepared.body,
      savedAt:Number(now()), ...(prepared.hasAttachment ? {
        hasAttachment:true, attachmentCount:prepared.attachmentCount,
      } : {}), ...(prepared.blockers.length ? {
        blockers:prepared.blockers, blockerCount:prepared.blockers.length,
      } : {}),
    };
    const items = [item, ...existing.filter(candidate => candidate.id !== item.id)];
    const writeItems = () => {
      try { write(items); }
      catch (error) {
        if (prepared.hasAttachment) Promise.resolve(attachmentStore.delete(item.id)).catch(() => {});
        throw error;
      }
      onChange(item.id, false);
      return item;
    };
    const stage = prepared.hasAttachment
      ? Promise.resolve(attachmentStore.put(item.id, prepared.attachments ? {
        attachments:prepared.attachments.map(value => ({
          filename:String(value.filename).slice(0, 255),
          contentType:String(value.contentType), blob:value.blob,
          ...(String(value.note || '').trim() ? {note:String(value.note).trim().slice(0, 240)} : {}),
        })),
      } : {
        filename:String(prepared.attachment.filename).slice(0, 255),
        contentType:String(prepared.attachment.contentType), blob:prepared.attachment.blob,
      }))
      : null;
    if (!stage && !removed?.hasAttachment) return writeItems();
    return Promise.resolve(stage).then(async () => {
      if (!removed?.hasAttachment) return writeItems();
      const removedAttachment = await attachmentStore.get(removed.id);
      try {
        await attachmentStore.delete(removed.id);
      } catch (error) {
        if (prepared.hasAttachment) await Promise.resolve(attachmentStore.delete(item.id)).catch(() => {});
        throw error;
      }
      try { return writeItems(); }
      catch (error) {
        if (removedAttachment) await Promise.resolve(attachmentStore.put(removed.id, removedAttachment)).catch(() => {});
        throw error;
      }
    });
  }

  function save(note) {
    const prepared = prepare(note);
    const existing = read();
    if (existing.length >= maxItems) throw new Error('Drafts full — nothing was deleted.');
    return persist(prepared, existing);
  }

  function replaceOldest(note, expectedOldestId) {
    const prepared = prepare(note);
    const existing = read().slice().sort((left, right) => Number(right.savedAt) - Number(left.savedAt));
    const oldest = existing.at(-1);
    if (existing.length < maxItems || !oldest || oldest.id !== expectedOldestId) {
      throw new Error('Drafts changed. Review them before replacing anything.');
    }
    return persist(prepared, existing.filter(item => item.id !== oldest.id), oldest);
  }

  function discard(id) {
    const items = read();
    const remaining = items.filter(item => item.id !== id);
    if (remaining.length === items.length) return false;
    const removed = items.find(item => item.id === id);
    if (!removed?.hasAttachment) {
      write(remaining);
      onChange(id, true);
      return true;
    }
    return Promise.resolve(attachmentStore?.get(id)).then(removedAttachment =>
      Promise.resolve(attachmentStore?.delete(id)).then(async () => {
        try { write(remaining); }
        catch (error) {
          if (removedAttachment) await Promise.resolve(attachmentStore?.put(id, removedAttachment)).catch(() => {});
          throw error;
        }
        onChange(id, true);
        return true;
      })
    );
  }

  function resume(id, confirmedLogin) {
    const item = read().find(candidate => candidate.id === id);
    if (!item) throw new Error('This capture is no longer available.');
    if (!confirmedLogin || String(confirmedLogin).trim() !== item.ownerLogin) {
      throw new Error('Reconnect with the account that saved this capture.');
    }
    const draft = {repository:'', title:item.title, body:item.body, labelIds:[],
      ...(Array.isArray(item.blockers) && item.blockers.length ? {blockers:item.blockers} : {})};
    if (!item.hasAttachment) return draft;
    if (!attachmentStore) throw new Error('The saved screenshot is unavailable. Retry after reloading.');
    return Promise.resolve(attachmentStore.get(id)).then(attachment => {
      if (Array.isArray(attachment?.attachments) && attachment.attachments.length) {
        if (attachment.attachments.length > 5 || attachment.attachments.some(value =>
          !value?.blob || !value?.filename || !value?.contentType)) {
          throw new Error('The saved screenshots are unavailable. Keep this Draft and retry.');
        }
        return {...draft, attachments:attachment.attachments};
      }
      if (!attachment?.blob || !attachment?.filename || !attachment?.contentType) {
        throw new Error('The saved screenshot is unavailable. Keep this Draft and retry.');
      }
      return {...draft, attachment};
    });
  }

  function completeResume(id) { return discard(id); }

  function encodeBytes(buffer) {
    const bytes = new Uint8Array(buffer);
    let binary = '';
    for (let offset = 0; offset < bytes.length; offset += 0x8000) {
      binary += String.fromCharCode(...bytes.subarray(offset, offset + 0x8000));
    }
    return btoa(binary);
  }

  function decodeBytes(value, contentType) {
    const binary = atob(value);
    const bytes = new Uint8Array(binary.length);
    for (let index = 0; index < binary.length; index += 1) bytes[index] = binary.charCodeAt(index);
    return new Blob([bytes], {type:contentType});
  }

  async function exportOwned(login) {
    const owner = String(login || '').trim();
    const exported = [];
    for (const item of read().filter(candidate => candidate.ownerLogin === owner)) {
      let evidence = [];
      if (item.hasAttachment) {
        const stored = await attachmentStore?.get(item.id);
        const attachments = Array.isArray(stored?.attachments) ? stored.attachments :
          (stored?.blob ? [stored] : []);
        if (attachments.length !== Number(item.attachmentCount || 1)) {
          throw new Error('The saved screenshots are unavailable. Keep this Draft and retry.');
        }
        evidence = await Promise.all(attachments.map(async attachment => ({
          filename:attachment.filename,
          content_type:attachment.contentType,
          ...(attachment.note ? {note:attachment.note} : {}),
          data:encodeBytes(await attachment.blob.arrayBuffer()),
        })));
      }
      exported.push({
        id:item.id, title:item.title, body:item.body, saved_at:Number(item.savedAt),
        ...(Array.isArray(item.blockers) && item.blockers.length ? {blockers:item.blockers} : {}),
        ...(evidence.length ? {evidence} : {}),
      });
    }
    return exported;
  }

  async function mergeRemote(drafts, login) {
    const ownerLogin = String(login || '').trim();
    if (!ownerLogin || !Array.isArray(drafts)) return 0;
    const existing = read();
    const known = new Set(existing.map(item => item.id));
    const imported = [];
    for (const remote of drafts) {
      if (!remote || known.has(remote.id) || imported.length + existing.length >= maxItems) continue;
      const evidence = Array.isArray(remote.evidence) ? remote.evidence : [];
      if (evidence.length && !attachmentStore) continue;
      const item = {
        id:String(remote.id), ownerLogin, title:String(remote.title || ''), body:String(remote.body || ''),
        savedAt:Number(remote.saved_at),
        ...(Array.isArray(remote.blockers) && remote.blockers.length ? {
          blockers:remote.blockers, blockerCount:remote.blockers.length,
        } : {}),
        ...(evidence.length ? {hasAttachment:true, attachmentCount:evidence.length} : {}),
      };
      if (!item.id || !item.title.trim() || !Number.isFinite(item.savedAt)) continue;
      if (evidence.length) {
        await attachmentStore.put(item.id, {attachments:evidence.map(entry => ({
          filename:String(entry.filename), contentType:String(entry.content_type),
          blob:decodeBytes(String(entry.data), String(entry.content_type)),
          ...(entry.note ? {note:String(entry.note)} : {}),
        }))});
      }
      known.add(item.id);
      imported.push(item);
    }
    if (imported.length) write(imported.concat(existing));
    return imported.length;
  }

  async function reconcileRemote(drafts, login) {
    const ownerLogin = String(login || '').trim();
    if (!ownerLogin || !Array.isArray(drafts)) return 0;
    const existing = read();
    const retained = existing.filter(item => item.ownerLogin !== ownerLogin);
    const reconciled = [];
    const stagedEvidence = new Map();
    for (const remote of drafts) {
      if (!remote || reconciled.length + retained.length >= maxItems) continue;
      const evidence = Array.isArray(remote.evidence) ? remote.evidence : [];
      if (evidence.length && !attachmentStore) {
        throw new Error('The synchronized screenshots cannot be stored on this device.');
      }
      const item = {
        id:String(remote.id || ''), ownerLogin, title:String(remote.title || ''), body:String(remote.body || ''),
        savedAt:Number(remote.saved_at),
        ...(Array.isArray(remote.blockers) && remote.blockers.length ? {
          blockers:remote.blockers, blockerCount:remote.blockers.length,
        } : {}),
        ...(evidence.length ? {hasAttachment:true, attachmentCount:evidence.length} : {}),
      };
      if (!item.id || !item.title.trim() || !Number.isFinite(item.savedAt)) continue;
      if (evidence.length) {
        stagedEvidence.set(item.id, {attachments:evidence.map(entry => ({
          filename:String(entry.filename), contentType:String(entry.content_type),
          blob:decodeBytes(String(entry.data), String(entry.content_type)),
          ...(entry.note ? {note:String(entry.note)} : {}),
        }))});
      }
      reconciled.push(item);
    }
    const evidenceIds = new Set(reconciled.filter(item => item.hasAttachment).map(item => item.id));
    const affectedIds = new Set(stagedEvidence.keys());
    for (const item of existing) if (item.ownerLogin === ownerLogin && item.hasAttachment) affectedIds.add(item.id);
    const previousEvidence = new Map();
    for (const id of affectedIds) previousEvidence.set(id, await attachmentStore?.get(id));
    try {
      for (const [id, value] of stagedEvidence) await attachmentStore.put(id, value);
      for (const item of existing) {
        if (item.ownerLogin === ownerLogin && item.hasAttachment && !evidenceIds.has(item.id)) {
          await attachmentStore?.delete(item.id);
        }
      }
      write(reconciled.concat(retained));
    } catch (error) {
      for (const [id, value] of previousEvidence) {
        await Promise.resolve(value ? attachmentStore?.put(id, value) : attachmentStore?.delete(id)).catch(() => {});
      }
      throw error;
    }
    return reconciled.length;
  }

  return {list, capacity, save, replaceOldest, discard, resume, completeResume,
    exportOwned, mergeRemote, reconcileRemote, currentLogin:getCurrentLogin,
    subscribe:listener => (listeners.add(listener), () => listeners.delete(listener))};
}

if (typeof module !== 'undefined' && module.exports) module.exports = createUnfiledCaptures;