The most powerful and modular diffusion model GUI, api and backend with a graph/nodes interface. The fastest local inference engine in the world.
fix(assets): harden the asset catalogue's failure paths (#16393)
Simon Pinfold02ba106f9789
diff --git a/alembic_db/versions/0008_drop_asset_meta.py b/alembic_db/versions/0008_drop_asset_meta.pynew file mode 100644index 000000000..1bc0be7ed--- /dev/null+++ b/alembic_db/versions/0008_drop_asset_meta.py@@ -0,0 +1,38 @@+"""+Drop the unused asset_meta table.++Asset metadata lives in the user_metadata and system_metadata JSON columns on+assets; no code path reads or writes asset_meta.++Revision ID: 0008_drop_asset_meta+Revises: 0007_record_content_split+Create Date: 2026-09-22+"""++from alembic import op+import sqlalchemy as sa++revision = "0008_drop_asset_meta"+down_revision = "0007_record_content_split"+branch_labels = None+depends_on = None+++def upgrade() -> None:+ op.execute("DROP TABLE IF EXISTS asset_meta")+++def downgrade() -> None:+ op.create_table(+ "asset_meta",+ sa.Column("asset_id", sa.String(36), sa.ForeignKey("assets.id", ondelete="CASCADE"), primary_key=True),+ sa.Column("key", sa.String(256), primary_key=True),+ sa.Column("ordinal", sa.Integer(), primary_key=True),+ sa.Column("val_str", sa.String(2048)), sa.Column("val_num", sa.Numeric(38, 10)),+ sa.Column("val_bool", sa.Boolean()), sa.Column("val_json", sa.JSON()),+ sa.CheckConstraint("val_str IS NOT NULL OR val_num IS NOT NULL OR val_bool IS NOT NULL OR val_json IS NOT NULL", name="ck_asset_meta_has_value"),+ )+ op.create_index("ix_asset_meta_key", "asset_meta", ["key"])+ op.create_index("ix_asset_meta_key_val_str", "asset_meta", ["key", "val_str"])+ op.create_index("ix_asset_meta_key_val_num", "asset_meta", ["key", "val_num"])+ op.create_index("ix_asset_meta_key_val_bool", "asset_meta", ["key", "val_bool"])diff --git a/app/assets/api/routes.py b/app/assets/api/routes.pyindex f5ed98be5..b6fbfe131 100644--- a/app/assets/api/routes.py+++ b/app/assets/api/routes.py@@ -1126,6 +1126,8 @@ async def mark_missing_assets(request: web.Request) -> web.Response:Returns:200 OK with count of marked assets409 Conflict if a scan is currently running+ 500 Internal Server Error with PRUNE_FAILED if the marking failed, so a+ prune that did not run is never reported as a completed one"""try:marked = asset_seeder.mark_missing_outside_prefixes()@@ -1134,4 +1136,10 @@ async def mark_missing_assets(request: web.Request) -> web.Response:{"status": "scan_running", "marked": 0},status=409,)+ if marked is None:+ return _build_error_response(+ 500,+ "PRUNE_FAILED",+ "Failed to mark missing assets.",+ )return web.json_response({"status": "completed", "marked": marked}, status=200)diff --git a/app/assets/api/upload.py b/app/assets/api/upload.pyindex d46ad6389..f16b2e6aa 100644--- a/app/assets/api/upload.py+++ b/app/assets/api/upload.py@@ -1,9 +1,7 @@"""Reads a multipart upload off the wire and lands its bytes in a temporary filethe ingest service can hash and move. The body is consumed in chunks so a large-model never has to fit in memory, and the temporary file is removed on every-failure path so an abandoned upload leaves nothing behind. Field values are-validated as they arrive, letting a bad request fail before its bytes are-written.+model never has to fit in memory. Validation failures remove any temporary file+before they are reported to the caller."""import logging@@ -65,101 +63,115 @@ async def parse_multipart_upload(file_written = 0tmp_path: str | None = None+ parse_succeeded = False- while True:- field = await reader.next()- if field is None:- break-- fname = getattr(field, "name", "") or ""+ try:+ while True:+ field = await reader.next()+ if field is None:+ break- if fname == "hash":- try:- s = ((await field.text()) or "").strip().lower()- except Exception:- raise UploadError(- 400, "INVALID_HASH", "hash must be like 'blake3:<hex>'"- )+ fname = getattr(field, "name", "") or ""- if s:- provided_hash = normalize_and_validate_hash(s)+ if fname == "hash":try:- provided_hash_exists = check_hash_exists(provided_hash)- except Exception as e:- logging.exception(- "check_hash_exists failed for hash=%s: %s", provided_hash, e+ s = ((await field.text()) or "").strip().lower()+ except Exception:+ raise UploadError(+ 400, "INVALID_HASH", "hash must be like 'blake3:<hex>'"+ )++ if s:+ provided_hash = normalize_and_validate_hash(s)+ try:+ provided_hash_exists = check_hash_exists(provided_hash)+ except Exception as e:+ logging.exception(+ "check_hash_exists failed for hash=%s: %s", provided_hash, e+ )+ raise UploadError(+ 500,+ "HASH_CHECK_FAILED",+ "Backend error while checking asset hash.",+ )++ elif fname == "file":+ if file_present:+ raise UploadError(+ 400,+ "UNSUPPORTED_FIELD",+ "Multiple 'file' parts are not supported.",)+ file_present = True+ file_client_name = (field.filename or "").strip()++ uploads_root = os.path.join(folder_paths.get_temp_directory(), "uploads")+ unique_dir = os.path.join(uploads_root, uuid.uuid4().hex)+ os.makedirs(unique_dir, exist_ok=True)+ tmp_path = os.path.join(unique_dir, ".upload.part")++ try:+ with open(tmp_path, "wb") as f:+ while True:+ chunk = await field.read_chunk(8 * 1024 * 1024)+ if not chunk:+ break+ f.write(chunk)+ file_written += len(chunk)+ except Exception:raise UploadError(- 500,- "HASH_CHECK_FAILED",- "Backend error while checking asset hash.",+ 500, "UPLOAD_IO_ERROR", "Failed to receive and store uploaded file.")- elif fname == "file":- file_present = True- file_client_name = (field.filename or "").strip()-- uploads_root = os.path.join(folder_paths.get_temp_directory(), "uploads")- unique_dir = os.path.join(uploads_root, uuid.uuid4().hex)- os.makedirs(unique_dir, exist_ok=True)- tmp_path = os.path.join(unique_dir, ".upload.part")-- try:- with open(tmp_path, "wb") as f:- while True:- chunk = await field.read_chunk(8 * 1024 * 1024)- if not chunk:- break- f.write(chunk)- file_written += len(chunk)- except Exception:- delete_temp_file_if_exists(tmp_path)+ elif fname == "tags":+ tags_raw.append((await field.text()) or "")+ elif fname == "name":+ provided_name = (await field.text()) or None+ elif fname == "user_metadata":+ user_metadata_raw = (await field.text()) or None+ elif fname == "id":raise UploadError(- 500, "UPLOAD_IO_ERROR", "Failed to receive and store uploaded file."+ 400,+ "UNSUPPORTED_FIELD",+ "Client-provided 'id' is not supported. Asset IDs are assigned by the server.",)+ elif fname == "mime_type":+ provided_mime_type = ((await field.text()) or "").strip() or None+ elif fname == "preview_id":+ provided_preview_id = ((await field.text()) or "").strip() or None- elif fname == "tags":- tags_raw.append((await field.text()) or "")- elif fname == "name":- provided_name = (await field.text()) or None- elif fname == "user_metadata":- user_metadata_raw = (await field.text()) or None- elif fname == "id":+ if not file_present and not (provided_hash and provided_hash_exists):raise UploadError(400,- "UNSUPPORTED_FIELD",- "Client-provided 'id' is not supported. Asset IDs are assigned by the server.",+ "MISSING_FILE",+ "Form must include a 'file' part or a known 'hash'.",)- elif fname == "mime_type":- provided_mime_type = ((await field.text()) or "").strip() or None- elif fname == "preview_id":- provided_preview_id = ((await field.text()) or "").strip() or None- if not file_present and not (provided_hash and provided_hash_exists):- raise UploadError(- 400, "MISSING_FILE", "Form must include a 'file' part or a known 'hash'."- )- if (- file_present- and file_written == 0- and not (provided_hash and provided_hash_exists)- ):- delete_temp_file_if_exists(tmp_path)- raise UploadError(400, "EMPTY_UPLOAD", "Uploaded file is empty.")-- return ParsedUpload(- file_present=file_present,- file_written=file_written,- file_client_name=file_client_name,- tmp_path=tmp_path,- tags_raw=tags_raw,- provided_name=provided_name,- user_metadata_raw=user_metadata_raw,- provided_hash=provided_hash,- provided_hash_exists=provided_hash_exists,- provided_mime_type=provided_mime_type,- provided_preview_id=provided_preview_id,- )+ if (+ file_present+ and file_written == 0+ and not (provided_hash and provided_hash_exists)+ ):+ raise UploadError(400, "EMPTY_UPLOAD", "Uploaded file is empty.")++ parsed = ParsedUpload(+ file_present=file_present,+ file_written=file_written,+ file_client_name=file_client_name,+ tmp_path=tmp_path,+ tags_raw=tags_raw,+ provided_name=provided_name,+ user_metadata_raw=user_metadata_raw,+ provided_hash=provided_hash,+ provided_hash_exists=provided_hash_exists,+ provided_mime_type=provided_mime_type,+ provided_preview_id=provided_preview_id,+ )+ parse_succeeded = True+ return parsed+ finally:+ if not parse_succeeded:+ delete_temp_file_if_exists(tmp_path)def delete_temp_file_if_exists(tmp_path: str | None) -> None:diff --git a/app/assets/database/models.py b/app/assets/database/models.pyindex bb0b8c355..2c261ed04 100644--- a/app/assets/database/models.py+++ b/app/assets/database/models.py@@ -1,5 +1,5 @@"""Declares the asset schema: content rows describing bytes on disk, records-describing what a user sees, and the tag and metadata tables hanging off them.+describing what a user sees, and the asset_tags table hanging off them.The split is the point — many records can name one content row, and retiringcontent by marking it missing rather than deleting it is what keeps a path'shistory intact. Constraints declared here, not application code, are what make@@ -10,7 +10,6 @@ from __future__ import annotationsimport uuidfrom datetime import datetime-from decimal import Decimalfrom typing import Anyfrom sqlalchemy import (@@ -21,8 +20,6 @@ from sqlalchemy import (DateTime,ForeignKey,Index,- Integer,- Numeric,String,Text,text,@@ -103,9 +100,6 @@ class Asset(Base):preview: Mapped[Asset | None] = relationship("Asset", foreign_keys=[preview_id], remote_side=lambda: [Asset.id])- metadata_entries: Mapped[list[AssetMeta]] = relationship(- back_populates="asset", cascade="all,delete-orphan", passive_deletes=True- )tag_links: Mapped[list[AssetTag]] = relationship(back_populates="asset", cascade="all,delete-orphan", passive_deletes=True)@@ -121,33 +115,6 @@ class Asset(Base):)-class AssetMeta(Base):- __tablename__ = "asset_meta"-- asset_id: Mapped[str] = mapped_column(- String(36), ForeignKey("assets.id", ondelete="CASCADE"), primary_key=True- )- key: Mapped[str] = mapped_column(String(256), primary_key=True)- ordinal: Mapped[int] = mapped_column(Integer, primary_key=True, default=0)- val_str: Mapped[str | None] = mapped_column(String(2048))- val_num: Mapped[Decimal | None] = mapped_column(Numeric(38, 10))- val_bool: Mapped[bool | None] = mapped_column(Boolean)- val_json: Mapped[Any | None] = mapped_column(JSON)-- asset: Mapped[Asset] = relationship(back_populates="metadata_entries")-- __table_args__ = (- Index("ix_asset_meta_key", "key"),- Index("ix_asset_meta_key_val_str", "key", "val_str"),- Index("ix_asset_meta_key_val_num", "key", "val_num"),- Index("ix_asset_meta_key_val_bool", "key", "val_bool"),- CheckConstraint(- "val_str IS NOT NULL OR val_num IS NOT NULL OR val_bool IS NOT NULL OR val_json IS NOT NULL",- name="ck_asset_meta_has_value",- ),- )--class AssetTag(Base):__tablename__ = "asset_tags"diff --git a/app/assets/database/queries/__init__.py b/app/assets/database/queries/__init__.pyindex 8707c229b..14dff90a8 100644--- a/app/assets/database/queries/__init__.py+++ b/app/assets/database/queries/__init__.py@@ -13,6 +13,7 @@ from app.assets.database.queries.records import (delete_record,fetch_record_tags,get_record_by_id,+ is_live_path_conflict,list_records_page,mark_content_missing,rename_record,@@ -27,6 +28,7 @@ __all__ = ["delete_record","fetch_record_tags","get_record_by_id",+ "is_live_path_conflict","list_records_page","mark_content_missing","rename_record",diff --git a/app/assets/database/queries/records.py b/app/assets/database/queries/records.pyindex 5a20b6bab..60b7f8231 100644--- a/app/assets/database/queries/records.py+++ b/app/assets/database/queries/records.py@@ -1,5 +1,5 @@-"""Owns every write to content rows, records and their tag links, plus the paged-reads that list them. Inserts that can lose a race — a content row at a path, a+"""Provides shared writes for content rows, records and tag links, plus the paged+reads that list records. Inserts that can lose a race — a content row at a path, atag, a tag link — run inside a savepoint and re-read the conflicting row, so aconcurrent writer settles the call instead of raising, while a genuineconstraint failure still surfaces. This is the sole writer of a content row's@@ -47,7 +47,7 @@ class RecordPageSpec(NamedTuple):_LIVE_PATH_UNIQUE_INDEX = "uq_asset_contents_path_live"-def _is_live_path_conflict(error: IntegrityError) -> bool:+def is_live_path_conflict(error: IntegrityError) -> bool:orig = error.origmessage = str(orig)postgres_names_the_index = getattr(getattr(orig, "diag", None), "constraint_name", None) == _LIVE_PATH_UNIQUE_INDEX@@ -66,7 +66,7 @@ def create_content_reporting_insert(session: Session, path: str, hash: str | Nonsession.flush()return content, Trueexcept IntegrityError as error:- if not _is_live_path_conflict(error):+ if not is_live_path_conflict(error):raisewinner = session.execute(sa.select(AssetContent).where(AssetContent.path == path, AssetContent.is_missing.is_(False))).scalar_one()return winner, False@@ -299,8 +299,9 @@ def rename_record(session: Session, id: str, name: str) -> Asset:record = session.get(Asset, id)if record is None:raise LookupError(id)- record.name = name- record.updated_at = get_utc_now()+ if record.name != name:+ record.name = name+ record.updated_at = get_utc_now()session.flush()return recorddiff --git a/app/assets/database/queries/tags.py b/app/assets/database/queries/tags.pyindex 177cc980d..8c9a95654 100644--- a/app/assets/database/queries/tags.py+++ b/app/assets/database/queries/tags.py@@ -1,7 +1,7 @@"""Answers questions about tag usage: which tags exist with how many assets, and-how those counts narrow once a filter is applied. Both queries reuse the record-listing's own joins and filter clauses, so the counts a client sees always-describe the same assets the listing endpoint would return for that filter,+how those counts narrow once a filter is applied. The unfiltered query counts+all catalogued records. The filtered query reuses the record listing's joins and+filter clauses, so its counts describe the assets the listing endpoint returns,records with missing content included."""diff --git a/app/assets/event_log.py b/app/assets/event_log.pyindex e8962a3ad..c6ef2796f 100644--- a/app/assets/event_log.py+++ b/app/assets/event_log.py@@ -8,9 +8,9 @@ without parsing prose, and the existing human-readable lines stay exactly asthey are.The field vocabulary is closed. Only the names in :data:`ALLOWED_FIELDS` may be-carried, each has a validator, and no string value may contain a path separator-or logfmt delimiter — so file names, paths, asset ids and content hashes cannot-ride along.+carried, each has a validator, and no string value may contain a path separator,+logfmt delimiter or line break — so file names, paths, asset ids and content+hashes cannot ride along."""import logging@@ -22,7 +22,7 @@ from typing import AnyTAG = "[assets-event]"MAX_STRING_LENGTH = 64-FORBIDDEN_STRING_CHARS = ("/", "\\", ":", " ", "=", '"')+FORBIDDEN_STRING_CHARS = ("/", "\\", ":", " ", "=", '"', "\n", "\r")ROOTS = frozenset({"models", "input", "output", "user", "temp"})PHASES = frozenset({"fast", "enrich", "full"})@@ -43,6 +43,10 @@ ALLOWED_EVENTS = frozenset({"scanner.temp_sync_failed","scanner.mark_missing_failed","scanner.stat_failed",+ "scanner.invalid_mtime",+ "scanner.watch_stat_failed",+ "scanner.watch_spec_failed",+ "scanner.watch_seed_failed",})diff --git a/app/assets/lifecycle.py b/app/assets/lifecycle.pyindex 26ecd0370..2a2f240b4 100644--- a/app/assets/lifecycle.py+++ b/app/assets/lifecycle.py@@ -2,8 +2,7 @@and files, recording a hash-mode transition, and handing the filesystem scan tothe background seeder. Startup only enqueues transition work — draining itbelongs to the seeder, so a large library cannot stall the server before it-accepts requests. It also settles, before any of that, whether the database-dependencies exist at all, disabling the asset routes when they do not.+accepts requests."""from __future__ import annotationsdiff --git a/app/assets/manager.py b/app/assets/manager.pyindex 590015d6a..73e20bc32 100644--- a/app/assets/manager.py+++ b/app/assets/manager.py@@ -1,3 +1,9 @@+"""Selects and implements the enabled and disabled asset managers.++``default_asset_manager`` checks database dependencies before enabling assets+and chooses ``NoAssets`` when the requested mode cannot run.+"""+import loggingfrom typing import Any, Callable, Protocoldiff --git a/app/assets/scanner.py b/app/assets/scanner.pyindex 9e0f1f32e..7fa7b7f41 100644--- a/app/assets/scanner.py+++ b/app/assets/scanner.py@@ -2,9 +2,10 @@paths, building specs, seeding new content and records, then enriching themwith metadata and hashes. Each spec is seeded inside its own savepoint, so onefile whose row conflicts cannot discard the work done for the files around it.-Enrichment counts as progress only when it produced what was asked of it — a-requested hash that could not be computed is no progress, which is what bounds-a pass over a file the server cannot read.+Enrichment candidates use ordered ID pagination, so each row is attempted at+most once per pass while failed rows remain eligible for the next pass. A pause+can end a batch early, and the cursor holds at the last row the batch attempted,+so the rows it never reached are selected again when the scan resumes."""import logging@@ -21,6 +22,7 @@ from app.assets import modefrom app.assets.event_log import emit, error_typefrom app.assets.database.queries import (create_content_reporting_insert,+ is_live_path_conflict,mark_content_missing,create_record,)@@ -52,7 +54,6 @@ from app.assets.services.path_utils import (get_comfy_models_folders,get_name_and_tags_from_asset_path,)-from app.assets.services.ingest import _discard_unreferenced_contentfrom app.assets.services.snapshot_hash import snapshot_hashfrom app.database.db import create_session, create_write_session@@ -277,10 +278,11 @@ def sync_temp_references_safely()-def mark_missing_outside_prefixes_safely(prefixes: list[str]) -> int:+def mark_missing_outside_prefixes_safely(prefixes: list[str]) -> int | None:"""Mark references as missing when outside the given prefixes.- This is a non-destructive soft-delete. Returns count marked or 0 on failure.+ This is a non-destructive soft-delete. Returns the count marked, or None when+ the operation fails."""try:with create_session() as sess:@@ -293,7 +295,7 @@ def mark_missing_outside_prefixes_safely(prefixes: list[str]) -> int:"scanner.mark_missing_failed",error_type=error_type(exc),)- return 0+ return Nonedef mark_contents_missing_outside_prefixes(@@ -438,77 +440,137 @@ def seed_asset_specs(session: Session,specs: list[SeedAssetSpec],observed: dict[str, _SpecObservation | None] | None = None,-) -> int:+) -> tuple[int, Exception | None]:if observed is None:observed = observe_asset_specs(specs)created = 0- created_content_ids: list[str] = []- try:- for spec in specs:- path = os.path.abspath(spec["abs_path"])- try:- with session.begin_nested():- observation = observed[path]- if observation is None: # observe_asset_specs already logged why- continue- stat_result = observation.stat_result- recovery = recover_missing_content(- session,- path,- observation.snapshot,- hashing_is_enabled=mode.hashing_enabled(),- )- if recovery != "no_match":- continue- content, inserted = create_content_reporting_insert(- session,- path=path,- hash=None,- size_bytes=stat_result.st_size,- mtime_ns=get_mtime_ns(stat_result),- )- if inserted:- created_content_ids.append(content.id)- existing_record = session.scalar(- sa.select(Asset.id).where(Asset.content_id == content.id).limit(1)- )- if existing_record is not None:- continue- create_record(- session,- content_id=content.id,- name=spec["info_name"],- mime_type=spec["mime_type"],- job_id=spec["job_id"],- loader_path=spec["fname"],- tags=spec["tags"],+ first_error: Exception | None = None+ # Counted, not gated through _ScanProgress.mark_emitted like its neighbours, because this+ # function takes no progress object. Ungated, a restored archive of pre-epoch mtimes puts+ # one event per file into the closed-vocabulary stream.+ invalid_mtimes = 0+ for spec in specs:+ path = os.path.abspath(spec["abs_path"])+ try:+ with session.begin_nested():+ observation = observed[path]+ if observation is None: # observe_asset_specs already logged why+ continue+ stat_result = observation.stat_result+ if get_mtime_ns(stat_result) < 0:+ logging.warning(+ "Skipping asset with invalid mtime during scan: %s", path)- created += 1- except IntegrityError:- logging.warning("Skipping asset whose row conflicts during scan: %s", path)+ invalid_mtimes += 1+ continue+ recovery = recover_missing_content(+ session,+ path,+ observation.snapshot,+ hashing_is_enabled=mode.hashing_enabled(),+ )+ if recovery != "no_match":+ continue+ content, _inserted = create_content_reporting_insert(+ session,+ path=path,+ hash=None,+ size_bytes=stat_result.st_size,+ mtime_ns=get_mtime_ns(stat_result),+ )+ existing_record = session.scalar(+ sa.select(Asset.id).where(Asset.content_id == content.id).limit(1)+ )+ if existing_record is not None:+ continue+ create_record(+ session,+ content_id=content.id,+ name=spec["info_name"],+ mime_type=spec["mime_type"],+ job_id=spec["job_id"],+ loader_path=spec["fname"],+ tags=spec["tags"],+ )+ created += 1+ except IntegrityError as error:+ if is_live_path_conflict(error):+ logging.warning(+ "Skipping asset whose row conflicts during scan: %s", path+ )continue- except Exception:- session.rollback()- for content_id in created_content_ids:- _discard_unreferenced_content(session, content_id)- raise- return created---def insert_asset_specs(specs: list[SeedAssetSpec], _tag_pool: set[str]) -> int:+ if first_error is None:+ first_error = error+ except MemoryError:+ # Deferring this one would keep allocating for every remaining spec+ # while the process is already out of memory.+ raise+ except Exception as error:+ if first_error is None:+ first_error = error+ if invalid_mtimes:+ emit("scanner.invalid_mtime", count=invalid_mtimes)+ return created, first_error+++def insert_asset_specs(+ specs: list[SeedAssetSpec], _tag_pool: set[str]+) -> tuple[int, Exception | None]:if not specs:- return 0+ return 0, Noneobserved = observe_asset_specs(specs)- with create_write_session() as session:- created = seed_asset_specs(session, specs, observed)- session.commit()- return created+ with create_write_session() as sess:+ created, first_error = seed_asset_specs(sess, specs, observed)+ try:+ sess.commit()+ except Exception:+ if first_error is None:+ raise+ logging.exception("Failed to commit successful specs from failed asset batch")+ try:+ sess.rollback()+ except Exception:+ logging.exception("Failed to roll back asset batch after commit failure")+ return 0, first_error+ return created, first_error+++def build_unenriched_candidates_statement(+ prefixes: list[str],+ compute_hashes: bool,+ last_seen_id: str | None,+ limit: int = 1000,+) -> sa.Select[tuple[str, str, str]]:+ query = (+ sa.select(AssetContent.id, Asset.id, AssetContent.path)+ .join(Asset, Asset.content_id == AssetContent.id)+ .where(AssetContent.is_missing.is_(False))+ )+ if compute_hashes:+ query = query.where(+ sa.or_(+ AssetContent.hash.is_(None),+ Asset.system_metadata.is_(None),+ )+ )+ else:+ query = query.where(Asset.system_metadata.is_(None))+ if last_seen_id is not None:+ query = query.where(Asset.id > last_seen_id)+ return (+ query.where(+ sa.or_(*(sql_path_under_prefix(AssetContent.path, p) for p in prefixes))+ )+ .order_by(Asset.id.asc())+ .limit(limit)+ )def get_unenriched_assets_for_roots(roots: tuple[RootType, ...],compute_hashes: bool,limit: int = 1000,+ last_seen_id: str | None = None,) -> list[UnenrichedContent]:prefixes: list[str] = []for root in roots:@@ -517,27 +579,14 @@ def get_unenriched_assets_for_roots(if not prefixes:return []+ query = build_unenriched_candidates_statement(+ prefixes,+ compute_hashes,+ last_seen_id,+ limit,+ )with create_session() as sess:- query = (- sa.select(AssetContent.id, Asset.id, AssetContent.path)- .join(Asset, Asset.content_id == AssetContent.id)- .where(AssetContent.is_missing.is_(False))- )- if compute_hashes:- query = query.where(- sa.or_(- AssetContent.hash.is_(None),- Asset.system_metadata.is_(None),- )- )- else:- query = query.where(Asset.system_metadata.is_(None))- query = query.where(- sa.or_(- *(sql_path_under_prefix(AssetContent.path, p) for p in prefixes)- )- )- rows = sess.execute(query.order_by(Asset.id).limit(limit)).all()+ rows = sess.execute(query).all()return [UnenrichedContent(content_id, record_id, file_path)@@ -623,7 +672,7 @@ def enrich_asset(if isinstance(exc, OSError):_log_scan_error("hashing", exc)else:- logging.warning("Failed to hash %s: %s", file_path, exc)+ logging.warning("Failed to hash %s: %s", file_path, exc, exc_info=True)record = session.get(Asset, record_id)if content is None or record is None or content.mtime_ns != initial_mtime_ns:@@ -674,7 +723,7 @@ def enrich_assets_batch(compute_hash: bool = False,interrupt_check: Callable[[], bool] | None = None,progress: _ScanProgress | None = None,-) -> tuple[int, list[str]]:+) -> tuple[int, list[str], int]:"""Enrich a batch of assets.Uses a single DB session for the entire batch, committing after each@@ -689,15 +738,17 @@ def enrich_assets_batch(the operation should be interrupted (e.g. paused or cancelled)Returns:- Tuple of (enriched_count, failed_reference_ids)+ Tuple of (enriched_count, failed_reference_ids, consumed_count)"""enriched = 0failed_ids: list[str] = []+ consumed = 0with create_session() as sess:for row in rows:if interrupt_check is not None and interrupt_check():break+ consumed += 1try:updated = enrich_asset(@@ -722,4 +773,4 @@ def enrich_assets_batch(sess.rollback()failed_ids.append(row.record_id)- return enriched, failed_ids+ return enriched, failed_ids, consumeddiff --git a/app/assets/scanner_admission.py b/app/assets/scanner_admission.pyindex 68fda54f3..0fa50ece0 100644--- a/app/assets/scanner_admission.py+++ b/app/assets/scanner_admission.py@@ -8,12 +8,14 @@ still downloading out of the catalog.from __future__ import annotations+import loggingimport mimetypesimport osimport timefrom dataclasses import dataclassfrom typing import Final+from app.assets.event_log import emit, error_typefrom app.assets.services.path_utils import compute_loader_path, get_name_and_tags_from_asset_pathPARTIAL_DOWNLOAD_EXTENSIONS = frozenset({@@ -69,29 +71,49 @@ def tick_watch_list() -> None:remaining: list[_WatchEntry] = []settled: list[SeedAssetSpec] = []- for entry in _WATCH_LIST:- try:- current = os.stat(entry.path)- except FileNotFoundError:- continue- if (current.st_mtime_ns, current.st_size) == (entry.last_stat.st_mtime_ns, entry.last_stat.st_size):- name, tags = get_name_and_tags_from_asset_path(entry.path)- spec: SeedAssetSpec = {- "abs_path": entry.path,- "size_bytes": current.st_size,- "mtime_ns": current.st_mtime_ns,- "info_name": name,- "tags": tags,- "fname": compute_loader_path(entry.path),- "metadata": None,- "mime_type": mimetypes.guess_type(entry.path, strict=False)[0],- "job_id": None,- }- settled.append(spec)- continue- entry.last_stat = current- entry.ticks += 1- if entry.ticks < _WATCH_SCAN_RETRIES:- remaining.append(entry)- insert_asset_specs(settled, set())- _WATCH_LIST[:] = remaining+ unvisited = iter(list(_WATCH_LIST))+ try:+ for entry in unvisited:+ try:+ current = os.stat(entry.path)+ except OSError as exc:+ logging.warning("Dropping watched asset after stat failed: %s", entry.path)+ emit("scanner.watch_stat_failed", error_type=error_type(exc))+ continue+ if (current.st_mtime_ns, current.st_size) == (entry.last_stat.st_mtime_ns, entry.last_stat.st_size):+ try:+ name, tags = get_name_and_tags_from_asset_path(entry.path)+ spec: SeedAssetSpec = {+ "abs_path": entry.path,+ "size_bytes": current.st_size,+ "mtime_ns": current.st_mtime_ns,+ "info_name": name,+ "tags": tags,+ "fname": compute_loader_path(entry.path),+ "metadata": None,+ "mime_type": mimetypes.guess_type(entry.path, strict=False)[0],+ "job_id": None,+ }+ except Exception as exc:+ logging.warning(+ "Dropping watched asset after spec construction failed: %s", entry.path+ )+ emit("scanner.watch_spec_failed", error_type=error_type(exc))+ continue+ settled.append(spec)+ continue+ entry.last_stat = current+ entry.ticks += 1+ if entry.ticks < _WATCH_SCAN_RETRIES:+ remaining.append(entry)+ _created, seed_error = insert_asset_specs(settled, set())+ if seed_error is not None:+ # The batch reports only its first error, so failed entries can't be named here;+ # like any settled entry, they leave the watch list either way.+ logging.warning("Seeding settled watched assets failed for at least one entry")+ emit("scanner.watch_seed_failed", error_type=error_type(seed_error))+ finally:+ # Skipping this write wedges the list: drained entries stay on it and are re-attempted+ # every tick, while entries past the fault never reach the increment _WATCH_SCAN_RETRIES+ # needs to retire them. Draining the iterator keeps entries the loop never reached.+ _WATCH_LIST[:] = remaining + list(unvisited)diff --git a/app/assets/seeder.py b/app/assets/seeder.pyindex c66ea7502..8e6e8ed18 100644--- a/app/assets/seeder.py+++ b/app/assets/seeder.py@@ -2,15 +2,15 @@exposing pause, resume, cancel and progress to the API. A run seedsnewly-observed files first, then enriches records in batches, and settles anypending hash-mode transition at the start of the enrich phase so a server that-receives no prompts still completes the switch. A pass stops once batches stop-making progress, bounding a scan over files that cannot be read.+receives no prompts still completes the switch. An enrichment pass ends when+its ordered candidate cursor is exhausted."""import loggingimport osimport threadingimport time-from dataclasses import dataclass, field+from dataclasses import dataclass, field, replacefrom enum import Enumfrom typing import Any, Callable, TypedDict@@ -410,7 +410,9 @@ class _AssetSeeder:progress = (_snapshot_progress(self._scan_state)if self._scan_state is not None- else self._last_progress+ else replace(self._last_progress)+ if self._last_progress is not None+ else None)return ScanStatus(state=self._state,@@ -439,7 +441,7 @@ class _AssetSeeder:self._thread = Nonereturn joined- def mark_missing_outside_prefixes(self) -> int:+ def mark_missing_outside_prefixes(self) -> int | None:"""Mark references as missing when outside all known root prefixes.This is a non-destructive soft-delete operation. Assets and their@@ -453,7 +455,10 @@ class _AssetSeeder:a full scan of all roots or during maintenance.Returns:- Number of references marked as missing+ Number of references marked as missing, or None when the marking+ itself failed. Zero and None are deliberately distinct: zero means+ nothing was outside the known prefixes, None means the answer is+ unknown, so callers must not report a failed prune as a clean one.Raises:ScanInProgressError: If a scan is currently running@@ -474,6 +479,8 @@ class _AssetSeeder:all_prefixes = get_owned_prefixes()marked = mark_missing_outside_prefixes_safely(all_prefixes)+ if marked is None:+ return Noneemit("seeder.marked_missing",count=marked,@@ -624,13 +631,21 @@ class _AssetSeeder:if self._prune_first:all_prefixes = get_owned_prefixes()marked = mark_missing_outside_prefixes_safely(all_prefixes)- emit(- "seeder.marked_missing",- count=marked,- stage=_ScanStage.PRUNING.value,- )- if marked > 0:- logging.info("Marked %d refs as missing before scan", marked)+ marked_count = 0 if marked is None else marked+ if marked is None:+ self._add_error(+ "Marking missing assets failed; scan continued without pruning"+ )+ else:+ emit(+ "seeder.marked_missing",+ count=marked_count,+ stage=_ScanStage.PRUNING.value,+ )+ if marked_count > 0:+ logging.info(+ "Marked %d refs as missing before scan", marked_count+ )sync_temp_references_safely(scan_state)if self._check_pause_and_cancel(_ScanStage.PRUNING):@@ -848,12 +863,26 @@ class _AssetSeeder:batch = specs[i : i + batch_size]batch_tags = {t for spec in batch for t in spec["tags"]}+ created = 0try:- created = insert_asset_specs(batch, batch_tags)+ created, batch_error = insert_asset_specs(batch, batch_tags)total_created += created+ if batch_error is not None:+ raise batch_error+ except MemoryError:+ # Recording this as a batch failure would march the scan through+ # every remaining batch while the process is out of memory.+ raiseexcept Exception as e:- self._add_error(f"Batch insert failed at offset {i}: {e}")- logging.exception("Batch insert failed at offset %d", i)+ self._add_error(+ f"Batch insert encountered an error at offset {i} "+ f"after creating {created}: {e}"+ )+ logging.exception(+ "Batch insert encountered an error at offset %d after creating %d",+ i,+ created,+ )emit("seeder.batch_insert_failed", error_type=error_type(e))scanned = i + len(batch)@@ -909,9 +938,7 @@ class _AssetSeeder:{"roots": list(roots), "phase": "enrich"},)- skip_ids: set[str] = set()- consecutive_empty = 0- max_consecutive_empty = 3+ last_seen_id: str | None = Nonewhile True:if self._check_pause_and_cancel(_ScanStage.ENRICH):@@ -923,16 +950,13 @@ class _AssetSeeder:roots,compute_hashes=self._compute_hashes,limit=batch_size,+ last_seen_id=last_seen_id,)- # Filter out previously failed references- if skip_ids:- unenriched = [row for row in unenriched if row.record_id not in skip_ids]-if not unenriched:break- enriched, failed_ids = enrich_assets_batch(+ enriched, _failed_ids, consumed = enrich_assets_batch(unenriched,extract_metadata=True,compute_hash=self._compute_hashes,@@ -940,19 +964,8 @@ class _AssetSeeder:progress=scan_state,)total_enriched += enriched- skip_ids.update(failed_ids)-- if enriched == 0:- consecutive_empty += 1- if consecutive_empty >= max_consecutive_empty:- logging.warning(- "Enrich phase stopping: %d consecutive batches with no progress (%d skipped)",- consecutive_empty,- len(skip_ids),- )- break- else:- consecutive_empty = 0+ if consumed > 0:+ last_seen_id = unenriched[consumed - 1].record_idnow = time.perf_counter()if now - last_progress_time >= progress_interval:diff --git a/app/assets/services/asset_management.py b/app/assets/services/asset_management.pyindex 0f7ad716c..25be23906 100644--- a/app/assets/services/asset_management.py+++ b/app/assets/services/asset_management.py@@ -1,8 +1,7 @@"""Serves the per-asset operations behind the API: reading an asset's detail,updating its name, tags, metadata and preview, deleting a record, and resolving-a hash to a servable path. An update moves ``updated_at`` only when it actually-changed something, so a call that requests what is already true is not recorded-as a user edit.+a hash to a servable path. Name and tag updates move ``updated_at`` only when+the requested values differ. Other supplied metadata fields record a write."""import mimetypesdiff --git a/app/assets/services/ingest.py b/app/assets/services/ingest.pyindex 8813573a4..52bcde4c0 100644--- a/app/assets/services/ingest.py+++ b/app/assets/services/ingest.py@@ -131,10 +131,11 @@ _UPLOAD_HASH_ATTEMPTS = 3def _remove_temp_path(temp_path: str | None) -> None:- if not temp_path or not os.path.exists(temp_path):+ if not temp_path:returnwith contextlib.suppress(OSError):- os.remove(temp_path)+ if os.path.exists(temp_path):+ os.remove(temp_path)parent = os.path.dirname(temp_path)with contextlib.suppress(OSError):if parent and os.path.isdir(parent):@@ -480,11 +481,14 @@ def upload_from_temp_path(_remove_temp_path(temp_path)raise ValueError("tags are required for new asset uploads")- dest_abs = _hash_mode_dest_path(tags, digest, client_filename, name)- content_type = _guess_upload_mime_type(- mime_type, client_filename, name, os.path.basename(dest_abs)- )- _move_temp_to_dest(temp_path, dest_abs)+ try:+ dest_abs = _hash_mode_dest_path(tags, digest, client_filename, name)+ content_type = _guess_upload_mime_type(+ mime_type, client_filename, name, os.path.basename(dest_abs)+ )+ _move_temp_to_dest(temp_path, dest_abs)+ finally:+ _remove_temp_path(temp_path)size_bytes, mtime_ns = verified_stat.st_size, verified_stat.st_mtime_nssystem_metadata = _extract_system_metadata_sync(dest_abs, content_type)with create_session() as session:diff --git a/app/assets/services/snapshot_hash.py b/app/assets/services/snapshot_hash.pyindex d3e9b8c71..051f4e181 100644--- a/app/assets/services/snapshot_hash.py+++ b/app/assets/services/snapshot_hash.py@@ -11,7 +11,13 @@ from __future__ import annotationsimport osfrom dataclasses import dataclass-from blake3 import blake3+try:+ from blake3 import blake3+except ImportError as error:+ blake3 = None+ _BLAKE3_IMPORT_ERROR: ImportError | None = error+else:+ _BLAKE3_IMPORT_ERROR = None@dataclass(frozen=True, slots=True)@@ -34,6 +40,11 @@ def _snapshot(stat_result: os.stat_result) -> _Snapshot:def snapshot_hash(path: str, chunk_size: int = 8 * 1024 * 1024) -> tuple[str, os.stat_result] | None:+ if blake3 is None:+ raise ModuleNotFoundError(+ f"blake3 is required for asset hashing but could not be imported: "+ f"{_BLAKE3_IMPORT_ERROR}"+ ) from _BLAKE3_IMPORT_ERRORtry:pre_stat = _snapshot(os.stat(path))hasher = blake3()diff --git a/app/database/db.py b/app/database/db.pyindex 96d5ee7c2..f0ee2255a 100644--- a/app/database/db.py+++ b/app/database/db.py@@ -133,8 +133,6 @@ def prepare_file_db_path(db_path):if db_dir:os.makedirs(db_dir, exist_ok=True)- copy_legacy_default_db(db_path)-_BACKUP_TIMEOUT_SECONDS = 5.0_SQLITE_BUSY, _SQLITE_LOCKED = 5, 6 # sqlite3 only exports these names from Python 3.11@@ -222,14 +220,14 @@ def _init_file_db(db_url):"""Initialize a file-backed SQLite database using Alembic migrations."""db_path = get_db_path()prepare_file_db_path(db_path)- db_exists = os.path.exists(db_path)- # Lock BEFORE any migration work — deliberately diverging from upstream master, whose- # "it would block Alembic" rationale is false (the lock guards a separate `<db>.lock`- # file). Only this order makes revision inspection, backup, upgrade and the failure-path- # restore mutually exclusive between processes.+ # Lock before legacy import, migration inspection, backup, upgrade, and failure recovery.+ # The separate `<db>.lock` file does not block Alembic; this ordering keeps the sequence+ # process-exclusive._acquire_file_lock(db_path)try:+ copy_legacy_default_db(db_path)+ db_exists = os.path.exists(db_path)_migrate_and_bind(db_url, db_path, db_exists)except Exception:_db_lock.release()@@ -322,7 +320,9 @@ def _migrate_and_bind(db_url, db_path, db_exists):f"The asset catalog was rebuilt from scratch by migration "f"{_DESTRUCTIVE_REVISION}: manual tags, user metadata, previews, renames, "f"API-created records and job_id links from the previous database were "- f"discarded. The database from before the upgrade was kept at {backup_path}."+ f"discarded. Record deletions were also discarded, so files still on disk "+ f"will be catalogued again. The database from before the upgrade was kept "+ f"at {backup_path}.")conn.close()diff --git a/comfy_api/feature_flags.py b/comfy_api/feature_flags.pyindex 00f6bb65f..d12855fb9 100644--- a/comfy_api/feature_flags.py+++ b/comfy_api/feature_flags.py@@ -109,11 +109,11 @@ _CORE_FEATURE_FLAGS: dict[str, Any] = {"max_upload_size": args.max_upload_size * 1024 * 1024, # Convert MB to bytes"extension": {"manager": {"supports_v4": True}},"node_replacements": True,- # Mirrors the constructed AssetManager; no degradation path exists, so this always agrees with it.+ # main.py replaces this at startup with the selected AssetManager's state, which is off without database dependencies."assets": args.enable_assets,}-# CLI-provided flags cannot overwrite core flags+# CLI-provided flags cannot overwrite core flags. Startup code may: main.py sets "assets"._cli_flags = {k: v for k, v in _parse_cli_feature_flags().items() if k not in _CORE_FEATURE_FLAGS}SERVER_FEATURE_FLAGS: dict[str, Any] = {**_CORE_FEATURE_FLAGS, **_cli_flags}diff --git a/main.py b/main.pyindex 3c6e41d35..af82e3103 100644--- a/main.py+++ b/main.py@@ -340,73 +340,86 @@ def prompt_worker(q, server_instance, asset_manager):last_gc_collect = 0need_gc = Falsegc_collect_interval = 10.0+ background_scan_paused = Falsewhile True:- timeout = 1000.0- if need_gc:- timeout = max(gc_collect_interval - (current_time - last_gc_collect), 0.0)-- queue_item = q.get(timeout=timeout)- if queue_item is not None:- item, item_id = queue_item- execution_start_time = time.perf_counter()- prompt_id = item[1]- server_instance.last_prompt_id = prompt_id-- sensitive = item[5]- extra_data = item[3].copy()- for k in sensitive:- extra_data[k] = sensitive[k]-- asset_manager.pause_background_scan()- e.execute(item[2], prompt_id, extra_data, item[4])-- need_gc = True-- remove_sensitive = lambda prompt: prompt[:5] + prompt[6:]- q.task_done(item_id,- e.history_result,- status=execution.PromptQueue.ExecutionStatus(- status_str='success' if e.success else 'error',- completed=e.success,- messages=e.status_messages), process_item=remove_sensitive)- if server_instance.client_id is not None:- server_instance.send_sync("executing", {"node": None, "prompt_id": prompt_id}, server_instance.client_id)-- current_time = time.perf_counter()- execution_time = current_time - execution_start_time-- # Log Time in a more readable way after 10 minutes- if execution_time > 600:- execution_time = time.strftime("%H:%M:%S", time.gmtime(execution_time))- logging.info(f"Prompt executed in {execution_time}", extra={'color': 'green'})- else:- logging.info("Prompt executed in {:.2f} seconds".format(execution_time), extra={'color': 'green'})-- flags = q.get_flags()- free_memory = flags.get("free_memory", False)-- if flags.get("unload_models", free_memory):- comfy.model_management.unload_all_models()- need_gc = True- last_gc_collect = 0-- if free_memory:- e.reset()- need_gc = True- last_gc_collect = 0-- if need_gc:- current_time = time.perf_counter()- if (current_time - last_gc_collect) > gc_collect_interval:- gc.collect()- comfy.model_management.soft_empty_cache()- last_gc_collect = current_time- need_gc = False- hook_breaker_ac10a0.restore_functions()-- asset_manager.queue_output_scan()- asset_manager.resume_background_scan()+ try:+ timeout = 1000.0+ if need_gc:+ timeout = max(gc_collect_interval - (current_time - last_gc_collect), 0.0)++ queue_item = q.get(timeout=timeout)+ if queue_item is not None:+ item, item_id = queue_item+ execution_start_time = time.perf_counter()+ prompt_id = item[1]+ server_instance.last_prompt_id = prompt_id++ sensitive = item[5]+ extra_data = item[3].copy()+ for k in sensitive:+ extra_data[k] = sensitive[k]++ asset_manager.pause_background_scan()+ background_scan_paused = True+ e.execute(item[2], prompt_id, extra_data, item[4])++ need_gc = True++ remove_sensitive = lambda prompt: prompt[:5] + prompt[6:]+ q.task_done(item_id,+ e.history_result,+ status=execution.PromptQueue.ExecutionStatus(+ status_str='success' if e.success else 'error',+ completed=e.success,+ messages=e.status_messages), process_item=remove_sensitive)+ if server_instance.client_id is not None:+ server_instance.send_sync("executing", {"node": None, "prompt_id": prompt_id}, server_instance.client_id)++ current_time = time.perf_counter()+ execution_time = current_time - execution_start_time++ # Log Time in a more readable way after 10 minutes+ if execution_time > 600:+ execution_time = time.strftime("%H:%M:%S", time.gmtime(execution_time))+ logging.info(f"Prompt executed in {execution_time}", extra={'color': 'green'})+ else:+ logging.info("Prompt executed in {:.2f} seconds".format(execution_time), extra={'color': 'green'})++ flags = q.get_flags()+ free_memory = flags.get("free_memory", False)++ if flags.get("unload_models", free_memory):+ comfy.model_management.unload_all_models()+ need_gc = True+ last_gc_collect = 0++ if free_memory:+ e.reset()+ need_gc = True+ last_gc_collect = 0++ if need_gc:+ current_time = time.perf_counter()+ if (current_time - last_gc_collect) > gc_collect_interval:+ gc.collect()+ comfy.model_management.soft_empty_cache()+ last_gc_collect = current_time+ need_gc = False+ hook_breaker_ac10a0.restore_functions()++ asset_manager.queue_output_scan()+ asset_manager.resume_background_scan()+ background_scan_paused = False+ # BaseException is deliberate. This runs on the worker thread, so Ctrl-C lands in+ # the main thread instead, and resume only flips the seeder's pause state.+ except BaseException:+ if background_scan_paused:+ try:+ asset_manager.resume_background_scan()+ except Exception:+ logging.exception("Failed to resume background asset scanning after prompt worker failure")+ raiseasync def run(server_instance, address='', port=8188, verbose=True, call_on_start=None):@@ -497,6 +510,7 @@ def start_comfyui(asyncio_loop=None):folder_paths.set_temp_directory(temp_dir)asset_manager: AssetManager = default_asset_manager()+ feature_flags.SERVER_FEATURE_FLAGS["assets"] = asset_manager.enabledif not asset_manager.enabled:cleanup_temp_filesystem()diff --git a/tests-unit/app_test/database_path_test.py b/tests-unit/app_test/database_path_test.pyindex 5e6648bea..838e1a96c 100644--- a/tests-unit/app_test/database_path_test.py+++ b/tests-unit/app_test/database_path_test.py@@ -119,7 +119,6 @@ def test_prepare_file_database_creates_parent_directory(monkeypatch, tmp_path):db_path = tmp_path / "nested" / "comfyui.db"monkeypatch.setattr(db.args, "database_url", None)- monkeypatch.setattr(db, "copy_legacy_default_db", lambda path: None)db.prepare_file_db_path(str(db_path))@@ -129,7 +128,6 @@ def test_prepare_file_database_creates_parent_directory(monkeypatch, tmp_path):def test_prepare_file_database_accepts_relative_database_path(monkeypatch, tmp_path):monkeypatch.chdir(tmp_path)monkeypatch.setattr(db.args, "database_url", "sqlite:///relative.db")- monkeypatch.setattr(db, "copy_legacy_default_db", lambda path: None)db.prepare_file_db_path("relative.db")diff --git a/tests-unit/app_test/test_db_init_locking.py b/tests-unit/app_test/test_db_init_locking.pyindex 1015ffaba..05f02406e 100644--- a/tests-unit/app_test/test_db_init_locking.py+++ b/tests-unit/app_test/test_db_init_locking.py@@ -97,6 +97,43 @@ def test_held_lock_blocks_before_any_migration_work(stale_db):holder.release()+def test_legacy_database_copy_runs_under_file_lock(tmp_path, monkeypatch):+ legacy_db = tmp_path / "legacy" / "comfyui.db"+ target_db = tmp_path / "current" / "comfyui.db"+ legacy_db.parent.mkdir()+ legacy_db.write_bytes(b"legacy database")+ copied: list[tuple[str, str]] = []+ real_copy = db_module.shutil.copy++ def _copy_while_locked(source: str, destination: str):+ contender = FileLock(str(target_db) + ".lock")+ try:+ with pytest.raises(Timeout):+ contender.acquire(timeout=0)+ finally:+ if contender.is_locked:+ contender.release()+ copied.append((source, destination))+ return real_copy(source, destination)++ monkeypatch.setattr(db_module.args, "database_url", None)+ monkeypatch.setattr(db_module, "get_db_path", lambda: str(target_db))+ monkeypatch.setattr(+ db_module, "get_legacy_default_db_path", lambda: str(legacy_db)+ )+ monkeypatch.setattr(db_module, "_migrate_and_bind", lambda *_args: None)+ monkeypatch.setattr(db_module.shutil, "copy", _copy_while_locked)+ monkeypatch.setattr(db_module, "_db_lock", None)++ try:+ db_module._init_file_db(f"sqlite:///{target_db}")+ finally:+ if db_module._db_lock is not None:+ db_module._db_lock.release(force=True)++ assert copied == [(str(legacy_db) + ".bak", str(target_db))]++def test_setup_database_routes_file_lock_to_lock_guidance(monkeypatch, caplog):monkeypatch.setattr(main, "dependencies_available", lambda: True)diff --git a/tests-unit/app_test/test_migration_0007.py b/tests-unit/app_test/test_migration_0007.pyindex ae7efd2bd..4d2c126f2 100644--- a/tests-unit/app_test/test_migration_0007.py+++ b/tests-unit/app_test/test_migration_0007.py@@ -4,6 +4,9 @@ import sqlite3import pytestfrom alembic import commandfrom alembic.config import Config+from sqlalchemy import create_engine, inspect++import app.assets.database.models as asset_models_BASELINE_0006 = "0006_add_loader_path"@@ -95,7 +98,6 @@ def test_0007_invariants_on_migrated_db(db_at_0006):def test_0007_orm_parity(db_at_0006, tmp_path):from sqlalchemy import create_engine, inspect- import app.assets.database.models as asset_modelsfrom app.database.models import Basecfg, db_path = db_at_0006@@ -109,26 +111,47 @@ def test_0007_orm_parity(db_at_0006, tmp_path):)}- alembic_engine = create_engine(f"sqlite:///{db_path}")orm_db = str(tmp_path / "orm.db")engine = create_engine(f"sqlite:///{orm_db}")- alembic_inspector = inspect(alembic_engine)Base.metadata.create_all(engine)orm_inspector = inspect(engine)orm_tables = set(orm_inspector.get_table_names())- assert asset_models.AssetMeta.__tablename__ == "asset_meta"- alembic_indexes = {- (index["name"], tuple(index["column_names"]))- for index in alembic_inspector.get_indexes("asset_meta")- }+ assert alembic_tables == orm_tables, f"Mismatch: alembic={alembic_tables}, orm={orm_tables}"+++ ("table_name", "has_indexes"),+ [+ ("assets", True),+ ("asset_contents", True),+ ("asset_tags", True),+ ("asset_system_state", False),+ ],+)+def test_0007_index_orm_parity(db_at_0006, table_name, has_indexes):+ cfg, db_path = db_at_0006+ command.upgrade(cfg, "head")++ alembic_engine = create_engine(f"sqlite:///{db_path}")+ try:+ alembic_indexes = {+ (index["name"], tuple(index["column_names"]))+ for index in inspect(alembic_engine).get_indexes(table_name)+ }+ finally:+ alembic_engine.dispose()+orm_indexes = {(index.name, tuple(index.columns.keys()))- for index in Base.metadata.tables["asset_meta"].indexes+ for index in asset_models.Base.metadata.tables[table_name].indexes}- assert alembic_tables == orm_tables, f"Mismatch: alembic={alembic_tables}, orm={orm_tables}"- assert alembic_indexes == orm_indexes, f"Mismatch: alembic={alembic_indexes}, orm={orm_indexes}"+ assert bool(alembic_indexes) is has_indexes+ assert bool(orm_indexes) is has_indexes+ assert alembic_indexes == orm_indexes, (+ f"Mismatch for {table_name}: alembic={alembic_indexes}, orm={orm_indexes}"+ )def test_0007_downgrade_chain_past_0003_succeeds(db_at_0006):diff --git a/tests-unit/app_test/test_migration_0008.py b/tests-unit/app_test/test_migration_0008.pynew file mode 100644index 000000000..caa4f33d3--- /dev/null+++ b/tests-unit/app_test/test_migration_0008.py@@ -0,0 +1,99 @@+import os+import sqlite3++import pytest+from alembic import command+from alembic.config import Config+from sqlalchemy import create_engine, inspect++_BASELINE_0007 = "0007_record_content_split"+_REVISION_0008 = "0008_drop_asset_meta"+++def _make_config(db_path: str) -> Config:+ root = os.path.join(os.path.dirname(__file__), "../..")+ cfg = Config(os.path.abspath(os.path.join(root, "alembic.ini")))+ cfg.set_main_option("script_location", os.path.abspath(os.path.join(root, "alembic_db")))+ cfg.set_main_option("sqlalchemy.url", f"sqlite:///{db_path}")+ return cfg+++def _has_asset_meta(db_path: str) -> bool:+ with sqlite3.connect(db_path) as conn:+ return conn.execute(+ "SELECT 1 FROM sqlite_master WHERE type='table' AND name='asset_meta'"+ ).fetchone() is not None+++def _asset_meta_shape(db_path: str):+ engine = create_engine(f"sqlite:///{db_path}")+ try:+ inspector = inspect(engine)+ columns = {+ (column["name"], str(column["type"]))+ for column in inspector.get_columns("asset_meta")+ }+ indexes = {+ (index["name"], tuple(index["column_names"]))+ for index in inspector.get_indexes("asset_meta")+ }+ return columns, indexes+ finally:+ engine.dispose()+++def db_at_0007(tmp_path):+ db_path = str(tmp_path / "test.db")+ cfg = _make_config(db_path)+ command.upgrade(cfg, _BASELINE_0007)+ yield cfg, db_path+++def test_0008_upgrade_drops_asset_meta(db_at_0007):+ cfg, db_path = db_at_0007+ assert _has_asset_meta(db_path), "0007 creates asset_meta, so 0008 has something to drop"++ command.upgrade(cfg, _REVISION_0008)++ assert not _has_asset_meta(db_path)+++def test_0008_upgrade_tolerates_a_database_without_asset_meta(db_at_0007):+ cfg, db_path = db_at_0007+ with sqlite3.connect(db_path) as conn:+ conn.execute("DROP TABLE asset_meta")+ conn.commit()++ command.upgrade(cfg, _REVISION_0008)++ assert not _has_asset_meta(db_path)+++def test_0008_downgrade_restores_the_0007_asset_meta(db_at_0007, tmp_path):+ cfg, db_path = db_at_0007++ reference_db = str(tmp_path / "reference_0007.db")+ command.upgrade(_make_config(reference_db), _BASELINE_0007)++ command.upgrade(cfg, _REVISION_0008)+ command.downgrade(cfg, _BASELINE_0007)++ restored_columns, restored_indexes = _asset_meta_shape(db_path)+ expected_columns, expected_indexes = _asset_meta_shape(reference_db)++ assert restored_columns == expected_columns, (+ f"column drift: restored={restored_columns}, expected={expected_columns}"+ )+ assert restored_indexes == expected_indexes, (+ f"index drift: restored={restored_indexes}, expected={expected_indexes}"+ )+ assert len(restored_indexes) == 4, f"0007 creates four asset_meta indexes, got {restored_indexes}"+++def test_head_has_no_asset_meta(tmp_path):+ db_path = str(tmp_path / "head.db")++ command.upgrade(_make_config(db_path), "head")++ assert not _has_asset_meta(db_path)diff --git a/tests-unit/app_test/test_prompt_worker.py b/tests-unit/app_test/test_prompt_worker.pynew file mode 100644index 000000000..3b572bf31--- /dev/null+++ b/tests-unit/app_test/test_prompt_worker.py@@ -0,0 +1,118 @@+import pytest+import torch++from comfy.cli_args import args++# Must precede the import: comfy.model_management picks its device at import time, and a CUDA+# build with no driver raises there.+_original_cpu = args.cpu+if not torch.cuda.is_available():+ args.cpu = True+try:+ import main+finally:+ args.cpu = _original_cpu++class LoopEscape(Exception):+ pass+++class Queue:+ def __init__(self, completion_error: RuntimeError | None = None) -> None:+ self.completion_error = completion_error+ self.get_calls = 0++ def get(self, timeout=None):+ self.get_calls += 1+ if self.get_calls > 1:+ raise LoopEscape("prompt worker requested a second item")+ return (0, "prompt-id", {}, {}, [], {}), 1++ def task_done(self, *args, **kwargs) -> None:+ if self.completion_error is not None:+ raise self.completion_error++ def get_flags(self):+ return {}+++class Server:+ last_prompt_id = None+ client_id = None+++class AssetManager:+ def __init__(self, resume_error: RuntimeError | None = None) -> None:+ self.paused = False+ self.resume_error = resume_error++ def pause_background_scan(self) -> None:+ self.paused = True++ def resume_background_scan(self) -> None:+ self.paused = False+ if self.resume_error is not None:+ raise self.resume_error+++class Executor:+ def __init__(self, *args, **kwargs) -> None:+ self.history_result = {}+ self.success = True+ self.status_messages = []++ def execute(self, *args, **kwargs) -> None:+ return None+++class ExecuteFailureExecutor(Executor):+ def execute(self, *args, **kwargs) -> None:+ raise RuntimeError("forced execute failure")+++def test_prompt_worker_resumes_background_scan_when_execute_raises(monkeypatch) -> None:+ monkeypatch.setattr(main.execution, "PromptExecutor", ExecuteFailureExecutor)+ asset_manager = AssetManager()++ with pytest.raises(RuntimeError, match="^forced execute failure$"):+ main.prompt_worker(Queue(), Server(), asset_manager)++ assert asset_manager.paused is False+++def test_prompt_worker_resumes_background_scan_when_completion_raises(monkeypatch) -> None:+ monkeypatch.setattr(main.execution, "PromptExecutor", Executor)+ asset_manager = AssetManager()++ with pytest.raises(RuntimeError, match="^forced completion failure$"):+ main.prompt_worker(+ Queue(completion_error=RuntimeError("forced completion failure")),+ Server(),+ asset_manager,+ )++ assert asset_manager.paused is False+++def test_prompt_worker_preserves_execute_error_when_resume_raises(monkeypatch) -> None:+ monkeypatch.setattr(main.execution, "PromptExecutor", ExecuteFailureExecutor)+ asset_manager = AssetManager(resume_error=RuntimeError("forced resume failure"))++ with pytest.raises(RuntimeError, match="^forced execute failure$"):+ main.prompt_worker(Queue(), Server(), asset_manager)++ assert asset_manager.paused is False+++def test_prompt_worker_resumes_scan_when_later_iteration_raises_before_gc(monkeypatch) -> None:+ monkeypatch.setattr(main.execution, "PromptExecutor", Executor)+ clock = iter((1.0, 2.0, 2.0))+ monkeypatch.setattr(main.time, "perf_counter", lambda: next(clock))+ asset_manager = AssetManager()+ queue = Queue()++ with pytest.raises(LoopEscape, match="^prompt worker requested a second item$"):+ main.prompt_worker(queue, Server(), asset_manager)++ assert queue.get_calls == 2+ assert asset_manager.paused is Falsediff --git a/tests-unit/assets_test/queries/conftest.py b/tests-unit/assets_test/queries/conftest.pyindex 18b67c159..30f4a84b1 100644--- a/tests-unit/assets_test/queries/conftest.py+++ b/tests-unit/assets_test/queries/conftest.py@@ -10,7 +10,6 @@ def assert_asset_metadata_tables():assert set(Base.metadata.tables) == {"assets","asset_contents",- "asset_meta","asset_tags","tags","asset_system_state",diff --git a/tests-unit/assets_test/queries/test_asset_reference_keyset.py b/tests-unit/assets_test/queries/test_asset_reference_keyset.pyindex b3d2c42cd..28f9f6350 100644--- a/tests-unit/assets_test/queries/test_asset_reference_keyset.py+++ b/tests-unit/assets_test/queries/test_asset_reference_keyset.py@@ -1,28 +1,41 @@+import pytestfrom sqlalchemy.orm import Sessionfrom app.assets.database.queries import create_content, create_record, list_records_page-from app.assets.database.queries.records import RecordCursorBoundary, RecordPageSpec+from app.assets.database.queries.records import (+ RecordCursorBoundary,+ RecordPageSpec,+ RecordSortOrder,+)-def test_record_keyset_cursor_pages_in_creation_order(session: Session) -> None:+ ("order", "expected_indexes"),+ [("asc", (0, 1, 2)), ("desc", (2, 1, 0))],+)+def test_record_keyset_cursor_pages_in_creation_order(+ session: Session, order: RecordSortOrder, expected_indexes: tuple[int, int, int]+) -> None:records = [create_record(session, create_content(session, f"/output/{name}").id, name)for name in ("one.png", "two.png", "three.png")]+ shared_created_at = records[0].created_atfor index, record in enumerate(records, start=1):record.id = f"00000000-0000-0000-0000-{index:012d}"+ record.created_at = shared_created_atsession.flush()first_page, _, _ = list_records_page(session,- RecordPageSpec(limit=2, order="asc"),+ RecordPageSpec(limit=2, order=order),)boundary_record = first_page[-1]second_page, _, _ = list_records_page(session,RecordPageSpec(limit=2,- order="asc",+ order=order,after=RecordCursorBoundary(value=boundary_record.created_at,id=boundary_record.id,@@ -30,4 +43,6 @@ def test_record_keyset_cursor_pages_in_creation_order(session: Session) -> None:),)- assert [record.id for record in first_page + second_page] == [record.id for record in records]+ assert [record.id for record in first_page + second_page] == [+ records[index].id for index in expected_indexes+ ]diff --git a/tests-unit/assets_test/services/test_admission_gate.py b/tests-unit/assets_test/services/test_admission_gate.pyindex 6bd82f15d..1673295eb 100644--- a/tests-unit/assets_test/services/test_admission_gate.py+++ b/tests-unit/assets_test/services/test_admission_gate.py@@ -1,10 +1,13 @@+import loggingimport osfrom collections.abc import Iteratorfrom pathlib import Path+from types import SimpleNamespacefrom unittest.mock import patchimport pytestfrom sqlalchemy import select+from sqlalchemy.orm import sessionmakerfrom app.assets import scanner_admissionfrom app.assets.database.models import AssetContent@@ -94,6 +97,159 @@ def test_never_stabilizes_dropped_after_cap(session, temp_dir: Path):assert session.scalars(select(AssetContent)).all() == []+def test_stat_error_drops_entry_and_allows_other_watch_entries_to_commit(+ db_engine, session, temp_dir: Path, monkeypatch, caplog: pytest.LogCaptureFixture+):+ unreadable_path = temp_dir / "unreadable.bin"+ stable_path = temp_dir / "stable.bin"+ unreadable_path.write_bytes(b"unreadable")+ stable_path.write_bytes(b"stable")+ unreadable_stat = unreadable_path.stat()+ stable_stat = stable_path.stat()+ _WATCH_LIST[:] = [+ _WatchEntry(str(unreadable_path), unreadable_stat),+ _WatchEntry(str(stable_path), stable_stat),+ ]+ real_os = scanner_admission.os++ def _stat(path: str):+ if path == str(unreadable_path):+ raise PermissionError(path)+ return real_os.stat(path)++ monkeypatch.setattr("folder_paths.get_input_directory", lambda: str(temp_dir))+ monkeypatch.setattr(scanner_admission, "os", SimpleNamespace(stat=_stat))+ monkeypatch.setattr("app.database.db.WriteSession", sessionmaker(bind=db_engine))++ with caplog.at_level(logging.INFO):+ tick_watch_list()++ persisted_paths = set(session.scalars(select(AssetContent.path)).all())+ assert persisted_paths == {str(stable_path)}+ assert _WATCH_LIST == []+ assert any(+ record.getMessage()+ == f"Dropping watched asset after stat failed: {unreadable_path}"+ for record in caplog.records+ )+ assert any(+ record.getMessage()+ == "[assets-event] scanner.watch_stat_failed error_type=PermissionError"+ for record in caplog.records+ )+++def test_seed_failure_does_not_stop_watch_list_drain(+ temp_dir: Path,+ monkeypatch,+ caplog: pytest.LogCaptureFixture,+) -> None:+ paths = [temp_dir / name for name in ("broken.bin", "stable.bin")]+ for path in paths:+ path.write_bytes(path.name.encode())+ _WATCH_LIST[:] = [_WatchEntry(str(path), path.stat()) for path in paths]+ batches: list[list[str]] = []++ def insert_with_one_failure(specs, _tag_pool) -> tuple[int, Exception | None]:+ batches.append([spec["abs_path"] for spec in specs])+ return 1, RuntimeError("forced watch seed failure")++ monkeypatch.setattr("folder_paths.get_input_directory", lambda: str(temp_dir))+ monkeypatch.setattr("app.assets.scanner.insert_asset_specs", insert_with_one_failure)++ with caplog.at_level(logging.INFO):+ tick_watch_list()++ assert batches == [[str(path) for path in paths]]+ assert _WATCH_LIST == []+ assert any(+ record.getMessage() == "Seeding settled watched assets failed for at least one entry"+ for record in caplog.records+ )+ assert any(+ record.getMessage()+ == "[assets-event] scanner.watch_seed_failed error_type=RuntimeError"+ for record in caplog.records+ )+++def test_spec_construction_failure_drops_the_entry_without_wedging_the_watch_list(+ db_engine,+ session,+ temp_dir: Path,+ monkeypatch,+ caplog: pytest.LogCaptureFixture,+) -> None:+ changing_path = temp_dir / "changing.bin"+ unresolvable_path = temp_dir / "unresolvable.bin"+ stable_path = temp_dir / "stable.bin"+ for path in (changing_path, unresolvable_path, stable_path):+ path.write_bytes(path.name.encode())+ changing_stat = changing_path.stat()+ changing_path.write_bytes(b"still-downloading-and-now-longer")+ _WATCH_LIST[:] = [+ _WatchEntry(str(changing_path), changing_stat),+ _WatchEntry(str(unresolvable_path), unresolvable_path.stat()),+ _WatchEntry(str(stable_path), stable_path.stat()),+ ]+ resolve_name_and_tags = scanner_admission.get_name_and_tags_from_asset_path++ def _name_and_tags(path: str) -> tuple[str, list[str]]:+ if path == str(unresolvable_path):+ raise ValueError(+ "Path is not within input, output, temp, or configured model bases: "+ f"{path}"+ )+ return resolve_name_and_tags(path)++ monkeypatch.setattr("folder_paths.get_input_directory", lambda: str(temp_dir))+ monkeypatch.setattr(+ scanner_admission, "get_name_and_tags_from_asset_path", _name_and_tags+ )+ monkeypatch.setattr("app.database.db.WriteSession", sessionmaker(bind=db_engine))++ with caplog.at_level(logging.INFO):+ tick_watch_list()++ assert set(session.scalars(select(AssetContent.path)).all()) == {str(stable_path)}+ assert [(entry.path, entry.ticks) for entry in _WATCH_LIST] == [+ (str(changing_path), 1)+ ]+ assert any(+ record.getMessage()+ == f"Dropping watched asset after spec construction failed: {unresolvable_path}"+ for record in caplog.records+ )+ assert any(+ record.getMessage()+ == "[assets-event] scanner.watch_spec_failed error_type=ValueError"+ for record in caplog.records+ )+++def test_unexpected_fault_mid_drain_leaves_unvisited_entries_on_the_watch_list(+ temp_dir: Path, monkeypatch+) -> None:+ paths = [temp_dir / name for name in ("first.bin", "exploding.bin", "untouched.bin")]+ for path in paths:+ path.write_bytes(path.name.encode())+ _WATCH_LIST[:] = [_WatchEntry(str(path), path.stat()) for path in paths]+ real_os = scanner_admission.os++ def stat_or_explode(path: str):+ if path == str(paths[1]):+ raise MemoryError("forced unrecoverable fault")+ return real_os.stat(path)++ monkeypatch.setattr("folder_paths.get_input_directory", lambda: str(temp_dir))+ monkeypatch.setattr(scanner_admission, "os", SimpleNamespace(stat=stat_or_explode))++ with pytest.raises(MemoryError, match="^forced unrecoverable fault$"):+ tick_watch_list()++ assert [entry.path for entry in _WATCH_LIST] == [str(paths[2])]++def test_stable_scan_admission_removes_watch_entry_before_next_tick(session, temp_dir: Path, monkeypatch):path = temp_dir / "stable.bin"path.write_bytes(b"complete")@@ -109,7 +265,7 @@ def test_stable_scan_admission_removes_watch_entry_before_next_tick(session, tem"app.assets.scanner_admission.get_name_and_tags_from_asset_path",return_value=("stable.bin", []),),- patch("app.assets.scanner.insert_asset_specs") as insert_asset_specs,+ patch("app.assets.scanner.insert_asset_specs", return_value=(0, None)) as insert_asset_specs,):tick_watch_list()@@ -183,7 +339,7 @@ def test_settled_entries_are_seeded_in_one_write_session_batch(temp_dir: Path):"app.assets.scanner_admission.get_name_and_tags_from_asset_path",side_effect=lambda path: (os.path.basename(path), []),),- patch("app.assets.scanner.insert_asset_specs") as insert_asset_specs,+ patch("app.assets.scanner.insert_asset_specs", return_value=(0, None)) as insert_asset_specs,):tick_watch_list()diff --git a/tests-unit/assets_test/services/test_api_routes_b.py b/tests-unit/assets_test/services/test_api_routes_b.pyindex c6e186eb3..2f86313d3 100644--- a/tests-unit/assets_test/services/test_api_routes_b.py+++ b/tests-unit/assets_test/services/test_api_routes_b.py@@ -153,3 +153,19 @@ async def test_from_hash_off_mode_returns_400(monkeypatch):response_body = response.bodyassert isinstance(response_body, bytes | bytearray)assert json.loads(response_body)["error"]["code"] == "FEATURE_DISABLED"+++async def test_prune_failure_returns_500_instead_of_completed(monkeypatch):+ monkeypatch.setattr(+ routes.asset_seeder, "mark_missing_outside_prefixes", lambda: None+ )++ response = await routes.mark_missing_assets.__wrapped__(+ make_mocked_request("POST", "/api/assets/prune")+ )++ assert response.status == 500+ response_body = response.body+ assert isinstance(response_body, bytes | bytearray)+ assert json.loads(response_body)["error"]["code"] == "PRUNE_FAILED"diff --git a/tests-unit/assets_test/services/test_ingest_orphan_content.py b/tests-unit/assets_test/services/test_ingest_orphan_content.pyindex ae209945c..826e6dfe8 100644--- a/tests-unit/assets_test/services/test_ingest_orphan_content.py+++ b/tests-unit/assets_test/services/test_ingest_orphan_content.py@@ -119,7 +119,7 @@ def _orphaned_content_paths(session: Session) -> list[str]:]-def test_seed_asset_specs_orphans_nothing_and_keeps_earlier_specs_on_record_failure(+def test_seed_asset_specs_orphans_nothing_and_keeps_surrounding_specs_on_record_failure(session: Session, tmp_path, monkeypatch: pytest.MonkeyPatch) -> None:specs: list[SeedAssetSpec] = []@@ -144,10 +144,11 @@ def test_seed_asset_specs_orphans_nothing_and_keeps_earlier_specs_on_record_failmonkeypatch.setattr("app.assets.scanner.create_record", _create_record_or_raise)- with pytest.raises(RuntimeError, match="forced create_record failure"):- seed_asset_specs(session, specs)- session.rollback()+ _created, error = seed_asset_specs(session, specs)+ session.commit()+ assert isinstance(error, RuntimeError)+ assert str(error) == "forced create_record failure"assert _content_at(session, paths[fail_name]) is None, ("the failed spec's content must not outlive the record that would have referenced it")@@ -162,7 +163,10 @@ def test_seed_asset_specs_orphans_nothing_and_keeps_earlier_specs_on_record_failassert session.scalar(select(Asset).where(Asset.name == "first.bin")) is not Noneassert _reference_count(session, survivor.id) == 1- assert attempted == ["first.bin", fail_name]- assert _content_at(session, paths["last.bin"]) is None, (- "the raise aborts the loop, so the spec after the failed one is never attempted"+ assert attempted == ["first.bin", fail_name, "last.bin"]+ last_survivor = _content_at(session, paths["last.bin"])+ assert last_survivor is not None, (+ "a failed spec must not prevent the remaining specs in the batch from being seeded")+ assert session.scalar(select(Asset).where(Asset.name == "last.bin")) is not None+ assert _reference_count(session, last_survivor.id) == 1diff --git a/tests-unit/assets_test/services/test_lifecycle.py b/tests-unit/assets_test/services/test_lifecycle.pyindex 4010a770c..75e2f9703 100644--- a/tests-unit/assets_test/services/test_lifecycle.py+++ b/tests-unit/assets_test/services/test_lifecycle.py@@ -15,7 +15,6 @@ from app.assets.database.models import Asset, AssetContent, Basefrom app.assets.database.queries.records import create_content, create_recordfrom app.assets.lifecycle import (cleanup_temp_filesystem,- get_excluded_scan_roots,run_asset_shutdown_cleanup,run_asset_startup,run_startup,@@ -182,24 +181,21 @@ def test_run_startup_logs_and_absorbs_disabled_filesystem_failure(caplog):def test_rmtree_failure_excludes_temp_from_scan(session, comfy_dirs, mock_create_session):record_id, content_id = _seed_temp_rows(session, comfy_dirs)-- wipe_temp_db_rows(session)- session.commit()- assert session.get(Asset, record_id) is None+ tracked_file = comfy_dirs / "preview.png"+ tracked_file.unlink()with patch("app.assets.lifecycle.shutil.rmtree", side_effect=OSError("busy")):assert cleanup_temp_filesystem() is False- assert str(comfy_dirs) in get_excluded_scan_roots()assert get_temp_prefixes() == []- residual = comfy_dirs / "leftover.png"- residual.write_bytes(b"\x00" * 10)-with patch("app.assets.scanner.create_session", mock_create_session):sync_temp_references_safely()- assert session.scalars(select(Asset)).all() == []+ session.expire_all()+ content = session.get(AssetContent, content_id)+ assert session.get(Asset, record_id) is not None+ assert content is not None and content.is_missing is Falsedef test_shutdown_skips_cleanup_when_seeder_join_times_out(session, comfy_dirs, mock_create_session, caplog):diff --git a/tests-unit/assets_test/services/test_null_hash_recovery.py b/tests-unit/assets_test/services/test_null_hash_recovery.pyindex 2a247fced..6736ab004 100644--- a/tests-unit/assets_test/services/test_null_hash_recovery.py+++ b/tests-unit/assets_test/services/test_null_hash_recovery.py@@ -81,9 +81,10 @@ def test_deleted_null_hash_row_recovers_via_scanner_after_restore(assert path.stat().st_mtime_ns == stat.st_mtime_ns, "setup: mtime must round-trip exactly"with patch("app.assets.scanner.mode.hashing_enabled", return_value=True):- created = seed_asset_specs(session, [_spec(path)])+ created, error = seed_asset_specs(session, [_spec(path)])session.commit()+ assert error is Noneassert created == 0, "the original row must recover — no fresh content row minted"recovered = session.get(AssetContent, content_id)assert recovered.is_missing is False@@ -118,9 +119,10 @@ def test_different_bytes_restored_at_same_path_does_not_recover_old_row(path.write_bytes(b"a completely different, much longer payload than the original")with patch("app.assets.scanner.mode.hashing_enabled", return_value=True):- created = seed_asset_specs(session, [_spec(path)])+ created, error = seed_asset_specs(session, [_spec(path)])session.commit()+ assert error is Noneassert created == 1, "a genuinely different file must take the normal new-content path"assert session.get(AssetContent, content_id).is_missing is True, ("the old row must stay missing — recovering it here would hand the wrong record's "@@ -158,9 +160,10 @@ def test_same_size_different_mtime_restored_at_same_path_does_not_recover_old_roassert path.stat().st_size == stat.st_size, "setup: size must match so only mtime disambiguates"with patch("app.assets.scanner.mode.hashing_enabled", return_value=True):- created = seed_asset_specs(session, [_spec(path)])+ created, error = seed_asset_specs(session, [_spec(path)])session.commit()+ assert error is Noneassert created == 1, "a same-size-but-different-mtime restore must take the new-content path"assert session.get(AssetContent, content_id).is_missing is True, ("a matching size with a mismatched mtime is not proof the old row's bytes are back — "@@ -190,9 +193,10 @@ def test_two_missing_null_hash_candidates_at_same_path_do_not_recover(session.commit()with patch("app.assets.scanner.mode.hashing_enabled", return_value=True):- created = seed_asset_specs(session, [_spec(path)])+ created, error = seed_asset_specs(session, [_spec(path)])session.commit()+ assert error is Noneassert created == 1, "ambiguous candidates must fall through to the normal new-content path"assert session.get(AssetContent, first_id).is_missing is Trueassert session.get(AssetContent, second_id).is_missing is Truediff --git a/tests-unit/assets_test/services/test_recovery_gate.py b/tests-unit/assets_test/services/test_recovery_gate.pyindex 885d0100b..59b365570 100644--- a/tests-unit/assets_test/services/test_recovery_gate.py+++ b/tests-unit/assets_test/services/test_recovery_gate.py@@ -65,9 +65,10 @@ def test_single_hash_match_recovers(session, temp_dir: Path):content, record = _missing_content(session, path, _stored_hash(path))with patch("app.assets.scanner.mode.hashing_enabled", return_value=True):- created = seed_asset_specs(session, [_spec(path)])+ created, error = seed_asset_specs(session, [_spec(path)])session.commit()+ assert error is Noneassert created == 0assert session.get(AssetContent, content.id).is_missing is Falseassert session.get(AssetTag, {"asset_id": record.id, "tag_name": "missing"}) is None@@ -81,9 +82,10 @@ def test_ambiguous_hash_match_recovers_nothing(session, temp_dir: Path):second, _ = _missing_content(session, path, digest)with patch("app.assets.scanner.mode.hashing_enabled", return_value=True):- created = seed_asset_specs(session, [_spec(path)])+ created, error = seed_asset_specs(session, [_spec(path)])session.commit()+ assert error is Noneassert created == 1assert session.get(AssetContent, first.id).is_missing is Trueassert session.get(AssetContent, second.id).is_missing is True@@ -96,9 +98,10 @@ def test_no_hash_match_creates_fresh_rows(session, temp_dir: Path):missing, _ = _missing_content(session, path, "old")with patch("app.assets.scanner.mode.hashing_enabled", return_value=True):- created = seed_asset_specs(session, [_spec(path)])+ created, error = seed_asset_specs(session, [_spec(path)])session.commit()+ assert error is Noneassert created == 1assert session.get(AssetContent, missing.id).is_missing is Trueassert len(session.scalars(select(Asset)).all()) == 2@@ -113,10 +116,11 @@ def test_off_mode_no_recovery(session, temp_dir: Path):patch("app.assets.scanner.mode.hashing_enabled", return_value=False),patch("app.assets.scanner.snapshot_hash") as hash_mock,):- created = seed_asset_specs(session, [_spec(path)])+ created, error = seed_asset_specs(session, [_spec(path)])session.commit()hash_mock.assert_not_called()+ assert error is Noneassert created == 1assert session.get(AssetContent, missing.id).is_missing is True@@ -130,9 +134,10 @@ def test_unstable_hash_requeues(session, temp_dir: Path):patch("app.assets.scanner.mode.hashing_enabled", return_value=True),patch("app.assets.scanner.snapshot_hash", return_value=None),):- created = seed_asset_specs(session, [_spec(path)])+ created, error = seed_asset_specs(session, [_spec(path)])session.commit()+ assert error is Noneassert created == 0assert pending_recovery_count() == 1assert session.get(AssetContent, missing.id).is_missing is True@@ -180,7 +185,7 @@ def test_seeded_row_takes_the_stat_its_hash_was_verified_against(session, temp_dpatch("app.assets.scanner.mode.hashing_enabled", return_value=True),patch("app.assets.scanner.snapshot_hash", side_effect=rewrite_then_hash),):- created = seed_asset_specs(session, [_spec(path)])+ created, _ = seed_asset_specs(session, [_spec(path)])session.commit()assert created == 1diff --git a/tests-unit/assets_test/services/test_scan_lifecycle.py b/tests-unit/assets_test/services/test_scan_lifecycle.pyindex 134dc2118..0d244c0fa 100644--- a/tests-unit/assets_test/services/test_scan_lifecycle.py+++ b/tests-unit/assets_test/services/test_scan_lifecycle.py@@ -15,7 +15,10 @@ from app.assets.scanner import (def _scan(session, root: Path) -> int:paths = [str(path) for path in root.iterdir()]specs, _, _ = build_asset_specs(paths, set(), enable_metadata_extraction=False)- return seed_asset_specs(session, specs)+ created, error = seed_asset_specs(session, specs)+ if error is not None:+ raise error+ return createddef test_e2e_scan_seed_detect_prune(session, temp_dir: Path):diff --git a/tests-unit/assets_test/services/test_scanner_b.py b/tests-unit/assets_test/services/test_scanner_b.pyindex c298381fc..ad0828a9d 100644--- a/tests-unit/assets_test/services/test_scanner_b.py+++ b/tests-unit/assets_test/services/test_scanner_b.py@@ -13,6 +13,7 @@ from app.assets.scanner import (build_asset_specs,enrich_asset,mark_contents_missing_outside_prefixes,+ mark_missing_outside_prefixes_safely,seed_asset_specs,apply_reference_observations,observe_references_on_filesystem,@@ -133,12 +134,13 @@ def test_seed_creates_content_and_record(session, temp_dir: Path):(input_root / "second.png").write_bytes(b"second")with patch("folder_paths.get_input_directory", return_value=str(input_root)):- created = seed_asset_specs(session, _build_seed_specs(input_root))+ created, error = seed_asset_specs(session, _build_seed_specs(input_root))session.commit()contents = list(session.scalars(select(AssetContent).order_by(AssetContent.path)))records = list(session.scalars(select(Asset).order_by(Asset.name)))+ assert error is Noneassert created == 2assert len(contents) == 2assert len(records) == 2@@ -172,6 +174,16 @@ def test_prune_marks_missing_not_deletes(session, temp_dir: Path):assert missing_tag is not None and missing_tag.origin == "automatic"+def test_mark_missing_failure_returns_none():+ with patch(+ "app.assets.scanner.create_session",+ side_effect=RuntimeError("database unavailable"),+ ):+ result = mark_missing_outside_prefixes_safely([])++ assert result is None++def test_unhashed_missing_content_gets_tagged(session, temp_dir: Path):missing_path = os.path.abspath(temp_dir / "missing.bin")content = AssetContent(path=missing_path, hash=None, size_bytes=7, mtime_ns=1)diff --git a/tests-unit/assets_test/services/test_scanner_seed_resilience.py b/tests-unit/assets_test/services/test_scanner_seed_resilience.pyindex aafa019bb..7a2d10e10 100644--- a/tests-unit/assets_test/services/test_scanner_seed_resilience.py+++ b/tests-unit/assets_test/services/test_scanner_seed_resilience.py@@ -1,5 +1,7 @@+import loggingimport osfrom collections.abc import Callable+from contextlib import contextmanagerfrom pathlib import Pathfrom unittest.mock import patch@@ -9,8 +11,13 @@ from sqlalchemy.exc import IntegrityErrorfrom sqlalchemy.orm import Sessionfrom app.assets.database.models import Asset, AssetContent-from app.assets.database.queries import create_content, create_record, delete_record-from app.assets.scanner import SeedAssetSpec, seed_asset_specs+from app.assets.database.queries import (+ create_content,+ create_content_reporting_insert,+ create_record,+ delete_record,+)+from app.assets.scanner import SeedAssetSpec, insert_asset_specs, seed_asset_specsfrom app.assets.services.snapshot_hash import snapshot_hash@@ -46,9 +53,10 @@ def test_seed_persists_remaining_specs_when_path_vanishes_before_restat(specs, vanished_path = _specs_with_vanished_path(temp_dir)vanished_path.unlink()- created = seed_asset_specs(session, specs)+ created, error = seed_asset_specs(session, specs)session.commit()+ assert error is Noneassert created == 2assert _record_count(session) == 2@@ -67,9 +75,10 @@ def test_seed_persists_remaining_specs_when_path_vanishes_during_recovery_hash(monkeypatch.setattr("app.assets.scanner.snapshot_hash", _hash_or_raise)with patch("app.assets.scanner.mode.hashing_enabled", return_value=True):- created = seed_asset_specs(session, specs)+ created, error = seed_asset_specs(session, specs)session.commit()+ assert error is Noneassert created == 2assert _record_count(session) == 2@@ -115,37 +124,74 @@ def test_seed_logs_once_for_each_vanished_path(assert messages == [f"Skipping vanished asset during scan: {vanished_path}"]-def test_seed_logs_the_real_error_for_an_unreadable_path(- session: Session,- temp_dir: Path,- monkeypatch: pytest.MonkeyPatch,- caplog: pytest.LogCaptureFixture,+def test_seed_absorbs_live_path_conflict_and_persists_the_specs_around_it(+ session: Session, temp_dir: Path, monkeypatch: pytest.MonkeyPatch) -> None:- specs, unreadable_path = _specs_with_vanished_path(temp_dir)+ specs, conflicted_path = _specs_with_vanished_path(temp_dir)- def _hash_or_raise(path: str) -> str | None:- if path == str(unreadable_path):- raise PermissionError("permission denied")- return snapshot_hash(path)+ def _create_content_or_conflict(+ session_arg: Session,+ path: str,+ *,+ hash: str | None = None,+ size_bytes: int = 0,+ mtime_ns: int | None = None,+ ) -> tuple[AssetContent, bool]:+ if path != str(conflicted_path):+ return create_content_reporting_insert(+ session_arg,+ path=path,+ hash=hash,+ size_bytes=size_bytes,+ mtime_ns=mtime_ns,+ )+ session_arg.add(+ AssetContent(+ path=path,+ hash=hash,+ size_bytes=size_bytes,+ mtime_ns=mtime_ns,+ )+ )+ session_arg.flush()+ session_arg.add(+ AssetContent(+ path=path,+ hash=hash,+ size_bytes=size_bytes,+ mtime_ns=mtime_ns,+ )+ )+ session_arg.flush()+ raise AssertionError("duplicate live paths must violate the unique index")- monkeypatch.setattr("app.assets.scanner.snapshot_hash", _hash_or_raise)+ monkeypatch.setattr(+ "app.assets.scanner.create_content_reporting_insert",+ _create_content_or_conflict,+ )- with patch("app.assets.scanner.mode.hashing_enabled", return_value=True):- created = seed_asset_specs(session, specs)+ created, error = seed_asset_specs(session, specs)session.commit()+ assert error is Noneassert created == 2- messages = [record.getMessage() for record in caplog.records]- assert "Asset scan error: phase=seed_observation error_type=permission_denied" in messages- assert not any(- "vanished" in message and str(unreadable_path) in message for message in messages- ), "an unreadable file still exists and must not also be reported as vanished"+ assert _record_count(session) == 2+ assert {record.name for record in session.scalars(select(Asset))} == {+ "first.bin",+ "last.bin",+ }-def test_seed_isolates_a_poisoned_spec_and_persists_the_specs_around_it(+def test_seed_propagates_unrelated_integrity_error(session: Session, temp_dir: Path, monkeypatch: pytest.MonkeyPatch) -> None:- specs, poisoned_path = _specs_with_vanished_path(temp_dir)+ path = temp_dir / "unrelated-integrity-error.bin"+ path.write_bytes(b"content")+ unrelated_error = IntegrityError(+ "forced record creation failure",+ {},+ ValueError("unrelated integrity failure"),+ )def _create_record_or_raise(session_arg: Session,@@ -157,32 +203,206 @@ def test_seed_isolates_a_poisoned_spec_and_persists_the_specs_around_it(loader_path: str | None,tags: list[str],) -> Asset:- if name == poisoned_path.name:- raise IntegrityError("forced record creation failure", {}, ValueError())+ raise unrelated_error++ monkeypatch.setattr("app.assets.scanner.create_record", _create_record_or_raise)++ _created, error = seed_asset_specs(session, [_spec(path)])++ assert error is unrelated_error+++def test_seed_raises_memory_error_instead_of_attempting_later_specs(+ session: Session, temp_dir: Path, monkeypatch: pytest.MonkeyPatch+) -> None:+ paths = []+ for name in ("first.bin", "second.bin"):+ path = temp_dir / name+ path.write_bytes(b"content")+ paths.append(path)+ attempted: list[str] = []++ def _create_record_or_exhaust(+ session_arg: Session,+ *,+ content_id: str,+ name: str,+ mime_type: str | None,+ job_id: str | None,+ loader_path: str | None,+ tags: list[str],+ ) -> Asset:+ attempted.append(name)+ raise MemoryError("out of memory")++ monkeypatch.setattr("app.assets.scanner.create_record", _create_record_or_exhaust)++ with pytest.raises(MemoryError):+ seed_asset_specs(session, [_spec(path) for path in paths])++ assert attempted == ["first.bin"]+++def test_seed_attempts_remaining_specs_before_propagating_integrity_error(+ session: Session, temp_dir: Path, monkeypatch: pytest.MonkeyPatch+) -> None:+ paths = [temp_dir / name for name in ("first.bin", "broken.bin", "last.bin")]+ for path in paths:+ path.write_bytes(path.name.encode())+ attempted: list[str] = []+ unrelated_error = IntegrityError(+ "forced record creation failure",+ {},+ ValueError("unrelated integrity failure"),+ )++ def _create_record_or_raise(+ session_arg: Session,+ *,+ content_id: str,+ name: str,+ mime_type: str | None,+ job_id: str | None,+ loader_path: str | None,+ tags: list[str],+ ) -> Asset:+ attempted.append(name)+ if name == "broken.bin":+ raise unrelated_errorreturn create_record(session_arg,- content_id,- name,- mime_type,- job_id,- loader_path,- tags,+ content_id=content_id,+ name=name,+ mime_type=mime_type,+ job_id=job_id,+ loader_path=loader_path,+ tags=tags,)monkeypatch.setattr("app.assets.scanner.create_record", _create_record_or_raise)- created = seed_asset_specs(session, specs)+ created, error = seed_asset_specs(session, [_spec(path) for path in paths])session.commit()+ assert error is unrelated_errorassert created == 2- assert _record_count(session) == 2+ assert attempted == ["first.bin", "broken.bin", "last.bin"]assert {record.name for record in session.scalars(select(Asset))} == {"first.bin","last.bin",- }, (- "the batch shares one transaction, so a bare rollback would erase the spec BEFORE "- f"the poisoned one; both neighbours of {poisoned_path.name} must survive"+ }+++def test_insert_commits_successful_specs_before_propagating_batch_fault(+ db_engine, temp_dir: Path, monkeypatch: pytest.MonkeyPatch+) -> None:+ paths = [temp_dir / name for name in ("first.bin", "broken.bin", "last.bin")]+ for path in paths:+ path.write_bytes(path.name.encode())++ @contextmanager+ def _create_session():+ with Session(db_engine) as session:+ yield session++ def _create_record_or_raise(+ session_arg: Session,+ *,+ content_id: str,+ name: str,+ mime_type: str | None,+ job_id: str | None,+ loader_path: str | None,+ tags: list[str],+ ) -> Asset:+ if name == "broken.bin":+ raise RuntimeError("forced record creation failure")+ return create_record(+ session_arg,+ content_id=content_id,+ name=name,+ mime_type=mime_type,+ job_id=job_id,+ loader_path=loader_path,+ tags=tags,+ )++ monkeypatch.setattr("app.assets.scanner.create_session", _create_session)+ monkeypatch.setattr("app.assets.scanner.create_write_session", _create_session)+ monkeypatch.setattr("app.assets.scanner.create_record", _create_record_or_raise)++ created, error = insert_asset_specs([_spec(path) for path in paths], set())++ with Session(db_engine) as session:+ assert {record.name for record in session.scalars(select(Asset))} == {+ "first.bin",+ "last.bin",+ }+ assert created == 2+ assert isinstance(error, RuntimeError)+ assert str(error) == "forced record creation failure"+++def test_seed_skips_negative_fresh_mtime_with_warning_and_telemetry(+ session: Session,+ temp_dir: Path,+ caplog: pytest.LogCaptureFixture,+) -> None:+ paths = [temp_dir / name for name in ("first.bin", "old.bin", "last.bin")]+ for path in paths:+ path.write_bytes(path.name.encode())+ pre_epoch_ns = -315_547_200_000_000_000+ os.utime(paths[1], ns=(pre_epoch_ns, pre_epoch_ns))++ with caplog.at_level(logging.INFO):+ created, error = seed_asset_specs(session, [_spec(path) for path in paths])+ session.commit()++ assert error is None+ assert created == 2+ assert {record.name for record in session.scalars(select(Asset))} == {+ "first.bin",+ "last.bin",+ }+ assert any(+ record.getMessage() == f"Skipping asset with invalid mtime during scan: {paths[1]}"+ for record in caplog.records)+ assert [+ record.getMessage()+ for record in caplog.records+ if record.getMessage().startswith("[assets-event] scanner.invalid_mtime")+ ] == ["[assets-event] scanner.invalid_mtime count=1"]+++def test_seed_emits_one_invalid_mtime_event_for_a_whole_batch_of_pre_epoch_files(+ session: Session,+ temp_dir: Path,+ caplog: pytest.LogCaptureFixture,+) -> None:+ paths = [temp_dir / f"restored-{index}.bin" for index in range(5)]+ pre_epoch_ns = -315_547_200_000_000_000+ for path in paths:+ _ = path.write_bytes(path.name.encode())+ os.utime(path, ns=(pre_epoch_ns, pre_epoch_ns))++ with caplog.at_level(logging.INFO):+ created, error = seed_asset_specs(session, [_spec(path) for path in paths])+ session.commit()++ assert error is None+ assert created == 0+ assert _record_count(session) == 0+ assert [+ record.getMessage()+ for record in caplog.records+ if record.getMessage().startswith("[assets-event] scanner.invalid_mtime")+ ] == ["[assets-event] scanner.invalid_mtime count=5"]+ assert [+ record.getMessage()+ for record in caplog.records+ if record.getMessage().startswith("Skipping asset with invalid mtime")+ ] == [f"Skipping asset with invalid mtime during scan: {path}" for path in paths]def test_seed_persists_fresh_stat_after_spec_was_built(@@ -197,12 +417,13 @@ def test_seed_persists_fresh_stat_after_spec_was_built(os.utime(path, ns=(fresh_mtime_ns, fresh_mtime_ns))fresh_stat = path.stat()- created = seed_asset_specs(session, [spec])+ created, error = seed_asset_specs(session, [spec])session.commit()persisted = session.scalar(select(AssetContent).where(AssetContent.path == str(path)))+ assert error is Noneassert created == 1assert fresh_stat.st_size != spec["size_bytes"]assert fresh_stat.st_mtime_ns != spec["mtime_ns"]@@ -234,8 +455,10 @@ def test_seed_record_failure_preserves_retained_live_content(monkeypatch.setattr("app.assets.scanner.create_record", _raise_record_creation)- with pytest.raises(RuntimeError, match="forced record creation failure"):- seed_asset_specs(session, [spec])+ created, error = seed_asset_specs(session, [spec])session.rollback()+ assert created == 0+ assert isinstance(error, RuntimeError)+ assert str(error) == "forced record creation failure"assert session.get(AssetContent, retained_content_id) is not Nonediff --git a/tests-unit/assets_test/services/test_snapshot_hash_import.py b/tests-unit/assets_test/services/test_snapshot_hash_import.pynew file mode 100644index 000000000..1d60f961f--- /dev/null+++ b/tests-unit/assets_test/services/test_snapshot_hash_import.py@@ -0,0 +1,38 @@+import builtins+import importlib.util+import sys+from pathlib import Path+from unittest.mock import patch++import pytest+++def test_snapshot_hash_defers_and_chains_blake3_import_failure(tmp_path: Path) -> None:+ real_import = builtins.__import__+ blake3_import_error = ImportError("simulated blake3 ABI failure")++ def import_without_blake3(name, globals=None, locals=None, fromlist=(), level=0):+ if name == "blake3" or name.startswith("blake3."):+ raise blake3_import_error+ return real_import(name, globals, locals, fromlist, level)++ module_path = Path(__file__).parents[3] / "app/assets/services/snapshot_hash.py"+ spec = importlib.util.spec_from_file_location(+ "isolated_snapshot_hash_import_guard", module_path+ )+ assert spec is not None+ assert spec.loader is not None+ snapshot_hash_module = importlib.util.module_from_spec(spec)+ sys.modules[spec.name] = snapshot_hash_module+ try:+ with patch("builtins.__import__", side_effect=import_without_blake3):+ spec.loader.exec_module(snapshot_hash_module)++ path = tmp_path / "asset.bin"+ path.write_bytes(b"hash me")+ with pytest.raises(ModuleNotFoundError) as error_info:+ snapshot_hash_module.snapshot_hash(str(path))++ assert error_info.value.__cause__ is blake3_import_error+ finally:+ sys.modules.pop(spec.name, None)diff --git a/tests-unit/assets_test/services/test_transition_settle.py b/tests-unit/assets_test/services/test_transition_settle.pyindex 3da231ba5..9e9bd4118 100644--- a/tests-unit/assets_test/services/test_transition_settle.py+++ b/tests-unit/assets_test/services/test_transition_settle.py@@ -1,12 +1,14 @@from contextlib import contextmanagerfrom pathlib import Path+import threadingfrom unittest.mock import patchimport pytest+from sqlalchemy.dialects import sqlitefrom sqlalchemy.orm import Session as SASessionfrom app.assets import scanner, seeder as seeder_module-from app.assets.database.models import AssetContent+from app.assets.database.models import Asset, AssetContentfrom app.assets.database.queries.records import create_content, create_recordfrom app.assets.helpers import to_stored_hashfrom app.assets.services import hash_mode_state@@ -37,6 +39,35 @@ def _denied(_candidate_path: str):raise PermissionError("denied")+def _rendered_candidate_placeholder_count(failed_count: int) -> int:+ failed_ids = [f"{index:036d}" for index in range(failed_count)]+ statement = scanner.build_unenriched_candidates_statement(+ prefixes=["/models"],+ compute_hashes=False,+ last_seen_id=failed_ids[-1],+ limit=100,+ )+ compiled = statement.compile(+ dialect=sqlite.dialect(),+ compile_kwargs={"render_postcompile": True},+ )+ rendered_count = str(compiled).count("?")++ assert compiled.positiontup is not None+ assert len(compiled.positiontup) == rendered_count+ return rendered_count+++def test_unenriched_candidate_bind_count_does_not_scale_with_failed_rows() -> None:+ count_for_ten = _rendered_candidate_placeholder_count(10)+ count_for_thousand = _rendered_candidate_placeholder_count(1000)++ assert count_for_ten == count_for_thousand, (+ "rendered placeholders scaled with failed candidates: "+ f"N=10 -> {count_for_ten}; N=1000 -> {count_for_thousand}"+ )++def test_enrich_phase_settles_an_unreadable_transition_without_looping(session, db_engine, temp_dir: Path, monkeypatch):@@ -106,3 +137,202 @@ def test_enrich_phase_settles_an_unreadable_transition_without_looping(assert attempts == [record_id], ("the record is attempted once, then excluded from the rest of the pass")+++def test_enrich_phase_reaches_healthy_candidates_after_a_full_failed_batch(+ session, db_engine, temp_dir: Path, monkeypatch+):+ for index in range(101):+ path = temp_dir / f"candidate-{index}.safetensors"+ content = create_content(session, str(path))+ create_record(session, content.id, path.name)+ session.commit()++ @contextmanager+ def _create_session():+ with SASession(db_engine) as sess:+ yield sess++ monkeypatch.setattr("folder_paths.get_input_directory", lambda: str(temp_dir))+ with patch("app.assets.scanner.create_session", _create_session):+ ordered = scanner.get_unenriched_assets_for_roots(+ ("input",), compute_hashes=False, limit=101+ )++ failed_ids = {row.record_id for row in ordered[:100]}+ healthy = ordered[100]+ attempted: list[str] = []++ def enrich_batch(rows, **_kwargs):+ attempted.extend(row.record_id for row in rows)+ failed = [row.record_id for row in rows if row.record_id in failed_ids]+ if healthy.record_id in attempted:+ with SASession(db_engine) as update_session:+ record = update_session.get(Asset, healthy.record_id)+ assert record is not None+ record.system_metadata = {"enriched": True}+ update_session.commit()+ return 1, failed, len(rows)+ return 0, failed, len(rows)++ asset_seeder = seeder_module._AssetSeeder()+ asset_seeder._run_gate.set()+ asset_seeder._cancel_event.clear()++ with (+ patch("app.assets.seeder.create_session", _create_session),+ patch("app.assets.scanner.create_session", _create_session),+ patch("app.assets.seeder.enrich_assets_batch", enrich_batch),+ ):+ cancelled, enriched = asset_seeder._run_enrich_phase(("input",))++ assert cancelled is False+ assert enriched == 1+ assert healthy.record_id in attempted+++def test_enrich_phase_reaches_healthy_candidates_after_four_failed_batches(+ db_engine, monkeypatch+):+ failed_batches = [+ [scanner.UnenrichedContent(f"content-{index}", f"record-{index}", f"/{index}")]+ for index in range(4)+ ]+ healthy = scanner.UnenrichedContent("healthy-content", "healthy-record", "/healthy")+ batches = iter([*failed_batches, [healthy], []])+ attempted: list[str] = []++ @contextmanager+ def _create_session():+ with SASession(db_engine) as sess:+ yield sess++ def enrich_batch(rows, **_kwargs):+ attempted.extend(row.record_id for row in rows)+ if healthy in rows:+ return 1, [], len(rows)+ return 0, [row.record_id for row in rows], len(rows)++ asset_seeder = seeder_module._AssetSeeder()+ asset_seeder._run_gate.set()+ asset_seeder._cancel_event.clear()+ monkeypatch.setattr(+ seeder_module,+ "get_unenriched_assets_for_roots",+ lambda *_args, **_kwargs: next(batches),+ )+ monkeypatch.setattr(seeder_module, "enrich_assets_batch", enrich_batch)++ with patch("app.assets.seeder.create_session", _create_session):+ cancelled, enriched = asset_seeder._run_enrich_phase(("input",))++ assert cancelled is False+ assert enriched == 1+ assert attempted == [+ "record-0",+ "record-1",+ "record-2",+ "record-3",+ "healthy-record",+ ]++[email protected]("interrupt_after", [0, 1], ids=["before-first", "partway"])+def test_enrich_phase_reoffers_rows_not_attempted_before_pause(+ db_engine,+ monkeypatch: pytest.MonkeyPatch,+ interrupt_after: int,+) -> None:+ rows = [+ scanner.UnenrichedContent(+ f"content-{index}", f"record-{index}", f"/{index}"+ )+ for index in range(3)+ ]+ fetch_cursors: list[str | None] = []+ offered_batches: list[list[str]] = []+ attempted: list[str] = []+ pause_blocked = threading.Event()+ interruption_triggered = False++ @contextmanager+ def _create_session():+ with SASession(db_engine) as sess:+ yield sess++ asset_seeder = seeder_module._AssetSeeder()+ asset_seeder._run_gate.set()+ asset_seeder._cancel_event.clear()+ asset_seeder.set_event_sink(+ lambda event_type, _data: pause_blocked.set()+ if event_type == "assets.seed.paused"+ else None+ )++ def get_candidates(+ _roots,+ compute_hashes,+ limit=1000,+ last_seen_id=None,+ ):+ nonlocal interruption_triggered+ candidates = [+ row+ for row in rows+ if last_seen_id is None or row.record_id > last_seen_id+ ][:limit]+ fetch_cursors.append(last_seen_id)+ offered_batches.append([row.record_id for row in candidates])+ if interrupt_after == 0 and not interruption_triggered:+ interruption_triggered = True+ asset_seeder._run_gate.clear()+ return candidates++ def enrich_asset(*_args, **kwargs) -> bool:+ nonlocal interruption_triggered+ attempted.append(kwargs["record_id"])+ if len(attempted) == interrupt_after and not interruption_triggered:+ interruption_triggered = True+ asset_seeder._run_gate.clear()+ return True++ result: list[tuple[bool, int]] = []+ errors: list[BaseException] = []++ def run_enrich_phase() -> None:+ try:+ result.append(asset_seeder._run_enrich_phase(("input",)))+ except BaseException as exc:+ errors.append(exc)++ monkeypatch.setattr(+ seeder_module, "get_unenriched_assets_for_roots", get_candidates+ )+ monkeypatch.setattr(scanner, "enrich_asset", enrich_asset)++ with (+ patch("app.assets.seeder.create_session", _create_session),+ patch("app.assets.scanner.create_session", _create_session),+ ):+ worker = threading.Thread(target=run_enrich_phase, daemon=True)+ worker.start()+ try:+ assert pause_blocked.wait(timeout=2), (+ "the enrich loop did not block at its loop-top pause checkpoint"+ )+ assert fetch_cursors == [None]+ assert worker.is_alive()+ finally:+ asset_seeder._run_gate.set()+ worker.join(timeout=2)++ assert worker.is_alive() is False+ assert errors == []+ assert result == [(False, 3)]+ assert attempted == [row.record_id for row in rows]+ assert offered_batches[1] == [+ row.record_id for row in rows[interrupt_after:]+ ]+ assert fetch_cursors[1] == (+ None if interrupt_after == 0 else rows[interrupt_after - 1].record_id+ )diff --git a/tests-unit/assets_test/services/test_updated_at_semantics.py b/tests-unit/assets_test/services/test_updated_at_semantics.pyindex bfd17082b..99e9f3328 100644--- a/tests-unit/assets_test/services/test_updated_at_semantics.py+++ b/tests-unit/assets_test/services/test_updated_at_semantics.py@@ -111,6 +111,18 @@ def test_rename_moves_updated_at(session, mock_create_session, temp_dir):assert _updated_at(session, record.id) > STALE, "a rename is an explicit user edit"+def test_same_name_rename_does_not_move_updated_at(+ session, mock_create_session, temp_dir+):+ record = _seed_record(session, _write_file(temp_dir, "rename-noop.bin"))++ update_asset_metadata(record.id, name=record.name)++ assert _updated_at(session, record.id) == STALE, (+ "requesting the existing name changes nothing"+ )++@pytest.mark.parametrize("field,kwargs",[diff --git a/tests-unit/assets_test/services/test_upload_temp_cleanup.py b/tests-unit/assets_test/services/test_upload_temp_cleanup.pynew file mode 100644index 000000000..b87248a0a--- /dev/null+++ b/tests-unit/assets_test/services/test_upload_temp_cleanup.py@@ -0,0 +1,187 @@+import asyncio+import uuid+from pathlib import Path+from unittest.mock import AsyncMock++import pytest++import folder_paths+from app.assets.api.schemas_in import UploadError+from app.assets.api.upload import parse_multipart_upload+from app.assets.services.ingest import upload_from_temp_path+++async def test_multipart_id_after_file_removes_temp_upload(+ tmp_path: Path, monkeypatch: pytest.MonkeyPatch+) -> None:+ monkeypatch.setattr(folder_paths, "get_temp_directory", lambda: str(tmp_path))++ file_field = AsyncMock()+ file_field.name = "file"+ file_field.filename = "model.safetensors"+ file_field.read_chunk.side_effect = [b"uploaded bytes", b""]++ id_field = AsyncMock()+ id_field.name = "id"++ reader = AsyncMock()+ reader.next.side_effect = [file_field, id_field, None]++ request = AsyncMock()+ request.content_type = "multipart/form-data"+ request.multipart.return_value = reader++ with pytest.raises(UploadError, match="Client-provided 'id' is not supported"):+ await parse_multipart_upload(request, lambda _hash: False)++ assert list((tmp_path / "uploads").iterdir()) == []+++def _file_field() -> AsyncMock:+ field = AsyncMock()+ field.name = "file"+ field.filename = "model.safetensors"+ field.read_chunk.side_effect = [b"uploaded bytes", b""]+ return field+++def _multipart_request(*fields: AsyncMock) -> AsyncMock:+ reader = AsyncMock()+ reader.next.side_effect = [*fields, None]+ request = AsyncMock()+ request.content_type = "multipart/form-data"+ request.multipart.return_value = reader+ return request+++async def test_duplicate_file_parts_are_rejected_without_leaking_temp_uploads(+ tmp_path: Path, monkeypatch: pytest.MonkeyPatch+) -> None:+ monkeypatch.setattr(folder_paths, "get_temp_directory", lambda: str(tmp_path))+ request = _multipart_request(_file_field(), _file_field())++ error: UploadError | None = None+ try:+ await parse_multipart_upload(request, lambda _hash: False)+ except UploadError as exc:+ error = exc++ remaining = list((tmp_path / "uploads").iterdir())+ assert error is not None, f"duplicate file parts accepted; temp paths remain: {remaining}"+ assert error.status == 400+ assert error.code == "UNSUPPORTED_FIELD"+ assert error.message == "Multiple 'file' parts are not supported."+ assert remaining == []+++async def test_invalid_utf8_after_file_removes_temp_upload(+ tmp_path: Path, monkeypatch: pytest.MonkeyPatch+) -> None:+ monkeypatch.setattr(folder_paths, "get_temp_directory", lambda: str(tmp_path))+ tags_field = AsyncMock()+ tags_field.name = "tags"+ tags_field.text.side_effect = UnicodeDecodeError(+ "utf-8", b"\xff", 0, 1, "invalid start byte"+ )+ request = _multipart_request(_file_field(), tags_field)++ with pytest.raises(UnicodeDecodeError):+ await parse_multipart_upload(request, lambda _hash: False)++ assert list((tmp_path / "uploads").iterdir()) == []+++async def test_malformed_framing_after_file_removes_temp_upload(+ tmp_path: Path, monkeypatch: pytest.MonkeyPatch+) -> None:+ monkeypatch.setattr(folder_paths, "get_temp_directory", lambda: str(tmp_path))+ request = _multipart_request(_file_field())+ request.multipart.return_value.next.side_effect = [+ _file_field(),+ ValueError("Reading after EOF"),+ ]++ with pytest.raises(ValueError, match="Reading after EOF"):+ await parse_multipart_upload(request, lambda _hash: False)++ assert list((tmp_path / "uploads").iterdir()) == []+++async def test_cancelled_upload_removes_temp_upload(+ tmp_path: Path, monkeypatch: pytest.MonkeyPatch+) -> None:+ monkeypatch.setattr(folder_paths, "get_temp_directory", lambda: str(tmp_path))+ request = _multipart_request(_file_field())+ request.multipart.return_value.next.side_effect = [+ _file_field(),+ asyncio.CancelledError(),+ ]++ with pytest.raises(asyncio.CancelledError):+ await parse_multipart_upload(request, lambda _hash: False)++ assert list((tmp_path / "uploads").iterdir()) == []+++async def test_successful_parse_returns_consumable_temp_upload(+ tmp_path: Path, monkeypatch: pytest.MonkeyPatch+) -> None:+ monkeypatch.setattr(folder_paths, "get_temp_directory", lambda: str(tmp_path))+ request = _multipart_request(_file_field())++ parsed = await parse_multipart_upload(request, lambda _hash: False)++ assert parsed.tmp_path is not None+ assert Path(parsed.tmp_path).read_bytes() == b"uploaded bytes"+++def test_destination_resolution_failure_removes_temp_upload(+ mock_create_session, tmp_path: Path+) -> None:+ upload_dir = tmp_path / "uploads" / uuid.uuid4().hex+ upload_dir.mkdir(parents=True)+ temp_path = upload_dir / ".upload.part"+ temp_path.write_bytes(b"uploaded bytes")++ with pytest.raises(ValueError, match="exactly one destination role"):+ upload_from_temp_path(+ temp_path=str(temp_path),+ name="model.safetensors",+ tags=["not-a-destination"],+ client_filename="model.safetensors",+ )++ assert not temp_path.exists()+ assert not upload_dir.exists()+++def test_successful_upload_reaps_empty_per_upload_directory(+ mock_create_session,+ tmp_path: Path,+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ temp_root = tmp_path / "temp"+ output_root = tmp_path / "output"+ monkeypatch.setattr(folder_paths, "get_temp_directory", lambda: str(temp_root))+ monkeypatch.setattr(folder_paths, "get_output_directory", lambda: str(output_root))++ upload_dir = temp_root / "uploads" / uuid.uuid4().hex+ upload_dir.mkdir(parents=True)+ temp_path = upload_dir / ".upload.part"+ temp_path.write_bytes(b"uploaded bytes")++ result = upload_from_temp_path(+ temp_path=str(temp_path),+ name="model.safetensors",+ tags=["output"],+ client_filename="model.safetensors",+ )++ assert result.created_new is True+ assert not upload_dir.exists()diff --git a/tests-unit/assets_test/test_event_log.py b/tests-unit/assets_test/test_event_log.pyindex 27c9bba13..dccdfadc0 100644--- a/tests-unit/assets_test/test_event_log.py+++ b/tests-unit/assets_test/test_event_log.py@@ -168,7 +168,9 @@ def test_unknown_field_raises_under_pytest():emit("seeder.scan_started", path="/home/x/models")[email protected]("value", ["a/b", "a\\b", "a:b", "a b", "a=b", 'a"b'])+ "value", ["a/b", "a\\b", "a:b", "a b", "a=b", 'a"b', "a\nb", "a\rb"]+)def test_a_string_value_carrying_a_forbidden_character_raises(value):with pytest.raises(EventLogError):emit("seeder.scan_failed", error_type=value)diff --git a/tests-unit/assets_test/test_intended_behaviour.py b/tests-unit/assets_test/test_intended_behaviour.pyindex 19a00e4c1..9018bc329 100644--- a/tests-unit/assets_test/test_intended_behaviour.py+++ b/tests-unit/assets_test/test_intended_behaviour.py@@ -111,7 +111,10 @@ def _scan_pass(session, root: Path) -> int:specs, _tag_pool, _skipped = build_asset_specs(list_files_recursively(str(root)), survivors or set())- return seed_asset_specs(session, specs)+ created, error = seed_asset_specs(session, specs)+ if error is not None:+ raise error+ return created@contextmanagerdiff --git a/tests-unit/assets_test/test_scanner_ingest_event_log.py b/tests-unit/assets_test/test_scanner_ingest_event_log.pyindex f6eb62803..b3ae050ce 100644--- a/tests-unit/assets_test/test_scanner_ingest_event_log.py+++ b/tests-unit/assets_test/test_scanner_ingest_event_log.py@@ -390,8 +390,8 @@ def test_enrich_failures_emit_once_per_scan_and_reset_with_new_scan(first_result = scanner.enrich_assets_batch(rows, progress=_ScanState())second_result = scanner.enrich_assets_batch(rows[:1], progress=_ScanState())- assert first_result == (0, ["record-1", "record-2"])- assert second_result == (0, ["record-1"])+ assert first_result == (0, ["record-1", "record-2"], 2)+ assert second_result == (0, ["record-1"], 1)assert events_named(caplog, "scanner.enrich_failed") == [{"error_type": "FileNotFoundError"},{"error_type": "FileNotFoundError"},@@ -413,10 +413,13 @@ def test_enrich_exception_counts_one_failure_per_raising_row(monkeypatch.setattr(scanner, "enrich_asset", fail_enrich)progress = _ScanState()- enriched, failed_ids = scanner.enrich_assets_batch(rows, progress=progress)+ enriched, failed_ids, consumed = scanner.enrich_assets_batch(+ rows, progress=progress+ )assert enriched == 0assert failed_ids == ["record-1", "record-2"]+ assert consumed == 2assert progress.enrich_failed == 2@@ -429,8 +432,11 @@ def test_benign_enrich_no_op_is_skipped_without_counting_a_failure(monkeypatch.setattr(scanner, "create_session", lambda: nullcontext(Mock()))progress = _ScanState()- enriched, failed_ids = scanner.enrich_assets_batch(rows, progress=progress)+ enriched, failed_ids, consumed = scanner.enrich_assets_batch(+ rows, progress=progress+ )assert enriched == 0assert failed_ids == ["record-1"]+ assert consumed == 1assert progress.enrich_failed == 0diff --git a/tests-unit/feature_flags_test.py b/tests-unit/feature_flags_test.pyindex df16df6ab..2ee505870 100644--- a/tests-unit/feature_flags_test.py+++ b/tests-unit/feature_flags_test.py@@ -39,6 +39,11 @@ class TestFeatureFlags:assert "max_upload_size" in featuresassert isinstance(features["max_upload_size"], (int, float))+ def test_get_server_features_reports_the_assets_flag_without_an_argument(self, monkeypatch):+ """A no-argument call must report the current assets flag, not a default."""+ monkeypatch.setitem(SERVER_FEATURE_FLAGS, "assets", True)+ assert get_server_features()["assets"] is True+def test_get_connection_feature_with_missing_sid(self):"""Test getting feature for non-existent session ID."""sockets_metadata = {}diff --git a/tests-unit/seeder_test/test_seeder.py b/tests-unit/seeder_test/test_seeder.pyindex e18a224ee..ea49b9e0b 100644--- a/tests-unit/seeder_test/test_seeder.py+++ b/tests-unit/seeder_test/test_seeder.py@@ -1,18 +1,22 @@import loggingimport reimport threading-from contextlib import nullcontext+from contextlib import contextmanager, nullcontext+from pathlib import Pathfrom unittest.mock import Mockimport pytest-from sqlalchemy import create_engine+from sqlalchemy import create_engine, select+from sqlalchemy.engine import Enginefrom sqlalchemy.orm import Session+from app.assets import scanner as scanner_modulefrom app.assets import seeder as seeder_module-from app.assets.database.models import Base+from app.assets.database.models import Asset, Basefrom app.assets.database.queries import create_content, create_record, mark_content_missingfrom app.assets.event_log import TAG-from app.assets.seeder import ScanPhase, State, _AssetSeeder, _ScanStage, _ScanState+from app.assets.scanner import SeedAssetSpec+from app.assets.seeder import Progress, ScanPhase, State, _AssetSeeder, _ScanStage, _ScanStateEVENT_LINE_PATTERN = re.compile(@@ -67,6 +71,109 @@ def events_named(return [fields for event, fields in tagged_events(caplog) if event == event_name]+def _seed_spec(path: Path) -> SeedAssetSpec:+ stat_result = path.stat()+ return {+ "abs_path": str(path),+ "size_bytes": stat_result.st_size,+ "mtime_ns": stat_result.st_mtime_ns,+ "info_name": path.name,+ "tags": ["input"],+ "fname": path.name,+ "metadata": None,+ "mime_type": None,+ "job_id": None,+ }+++def _configure_fast_phase(+ monkeypatch: pytest.MonkeyPatch,+ paths: list[Path],+ specs: list[SeedAssetSpec],+) -> None:+ monkeypatch.setattr(+ seeder_module, "sync_root_safely", lambda _root, _progress: set()+ )+ monkeypatch.setattr(+ seeder_module, "collect_paths_for_roots", lambda _roots: [str(path) for path in paths]+ )+ monkeypatch.setattr(+ seeder_module,+ "build_asset_specs",+ lambda *_args, **_kwargs: (specs, set(), 0),+ )+ watch_session = Mock()+ monkeypatch.setattr(seeder_module, "create_session", lambda: nullcontext(watch_session))+ monkeypatch.setattr(seeder_module, "tick_watch_list", lambda: None)+++def _run_faulting_fast_phase(+ scan_seeder: _AssetSeeder,+ monkeypatch: pytest.MonkeyPatch,+ tmp_path: Path,+ original_fault: Exception,+ commit_failure: Exception | None = None,+) -> tuple[Engine, tuple[int, int, int]]:+ engine = create_engine("sqlite:///:memory:")+ Base.metadata.create_all(engine)+ paths = [tmp_path / name for name in ("first.bin", "broken.bin", "last.bin")]+ for path in paths:+ path.write_bytes(path.name.encode())+ specs = [_seed_spec(path) for path in paths]++ @contextmanager+ def database_session():+ with Session(engine) as session:+ if commit_failure is not None:+ session.connection().exec_driver_sql("BEGIN")+ monkeypatch.setattr(+ session, "commit", Mock(side_effect=commit_failure)+ )+ yield session++ def create_record_or_raise(+ session: Session,+ *,+ content_id: str,+ name: str,+ mime_type: str | None,+ job_id: str | None,+ loader_path: str | None,+ tags: list[str],+ ) -> Asset:+ if name == "broken.bin":+ raise original_fault+ return create_record(+ session,+ content_id=content_id,+ name=name,+ mime_type=mime_type,+ job_id=job_id,+ loader_path=loader_path,+ tags=tags,+ )++ monkeypatch.setattr(scanner_module, "create_session", database_session)+ monkeypatch.setattr(scanner_module, "create_write_session", database_session)+ monkeypatch.setattr(scanner_module, "create_record", create_record_or_raise)+ monkeypatch.setattr(scanner_module.mode, "hashing_enabled", lambda: False)+ _configure_fast_phase(monkeypatch, paths, specs)+ return engine, scan_seeder._run_fast_phase(("models",))+++def test_idle_status_returns_a_progress_snapshot() -> None:+ seeder = _AssetSeeder()+ seeder._last_progress = Progress(created=1)++ status = seeder.get_status()+ assert status.progress is not None+ status.progress.created = 999++ next_status = seeder.get_status()+ assert next_status.progress is not None+ assert next_status.progress.created == 1++def test_seeder_models_missing_as_content_state():engine = create_engine("sqlite:///:memory:")Base.metadata.create_all(engine)@@ -165,7 +272,7 @@ def test_enrich_phase_does_not_count_returned_ids_as_failures(monkeypatch.setattr(seeder_module,"enrich_assets_batch",- lambda *_args, **_kwargs: (0, ["record-1", "record-2"]),+ lambda *_args, **_kwargs: (0, ["record-1", "record-2"], 2),)monkeypatch.setattr(scan_seeder, "_check_pause_and_cancel", lambda _stage: False)@@ -420,6 +527,61 @@ def test_standalone_mark_missing_emits_count_with_mark_missing_stage(]+def test_standalone_mark_missing_failure_returns_none_and_emits_no_success_event(+ scan_seeder: _AssetSeeder,+ monkeypatch: pytest.MonkeyPatch,+ caplog: pytest.LogCaptureFixture,+) -> None:+ scan_seeder._state = State.IDLE+ monkeypatch.setattr(seeder_module, "get_owned_prefixes", lambda: [])++ def fail_create_session():+ raise RuntimeError("database unavailable")++ monkeypatch.setattr(scanner_module, "create_session", fail_create_session)++ with caplog.at_level(logging.INFO):+ result = scan_seeder.mark_missing_outside_prefixes()++ assert result is None+ assert events_named(caplog, "scanner.mark_missing_failed") == [+ {"error_type": "RuntimeError"}+ ]+ assert events_named(caplog, "seeder.marked_missing") == []+++def test_scan_prune_failure_is_reported_and_the_scan_still_runs(+ scan_seeder: _AssetSeeder,+ monkeypatch: pytest.MonkeyPatch,+ caplog: pytest.LogCaptureFixture,+) -> None:+ scan_seeder._prune_first = True+ scan_seeder._phase = ScanPhase.FAST+ fast_phase_roots: list[tuple[str, ...]] = []+ monkeypatch.setattr(seeder_module, "get_owned_prefixes", lambda: [])+ monkeypatch.setattr(+ seeder_module, "mark_missing_outside_prefixes_safely", lambda _prefixes: None+ )+ monkeypatch.setattr(+ seeder_module, "sync_temp_references_safely", lambda _progress: None+ )++ def run_fast_phase(roots: tuple[str, ...]) -> tuple[int, int, int]:+ fast_phase_roots.append(roots)+ return 0, 0, 0++ monkeypatch.setattr(scan_seeder, "_run_fast_phase", run_fast_phase)++ with caplog.at_level(logging.INFO):+ scan_seeder._run_scan()++ assert scan_seeder._errors == [+ "Marking missing assets failed; scan continued without pruning"+ ]+ assert fast_phase_roots == [("models", "input")]+ assert events_named(caplog, "seeder.marked_missing") == []++def test_batch_insert_failure_emits_only_the_exception_type(scan_seeder: _AssetSeeder,monkeypatch: pytest.MonkeyPatch,@@ -459,21 +621,83 @@ def test_batch_insert_failure_emits_only_the_exception_type(assert "/private/models/asset.safetensors" not in tagged-def test_enrich_phase_commits_pending_verifications_before_ticking_watch_list(+def test_batch_insert_fault_reports_the_specs_committed_before_it(scan_seeder: _AssetSeeder,monkeypatch: pytest.MonkeyPatch,+ caplog: pytest.LogCaptureFixture,+ tmp_path: Path,) -> None:- calls: list[str] = []- session = Mock()- session.commit.side_effect = lambda: calls.append("commit")- monkeypatch.setattr(seeder_module, "create_session", lambda: nullcontext(session))- monkeypatch.setattr(- seeder_module, "drain_pending_verifications", lambda _session: calls.append("drain_pending")- )- monkeypatch.setattr(seeder_module, "tick_watch_list", lambda: calls.append("tick_watch_list"))- monkeypatch.setattr(seeder_module, "drain_transition_queue", lambda _session: None)- monkeypatch.setattr(scan_seeder, "_check_pause_and_cancel", lambda _stage: True)+ with caplog.at_level(logging.INFO):+ engine, result = _run_faulting_fast_phase(+ scan_seeder,+ monkeypatch,+ tmp_path,+ OSError("forced record creation failure"),+ )- scan_seeder._run_enrich_phase(("models",))+ with Session(engine) as session:+ assert {record.name for record in session.scalars(select(Asset))} == {+ "first.bin",+ "last.bin",+ }+ assert result == (2, 0, 3)+ assert scan_seeder._scan_state is not None+ assert scan_seeder._scan_state.created == 2+ assert scan_seeder._errors == [+ "Batch insert encountered an error at offset 0 after creating 2: "+ "forced record creation failure"+ ]+++def test_batch_memory_error_stops_the_scan_instead_of_continuing(+ scan_seeder: _AssetSeeder,+ monkeypatch: pytest.MonkeyPatch,+ tmp_path: Path,+) -> None:+ with pytest.raises(MemoryError):+ _run_faulting_fast_phase(+ scan_seeder,+ monkeypatch,+ tmp_path,+ MemoryError("out of memory"),+ )++ assert scan_seeder._errors == []+++def test_salvage_commit_failure_reports_the_original_batch_fault(+ scan_seeder: _AssetSeeder,+ monkeypatch: pytest.MonkeyPatch,+ caplog: pytest.LogCaptureFixture,+ tmp_path: Path,+) -> None:+ original_fault = OSError("No space left on device")+ commit_failure = RuntimeError("forced salvage commit failure")++ with caplog.at_level(logging.INFO):+ engine, result = _run_faulting_fast_phase(+ scan_seeder,+ monkeypatch,+ tmp_path,+ original_fault,+ commit_failure,+ )- assert calls[:3] == ["drain_pending", "commit", "tick_watch_list"]+ with Session(engine) as session:+ assert session.scalar(select(Asset)) is None+ assert result == (0, 0, 3)+ assert scan_seeder._errors == [+ "Batch insert encountered an error at offset 0 after creating 0: "+ "No space left on device"+ ]+ assert events_named(caplog, "seeder.batch_insert_failed") == [+ {"error_type": "OSError"}+ ]+ caller_logs = [+ record+ for record in caplog.records+ if record.getMessage().startswith("Batch insert encountered an error")+ ]+ assert len(caller_logs) == 1+ assert caller_logs[0].exc_info is not None+ assert caller_logs[0].exc_info[1] is original_faultdiff --git a/tests-unit/test_assets_event_log_static.py b/tests-unit/test_assets_event_log_static.pyindex cbab691de..f2315bc8b 100644--- a/tests-unit/test_assets_event_log_static.py+++ b/tests-unit/test_assets_event_log_static.py@@ -63,6 +63,16 @@ EXPECTED_CALL_SITES: frozenset[CallSite] = frozenset(# todo 16 - discovery/enrich stat failures, emit-once per scan per siteCallSite("app/assets/scanner.py", "build_asset_specs", "scanner.stat_failed"),CallSite("app/assets/scanner.py", "enrich_asset", "scanner.stat_failed"),+ CallSite("app/assets/scanner.py", "seed_asset_specs", "scanner.invalid_mtime"),+ CallSite(+ "app/assets/scanner_admission.py", "tick_watch_list", "scanner.watch_stat_failed"+ ),+ CallSite(+ "app/assets/scanner_admission.py", "tick_watch_list", "scanner.watch_spec_failed"+ ),+ CallSite(+ "app/assets/scanner_admission.py", "tick_watch_list", "scanner.watch_seed_failed"+ ),})@@ -124,19 +134,39 @@ def _resolve_aliases(tree: ast.Module) -> Aliases:return Aliases(frozenset(module), frozenset(emit), frozenset(error_type))+def _dotted_name(node: ast.expr) -> str | None:+ parts: list[str] = []+ while isinstance(node, ast.Attribute):+ parts.append(node.attr)+ node = node.value+ if not isinstance(node, ast.Name):+ return None+ parts.append(node.id)+ return ".".join(reversed(parts))++def _is_emit_call(func: ast.expr, aliases: Aliases) -> bool:- if isinstance(func, ast.Attribute) and func.attr == "emit" and isinstance(func.value, ast.Name):- return func.value.id in aliases.module+ if isinstance(func, ast.Attribute) and func.attr == "emit":+ return _dotted_name(func.value) in aliases.modulereturn isinstance(func, ast.Name) and func.id in aliases.emit+def _is_unresolvable_emit_call(func: ast.expr, aliases: Aliases) -> bool:+ return (+ bool(aliases.module)+ and isinstance(func, ast.Attribute)+ and func.attr == "emit"+ and _dotted_name(func.value) is None+ )++def _is_error_type_call(value: ast.expr, aliases: Aliases) -> bool:"""True only for a call to the sanctioned event_log.error_type()."""if not isinstance(value, ast.Call):return Falsefunc = value.func- if isinstance(func, ast.Attribute) and func.attr == "error_type" and isinstance(func.value, ast.Name):- return func.value.id in aliases.module+ if isinstance(func, ast.Attribute) and func.attr == "error_type":+ return _dotted_name(func.value) in aliases.modulereturn isinstance(func, ast.Name) and func.id in aliases.error_type@@ -177,7 +207,9 @@ def _field_faults(call: ast.Call, aliases: Aliases) -> Iterator[tuple[str, str]]def _file_faults(call: ast.Call, aliases: Aliases) -> Iterator[tuple[str, str]]:- if _is_emit_call(call.func, aliases):+ if _is_unresolvable_emit_call(call.func, aliases):+ yield "event_names", "the emit receiver cannot be resolved statically"+ elif _is_emit_call(call.func, aliases):event = _event_of(call)if event not in ALLOWED_EVENTS:yield "event_names", "the event must be one string literal in the allowed vocabulary"@@ -203,6 +235,12 @@ def _scan_file(root: Path, relative: str) -> tuple[Counter[CallSite], list[tuplereturn sites, faults+def _write_scan_fixture(root: Path, relative: str, source: str) -> None:+ path = root / relative+ path.parent.mkdir(parents=True)+ path.write_text(source, encoding="utf-8")++def scan_repository(root: Path = REPO_ROOT) -> Scan:files = _scanned_files(root)sites: Counter[CallSite] = Counter()@@ -258,3 +296,37 @@ def test_call_sites_match_the_manifest() -> None:"EXPECTED_CALL_SITES")assert not missing, f"manifest call sites absent from the tree: {sorted(missing)}"+++def test_qualified_event_log_import_is_scanned(tmp_path: Path) -> None:+ relative = "app/assets/qualified.py"+ _write_scan_fixture(+ tmp_path,+ relative,+ "import app.assets.event_log\n\n"+ "def probe():\n"+ ' app.assets.event_log.emit("seeder.scan_started", phase="fast")\n',+ )++ sites, faults = _scan_file(tmp_path, relative)++ assert faults == []+ assert sites == Counter(+ {CallSite(relative, "probe", "seeder.scan_started"): 1}+ )+++def test_unresolvable_emit_receiver_is_a_scan_failure(tmp_path: Path) -> None:+ relative = "app/assets/dynamic.py"+ _write_scan_fixture(+ tmp_path,+ relative,+ "from app.assets import event_log\n\n"+ "def probe(provider):\n"+ ' provider().emit("seeder.scan_started", phase="fast")\n',+ )++ sites, faults = _scan_file(tmp_path, relative)++ assert sites == Counter()+ assert [category for category, _reason in faults] == ["event_names"]