Add TypedDict types to scanner and bulk_ingest

Amp-Thread-ID: https://ampcode.com/threads/T-019c2af9-4d41-73e9-b38d-78d06bc28a3f
Co-authored-by: Amp <amp@ampcode.com>

.coderabbit.yaml

@@ -1,127 +0,0 @@
-# yaml-language-server: $schema=https://coderabbit.ai/integrations/schema.v2.json
-language: "en-US"
-early_access: false
-tone_instructions: "Only comment on issues introduced by this PR's changes. Do not flag pre-existing problems in moved, re-indented, or reformatted code."
-
-reviews:
-  profile: "chill"
-  request_changes_workflow: false
-  high_level_summary: false
-  poem: false
-  review_status: false
-  review_details: false
-  commit_status: true
-  collapse_walkthrough: true
-  changed_files_summary: false
-  sequence_diagrams: false
-  estimate_code_review_effort: false
-  assess_linked_issues: false
-  related_issues: false
-  related_prs: false
-  suggested_labels: false
-  auto_apply_labels: false
-  suggested_reviewers: false
-  auto_assign_reviewers: false
-  in_progress_fortune: false
-  enable_prompt_for_ai_agents: true
-
-  path_filters:
-    - "!comfy_api_nodes/apis/**"
-    - "!**/generated/*.pyi"
-    - "!.ci/**"
-    - "!script_examples/**"
-    - "!**/__pycache__/**"
-    - "!**/*.ipynb"
-    - "!**/*.png"
-    - "!**/*.bat"
-
-  path_instructions:
-    - path: "**"
-      instructions: |
-        IMPORTANT: Only comment on issues directly introduced by this PR's code changes.
-        Do NOT flag pre-existing issues in code that was merely moved, re-indented,
-        de-indented, or reformatted without logic changes. If code appears in the diff
-        only due to whitespace or structural reformatting (e.g., removing a `with:` block),
-        treat it as unchanged. Contributors should not feel obligated to address
-        pre-existing issues outside the scope of their contribution.
-    - path: "comfy/**"
-      instructions: |
-        Core ML/diffusion engine. Focus on:
-        - Backward compatibility (breaking changes affect all custom nodes)
-        - Memory management and GPU resource handling
-        - Performance implications in hot paths
-        - Thread safety for concurrent execution
-    - path: "comfy_api_nodes/**"
-      instructions: |
-        Third-party API integration nodes. Focus on:
-        - No hardcoded API keys or secrets
-        - Proper error handling for API failures (timeouts, rate limits, auth errors)
-        - Correct Pydantic model usage
-        - Security of user data passed to external APIs
-    - path: "comfy_extras/**"
-      instructions: |
-        Community-contributed extra nodes. Focus on:
-        - Consistency with node patterns (INPUT_TYPES, RETURN_TYPES, FUNCTION, CATEGORY)
-        - No breaking changes to existing node interfaces
-    - path: "comfy_execution/**"
-      instructions: |
-        Execution engine (graph execution, caching, jobs). Focus on:
-        - Caching correctness
-        - Concurrent execution safety
-        - Graph validation edge cases
-    - path: "nodes.py"
-      instructions: |
-        Core node definitions (2500+ lines). Focus on:
-        - Backward compatibility of NODE_CLASS_MAPPINGS
-        - Consistency of INPUT_TYPES return format
-    - path: "alembic_db/**"
-      instructions: |
-        Database migrations. Focus on:
-        - Migration safety and rollback support
-        - Data preservation during schema changes
-
-  auto_review:
-    enabled: true
-    auto_incremental_review: true
-    drafts: false
-    ignore_title_keywords:
-      - "WIP"
-      - "DO NOT REVIEW"
-      - "DO NOT MERGE"
-
-  finishing_touches:
-    docstrings:
-      enabled: false
-    unit_tests:
-      enabled: false
-
-  tools:
-    ruff:
-      enabled: false
-    pylint:
-      enabled: false
-    flake8:
-      enabled: false
-    gitleaks:
-      enabled: true
-    shellcheck:
-      enabled: false
-    markdownlint:
-      enabled: false
-    yamllint:
-      enabled: false
-    languagetool:
-      enabled: false
-    github-checks:
-      enabled: true
-      timeout_ms: 90000
-    ast-grep:
-      essential_rules: true
-
-chat:
-  auto_reply: true
-
-knowledge_base:
-  opt_out: false
-  learnings:
-    scope: "auto"

.github/ISSUE_TEMPLATE/bug-report.yml

@@ -16,7 +16,7 @@ body:
 
         ## Very Important
 
-        Please make sure that you post ALL your ComfyUI logs in the bug report **even if there is no crash**. Just paste everything. The startup log (everything before "To see the GUI go to: ...") contains critical information to developers trying to help. For a performance issue or crash, paste everything from "got prompt" to the end, including the crash. More is better - always. A bug report without logs will likely be ignored.
+        Please make sure that you post ALL your ComfyUI logs in the bug report. A bug report without logs will likely be ignored.
   - type: checkboxes
     id: custom-nodes-test
     attributes:

.github/scripts/check-ai-co-authors.sh

@@ -1,103 +0,0 @@
-#!/usr/bin/env bash
-# Checks pull request commits for AI agent Co-authored-by trailers.
-# Exits non-zero when any are found and prints fix instructions.
-set -euo pipefail
-
-base_sha="${1:?usage: check-ai-co-authors.sh <base_sha> <head_sha>}"
-head_sha="${2:?usage: check-ai-co-authors.sh <base_sha> <head_sha>}"
-
-# Known AI coding-agent trailer patterns (case-insensitive).
-# Each entry is an extended-regex fragment matched against Co-authored-by lines.
-AGENT_PATTERNS=(
-    # Anthropic — Claude Code / Amp
-    'noreply@anthropic\.com'
-    # Cursor
-    'cursoragent@cursor\.com'
-    # GitHub Copilot
-    'copilot-swe-agent\[bot\]'
-    'copilot@github\.com'
-    # OpenAI Codex
-    'noreply@openai\.com'
-    'codex@openai\.com'
-    # Aider
-    'aider@aider\.chat'
-    # Google — Gemini / Jules
-    'gemini@google\.com'
-    'jules@google\.com'
-    # Windsurf / Codeium
-    '@codeium\.com'
-    # Devin
-    'devin-ai-integration\[bot\]'
-    'devin@cognition\.ai'
-    'devin@cognition-labs\.com'
-    # Amazon Q Developer
-    'amazon-q-developer'
-    '@amazon\.com.*[Qq].[Dd]eveloper'
-    # Cline
-    'cline-bot'
-    'cline@cline\.ai'
-    # Continue
-    'continue-agent'
-    'continue@continue\.dev'
-    # Sourcegraph
-    'noreply@sourcegraph\.com'
-    # Generic catch-alls for common agent name patterns
-    'Co-authored-by:.*\b[Cc]laude\b'
-    'Co-authored-by:.*\b[Cc]opilot\b'
-    'Co-authored-by:.*\b[Cc]ursor\b'
-    'Co-authored-by:.*\b[Cc]odex\b'
-    'Co-authored-by:.*\b[Gg]emini\b'
-    'Co-authored-by:.*\b[Aa]ider\b'
-    'Co-authored-by:.*\b[Dd]evin\b'
-    'Co-authored-by:.*\b[Ww]indsurf\b'
-    'Co-authored-by:.*\b[Cc]line\b'
-    'Co-authored-by:.*\b[Aa]mazon Q\b'
-    'Co-authored-by:.*\b[Jj]ules\b'
-    'Co-authored-by:.*\bOpenCode\b'
-)
-
-# Build a single alternation regex from all patterns.
-regex=""
-for pattern in "${AGENT_PATTERNS[@]}"; do
-    if [[ -n "$regex" ]]; then
-        regex="${regex}|${pattern}"
-    else
-        regex="$pattern"
-    fi
-done
-
-# Collect Co-authored-by lines from every commit in the PR range.
-violations=""
-while IFS= read -r sha; do
-    message="$(git log -1 --format='%B' "$sha")"
-    matched_lines="$(echo "$message" | grep -iE "^Co-authored-by:" || true)"
-    if [[ -z "$matched_lines" ]]; then
-        continue
-    fi
-
-    while IFS= read -r line; do
-        if echo "$line" | grep -iqE "$regex"; then
-            short="$(git log -1 --format='%h' "$sha")"
-            violations="${violations}  ${short}: ${line}"$'\n'
-        fi
-    done <<< "$matched_lines"
-done < <(git rev-list "${base_sha}..${head_sha}")
-
-if [[ -n "$violations" ]]; then
-    echo "::error::AI agent Co-authored-by trailers detected in PR commits."
-    echo ""
-    echo "The following commits contain Co-authored-by trailers from AI coding agents:"
-    echo ""
-    echo "$violations"
-    echo "These trailers should be removed before merging."
-    echo ""
-    echo "To fix, rewrite the commit messages with:"
-    echo "  git rebase -i ${base_sha}"
-    echo ""
-    echo "and remove the Co-authored-by lines, then force-push your branch."
-    echo ""
-    echo "If you believe this is a false positive, please open an issue."
-    exit 1
-fi
-
-echo "No AI agent Co-authored-by trailers found."

.github/workflows/check-ai-co-authors.yml

@@ -1,19 +0,0 @@
-name: Check AI Co-Authors
-
-on:
-  pull_request:
-    branches: ['*']
-
-jobs:
-  check-ai-co-authors:
-    name: Check for AI agent co-author trailers
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Check commits for AI co-author trailers
-        run: bash .github/scripts/check-ai-co-authors.sh "${{ github.event.pull_request.base.sha }}" "${{ github.event.pull_request.head.sha }}"

.github/workflows/release-webhook.yml

@@ -7,8 +7,6 @@ on:
 jobs:
   send-webhook:
     runs-on: ubuntu-latest
-    env:
-      DESKTOP_REPO_DISPATCH_TOKEN: ${{ secrets.DESKTOP_REPO_DISPATCH_TOKEN }}
     steps:
       - name: Send release webhook
         env:
@@ -108,37 +106,3 @@ jobs:
             --fail --silent --show-error
           
           echo "✅ Release webhook sent successfully"
-
-      - name: Send repository dispatch to desktop
-        env:
-          DISPATCH_TOKEN: ${{ env.DESKTOP_REPO_DISPATCH_TOKEN }}
-          RELEASE_TAG: ${{ github.event.release.tag_name }}
-          RELEASE_URL: ${{ github.event.release.html_url }}
-        run: |
-          set -euo pipefail
-
-          if [ -z "${DISPATCH_TOKEN:-}" ]; then
-            echo "::error::DESKTOP_REPO_DISPATCH_TOKEN is required but not set."
-            exit 1
-          fi
-
-          PAYLOAD="$(jq -n \
-            --arg release_tag "$RELEASE_TAG" \
-            --arg release_url "$RELEASE_URL" \
-            '{
-              event_type: "comfyui_release_published",
-              client_payload: {
-                release_tag: $release_tag,
-                release_url: $release_url
-              }
-            }')"
-
-          curl -fsSL \
-            -X POST \
-            -H "Accept: application/vnd.github+json" \
-            -H "Content-Type: application/json" \
-            -H "Authorization: Bearer ${DISPATCH_TOKEN}" \
-            https://api.github.com/repos/Comfy-Org/desktop/dispatches \
-            -d "$PAYLOAD"
-
-          echo "✅ Dispatched ComfyUI release ${RELEASE_TAG} to Comfy-Org/desktop"

.gitignore

@@ -11,7 +11,7 @@ extra_model_paths.yaml
 /.vs
 .vscode/
 .idea/
-venv*/
+venv/
 .venv/
 /web/extensions/*
 !/web/extensions/logging.js.example

README.md

@@ -38,8 +38,6 @@ ComfyUI lets you design and execute advanced stable diffusion pipelines using a
 
 ## Get Started
 
-### Local
-
 #### [Desktop Application](https://www.comfy.org/download)
 - The easiest way to get started.
 - Available on Windows & macOS.
@@ -51,13 +49,8 @@ ComfyUI lets you design and execute advanced stable diffusion pipelines using a
 #### [Manual Install](#manual-install-windows-linux)
 Supports all operating systems and GPU types (NVIDIA, AMD, Intel, Apple Silicon, Ascend).
 
-### Cloud
-
-#### [Comfy Cloud](https://www.comfy.org/cloud)
-- Our official paid cloud version for those who can't afford local hardware.
-
-## Examples
-See what ComfyUI can do with the [newer template workflows](https://comfy.org/workflows) or old [example workflows](https://comfyanonymous.github.io/ComfyUI_examples/).
+## [Examples](https://comfyanonymous.github.io/ComfyUI_examples/)
+See what ComfyUI can do with the [example workflows](https://comfyanonymous.github.io/ComfyUI_examples/).
 
 ## Features
 - Nodes/graph/flowchart interface to experiment and create complex Stable Diffusion workflows without needing to code anything.
@@ -196,6 +189,8 @@ The portable above currently comes with python 3.13 and pytorch cuda 13.0. Updat
 
 [Experimental portable for AMD GPUs](https://github.com/comfyanonymous/ComfyUI/releases/latest/download/ComfyUI_windows_portable_amd.7z)
 
+[Portable with pytorch cuda 12.8 and python 3.12](https://github.com/comfyanonymous/ComfyUI/releases/latest/download/ComfyUI_windows_portable_nvidia_cu128.7z).
+
 [Portable with pytorch cuda 12.6 and python 3.12](https://github.com/comfyanonymous/ComfyUI/releases/latest/download/ComfyUI_windows_portable_nvidia_cu126.7z) (Supports Nvidia 10 series and older GPUs).
 
 #### How do I share models between another UI and ComfyUI?
@@ -232,11 +227,11 @@ Put your VAE in: models/vae
 
 AMD users can install rocm and pytorch with pip if you don't have it already installed, this is the command to install the stable version:
 
-```pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/rocm7.1```
+```pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/rocm6.4```
 
-This is the command to install the nightly with ROCm 7.2 which might have some performance improvements:
+This is the command to install the nightly with ROCm 7.1 which might have some performance improvements:
 
-```pip install --pre torch torchvision torchaudio --index-url https://download.pytorch.org/whl/nightly/rocm7.2```
+```pip install --pre torch torchvision torchaudio --index-url https://download.pytorch.org/whl/nightly/rocm7.1```
 
 
 ### AMD GPUs (Experimental: Windows and Linux), RDNA 3, 3.5 and 4 only.

alembic_db/env.py

@@ -8,7 +8,7 @@ from alembic import context
 config = context.config
 
 
-from app.database.models import Base, NAMING_CONVENTION
+from app.database.models import Base
 target_metadata = Base.metadata
 
 # other values from the config, defined by the needs of env.py,
@@ -51,10 +51,7 @@ def run_migrations_online() -> None:
 
     with connectable.connect() as connection:
         context.configure(
-            connection=connection,
-            target_metadata=target_metadata,
-            render_as_batch=True,
-            naming_convention=NAMING_CONVENTION,
+            connection=connection, target_metadata=target_metadata
         )
 
         with context.begin_transaction():

alembic_db/versions/0002_merge_to_asset_references.py

@@ -1,267 +0,0 @@
-"""
-Merge AssetInfo and AssetCacheState into unified asset_references table.
-
-This migration drops old tables and creates the new unified schema.
-All existing data is discarded.
-
-Revision ID: 0002_merge_to_asset_references
-Revises: 0001_assets
-Create Date: 2025-02-11
-"""
-
-from alembic import op
-import sqlalchemy as sa
-
-revision = "0002_merge_to_asset_references"
-down_revision = "0001_assets"
-branch_labels = None
-depends_on = None
-
-
-def upgrade() -> None:
-    # Drop old tables (order matters due to FK constraints)
-    op.drop_index("ix_asset_info_meta_key_val_bool", table_name="asset_info_meta")
-    op.drop_index("ix_asset_info_meta_key_val_num", table_name="asset_info_meta")
-    op.drop_index("ix_asset_info_meta_key_val_str", table_name="asset_info_meta")
-    op.drop_index("ix_asset_info_meta_key", table_name="asset_info_meta")
-    op.drop_table("asset_info_meta")
-
-    op.drop_index("ix_asset_info_tags_asset_info_id", table_name="asset_info_tags")
-    op.drop_index("ix_asset_info_tags_tag_name", table_name="asset_info_tags")
-    op.drop_table("asset_info_tags")
-
-    op.drop_index("ix_asset_cache_state_asset_id", table_name="asset_cache_state")
-    op.drop_index("ix_asset_cache_state_file_path", table_name="asset_cache_state")
-    op.drop_table("asset_cache_state")
-
-    op.drop_index("ix_assets_info_owner_name", table_name="assets_info")
-    op.drop_index("ix_assets_info_last_access_time", table_name="assets_info")
-    op.drop_index("ix_assets_info_created_at", table_name="assets_info")
-    op.drop_index("ix_assets_info_name", table_name="assets_info")
-    op.drop_index("ix_assets_info_asset_id", table_name="assets_info")
-    op.drop_index("ix_assets_info_owner_id", table_name="assets_info")
-    op.drop_table("assets_info")
-
-    # Truncate assets table (cascades handled by dropping dependent tables first)
-    op.execute("DELETE FROM assets")
-
-    # Create asset_references table
-    op.create_table(
-        "asset_references",
-        sa.Column("id", sa.String(length=36), primary_key=True),
-        sa.Column(
-            "asset_id",
-            sa.String(length=36),
-            sa.ForeignKey("assets.id", ondelete="CASCADE"),
-            nullable=False,
-        ),
-        sa.Column("file_path", sa.Text(), nullable=True),
-        sa.Column("mtime_ns", sa.BigInteger(), nullable=True),
-        sa.Column(
-            "needs_verify",
-            sa.Boolean(),
-            nullable=False,
-            server_default=sa.text("false"),
-        ),
-        sa.Column(
-            "is_missing", sa.Boolean(), nullable=False, server_default=sa.text("false")
-        ),
-        sa.Column("enrichment_level", sa.Integer(), nullable=False, server_default="0"),
-        sa.Column("owner_id", sa.String(length=128), nullable=False, server_default=""),
-        sa.Column("name", sa.String(length=512), nullable=False),
-        sa.Column(
-            "preview_id",
-            sa.String(length=36),
-            sa.ForeignKey("assets.id", ondelete="SET NULL"),
-            nullable=True,
-        ),
-        sa.Column("user_metadata", sa.JSON(), nullable=True),
-        sa.Column("created_at", sa.DateTime(timezone=False), nullable=False),
-        sa.Column("updated_at", sa.DateTime(timezone=False), nullable=False),
-        sa.Column("last_access_time", sa.DateTime(timezone=False), nullable=False),
-        sa.Column("deleted_at", sa.DateTime(timezone=False), nullable=True),
-        sa.CheckConstraint(
-            "(mtime_ns IS NULL) OR (mtime_ns >= 0)", name="ck_ar_mtime_nonneg"
-        ),
-        sa.CheckConstraint(
-            "enrichment_level >= 0 AND enrichment_level <= 2",
-            name="ck_ar_enrichment_level_range",
-        ),
-    )
-    op.create_index(
-        "uq_asset_references_file_path", "asset_references", ["file_path"], unique=True
-    )
-    op.create_index("ix_asset_references_asset_id", "asset_references", ["asset_id"])
-    op.create_index("ix_asset_references_owner_id", "asset_references", ["owner_id"])
-    op.create_index("ix_asset_references_name", "asset_references", ["name"])
-    op.create_index("ix_asset_references_is_missing", "asset_references", ["is_missing"])
-    op.create_index(
-        "ix_asset_references_enrichment_level", "asset_references", ["enrichment_level"]
-    )
-    op.create_index("ix_asset_references_created_at", "asset_references", ["created_at"])
-    op.create_index(
-        "ix_asset_references_last_access_time", "asset_references", ["last_access_time"]
-    )
-    op.create_index(
-        "ix_asset_references_owner_name", "asset_references", ["owner_id", "name"]
-    )
-    op.create_index("ix_asset_references_deleted_at", "asset_references", ["deleted_at"])
-
-    # Create asset_reference_tags table
-    op.create_table(
-        "asset_reference_tags",
-        sa.Column(
-            "asset_reference_id",
-            sa.String(length=36),
-            sa.ForeignKey("asset_references.id", ondelete="CASCADE"),
-            nullable=False,
-        ),
-        sa.Column(
-            "tag_name",
-            sa.String(length=512),
-            sa.ForeignKey("tags.name", ondelete="RESTRICT"),
-            nullable=False,
-        ),
-        sa.Column(
-            "origin", sa.String(length=32), nullable=False, server_default="manual"
-        ),
-        sa.Column("added_at", sa.DateTime(timezone=False), nullable=False),
-        sa.PrimaryKeyConstraint(
-            "asset_reference_id", "tag_name", name="pk_asset_reference_tags"
-        ),
-    )
-    op.create_index(
-        "ix_asset_reference_tags_tag_name", "asset_reference_tags", ["tag_name"]
-    )
-    op.create_index(
-        "ix_asset_reference_tags_asset_reference_id",
-        "asset_reference_tags",
-        ["asset_reference_id"],
-    )
-
-    # Create asset_reference_meta table
-    op.create_table(
-        "asset_reference_meta",
-        sa.Column(
-            "asset_reference_id",
-            sa.String(length=36),
-            sa.ForeignKey("asset_references.id", ondelete="CASCADE"),
-            nullable=False,
-        ),
-        sa.Column("key", sa.String(length=256), nullable=False),
-        sa.Column("ordinal", sa.Integer(), nullable=False, server_default="0"),
-        sa.Column("val_str", sa.String(length=2048), nullable=True),
-        sa.Column("val_num", sa.Numeric(38, 10), nullable=True),
-        sa.Column("val_bool", sa.Boolean(), nullable=True),
-        sa.Column("val_json", sa.JSON(), nullable=True),
-        sa.PrimaryKeyConstraint(
-            "asset_reference_id", "key", "ordinal", name="pk_asset_reference_meta"
-        ),
-    )
-    op.create_index("ix_asset_reference_meta_key", "asset_reference_meta", ["key"])
-    op.create_index(
-        "ix_asset_reference_meta_key_val_str", "asset_reference_meta", ["key", "val_str"]
-    )
-    op.create_index(
-        "ix_asset_reference_meta_key_val_num", "asset_reference_meta", ["key", "val_num"]
-    )
-    op.create_index(
-        "ix_asset_reference_meta_key_val_bool",
-        "asset_reference_meta",
-        ["key", "val_bool"],
-    )
-
-
-def downgrade() -> None:
-    """Reverse 0002_merge_to_asset_references: drop new tables, recreate old schema.
-
-    NOTE: Data is not recoverable. The upgrade discards all rows from the old
-    tables and truncates assets. After downgrade the old schema will be empty.
-    A filesystem rescan will repopulate data once the older code is running.
-    """
-    # Drop new tables (order matters due to FK constraints)
-    op.drop_index("ix_asset_reference_meta_key_val_bool", table_name="asset_reference_meta")
-    op.drop_index("ix_asset_reference_meta_key_val_num", table_name="asset_reference_meta")
-    op.drop_index("ix_asset_reference_meta_key_val_str", table_name="asset_reference_meta")
-    op.drop_index("ix_asset_reference_meta_key", table_name="asset_reference_meta")
-    op.drop_table("asset_reference_meta")
-
-    op.drop_index("ix_asset_reference_tags_asset_reference_id", table_name="asset_reference_tags")
-    op.drop_index("ix_asset_reference_tags_tag_name", table_name="asset_reference_tags")
-    op.drop_table("asset_reference_tags")
-
-    op.drop_index("ix_asset_references_deleted_at", table_name="asset_references")
-    op.drop_index("ix_asset_references_owner_name", table_name="asset_references")
-    op.drop_index("ix_asset_references_last_access_time", table_name="asset_references")
-    op.drop_index("ix_asset_references_created_at", table_name="asset_references")
-    op.drop_index("ix_asset_references_enrichment_level", table_name="asset_references")
-    op.drop_index("ix_asset_references_is_missing", table_name="asset_references")
-    op.drop_index("ix_asset_references_name", table_name="asset_references")
-    op.drop_index("ix_asset_references_owner_id", table_name="asset_references")
-    op.drop_index("ix_asset_references_asset_id", table_name="asset_references")
-    op.drop_index("uq_asset_references_file_path", table_name="asset_references")
-    op.drop_table("asset_references")
-
-    # Truncate assets (upgrade deleted all rows; downgrade starts fresh too)
-    op.execute("DELETE FROM assets")
-
-    # Recreate old tables from 0001_assets schema
-    op.create_table(
-        "assets_info",
-        sa.Column("id", sa.String(length=36), primary_key=True),
-        sa.Column("owner_id", sa.String(length=128), nullable=False, server_default=""),
-        sa.Column("name", sa.String(length=512), nullable=False),
-        sa.Column("asset_id", sa.String(length=36), sa.ForeignKey("assets.id", ondelete="RESTRICT"), nullable=False),
-        sa.Column("preview_id", sa.String(length=36), sa.ForeignKey("assets.id", ondelete="SET NULL"), nullable=True),
-        sa.Column("user_metadata", sa.JSON(), nullable=True),
-        sa.Column("created_at", sa.DateTime(timezone=False), nullable=False),
-        sa.Column("updated_at", sa.DateTime(timezone=False), nullable=False),
-        sa.Column("last_access_time", sa.DateTime(timezone=False), nullable=False),
-        sa.UniqueConstraint("asset_id", "owner_id", "name", name="uq_assets_info_asset_owner_name"),
-    )
-    op.create_index("ix_assets_info_owner_id", "assets_info", ["owner_id"])
-    op.create_index("ix_assets_info_asset_id", "assets_info", ["asset_id"])
-    op.create_index("ix_assets_info_name", "assets_info", ["name"])
-    op.create_index("ix_assets_info_created_at", "assets_info", ["created_at"])
-    op.create_index("ix_assets_info_last_access_time", "assets_info", ["last_access_time"])
-    op.create_index("ix_assets_info_owner_name", "assets_info", ["owner_id", "name"])
-
-    op.create_table(
-        "asset_cache_state",
-        sa.Column("id", sa.Integer(), primary_key=True, autoincrement=True),
-        sa.Column("asset_id", sa.String(length=36), sa.ForeignKey("assets.id", ondelete="CASCADE"), nullable=False),
-        sa.Column("file_path", sa.Text(), nullable=False),
-        sa.Column("mtime_ns", sa.BigInteger(), nullable=True),
-        sa.Column("needs_verify", sa.Boolean(), nullable=False, server_default=sa.text("false")),
-        sa.CheckConstraint("(mtime_ns IS NULL) OR (mtime_ns >= 0)", name="ck_acs_mtime_nonneg"),
-        sa.UniqueConstraint("file_path", name="uq_asset_cache_state_file_path"),
-    )
-    op.create_index("ix_asset_cache_state_file_path", "asset_cache_state", ["file_path"])
-    op.create_index("ix_asset_cache_state_asset_id", "asset_cache_state", ["asset_id"])
-
-    op.create_table(
-        "asset_info_tags",
-        sa.Column("asset_info_id", sa.String(length=36), sa.ForeignKey("assets_info.id", ondelete="CASCADE"), nullable=False),
-        sa.Column("tag_name", sa.String(length=512), sa.ForeignKey("tags.name", ondelete="RESTRICT"), nullable=False),
-        sa.Column("origin", sa.String(length=32), nullable=False, server_default="manual"),
-        sa.Column("added_at", sa.DateTime(timezone=False), nullable=False),
-        sa.PrimaryKeyConstraint("asset_info_id", "tag_name", name="pk_asset_info_tags"),
-    )
-    op.create_index("ix_asset_info_tags_tag_name", "asset_info_tags", ["tag_name"])
-    op.create_index("ix_asset_info_tags_asset_info_id", "asset_info_tags", ["asset_info_id"])
-
-    op.create_table(
-        "asset_info_meta",
-        sa.Column("asset_info_id", sa.String(length=36), sa.ForeignKey("assets_info.id", ondelete="CASCADE"), nullable=False),
-        sa.Column("key", sa.String(length=256), nullable=False),
-        sa.Column("ordinal", sa.Integer(), nullable=False, server_default="0"),
-        sa.Column("val_str", sa.String(length=2048), nullable=True),
-        sa.Column("val_num", sa.Numeric(38, 10), nullable=True),
-        sa.Column("val_bool", sa.Boolean(), nullable=True),
-        sa.Column("val_json", sa.JSON(), nullable=True),
-        sa.PrimaryKeyConstraint("asset_info_id", "key", "ordinal", name="pk_asset_info_meta"),
-    )
-    op.create_index("ix_asset_info_meta_key", "asset_info_meta", ["key"])
-    op.create_index("ix_asset_info_meta_key_val_str", "asset_info_meta", ["key", "val_str"])
-    op.create_index("ix_asset_info_meta_key_val_num", "asset_info_meta", ["key", "val_num"])
-    op.create_index("ix_asset_info_meta_key_val_bool", "asset_info_meta", ["key", "val_bool"])

alembic_db/versions/0003_add_metadata_job_id.py

@@ -1,98 +0,0 @@
-"""
-Add system_metadata and job_id columns to asset_references.
-Change preview_id FK from assets.id to asset_references.id.
-
-Revision ID: 0003_add_metadata_job_id
-Revises: 0002_merge_to_asset_references
-Create Date: 2026-03-09
-"""
-
-from alembic import op
-import sqlalchemy as sa
-
-from app.database.models import NAMING_CONVENTION
-
-revision = "0003_add_metadata_job_id"
-down_revision = "0002_merge_to_asset_references"
-branch_labels = None
-depends_on = None
-
-
-def upgrade() -> None:
-    with op.batch_alter_table("asset_references") as batch_op:
-        batch_op.add_column(
-            sa.Column("system_metadata", sa.JSON(), nullable=True)
-        )
-        batch_op.add_column(
-            sa.Column("job_id", sa.String(length=36), nullable=True)
-        )
-
-    # Change preview_id FK from assets.id to asset_references.id (self-ref).
-    # Existing values are asset-content IDs that won't match reference IDs,
-    # so null them out first.
-    op.execute("UPDATE asset_references SET preview_id = NULL WHERE preview_id IS NOT NULL")
-    with op.batch_alter_table(
-        "asset_references", naming_convention=NAMING_CONVENTION
-    ) as batch_op:
-        batch_op.drop_constraint(
-            "fk_asset_references_preview_id_assets", type_="foreignkey"
-        )
-        batch_op.create_foreign_key(
-            "fk_asset_references_preview_id_asset_references",
-            "asset_references",
-            ["preview_id"],
-            ["id"],
-            ondelete="SET NULL",
-        )
-        batch_op.create_index(
-            "ix_asset_references_preview_id", ["preview_id"]
-        )
-
-    # Purge any all-null meta rows before adding the constraint
-    op.execute(
-        "DELETE FROM asset_reference_meta"
-        " WHERE val_str IS NULL AND val_num IS NULL AND val_bool IS NULL AND val_json IS NULL"
-    )
-    with op.batch_alter_table("asset_reference_meta") as batch_op:
-        batch_op.create_check_constraint(
-            "ck_asset_reference_meta_has_value",
-            "val_str IS NOT NULL OR val_num IS NOT NULL OR val_bool IS NOT NULL OR val_json IS NOT NULL",
-        )
-
-
-def downgrade() -> None:
-    # SQLite doesn't reflect CHECK constraints, so we must declare it
-    # explicitly via table_args for the batch recreate to find it.
-    # Use the fully-rendered constraint name to avoid the naming convention
-    # doubling the prefix.
-    with op.batch_alter_table(
-        "asset_reference_meta",
-        table_args=[
-            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_reference_meta_has_value",
-            ),
-        ],
-    ) as batch_op:
-        batch_op.drop_constraint(
-            "ck_asset_reference_meta_has_value", type_="check"
-        )
-
-    with op.batch_alter_table(
-        "asset_references", naming_convention=NAMING_CONVENTION
-    ) as batch_op:
-        batch_op.drop_index("ix_asset_references_preview_id")
-        batch_op.drop_constraint(
-            "fk_asset_references_preview_id_asset_references", type_="foreignkey"
-        )
-        batch_op.create_foreign_key(
-            "fk_asset_references_preview_id_assets",
-            "assets",
-            ["preview_id"],
-            ["id"],
-            ondelete="SET NULL",
-        )
-
-    with op.batch_alter_table("asset_references") as batch_op:
-        batch_op.drop_column("job_id")
-        batch_op.drop_column("system_metadata")

app/assets/api/routes.py

@@ -1,6 +1,3 @@
-import asyncio
-import functools
-import json
 import logging
 import os
 import urllib.parse
@@ -13,17 +10,12 @@ from pydantic import ValidationError
 import folder_paths
 from app import user_manager
 from app.assets.api import schemas_in, schemas_out
-from app.assets.services import schemas
 from app.assets.api.schemas_in import (
     AssetValidationError,
     UploadError,
 )
-from app.assets.helpers import validate_blake3_hash
-from app.assets.api.upload import (
-    delete_temp_file_if_exists,
-    parse_multipart_upload,
-)
-from app.assets.seeder import ScanInProgressError, asset_seeder
+from app.assets.api.upload import parse_multipart_upload
+from app.assets.scanner import seed_assets as scanner_seed_assets
 from app.assets.services import (
     DependencyMissingError,
     HashMismatchError,
@@ -39,36 +31,19 @@ from app.assets.services import (
     update_asset_metadata,
     upload_from_temp_path,
 )
-from app.assets.services.tagging import list_tag_histogram
 
 ROUTES = web.RouteTableDef()
 USER_MANAGER: user_manager.UserManager | None = None
-_ASSETS_ENABLED = False
-
-
-def _require_assets_feature_enabled(handler):
-    @functools.wraps(handler)
-    async def wrapper(request: web.Request) -> web.Response:
-        if not _ASSETS_ENABLED:
-            return _build_error_response(
-                503,
-                "SERVICE_DISABLED",
-                "Assets system is disabled. Start the server with --enable-assets to use this feature.",
-            )
-        return await handler(request)
-
-    return wrapper
-
 
 # UUID regex (canonical hyphenated form, case-insensitive)
 UUID_RE = r"[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}"
 
 
 def get_query_dict(request: web.Request) -> dict[str, Any]:
-    """Gets a dictionary of query parameters from the request.
+    """
+    Gets a dictionary of query parameters from the request.
 
-    request.query is a MultiMapping[str], needs to be converted to a dict
-    to be validated by Pydantic.
+    'request.query' is a MultiMapping[str], needs to be converted to a dictionary to be validated by Pydantic.
     """
     query_dict = {
         key: request.query.getall(key)
@@ -80,27 +55,17 @@ def get_query_dict(request: web.Request) -> dict[str, Any]:
 
 
 # Note to any custom node developers reading this code:
-# The assets system is not yet fully implemented,
-# do not rely on the code in /app/assets remaining the same.
+# The assets system is not yet fully implemented, do not rely on the code in /app/assets remaining the same.
 
 
-def register_assets_routes(
-    app: web.Application,
-    user_manager_instance: user_manager.UserManager | None = None,
+def register_assets_system(
+    app: web.Application, user_manager_instance: user_manager.UserManager
 ) -> None:
-    global USER_MANAGER, _ASSETS_ENABLED
-    if user_manager_instance is not None:
-        USER_MANAGER = user_manager_instance
-        _ASSETS_ENABLED = True
+    global USER_MANAGER
+    USER_MANAGER = user_manager_instance
     app.add_routes(ROUTES)
 
 
-def disable_assets_routes() -> None:
-    """Disable asset routes at runtime (e.g. after DB init failure)."""
-    global _ASSETS_ENABLED
-    _ASSETS_ENABLED = False
-
-
 def _build_error_response(
     status: int, code: str, message: str, details: dict | None = None
 ) -> web.Response:
@@ -111,8 +76,7 @@ def _build_error_response(
 
 
 def _build_validation_error_response(code: str, ve: ValidationError) -> web.Response:
-    errors = json.loads(ve.json())
-    return _build_error_response(400, code, "Validation failed.", {"errors": errors})
+    return _build_error_response(400, code, "Validation failed.", {"errors": ve.json()})
 
 
 def _validate_sort_field(requested: str | None) -> str:
@@ -124,68 +88,19 @@ def _validate_sort_field(requested: str | None) -> str:
     return "created_at"
 
 
-def _build_preview_url_from_view(tags: list[str], user_metadata: dict[str, Any] | None) -> str | None:
-    """Build a /api/view preview URL from asset tags and user_metadata filename."""
-    if not user_metadata:
-        return None
-    filename = user_metadata.get("filename")
-    if not filename:
-        return None
-
-    if "input" in tags:
-        view_type = "input"
-    elif "output" in tags:
-        view_type = "output"
-    else:
-        return None
-
-    subfolder = ""
-    if "/" in filename:
-        subfolder, filename = filename.rsplit("/", 1)
-
-    encoded_filename = urllib.parse.quote(filename, safe="")
-    url = f"/api/view?type={view_type}&filename={encoded_filename}"
-    if subfolder:
-        url += f"&subfolder={urllib.parse.quote(subfolder, safe='')}"
-    return url
-
-
-def _build_asset_response(result: schemas.AssetDetailResult | schemas.UploadResult) -> schemas_out.Asset:
-    """Build an Asset response from a service result."""
-    if result.ref.preview_id:
-        preview_detail = get_asset_detail(result.ref.preview_id)
-        if preview_detail:
-            preview_url = _build_preview_url_from_view(preview_detail.tags, preview_detail.ref.user_metadata)
-        else:
-            preview_url = None
-    else:
-        preview_url = _build_preview_url_from_view(result.tags, result.ref.user_metadata)
-    return schemas_out.Asset(
-        id=result.ref.id,
-        name=result.ref.name,
-        asset_hash=result.asset.hash if result.asset else None,
-        size=int(result.asset.size_bytes) if result.asset else None,
-        mime_type=result.asset.mime_type if result.asset else None,
-        tags=result.tags,
-        preview_url=preview_url,
-        preview_id=result.ref.preview_id,
-        user_metadata=result.ref.user_metadata or {},
-        metadata=result.ref.system_metadata,
-        job_id=result.ref.job_id,
-        prompt_id=result.ref.job_id,  # deprecated: mirrors job_id for cloud compat
-        created_at=result.ref.created_at,
-        updated_at=result.ref.updated_at,
-        last_access_time=result.ref.last_access_time,
-    )
-
-
 @ROUTES.head("/api/assets/hash/{hash}")
-@_require_assets_feature_enabled
 async def head_asset_by_hash(request: web.Request) -> web.Response:
     hash_str = request.match_info.get("hash", "").strip().lower()
-    try:
-        hash_str = validate_blake3_hash(hash_str)
-    except ValueError:
+    if not hash_str or ":" not in hash_str:
+        return _build_error_response(
+            400, "INVALID_HASH", "hash must be like 'blake3:<hex>'"
+        )
+    algo, digest = hash_str.split(":", 1)
+    if (
+        algo != "blake3"
+        or not digest
+        or any(c for c in digest if c not in "0123456789abcdef")
+    ):
         return _build_error_response(
             400, "INVALID_HASH", "hash must be like 'blake3:<hex>'"
         )
@@ -194,7 +109,6 @@ async def head_asset_by_hash(request: web.Request) -> web.Response:
 
 
 @ROUTES.get("/api/assets")
-@_require_assets_feature_enabled
 async def list_assets_route(request: web.Request) -> web.Response:
     """
     GET request to list assets.
@@ -206,8 +120,11 @@ async def list_assets_route(request: web.Request) -> web.Response:
         return _build_validation_error_response("INVALID_QUERY", ve)
 
     sort = _validate_sort_field(q.sort)
-    order_candidate = (q.order or "desc").lower()
-    order = order_candidate if order_candidate in {"asc", "desc"} else "desc"
+    order = (
+        "desc"
+        if (q.order or "desc").lower() not in {"asc", "desc"}
+        else q.order.lower()
+    )
 
     result = list_assets_page(
         owner_id=USER_MANAGER.get_request_user_id(request),
@@ -221,7 +138,22 @@ async def list_assets_route(request: web.Request) -> web.Response:
         order=order,
     )
 
-    summaries = [_build_asset_response(item) for item in result.items]
+    summaries = [
+        schemas_out.AssetSummary(
+            id=item.info.id,
+            name=item.info.name,
+            asset_hash=item.asset.hash if item.asset else None,
+            size=int(item.asset.size_bytes)
+            if item.asset and item.asset.size_bytes
+            else None,
+            mime_type=item.asset.mime_type if item.asset else None,
+            tags=item.tags,
+            created_at=item.info.created_at,
+            updated_at=item.info.updated_at,
+            last_access_time=item.info.last_access_time,
+        )
+        for item in result.items
+    ]
 
     payload = schemas_out.AssetsList(
         assets=summaries,
@@ -232,42 +164,53 @@ async def list_assets_route(request: web.Request) -> web.Response:
 
 
 @ROUTES.get(f"/api/assets/{{id:{UUID_RE}}}")
-@_require_assets_feature_enabled
 async def get_asset_route(request: web.Request) -> web.Response:
     """
     GET request to get an asset's info as JSON.
     """
-    reference_id = str(uuid.UUID(request.match_info["id"]))
+    asset_info_id = str(uuid.UUID(request.match_info["id"]))
     try:
         result = get_asset_detail(
-            reference_id=reference_id,
+            asset_info_id=asset_info_id,
             owner_id=USER_MANAGER.get_request_user_id(request),
         )
         if not result:
             return _build_error_response(
                 404,
                 "ASSET_NOT_FOUND",
-                f"AssetReference {reference_id} not found",
-                {"id": reference_id},
+                f"AssetInfo {asset_info_id} not found",
+                {"id": asset_info_id},
             )
 
-        payload = _build_asset_response(result)
+        payload = schemas_out.AssetDetail(
+            id=result.info.id,
+            name=result.info.name,
+            asset_hash=result.asset.hash if result.asset else None,
+            size=int(result.asset.size_bytes)
+            if result.asset and result.asset.size_bytes is not None
+            else None,
+            mime_type=result.asset.mime_type if result.asset else None,
+            tags=result.tags,
+            user_metadata=result.info.user_metadata or {},
+            preview_id=result.info.preview_id,
+            created_at=result.info.created_at,
+            last_access_time=result.info.last_access_time,
+        )
     except ValueError as e:
         return _build_error_response(
-            404, "ASSET_NOT_FOUND", str(e), {"id": reference_id}
+            404, "ASSET_NOT_FOUND", str(e), {"id": asset_info_id}
         )
     except Exception:
         logging.exception(
-            "get_asset failed for reference_id=%s, owner_id=%s",
-            reference_id,
+            "get_asset failed for asset_info_id=%s, owner_id=%s",
+            asset_info_id,
             USER_MANAGER.get_request_user_id(request),
         )
         return _build_error_response(500, "INTERNAL", "Unexpected server error.")
-    return web.json_response(payload.model_dump(mode="json", exclude_none=True), status=200)
+    return web.json_response(payload.model_dump(mode="json"), status=200)
 
 
 @ROUTES.get(f"/api/assets/{{id:{UUID_RE}}}/content")
-@_require_assets_feature_enabled
 async def download_asset_content(request: web.Request) -> web.Response:
     disposition = request.query.get("disposition", "attachment").lower().strip()
     if disposition not in {"inline", "attachment"}:
@@ -275,7 +218,7 @@ async def download_asset_content(request: web.Request) -> web.Response:
 
     try:
         result = resolve_asset_for_download(
-            reference_id=str(uuid.UUID(request.match_info["id"])),
+            asset_info_id=str(uuid.UUID(request.match_info["id"])),
             owner_id=USER_MANAGER.get_request_user_id(request),
         )
         abs_path = result.abs_path
@@ -290,24 +233,15 @@ async def download_asset_content(request: web.Request) -> web.Response:
             404, "FILE_NOT_FOUND", "Underlying file not found on disk."
         )
 
-    _DANGEROUS_MIME_TYPES = {
-        "text/html", "text/html-sandboxed", "application/xhtml+xml",
-        "text/javascript", "text/css",
-    }
-    if content_type in _DANGEROUS_MIME_TYPES:
-        content_type = "application/octet-stream"
-
-    safe_name = (filename or "").replace("\r", "").replace("\n", "")
-    encoded = urllib.parse.quote(safe_name)
-    cd = f"{disposition}; filename*=UTF-8''{encoded}"
+    quoted = (filename or "").replace("\r", "").replace("\n", "").replace('"', "'")
+    cd = f"{disposition}; filename=\"{quoted}\"; filename*=UTF-8''{urllib.parse.quote(filename)}"
 
     file_size = os.path.getsize(abs_path)
-    size_mb = file_size / (1024 * 1024)
     logging.info(
-        "download_asset_content: path=%s, size=%d bytes (%.2f MB), type=%s, name=%s",
+        "download_asset_content: path=%s, size=%d bytes (%.2f MB), content_type=%s, filename=%s",
         abs_path,
         file_size,
-        size_mb,
+        file_size / (1024 * 1024),
         content_type,
         filename,
     )
@@ -327,13 +261,11 @@ async def download_asset_content(request: web.Request) -> web.Response:
         headers={
             "Content-Disposition": cd,
             "Content-Length": str(file_size),
-            "X-Content-Type-Options": "nosniff",
         },
     )
 
 
 @ROUTES.post("/api/assets/from-hash")
-@_require_assets_feature_enabled
 async def create_asset_from_hash_route(request: web.Request) -> web.Response:
     try:
         payload = await request.json()
@@ -345,35 +277,43 @@ async def create_asset_from_hash_route(request: web.Request) -> web.Response:
             400, "INVALID_JSON", "Request body must be valid JSON."
         )
 
-    # Derive name from hash if not provided
-    name = body.name
-    if name is None:
-        name = body.hash.split(":", 1)[1] if ":" in body.hash else body.hash
-
     result = create_from_hash(
         hash_str=body.hash,
-        name=name,
+        name=body.name,
         tags=body.tags,
         user_metadata=body.user_metadata,
         owner_id=USER_MANAGER.get_request_user_id(request),
-        mime_type=body.mime_type,
-        preview_id=body.preview_id,
     )
     if result is None:
         return _build_error_response(
             404, "ASSET_NOT_FOUND", f"Asset content {body.hash} does not exist"
         )
 
-    asset = _build_asset_response(result)
     payload_out = schemas_out.AssetCreated(
-        **asset.model_dump(),
+        id=result.info.id,
+        name=result.info.name,
+        asset_hash=result.asset.hash,
+        size=int(result.asset.size_bytes) if result.asset.size_bytes else None,
+        mime_type=result.asset.mime_type,
+        tags=result.tags,
+        user_metadata=result.info.user_metadata or {},
+        preview_id=result.info.preview_id,
+        created_at=result.info.created_at,
+        last_access_time=result.info.last_access_time,
         created_new=result.created_new,
     )
-    return web.json_response(payload_out.model_dump(mode="json", exclude_none=True), status=201)
+    return web.json_response(payload_out.model_dump(mode="json"), status=201)
+
+
+def _delete_temp_file_if_exists(path: str | None) -> None:
+    if path and os.path.exists(path):
+        try:
+            os.remove(path)
+        except Exception:
+            pass
 
 
 @ROUTES.post("/api/assets")
-@_require_assets_feature_enabled
 async def upload_asset(request: web.Request) -> web.Response:
     """Multipart/form-data endpoint for Asset uploads."""
     try:
@@ -390,12 +330,10 @@ async def upload_asset(request: web.Request) -> web.Response:
                 "name": parsed.provided_name,
                 "user_metadata": parsed.user_metadata_raw,
                 "hash": parsed.provided_hash,
-                "mime_type": parsed.provided_mime_type,
-                "preview_id": parsed.provided_preview_id,
             }
         )
     except ValidationError as ve:
-        delete_temp_file_if_exists(parsed.tmp_path)
+        _delete_temp_file_if_exists(parsed.tmp_path)
         return _build_error_response(
             400, "INVALID_BODY", f"Validation failed: {ve.json()}"
         )
@@ -405,14 +343,14 @@ async def upload_asset(request: web.Request) -> web.Response:
             len(spec.tags) < 2
             or spec.tags[1] not in folder_paths.folder_names_and_paths
         ):
-            delete_temp_file_if_exists(parsed.tmp_path)
+            _delete_temp_file_if_exists(parsed.tmp_path)
             category = spec.tags[1] if len(spec.tags) >= 2 else ""
             return _build_error_response(
                 400, "INVALID_BODY", f"unknown models category '{category}'"
             )
 
     try:
-        # Fast path: hash exists, create AssetReference without writing anything
+        # Fast path: if a valid provided hash exists, create AssetInfo without writing anything
         if spec.hash and parsed.provided_hash_exists is True:
             result = create_from_hash(
                 hash_str=spec.hash,
@@ -420,21 +358,19 @@ async def upload_asset(request: web.Request) -> web.Response:
                 tags=spec.tags,
                 user_metadata=spec.user_metadata or {},
                 owner_id=owner_id,
-                mime_type=spec.mime_type,
-                preview_id=spec.preview_id,
             )
             if result is None:
-                delete_temp_file_if_exists(parsed.tmp_path)
+                _delete_temp_file_if_exists(parsed.tmp_path)
                 return _build_error_response(
                     404, "ASSET_NOT_FOUND", f"Asset content {spec.hash} does not exist"
                 )
-            delete_temp_file_if_exists(parsed.tmp_path)
+            _delete_temp_file_if_exists(parsed.tmp_path)
         else:
             # Otherwise, we must have a temp file path to ingest
             if not parsed.tmp_path or not os.path.exists(parsed.tmp_path):
                 return _build_error_response(
-                    400,
-                    "MISSING_INPUT",
+                    404,
+                    "ASSET_NOT_FOUND",
                     "Provided hash not found and no file uploaded.",
                 )
 
@@ -446,39 +382,44 @@ async def upload_asset(request: web.Request) -> web.Response:
                 client_filename=parsed.file_client_name,
                 owner_id=owner_id,
                 expected_hash=spec.hash,
-                mime_type=spec.mime_type,
-                preview_id=spec.preview_id,
             )
     except AssetValidationError as e:
-        delete_temp_file_if_exists(parsed.tmp_path)
+        _delete_temp_file_if_exists(parsed.tmp_path)
         return _build_error_response(400, e.code, str(e))
     except ValueError as e:
-        delete_temp_file_if_exists(parsed.tmp_path)
+        _delete_temp_file_if_exists(parsed.tmp_path)
         return _build_error_response(400, "BAD_REQUEST", str(e))
     except HashMismatchError as e:
-        delete_temp_file_if_exists(parsed.tmp_path)
+        _delete_temp_file_if_exists(parsed.tmp_path)
         return _build_error_response(400, "HASH_MISMATCH", str(e))
     except DependencyMissingError as e:
-        delete_temp_file_if_exists(parsed.tmp_path)
+        _delete_temp_file_if_exists(parsed.tmp_path)
         return _build_error_response(503, "DEPENDENCY_MISSING", e.message)
     except Exception:
-        delete_temp_file_if_exists(parsed.tmp_path)
+        _delete_temp_file_if_exists(parsed.tmp_path)
         logging.exception("upload_asset failed for owner_id=%s", owner_id)
         return _build_error_response(500, "INTERNAL", "Unexpected server error.")
 
-    asset = _build_asset_response(result)
-    payload_out = schemas_out.AssetCreated(
-        **asset.model_dump(),
+    payload = schemas_out.AssetCreated(
+        id=result.info.id,
+        name=result.info.name,
+        asset_hash=result.asset.hash,
+        size=int(result.asset.size_bytes) if result.asset.size_bytes else None,
+        mime_type=result.asset.mime_type,
+        tags=result.tags,
+        user_metadata=result.info.user_metadata or {},
+        preview_id=result.info.preview_id,
+        created_at=result.info.created_at,
+        last_access_time=result.info.last_access_time,
         created_new=result.created_new,
     )
     status = 201 if result.created_new else 200
-    return web.json_response(payload_out.model_dump(mode="json", exclude_none=True), status=status)
+    return web.json_response(payload.model_dump(mode="json"), status=status)
 
 
 @ROUTES.put(f"/api/assets/{{id:{UUID_RE}}}")
-@_require_assets_feature_enabled
 async def update_asset_route(request: web.Request) -> web.Response:
-    reference_id = str(uuid.UUID(request.match_info["id"]))
+    asset_info_id = str(uuid.UUID(request.match_info["id"]))
     try:
         body = schemas_in.UpdateAssetBody.model_validate(await request.json())
     except ValidationError as ve:
@@ -490,63 +431,65 @@ async def update_asset_route(request: web.Request) -> web.Response:
 
     try:
         result = update_asset_metadata(
-            reference_id=reference_id,
+            asset_info_id=asset_info_id,
             name=body.name,
             user_metadata=body.user_metadata,
             owner_id=USER_MANAGER.get_request_user_id(request),
-            preview_id=body.preview_id,
         )
-        payload = _build_asset_response(result)
-    except PermissionError as pe:
-        return _build_error_response(403, "FORBIDDEN", str(pe), {"id": reference_id})
-    except ValueError as ve:
+        payload = schemas_out.AssetUpdated(
+            id=result.info.id,
+            name=result.info.name,
+            asset_hash=result.asset.hash if result.asset else None,
+            tags=result.tags,
+            user_metadata=result.info.user_metadata or {},
+            updated_at=result.info.updated_at,
+        )
+    except (ValueError, PermissionError) as ve:
         return _build_error_response(
-            404, "ASSET_NOT_FOUND", str(ve), {"id": reference_id}
+            404, "ASSET_NOT_FOUND", str(ve), {"id": asset_info_id}
         )
     except Exception:
         logging.exception(
-            "update_asset failed for reference_id=%s, owner_id=%s",
-            reference_id,
+            "update_asset failed for asset_info_id=%s, owner_id=%s",
+            asset_info_id,
             USER_MANAGER.get_request_user_id(request),
         )
         return _build_error_response(500, "INTERNAL", "Unexpected server error.")
-    return web.json_response(payload.model_dump(mode="json", exclude_none=True), status=200)
+    return web.json_response(payload.model_dump(mode="json"), status=200)
 
 
 @ROUTES.delete(f"/api/assets/{{id:{UUID_RE}}}")
-@_require_assets_feature_enabled
 async def delete_asset_route(request: web.Request) -> web.Response:
-    reference_id = str(uuid.UUID(request.match_info["id"]))
+    asset_info_id = str(uuid.UUID(request.match_info["id"]))
     delete_content_param = request.query.get("delete_content")
     delete_content = (
-        False
+        True
         if delete_content_param is None
         else delete_content_param.lower() not in {"0", "false", "no"}
     )
 
     try:
         deleted = delete_asset_reference(
-            reference_id=reference_id,
+            asset_info_id=asset_info_id,
             owner_id=USER_MANAGER.get_request_user_id(request),
             delete_content_if_orphan=delete_content,
         )
     except Exception:
         logging.exception(
-            "delete_asset_reference failed for reference_id=%s, owner_id=%s",
-            reference_id,
+            "delete_asset_reference failed for asset_info_id=%s, owner_id=%s",
+            asset_info_id,
             USER_MANAGER.get_request_user_id(request),
         )
         return _build_error_response(500, "INTERNAL", "Unexpected server error.")
 
     if not deleted:
         return _build_error_response(
-            404, "ASSET_NOT_FOUND", f"AssetReference {reference_id} not found."
+            404, "ASSET_NOT_FOUND", f"AssetInfo {asset_info_id} not found."
         )
     return web.Response(status=204)
 
 
 @ROUTES.get("/api/tags")
-@_require_assets_feature_enabled
 async def get_tags(request: web.Request) -> web.Response:
     """
     GET request to list all tags based on query parameters.
@@ -556,11 +499,15 @@ async def get_tags(request: web.Request) -> web.Response:
     try:
         query = schemas_in.TagsListQuery.model_validate(query_map)
     except ValidationError as e:
-        return _build_error_response(
-            400,
-            "INVALID_QUERY",
-            "Invalid query parameters",
-            {"errors": json.loads(e.json())},
+        return web.json_response(
+            {
+                "error": {
+                    "code": "INVALID_QUERY",
+                    "message": "Invalid query parameters",
+                    "details": e.errors(),
+                }
+            },
+            status=400,
         )
 
     rows, total = list_tags(
@@ -579,13 +526,12 @@ async def get_tags(request: web.Request) -> web.Response:
     payload = schemas_out.TagsList(
         tags=tags, total=total, has_more=(query.offset + len(tags)) < total
     )
-    return web.json_response(payload.model_dump(mode="json", exclude_none=True))
+    return web.json_response(payload.model_dump(mode="json"))
 
 
 @ROUTES.post(f"/api/assets/{{id:{UUID_RE}}}/tags")
-@_require_assets_feature_enabled
 async def add_asset_tags(request: web.Request) -> web.Response:
-    reference_id = str(uuid.UUID(request.match_info["id"]))
+    asset_info_id = str(uuid.UUID(request.match_info["id"]))
     try:
         json_payload = await request.json()
         data = schemas_in.TagsAdd.model_validate(json_payload)
@@ -603,7 +549,7 @@ async def add_asset_tags(request: web.Request) -> web.Response:
 
     try:
         result = apply_tags(
-            reference_id=reference_id,
+            asset_info_id=asset_info_id,
             tags=data.tags,
             origin="manual",
             owner_id=USER_MANAGER.get_request_user_id(request),
@@ -613,27 +559,24 @@ async def add_asset_tags(request: web.Request) -> web.Response:
             already_present=result.already_present,
             total_tags=result.total_tags,
         )
-    except PermissionError as pe:
-        return _build_error_response(403, "FORBIDDEN", str(pe), {"id": reference_id})
-    except ValueError as ve:
+    except (ValueError, PermissionError) as ve:
         return _build_error_response(
-            404, "ASSET_NOT_FOUND", str(ve), {"id": reference_id}
+            404, "ASSET_NOT_FOUND", str(ve), {"id": asset_info_id}
         )
     except Exception:
         logging.exception(
-            "add_tags_to_asset failed for reference_id=%s, owner_id=%s",
-            reference_id,
+            "add_tags_to_asset failed for asset_info_id=%s, owner_id=%s",
+            asset_info_id,
             USER_MANAGER.get_request_user_id(request),
         )
         return _build_error_response(500, "INTERNAL", "Unexpected server error.")
 
-    return web.json_response(payload.model_dump(mode="json", exclude_none=True), status=200)
+    return web.json_response(payload.model_dump(mode="json"), status=200)
 
 
 @ROUTES.delete(f"/api/assets/{{id:{UUID_RE}}}/tags")
-@_require_assets_feature_enabled
 async def delete_asset_tags(request: web.Request) -> web.Response:
-    reference_id = str(uuid.UUID(request.match_info["id"]))
+    asset_info_id = str(uuid.UUID(request.match_info["id"]))
     try:
         json_payload = await request.json()
         data = schemas_in.TagsRemove.model_validate(json_payload)
@@ -651,7 +594,7 @@ async def delete_asset_tags(request: web.Request) -> web.Response:
 
     try:
         result = remove_tags(
-            reference_id=reference_id,
+            asset_info_id=asset_info_id,
             tags=data.tags,
             owner_id=USER_MANAGER.get_request_user_id(request),
         )
@@ -660,145 +603,38 @@ async def delete_asset_tags(request: web.Request) -> web.Response:
             not_present=result.not_present,
             total_tags=result.total_tags,
         )
-    except PermissionError as pe:
-        return _build_error_response(403, "FORBIDDEN", str(pe), {"id": reference_id})
     except ValueError as ve:
         return _build_error_response(
-            404, "ASSET_NOT_FOUND", str(ve), {"id": reference_id}
+            404, "ASSET_NOT_FOUND", str(ve), {"id": asset_info_id}
         )
     except Exception:
         logging.exception(
-            "remove_tags_from_asset failed for reference_id=%s, owner_id=%s",
-            reference_id,
+            "remove_tags_from_asset failed for asset_info_id=%s, owner_id=%s",
+            asset_info_id,
             USER_MANAGER.get_request_user_id(request),
         )
         return _build_error_response(500, "INTERNAL", "Unexpected server error.")
 
-    return web.json_response(payload.model_dump(mode="json", exclude_none=True), status=200)
-
-
-@ROUTES.get("/api/assets/tags/refine")
-@_require_assets_feature_enabled
-async def get_tags_refine(request: web.Request) -> web.Response:
-    """GET request to get tag histogram for filtered assets."""
-    query_dict = get_query_dict(request)
-    try:
-        q = schemas_in.TagsRefineQuery.model_validate(query_dict)
-    except ValidationError as ve:
-        return _build_validation_error_response("INVALID_QUERY", ve)
-
-    tag_counts = list_tag_histogram(
-        owner_id=USER_MANAGER.get_request_user_id(request),
-        include_tags=q.include_tags,
-        exclude_tags=q.exclude_tags,
-        name_contains=q.name_contains,
-        metadata_filter=q.metadata_filter,
-        limit=q.limit,
-    )
-    payload = schemas_out.TagHistogram(tag_counts=tag_counts)
-    return web.json_response(payload.model_dump(mode="json", exclude_none=True), status=200)
+    return web.json_response(payload.model_dump(mode="json"), status=200)
 
 
 @ROUTES.post("/api/assets/seed")
-@_require_assets_feature_enabled
 async def seed_assets(request: web.Request) -> web.Response:
-    """Trigger asset seeding for specified roots (models, input, output).
-
-    Query params:
-        wait: If "true", block until scan completes (synchronous behavior for tests)
-
-    Returns:
-        202 Accepted if scan started
-        409 Conflict if scan already running
-        200 OK with final stats if wait=true
-    """
+    """Trigger asset seeding for specified roots (models, input, output)."""
     try:
         payload = await request.json()
         roots = payload.get("roots", ["models", "input", "output"])
     except Exception:
         roots = ["models", "input", "output"]
 
-    valid_roots = tuple(r for r in roots if r in ("models", "input", "output"))
+    valid_roots = [r for r in roots if r in ("models", "input", "output")]
     if not valid_roots:
         return _build_error_response(400, "INVALID_BODY", "No valid roots specified")
 
-    wait_param = request.query.get("wait", "").lower()
-    should_wait = wait_param in ("true", "1", "yes")
-
-    started = asset_seeder.start(roots=valid_roots)
-    if not started:
-        return web.json_response({"status": "already_running"}, status=409)
-
-    if should_wait:
-        await asyncio.to_thread(asset_seeder.wait)
-        status = asset_seeder.get_status()
-        return web.json_response(
-            {
-                "status": "completed",
-                "progress": {
-                    "scanned": status.progress.scanned if status.progress else 0,
-                    "total": status.progress.total if status.progress else 0,
-                    "created": status.progress.created if status.progress else 0,
-                    "skipped": status.progress.skipped if status.progress else 0,
-                },
-                "errors": status.errors,
-            },
-            status=200,
-        )
-
-    return web.json_response({"status": "started"}, status=202)
-
-
-@ROUTES.get("/api/assets/seed/status")
-@_require_assets_feature_enabled
-async def get_seed_status(request: web.Request) -> web.Response:
-    """Get current scan status and progress."""
-    status = asset_seeder.get_status()
-    return web.json_response(
-        {
-            "state": status.state.value,
-            "progress": {
-                "scanned": status.progress.scanned,
-                "total": status.progress.total,
-                "created": status.progress.created,
-                "skipped": status.progress.skipped,
-            }
-            if status.progress
-            else None,
-            "errors": status.errors,
-        },
-        status=200,
-    )
-
-
-@ROUTES.post("/api/assets/seed/cancel")
-@_require_assets_feature_enabled
-async def cancel_seed(request: web.Request) -> web.Response:
-    """Request cancellation of in-progress scan."""
-    cancelled = asset_seeder.cancel()
-    if cancelled:
-        return web.json_response({"status": "cancelling"}, status=200)
-    return web.json_response({"status": "idle"}, status=200)
-
-
-@ROUTES.post("/api/assets/prune")
-@_require_assets_feature_enabled
-async def mark_missing_assets(request: web.Request) -> web.Response:
-    """Mark assets as missing when outside all known root prefixes.
-
-    This is a non-destructive soft-delete operation. Assets and metadata
-    are preserved, but references are flagged as missing. They can be
-    restored if the file reappears in a future scan.
-
-    Returns:
-        200 OK with count of marked assets
-        409 Conflict if a scan is currently running
-    """
     try:
-        marked = asset_seeder.mark_missing_outside_prefixes()
-    except ScanInProgressError:
-        return web.json_response(
-            {"status": "scan_running", "marked": 0},
-            status=409,
-        )
-    return web.json_response({"status": "completed", "marked": marked}, status=200)
+        scanner_seed_assets(tuple(valid_roots))
+    except Exception:
+        logging.exception("scanner_seed_assets failed for roots=%s", valid_roots)
+        return _build_error_response(500, "INTERNAL", "Seed operation failed")
+
+    return web.json_response({"seeded": valid_roots}, status=200)

app/assets/api/schemas_in.py

@@ -2,7 +2,6 @@ import json
 from dataclasses import dataclass
 from typing import Any, Literal
 
-from app.assets.helpers import validate_blake3_hash
 from pydantic import (
     BaseModel,
     ConfigDict,
@@ -14,7 +13,7 @@ from pydantic import (
 
 
 class UploadError(Exception):
-    """Error during upload parsing with HTTP status and code."""
+    """Error during upload parsing with HTTP status and code (used in HTTP layer only)."""
 
     def __init__(self, status: int, code: str, message: str):
         super().__init__(message)
@@ -29,6 +28,26 @@ class AssetValidationError(Exception):
     def __init__(self, code: str, message: str):
         super().__init__(message)
         self.code = code
+
+
+class AssetNotFoundError(Exception):
+    """Asset or asset content not found."""
+
+    def __init__(self, message: str):
+        super().__init__(message)
+
+
+class HashMismatchError(Exception):
+    """Uploaded file hash does not match provided hash."""
+
+    pass
+
+
+class DependencyMissingError(Exception):
+    """A required dependency is not installed."""
+
+    def __init__(self, message: str):
+        super().__init__(message)
         self.message = message
 
 
@@ -45,8 +64,6 @@ class ParsedUpload:
     user_metadata_raw: str | None
     provided_hash: str | None
     provided_hash_exists: bool | None
-    provided_mime_type: str | None = None
-    provided_preview_id: str | None = None
 
 
 class ListAssetsQuery(BaseModel):
@@ -100,17 +117,11 @@ class ListAssetsQuery(BaseModel):
 class UpdateAssetBody(BaseModel):
     name: str | None = None
     user_metadata: dict[str, Any] | None = None
-    preview_id: str | None = None  # references an asset_reference id, not an asset id
 
     @model_validator(mode="after")
     def _validate_at_least_one_field(self):
-        if all(
-            v is None
-            for v in (self.name, self.user_metadata, self.preview_id)
-        ):
-            raise ValueError(
-                "Provide at least one of: name, user_metadata, preview_id."
-            )
+        if self.name is None and self.user_metadata is None:
+            raise ValueError("Provide at least one of: name, user_metadata.")
         return self
 
 
@@ -118,16 +129,22 @@ class CreateFromHashBody(BaseModel):
     model_config = ConfigDict(extra="ignore", str_strip_whitespace=True)
 
     hash: str
-    name: str | None = None
+    name: str
     tags: list[str] = Field(default_factory=list)
     user_metadata: dict[str, Any] = Field(default_factory=dict)
-    mime_type: str | None = None
-    preview_id: str | None = None  # references an asset_reference id, not an asset id
 
     @field_validator("hash")
     @classmethod
     def _require_blake3(cls, v):
-        return validate_blake3_hash(v or "")
+        s = (v or "").strip().lower()
+        if ":" not in s:
+            raise ValueError("hash must be 'blake3:<hex>'")
+        algo, digest = s.split(":", 1)
+        if algo != "blake3":
+            raise ValueError("only canonical 'blake3:<hex>' is accepted here")
+        if not digest or any(c for c in digest if c not in "0123456789abcdef"):
+            raise ValueError("hash digest must be lowercase hex")
+        return s
 
     @field_validator("tags", mode="before")
     @classmethod
@@ -148,44 +165,6 @@ class CreateFromHashBody(BaseModel):
         return []
 
 
-class TagsRefineQuery(BaseModel):
-    include_tags: list[str] = Field(default_factory=list)
-    exclude_tags: list[str] = Field(default_factory=list)
-    name_contains: str | None = None
-    metadata_filter: dict[str, Any] | None = None
-    limit: conint(ge=1, le=1000) = 100
-
-    @field_validator("include_tags", "exclude_tags", mode="before")
-    @classmethod
-    def _split_csv_tags(cls, v):
-        if v is None:
-            return []
-        if isinstance(v, str):
-            return [t.strip() for t in v.split(",") if t.strip()]
-        if isinstance(v, list):
-            out: list[str] = []
-            for item in v:
-                if isinstance(item, str):
-                    out.extend([t.strip() for t in item.split(",") if t.strip()])
-            return out
-        return v
-
-    @field_validator("metadata_filter", mode="before")
-    @classmethod
-    def _parse_metadata_json(cls, v):
-        if v is None or isinstance(v, dict):
-            return v
-        if isinstance(v, str) and v.strip():
-            try:
-                parsed = json.loads(v)
-            except Exception as e:
-                raise ValueError(f"metadata_filter must be JSON: {e}") from e
-            if not isinstance(parsed, dict):
-                raise ValueError("metadata_filter must be a JSON object")
-            return parsed
-        return None
-
-
 class TagsListQuery(BaseModel):
     model_config = ConfigDict(extra="ignore", str_strip_whitespace=True)
 
@@ -233,36 +212,39 @@ class TagsRemove(TagsAdd):
 
 class UploadAssetSpec(BaseModel):
     """Upload Asset operation.
-
-    - tags: optional list; if provided, first is root ('models'|'input'|'output');
-            if root == 'models', second must be a valid category
+    - tags: ordered; first is root ('models'|'input'|'output');
+            if root == 'models', second must be a valid category from folder_paths.folder_names_and_paths
     - name: display name
     - user_metadata: arbitrary JSON object (optional)
-    - hash: optional canonical 'blake3:<hex>' for validation / fast-path
-    - mime_type: optional MIME type override
-    - preview_id: optional asset_reference ID for preview
+    - hash: optional canonical 'blake3:<hex>' provided by the client for validation / fast-path
 
-    Files are stored using the content hash as filename stem.
+    Files created via this endpoint are stored on disk using the **content hash** as the filename stem
+    and the original extension is preserved when available.
     """
 
     model_config = ConfigDict(extra="ignore", str_strip_whitespace=True)
 
-    tags: list[str] = Field(default_factory=list)
+    tags: list[str] = Field(..., min_length=1)
     name: str | None = Field(default=None, max_length=512, description="Display Name")
     user_metadata: dict[str, Any] = Field(default_factory=dict)
     hash: str | None = Field(default=None)
-    mime_type: str | None = Field(default=None)
-    preview_id: str | None = Field(default=None)  # references an asset_reference id
 
     @field_validator("hash", mode="before")
     @classmethod
     def _parse_hash(cls, v):
         if v is None:
             return None
-        s = str(v).strip()
+        s = str(v).strip().lower()
         if not s:
             return None
-        return validate_blake3_hash(s)
+        if ":" not in s:
+            raise ValueError("hash must be 'blake3:<hex>'")
+        algo, digest = s.split(":", 1)
+        if algo != "blake3":
+            raise ValueError("only canonical 'blake3:<hex>' is accepted here")
+        if not digest or any(c for c in digest if c not in "0123456789abcdef"):
+            raise ValueError("hash digest must be lowercase hex")
+        return f"{algo}:{digest}"
 
     @field_validator("tags", mode="before")
     @classmethod
@@ -331,7 +313,7 @@ class UploadAssetSpec(BaseModel):
     @model_validator(mode="after")
     def _validate_order(self):
         if not self.tags:
-            raise ValueError("at least one tag is required for uploads")
+            raise ValueError("tags must be provided and non-empty")
         root = self.tags[0]
         if root not in {"models", "input", "output"}:
             raise ValueError("first tag must be one of: models, input, output")

app/assets/api/schemas_out.py

@@ -4,10 +4,7 @@ from typing import Any
 from pydantic import BaseModel, ConfigDict, Field, field_serializer
 
 
-class Asset(BaseModel):
-    """API view of an asset. Maps to DB ``AssetReference`` joined with its ``Asset`` blob;
-    ``id`` here is the AssetReference id, not the content-addressed Asset id."""
-
+class AssetSummary(BaseModel):
     id: str
     name: str
     asset_hash: str | None = None
@@ -15,14 +12,8 @@ class Asset(BaseModel):
     mime_type: str | None = None
     tags: list[str] = Field(default_factory=list)
     preview_url: str | None = None
-    preview_id: str | None = None  # references an asset_reference id, not an asset id
-    user_metadata: dict[str, Any] = Field(default_factory=dict)
-    is_immutable: bool = False
-    metadata: dict[str, Any] | None = None
-    job_id: str | None = None
-    prompt_id: str | None = None  # deprecated: use job_id
-    created_at: datetime
-    updated_at: datetime
+    created_at: datetime | None = None
+    updated_at: datetime | None = None
     last_access_time: datetime | None = None
 
     model_config = ConfigDict(from_attributes=True)
@@ -32,16 +23,50 @@ class Asset(BaseModel):
         return v.isoformat() if v else None
 
 
-class AssetCreated(Asset):
-    created_new: bool
-
-
 class AssetsList(BaseModel):
-    assets: list[Asset]
+    assets: list[AssetSummary]
     total: int
     has_more: bool
 
 
+class AssetUpdated(BaseModel):
+    id: str
+    name: str
+    asset_hash: str | None = None
+    tags: list[str] = Field(default_factory=list)
+    user_metadata: dict[str, Any] = Field(default_factory=dict)
+    updated_at: datetime | None = None
+
+    model_config = ConfigDict(from_attributes=True)
+
+    @field_serializer("updated_at")
+    def _serialize_updated_at(self, v: datetime | None, _info):
+        return v.isoformat() if v else None
+
+
+class AssetDetail(BaseModel):
+    id: str
+    name: str
+    asset_hash: str | None = None
+    size: int | None = None
+    mime_type: str | None = None
+    tags: list[str] = Field(default_factory=list)
+    user_metadata: dict[str, Any] = Field(default_factory=dict)
+    preview_id: str | None = None
+    created_at: datetime | None = None
+    last_access_time: datetime | None = None
+
+    model_config = ConfigDict(from_attributes=True)
+
+    @field_serializer("created_at", "last_access_time")
+    def _serialize_datetime(self, v: datetime | None, _info):
+        return v.isoformat() if v else None
+
+
+class AssetCreated(AssetDetail):
+    created_new: bool
+
+
 class TagUsage(BaseModel):
     name: str
     count: int
@@ -66,7 +91,3 @@ class TagsRemove(BaseModel):
     removed: list[str] = Field(default_factory=list)
     not_present: list[str] = Field(default_factory=list)
     total_tags: list[str] = Field(default_factory=list)
-
-
-class TagHistogram(BaseModel):
-    tag_counts: dict[str, int]

app/assets/api/upload.py

@@ -1,29 +1,36 @@
-import logging
 import os
 import uuid
-from typing import Callable
 
 from aiohttp import web
 
 import folder_paths
 from app.assets.api.schemas_in import ParsedUpload, UploadError
-from app.assets.helpers import validate_blake3_hash
 
 
 def normalize_and_validate_hash(s: str) -> str:
-    """Validate and normalize a hash string.
+    """
+    Validate and normalize a hash string.
 
     Returns canonical 'blake3:<hex>' or raises UploadError.
     """
-    try:
-        return validate_blake3_hash(s)
-    except ValueError:
+    s = s.strip().lower()
+    if not s:
         raise UploadError(400, "INVALID_HASH", "hash must be like 'blake3:<hex>'")
+    if ":" not in s:
+        raise UploadError(400, "INVALID_HASH", "hash must be like 'blake3:<hex>'")
+    algo, digest = s.split(":", 1)
+    if (
+        algo != "blake3"
+        or not digest
+        or any(c for c in digest if c not in "0123456789abcdef")
+    ):
+        raise UploadError(400, "INVALID_HASH", "hash must be like 'blake3:<hex>'")
+    return f"{algo}:{digest}"
 
 
 async def parse_multipart_upload(
     request: web.Request,
-    check_hash_exists: Callable[[str], bool],
+    check_hash_exists: callable,
 ) -> ParsedUpload:
     """
     Parse a multipart/form-data upload request.
@@ -52,8 +59,6 @@ async def parse_multipart_upload(
     user_metadata_raw: str | None = None
     provided_hash: str | None = None
     provided_hash_exists: bool | None = None
-    provided_mime_type: str | None = None
-    provided_preview_id: str | None = None
 
     file_written = 0
     tmp_path: str | None = None
@@ -77,22 +82,15 @@ async def parse_multipart_upload(
                 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.",
-                    )
+                except Exception:
+                    provided_hash_exists = None  # do not fail the whole request here
 
         elif fname == "file":
             file_present = True
             file_client_name = (field.filename or "").strip()
 
             if provided_hash and provided_hash_exists is True:
-                # Hash exists - drain file but don't write to disk
+                # If client supplied a hash that we know exists, drain but do not write to disk
                 try:
                     while True:
                         chunk = await field.read_chunk(8 * 1024 * 1024)
@@ -119,7 +117,7 @@ async def parse_multipart_upload(
                         f.write(chunk)
                         file_written += len(chunk)
             except Exception:
-                delete_temp_file_if_exists(tmp_path)
+                _delete_temp_file_if_exists(tmp_path)
                 raise UploadError(
                     500, "UPLOAD_IO_ERROR", "Failed to receive and store uploaded file."
                 )
@@ -130,16 +128,6 @@ async def parse_multipart_upload(
             provided_name = (await field.text()) or None
         elif fname == "user_metadata":
             user_metadata_raw = (await field.text()) or None
-        elif fname == "id":
-            raise UploadError(
-                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
 
     if not file_present and not (provided_hash and provided_hash_exists):
         raise UploadError(
@@ -151,7 +139,7 @@ async def parse_multipart_upload(
         and file_written == 0
         and not (provided_hash and provided_hash_exists)
     ):
-        delete_temp_file_if_exists(tmp_path)
+        _delete_temp_file_if_exists(tmp_path)
         raise UploadError(400, "EMPTY_UPLOAD", "Uploaded file is empty.")
 
     return ParsedUpload(
@@ -164,22 +152,14 @@ async def parse_multipart_upload(
         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,
     )
 
 
-def delete_temp_file_if_exists(tmp_path: str | None) -> None:
-    """Safely remove a temp file and its parent directory if empty."""
+def _delete_temp_file_if_exists(tmp_path: str | None) -> None:
+    """Safely remove a temp file if it exists."""
     if tmp_path:
         try:
             if os.path.exists(tmp_path):
                 os.remove(tmp_path)
-        except OSError as e:
-            logging.debug("Failed to delete temp file %s: %s", tmp_path, e)
-        try:
-            parent = os.path.dirname(tmp_path)
-            if parent and os.path.isdir(parent):
-                os.rmdir(parent)  # only succeeds if empty
-        except OSError:
+        except Exception:
             pass

app/assets/database/models.py

@@ -16,11 +16,12 @@ from sqlalchemy import (
     Numeric,
     String,
     Text,
+    UniqueConstraint,
 )
 from sqlalchemy.orm import Mapped, foreign, mapped_column, relationship
 
 from app.assets.helpers import get_utc_now
-from app.database.models import Base
+from app.database.models import Base, to_dict
 
 
 class Asset(Base):
@@ -36,16 +37,28 @@ class Asset(Base):
         DateTime(timezone=False), nullable=False, default=get_utc_now
     )
 
-    references: Mapped[list[AssetReference]] = relationship(
-        "AssetReference",
+    infos: Mapped[list[AssetInfo]] = relationship(
+        "AssetInfo",
         back_populates="asset",
-        primaryjoin=lambda: Asset.id == foreign(AssetReference.asset_id),
-        foreign_keys=lambda: [AssetReference.asset_id],
+        primaryjoin=lambda: Asset.id == foreign(AssetInfo.asset_id),
+        foreign_keys=lambda: [AssetInfo.asset_id],
         cascade="all,delete-orphan",
         passive_deletes=True,
     )
 
-    # preview_id on AssetReference is a self-referential FK to asset_references.id
+    preview_of: Mapped[list[AssetInfo]] = relationship(
+        "AssetInfo",
+        back_populates="preview_asset",
+        primaryjoin=lambda: Asset.id == foreign(AssetInfo.preview_id),
+        foreign_keys=lambda: [AssetInfo.preview_id],
+        viewonly=True,
+    )
+
+    cache_states: Mapped[list[AssetCacheState]] = relationship(
+        back_populates="asset",
+        cascade="all, delete-orphan",
+        passive_deletes=True,
+    )
 
     __table_args__ = (
         Index("uq_assets_hash", "hash", unique=True),
@@ -53,47 +66,59 @@ class Asset(Base):
         CheckConstraint("size_bytes >= 0", name="ck_assets_size_nonneg"),
     )
 
+    def to_dict(self, include_none: bool = False) -> dict[str, Any]:
+        return to_dict(self, include_none=include_none)
+
     def __repr__(self) -> str:
         return f"<Asset id={self.id} hash={(self.hash or '')[:12]}>"
 
 
-class AssetReference(Base):
-    """Unified model combining file cache state and user-facing metadata.
+class AssetCacheState(Base):
+    __tablename__ = "asset_cache_state"
 
-    Each row represents either:
-    - A filesystem reference (file_path is set) with cache state
-    - An API-created reference (file_path is NULL) without cache state
-    """
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+    asset_id: Mapped[str] = mapped_column(
+        String(36), ForeignKey("assets.id", ondelete="CASCADE"), nullable=False
+    )
+    file_path: Mapped[str] = mapped_column(Text, nullable=False)
+    mtime_ns: Mapped[int | None] = mapped_column(BigInteger, nullable=True)
+    needs_verify: Mapped[bool] = mapped_column(Boolean, nullable=False, default=False)
 
-    __tablename__ = "asset_references"
+    asset: Mapped[Asset] = relationship(back_populates="cache_states")
+
+    __table_args__ = (
+        Index("ix_asset_cache_state_file_path", "file_path"),
+        Index("ix_asset_cache_state_asset_id", "asset_id"),
+        CheckConstraint(
+            "(mtime_ns IS NULL) OR (mtime_ns >= 0)", name="ck_acs_mtime_nonneg"
+        ),
+        UniqueConstraint("file_path", name="uq_asset_cache_state_file_path"),
+    )
+
+    def to_dict(self, include_none: bool = False) -> dict[str, Any]:
+        return to_dict(self, include_none=include_none)
+
+    def __repr__(self) -> str:
+        return f"<AssetCacheState id={self.id} asset_id={self.asset_id} path={self.file_path!r}>"
+
+
+class AssetInfo(Base):
+    __tablename__ = "assets_info"
 
     id: Mapped[str] = mapped_column(
         String(36), primary_key=True, default=lambda: str(uuid.uuid4())
     )
-    asset_id: Mapped[str] = mapped_column(
-        String(36), ForeignKey("assets.id", ondelete="CASCADE"), nullable=False
-    )
-
-    # Cache state fields (from former AssetCacheState)
-    file_path: Mapped[str | None] = mapped_column(Text, nullable=True)
-    mtime_ns: Mapped[int | None] = mapped_column(BigInteger, nullable=True)
-    needs_verify: Mapped[bool] = mapped_column(Boolean, nullable=False, default=False)
-    is_missing: Mapped[bool] = mapped_column(Boolean, nullable=False, default=False)
-    enrichment_level: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
-
-    # Info fields (from former AssetInfo)
     owner_id: Mapped[str] = mapped_column(String(128), nullable=False, default="")
     name: Mapped[str] = mapped_column(String(512), nullable=False)
+    asset_id: Mapped[str] = mapped_column(
+        String(36), ForeignKey("assets.id", ondelete="RESTRICT"), nullable=False
+    )
     preview_id: Mapped[str | None] = mapped_column(
-        String(36), ForeignKey("asset_references.id", ondelete="SET NULL")
+        String(36), ForeignKey("assets.id", ondelete="SET NULL")
     )
     user_metadata: Mapped[dict[str, Any] | None] = mapped_column(
         JSON(none_as_null=True)
     )
-    system_metadata: Mapped[dict[str, Any] | None] = mapped_column(
-        JSON(none_as_null=True), nullable=True, default=None
-    )
-    job_id: Mapped[str | None] = mapped_column(String(36), nullable=True, default=None)
     created_at: Mapped[datetime] = mapped_column(
         DateTime(timezone=False), nullable=False, default=get_utc_now
     )
@@ -103,76 +128,66 @@ class AssetReference(Base):
     last_access_time: Mapped[datetime] = mapped_column(
         DateTime(timezone=False), nullable=False, default=get_utc_now
     )
-    deleted_at: Mapped[datetime | None] = mapped_column(
-        DateTime(timezone=False), nullable=True, default=None
-    )
 
     asset: Mapped[Asset] = relationship(
         "Asset",
-        back_populates="references",
+        back_populates="infos",
         foreign_keys=[asset_id],
         lazy="selectin",
     )
-    preview_ref: Mapped[AssetReference | None] = relationship(
-        "AssetReference",
+    preview_asset: Mapped[Asset | None] = relationship(
+        "Asset",
+        back_populates="preview_of",
         foreign_keys=[preview_id],
-        remote_side=lambda: [AssetReference.id],
     )
 
-    metadata_entries: Mapped[list[AssetReferenceMeta]] = relationship(
-        back_populates="asset_reference",
+    metadata_entries: Mapped[list[AssetInfoMeta]] = relationship(
+        back_populates="asset_info",
         cascade="all,delete-orphan",
         passive_deletes=True,
     )
 
-    tag_links: Mapped[list[AssetReferenceTag]] = relationship(
-        back_populates="asset_reference",
+    tag_links: Mapped[list[AssetInfoTag]] = relationship(
+        back_populates="asset_info",
         cascade="all,delete-orphan",
         passive_deletes=True,
-        overlaps="tags,asset_references",
+        overlaps="tags,asset_infos",
     )
 
     tags: Mapped[list[Tag]] = relationship(
-        secondary="asset_reference_tags",
-        back_populates="asset_references",
+        secondary="asset_info_tags",
+        back_populates="asset_infos",
         lazy="selectin",
         viewonly=True,
-        overlaps="tag_links,asset_reference_links,asset_references,tag",
+        overlaps="tag_links,asset_info_links,asset_infos,tag",
     )
 
     __table_args__ = (
-        Index("uq_asset_references_file_path", "file_path", unique=True),
-        Index("ix_asset_references_asset_id", "asset_id"),
-        Index("ix_asset_references_owner_id", "owner_id"),
-        Index("ix_asset_references_name", "name"),
-        Index("ix_asset_references_is_missing", "is_missing"),
-        Index("ix_asset_references_enrichment_level", "enrichment_level"),
-        Index("ix_asset_references_created_at", "created_at"),
-        Index("ix_asset_references_last_access_time", "last_access_time"),
-        Index("ix_asset_references_deleted_at", "deleted_at"),
-        Index("ix_asset_references_preview_id", "preview_id"),
-        Index("ix_asset_references_owner_name", "owner_id", "name"),
-        CheckConstraint(
-            "(mtime_ns IS NULL) OR (mtime_ns >= 0)", name="ck_ar_mtime_nonneg"
-        ),
-        CheckConstraint(
-            "enrichment_level >= 0 AND enrichment_level <= 2",
-            name="ck_ar_enrichment_level_range",
+        UniqueConstraint(
+            "asset_id", "owner_id", "name", name="uq_assets_info_asset_owner_name"
         ),
+        Index("ix_assets_info_owner_name", "owner_id", "name"),
+        Index("ix_assets_info_owner_id", "owner_id"),
+        Index("ix_assets_info_asset_id", "asset_id"),
+        Index("ix_assets_info_name", "name"),
+        Index("ix_assets_info_created_at", "created_at"),
+        Index("ix_assets_info_last_access_time", "last_access_time"),
     )
 
+    def to_dict(self, include_none: bool = False) -> dict[str, Any]:
+        data = to_dict(self, include_none=include_none)
+        data["tags"] = [t.name for t in self.tags]
+        return data
+
     def __repr__(self) -> str:
-        path_part = f" path={self.file_path!r}" if self.file_path else ""
-        return f"<AssetReference id={self.id} name={self.name!r}{path_part}>"
+        return f"<AssetInfo id={self.id} name={self.name!r} asset_id={self.asset_id}>"
 
 
-class AssetReferenceMeta(Base):
-    __tablename__ = "asset_reference_meta"
+class AssetInfoMeta(Base):
+    __tablename__ = "asset_info_meta"
 
-    asset_reference_id: Mapped[str] = mapped_column(
-        String(36),
-        ForeignKey("asset_references.id", ondelete="CASCADE"),
-        primary_key=True,
+    asset_info_id: Mapped[str] = mapped_column(
+        String(36), ForeignKey("assets_info.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)
@@ -182,29 +197,21 @@ class AssetReferenceMeta(Base):
     val_bool: Mapped[bool | None] = mapped_column(Boolean, nullable=True)
     val_json: Mapped[Any | None] = mapped_column(JSON(none_as_null=True), nullable=True)
 
-    asset_reference: Mapped[AssetReference] = relationship(
-        back_populates="metadata_entries"
-    )
+    asset_info: Mapped[AssetInfo] = relationship(back_populates="metadata_entries")
 
     __table_args__ = (
-        Index("ix_asset_reference_meta_key", "key"),
-        Index("ix_asset_reference_meta_key_val_str", "key", "val_str"),
-        Index("ix_asset_reference_meta_key_val_num", "key", "val_num"),
-        Index("ix_asset_reference_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="has_value",
-        ),
+        Index("ix_asset_info_meta_key", "key"),
+        Index("ix_asset_info_meta_key_val_str", "key", "val_str"),
+        Index("ix_asset_info_meta_key_val_num", "key", "val_num"),
+        Index("ix_asset_info_meta_key_val_bool", "key", "val_bool"),
     )
 
 
-class AssetReferenceTag(Base):
-    __tablename__ = "asset_reference_tags"
+class AssetInfoTag(Base):
+    __tablename__ = "asset_info_tags"
 
-    asset_reference_id: Mapped[str] = mapped_column(
-        String(36),
-        ForeignKey("asset_references.id", ondelete="CASCADE"),
-        primary_key=True,
+    asset_info_id: Mapped[str] = mapped_column(
+        String(36), ForeignKey("assets_info.id", ondelete="CASCADE"), primary_key=True
     )
     tag_name: Mapped[str] = mapped_column(
         String(512), ForeignKey("tags.name", ondelete="RESTRICT"), primary_key=True
@@ -214,12 +221,12 @@ class AssetReferenceTag(Base):
         DateTime(timezone=False), nullable=False, default=get_utc_now
     )
 
-    asset_reference: Mapped[AssetReference] = relationship(back_populates="tag_links")
-    tag: Mapped[Tag] = relationship(back_populates="asset_reference_links")
+    asset_info: Mapped[AssetInfo] = relationship(back_populates="tag_links")
+    tag: Mapped[Tag] = relationship(back_populates="asset_info_links")
 
     __table_args__ = (
-        Index("ix_asset_reference_tags_tag_name", "tag_name"),
-        Index("ix_asset_reference_tags_asset_reference_id", "asset_reference_id"),
+        Index("ix_asset_info_tags_tag_name", "tag_name"),
+        Index("ix_asset_info_tags_asset_info_id", "asset_info_id"),
     )
 
 
@@ -229,15 +236,15 @@ class Tag(Base):
     name: Mapped[str] = mapped_column(String(512), primary_key=True)
     tag_type: Mapped[str] = mapped_column(String(32), nullable=False, default="user")
 
-    asset_reference_links: Mapped[list[AssetReferenceTag]] = relationship(
+    asset_info_links: Mapped[list[AssetInfoTag]] = relationship(
         back_populates="tag",
-        overlaps="asset_references,tags",
+        overlaps="asset_infos,tags",
     )
-    asset_references: Mapped[list[AssetReference]] = relationship(
-        secondary="asset_reference_tags",
+    asset_infos: Mapped[list[AssetInfo]] = relationship(
+        secondary="asset_info_tags",
         back_populates="tags",
         viewonly=True,
-        overlaps="asset_reference_links,tag_links,tags,asset_reference",
+        overlaps="asset_info_links,tag_links,tags,asset_info",
     )
 
     __table_args__ = (Index("ix_tags_tag_type", "tag_type"),)

app/assets/database/queries/__init__.py

@@ -1,137 +1,99 @@
 from app.assets.database.queries.asset import (
     asset_exists_by_hash,
     bulk_insert_assets,
-    create_stub_asset,
     get_asset_by_hash,
-    get_existing_asset_ids,
-    reassign_asset_references,
-    update_asset_hash_and_mime,
     upsert_asset,
 )
-from app.assets.database.queries.asset_reference import (
+from app.assets.database.queries.asset_info import (
+    asset_info_exists_for_asset_id,
+    bulk_insert_asset_infos_ignore_conflicts,
+    delete_asset_info_by_id,
+    fetch_asset_info_and_asset,
+    fetch_asset_info_asset_and_tags,
+    get_asset_info_by_id,
+    get_asset_info_ids_by_ids,
+    get_or_create_asset_info,
+    insert_asset_info,
+    list_asset_infos_page,
+    set_asset_info_metadata,
+    set_asset_info_preview,
+    update_asset_info_access_time,
+    update_asset_info_name,
+    update_asset_info_timestamps,
+    update_asset_info_updated_at,
+)
+from app.assets.database.queries.cache_state import (
     CacheStateRow,
-    UnenrichedReferenceRow,
-    bulk_insert_references_ignore_conflicts,
-    bulk_update_enrichment_level,
-    count_active_siblings,
-    bulk_update_is_missing,
-    bulk_update_needs_verify,
-    convert_metadata_to_rows,
+    bulk_insert_cache_states_ignore_conflicts,
+    bulk_set_needs_verify,
     delete_assets_by_ids,
+    delete_cache_states_by_ids,
+    delete_cache_states_outside_prefixes,
     delete_orphaned_seed_asset,
-    delete_reference_by_id,
-    delete_references_by_ids,
-    fetch_reference_and_asset,
-    fetch_reference_asset_and_tags,
-    get_or_create_reference,
-    get_reference_by_file_path,
-    get_reference_by_id,
-    get_reference_with_owner_check,
-    get_reference_ids_by_ids,
-    get_references_by_paths_and_asset_ids,
-    get_references_for_prefixes,
-    get_unenriched_references,
-    get_unreferenced_unhashed_asset_ids,
-    insert_reference,
-    list_all_file_paths_by_asset_id,
-    list_references_by_asset_id,
-    list_references_page,
-    mark_references_missing_outside_prefixes,
-    rebuild_metadata_projection,
-    reference_exists,
-    reference_exists_for_asset_id,
-    restore_references_by_paths,
-    set_reference_metadata,
-    set_reference_preview,
-    set_reference_system_metadata,
-    soft_delete_reference_by_id,
-    update_reference_access_time,
-    update_reference_name,
-    update_is_missing_by_asset_id,
-    update_reference_timestamps,
-    update_reference_updated_at,
-    upsert_reference,
+    get_cache_states_by_paths_and_asset_ids,
+    get_cache_states_for_prefixes,
+    get_orphaned_seed_asset_ids,
+    list_cache_states_by_asset_id,
+    upsert_cache_state,
 )
 from app.assets.database.queries.tags import (
-    AddTagsResult,
-    RemoveTagsResult,
-    SetTagsResult,
+    AddTagsDict,
+    RemoveTagsDict,
+    SetTagsDict,
     add_missing_tag_for_asset_id,
-    add_tags_to_reference,
+    add_tags_to_asset_info,
     bulk_insert_tags_and_meta,
     ensure_tags_exist,
-    get_reference_tags,
-    list_tag_counts_for_filtered_assets,
+    get_asset_tags,
     list_tags_with_usage,
     remove_missing_tag_for_asset_id,
-    remove_tags_from_reference,
-    set_reference_tags,
-    validate_tags_exist,
+    remove_tags_from_asset_info,
+    set_asset_info_tags,
 )
 
 __all__ = [
-    "AddTagsResult",
+    "AddTagsDict",
     "CacheStateRow",
-    "RemoveTagsResult",
-    "SetTagsResult",
-    "UnenrichedReferenceRow",
+    "RemoveTagsDict",
+    "SetTagsDict",
     "add_missing_tag_for_asset_id",
-    "add_tags_to_reference",
+    "add_tags_to_asset_info",
     "asset_exists_by_hash",
+    "asset_info_exists_for_asset_id",
+    "bulk_insert_asset_infos_ignore_conflicts",
     "bulk_insert_assets",
-    "bulk_insert_references_ignore_conflicts",
+    "bulk_insert_cache_states_ignore_conflicts",
     "bulk_insert_tags_and_meta",
-    "bulk_update_enrichment_level",
-    "count_active_siblings",
-    "create_stub_asset",
-    "bulk_update_is_missing",
-    "bulk_update_needs_verify",
-    "convert_metadata_to_rows",
+    "bulk_set_needs_verify",
+    "delete_asset_info_by_id",
     "delete_assets_by_ids",
+    "delete_cache_states_by_ids",
+    "delete_cache_states_outside_prefixes",
     "delete_orphaned_seed_asset",
-    "delete_reference_by_id",
-    "delete_references_by_ids",
     "ensure_tags_exist",
-    "fetch_reference_and_asset",
-    "fetch_reference_asset_and_tags",
+    "fetch_asset_info_and_asset",
+    "fetch_asset_info_asset_and_tags",
     "get_asset_by_hash",
-    "get_existing_asset_ids",
-    "get_or_create_reference",
-    "get_reference_by_file_path",
-    "get_reference_by_id",
-    "get_reference_with_owner_check",
-    "get_reference_ids_by_ids",
-    "get_reference_tags",
-    "get_references_by_paths_and_asset_ids",
-    "get_references_for_prefixes",
-    "get_unenriched_references",
-    "get_unreferenced_unhashed_asset_ids",
-    "insert_reference",
-    "list_all_file_paths_by_asset_id",
-    "list_references_by_asset_id",
-    "list_references_page",
-    "list_tag_counts_for_filtered_assets",
+    "get_asset_info_by_id",
+    "get_asset_info_ids_by_ids",
+    "get_asset_tags",
+    "get_cache_states_by_paths_and_asset_ids",
+    "get_cache_states_for_prefixes",
+    "get_or_create_asset_info",
+    "get_orphaned_seed_asset_ids",
+    "insert_asset_info",
+    "list_asset_infos_page",
+    "list_cache_states_by_asset_id",
     "list_tags_with_usage",
-    "mark_references_missing_outside_prefixes",
-    "reassign_asset_references",
-    "rebuild_metadata_projection",
-    "reference_exists",
-    "reference_exists_for_asset_id",
     "remove_missing_tag_for_asset_id",
-    "remove_tags_from_reference",
-    "restore_references_by_paths",
-    "set_reference_metadata",
-    "set_reference_preview",
-    "set_reference_system_metadata",
-    "soft_delete_reference_by_id",
-    "set_reference_tags",
-    "update_asset_hash_and_mime",
-    "update_is_missing_by_asset_id",
-    "update_reference_access_time",
-    "update_reference_name",
-    "update_reference_timestamps",
-    "update_reference_updated_at",
+    "remove_tags_from_asset_info",
+    "set_asset_info_metadata",
+    "set_asset_info_preview",
+    "set_asset_info_tags",
+    "update_asset_info_access_time",
+    "update_asset_info_name",
+    "update_asset_info_timestamps",
+    "update_asset_info_updated_at",
     "upsert_asset",
-    "upsert_reference",
-    "validate_tags_exist",
+    "upsert_cache_state",
 ]

app/assets/database/queries/asset.py

@@ -3,8 +3,8 @@ from sqlalchemy import select
 from sqlalchemy.dialects import sqlite
 from sqlalchemy.orm import Session
 
-from app.assets.database.models import Asset, AssetReference
-from app.assets.database.queries.common import MAX_BIND_PARAMS, calculate_rows_per_statement, iter_chunks
+from app.assets.database.models import Asset
+from app.assets.database.queries.common import calculate_rows_per_statement, iter_chunks
 
 
 def asset_exists_by_hash(
@@ -69,7 +69,7 @@ def upsert_asset(
         if asset.size_bytes != int(size_bytes) and int(size_bytes) > 0:
             asset.size_bytes = int(size_bytes)
             changed = True
-        if mime_type and not asset.mime_type:
+        if mime_type and asset.mime_type != mime_type:
             asset.mime_type = mime_type
             changed = True
         if changed:
@@ -78,75 +78,13 @@ def upsert_asset(
     return asset, created, updated
 
 
-def create_stub_asset(
-    session: Session,
-    size_bytes: int,
-    mime_type: str | None = None,
-) -> Asset:
-    """Create a new asset with no hash (stub for later enrichment)."""
-    asset = Asset(size_bytes=size_bytes, mime_type=mime_type, hash=None)
-    session.add(asset)
-    session.flush()
-    return asset
-
-
 def bulk_insert_assets(
     session: Session,
     rows: list[dict],
 ) -> None:
-    """Bulk insert Asset rows with ON CONFLICT DO NOTHING on hash."""
+    """Bulk insert Asset rows. Each dict should have: id, hash, size_bytes, mime_type, created_at."""
     if not rows:
         return
-    ins = sqlite.insert(Asset).on_conflict_do_nothing(index_elements=[Asset.hash])
+    ins = sqlite.insert(Asset)
     for chunk in iter_chunks(rows, calculate_rows_per_statement(5)):
         session.execute(ins, chunk)
-
-
-def get_existing_asset_ids(
-    session: Session,
-    asset_ids: list[str],
-) -> set[str]:
-    """Return the subset of asset_ids that exist in the database."""
-    if not asset_ids:
-        return set()
-    found: set[str] = set()
-    for chunk in iter_chunks(asset_ids, MAX_BIND_PARAMS):
-        rows = session.execute(
-            select(Asset.id).where(Asset.id.in_(chunk))
-        ).fetchall()
-        found.update(row[0] for row in rows)
-    return found
-
-
-def update_asset_hash_and_mime(
-    session: Session,
-    asset_id: str,
-    asset_hash: str | None = None,
-    mime_type: str | None = None,
-) -> bool:
-    """Update asset hash and/or mime_type. Returns True if asset was found."""
-    asset = session.get(Asset, asset_id)
-    if not asset:
-        return False
-    if asset_hash is not None:
-        asset.hash = asset_hash
-    if mime_type is not None and not asset.mime_type:
-        asset.mime_type = mime_type
-    return True
-
-
-def reassign_asset_references(
-    session: Session,
-    from_asset_id: str,
-    to_asset_id: str,
-    reference_id: str,
-) -> None:
-    """Reassign a reference from one asset to another.
-
-    Used when merging a stub asset into an existing asset with the same hash.
-    """
-    ref = session.get(AssetReference, reference_id)
-    if ref and ref.asset_id == from_asset_id:
-        ref.asset_id = to_asset_id
-
-    session.flush()

app/assets/database/queries/asset_info.py

@@ -0,0 +1,527 @@
+from collections import defaultdict
+from datetime import datetime
+from decimal import Decimal
+from typing import Sequence
+
+import sqlalchemy as sa
+from sqlalchemy import delete, exists, select
+from sqlalchemy.dialects import sqlite
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.orm import Session, contains_eager, noload
+
+from app.assets.database.models import (
+    Asset,
+    AssetInfo,
+    AssetInfoMeta,
+    AssetInfoTag,
+    Tag,
+)
+from app.assets.database.queries.common import (
+    MAX_BIND_PARAMS,
+    build_visible_owner_clause,
+    calculate_rows_per_statement,
+    iter_chunks,
+)
+from app.assets.helpers import escape_sql_like_string, get_utc_now, normalize_tags
+
+
+def _check_is_scalar(v):
+    if v is None:
+        return True
+    if isinstance(v, bool):
+        return True
+    if isinstance(v, (int, float, Decimal, str)):
+        return True
+    return False
+
+
+def _scalar_to_row(key: str, ordinal: int, value) -> dict:
+    """Convert a scalar value to a typed projection row."""
+    if value is None:
+        return {
+            "key": key,
+            "ordinal": ordinal,
+            "val_str": None,
+            "val_num": None,
+            "val_bool": None,
+            "val_json": None,
+        }
+    if isinstance(value, bool):
+        return {"key": key, "ordinal": ordinal, "val_bool": bool(value)}
+    if isinstance(value, (int, float, Decimal)):
+        num = value if isinstance(value, Decimal) else Decimal(str(value))
+        return {"key": key, "ordinal": ordinal, "val_num": num}
+    if isinstance(value, str):
+        return {"key": key, "ordinal": ordinal, "val_str": value}
+    return {"key": key, "ordinal": ordinal, "val_json": value}
+
+
+def convert_metadata_to_rows(key: str, value) -> list[dict]:
+    """
+    Turn a metadata key/value into typed projection rows.
+    Returns list[dict] with keys:
+      key, ordinal, and one of val_str / val_num / val_bool / val_json (others None)
+    """
+    if value is None:
+        return [_scalar_to_row(key, 0, None)]
+
+    if _check_is_scalar(value):
+        return [_scalar_to_row(key, 0, value)]
+
+    if isinstance(value, list):
+        if all(_check_is_scalar(x) for x in value):
+            return [_scalar_to_row(key, i, x) for i, x in enumerate(value)]
+        return [{"key": key, "ordinal": i, "val_json": x} for i, x in enumerate(value)]
+
+    return [{"key": key, "ordinal": 0, "val_json": value}]
+
+
+def _apply_tag_filters(
+    stmt: sa.sql.Select,
+    include_tags: Sequence[str] | None = None,
+    exclude_tags: Sequence[str] | None = None,
+) -> sa.sql.Select:
+    """include_tags: every tag must be present; exclude_tags: none may be present."""
+    include_tags = normalize_tags(include_tags)
+    exclude_tags = normalize_tags(exclude_tags)
+
+    if include_tags:
+        for tag_name in include_tags:
+            stmt = stmt.where(
+                exists().where(
+                    (AssetInfoTag.asset_info_id == AssetInfo.id)
+                    & (AssetInfoTag.tag_name == tag_name)
+                )
+            )
+
+    if exclude_tags:
+        stmt = stmt.where(
+            ~exists().where(
+                (AssetInfoTag.asset_info_id == AssetInfo.id)
+                & (AssetInfoTag.tag_name.in_(exclude_tags))
+            )
+        )
+    return stmt
+
+
+def _apply_metadata_filter(
+    stmt: sa.sql.Select,
+    metadata_filter: dict | None = None,
+) -> sa.sql.Select:
+    """Apply filters using asset_info_meta projection table."""
+    if not metadata_filter:
+        return stmt
+
+    def _exists_for_pred(key: str, *preds) -> sa.sql.ClauseElement:
+        return sa.exists().where(
+            AssetInfoMeta.asset_info_id == AssetInfo.id,
+            AssetInfoMeta.key == key,
+            *preds,
+        )
+
+    def _exists_clause_for_value(key: str, value) -> sa.sql.ClauseElement:
+        if value is None:
+            no_row_for_key = sa.not_(
+                sa.exists().where(
+                    AssetInfoMeta.asset_info_id == AssetInfo.id,
+                    AssetInfoMeta.key == key,
+                )
+            )
+            null_row = _exists_for_pred(
+                key,
+                AssetInfoMeta.val_json.is_(None),
+                AssetInfoMeta.val_str.is_(None),
+                AssetInfoMeta.val_num.is_(None),
+                AssetInfoMeta.val_bool.is_(None),
+            )
+            return sa.or_(no_row_for_key, null_row)
+
+        if isinstance(value, bool):
+            return _exists_for_pred(key, AssetInfoMeta.val_bool == bool(value))
+        if isinstance(value, (int, float)):
+            num = value if isinstance(value, Decimal) else Decimal(str(value))
+            return _exists_for_pred(key, AssetInfoMeta.val_num == num)
+        if isinstance(value, str):
+            return _exists_for_pred(key, AssetInfoMeta.val_str == value)
+        return _exists_for_pred(key, AssetInfoMeta.val_json == value)
+
+    for k, v in metadata_filter.items():
+        if isinstance(v, list):
+            ors = [_exists_clause_for_value(k, elem) for elem in v]
+            if ors:
+                stmt = stmt.where(sa.or_(*ors))
+        else:
+            stmt = stmt.where(_exists_clause_for_value(k, v))
+    return stmt
+
+
+def asset_info_exists_for_asset_id(
+    session: Session,
+    asset_id: str,
+) -> bool:
+    q = (
+        select(sa.literal(True))
+        .select_from(AssetInfo)
+        .where(AssetInfo.asset_id == asset_id)
+        .limit(1)
+    )
+    return (session.execute(q)).first() is not None
+
+
+def get_asset_info_by_id(
+    session: Session,
+    asset_info_id: str,
+) -> AssetInfo | None:
+    return session.get(AssetInfo, asset_info_id)
+
+
+def insert_asset_info(
+    session: Session,
+    asset_id: str,
+    owner_id: str,
+    name: str,
+    preview_id: str | None = None,
+) -> AssetInfo | None:
+    """Insert a new AssetInfo. Returns None if unique constraint violated."""
+    now = get_utc_now()
+    try:
+        with session.begin_nested():
+            info = AssetInfo(
+                owner_id=owner_id,
+                name=name,
+                asset_id=asset_id,
+                preview_id=preview_id,
+                created_at=now,
+                updated_at=now,
+                last_access_time=now,
+            )
+            session.add(info)
+            session.flush()
+            return info
+    except IntegrityError:
+        return None
+
+
+def get_or_create_asset_info(
+    session: Session,
+    asset_id: str,
+    owner_id: str,
+    name: str,
+    preview_id: str | None = None,
+) -> tuple[AssetInfo, bool]:
+    """Get existing or create new AssetInfo. Returns (info, created)."""
+    info = insert_asset_info(
+        session,
+        asset_id=asset_id,
+        owner_id=owner_id,
+        name=name,
+        preview_id=preview_id,
+    )
+    if info:
+        return info, True
+
+    existing = (
+        session.execute(
+            select(AssetInfo)
+            .where(
+                AssetInfo.asset_id == asset_id,
+                AssetInfo.name == name,
+                AssetInfo.owner_id == owner_id,
+            )
+            .limit(1)
+        )
+        .unique()
+        .scalar_one_or_none()
+    )
+    if not existing:
+        raise RuntimeError("Failed to find AssetInfo after insert conflict.")
+    return existing, False
+
+
+def update_asset_info_timestamps(
+    session: Session,
+    asset_info: AssetInfo,
+    preview_id: str | None = None,
+) -> None:
+    """Update timestamps and optionally preview_id on existing AssetInfo."""
+    now = get_utc_now()
+    if preview_id and asset_info.preview_id != preview_id:
+        asset_info.preview_id = preview_id
+    asset_info.updated_at = now
+    if asset_info.last_access_time < now:
+        asset_info.last_access_time = now
+    session.flush()
+
+
+def list_asset_infos_page(
+    session: Session,
+    owner_id: str = "",
+    include_tags: Sequence[str] | None = None,
+    exclude_tags: Sequence[str] | None = None,
+    name_contains: str | None = None,
+    metadata_filter: dict | None = None,
+    limit: int = 20,
+    offset: int = 0,
+    sort: str = "created_at",
+    order: str = "desc",
+) -> tuple[list[AssetInfo], dict[str, list[str]], int]:
+    base = (
+        select(AssetInfo)
+        .join(Asset, Asset.id == AssetInfo.asset_id)
+        .options(contains_eager(AssetInfo.asset), noload(AssetInfo.tags))
+        .where(build_visible_owner_clause(owner_id))
+    )
+
+    if name_contains:
+        escaped, esc = escape_sql_like_string(name_contains)
+        base = base.where(AssetInfo.name.ilike(f"%{escaped}%", escape=esc))
+
+    base = _apply_tag_filters(base, include_tags, exclude_tags)
+    base = _apply_metadata_filter(base, metadata_filter)
+
+    sort = (sort or "created_at").lower()
+    order = (order or "desc").lower()
+    sort_map = {
+        "name": AssetInfo.name,
+        "created_at": AssetInfo.created_at,
+        "updated_at": AssetInfo.updated_at,
+        "last_access_time": AssetInfo.last_access_time,
+        "size": Asset.size_bytes,
+    }
+    sort_col = sort_map.get(sort, AssetInfo.created_at)
+    sort_exp = sort_col.desc() if order == "desc" else sort_col.asc()
+
+    base = base.order_by(sort_exp).limit(limit).offset(offset)
+
+    count_stmt = (
+        select(sa.func.count())
+        .select_from(AssetInfo)
+        .join(Asset, Asset.id == AssetInfo.asset_id)
+        .where(build_visible_owner_clause(owner_id))
+    )
+    if name_contains:
+        escaped, esc = escape_sql_like_string(name_contains)
+        count_stmt = count_stmt.where(AssetInfo.name.ilike(f"%{escaped}%", escape=esc))
+    count_stmt = _apply_tag_filters(count_stmt, include_tags, exclude_tags)
+    count_stmt = _apply_metadata_filter(count_stmt, metadata_filter)
+
+    total = int((session.execute(count_stmt)).scalar_one() or 0)
+
+    infos = (session.execute(base)).unique().scalars().all()
+
+    id_list: list[str] = [i.id for i in infos]
+    tag_map: dict[str, list[str]] = defaultdict(list)
+    if id_list:
+        rows = session.execute(
+            select(AssetInfoTag.asset_info_id, Tag.name)
+            .join(Tag, Tag.name == AssetInfoTag.tag_name)
+            .where(AssetInfoTag.asset_info_id.in_(id_list))
+            .order_by(AssetInfoTag.added_at)
+        )
+        for aid, tag_name in rows.all():
+            tag_map[aid].append(tag_name)
+
+    return infos, tag_map, total
+
+
+def fetch_asset_info_asset_and_tags(
+    session: Session,
+    asset_info_id: str,
+    owner_id: str = "",
+) -> tuple[AssetInfo, Asset, list[str]] | None:
+    stmt = (
+        select(AssetInfo, Asset, Tag.name)
+        .join(Asset, Asset.id == AssetInfo.asset_id)
+        .join(AssetInfoTag, AssetInfoTag.asset_info_id == AssetInfo.id, isouter=True)
+        .join(Tag, Tag.name == AssetInfoTag.tag_name, isouter=True)
+        .where(
+            AssetInfo.id == asset_info_id,
+            build_visible_owner_clause(owner_id),
+        )
+        .options(noload(AssetInfo.tags))
+        .order_by(Tag.name.asc())
+    )
+
+    rows = (session.execute(stmt)).all()
+    if not rows:
+        return None
+
+    first_info, first_asset, _ = rows[0]
+    tags: list[str] = []
+    seen: set[str] = set()
+    for _info, _asset, tag_name in rows:
+        if tag_name and tag_name not in seen:
+            seen.add(tag_name)
+            tags.append(tag_name)
+    return first_info, first_asset, tags
+
+
+def fetch_asset_info_and_asset(
+    session: Session,
+    asset_info_id: str,
+    owner_id: str = "",
+) -> tuple[AssetInfo, Asset] | None:
+    stmt = (
+        select(AssetInfo, Asset)
+        .join(Asset, Asset.id == AssetInfo.asset_id)
+        .where(
+            AssetInfo.id == asset_info_id,
+            build_visible_owner_clause(owner_id),
+        )
+        .limit(1)
+        .options(noload(AssetInfo.tags))
+    )
+    row = session.execute(stmt)
+    pair = row.first()
+    if not pair:
+        return None
+    return pair[0], pair[1]
+
+
+def update_asset_info_access_time(
+    session: Session,
+    asset_info_id: str,
+    ts: datetime | None = None,
+    only_if_newer: bool = True,
+) -> None:
+    ts = ts or get_utc_now()
+    stmt = sa.update(AssetInfo).where(AssetInfo.id == asset_info_id)
+    if only_if_newer:
+        stmt = stmt.where(
+            sa.or_(
+                AssetInfo.last_access_time.is_(None), AssetInfo.last_access_time < ts
+            )
+        )
+    session.execute(stmt.values(last_access_time=ts))
+
+
+def update_asset_info_name(
+    session: Session,
+    asset_info_id: str,
+    name: str,
+) -> None:
+    """Update the name of an AssetInfo."""
+    now = get_utc_now()
+    session.execute(
+        sa.update(AssetInfo)
+        .where(AssetInfo.id == asset_info_id)
+        .values(name=name, updated_at=now)
+    )
+
+
+def update_asset_info_updated_at(
+    session: Session,
+    asset_info_id: str,
+    ts: datetime | None = None,
+) -> None:
+    """Update the updated_at timestamp of an AssetInfo."""
+    ts = ts or get_utc_now()
+    session.execute(
+        sa.update(AssetInfo).where(AssetInfo.id == asset_info_id).values(updated_at=ts)
+    )
+
+
+def set_asset_info_metadata(
+    session: Session,
+    asset_info_id: str,
+    user_metadata: dict | None = None,
+) -> None:
+    info = session.get(AssetInfo, asset_info_id)
+    if not info:
+        raise ValueError(f"AssetInfo {asset_info_id} not found")
+
+    info.user_metadata = user_metadata or {}
+    info.updated_at = get_utc_now()
+    session.flush()
+
+    session.execute(
+        delete(AssetInfoMeta).where(AssetInfoMeta.asset_info_id == asset_info_id)
+    )
+    session.flush()
+
+    if not user_metadata:
+        return
+
+    rows: list[AssetInfoMeta] = []
+    for k, v in user_metadata.items():
+        for r in convert_metadata_to_rows(k, v):
+            rows.append(
+                AssetInfoMeta(
+                    asset_info_id=asset_info_id,
+                    key=r["key"],
+                    ordinal=int(r["ordinal"]),
+                    val_str=r.get("val_str"),
+                    val_num=r.get("val_num"),
+                    val_bool=r.get("val_bool"),
+                    val_json=r.get("val_json"),
+                )
+            )
+    if rows:
+        session.add_all(rows)
+        session.flush()
+
+
+def delete_asset_info_by_id(
+    session: Session,
+    asset_info_id: str,
+    owner_id: str,
+) -> bool:
+    stmt = sa.delete(AssetInfo).where(
+        AssetInfo.id == asset_info_id,
+        build_visible_owner_clause(owner_id),
+    )
+    return int((session.execute(stmt)).rowcount or 0) > 0
+
+
+def set_asset_info_preview(
+    session: Session,
+    asset_info_id: str,
+    preview_asset_id: str | None = None,
+) -> None:
+    """Set or clear preview_id and bump updated_at. Raises on unknown IDs."""
+    info = session.get(AssetInfo, asset_info_id)
+    if not info:
+        raise ValueError(f"AssetInfo {asset_info_id} not found")
+
+    if preview_asset_id is None:
+        info.preview_id = None
+    else:
+        if not session.get(Asset, preview_asset_id):
+            raise ValueError(f"Preview Asset {preview_asset_id} not found")
+        info.preview_id = preview_asset_id
+
+    info.updated_at = get_utc_now()
+    session.flush()
+
+
+def bulk_insert_asset_infos_ignore_conflicts(
+    session: Session,
+    rows: list[dict],
+) -> None:
+    """Bulk insert AssetInfo rows with ON CONFLICT DO NOTHING.
+
+    Each dict should have: id, owner_id, name, asset_id, preview_id,
+    user_metadata, created_at, updated_at, last_access_time
+    """
+    if not rows:
+        return
+    ins = sqlite.insert(AssetInfo).on_conflict_do_nothing(
+        index_elements=[AssetInfo.asset_id, AssetInfo.owner_id, AssetInfo.name]
+    )
+    for chunk in iter_chunks(rows, calculate_rows_per_statement(9)):
+        session.execute(ins, chunk)
+
+
+def get_asset_info_ids_by_ids(
+    session: Session,
+    info_ids: list[str],
+) -> set[str]:
+    """Query to find which AssetInfo IDs exist in the database."""
+    if not info_ids:
+        return set()
+
+    found: set[str] = set()
+    for chunk in iter_chunks(info_ids, MAX_BIND_PARAMS):
+        result = session.execute(select(AssetInfo.id).where(AssetInfo.id.in_(chunk)))
+        found.update(result.scalars().all())
+    return found

app/assets/database/queries/cache_state.py

@@ -0,0 +1,280 @@
+import os
+from typing import NamedTuple, Sequence
+
+import sqlalchemy as sa
+from sqlalchemy import select
+from sqlalchemy.dialects import sqlite
+from sqlalchemy.orm import Session
+
+from app.assets.database.models import Asset, AssetCacheState, AssetInfo
+from app.assets.database.queries.common import (
+    MAX_BIND_PARAMS,
+    calculate_rows_per_statement,
+    iter_chunks,
+)
+from app.assets.helpers import escape_sql_like_string
+
+
+class CacheStateRow(NamedTuple):
+    """Row from cache state query with joined asset data."""
+
+    state_id: int
+    file_path: str
+    mtime_ns: int | None
+    needs_verify: bool
+    asset_id: str
+    asset_hash: str | None
+    size_bytes: int
+
+
+def list_cache_states_by_asset_id(
+    session: Session, *, asset_id: str
+) -> Sequence[AssetCacheState]:
+    return (
+        (
+            session.execute(
+                select(AssetCacheState)
+                .where(AssetCacheState.asset_id == asset_id)
+                .order_by(AssetCacheState.id.asc())
+            )
+        )
+        .scalars()
+        .all()
+    )
+
+
+def upsert_cache_state(
+    session: Session,
+    asset_id: str,
+    file_path: str,
+    mtime_ns: int,
+) -> tuple[bool, bool]:
+    """Upsert a cache state by file_path. Returns (created, updated)."""
+    vals = {
+        "asset_id": asset_id,
+        "file_path": file_path,
+        "mtime_ns": int(mtime_ns),
+    }
+    ins = (
+        sqlite.insert(AssetCacheState)
+        .values(**vals)
+        .on_conflict_do_nothing(index_elements=[AssetCacheState.file_path])
+    )
+    res = session.execute(ins)
+    created = int(res.rowcount or 0) > 0
+
+    if created:
+        return True, False
+
+    upd = (
+        sa.update(AssetCacheState)
+        .where(AssetCacheState.file_path == file_path)
+        .where(
+            sa.or_(
+                AssetCacheState.asset_id != asset_id,
+                AssetCacheState.mtime_ns.is_(None),
+                AssetCacheState.mtime_ns != int(mtime_ns),
+            )
+        )
+        .values(asset_id=asset_id, mtime_ns=int(mtime_ns))
+    )
+    res2 = session.execute(upd)
+    updated = int(res2.rowcount or 0) > 0
+    return False, updated
+
+
+def delete_cache_states_outside_prefixes(
+    session: Session, valid_prefixes: list[str]
+) -> int:
+    """Delete cache states with file_path not matching any of the valid prefixes.
+
+    Args:
+        session: Database session
+        valid_prefixes: List of absolute directory prefixes that are valid
+
+    Returns:
+        Number of cache states deleted
+    """
+    if not valid_prefixes:
+        return 0
+
+    def make_prefix_condition(prefix: str):
+        base = prefix if prefix.endswith(os.sep) else prefix + os.sep
+        escaped, esc = escape_sql_like_string(base)
+        return AssetCacheState.file_path.like(escaped + "%", escape=esc)
+
+    matches_valid_prefix = sa.or_(*[make_prefix_condition(p) for p in valid_prefixes])
+    result = session.execute(sa.delete(AssetCacheState).where(~matches_valid_prefix))
+    return result.rowcount
+
+
+def get_orphaned_seed_asset_ids(session: Session) -> list[str]:
+    """Get IDs of seed assets (hash is None) with no remaining cache states.
+
+    Returns:
+        List of asset IDs that are orphaned
+    """
+    orphan_subq = (
+        sa.select(Asset.id)
+        .outerjoin(AssetCacheState, AssetCacheState.asset_id == Asset.id)
+        .where(Asset.hash.is_(None), AssetCacheState.id.is_(None))
+    )
+    return [row[0] for row in session.execute(orphan_subq).all()]
+
+
+def delete_assets_by_ids(session: Session, asset_ids: list[str]) -> int:
+    """Delete assets and their AssetInfos by ID.
+
+    Args:
+        session: Database session
+        asset_ids: List of asset IDs to delete
+
+    Returns:
+        Number of assets deleted
+    """
+    if not asset_ids:
+        return 0
+    session.execute(sa.delete(AssetInfo).where(AssetInfo.asset_id.in_(asset_ids)))
+    result = session.execute(sa.delete(Asset).where(Asset.id.in_(asset_ids)))
+    return result.rowcount
+
+
+def get_cache_states_for_prefixes(
+    session: Session,
+    prefixes: list[str],
+) -> list[CacheStateRow]:
+    """Get all cache states with paths matching any of the given prefixes.
+
+    Args:
+        session: Database session
+        prefixes: List of absolute directory prefixes to match
+
+    Returns:
+        List of cache state rows with joined asset data, ordered by asset_id, state_id
+    """
+    if not prefixes:
+        return []
+
+    conds = []
+    for p in prefixes:
+        base = os.path.abspath(p)
+        if not base.endswith(os.sep):
+            base += os.sep
+        escaped, esc = escape_sql_like_string(base)
+        conds.append(AssetCacheState.file_path.like(escaped + "%", escape=esc))
+
+    rows = session.execute(
+        sa.select(
+            AssetCacheState.id,
+            AssetCacheState.file_path,
+            AssetCacheState.mtime_ns,
+            AssetCacheState.needs_verify,
+            AssetCacheState.asset_id,
+            Asset.hash,
+            Asset.size_bytes,
+        )
+        .join(Asset, Asset.id == AssetCacheState.asset_id)
+        .where(sa.or_(*conds))
+        .order_by(AssetCacheState.asset_id.asc(), AssetCacheState.id.asc())
+    ).all()
+
+    return [
+        CacheStateRow(
+            state_id=row[0],
+            file_path=row[1],
+            mtime_ns=row[2],
+            needs_verify=row[3],
+            asset_id=row[4],
+            asset_hash=row[5],
+            size_bytes=int(row[6] or 0),
+        )
+        for row in rows
+    ]
+
+
+def bulk_set_needs_verify(session: Session, state_ids: list[int], value: bool) -> int:
+    """Set needs_verify flag for multiple cache states.
+
+    Returns: Number of rows updated
+    """
+    if not state_ids:
+        return 0
+    result = session.execute(
+        sa.update(AssetCacheState)
+        .where(AssetCacheState.id.in_(state_ids))
+        .values(needs_verify=value)
+    )
+    return result.rowcount
+
+
+def delete_cache_states_by_ids(session: Session, state_ids: list[int]) -> int:
+    """Delete cache states by their IDs.
+
+    Returns: Number of rows deleted
+    """
+    if not state_ids:
+        return 0
+    result = session.execute(
+        sa.delete(AssetCacheState).where(AssetCacheState.id.in_(state_ids))
+    )
+    return result.rowcount
+
+
+def delete_orphaned_seed_asset(session: Session, asset_id: str) -> bool:
+    """Delete a seed asset (hash is None) and its AssetInfos.
+
+    Returns: True if asset was deleted, False if not found
+    """
+    session.execute(sa.delete(AssetInfo).where(AssetInfo.asset_id == asset_id))
+    asset = session.get(Asset, asset_id)
+    if asset:
+        session.delete(asset)
+        return True
+    return False
+
+
+def bulk_insert_cache_states_ignore_conflicts(
+    session: Session,
+    rows: list[dict],
+) -> None:
+    """Bulk insert cache state rows with ON CONFLICT DO NOTHING on file_path.
+
+    Each dict should have: asset_id, file_path, mtime_ns
+    """
+    if not rows:
+        return
+    ins = sqlite.insert(AssetCacheState).on_conflict_do_nothing(
+        index_elements=[AssetCacheState.file_path]
+    )
+    for chunk in iter_chunks(rows, calculate_rows_per_statement(3)):
+        session.execute(ins, chunk)
+
+
+def get_cache_states_by_paths_and_asset_ids(
+    session: Session,
+    path_to_asset: dict[str, str],
+) -> set[str]:
+    """Query cache states to find paths where our asset_id won the insert.
+
+    Args:
+        path_to_asset: Mapping of file_path -> asset_id we tried to insert
+
+    Returns:
+        Set of file_paths where our asset_id is present
+    """
+    if not path_to_asset:
+        return set()
+
+    paths = list(path_to_asset.keys())
+    winners: set[str] = set()
+
+    for chunk in iter_chunks(paths, MAX_BIND_PARAMS):
+        result = session.execute(
+            select(AssetCacheState.file_path).where(
+                AssetCacheState.file_path.in_(chunk),
+                AssetCacheState.asset_id.in_([path_to_asset[p] for p in chunk]),
+            )
+        )
+        winners.update(result.scalars().all())
+
+    return winners

app/assets/database/queries/common.py

@@ -1,14 +1,10 @@
 """Shared utilities for database query modules."""
 
-import os
-from decimal import Decimal
-from typing import Iterable, Sequence
+from typing import Iterable
 
 import sqlalchemy as sa
-from sqlalchemy import exists
 
-from app.assets.database.models import AssetReference, AssetReferenceMeta, AssetReferenceTag
-from app.assets.helpers import escape_sql_like_string, normalize_tags
+from app.assets.database.models import AssetInfo
 
 MAX_BIND_PARAMS = 800
 
@@ -27,101 +23,15 @@ def iter_chunks(seq, n: int):
 def iter_row_chunks(rows: list[dict], cols_per_row: int) -> Iterable[list[dict]]:
     """Yield chunks of rows sized to fit within bind param limits."""
     if not rows:
-        return
-    yield from iter_chunks(rows, calculate_rows_per_statement(cols_per_row))
+        return []
+    rows_per_stmt = max(1, MAX_BIND_PARAMS // max(1, cols_per_row))
+    for i in range(0, len(rows), rows_per_stmt):
+        yield rows[i : i + rows_per_stmt]
 
 
 def build_visible_owner_clause(owner_id: str) -> sa.sql.ClauseElement:
-    """Build owner visibility predicate for reads.
-
-    Owner-less rows are visible to everyone.
-    """
+    """Build owner visibility predicate for reads. Owner-less rows are visible to everyone."""
     owner_id = (owner_id or "").strip()
     if owner_id == "":
-        return AssetReference.owner_id == ""
-    return AssetReference.owner_id.in_(["", owner_id])
-
-
-def build_prefix_like_conditions(
-    prefixes: list[str],
-) -> list[sa.sql.ColumnElement]:
-    """Build LIKE conditions for matching file paths under directory prefixes."""
-    conds = []
-    for p in prefixes:
-        base = os.path.abspath(p)
-        if not base.endswith(os.sep):
-            base += os.sep
-        escaped, esc = escape_sql_like_string(base)
-        conds.append(AssetReference.file_path.like(escaped + "%", escape=esc))
-    return conds
-
-
-def apply_tag_filters(
-    stmt: sa.sql.Select,
-    include_tags: Sequence[str] | None = None,
-    exclude_tags: Sequence[str] | None = None,
-) -> sa.sql.Select:
-    """include_tags: every tag must be present; exclude_tags: none may be present."""
-    include_tags = normalize_tags(include_tags)
-    exclude_tags = normalize_tags(exclude_tags)
-
-    if include_tags:
-        for tag_name in include_tags:
-            stmt = stmt.where(
-                exists().where(
-                    (AssetReferenceTag.asset_reference_id == AssetReference.id)
-                    & (AssetReferenceTag.tag_name == tag_name)
-                )
-            )
-
-    if exclude_tags:
-        stmt = stmt.where(
-            ~exists().where(
-                (AssetReferenceTag.asset_reference_id == AssetReference.id)
-                & (AssetReferenceTag.tag_name.in_(exclude_tags))
-            )
-        )
-    return stmt
-
-
-def apply_metadata_filter(
-    stmt: sa.sql.Select,
-    metadata_filter: dict | None = None,
-) -> sa.sql.Select:
-    """Apply filters using asset_reference_meta projection table."""
-    if not metadata_filter:
-        return stmt
-
-    def _exists_for_pred(key: str, *preds) -> sa.sql.ClauseElement:
-        return sa.exists().where(
-            AssetReferenceMeta.asset_reference_id == AssetReference.id,
-            AssetReferenceMeta.key == key,
-            *preds,
-        )
-
-    def _exists_clause_for_value(key: str, value) -> sa.sql.ClauseElement:
-        if value is None:
-            return sa.not_(
-                sa.exists().where(
-                    AssetReferenceMeta.asset_reference_id == AssetReference.id,
-                    AssetReferenceMeta.key == key,
-                )
-            )
-
-        if isinstance(value, bool):
-            return _exists_for_pred(key, AssetReferenceMeta.val_bool == bool(value))
-        if isinstance(value, (int, float, Decimal)):
-            num = value if isinstance(value, Decimal) else Decimal(str(value))
-            return _exists_for_pred(key, AssetReferenceMeta.val_num == num)
-        if isinstance(value, str):
-            return _exists_for_pred(key, AssetReferenceMeta.val_str == value)
-        return _exists_for_pred(key, AssetReferenceMeta.val_json == value)
-
-    for k, v in metadata_filter.items():
-        if isinstance(v, list):
-            ors = [_exists_clause_for_value(k, elem) for elem in v]
-            if ors:
-                stmt = stmt.where(sa.or_(*ors))
-        else:
-            stmt = stmt.where(_exists_clause_for_value(k, v))
-    return stmt
+        return AssetInfo.owner_id == ""
+    return AssetInfo.owner_id.in_(["", owner_id])

app/assets/database/queries/tags.py

@@ -1,5 +1,4 @@
-from dataclasses import dataclass
-from typing import Iterable, Sequence
+from typing import Iterable, Sequence, TypedDict
 
 import sqlalchemy as sa
 from sqlalchemy import delete, func, select
@@ -7,54 +6,32 @@ from sqlalchemy.dialects import sqlite
 from sqlalchemy.exc import IntegrityError
 from sqlalchemy.orm import Session
 
-from app.assets.database.models import (
-    Asset,
-    AssetReference,
-    AssetReferenceMeta,
-    AssetReferenceTag,
-    Tag,
-)
+from app.assets.database.models import AssetInfo, AssetInfoMeta, AssetInfoTag, Tag
 from app.assets.database.queries.common import (
-    apply_metadata_filter,
-    apply_tag_filters,
     build_visible_owner_clause,
     iter_row_chunks,
 )
 from app.assets.helpers import escape_sql_like_string, get_utc_now, normalize_tags
 
 
-@dataclass(frozen=True)
-class AddTagsResult:
+class AddTagsDict(TypedDict):
     added: list[str]
     already_present: list[str]
     total_tags: list[str]
 
 
-@dataclass(frozen=True)
-class RemoveTagsResult:
+class RemoveTagsDict(TypedDict):
     removed: list[str]
     not_present: list[str]
     total_tags: list[str]
 
 
-@dataclass(frozen=True)
-class SetTagsResult:
+class SetTagsDict(TypedDict):
     added: list[str]
     removed: list[str]
     total: list[str]
 
 
-def validate_tags_exist(session: Session, tags: list[str]) -> None:
-    """Raise ValueError if any of the given tag names do not exist."""
-    existing_tag_names = set(
-        name
-        for (name,) in session.execute(select(Tag.name).where(Tag.name.in_(tags))).all()
-    )
-    missing = [t for t in tags if t not in existing_tag_names]
-    if missing:
-        raise ValueError(f"Unknown tags: {missing}")
-
-
 def ensure_tags_exist(
     session: Session, names: Iterable[str], tag_type: str = "user"
 ) -> None:
@@ -70,28 +47,37 @@ def ensure_tags_exist(
     session.execute(ins)
 
 
-def get_reference_tags(session: Session, reference_id: str) -> list[str]:
+def get_asset_tags(session: Session, asset_info_id: str) -> list[str]:
     return [
         tag_name
         for (tag_name,) in (
             session.execute(
-                select(AssetReferenceTag.tag_name)
-                .where(AssetReferenceTag.asset_reference_id == reference_id)
-                .order_by(AssetReferenceTag.tag_name.asc())
+                select(AssetInfoTag.tag_name).where(
+                    AssetInfoTag.asset_info_id == asset_info_id
+                )
             )
         ).all()
     ]
 
 
-def set_reference_tags(
+def set_asset_info_tags(
     session: Session,
-    reference_id: str,
+    asset_info_id: str,
     tags: Sequence[str],
     origin: str = "manual",
-) -> SetTagsResult:
+) -> SetTagsDict:
     desired = normalize_tags(tags)
 
-    current = set(get_reference_tags(session, reference_id))
+    current = set(
+        tag_name
+        for (tag_name,) in (
+            session.execute(
+                select(AssetInfoTag.tag_name).where(
+                    AssetInfoTag.asset_info_id == asset_info_id
+                )
+            )
+        ).all()
+    )
 
     to_add = [t for t in desired if t not in current]
     to_remove = [t for t in current if t not in desired]
@@ -100,8 +86,8 @@ def set_reference_tags(
         ensure_tags_exist(session, to_add, tag_type="user")
         session.add_all(
             [
-                AssetReferenceTag(
-                    asset_reference_id=reference_id,
+                AssetInfoTag(
+                    asset_info_id=asset_info_id,
                     tag_name=t,
                     origin=origin,
                     added_at=get_utc_now(),
@@ -113,38 +99,47 @@ def set_reference_tags(
 
     if to_remove:
         session.execute(
-            delete(AssetReferenceTag).where(
-                AssetReferenceTag.asset_reference_id == reference_id,
-                AssetReferenceTag.tag_name.in_(to_remove),
+            delete(AssetInfoTag).where(
+                AssetInfoTag.asset_info_id == asset_info_id,
+                AssetInfoTag.tag_name.in_(to_remove),
             )
         )
         session.flush()
 
-    return SetTagsResult(added=sorted(to_add), removed=sorted(to_remove), total=sorted(desired))
+    return {"added": to_add, "removed": to_remove, "total": desired}
 
 
-def add_tags_to_reference(
+def add_tags_to_asset_info(
     session: Session,
-    reference_id: str,
+    asset_info_id: str,
     tags: Sequence[str],
     origin: str = "manual",
     create_if_missing: bool = True,
-    reference_row: AssetReference | None = None,
-) -> AddTagsResult:
-    if not reference_row:
-        ref = session.get(AssetReference, reference_id)
-        if not ref:
-            raise ValueError(f"AssetReference {reference_id} not found")
+    asset_info_row: AssetInfo | None = None,
+) -> AddTagsDict:
+    if not asset_info_row:
+        info = session.get(AssetInfo, asset_info_id)
+        if not info:
+            raise ValueError(f"AssetInfo {asset_info_id} not found")
 
     norm = normalize_tags(tags)
     if not norm:
-        total = get_reference_tags(session, reference_id=reference_id)
-        return AddTagsResult(added=[], already_present=[], total_tags=total)
+        total = get_asset_tags(session, asset_info_id=asset_info_id)
+        return {"added": [], "already_present": [], "total_tags": total}
 
     if create_if_missing:
         ensure_tags_exist(session, norm, tag_type="user")
 
-    current = set(get_reference_tags(session, reference_id))
+    current = {
+        tag_name
+        for (tag_name,) in (
+            session.execute(
+                sa.select(AssetInfoTag.tag_name).where(
+                    AssetInfoTag.asset_info_id == asset_info_id
+                )
+            )
+        ).all()
+    }
 
     want = set(norm)
     to_add = sorted(want - current)
@@ -154,8 +149,8 @@ def add_tags_to_reference(
             try:
                 session.add_all(
                     [
-                        AssetReferenceTag(
-                            asset_reference_id=reference_id,
+                        AssetInfoTag(
+                            asset_info_id=asset_info_id,
                             tag_name=t,
                             origin=origin,
                             added_at=get_utc_now(),
@@ -167,44 +162,53 @@ def add_tags_to_reference(
             except IntegrityError:
                 nested.rollback()
 
-    after = set(get_reference_tags(session, reference_id=reference_id))
-    return AddTagsResult(
-        added=sorted(((after - current) & want)),
-        already_present=sorted(want & current),
-        total_tags=sorted(after),
-    )
+    after = set(get_asset_tags(session, asset_info_id=asset_info_id))
+    return {
+        "added": sorted(((after - current) & want)),
+        "already_present": sorted(want & current),
+        "total_tags": sorted(after),
+    }
 
 
-def remove_tags_from_reference(
+def remove_tags_from_asset_info(
     session: Session,
-    reference_id: str,
+    asset_info_id: str,
     tags: Sequence[str],
-) -> RemoveTagsResult:
-    ref = session.get(AssetReference, reference_id)
-    if not ref:
-        raise ValueError(f"AssetReference {reference_id} not found")
+) -> RemoveTagsDict:
+    info = session.get(AssetInfo, asset_info_id)
+    if not info:
+        raise ValueError(f"AssetInfo {asset_info_id} not found")
 
     norm = normalize_tags(tags)
     if not norm:
-        total = get_reference_tags(session, reference_id=reference_id)
-        return RemoveTagsResult(removed=[], not_present=[], total_tags=total)
+        total = get_asset_tags(session, asset_info_id=asset_info_id)
+        return {"removed": [], "not_present": [], "total_tags": total}
 
-    existing = set(get_reference_tags(session, reference_id))
+    existing = {
+        tag_name
+        for (tag_name,) in (
+            session.execute(
+                sa.select(AssetInfoTag.tag_name).where(
+                    AssetInfoTag.asset_info_id == asset_info_id
+                )
+            )
+        ).all()
+    }
 
     to_remove = sorted(set(t for t in norm if t in existing))
     not_present = sorted(set(t for t in norm if t not in existing))
 
     if to_remove:
         session.execute(
-            delete(AssetReferenceTag).where(
-                AssetReferenceTag.asset_reference_id == reference_id,
-                AssetReferenceTag.tag_name.in_(to_remove),
+            delete(AssetInfoTag).where(
+                AssetInfoTag.asset_info_id == asset_info_id,
+                AssetInfoTag.tag_name.in_(to_remove),
             )
         )
         session.flush()
 
-    total = get_reference_tags(session, reference_id=reference_id)
-    return RemoveTagsResult(removed=to_remove, not_present=not_present, total_tags=total)
+    total = get_asset_tags(session, asset_info_id=asset_info_id)
+    return {"removed": to_remove, "not_present": not_present, "total_tags": total}
 
 
 def add_missing_tag_for_asset_id(
@@ -214,32 +218,29 @@ def add_missing_tag_for_asset_id(
 ) -> None:
     select_rows = (
         sa.select(
-            AssetReference.id.label("asset_reference_id"),
+            AssetInfo.id.label("asset_info_id"),
             sa.literal("missing").label("tag_name"),
             sa.literal(origin).label("origin"),
             sa.literal(get_utc_now()).label("added_at"),
         )
-        .where(AssetReference.asset_id == asset_id)
+        .where(AssetInfo.asset_id == asset_id)
         .where(
             sa.not_(
                 sa.exists().where(
-                    (AssetReferenceTag.asset_reference_id == AssetReference.id)
-                    & (AssetReferenceTag.tag_name == "missing")
+                    (AssetInfoTag.asset_info_id == AssetInfo.id)
+                    & (AssetInfoTag.tag_name == "missing")
                 )
             )
         )
     )
     session.execute(
-        sqlite.insert(AssetReferenceTag)
+        sqlite.insert(AssetInfoTag)
         .from_select(
-            ["asset_reference_id", "tag_name", "origin", "added_at"],
+            ["asset_info_id", "tag_name", "origin", "added_at"],
             select_rows,
         )
         .on_conflict_do_nothing(
-            index_elements=[
-                AssetReferenceTag.asset_reference_id,
-                AssetReferenceTag.tag_name,
-            ]
+            index_elements=[AssetInfoTag.asset_info_id, AssetInfoTag.tag_name]
         )
     )
 
@@ -249,11 +250,11 @@ def remove_missing_tag_for_asset_id(
     asset_id: str,
 ) -> None:
     session.execute(
-        sa.delete(AssetReferenceTag).where(
-            AssetReferenceTag.asset_reference_id.in_(
-                sa.select(AssetReference.id).where(AssetReference.asset_id == asset_id)
+        sa.delete(AssetInfoTag).where(
+            AssetInfoTag.asset_info_id.in_(
+                sa.select(AssetInfo.id).where(AssetInfo.asset_id == asset_id)
             ),
-            AssetReferenceTag.tag_name == "missing",
+            AssetInfoTag.tag_name == "missing",
         )
     )
 
@@ -269,20 +270,13 @@ def list_tags_with_usage(
 ) -> tuple[list[tuple[str, str, int]], int]:
     counts_sq = (
         select(
-            AssetReferenceTag.tag_name.label("tag_name"),
-            func.count(AssetReferenceTag.asset_reference_id).label("cnt"),
+            AssetInfoTag.tag_name.label("tag_name"),
+            func.count(AssetInfoTag.asset_info_id).label("cnt"),
         )
-        .select_from(AssetReferenceTag)
-        .join(AssetReference, AssetReference.id == AssetReferenceTag.asset_reference_id)
+        .select_from(AssetInfoTag)
+        .join(AssetInfo, AssetInfo.id == AssetInfoTag.asset_info_id)
         .where(build_visible_owner_clause(owner_id))
-        .where(
-            sa.or_(
-                AssetReference.is_missing == False,  # noqa: E712
-                AssetReferenceTag.tag_name == "missing",
-            )
-        )
-        .where(AssetReference.deleted_at.is_(None))
-        .group_by(AssetReferenceTag.tag_name)
+        .group_by(AssetInfoTag.tag_name)
         .subquery()
     )
 
@@ -313,20 +307,9 @@ def list_tags_with_usage(
         escaped, esc = escape_sql_like_string(prefix.strip().lower())
         total_q = total_q.where(Tag.name.like(escaped + "%", escape=esc))
     if not include_zero:
-        visible_tags_sq = (
-            select(AssetReferenceTag.tag_name)
-            .join(AssetReference, AssetReference.id == AssetReferenceTag.asset_reference_id)
-            .where(build_visible_owner_clause(owner_id))
-            .where(
-                sa.or_(
-                    AssetReference.is_missing == False,  # noqa: E712
-                    AssetReferenceTag.tag_name == "missing",
-                )
-            )
-            .where(AssetReference.deleted_at.is_(None))
-            .group_by(AssetReferenceTag.tag_name)
+        total_q = total_q.where(
+            Tag.name.in_(select(AssetInfoTag.tag_name).group_by(AssetInfoTag.tag_name))
         )
-        total_q = total_q.where(Tag.name.in_(visible_tags_sq))
 
     rows = (session.execute(q.limit(limit).offset(offset))).all()
     total = (session.execute(total_q)).scalar_one()
@@ -335,83 +318,31 @@ def list_tags_with_usage(
     return rows_norm, int(total or 0)
 
 
-def list_tag_counts_for_filtered_assets(
-    session: Session,
-    owner_id: str = "",
-    include_tags: Sequence[str] | None = None,
-    exclude_tags: Sequence[str] | None = None,
-    name_contains: str | None = None,
-    metadata_filter: dict | None = None,
-    limit: int = 100,
-) -> dict[str, int]:
-    """Return tag counts for assets matching the given filters.
-
-    Uses the same filtering logic as list_references_page but returns
-    {tag_name: count} instead of paginated references.
-    """
-    # Build a subquery of matching reference IDs
-    ref_sq = (
-        select(AssetReference.id)
-        .join(Asset, Asset.id == AssetReference.asset_id)
-        .where(build_visible_owner_clause(owner_id))
-        .where(AssetReference.is_missing == False)  # noqa: E712
-        .where(AssetReference.deleted_at.is_(None))
-    )
-
-    if name_contains:
-        escaped, esc = escape_sql_like_string(name_contains)
-        ref_sq = ref_sq.where(AssetReference.name.ilike(f"%{escaped}%", escape=esc))
-
-    ref_sq = apply_tag_filters(ref_sq, include_tags, exclude_tags)
-    ref_sq = apply_metadata_filter(ref_sq, metadata_filter)
-    ref_sq = ref_sq.subquery()
-
-    # Count tags across those references
-    q = (
-        select(
-            AssetReferenceTag.tag_name,
-            func.count(AssetReferenceTag.asset_reference_id).label("cnt"),
-        )
-        .where(AssetReferenceTag.asset_reference_id.in_(select(ref_sq.c.id)))
-        .group_by(AssetReferenceTag.tag_name)
-        .order_by(func.count(AssetReferenceTag.asset_reference_id).desc(), AssetReferenceTag.tag_name.asc())
-        .limit(limit)
-    )
-
-    rows = session.execute(q).all()
-    return {tag_name: int(cnt) for tag_name, cnt in rows}
-
-
 def bulk_insert_tags_and_meta(
     session: Session,
     tag_rows: list[dict],
     meta_rows: list[dict],
 ) -> None:
-    """Batch insert into asset_reference_tags and asset_reference_meta.
-
-    Uses ON CONFLICT DO NOTHING.
+    """Batch insert into asset_info_tags and asset_info_meta with ON CONFLICT DO NOTHING.
 
     Args:
         session: Database session
-        tag_rows: Dicts with: asset_reference_id, tag_name, origin, added_at
-        meta_rows: Dicts with: asset_reference_id, key, ordinal, val_*
+        tag_rows: List of dicts with keys: asset_info_id, tag_name, origin, added_at
+        meta_rows: List of dicts with keys: asset_info_id, key, ordinal, val_str, val_num, val_bool, val_json
     """
     if tag_rows:
-        ins_tags = sqlite.insert(AssetReferenceTag).on_conflict_do_nothing(
-            index_elements=[
-                AssetReferenceTag.asset_reference_id,
-                AssetReferenceTag.tag_name,
-            ]
+        ins_tags = sqlite.insert(AssetInfoTag).on_conflict_do_nothing(
+            index_elements=[AssetInfoTag.asset_info_id, AssetInfoTag.tag_name]
         )
         for chunk in iter_row_chunks(tag_rows, cols_per_row=4):
             session.execute(ins_tags, chunk)
 
     if meta_rows:
-        ins_meta = sqlite.insert(AssetReferenceMeta).on_conflict_do_nothing(
+        ins_meta = sqlite.insert(AssetInfoMeta).on_conflict_do_nothing(
             index_elements=[
-                AssetReferenceMeta.asset_reference_id,
-                AssetReferenceMeta.key,
-                AssetReferenceMeta.ordinal,
+                AssetInfoMeta.asset_info_id,
+                AssetInfoMeta.key,
+                AssetInfoMeta.ordinal,
             ]
         )
         for chunk in iter_row_chunks(meta_rows, cols_per_row=7):

app/assets/helpers.py

@@ -1,6 +1,6 @@
 import os
 from datetime import datetime, timezone
-from typing import Sequence
+from typing import Literal, Sequence
 
 
 def select_best_live_path(states: Sequence) -> str:
@@ -23,10 +23,16 @@ def select_best_live_path(states: Sequence) -> str:
     return alive[0].file_path
 
 
-def escape_sql_like_string(s: str, escape: str = "!") -> tuple[str, str]:
-    """Escapes %, _ and the escape char in a LIKE prefix.
+ALLOWED_ROOTS: tuple[Literal["models", "input", "output"], ...] = (
+    "models",
+    "input",
+    "output",
+)
 
-    Returns (escaped_prefix, escape_char).
+
+def escape_sql_like_string(s: str, escape: str = "!") -> tuple[str, str]:
+    """Escapes %, _ and the escape char itself in a LIKE prefix.
+    Returns (escaped_prefix, escape_char). Caller should append '%' and pass escape=escape_char to .like().
     """
     s = s.replace(escape, escape + escape)  # escape the escape char first
     s = s.replace("%", escape + "%").replace("_", escape + "_")  # escape LIKE wildcards
@@ -44,22 +50,4 @@ def normalize_tags(tags: list[str] | None) -> list[str]:
       - Stripping whitespace and converting to lowercase.
       - Removing duplicates.
     """
-    return list(dict.fromkeys(t.strip().lower() for t in (tags or []) if (t or "").strip()))
-
-
-def validate_blake3_hash(s: str) -> str:
-    """Validate and normalize a blake3 hash string.
-
-    Returns canonical 'blake3:<hex>' or raises ValueError.
-    """
-    s = s.strip().lower()
-    if not s or ":" not in s:
-        raise ValueError("hash must be 'blake3:<hex>'")
-    algo, digest = s.split(":", 1)
-    if (
-        algo != "blake3"
-        or len(digest) != 64
-        or any(c for c in digest if c not in "0123456789abcdef")
-    ):
-        raise ValueError("hash must be 'blake3:<hex>'")
-    return f"{algo}:{digest}"
+    return [t.strip().lower() for t in (tags or []) if (t or "").strip()]

app/assets/scanner.py

@@ -1,60 +1,49 @@
+import contextlib
 import logging
 import os
-from pathlib import Path
-from typing import Callable, Literal, TypedDict
+import time
+from typing import Literal, TypedDict
 
 import folder_paths
 from app.assets.database.queries import (
     add_missing_tag_for_asset_id,
-    bulk_update_enrichment_level,
-    bulk_update_is_missing,
-    bulk_update_needs_verify,
+    bulk_set_needs_verify,
+    delete_cache_states_by_ids,
     delete_orphaned_seed_asset,
-    delete_references_by_ids,
     ensure_tags_exist,
-    get_asset_by_hash,
-    get_reference_by_id,
-    get_references_for_prefixes,
-    get_unenriched_references,
-    mark_references_missing_outside_prefixes,
-    reassign_asset_references,
+    get_cache_states_for_prefixes,
     remove_missing_tag_for_asset_id,
-    set_reference_system_metadata,
-    update_asset_hash_and_mime,
 )
 from app.assets.services.bulk_ingest import (
     SeedAssetSpec,
     batch_insert_seed_assets,
+    prune_orphaned_assets,
 )
 from app.assets.services.file_utils import (
     get_mtime_ns,
-    is_visible,
     list_files_recursively,
     verify_file_unchanged,
 )
-from app.assets.services.hashing import HashCheckpoint, compute_blake3_hash
-from app.assets.services.metadata_extract import extract_file_metadata
 from app.assets.services.path_utils import (
     compute_relative_filename,
     get_comfy_models_folders,
     get_name_and_tags_from_asset_path,
 )
-from app.database.db import create_session
+from app.database.db import create_session, dependencies_available
 
 
-class _RefInfo(TypedDict):
-    ref_id: str
-    file_path: str
+class _StateInfo(TypedDict):
+    sid: int
+    fp: str
     exists: bool
-    stat_unchanged: bool
+    fast_ok: bool
     needs_verify: bool
 
 
 class _AssetAccumulator(TypedDict):
     hash: str | None
     size_db: int
-    refs: list[_RefInfo]
-
+    states: list[_StateInfo]
 
 RootType = Literal["models", "input", "output"]
 
@@ -72,46 +61,39 @@ def get_prefixes_for_root(root: RootType) -> list[str]:
     return []
 
 
-def get_all_known_prefixes() -> list[str]:
-    """Get all known asset prefixes across all root types."""
-    all_roots: tuple[RootType, ...] = ("models", "input", "output")
-    return [p for root in all_roots for p in get_prefixes_for_root(root)]
-
-
 def collect_models_files() -> list[str]:
     out: list[str] = []
     for folder_name, bases in get_comfy_models_folders():
         rel_files = folder_paths.get_filename_list(folder_name) or []
         for rel_path in rel_files:
-            if not all(is_visible(part) for part in Path(rel_path).parts):
-                continue
             abs_path = folder_paths.get_full_path(folder_name, rel_path)
             if not abs_path:
                 continue
             abs_path = os.path.abspath(abs_path)
             allowed = False
-            abs_p = Path(abs_path)
             for b in bases:
-                if abs_p.is_relative_to(os.path.abspath(b)):
-                    allowed = True
-                    break
+                base_abs = os.path.abspath(b)
+                with contextlib.suppress(Exception):
+                    if os.path.commonpath([abs_path, base_abs]) == base_abs:
+                        allowed = True
+                        break
             if allowed:
                 out.append(abs_path)
     return out
 
 
-def sync_references_with_filesystem(
+def sync_cache_states_with_filesystem(
     session,
     root: RootType,
     collect_existing_paths: bool = False,
     update_missing_tags: bool = False,
 ) -> set[str] | None:
-    """Reconcile asset references with filesystem for a root.
+    """Reconcile cache states with filesystem for a root.
 
-    - Toggle needs_verify per reference using mtime/size stat check
-    - For hashed assets with at least one stat-unchanged ref: delete stale missing refs
-    - For seed assets with all refs missing: delete Asset and its references
-    - Optionally add/remove 'missing' tags based on stat check in this root
+    - Toggle needs_verify per state using fast mtime/size check
+    - For hashed assets with at least one fast-ok state in this root: delete stale missing states
+    - For seed assets with all states missing: delete Asset and its AssetInfos
+    - Optionally add/remove 'missing' tags based on fast-ok in this root
     - Optionally return surviving absolute paths
 
     Args:
@@ -127,117 +109,96 @@ def sync_references_with_filesystem(
     if not prefixes:
         return set() if collect_existing_paths else None
 
-    rows = get_references_for_prefixes(
-        session, prefixes, include_missing=update_missing_tags
-    )
+    rows = get_cache_states_for_prefixes(session, prefixes)
 
     by_asset: dict[str, _AssetAccumulator] = {}
     for row in rows:
         acc = by_asset.get(row.asset_id)
         if acc is None:
-            acc = {"hash": row.asset_hash, "size_db": row.size_bytes, "refs": []}
+            acc = {"hash": row.asset_hash, "size_db": row.size_bytes, "states": []}
             by_asset[row.asset_id] = acc
 
-        stat_unchanged = False
+        fast_ok = False
         try:
             exists = True
-            stat_unchanged = verify_file_unchanged(
+            fast_ok = verify_file_unchanged(
                 mtime_db=row.mtime_ns,
                 size_db=acc["size_db"],
                 stat_result=os.stat(row.file_path, follow_symlinks=True),
             )
         except FileNotFoundError:
             exists = False
-        except PermissionError:
-            exists = True
-            logging.debug("Permission denied accessing %s", row.file_path)
-        except OSError as e:
+        except OSError:
             exists = False
-            logging.debug("OSError checking %s: %s", row.file_path, e)
 
-        acc["refs"].append(
+        acc["states"].append(
             {
-                "ref_id": row.reference_id,
-                "file_path": row.file_path,
+                "sid": row.state_id,
+                "fp": row.file_path,
                 "exists": exists,
-                "stat_unchanged": stat_unchanged,
+                "fast_ok": fast_ok,
                 "needs_verify": row.needs_verify,
             }
         )
 
-    to_set_verify: list[str] = []
-    to_clear_verify: list[str] = []
-    stale_ref_ids: list[str] = []
-    to_mark_missing: list[str] = []
-    to_clear_missing: list[str] = []
+    to_set_verify: list[int] = []
+    to_clear_verify: list[int] = []
+    stale_state_ids: list[int] = []
     survivors: set[str] = set()
 
     for aid, acc in by_asset.items():
         a_hash = acc["hash"]
-        refs = acc["refs"]
-        any_unchanged = any(r["stat_unchanged"] for r in refs)
-        all_missing = all(not r["exists"] for r in refs)
+        states = acc["states"]
+        any_fast_ok = any(s["fast_ok"] for s in states)
+        all_missing = all(not s["exists"] for s in states)
 
-        for r in refs:
-            if not r["exists"]:
-                to_mark_missing.append(r["ref_id"])
+        for s in states:
+            if not s["exists"]:
                 continue
-            if r["stat_unchanged"]:
-                to_clear_missing.append(r["ref_id"])
-                if r["needs_verify"]:
-                    to_clear_verify.append(r["ref_id"])
-            if not r["stat_unchanged"] and not r["needs_verify"]:
-                to_set_verify.append(r["ref_id"])
+            if s["fast_ok"] and s["needs_verify"]:
+                to_clear_verify.append(s["sid"])
+            if not s["fast_ok"] and not s["needs_verify"]:
+                to_set_verify.append(s["sid"])
 
         if a_hash is None:
-            if refs and all_missing:
+            if states and all_missing:
                 delete_orphaned_seed_asset(session, aid)
             else:
-                for r in refs:
-                    if r["exists"]:
-                        survivors.add(os.path.abspath(r["file_path"]))
+                for s in states:
+                    if s["exists"]:
+                        survivors.add(os.path.abspath(s["fp"]))
             continue
 
-        if any_unchanged:
-            for r in refs:
-                if not r["exists"]:
-                    stale_ref_ids.append(r["ref_id"])
+        if any_fast_ok:
+            for s in states:
+                if not s["exists"]:
+                    stale_state_ids.append(s["sid"])
             if update_missing_tags:
-                try:
+                with contextlib.suppress(Exception):
                     remove_missing_tag_for_asset_id(session, asset_id=aid)
-                except Exception as e:
-                    logging.warning(
-                        "Failed to remove missing tag for asset %s: %s", aid, e
-                    )
         elif update_missing_tags:
-            try:
+            with contextlib.suppress(Exception):
                 add_missing_tag_for_asset_id(session, asset_id=aid, origin="automatic")
-            except Exception as e:
-                logging.warning("Failed to add missing tag for asset %s: %s", aid, e)
 
-        for r in refs:
-            if r["exists"]:
-                survivors.add(os.path.abspath(r["file_path"]))
+        for s in states:
+            if s["exists"]:
+                survivors.add(os.path.abspath(s["fp"]))
 
-    delete_references_by_ids(session, stale_ref_ids)
-    stale_set = set(stale_ref_ids)
-    to_mark_missing = [ref_id for ref_id in to_mark_missing if ref_id not in stale_set]
-    bulk_update_is_missing(session, to_mark_missing, value=True)
-    bulk_update_is_missing(session, to_clear_missing, value=False)
-    bulk_update_needs_verify(session, to_set_verify, value=True)
-    bulk_update_needs_verify(session, to_clear_verify, value=False)
+    delete_cache_states_by_ids(session, stale_state_ids)
+    bulk_set_needs_verify(session, to_set_verify, value=True)
+    bulk_set_needs_verify(session, to_clear_verify, value=False)
 
     return survivors if collect_existing_paths else None
 
 
-def sync_root_safely(root: RootType) -> set[str]:
-    """Sync a single root's references with the filesystem.
+def _sync_root_safely(root: RootType) -> set[str]:
+    """Sync a single root's cache states with the filesystem.
 
     Returns survivors (existing paths) or empty set on failure.
     """
     try:
         with create_session() as sess:
-            survivors = sync_references_with_filesystem(
+            survivors = sync_cache_states_with_filesystem(
                 sess,
                 root,
                 collect_existing_paths=True,
@@ -250,22 +211,22 @@ def sync_root_safely(root: RootType) -> set[str]:
         return set()
 
 
-def mark_missing_outside_prefixes_safely(prefixes: list[str]) -> int:
-    """Mark references as missing when outside the given prefixes.
+def _prune_orphans_safely(prefixes: list[str]) -> int:
+    """Prune orphaned assets outside the given prefixes.
 
-    This is a non-destructive soft-delete. Returns count marked or 0 on failure.
+    Returns count pruned or 0 on failure.
     """
     try:
         with create_session() as sess:
-            count = mark_references_missing_outside_prefixes(sess, prefixes)
+            count = prune_orphaned_assets(sess, prefixes)
             sess.commit()
             return count
     except Exception as e:
-        logging.exception("marking missing assets failed: %s", e)
+        logging.exception("orphan pruning failed: %s", e)
         return 0
 
 
-def collect_paths_for_roots(roots: tuple[RootType, ...]) -> list[str]:
+def _collect_paths_for_roots(roots: tuple[RootType, ...]) -> list[str]:
     """Collect all file paths for the given roots."""
     paths: list[str] = []
     if "models" in roots:
@@ -277,20 +238,11 @@ def collect_paths_for_roots(roots: tuple[RootType, ...]) -> list[str]:
     return paths
 
 
-def build_asset_specs(
+def _build_asset_specs(
     paths: list[str],
     existing_paths: set[str],
-    enable_metadata_extraction: bool = True,
-    compute_hashes: bool = False,
 ) -> tuple[list[SeedAssetSpec], set[str], int]:
-    """Build asset specs from paths, returning (specs, tag_pool, skipped_count).
-
-    Args:
-        paths: List of file paths to process
-        existing_paths: Set of paths that already exist in the database
-        enable_metadata_extraction: If True, extract tier 1 & 2 metadata
-        compute_hashes: If True, compute blake3 hashes (slow for large files)
-    """
+    """Build asset specs from paths, returning (specs, tag_pool, skipped_count)."""
     specs: list[SeedAssetSpec] = []
     tag_pool: set[str] = set()
     skipped = 0
@@ -301,33 +253,12 @@ def build_asset_specs(
             skipped += 1
             continue
         try:
-            stat_p = os.stat(abs_p, follow_symlinks=True)
+            stat_p = os.stat(abs_p, follow_symlinks=False)
         except OSError:
             continue
         if not stat_p.st_size:
             continue
         name, tags = get_name_and_tags_from_asset_path(abs_p)
-        rel_fname = compute_relative_filename(abs_p)
-
-        # Extract metadata (tier 1: filesystem, tier 2: safetensors header)
-        metadata = None
-        if enable_metadata_extraction:
-            metadata = extract_file_metadata(
-                abs_p,
-                stat_result=stat_p,
-                relative_filename=rel_fname,
-            )
-
-        # Compute hash if requested
-        asset_hash: str | None = None
-        if compute_hashes:
-            try:
-                digest, _ = compute_blake3_hash(abs_p)
-                asset_hash = "blake3:" + digest
-            except Exception as e:
-                logging.warning("Failed to hash %s: %s", abs_p, e)
-
-        mime_type = metadata.content_type if metadata else None
         specs.append(
             {
                 "abs_path": abs_p,
@@ -335,11 +266,7 @@ def build_asset_specs(
                 "mtime_ns": get_mtime_ns(stat_p),
                 "info_name": name,
                 "tags": tags,
-                "fname": rel_fname,
-                "metadata": metadata,
-                "hash": asset_hash,
-                "mime_type": mime_type,
-                "job_id": None,
+                "fname": compute_relative_filename(abs_p),
             }
         )
         tag_pool.update(tags)
@@ -347,9 +274,8 @@ def build_asset_specs(
     return specs, tag_pool, skipped
 
 
-
-def insert_asset_specs(specs: list[SeedAssetSpec], tag_pool: set[str]) -> int:
-    """Insert asset specs into database, returning count of created refs."""
+def _insert_asset_specs(specs: list[SeedAssetSpec], tag_pool: set[str]) -> int:
+    """Insert asset specs into database, returning count of created infos."""
     if not specs:
         return 0
     with create_session() as sess:
@@ -357,226 +283,36 @@ def insert_asset_specs(specs: list[SeedAssetSpec], tag_pool: set[str]) -> int:
             ensure_tags_exist(sess, tag_pool, tag_type="user")
         result = batch_insert_seed_assets(sess, specs=specs, owner_id="")
         sess.commit()
-        return result.inserted_refs
+        return result.inserted_infos
 
 
-# Enrichment level constants
-ENRICHMENT_STUB = 0  # Fast scan: path, size, mtime only
-ENRICHMENT_METADATA = 1  # Metadata extracted (safetensors header, mime type)
-ENRICHMENT_HASHED = 2  # Hash computed (blake3)
+def seed_assets(roots: tuple[RootType, ...], enable_logging: bool = False) -> None:
+    """Scan the given roots and seed the assets into the database."""
+    if not dependencies_available():
+        if enable_logging:
+            logging.warning("Database dependencies not available, skipping assets scan")
+        return
 
+    t_start = time.perf_counter()
 
-def get_unenriched_assets_for_roots(
-    roots: tuple[RootType, ...],
-    max_level: int = ENRICHMENT_STUB,
-    limit: int = 1000,
-) -> list:
-    """Get assets that need enrichment for the given roots.
+    existing_paths: set[str] = set()
+    for r in roots:
+        existing_paths.update(_sync_root_safely(r))
 
-    Args:
-        roots: Tuple of root types to scan
-        max_level: Maximum enrichment level to include
-        limit: Maximum number of rows to return
+    all_prefixes = [os.path.abspath(p) for r in roots for p in get_prefixes_for_root(r)]
+    orphans_pruned = _prune_orphans_safely(all_prefixes)
 
-    Returns:
-        List of UnenrichedReferenceRow
-    """
-    prefixes: list[str] = []
-    for root in roots:
-        prefixes.extend(get_prefixes_for_root(root))
+    paths = _collect_paths_for_roots(roots)
+    specs, tag_pool, skipped_existing = _build_asset_specs(paths, existing_paths)
+    created = _insert_asset_specs(specs, tag_pool)
 
-    if not prefixes:
-        return []
-
-    with create_session() as sess:
-        return get_unenriched_references(
-            sess, prefixes, max_level=max_level, limit=limit
-        )
-
-
-def enrich_asset(
-    session,
-    file_path: str,
-    reference_id: str,
-    asset_id: str,
-    extract_metadata: bool = True,
-    compute_hash: bool = False,
-    interrupt_check: Callable[[], bool] | None = None,
-    hash_checkpoints: dict[str, HashCheckpoint] | None = None,
-) -> int:
-    """Enrich a single asset with metadata and/or hash.
-
-    Args:
-        session: Database session (caller manages lifecycle)
-        file_path: Absolute path to the file
-        reference_id: ID of the reference to update
-        asset_id: ID of the asset to update (for mime_type and hash)
-        extract_metadata: If True, extract safetensors header and mime type
-        compute_hash: If True, compute blake3 hash
-        interrupt_check: Optional non-blocking callable that returns True if
-            the operation should be interrupted (e.g. paused or cancelled)
-        hash_checkpoints: Optional dict for saving/restoring hash progress
-            across interruptions, keyed by file path
-
-    Returns:
-        New enrichment level achieved
-    """
-    new_level = ENRICHMENT_STUB
-
-    try:
-        stat_p = os.stat(file_path, follow_symlinks=True)
-    except OSError:
-        return new_level
-
-    initial_mtime_ns = get_mtime_ns(stat_p)
-    rel_fname = compute_relative_filename(file_path)
-    mime_type: str | None = None
-    metadata = None
-
-    if extract_metadata:
-        metadata = extract_file_metadata(
-            file_path,
-            stat_result=stat_p,
-            relative_filename=rel_fname,
-        )
-        if metadata:
-            mime_type = metadata.content_type
-            new_level = ENRICHMENT_METADATA
-
-    full_hash: str | None = None
-    if compute_hash:
-        try:
-            mtime_before = get_mtime_ns(stat_p)
-            size_before = stat_p.st_size
-
-            # Restore checkpoint if available and file unchanged
-            checkpoint = None
-            if hash_checkpoints is not None:
-                checkpoint = hash_checkpoints.get(file_path)
-                if checkpoint is not None:
-                    cur_stat = os.stat(file_path, follow_symlinks=True)
-                    if (checkpoint.mtime_ns != get_mtime_ns(cur_stat)
-                            or checkpoint.file_size != cur_stat.st_size):
-                        checkpoint = None
-                        hash_checkpoints.pop(file_path, None)
-                    else:
-                        mtime_before = get_mtime_ns(cur_stat)
-
-            digest, new_checkpoint = compute_blake3_hash(
-                file_path,
-                interrupt_check=interrupt_check,
-                checkpoint=checkpoint,
-            )
-
-            if digest is None:
-                # Interrupted — save checkpoint for later resumption
-                if hash_checkpoints is not None and new_checkpoint is not None:
-                    new_checkpoint.mtime_ns = mtime_before
-                    new_checkpoint.file_size = size_before
-                    hash_checkpoints[file_path] = new_checkpoint
-                return new_level
-
-            # Completed — clear any saved checkpoint
-            if hash_checkpoints is not None:
-                hash_checkpoints.pop(file_path, None)
-
-            stat_after = os.stat(file_path, follow_symlinks=True)
-            mtime_after = get_mtime_ns(stat_after)
-            if mtime_before != mtime_after:
-                logging.warning("File modified during hashing, discarding hash: %s", file_path)
-            else:
-                full_hash = f"blake3:{digest}"
-                metadata_ok = not extract_metadata or metadata is not None
-                if metadata_ok:
-                    new_level = ENRICHMENT_HASHED
-        except Exception as e:
-            logging.warning("Failed to hash %s: %s", file_path, e)
-
-    # Optimistic guard: if the reference's mtime_ns changed since we
-    # started (e.g. ingest_existing_file updated it), our results are
-    # stale — discard them to avoid overwriting fresh registration data.
-    ref = get_reference_by_id(session, reference_id)
-    if ref is None or ref.mtime_ns != initial_mtime_ns:
-        session.rollback()
+    if enable_logging:
         logging.info(
-            "Ref %s mtime changed during enrichment, discarding stale result",
-            reference_id,
+            "Assets scan(roots=%s) completed in %.3fs (created=%d, skipped_existing=%d, orphans_pruned=%d, total_seen=%d)",
+            roots,
+            time.perf_counter() - t_start,
+            created,
+            skipped_existing,
+            orphans_pruned,
+            len(paths),
         )
-        return ENRICHMENT_STUB
-
-    if extract_metadata and metadata:
-        system_metadata = metadata.to_user_metadata()
-        set_reference_system_metadata(session, reference_id, system_metadata)
-
-    if full_hash:
-        existing = get_asset_by_hash(session, full_hash)
-        if existing and existing.id != asset_id:
-            reassign_asset_references(session, asset_id, existing.id, reference_id)
-            delete_orphaned_seed_asset(session, asset_id)
-            if mime_type:
-                update_asset_hash_and_mime(session, existing.id, mime_type=mime_type)
-        else:
-            update_asset_hash_and_mime(session, asset_id, full_hash, mime_type)
-    elif mime_type:
-        update_asset_hash_and_mime(session, asset_id, mime_type=mime_type)
-
-    bulk_update_enrichment_level(session, [reference_id], new_level)
-    session.commit()
-
-    return new_level
-
-
-def enrich_assets_batch(
-    rows: list,
-    extract_metadata: bool = True,
-    compute_hash: bool = False,
-    interrupt_check: Callable[[], bool] | None = None,
-    hash_checkpoints: dict[str, HashCheckpoint] | None = None,
-) -> tuple[int, list[str]]:
-    """Enrich a batch of assets.
-
-    Uses a single DB session for the entire batch, committing after each
-    individual asset to avoid long-held transactions while eliminating
-    per-asset session creation overhead.
-
-    Args:
-        rows: List of UnenrichedReferenceRow from get_unenriched_assets_for_roots
-        extract_metadata: If True, extract metadata for each asset
-        compute_hash: If True, compute hash for each asset
-        interrupt_check: Optional non-blocking callable that returns True if
-            the operation should be interrupted (e.g. paused or cancelled)
-        hash_checkpoints: Optional dict for saving/restoring hash progress
-            across interruptions, keyed by file path
-
-    Returns:
-        Tuple of (enriched_count, failed_reference_ids)
-    """
-    enriched = 0
-    failed_ids: list[str] = []
-
-    with create_session() as sess:
-        for row in rows:
-            if interrupt_check is not None and interrupt_check():
-                break
-
-            try:
-                new_level = enrich_asset(
-                    sess,
-                    file_path=row.file_path,
-                    reference_id=row.reference_id,
-                    asset_id=row.asset_id,
-                    extract_metadata=extract_metadata,
-                    compute_hash=compute_hash,
-                    interrupt_check=interrupt_check,
-                    hash_checkpoints=hash_checkpoints,
-                )
-                if new_level > row.enrichment_level:
-                    enriched += 1
-                else:
-                    failed_ids.append(row.reference_id)
-            except Exception as e:
-                logging.warning("Failed to enrich %s: %s", row.file_path, e)
-                sess.rollback()
-                failed_ids.append(row.reference_id)
-
-    return enriched, failed_ids

app/assets/seeder.py

@@ -1,846 +0,0 @@
-"""Background asset seeder with thread management and cancellation support."""
-
-import logging
-import os
-import threading
-import time
-from dataclasses import dataclass, field
-from enum import Enum
-from typing import Callable
-
-from app.assets.scanner import (
-    ENRICHMENT_METADATA,
-    ENRICHMENT_STUB,
-    RootType,
-    build_asset_specs,
-    collect_paths_for_roots,
-    enrich_assets_batch,
-    get_all_known_prefixes,
-    get_prefixes_for_root,
-    get_unenriched_assets_for_roots,
-    insert_asset_specs,
-    mark_missing_outside_prefixes_safely,
-    sync_root_safely,
-)
-from app.database.db import dependencies_available
-
-
-class ScanInProgressError(Exception):
-    """Raised when an operation cannot proceed because a scan is running."""
-
-
-class State(Enum):
-    """Seeder state machine states."""
-
-    IDLE = "IDLE"
-    RUNNING = "RUNNING"
-    PAUSED = "PAUSED"
-    CANCELLING = "CANCELLING"
-
-
-class ScanPhase(Enum):
-    """Scan phase options."""
-
-    FAST = "fast"  # Phase 1: filesystem only (stubs)
-    ENRICH = "enrich"  # Phase 2: metadata + hash
-    FULL = "full"  # Both phases sequentially
-
-
-@dataclass
-class Progress:
-    """Progress information for a scan operation."""
-
-    scanned: int = 0
-    total: int = 0
-    created: int = 0
-    skipped: int = 0
-
-
-@dataclass
-class ScanStatus:
-    """Current status of the asset seeder."""
-
-    state: State
-    progress: Progress | None
-    errors: list[str] = field(default_factory=list)
-
-
-ProgressCallback = Callable[[Progress], None]
-
-
-class _AssetSeeder:
-    """Background asset scanning manager.
-
-    Spawns ephemeral daemon threads for scanning.
-    Each scan creates a new thread that exits when complete.
-    Use the module-level ``asset_seeder`` instance.
-    """
-
-    def __init__(self) -> None:
-        # RLock is required because _run_scan() drains pending work while
-        # holding _lock and re-enters start() which also acquires _lock.
-        self._lock = threading.RLock()
-        self._state = State.IDLE
-        self._progress: Progress | None = None
-        self._last_progress: Progress | None = None
-        self._errors: list[str] = []
-        self._thread: threading.Thread | None = None
-        self._cancel_event = threading.Event()
-        self._run_gate = threading.Event()
-        self._run_gate.set()  # Start unpaused (set = running, clear = paused)
-        self._roots: tuple[RootType, ...] = ()
-        self._phase: ScanPhase = ScanPhase.FULL
-        self._compute_hashes: bool = False
-        self._prune_first: bool = False
-        self._progress_callback: ProgressCallback | None = None
-        self._disabled: bool = False
-        self._pending_enrich: dict | None = None
-
-    def disable(self) -> None:
-        """Disable the asset seeder, preventing any scans from starting."""
-        self._disabled = True
-        logging.info("Asset seeder disabled")
-
-    def is_disabled(self) -> bool:
-        """Check if the asset seeder is disabled."""
-        return self._disabled
-
-    def start(
-        self,
-        roots: tuple[RootType, ...] = ("models", "input", "output"),
-        phase: ScanPhase = ScanPhase.FULL,
-        progress_callback: ProgressCallback | None = None,
-        prune_first: bool = False,
-        compute_hashes: bool = False,
-    ) -> bool:
-        """Start a background scan for the given roots.
-
-        Args:
-            roots: Tuple of root types to scan (models, input, output)
-            phase: Scan phase to run (FAST, ENRICH, or FULL for both)
-            progress_callback: Optional callback called with progress updates
-            prune_first: If True, prune orphaned assets before scanning
-            compute_hashes: If True, compute blake3 hashes (slow)
-
-        Returns:
-            True if scan was started, False if already running
-        """
-        if self._disabled:
-            logging.debug("Asset seeder is disabled, skipping start")
-            return False
-        logging.info("Seeder start (roots=%s, phase=%s)", roots, phase.value)
-        with self._lock:
-            if self._state != State.IDLE:
-                logging.info("Asset seeder already running, skipping start")
-                return False
-            self._state = State.RUNNING
-            self._progress = Progress()
-            self._errors = []
-            self._roots = roots
-            self._phase = phase
-            self._prune_first = prune_first
-            self._compute_hashes = compute_hashes
-            self._progress_callback = progress_callback
-            self._cancel_event.clear()
-            self._run_gate.set()  # Ensure unpaused when starting
-            self._thread = threading.Thread(
-                target=self._run_scan,
-                name="_AssetSeeder",
-                daemon=True,
-            )
-            self._thread.start()
-            return True
-
-    def start_fast(
-        self,
-        roots: tuple[RootType, ...] = ("models", "input", "output"),
-        progress_callback: ProgressCallback | None = None,
-        prune_first: bool = False,
-    ) -> bool:
-        """Start a fast scan (phase 1 only) - creates stub records.
-
-        Args:
-            roots: Tuple of root types to scan
-            progress_callback: Optional callback for progress updates
-            prune_first: If True, prune orphaned assets before scanning
-
-        Returns:
-            True if scan was started, False if already running
-        """
-        return self.start(
-            roots=roots,
-            phase=ScanPhase.FAST,
-            progress_callback=progress_callback,
-            prune_first=prune_first,
-            compute_hashes=False,
-        )
-
-    def start_enrich(
-        self,
-        roots: tuple[RootType, ...] = ("models", "input", "output"),
-        progress_callback: ProgressCallback | None = None,
-        compute_hashes: bool = False,
-    ) -> bool:
-        """Start an enrichment scan (phase 2 only) - extracts metadata and hashes.
-
-        Args:
-            roots: Tuple of root types to scan
-            progress_callback: Optional callback for progress updates
-            compute_hashes: If True, compute blake3 hashes
-
-        Returns:
-            True if scan was started, False if already running
-        """
-        return self.start(
-            roots=roots,
-            phase=ScanPhase.ENRICH,
-            progress_callback=progress_callback,
-            prune_first=False,
-            compute_hashes=compute_hashes,
-        )
-
-    def enqueue_enrich(
-        self,
-        roots: tuple[RootType, ...] = ("models", "input", "output"),
-        compute_hashes: bool = False,
-    ) -> bool:
-        """Start an enrichment scan now, or queue it for after the current scan.
-
-        If the seeder is idle, starts immediately. Otherwise, the enrich
-        request is stored and will run automatically when the current scan
-        finishes.
-
-        Args:
-            roots: Tuple of root types to scan
-            compute_hashes: If True, compute blake3 hashes
-
-        Returns:
-            True if started immediately, False if queued for later
-        """
-        with self._lock:
-            if self.start_enrich(roots=roots, compute_hashes=compute_hashes):
-                return True
-            if self._pending_enrich is not None:
-                existing_roots = set(self._pending_enrich["roots"])
-                existing_roots.update(roots)
-                self._pending_enrich["roots"] = tuple(existing_roots)
-                self._pending_enrich["compute_hashes"] = (
-                    self._pending_enrich["compute_hashes"] or compute_hashes
-                )
-            else:
-                self._pending_enrich = {
-                    "roots": roots,
-                    "compute_hashes": compute_hashes,
-                }
-            logging.info("Enrich scan queued (roots=%s)", self._pending_enrich["roots"])
-        return False
-
-    def cancel(self) -> bool:
-        """Request cancellation of the current scan.
-
-        Returns:
-            True if cancellation was requested, False if not running or paused
-        """
-        with self._lock:
-            if self._state not in (State.RUNNING, State.PAUSED):
-                return False
-            logging.info("Asset seeder cancelling (was %s)", self._state.value)
-            self._state = State.CANCELLING
-            self._cancel_event.set()
-            self._run_gate.set()  # Unblock if paused so thread can exit
-            return True
-
-    def stop(self) -> bool:
-        """Stop the current scan (alias for cancel).
-
-        Returns:
-            True if stop was requested, False if not running
-        """
-        return self.cancel()
-
-    def pause(self) -> bool:
-        """Pause the current scan.
-
-        The scan will complete its current batch before pausing.
-
-        Returns:
-            True if pause was requested, False if not running
-        """
-        with self._lock:
-            if self._state != State.RUNNING:
-                return False
-            logging.info("Asset seeder pausing")
-            self._state = State.PAUSED
-            self._run_gate.clear()
-            return True
-
-    def resume(self) -> bool:
-        """Resume a paused scan.
-
-        This is a noop if the scan is not in the PAUSED state
-
-        Returns:
-            True if resumed, False if not paused
-        """
-        with self._lock:
-            if self._state != State.PAUSED:
-                return False
-            logging.info("Asset seeder resuming")
-            self._state = State.RUNNING
-            self._run_gate.set()
-        self._emit_event("assets.seed.resumed", {})
-        return True
-
-    def restart(
-        self,
-        roots: tuple[RootType, ...] | None = None,
-        phase: ScanPhase | None = None,
-        progress_callback: ProgressCallback | None = None,
-        prune_first: bool | None = None,
-        compute_hashes: bool | None = None,
-        timeout: float = 5.0,
-    ) -> bool:
-        """Cancel any running scan and start a new one.
-
-        Args:
-            roots: Roots to scan (defaults to previous roots)
-            phase: Scan phase (defaults to previous phase)
-            progress_callback: Progress callback (defaults to previous)
-            prune_first: Prune before scan (defaults to previous)
-            compute_hashes: Compute hashes (defaults to previous)
-            timeout: Max seconds to wait for current scan to stop
-
-        Returns:
-            True if new scan was started, False if failed to stop previous
-        """
-        logging.info("Asset seeder restart requested")
-        with self._lock:
-            prev_roots = self._roots
-            prev_phase = self._phase
-            prev_callback = self._progress_callback
-            prev_prune = self._prune_first
-            prev_hashes = self._compute_hashes
-
-        self.cancel()
-        if not self.wait(timeout=timeout):
-            return False
-
-        cb = progress_callback if progress_callback is not None else prev_callback
-        return self.start(
-            roots=roots if roots is not None else prev_roots,
-            phase=phase if phase is not None else prev_phase,
-            progress_callback=cb,
-            prune_first=prune_first if prune_first is not None else prev_prune,
-            compute_hashes=(
-                compute_hashes if compute_hashes is not None else prev_hashes
-            ),
-        )
-
-    def wait(self, timeout: float | None = None) -> bool:
-        """Wait for the current scan to complete.
-
-        Args:
-            timeout: Maximum seconds to wait, or None for no timeout
-
-        Returns:
-            True if scan completed, False if timeout expired or no scan running
-        """
-        with self._lock:
-            thread = self._thread
-        if thread is None:
-            return True
-        thread.join(timeout=timeout)
-        return not thread.is_alive()
-
-    def get_status(self) -> ScanStatus:
-        """Get the current status and progress of the seeder."""
-        with self._lock:
-            src = self._progress or self._last_progress
-            return ScanStatus(
-                state=self._state,
-                progress=Progress(
-                    scanned=src.scanned,
-                    total=src.total,
-                    created=src.created,
-                    skipped=src.skipped,
-                )
-                if src
-                else None,
-                errors=list(self._errors),
-            )
-
-    def shutdown(self, timeout: float = 5.0) -> None:
-        """Gracefully shutdown: cancel any running scan and wait for thread.
-
-        Args:
-            timeout: Maximum seconds to wait for thread to exit
-        """
-        self.cancel()
-        self.wait(timeout=timeout)
-        with self._lock:
-            self._thread = None
-
-    def mark_missing_outside_prefixes(self) -> int:
-        """Mark references as missing when outside all known root prefixes.
-
-        This is a non-destructive soft-delete operation. Assets and their
-        metadata are preserved, but references are flagged as missing.
-        They can be restored if the file reappears in a future scan.
-
-        This operation is decoupled from scanning to prevent partial scans
-        from accidentally marking assets belonging to other roots.
-
-        Should be called explicitly when cleanup is desired, typically after
-        a full scan of all roots or during maintenance.
-
-        Returns:
-            Number of references marked as missing
-
-        Raises:
-            ScanInProgressError: If a scan is currently running
-        """
-        with self._lock:
-            if self._state != State.IDLE:
-                raise ScanInProgressError(
-                    "Cannot mark missing assets while scan is running"
-                )
-            self._state = State.RUNNING
-
-        try:
-            if not dependencies_available():
-                logging.warning(
-                    "Database dependencies not available, skipping mark missing"
-                )
-                return 0
-
-            all_prefixes = get_all_known_prefixes()
-            marked = mark_missing_outside_prefixes_safely(all_prefixes)
-            if marked > 0:
-                logging.info("Marked %d references as missing", marked)
-            return marked
-        finally:
-            with self._lock:
-                self._reset_to_idle()
-
-    def _reset_to_idle(self) -> None:
-        """Reset state to IDLE, preserving last progress. Caller must hold _lock."""
-        self._last_progress = self._progress
-        self._state = State.IDLE
-        self._progress = None
-
-    def _is_cancelled(self) -> bool:
-        """Check if cancellation has been requested."""
-        return self._cancel_event.is_set()
-
-    def _is_paused_or_cancelled(self) -> bool:
-        """Non-blocking check: True if paused or cancelled.
-
-        Use as interrupt_check for I/O-bound work (e.g. hashing) so that
-        file handles are released immediately on pause rather than held
-        open while blocked. The caller is responsible for blocking on
-        _check_pause_and_cancel() afterward.
-        """
-        return not self._run_gate.is_set() or self._cancel_event.is_set()
-
-    def _check_pause_and_cancel(self) -> bool:
-        """Block while paused, then check if cancelled.
-
-        Call this at checkpoint locations in scan loops. It will:
-        1. Block indefinitely while paused (until resume or cancel)
-        2. Return True if cancelled, False to continue
-
-        Returns:
-            True if scan should stop, False to continue
-        """
-        if not self._run_gate.is_set():
-            self._emit_event("assets.seed.paused", {})
-        self._run_gate.wait()  # Blocks if paused
-        return self._is_cancelled()
-
-    def _emit_event(self, event_type: str, data: dict) -> None:
-        """Emit a WebSocket event if server is available."""
-        try:
-            from server import PromptServer
-
-            if hasattr(PromptServer, "instance") and PromptServer.instance:
-                PromptServer.instance.send_sync(event_type, data)
-        except Exception:
-            pass
-
-    def _update_progress(
-        self,
-        scanned: int | None = None,
-        total: int | None = None,
-        created: int | None = None,
-        skipped: int | None = None,
-    ) -> None:
-        """Update progress counters (thread-safe)."""
-        callback: ProgressCallback | None = None
-        progress: Progress | None = None
-
-        with self._lock:
-            if self._progress is None:
-                return
-            if scanned is not None:
-                self._progress.scanned = scanned
-            if total is not None:
-                self._progress.total = total
-            if created is not None:
-                self._progress.created = created
-            if skipped is not None:
-                self._progress.skipped = skipped
-            if self._progress_callback:
-                callback = self._progress_callback
-                progress = Progress(
-                    scanned=self._progress.scanned,
-                    total=self._progress.total,
-                    created=self._progress.created,
-                    skipped=self._progress.skipped,
-                )
-
-        if callback and progress:
-            try:
-                callback(progress)
-            except Exception:
-                pass
-
-    _MAX_ERRORS = 200
-
-    def _add_error(self, message: str) -> None:
-        """Add an error message (thread-safe), capped at _MAX_ERRORS."""
-        with self._lock:
-            if len(self._errors) < self._MAX_ERRORS:
-                self._errors.append(message)
-
-    def _log_scan_config(self, roots: tuple[RootType, ...]) -> None:
-        """Log the directories that will be scanned."""
-        import folder_paths
-
-        for root in roots:
-            if root == "models":
-                logging.info(
-                    "Asset scan [models] directory: %s",
-                    os.path.abspath(folder_paths.models_dir),
-                )
-            else:
-                prefixes = get_prefixes_for_root(root)
-                if prefixes:
-                    logging.info("Asset scan [%s] directories: %s", root, prefixes)
-
-    def _run_scan(self) -> None:
-        """Main scan loop running in background thread."""
-        t_start = time.perf_counter()
-        roots = self._roots
-        phase = self._phase
-        cancelled = False
-        total_created = 0
-        total_enriched = 0
-        skipped_existing = 0
-        total_paths = 0
-
-        try:
-            if not dependencies_available():
-                self._add_error("Database dependencies not available")
-                self._emit_event(
-                    "assets.seed.error",
-                    {"message": "Database dependencies not available"},
-                )
-                return
-
-            if self._prune_first:
-                all_prefixes = get_all_known_prefixes()
-                marked = mark_missing_outside_prefixes_safely(all_prefixes)
-                if marked > 0:
-                    logging.info("Marked %d refs as missing before scan", marked)
-
-            if self._check_pause_and_cancel():
-                logging.info("Asset scan cancelled after pruning phase")
-                cancelled = True
-                return
-
-            self._log_scan_config(roots)
-
-            # Phase 1: Fast scan (stub records)
-            if phase in (ScanPhase.FAST, ScanPhase.FULL):
-                created, skipped, paths = self._run_fast_phase(roots)
-                total_created, skipped_existing, total_paths = created, skipped, paths
-
-                if self._check_pause_and_cancel():
-                    cancelled = True
-                    return
-
-                self._emit_event(
-                    "assets.seed.fast_complete",
-                    {
-                        "roots": list(roots),
-                        "created": total_created,
-                        "skipped": skipped_existing,
-                        "total": total_paths,
-                    },
-                )
-
-            # Phase 2: Enrichment scan (metadata + hashes)
-            if phase in (ScanPhase.ENRICH, ScanPhase.FULL):
-                if self._check_pause_and_cancel():
-                    cancelled = True
-                    return
-
-                enrich_cancelled, total_enriched = self._run_enrich_phase(roots)
-
-                if enrich_cancelled:
-                    cancelled = True
-                    return
-
-                self._emit_event(
-                    "assets.seed.enrich_complete",
-                    {
-                        "roots": list(roots),
-                        "enriched": total_enriched,
-                    },
-                )
-
-            elapsed = time.perf_counter() - t_start
-            logging.info(
-                "Scan(%s, %s) done %.3fs: created=%d enriched=%d skipped=%d",
-                roots,
-                phase.value,
-                elapsed,
-                total_created,
-                total_enriched,
-                skipped_existing,
-            )
-
-            self._emit_event(
-                "assets.seed.completed",
-                {
-                    "phase": phase.value,
-                    "total": total_paths,
-                    "created": total_created,
-                    "enriched": total_enriched,
-                    "skipped": skipped_existing,
-                    "elapsed": round(elapsed, 3),
-                },
-            )
-
-        except Exception as e:
-            self._add_error(f"Scan failed: {e}")
-            logging.exception("Asset scan failed")
-            self._emit_event("assets.seed.error", {"message": str(e)})
-        finally:
-            if cancelled:
-                self._emit_event(
-                    "assets.seed.cancelled",
-                    {
-                        "scanned": self._progress.scanned if self._progress else 0,
-                        "total": total_paths,
-                        "created": total_created,
-                    },
-                )
-            with self._lock:
-                self._reset_to_idle()
-                pending = self._pending_enrich
-                if pending is not None:
-                    self._pending_enrich = None
-                    if not self.start_enrich(
-                        roots=pending["roots"],
-                        compute_hashes=pending["compute_hashes"],
-                    ):
-                        logging.warning(
-                            "Pending enrich scan could not start (roots=%s)",
-                            pending["roots"],
-                        )
-
-    def _run_fast_phase(self, roots: tuple[RootType, ...]) -> tuple[int, int, int]:
-        """Run phase 1: fast scan to create stub records.
-
-        Returns:
-            Tuple of (total_created, skipped_existing, total_paths)
-        """
-        t_fast_start = time.perf_counter()
-        total_created = 0
-        skipped_existing = 0
-
-        existing_paths: set[str] = set()
-        t_sync = time.perf_counter()
-        for r in roots:
-            if self._check_pause_and_cancel():
-                return total_created, skipped_existing, 0
-            existing_paths.update(sync_root_safely(r))
-        logging.debug(
-            "Fast scan: sync_root phase took %.3fs (%d existing paths)",
-            time.perf_counter() - t_sync,
-            len(existing_paths),
-        )
-
-        if self._check_pause_and_cancel():
-            return total_created, skipped_existing, 0
-
-        t_collect = time.perf_counter()
-        paths = collect_paths_for_roots(roots)
-        logging.debug(
-            "Fast scan: collect_paths took %.3fs (%d paths found)",
-            time.perf_counter() - t_collect,
-            len(paths),
-        )
-        total_paths = len(paths)
-        self._update_progress(total=total_paths)
-
-        self._emit_event(
-            "assets.seed.started",
-            {"roots": list(roots), "total": total_paths, "phase": "fast"},
-        )
-
-        # Use stub specs (no metadata extraction, no hashing)
-        t_specs = time.perf_counter()
-        specs, tag_pool, skipped_existing = build_asset_specs(
-            paths,
-            existing_paths,
-            enable_metadata_extraction=False,
-            compute_hashes=False,
-        )
-        logging.debug(
-            "Fast scan: build_asset_specs took %.3fs (%d specs, %d skipped)",
-            time.perf_counter() - t_specs,
-            len(specs),
-            skipped_existing,
-        )
-        self._update_progress(skipped=skipped_existing)
-
-        if self._check_pause_and_cancel():
-            return total_created, skipped_existing, total_paths
-
-        batch_size = 500
-        last_progress_time = time.perf_counter()
-        progress_interval = 1.0
-
-        for i in range(0, len(specs), batch_size):
-            if self._check_pause_and_cancel():
-                logging.info(
-                    "Fast scan cancelled after %d/%d files (created=%d)",
-                    i,
-                    len(specs),
-                    total_created,
-                )
-                return total_created, skipped_existing, total_paths
-
-            batch = specs[i : i + batch_size]
-            batch_tags = {t for spec in batch for t in spec["tags"]}
-            try:
-                created = insert_asset_specs(batch, batch_tags)
-                total_created += created
-            except Exception as e:
-                self._add_error(f"Batch insert failed at offset {i}: {e}")
-                logging.exception("Batch insert failed at offset %d", i)
-
-            scanned = i + len(batch)
-            now = time.perf_counter()
-            self._update_progress(scanned=scanned, created=total_created)
-
-            if now - last_progress_time >= progress_interval:
-                self._emit_event(
-                    "assets.seed.progress",
-                    {
-                        "phase": "fast",
-                        "scanned": scanned,
-                        "total": len(specs),
-                        "created": total_created,
-                    },
-                )
-                last_progress_time = now
-
-        self._update_progress(scanned=len(specs), created=total_created)
-        logging.info(
-            "Fast scan complete: %.3fs total (created=%d, skipped=%d, total_paths=%d)",
-            time.perf_counter() - t_fast_start,
-            total_created,
-            skipped_existing,
-            total_paths,
-        )
-        return total_created, skipped_existing, total_paths
-
-    def _run_enrich_phase(self, roots: tuple[RootType, ...]) -> tuple[bool, int]:
-        """Run phase 2: enrich existing records with metadata and hashes.
-
-        Returns:
-            Tuple of (cancelled, total_enriched)
-        """
-        total_enriched = 0
-        batch_size = 100
-        last_progress_time = time.perf_counter()
-        progress_interval = 1.0
-
-        # Get the target enrichment level based on compute_hashes
-        if not self._compute_hashes:
-            target_max_level = ENRICHMENT_STUB
-        else:
-            target_max_level = ENRICHMENT_METADATA
-
-        self._emit_event(
-            "assets.seed.started",
-            {"roots": list(roots), "phase": "enrich"},
-        )
-
-        skip_ids: set[str] = set()
-        consecutive_empty = 0
-        max_consecutive_empty = 3
-
-        # Hash checkpoints survive across batches so interrupted hashes
-        # can be resumed without re-reading the entire file.
-        hash_checkpoints: dict[str, object] = {}
-
-        while True:
-            if self._check_pause_and_cancel():
-                logging.info("Enrich scan cancelled after %d assets", total_enriched)
-                return True, total_enriched
-
-            # Fetch next batch of unenriched assets
-            unenriched = get_unenriched_assets_for_roots(
-                roots,
-                max_level=target_max_level,
-                limit=batch_size,
-            )
-
-            # Filter out previously failed references
-            if skip_ids:
-                unenriched = [r for r in unenriched if r.reference_id not in skip_ids]
-
-            if not unenriched:
-                break
-
-            enriched, failed_ids = enrich_assets_batch(
-                unenriched,
-                extract_metadata=True,
-                compute_hash=self._compute_hashes,
-                interrupt_check=self._is_paused_or_cancelled,
-                hash_checkpoints=hash_checkpoints,
-            )
-            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
-
-            now = time.perf_counter()
-            if now - last_progress_time >= progress_interval:
-                self._emit_event(
-                    "assets.seed.progress",
-                    {
-                        "phase": "enrich",
-                        "enriched": total_enriched,
-                    },
-                )
-                last_progress_time = now
-
-        return False, total_enriched
-
-
-asset_seeder = _AssetSeeder()

app/assets/services/__init__.py

@@ -11,7 +11,7 @@ from app.assets.services.asset_management import (
 from app.assets.services.bulk_ingest import (
     BulkInsertResult,
     batch_insert_seed_assets,
-    cleanup_unreferenced_assets,
+    prune_orphaned_assets,
 )
 from app.assets.services.file_utils import (
     get_mtime_ns,
@@ -23,23 +23,22 @@ from app.assets.services.ingest import (
     DependencyMissingError,
     HashMismatchError,
     create_from_hash,
-    ingest_existing_file,
-    register_output_files,
+    ingest_file_from_path,
+    register_existing_asset,
     upload_from_temp_path,
 )
-from app.assets.database.queries import (
-    AddTagsResult,
-    RemoveTagsResult,
-)
 from app.assets.services.schemas import (
+    AddTagsResult,
     AssetData,
     AssetDetailResult,
+    AssetInfoData,
     AssetSummaryData,
     DownloadResolutionResult,
     IngestResult,
     ListAssetsResult,
-    ReferenceData,
     RegisterAssetResult,
+    RemoveTagsResult,
+    SetTagsResult,
     TagUsage,
     UploadResult,
     UserMetadata,
@@ -54,8 +53,8 @@ __all__ = [
     "AddTagsResult",
     "AssetData",
     "AssetDetailResult",
+    "AssetInfoData",
     "AssetSummaryData",
-    "ReferenceData",
     "BulkInsertResult",
     "DependencyMissingError",
     "DownloadResolutionResult",
@@ -64,6 +63,7 @@ __all__ = [
     "ListAssetsResult",
     "RegisterAssetResult",
     "RemoveTagsResult",
+    "SetTagsResult",
     "TagUsage",
     "UploadResult",
     "UserMetadata",
@@ -74,14 +74,14 @@ __all__ = [
     "delete_asset_reference",
     "get_asset_by_hash",
     "get_asset_detail",
-    "ingest_existing_file",
-    "register_output_files",
     "get_mtime_ns",
     "get_size_and_mtime_ns",
+    "ingest_file_from_path",
     "list_assets_page",
     "list_files_recursively",
     "list_tags",
-    "cleanup_unreferenced_assets",
+    "prune_orphaned_assets",
+    "register_existing_asset",
     "remove_tags",
     "resolve_asset_for_download",
     "set_asset_preview",

app/assets/services/asset_management.py

@@ -7,27 +7,23 @@ from typing import Sequence
 from app.assets.database.models import Asset
 from app.assets.database.queries import (
     asset_exists_by_hash,
-    reference_exists_for_asset_id,
-    delete_reference_by_id,
-    fetch_reference_and_asset,
-    soft_delete_reference_by_id,
-    fetch_reference_asset_and_tags,
+    asset_info_exists_for_asset_id,
+    delete_asset_info_by_id,
+    fetch_asset_info_and_asset,
+    fetch_asset_info_asset_and_tags,
     get_asset_by_hash as queries_get_asset_by_hash,
-    get_reference_by_id,
-    get_reference_with_owner_check,
-    list_references_page,
-    list_all_file_paths_by_asset_id,
-    list_references_by_asset_id,
-    set_reference_metadata,
-    set_reference_preview,
-    set_reference_tags,
-    update_asset_hash_and_mime,
-    update_reference_access_time,
-    update_reference_name,
-    update_reference_updated_at,
+    get_asset_info_by_id,
+    list_asset_infos_page,
+    list_cache_states_by_asset_id,
+    set_asset_info_metadata,
+    set_asset_info_preview,
+    set_asset_info_tags,
+    update_asset_info_access_time,
+    update_asset_info_name,
+    update_asset_info_updated_at,
 )
 from app.assets.helpers import select_best_live_path
-from app.assets.services.path_utils import compute_relative_filename
+from app.assets.services.path_utils import compute_filename_for_asset
 from app.assets.services.schemas import (
     AssetData,
     AssetDetailResult,
@@ -36,106 +32,93 @@ from app.assets.services.schemas import (
     ListAssetsResult,
     UserMetadata,
     extract_asset_data,
-    extract_reference_data,
+    extract_info_data,
 )
 from app.database.db import create_session
 
 
 def get_asset_detail(
-    reference_id: str,
+    asset_info_id: str,
     owner_id: str = "",
 ) -> AssetDetailResult | None:
     with create_session() as session:
-        result = fetch_reference_asset_and_tags(
+        result = fetch_asset_info_asset_and_tags(
             session,
-            reference_id=reference_id,
+            asset_info_id=asset_info_id,
             owner_id=owner_id,
         )
         if not result:
             return None
 
-        ref, asset, tags = result
+        info, asset, tags = result
         return AssetDetailResult(
-            ref=extract_reference_data(ref),
+            info=extract_info_data(info),
             asset=extract_asset_data(asset),
             tags=tags,
         )
 
 
 def update_asset_metadata(
-    reference_id: str,
+    asset_info_id: str,
     name: str | None = None,
     tags: Sequence[str] | None = None,
     user_metadata: UserMetadata = None,
     tag_origin: str = "manual",
     owner_id: str = "",
-    mime_type: str | None = None,
-    preview_id: str | None = None,
 ) -> AssetDetailResult:
     with create_session() as session:
-        ref = get_reference_with_owner_check(session, reference_id, owner_id)
+        info = get_asset_info_by_id(session, asset_info_id=asset_info_id)
+        if not info:
+            raise ValueError(f"AssetInfo {asset_info_id} not found")
+        if info.owner_id and info.owner_id != owner_id:
+            raise PermissionError("not owner")
 
         touched = False
-        if name is not None and name != ref.name:
-            update_reference_name(session, reference_id=reference_id, name=name)
+        if name is not None and name != info.name:
+            update_asset_info_name(session, asset_info_id=asset_info_id, name=name)
             touched = True
 
-        computed_filename = compute_relative_filename(ref.file_path) if ref.file_path else None
+        computed_filename = compute_filename_for_asset(session, info.asset_id)
 
         new_meta: dict | None = None
         if user_metadata is not None:
             new_meta = dict(user_metadata)
         elif computed_filename:
-            current_meta = ref.user_metadata or {}
+            current_meta = info.user_metadata or {}
             if current_meta.get("filename") != computed_filename:
                 new_meta = dict(current_meta)
 
         if new_meta is not None:
             if computed_filename:
                 new_meta["filename"] = computed_filename
-            set_reference_metadata(
-                session, reference_id=reference_id, user_metadata=new_meta
+            set_asset_info_metadata(
+                session, asset_info_id=asset_info_id, user_metadata=new_meta
             )
             touched = True
 
         if tags is not None:
-            set_reference_tags(
+            set_asset_info_tags(
                 session,
-                reference_id=reference_id,
+                asset_info_id=asset_info_id,
                 tags=tags,
                 origin=tag_origin,
             )
             touched = True
 
-        if mime_type is not None:
-            updated = update_asset_hash_and_mime(
-                session, asset_id=ref.asset_id, mime_type=mime_type
-            )
-            if updated:
-                touched = True
-
-        if preview_id is not None:
-            set_reference_preview(
-                session,
-                reference_id=reference_id,
-                preview_reference_id=preview_id,
-            )
-            touched = True
-
         if touched and user_metadata is None:
-            update_reference_updated_at(session, reference_id=reference_id)
+            update_asset_info_updated_at(session, asset_info_id=asset_info_id)
 
-        result = fetch_reference_asset_and_tags(
+        result = fetch_asset_info_asset_and_tags(
             session,
-            reference_id=reference_id,
+            asset_info_id=asset_info_id,
             owner_id=owner_id,
         )
         if not result:
             raise RuntimeError("State changed during update")
 
-        ref, asset, tag_list = result
+        info, asset, tag_list = result
         detail = AssetDetailResult(
-            ref=extract_reference_data(ref),
+            info=extract_info_data(info),
             asset=extract_asset_data(asset),
             tags=tag_list,
         )
@@ -145,45 +128,35 @@ def update_asset_metadata(
 
 
 def delete_asset_reference(
-    reference_id: str,
+    asset_info_id: str,
     owner_id: str,
     delete_content_if_orphan: bool = True,
 ) -> bool:
     with create_session() as session:
-        if not delete_content_if_orphan:
-            # Soft delete: mark the reference as deleted but keep everything
-            deleted = soft_delete_reference_by_id(
-                session, reference_id=reference_id, owner_id=owner_id
-            )
-            session.commit()
-            return deleted
+        info_row = get_asset_info_by_id(session, asset_info_id=asset_info_id)
+        asset_id = info_row.asset_id if info_row else None
 
-        ref_row = get_reference_by_id(session, reference_id=reference_id)
-        asset_id = ref_row.asset_id if ref_row else None
-        file_path = ref_row.file_path if ref_row else None
-
-        deleted = delete_reference_by_id(
-            session, reference_id=reference_id, owner_id=owner_id
+        deleted = delete_asset_info_by_id(
+            session, asset_info_id=asset_info_id, owner_id=owner_id
         )
         if not deleted:
             session.commit()
             return False
 
-        if not asset_id:
+        if not delete_content_if_orphan or not asset_id:
             session.commit()
             return True
 
-        still_exists = reference_exists_for_asset_id(session, asset_id=asset_id)
+        still_exists = asset_info_exists_for_asset_id(session, asset_id=asset_id)
         if still_exists:
             session.commit()
             return True
 
-        # Orphaned asset - gather ALL file paths (including
-        # soft-deleted / missing refs) so their on-disk files get cleaned up.
-        file_paths = list_all_file_paths_by_asset_id(session, asset_id=asset_id)
-        # Also include the just-deleted file path
-        if file_path:
-            file_paths.append(file_path)
+        # Orphaned asset - delete it and its files
+        states = list_cache_states_by_asset_id(session, asset_id=asset_id)
+        file_paths = [
+            s.file_path for s in (states or []) if getattr(s, "file_path", None)
+        ]
 
         asset_row = session.get(Asset, asset_id)
         if asset_row is not None:
@@ -201,28 +174,32 @@ def delete_asset_reference(
 
 
 def set_asset_preview(
-    reference_id: str,
-    preview_reference_id: str | None = None,
+    asset_info_id: str,
+    preview_asset_id: str | None = None,
     owner_id: str = "",
 ) -> AssetDetailResult:
     with create_session() as session:
-        get_reference_with_owner_check(session, reference_id, owner_id)
+        info_row = get_asset_info_by_id(session, asset_info_id=asset_info_id)
+        if not info_row:
+            raise ValueError(f"AssetInfo {asset_info_id} not found")
+        if info_row.owner_id and info_row.owner_id != owner_id:
+            raise PermissionError("not owner")
 
-        set_reference_preview(
+        set_asset_info_preview(
             session,
-            reference_id=reference_id,
-            preview_reference_id=preview_reference_id,
+            asset_info_id=asset_info_id,
+            preview_asset_id=preview_asset_id,
         )
 
-        result = fetch_reference_asset_and_tags(
-            session, reference_id=reference_id, owner_id=owner_id
+        result = fetch_asset_info_asset_and_tags(
+            session, asset_info_id=asset_info_id, owner_id=owner_id
         )
         if not result:
             raise RuntimeError("State changed during preview update")
 
-        ref, asset, tags = result
+        info, asset, tags = result
         detail = AssetDetailResult(
-            ref=extract_reference_data(ref),
+            info=extract_info_data(info),
             asset=extract_asset_data(asset),
             tags=tags,
         )
@@ -254,7 +231,7 @@ def list_assets_page(
     order: str = "desc",
 ) -> ListAssetsResult:
     with create_session() as session:
-        refs, tag_map, total = list_references_page(
+        infos, tag_map, total = list_asset_infos_page(
             session,
             owner_id=owner_id,
             include_tags=include_tags,
@@ -268,98 +245,44 @@ def list_assets_page(
         )
 
         items: list[AssetSummaryData] = []
-        for ref in refs:
+        for info in infos:
             items.append(
                 AssetSummaryData(
-                    ref=extract_reference_data(ref),
-                    asset=extract_asset_data(ref.asset),
-                    tags=tag_map.get(ref.id, []),
+                    info=extract_info_data(info),
+                    asset=extract_asset_data(info.asset),
+                    tags=tag_map.get(info.id, []),
                 )
             )
 
         return ListAssetsResult(items=items, total=total)
 
 
-def resolve_hash_to_path(
-    asset_hash: str,
-    owner_id: str = "",
-) -> DownloadResolutionResult | None:
-    """Resolve a blake3 hash to an on-disk file path.
-
-    Only references visible to *owner_id* are considered (owner-less
-    references are always visible).
-
-    Returns a DownloadResolutionResult with abs_path, content_type, and
-    download_name, or None if no asset or live path is found.
-    """
-    with create_session() as session:
-        asset = queries_get_asset_by_hash(session, asset_hash)
-        if not asset:
-            return None
-        refs = list_references_by_asset_id(session, asset_id=asset.id)
-        visible = [
-            r for r in refs
-            if r.owner_id == "" or r.owner_id == owner_id
-        ]
-        abs_path = select_best_live_path(visible)
-        if not abs_path:
-            return None
-        display_name = os.path.basename(abs_path)
-        for ref in visible:
-            if ref.file_path == abs_path and ref.name:
-                display_name = ref.name
-                break
-        ctype = (
-            asset.mime_type
-            or mimetypes.guess_type(display_name)[0]
-            or "application/octet-stream"
-        )
-    return DownloadResolutionResult(
-        abs_path=abs_path,
-        content_type=ctype,
-        download_name=display_name,
-    )
-
-
 def resolve_asset_for_download(
-    reference_id: str,
+    asset_info_id: str,
     owner_id: str = "",
 ) -> DownloadResolutionResult:
     with create_session() as session:
-        pair = fetch_reference_and_asset(
-            session, reference_id=reference_id, owner_id=owner_id
+        pair = fetch_asset_info_and_asset(
+            session, asset_info_id=asset_info_id, owner_id=owner_id
         )
         if not pair:
-            raise ValueError(f"AssetReference {reference_id} not found")
+            raise ValueError(f"AssetInfo {asset_info_id} not found")
 
-        ref, asset = pair
+        info, asset = pair
+        states = list_cache_states_by_asset_id(session, asset_id=asset.id)
+        abs_path = select_best_live_path(states)
+        if not abs_path:
+            raise FileNotFoundError
 
-        # For references with file_path, use that directly
-        if ref.file_path and os.path.isfile(ref.file_path):
-            abs_path = ref.file_path
-        else:
-            # For API-created refs without file_path, find a path from other refs
-            refs = list_references_by_asset_id(session, asset_id=asset.id)
-            abs_path = select_best_live_path(refs)
-            if not abs_path:
-                raise FileNotFoundError(
-                    f"No live path for AssetReference {reference_id} "
-                    f"(asset id={asset.id}, name={ref.name})"
-                )
-
-        # Capture ORM attributes before commit (commit expires loaded objects)
-        ref_name = ref.name
-        asset_mime = asset.mime_type
-
-        update_reference_access_time(session, reference_id=reference_id)
+        update_asset_info_access_time(session, asset_info_id=asset_info_id)
         session.commit()
 
         ctype = (
-            asset_mime
-            or mimetypes.guess_type(ref_name or abs_path)[0]
+            asset.mime_type
+            or mimetypes.guess_type(info.name or abs_path)[0]
             or "application/octet-stream"
         )
-        download_name = ref_name or os.path.basename(abs_path)
+        download_name = info.name or os.path.basename(abs_path)
         return DownloadResolutionResult(
             abs_path=abs_path,
             content_type=ctype,

app/assets/services/bulk_ingest.py

@@ -1,29 +1,10 @@
-from __future__ import annotations
-
 import os
 import uuid
 from dataclasses import dataclass
-from datetime import datetime
-from typing import TYPE_CHECKING, Any, TypedDict
+from typing import TypedDict
 
 from sqlalchemy.orm import Session
 
-from app.assets.database.queries import (
-    bulk_insert_assets,
-    bulk_insert_references_ignore_conflicts,
-    bulk_insert_tags_and_meta,
-    delete_assets_by_ids,
-    get_existing_asset_ids,
-    get_reference_ids_by_ids,
-    get_references_by_paths_and_asset_ids,
-    get_unreferenced_unhashed_asset_ids,
-    restore_references_by_paths,
-)
-from app.assets.helpers import get_utc_now
-
-if TYPE_CHECKING:
-    from app.assets.services.metadata_extract import ExtractedMetadata
-
 
 class SeedAssetSpec(TypedDict):
     """Spec for seeding an asset from filesystem."""
@@ -34,67 +15,28 @@ class SeedAssetSpec(TypedDict):
     info_name: str
     tags: list[str]
     fname: str
-    metadata: ExtractedMetadata | None
-    hash: str | None
-    mime_type: str | None
-    job_id: str | None
 
-
-class AssetRow(TypedDict):
-    """Row data for inserting an Asset."""
-
-    id: str
-    hash: str | None
-    size_bytes: int
-    mime_type: str | None
-    created_at: datetime
-
-
-class ReferenceRow(TypedDict):
-    """Row data for inserting an AssetReference."""
-
-    id: str
-    asset_id: str
-    file_path: str
-    mtime_ns: int
-    owner_id: str
-    name: str
-    preview_id: str | None
-    user_metadata: dict[str, Any] | None
-    job_id: str | None
-    created_at: datetime
-    updated_at: datetime
-    last_access_time: datetime
-
-
-class TagRow(TypedDict):
-    """Row data for inserting a Tag."""
-
-    asset_reference_id: str
-    tag_name: str
-    origin: str
-    added_at: datetime
-
-
-class MetadataRow(TypedDict):
-    """Row data for inserting asset metadata."""
-
-    asset_reference_id: str
-    key: str
-    ordinal: int
-    val_str: str | None
-    val_num: float | None
-    val_bool: bool | None
-    val_json: dict[str, Any] | None
+from app.assets.database.queries import (
+    bulk_insert_asset_infos_ignore_conflicts,
+    bulk_insert_assets,
+    bulk_insert_cache_states_ignore_conflicts,
+    bulk_insert_tags_and_meta,
+    delete_assets_by_ids,
+    delete_cache_states_outside_prefixes,
+    get_asset_info_ids_by_ids,
+    get_cache_states_by_paths_and_asset_ids,
+    get_orphaned_seed_asset_ids,
+)
+from app.assets.helpers import get_utc_now
 
 
 @dataclass
 class BulkInsertResult:
     """Result of bulk asset insertion."""
 
-    inserted_refs: int
-    won_paths: int
-    lost_paths: int
+    inserted_infos: int
+    won_states: int
+    lost_states: int
 
 
 def batch_insert_seed_assets(
@@ -114,170 +56,148 @@ def batch_insert_seed_assets(
 
     This function orchestrates:
     1. Insert seed Assets (hash=NULL)
-    2. Claim references with ON CONFLICT DO NOTHING on file_path
+    2. Claim cache states with ON CONFLICT DO NOTHING
     3. Query to find winners (paths where our asset_id was inserted)
     4. Delete Assets for losers (path already claimed by another asset)
-    5. Insert tags and metadata for successfully inserted references
+    5. Insert AssetInfo for winners
+    6. Insert tags and metadata for successfully inserted AssetInfos
 
     Returns:
-        BulkInsertResult with inserted_refs, won_paths, lost_paths
+        BulkInsertResult with inserted_infos, won_states, lost_states
     """
     if not specs:
-        return BulkInsertResult(inserted_refs=0, won_paths=0, lost_paths=0)
+        return BulkInsertResult(inserted_infos=0, won_states=0, lost_states=0)
 
-    current_time = get_utc_now()
-    asset_rows: list[AssetRow] = []
-    reference_rows: list[ReferenceRow] = []
-    path_to_asset_id: dict[str, str] = {}
-    asset_id_to_ref_data: dict[str, dict] = {}
-    absolute_path_list: list[str] = []
+    now = get_utc_now()
+    asset_rows: list[dict] = []
+    state_rows: list[dict] = []
+    path_to_asset: dict[str, str] = {}
+    asset_to_info: dict[str, dict] = {}
+    path_list: list[str] = []
 
-    for spec in specs:
-        absolute_path = os.path.abspath(spec["abs_path"])
-        asset_id = str(uuid.uuid4())
-        reference_id = str(uuid.uuid4())
-        absolute_path_list.append(absolute_path)
-        path_to_asset_id[absolute_path] = asset_id
+    for sp in specs:
+        ap = os.path.abspath(sp["abs_path"])
+        aid = str(uuid.uuid4())
+        iid = str(uuid.uuid4())
+        path_list.append(ap)
+        path_to_asset[ap] = aid
 
-        mime_type = spec.get("mime_type")
         asset_rows.append(
             {
-                "id": asset_id,
-                "hash": spec.get("hash"),
-                "size_bytes": spec["size_bytes"],
-                "mime_type": mime_type,
-                "created_at": current_time,
+                "id": aid,
+                "hash": None,
+                "size_bytes": sp["size_bytes"],
+                "mime_type": None,
+                "created_at": now,
             }
         )
-
-        # Build user_metadata from extracted metadata or fallback to filename
-        extracted_metadata = spec.get("metadata")
-        if extracted_metadata:
-            user_metadata: dict[str, Any] | None = extracted_metadata.to_user_metadata()
-        elif spec["fname"]:
-            user_metadata = {"filename": spec["fname"]}
-        else:
-            user_metadata = None
-
-        reference_rows.append(
+        state_rows.append(
             {
-                "id": reference_id,
-                "asset_id": asset_id,
-                "file_path": absolute_path,
-                "mtime_ns": spec["mtime_ns"],
-                "owner_id": owner_id,
-                "name": spec["info_name"],
-                "preview_id": None,
-                "user_metadata": user_metadata,
-                "job_id": spec.get("job_id"),
-                "created_at": current_time,
-                "updated_at": current_time,
-                "last_access_time": current_time,
+                "asset_id": aid,
+                "file_path": ap,
+                "mtime_ns": sp["mtime_ns"],
             }
         )
-
-        asset_id_to_ref_data[asset_id] = {
-            "reference_id": reference_id,
-            "tags": spec["tags"],
-            "filename": spec["fname"],
-            "extracted_metadata": extracted_metadata,
+        asset_to_info[aid] = {
+            "id": iid,
+            "owner_id": owner_id,
+            "name": sp["info_name"],
+            "asset_id": aid,
+            "preview_id": None,
+            "user_metadata": {"filename": sp["fname"]} if sp["fname"] else None,
+            "created_at": now,
+            "updated_at": now,
+            "last_access_time": now,
+            "_tags": sp["tags"],
+            "_filename": sp["fname"],
         }
 
     bulk_insert_assets(session, asset_rows)
+    bulk_insert_cache_states_ignore_conflicts(session, state_rows)
+    winners_by_path = get_cache_states_by_paths_and_asset_ids(session, path_to_asset)
 
-    # Filter reference rows to only those whose assets were actually inserted
-    # (assets with duplicate hashes are silently dropped by ON CONFLICT DO NOTHING)
-    inserted_asset_ids = get_existing_asset_ids(
-        session, [r["asset_id"] for r in reference_rows]
-    )
-    reference_rows = [r for r in reference_rows if r["asset_id"] in inserted_asset_ids]
+    all_paths_set = set(path_list)
+    losers_by_path = all_paths_set - winners_by_path
+    lost_assets = [path_to_asset[p] for p in losers_by_path]
 
-    bulk_insert_references_ignore_conflicts(session, reference_rows)
-    restore_references_by_paths(session, absolute_path_list)
-    winning_paths = get_references_by_paths_and_asset_ids(session, path_to_asset_id)
+    if lost_assets:
+        delete_assets_by_ids(session, lost_assets)
 
-    inserted_paths = {
-        path
-        for path in absolute_path_list
-        if path_to_asset_id[path] in inserted_asset_ids
-    }
-    losing_paths = inserted_paths - winning_paths
-    lost_asset_ids = [path_to_asset_id[path] for path in losing_paths]
-
-    if lost_asset_ids:
-        delete_assets_by_ids(session, lost_asset_ids)
-
-    if not winning_paths:
+    if not winners_by_path:
         return BulkInsertResult(
-            inserted_refs=0,
-            won_paths=0,
-            lost_paths=len(losing_paths),
+            inserted_infos=0,
+            won_states=0,
+            lost_states=len(losers_by_path),
         )
 
-    # Get reference IDs for winners
-    winning_ref_ids = [
-        asset_id_to_ref_data[path_to_asset_id[path]]["reference_id"]
-        for path in winning_paths
+    winner_info_rows = [asset_to_info[path_to_asset[p]] for p in winners_by_path]
+    db_info_rows = [
+        {
+            "id": row["id"],
+            "owner_id": row["owner_id"],
+            "name": row["name"],
+            "asset_id": row["asset_id"],
+            "preview_id": row["preview_id"],
+            "user_metadata": row["user_metadata"],
+            "created_at": row["created_at"],
+            "updated_at": row["updated_at"],
+            "last_access_time": row["last_access_time"],
+        }
+        for row in winner_info_rows
     ]
-    inserted_ref_ids = get_reference_ids_by_ids(session, winning_ref_ids)
+    bulk_insert_asset_infos_ignore_conflicts(session, db_info_rows)
 
-    tag_rows: list[TagRow] = []
-    metadata_rows: list[MetadataRow] = []
+    all_info_ids = [row["id"] for row in winner_info_rows]
+    inserted_info_ids = get_asset_info_ids_by_ids(session, all_info_ids)
 
-    if inserted_ref_ids:
-        for path in winning_paths:
-            asset_id = path_to_asset_id[path]
-            ref_data = asset_id_to_ref_data[asset_id]
-            ref_id = ref_data["reference_id"]
-
-            if ref_id not in inserted_ref_ids:
+    tag_rows: list[dict] = []
+    meta_rows: list[dict] = []
+    if inserted_info_ids:
+        for row in winner_info_rows:
+            iid = row["id"]
+            if iid not in inserted_info_ids:
                 continue
-
-            for tag in ref_data["tags"]:
+            for t in row["_tags"]:
                 tag_rows.append(
                     {
-                        "asset_reference_id": ref_id,
-                        "tag_name": tag,
+                        "asset_info_id": iid,
+                        "tag_name": t,
                         "origin": "automatic",
-                        "added_at": current_time,
+                        "added_at": now,
                     }
                 )
-
-            # Use extracted metadata for meta rows if available
-            extracted_metadata = ref_data.get("extracted_metadata")
-            if extracted_metadata:
-                metadata_rows.extend(extracted_metadata.to_meta_rows(ref_id))
-            elif ref_data["filename"]:
-                # Fallback: just store filename
-                metadata_rows.append(
+            if row["_filename"]:
+                meta_rows.append(
                     {
-                        "asset_reference_id": ref_id,
+                        "asset_info_id": iid,
                         "key": "filename",
                         "ordinal": 0,
-                        "val_str": ref_data["filename"],
+                        "val_str": row["_filename"],
                         "val_num": None,
                         "val_bool": None,
                         "val_json": None,
                     }
                 )
 
-    bulk_insert_tags_and_meta(session, tag_rows=tag_rows, meta_rows=metadata_rows)
+    bulk_insert_tags_and_meta(session, tag_rows=tag_rows, meta_rows=meta_rows)
 
     return BulkInsertResult(
-        inserted_refs=len(inserted_ref_ids),
-        won_paths=len(winning_paths),
-        lost_paths=len(losing_paths),
+        inserted_infos=len(inserted_info_ids),
+        won_states=len(winners_by_path),
+        lost_states=len(losers_by_path),
     )
 
 
-def cleanup_unreferenced_assets(session: Session) -> int:
-    """Hard-delete unhashed assets with no active references.
+def prune_orphaned_assets(session: Session, valid_prefixes: list[str]) -> int:
+    """Prune cache states outside valid prefixes, then delete orphaned seed assets.
 
-    This is a destructive operation intended for explicit cleanup.
-    Only deletes assets where hash=None and all references are missing.
+    Args:
+        session: Database session
+        valid_prefixes: List of absolute directory prefixes that are valid
 
     Returns:
-        Number of assets deleted
+        Number of orphaned assets deleted
     """
-    unreferenced_ids = get_unreferenced_unhashed_asset_ids(session)
-    return delete_assets_by_ids(session, unreferenced_ids)
+    delete_cache_states_outside_prefixes(session, valid_prefixes)
+    orphan_ids = get_orphaned_seed_asset_ids(session)
+    return delete_assets_by_ids(session, orphan_ids)

app/assets/services/file_utils.py

@@ -23,48 +23,27 @@ def verify_file_unchanged(
 
     Returns True if the file's mtime and size match the database values.
     Returns False if mtime_db is None or values don't match.
-
-    size_db=None means don't check size; 0 is a valid recorded size.
     """
     if mtime_db is None:
         return False
     actual_mtime_ns = get_mtime_ns(stat_result)
     if int(mtime_db) != int(actual_mtime_ns):
         return False
-    if size_db is not None:
-        return int(stat_result.st_size) == int(size_db)
+    sz = int(size_db or 0)
+    if sz > 0:
+        return int(stat_result.st_size) == sz
     return True
 
 
-def is_visible(name: str) -> bool:
-    """Return True if a file or directory name is visible (not hidden)."""
-    return not name.startswith(".")
-
-
 def list_files_recursively(base_dir: str) -> list[str]:
-    """Recursively list all files in a directory, following symlinks."""
+    """Recursively list all files in a directory."""
     out: list[str] = []
     base_abs = os.path.abspath(base_dir)
     if not os.path.isdir(base_abs):
         return out
-    # Track seen real directory identities to prevent circular symlink loops
-    seen_dirs: set[tuple[int, int]] = set()
-    for dirpath, subdirs, filenames in os.walk(
-        base_abs, topdown=True, followlinks=True
+    for dirpath, _subdirs, filenames in os.walk(
+        base_abs, topdown=True, followlinks=False
     ):
-        try:
-            st = os.stat(dirpath)
-            dir_id = (st.st_dev, st.st_ino)
-        except OSError:
-            subdirs.clear()
-            continue
-        if dir_id in seen_dirs:
-            subdirs.clear()
-            continue
-        seen_dirs.add(dir_id)
-        subdirs[:] = [d for d in subdirs if is_visible(d)]
         for name in filenames:
-            if not is_visible(name):
-                continue
             out.append(os.path.abspath(os.path.join(dirpath, name)))
     return out

app/assets/services/hashing.py

@@ -1,99 +1,54 @@
-import io
+import asyncio
 import os
-from contextlib import contextmanager
-from dataclasses import dataclass
-from typing import IO, Any, Callable, Iterator
-import logging
+from typing import IO
 
-try:
-    from blake3 import blake3
-except ModuleNotFoundError:
-    logging.warning("WARNING: blake3 package not installed")
+from blake3 import blake3
 
 DEFAULT_CHUNK = 8 * 1024 * 1024
 
-InterruptCheck = Callable[[], bool]
-
-
-@dataclass
-class HashCheckpoint:
-    """Saved state for resuming an interrupted hash computation."""
-
-    bytes_processed: int
-    hasher: Any  # blake3 hasher instance
-    mtime_ns: int = 0
-    file_size: int = 0
-
-
-@contextmanager
-def _open_for_hashing(fp: str | IO[bytes]) -> Iterator[tuple[IO[bytes], bool]]:
-    """Yield (file_object, is_path) with appropriate setup/teardown."""
-    if hasattr(fp, "read"):
-        seekable = getattr(fp, "seekable", lambda: False)()
-        orig_pos = None
-        if seekable:
-            try:
-                orig_pos = fp.tell()
-                if orig_pos != 0:
-                    fp.seek(0)
-            except io.UnsupportedOperation:
-                orig_pos = None
-        try:
-            yield fp, False
-        finally:
-            if orig_pos is not None:
-                fp.seek(orig_pos)
-    else:
-        with open(os.fspath(fp), "rb") as f:
-            yield f, True
-
 
 def compute_blake3_hash(
     fp: str | IO[bytes],
     chunk_size: int = DEFAULT_CHUNK,
-    interrupt_check: InterruptCheck | None = None,
-    checkpoint: HashCheckpoint | None = None,
-) -> tuple[str | None, HashCheckpoint | None]:
-    """Compute BLAKE3 hash of a file, with optional checkpoint support.
+) -> str:
+    if hasattr(fp, "read"):
+        return _hash_file_obj(fp, chunk_size)
 
-    Args:
-        fp: File path or file-like object
-        chunk_size: Size of chunks to read at a time
-        interrupt_check: Optional callable that returns True if the operation
-            should be interrupted (e.g. paused or cancelled). Must be
-            non-blocking so file handles are released immediately. Checked
-            between chunk reads.
-        checkpoint: Optional checkpoint to resume from (file paths only)
+    with open(os.fspath(fp), "rb") as f:
+        return _hash_file_obj(f, chunk_size)
 
-    Returns:
-        Tuple of (hex_digest, None) on completion, or
-        (None, checkpoint) on interruption (file paths only), or
-        (None, None) on interruption of a file object
-    """
+
+async def compute_compute_blake3_hash_async(
+    fp: str | IO[bytes],
+    chunk_size: int = DEFAULT_CHUNK,
+) -> str:
+    if hasattr(fp, "read"):
+        return await asyncio.to_thread(compute_blake3_hash, fp, chunk_size)
+
+    def _worker() -> str:
+        with open(os.fspath(fp), "rb") as f:
+            return _hash_file_obj(f, chunk_size)
+
+    return await asyncio.to_thread(_worker)
+
+
+def _hash_file_obj(file_obj: IO, chunk_size: int = DEFAULT_CHUNK) -> str:
     if chunk_size <= 0:
         chunk_size = DEFAULT_CHUNK
 
-    with _open_for_hashing(fp) as (f, is_path):
-        if checkpoint is not None and is_path:
-            f.seek(checkpoint.bytes_processed)
-            h = checkpoint.hasher
-            bytes_processed = checkpoint.bytes_processed
-        else:
-            h = blake3()
-            bytes_processed = 0
+    orig_pos = file_obj.tell()
 
+    try:
+        if orig_pos != 0:
+            file_obj.seek(0)
+
+        h = blake3()
         while True:
-            if interrupt_check is not None and interrupt_check():
-                if is_path:
-                    return None, HashCheckpoint(
-                        bytes_processed=bytes_processed,
-                        hasher=h,
-                    )
-                return None, None
-            chunk = f.read(chunk_size)
+            chunk = file_obj.read(chunk_size)
             if not chunk:
                 break
             h.update(chunk)
-            bytes_processed += len(chunk)
-
-        return h.hexdigest(), None
+        return h.hexdigest()
+    finally:
+        if orig_pos != 0:
+            file_obj.seek(orig_pos)

app/assets/services/ingest.py

@@ -2,36 +2,30 @@ import contextlib
 import logging
 import mimetypes
 import os
-from typing import Any, Sequence
+from typing import Sequence
 
+from sqlalchemy import select
 from sqlalchemy.orm import Session
 
 import app.assets.services.hashing as hashing
+from app.assets.database.models import Asset, AssetInfo, Tag
 from app.assets.database.queries import (
-    add_tags_to_reference,
-    count_active_siblings,
-    create_stub_asset,
-    ensure_tags_exist,
-    fetch_reference_and_asset,
+    add_tags_to_asset_info,
+    fetch_asset_info_and_asset,
     get_asset_by_hash,
-    get_reference_by_file_path,
-    get_reference_tags,
-    get_or_create_reference,
-    reference_exists,
+    get_asset_tags,
+    get_or_create_asset_info,
     remove_missing_tag_for_asset_id,
-    set_reference_metadata,
-    set_reference_tags,
-    update_asset_hash_and_mime,
+    set_asset_info_metadata,
+    set_asset_info_tags,
+    update_asset_info_timestamps,
     upsert_asset,
-    upsert_reference,
-    validate_tags_exist,
+    upsert_cache_state,
 )
-from app.assets.helpers import get_utc_now, normalize_tags
-from app.assets.services.bulk_ingest import batch_insert_seed_assets
+from app.assets.helpers import normalize_tags
 from app.assets.services.file_utils import get_size_and_mtime_ns
 from app.assets.services.path_utils import (
-    compute_relative_filename,
-    get_name_and_tags_from_asset_path,
+    compute_filename_for_asset,
     resolve_destination_from_tags,
     validate_path_within_base,
 )
@@ -41,12 +35,12 @@ from app.assets.services.schemas import (
     UploadResult,
     UserMetadata,
     extract_asset_data,
-    extract_reference_data,
+    extract_info_data,
 )
 from app.database.db import create_session
 
 
-def _ingest_file_from_path(
+def ingest_file_from_path(
     abs_path: str,
     asset_hash: str,
     size_bytes: int,
@@ -61,17 +55,16 @@ def _ingest_file_from_path(
     require_existing_tags: bool = False,
 ) -> IngestResult:
     locator = os.path.abspath(abs_path)
-    user_metadata = user_metadata or {}
 
     asset_created = False
     asset_updated = False
-    ref_created = False
-    ref_updated = False
-    reference_id: str | None = None
+    state_created = False
+    state_updated = False
+    asset_info_id: str | None = None
 
     with create_session() as session:
         if preview_id:
-            if not reference_exists(session, preview_id):
+            if not session.get(Asset, preview_id):
                 preview_id = None
 
         asset, asset_created, asset_updated = upsert_asset(
@@ -81,42 +74,49 @@ def _ingest_file_from_path(
             mime_type=mime_type,
         )
 
-        ref_created, ref_updated = upsert_reference(
+        state_created, state_updated = upsert_cache_state(
             session,
             asset_id=asset.id,
             file_path=locator,
-            name=info_name or os.path.basename(locator),
             mtime_ns=mtime_ns,
-            owner_id=owner_id,
         )
 
-        # Get the reference we just created/updated
-        ref = get_reference_by_file_path(session, locator)
-        if ref:
-            reference_id = ref.id
-
-            if preview_id and ref.preview_id != preview_id:
-                ref.preview_id = preview_id
+        if info_name:
+            info, info_created = get_or_create_asset_info(
+                session,
+                asset_id=asset.id,
+                owner_id=owner_id,
+                name=info_name,
+                preview_id=preview_id,
+            )
+            if info_created:
+                asset_info_id = info.id
+            else:
+                update_asset_info_timestamps(
+                    session, asset_info=info, preview_id=preview_id
+                )
+                asset_info_id = info.id
 
             norm = normalize_tags(list(tags))
-            if norm:
+            if norm and asset_info_id:
                 if require_existing_tags:
-                    validate_tags_exist(session, norm)
-                add_tags_to_reference(
+                    _validate_tags_exist(session, norm)
+                add_tags_to_asset_info(
                     session,
-                    reference_id=reference_id,
+                    asset_info_id=asset_info_id,
                     tags=norm,
                     origin=tag_origin,
                     create_if_missing=not require_existing_tags,
                 )
 
-            _update_metadata_with_filename(
-                session,
-                reference_id=reference_id,
-                file_path=ref.file_path,
-                current_metadata=ref.user_metadata,
-                user_metadata=user_metadata,
-            )
+            if asset_info_id:
+                _update_metadata_with_filename(
+                    session,
+                    asset_info_id=asset_info_id,
+                    asset_id=asset.id,
+                    info=info,
+                    user_metadata=user_metadata,
+                )
 
         try:
             remove_missing_tag_for_asset_id(session, asset_id=asset.id)
@@ -128,147 +128,37 @@ def _ingest_file_from_path(
     return IngestResult(
         asset_created=asset_created,
         asset_updated=asset_updated,
-        ref_created=ref_created,
-        ref_updated=ref_updated,
-        reference_id=reference_id,
+        state_created=state_created,
+        state_updated=state_updated,
+        asset_info_id=asset_info_id,
     )
 
 
-def register_output_files(
-    file_paths: Sequence[str],
-    user_metadata: UserMetadata = None,
-    job_id: str | None = None,
-) -> int:
-    """Register a batch of output file paths as assets.
-
-    Returns the number of files successfully registered.
-    """
-    registered = 0
-    for abs_path in file_paths:
-        if not os.path.isfile(abs_path):
-            continue
-        try:
-            if ingest_existing_file(
-                abs_path, user_metadata=user_metadata, job_id=job_id
-            ):
-                registered += 1
-        except Exception:
-            logging.exception("Failed to register output: %s", abs_path)
-    return registered
-
-
-def ingest_existing_file(
-    abs_path: str,
-    user_metadata: UserMetadata = None,
-    extra_tags: Sequence[str] = (),
-    owner_id: str = "",
-    job_id: str | None = None,
-) -> bool:
-    """Register an existing on-disk file as an asset stub.
-
-    If a reference already exists for this path, updates mtime_ns, job_id,
-    size_bytes, and resets enrichment so the enricher will re-hash it.
-
-    For brand-new paths, inserts a stub record (hash=NULL) for immediate
-    UX visibility.
-
-    Returns True if a row was inserted or updated, False otherwise.
-    """
-    locator = os.path.abspath(abs_path)
-    size_bytes, mtime_ns = get_size_and_mtime_ns(abs_path)
-    mime_type = mimetypes.guess_type(abs_path, strict=False)[0]
-    name, path_tags = get_name_and_tags_from_asset_path(abs_path)
-    tags = list(dict.fromkeys(path_tags + list(extra_tags)))
-
-    with create_session() as session:
-        existing_ref = get_reference_by_file_path(session, locator)
-        if existing_ref is not None:
-            now = get_utc_now()
-            existing_ref.mtime_ns = mtime_ns
-            existing_ref.job_id = job_id
-            existing_ref.is_missing = False
-            existing_ref.deleted_at = None
-            existing_ref.updated_at = now
-            existing_ref.enrichment_level = 0
-
-            asset = existing_ref.asset
-            if asset:
-                # If other refs share this asset, detach to a new stub
-                # instead of mutating the shared row.
-                siblings = count_active_siblings(session, asset.id, existing_ref.id)
-                if siblings > 0:
-                    new_asset = create_stub_asset(
-                        session,
-                        size_bytes=size_bytes,
-                        mime_type=mime_type or asset.mime_type,
-                    )
-                    existing_ref.asset_id = new_asset.id
-                else:
-                    asset.hash = None
-                    asset.size_bytes = size_bytes
-                    if mime_type:
-                        asset.mime_type = mime_type
-            session.commit()
-            return True
-
-        spec = {
-            "abs_path": abs_path,
-            "size_bytes": size_bytes,
-            "mtime_ns": mtime_ns,
-            "info_name": name,
-            "tags": tags,
-            "fname": os.path.basename(abs_path),
-            "metadata": None,
-            "hash": None,
-            "mime_type": mime_type,
-            "job_id": job_id,
-        }
-        if tags:
-            ensure_tags_exist(session, tags)
-        result = batch_insert_seed_assets(session, [spec], owner_id=owner_id)
-        session.commit()
-        return result.won_paths > 0
-
-
-def _register_existing_asset(
+def register_existing_asset(
     asset_hash: str,
     name: str,
     user_metadata: UserMetadata = None,
     tags: list[str] | None = None,
     tag_origin: str = "manual",
     owner_id: str = "",
-    mime_type: str | None = None,
-    preview_id: str | None = None,
 ) -> RegisterAssetResult:
-    user_metadata = user_metadata or {}
-
     with create_session() as session:
         asset = get_asset_by_hash(session, asset_hash=asset_hash)
         if not asset:
             raise ValueError(f"No asset with hash {asset_hash}")
 
-        if mime_type and not asset.mime_type:
-            update_asset_hash_and_mime(session, asset_id=asset.id, mime_type=mime_type)
-
-        if preview_id:
-            if not reference_exists(session, preview_id):
-                preview_id = None
-
-        ref, ref_created = get_or_create_reference(
+        info, info_created = get_or_create_asset_info(
             session,
             asset_id=asset.id,
             owner_id=owner_id,
             name=name,
-            preview_id=preview_id,
+            preview_id=None,
         )
 
-        if not ref_created:
-            if preview_id and ref.preview_id != preview_id:
-                ref.preview_id = preview_id
-
-            tag_names = get_reference_tags(session, reference_id=ref.id)
+        if not info_created:
+            tag_names = get_asset_tags(session, asset_info_id=info.id)
             result = RegisterAssetResult(
-                ref=extract_reference_data(ref),
+                info=extract_info_data(info),
                 asset=extract_asset_data(asset),
                 tags=tag_names,
                 created=False,
@@ -276,30 +166,30 @@ def _register_existing_asset(
             session.commit()
             return result
 
-        new_meta = dict(user_metadata)
-        computed_filename = compute_relative_filename(ref.file_path) if ref.file_path else None
+        new_meta = dict(user_metadata or {})
+        computed_filename = compute_filename_for_asset(session, asset.id)
         if computed_filename:
             new_meta["filename"] = computed_filename
 
         if new_meta:
-            set_reference_metadata(
+            set_asset_info_metadata(
                 session,
-                reference_id=ref.id,
+                asset_info_id=info.id,
                 user_metadata=new_meta,
             )
 
         if tags is not None:
-            set_reference_tags(
+            set_asset_info_tags(
                 session,
-                reference_id=ref.id,
+                asset_info_id=info.id,
                 tags=tags,
                 origin=tag_origin,
             )
 
-        tag_names = get_reference_tags(session, reference_id=ref.id)
-        session.refresh(ref)
+        tag_names = get_asset_tags(session, asset_info_id=info.id)
+        session.refresh(info)
         result = RegisterAssetResult(
-            ref=extract_reference_data(ref),
+            info=extract_info_data(info),
             asset=extract_asset_data(asset),
             tags=tag_names,
             created=True,
@@ -309,27 +199,37 @@ def _register_existing_asset(
         return result
 
 
+def _validate_tags_exist(session: Session, tags: list[str]) -> None:
+    existing_tag_names = set(
+        name
+        for (name,) in session.execute(select(Tag.name).where(Tag.name.in_(tags))).all()
+    )
+    missing = [t for t in tags if t not in existing_tag_names]
+    if missing:
+        raise ValueError(f"Unknown tags: {missing}")
+
 
 def _update_metadata_with_filename(
     session: Session,
-    reference_id: str,
-    file_path: str | None,
-    current_metadata: dict | None,
-    user_metadata: dict[str, Any],
+    asset_info_id: str,
+    asset_id: str,
+    info: AssetInfo,
+    user_metadata: UserMetadata,
 ) -> None:
-    computed_filename = compute_relative_filename(file_path) if file_path else None
+    computed_filename = compute_filename_for_asset(session, asset_id)
 
-    current_meta = current_metadata or {}
+    current_meta = info.user_metadata or {}
     new_meta = dict(current_meta)
-    for k, v in user_metadata.items():
-        new_meta[k] = v
+    if user_metadata:
+        for k, v in user_metadata.items():
+            new_meta[k] = v
     if computed_filename:
         new_meta["filename"] = computed_filename
 
     if new_meta != current_meta:
-        set_reference_metadata(
+        set_asset_info_metadata(
             session,
-            reference_id=reference_id,
+            asset_info_id=asset_info_id,
             user_metadata=new_meta,
         )
 
@@ -357,11 +257,9 @@ def upload_from_temp_path(
     client_filename: str | None = None,
     owner_id: str = "",
     expected_hash: str | None = None,
-    mime_type: str | None = None,
-    preview_id: str | None = None,
 ) -> UploadResult:
     try:
-        digest, _ = hashing.compute_blake3_hash(temp_path)
+        digest = hashing.compute_blake3_hash(temp_path)
     except ImportError as e:
         raise DependencyMissingError(str(e))
     except Exception as e:
@@ -380,25 +278,21 @@ def upload_from_temp_path(
                 os.remove(temp_path)
 
         display_name = _sanitize_filename(name or client_filename, fallback=digest)
-        result = _register_existing_asset(
+        result = register_existing_asset(
             asset_hash=asset_hash,
             name=display_name,
             user_metadata=user_metadata or {},
             tags=tags or [],
             tag_origin="manual",
             owner_id=owner_id,
-            mime_type=mime_type,
-            preview_id=preview_id,
         )
         return UploadResult(
-            ref=result.ref,
+            info=result.info,
             asset=result.asset,
             tags=result.tags,
             created_new=False,
         )
 
-    if not tags:
-        raise ValueError("tags are required for new asset uploads")
     base_dir, subdirs = resolve_destination_from_tags(tags)
     dest_dir = os.path.join(base_dir, *subdirs) if subdirs else base_dir
     os.makedirs(dest_dir, exist_ok=True)
@@ -410,7 +304,7 @@ def upload_from_temp_path(
     dest_abs = os.path.abspath(os.path.join(dest_dir, hashed_basename))
     validate_path_within_base(dest_abs, base_dir)
 
-    content_type = mime_type or (
+    content_type = (
         mimetypes.guess_type(os.path.basename(src_for_ext), strict=False)[0]
         or mimetypes.guess_type(hashed_basename, strict=False)[0]
         or "application/octet-stream"
@@ -426,7 +320,7 @@ def upload_from_temp_path(
     except OSError as e:
         raise RuntimeError(f"failed to stat destination file: {e}")
 
-    ingest_result = _ingest_file_from_path(
+    ingest_result = ingest_file_from_path(
         asset_hash=asset_hash,
         abs_path=dest_abs,
         size_bytes=size_bytes,
@@ -434,93 +328,27 @@ def upload_from_temp_path(
         mime_type=content_type,
         info_name=_sanitize_filename(name or client_filename, fallback=digest),
         owner_id=owner_id,
-        preview_id=preview_id,
+        preview_id=None,
         user_metadata=user_metadata or {},
         tags=tags,
         tag_origin="manual",
         require_existing_tags=False,
     )
-    reference_id = ingest_result.reference_id
-    if not reference_id:
-        raise RuntimeError("failed to create asset reference")
+    info_id = ingest_result.asset_info_id
+    if not info_id:
+        raise RuntimeError("failed to create asset metadata")
 
     with create_session() as session:
-        pair = fetch_reference_and_asset(
-            session, reference_id=reference_id, owner_id=owner_id
+        pair = fetch_asset_info_and_asset(
+            session, asset_info_id=info_id, owner_id=owner_id
         )
         if not pair:
             raise RuntimeError("inconsistent DB state after ingest")
-        ref, asset = pair
-        tag_names = get_reference_tags(session, reference_id=ref.id)
+        info, asset = pair
+        tag_names = get_asset_tags(session, asset_info_id=info.id)
 
     return UploadResult(
-        ref=extract_reference_data(ref),
-        asset=extract_asset_data(asset),
-        tags=tag_names,
-        created_new=ingest_result.asset_created,
-    )
-
-
-def register_file_in_place(
-    abs_path: str,
-    name: str,
-    tags: list[str],
-    owner_id: str = "",
-    mime_type: str | None = None,
-) -> UploadResult:
-    """Register an already-saved file in the asset database without moving it.
-
-    Tags are derived from the filesystem path (root category + subfolder names),
-    merged with any caller-provided tags, matching the behavior of the scanner.
-    If the path is not under a known root, only the caller-provided tags are used.
-    """
-    try:
-        _, path_tags = get_name_and_tags_from_asset_path(abs_path)
-    except ValueError:
-        path_tags = []
-    merged_tags = normalize_tags([*path_tags, *tags])
-
-    try:
-        digest, _ = hashing.compute_blake3_hash(abs_path)
-    except ImportError as e:
-        raise DependencyMissingError(str(e))
-    except Exception as e:
-        raise RuntimeError(f"failed to hash file: {e}")
-    asset_hash = "blake3:" + digest
-
-    size_bytes, mtime_ns = get_size_and_mtime_ns(abs_path)
-    content_type = mime_type or (
-        mimetypes.guess_type(abs_path, strict=False)[0]
-        or "application/octet-stream"
-    )
-
-    ingest_result = _ingest_file_from_path(
-        abs_path=abs_path,
-        asset_hash=asset_hash,
-        size_bytes=size_bytes,
-        mtime_ns=mtime_ns,
-        mime_type=content_type,
-        info_name=_sanitize_filename(name, fallback=digest),
-        owner_id=owner_id,
-        tags=merged_tags,
-        tag_origin="upload",
-        require_existing_tags=False,
-    )
-    reference_id = ingest_result.reference_id
-    if not reference_id:
-        raise RuntimeError("failed to create asset reference")
-
-    with create_session() as session:
-        pair = fetch_reference_and_asset(
-            session, reference_id=reference_id, owner_id=owner_id
-        )
-        if not pair:
-            raise RuntimeError("inconsistent DB state after ingest")
-        ref, asset = pair
-        tag_names = get_reference_tags(session, reference_id=ref.id)
-
-    return UploadResult(
-        ref=extract_reference_data(ref),
+        info=extract_info_data(info),
         asset=extract_asset_data(asset),
         tags=tag_names,
         created_new=ingest_result.asset_created,
@@ -533,30 +361,27 @@ def create_from_hash(
     tags: list[str] | None = None,
     user_metadata: dict | None = None,
     owner_id: str = "",
-    mime_type: str | None = None,
-    preview_id: str | None = None,
 ) -> UploadResult | None:
     canonical = hash_str.strip().lower()
 
-    try:
-        result = _register_existing_asset(
-            asset_hash=canonical,
-            name=_sanitize_filename(
-                name, fallback=canonical.split(":", 1)[1] if ":" in canonical else canonical
-            ),
-            user_metadata=user_metadata or {},
-            tags=tags or [],
-            tag_origin="manual",
-            owner_id=owner_id,
-            mime_type=mime_type,
-            preview_id=preview_id,
-        )
-    except ValueError:
-        logging.warning("create_from_hash: no asset found for hash %s", canonical)
-        return None
+    with create_session() as session:
+        asset = get_asset_by_hash(session, asset_hash=canonical)
+        if not asset:
+            return None
+
+    result = register_existing_asset(
+        asset_hash=canonical,
+        name=_sanitize_filename(
+            name, fallback=canonical.split(":", 1)[1] if ":" in canonical else canonical
+        ),
+        user_metadata=user_metadata or {},
+        tags=tags or [],
+        tag_origin="manual",
+        owner_id=owner_id,
+    )
 
     return UploadResult(
-        ref=result.ref,
+        info=result.info,
         asset=result.asset,
         tags=result.tags,
         created_new=False,

app/assets/services/metadata_extract.py

@@ -1,327 +0,0 @@
-"""Metadata extraction for asset scanning.
-
-Tier 1: Filesystem metadata (zero parsing)
-Tier 2: Safetensors header metadata (fast JSON read only)
-"""
-
-from __future__ import annotations
-
-import json
-import logging
-import mimetypes
-import os
-import struct
-from dataclasses import dataclass
-from typing import Any
-
-from utils.mime_types import init_mime_types
-
-init_mime_types()
-
-# Supported safetensors extensions
-SAFETENSORS_EXTENSIONS = frozenset({".safetensors", ".sft"})
-
-# Maximum safetensors header size to read (8MB)
-MAX_SAFETENSORS_HEADER_SIZE = 8 * 1024 * 1024
-
-
-@dataclass
-class ExtractedMetadata:
-    """Metadata extracted from a file during scanning."""
-
-    # Tier 1: Filesystem (always available)
-    filename: str = ""
-    file_path: str = ""  # Full absolute path to the file
-    content_length: int = 0
-    content_type: str | None = None
-    format: str = ""  # file extension without dot
-
-    # Tier 2: Safetensors header (if available)
-    base_model: str | None = None
-    trained_words: list[str] | None = None
-    air: str | None = None  # CivitAI AIR identifier
-    has_preview_images: bool = False
-
-    # Source provenance (populated if embedded in safetensors)
-    source_url: str | None = None
-    source_arn: str | None = None
-    repo_url: str | None = None
-    preview_url: str | None = None
-    source_hash: str | None = None
-
-    # HuggingFace specific
-    repo_id: str | None = None
-    revision: str | None = None
-    filepath: str | None = None
-    resolve_url: str | None = None
-
-    def to_user_metadata(self) -> dict[str, Any]:
-        """Convert to user_metadata dict for AssetReference.user_metadata JSON field."""
-        data: dict[str, Any] = {
-            "filename": self.filename,
-            "content_length": self.content_length,
-            "format": self.format,
-        }
-        if self.file_path:
-            data["file_path"] = self.file_path
-        if self.content_type:
-            data["content_type"] = self.content_type
-
-        # Tier 2 fields
-        if self.base_model:
-            data["base_model"] = self.base_model
-        if self.trained_words:
-            data["trained_words"] = self.trained_words
-        if self.air:
-            data["air"] = self.air
-        if self.has_preview_images:
-            data["has_preview_images"] = True
-
-        # Source provenance
-        if self.source_url:
-            data["source_url"] = self.source_url
-        if self.source_arn:
-            data["source_arn"] = self.source_arn
-        if self.repo_url:
-            data["repo_url"] = self.repo_url
-        if self.preview_url:
-            data["preview_url"] = self.preview_url
-        if self.source_hash:
-            data["source_hash"] = self.source_hash
-
-        # HuggingFace
-        if self.repo_id:
-            data["repo_id"] = self.repo_id
-        if self.revision:
-            data["revision"] = self.revision
-        if self.filepath:
-            data["filepath"] = self.filepath
-        if self.resolve_url:
-            data["resolve_url"] = self.resolve_url
-
-        return data
-
-    def to_meta_rows(self, reference_id: str) -> list[dict]:
-        """Convert to asset_reference_meta rows for typed/indexed querying."""
-        rows: list[dict] = []
-
-        def add_str(key: str, val: str | None, ordinal: int = 0) -> None:
-            if val:
-                rows.append({
-                    "asset_reference_id": reference_id,
-                    "key": key,
-                    "ordinal": ordinal,
-                    "val_str": val[:2048] if len(val) > 2048 else val,
-                    "val_num": None,
-                    "val_bool": None,
-                    "val_json": None,
-                })
-
-        def add_num(key: str, val: int | float | None) -> None:
-            if val is not None:
-                rows.append({
-                    "asset_reference_id": reference_id,
-                    "key": key,
-                    "ordinal": 0,
-                    "val_str": None,
-                    "val_num": val,
-                    "val_bool": None,
-                    "val_json": None,
-                })
-
-        def add_bool(key: str, val: bool | None) -> None:
-            if val is not None:
-                rows.append({
-                    "asset_reference_id": reference_id,
-                    "key": key,
-                    "ordinal": 0,
-                    "val_str": None,
-                    "val_num": None,
-                    "val_bool": val,
-                    "val_json": None,
-                })
-
-        # Tier 1
-        add_str("filename", self.filename)
-        add_num("content_length", self.content_length)
-        add_str("content_type", self.content_type)
-        add_str("format", self.format)
-
-        # Tier 2
-        add_str("base_model", self.base_model)
-        add_str("air", self.air)
-        has_previews = self.has_preview_images if self.has_preview_images else None
-        add_bool("has_preview_images", has_previews)
-
-        # trained_words as multiple rows with ordinals
-        if self.trained_words:
-            for i, word in enumerate(self.trained_words[:100]):  # limit to 100 words
-                add_str("trained_words", word, ordinal=i)
-
-        # Source provenance
-        add_str("source_url", self.source_url)
-        add_str("source_arn", self.source_arn)
-        add_str("repo_url", self.repo_url)
-        add_str("preview_url", self.preview_url)
-        add_str("source_hash", self.source_hash)
-
-        # HuggingFace
-        add_str("repo_id", self.repo_id)
-        add_str("revision", self.revision)
-        add_str("filepath", self.filepath)
-        add_str("resolve_url", self.resolve_url)
-
-        return rows
-
-
-def _read_safetensors_header(
-    path: str, max_size: int = MAX_SAFETENSORS_HEADER_SIZE
-) -> dict[str, Any] | None:
-    """Read only the JSON header from a safetensors file.
-
-    This is very fast - reads 8 bytes for header length, then the JSON header.
-    No tensor data is loaded.
-
-    Args:
-        path: Absolute path to safetensors file
-        max_size: Maximum header size to read (default 8MB)
-
-    Returns:
-        Parsed header dict or None if failed
-    """
-    try:
-        with open(path, "rb") as f:
-            header_bytes = f.read(8)
-            if len(header_bytes) < 8:
-                return None
-            length_of_header = struct.unpack("<Q", header_bytes)[0]
-            if length_of_header > max_size:
-                return None
-            header_data = f.read(length_of_header)
-            if len(header_data) < length_of_header:
-                return None
-            return json.loads(header_data.decode("utf-8"))
-    except (OSError, json.JSONDecodeError, UnicodeDecodeError, struct.error):
-        return None
-
-
-def _extract_safetensors_metadata(
-    header: dict[str, Any], meta: ExtractedMetadata
-) -> None:
-    """Extract metadata from safetensors header __metadata__ section.
-
-    Modifies meta in-place.
-    """
-    st_meta = header.get("__metadata__", {})
-    if not isinstance(st_meta, dict):
-        return
-
-    # Common model metadata
-    meta.base_model = (
-        st_meta.get("ss_base_model_version")
-        or st_meta.get("modelspec.base_model")
-        or st_meta.get("base_model")
-    )
-
-    # Trained words / trigger words
-    trained_words = st_meta.get("ss_tag_frequency")
-    if trained_words and isinstance(trained_words, str):
-        try:
-            tag_freq = json.loads(trained_words)
-            # Extract unique tags from all datasets
-            all_tags: set[str] = set()
-            for dataset_tags in tag_freq.values():
-                if isinstance(dataset_tags, dict):
-                    all_tags.update(dataset_tags.keys())
-            if all_tags:
-                meta.trained_words = sorted(all_tags)[:100]
-        except json.JSONDecodeError:
-            pass
-
-    # Direct trained_words field (some formats)
-    if not meta.trained_words:
-        tw = st_meta.get("trained_words")
-        if isinstance(tw, str):
-            try:
-                parsed = json.loads(tw)
-                if isinstance(parsed, list):
-                    meta.trained_words = [str(x) for x in parsed]
-                else:
-                    meta.trained_words = [w.strip() for w in tw.split(",") if w.strip()]
-            except json.JSONDecodeError:
-                meta.trained_words = [w.strip() for w in tw.split(",") if w.strip()]
-        elif isinstance(tw, list):
-            meta.trained_words = [str(x) for x in tw]
-
-    # CivitAI AIR
-    meta.air = st_meta.get("air") or st_meta.get("modelspec.air")
-
-    # Preview images (ssmd_cover_images)
-    cover_images = st_meta.get("ssmd_cover_images")
-    if cover_images:
-        meta.has_preview_images = True
-
-    # Source provenance fields
-    meta.source_url = st_meta.get("source_url")
-    meta.source_arn = st_meta.get("source_arn")
-    meta.repo_url = st_meta.get("repo_url")
-    meta.preview_url = st_meta.get("preview_url")
-    meta.source_hash = st_meta.get("source_hash") or st_meta.get("sshs_model_hash")
-
-    # HuggingFace fields
-    meta.repo_id = st_meta.get("repo_id") or st_meta.get("hf_repo_id")
-    meta.revision = st_meta.get("revision") or st_meta.get("hf_revision")
-    meta.filepath = st_meta.get("filepath") or st_meta.get("hf_filepath")
-    meta.resolve_url = st_meta.get("resolve_url") or st_meta.get("hf_url")
-
-
-def extract_file_metadata(
-    abs_path: str,
-    stat_result: os.stat_result | None = None,
-    relative_filename: str | None = None,
-) -> ExtractedMetadata:
-    """Extract metadata from a file using tier 1 and tier 2 methods.
-
-    Tier 1: Filesystem metadata from path and stat
-    Tier 2: Safetensors header parsing if applicable
-
-    Args:
-        abs_path: Absolute path to the file
-        stat_result: Optional pre-fetched stat result (saves a syscall)
-        relative_filename: Optional relative filename to use instead of basename
-            (e.g., "flux/123/model.safetensors" for model paths)
-
-    Returns:
-        ExtractedMetadata with all available fields populated
-    """
-    meta = ExtractedMetadata()
-
-    # Tier 1: Filesystem metadata
-    meta.filename = relative_filename or os.path.basename(abs_path)
-    meta.file_path = abs_path
-    _, ext = os.path.splitext(abs_path)
-    meta.format = ext.lstrip(".").lower() if ext else ""
-
-    mime_type, _ = mimetypes.guess_type(abs_path)
-    meta.content_type = mime_type
-
-    # Size from stat
-    if stat_result is None:
-        try:
-            stat_result = os.stat(abs_path, follow_symlinks=True)
-        except OSError:
-            pass
-
-    if stat_result:
-        meta.content_length = stat_result.st_size
-
-    # Tier 2: Safetensors header (if applicable and enabled)
-    if ext.lower() in SAFETENSORS_EXTENSIONS:
-        header = _read_safetensors_header(abs_path)
-        if header:
-            try:
-                _extract_safetensors_metadata(header, meta)
-            except Exception as e:
-                logging.debug("Safetensors meta extract failed %s: %s", abs_path, e)
-
-    return meta

app/assets/services/path_utils.py

@@ -6,31 +6,27 @@ import folder_paths
 from app.assets.helpers import normalize_tags
 
 
-_NON_MODEL_FOLDER_NAMES = frozenset({"custom_nodes"})
-
-
 def get_comfy_models_folders() -> list[tuple[str, list[str]]]:
-    """Build list of (folder_name, base_paths[]) for all model locations.
+    """Build a list of (folder_name, base_paths[]) categories that are configured for model locations.
 
-    Includes every category registered in folder_names_and_paths,
-    regardless of whether its paths are under the main models_dir,
-    but excludes non-model entries like custom_nodes.
+    We trust `folder_paths.folder_names_and_paths` and include a category if
+    *any* of its base paths lies under the Comfy `models_dir`.
     """
     targets: list[tuple[str, list[str]]] = []
+    models_root = os.path.abspath(folder_paths.models_dir)
     for name, values in folder_paths.folder_names_and_paths.items():
-        if name in _NON_MODEL_FOLDER_NAMES:
-            continue
-        paths, _exts = values[0], values[1]
-        if paths:
+        paths, _exts = (
+            values[0],
+            values[1],
+        )  # NOTE: this prevents nodepacks that hackily edit folder_... from breaking ComfyUI
+        if any(os.path.abspath(p).startswith(models_root + os.sep) for p in paths):
             targets.append((name, paths))
     return targets
 
 
 def resolve_destination_from_tags(tags: list[str]) -> tuple[str, list[str]]:
     """Validates and maps tags -> (base_dir, subdirs_for_fs)"""
-    if not tags:
-        raise ValueError("tags must not be empty")
-    root = tags[0].lower()
+    root = tags[0]
     if root == "models":
         if len(tags) < 2:
             raise ValueError("at least two tags required for model asset")
@@ -42,27 +38,28 @@ def resolve_destination_from_tags(tags: list[str]) -> tuple[str, list[str]]:
             raise ValueError(f"no base path configured for category '{tags[1]}'")
         base_dir = os.path.abspath(bases[0])
         raw_subdirs = tags[2:]
-    elif root == "input":
-        base_dir = os.path.abspath(folder_paths.get_input_directory())
-        raw_subdirs = tags[1:]
-    elif root == "output":
-        base_dir = os.path.abspath(folder_paths.get_output_directory())
-        raw_subdirs = tags[1:]
     else:
-        raise ValueError(f"unknown root tag '{tags[0]}'; expected 'models', 'input', or 'output'")
-    _sep_chars = frozenset(("/", "\\", os.sep))
+        base_dir = os.path.abspath(
+            folder_paths.get_input_directory()
+            if root == "input"
+            else folder_paths.get_output_directory()
+        )
+        raw_subdirs = tags[1:]
     for i in raw_subdirs:
-        if i in (".", "..") or _sep_chars & set(i):
+        if i in (".", ".."):
             raise ValueError("invalid path component in tags")
 
     return base_dir, raw_subdirs if raw_subdirs else []
 
 
 def validate_path_within_base(candidate: str, base: str) -> None:
-    cand_abs = Path(os.path.abspath(candidate))
-    base_abs = Path(os.path.abspath(base))
-    if not cand_abs.is_relative_to(base_abs):
-        raise ValueError("destination escapes base directory")
+    cand_abs = os.path.abspath(candidate)
+    base_abs = os.path.abspath(base)
+    try:
+        if os.path.commonpath([cand_abs, base_abs]) != base_abs:
+            raise ValueError("destination escapes base directory")
+    except Exception:
+        raise ValueError("invalid destination path")
 
 
 def compute_relative_filename(file_path: str) -> str | None:
@@ -73,6 +70,7 @@ def compute_relative_filename(file_path: str) -> str | None:
       /.../models/text_encoders/clip_g.safetensors -> "clip_g.safetensors"
 
     For non-model paths, returns None.
+    NOTE: this is a temporary helper, used only for initializing metadata["filename"] field.
     """
     try:
         root_category, rel_path = get_asset_category_and_relative_path(file_path)
@@ -93,29 +91,29 @@ def compute_relative_filename(file_path: str) -> str | None:
 
 def get_asset_category_and_relative_path(
     file_path: str,
-) -> tuple[Literal["input", "output", "temp", "models"], str]:
-    """Determine which root category a file path belongs to.
-
-    Categories:
-      - 'input': under folder_paths.get_input_directory()
-      - 'output': under folder_paths.get_output_directory()
-      - 'temp': under folder_paths.get_temp_directory()
-      - 'models': under any base path from get_comfy_models_folders()
+) -> tuple[Literal["input", "output", "models"], str]:
+    """Given an absolute or relative file path, determine which root category the path belongs to:
+      - 'input' if the file resides under `folder_paths.get_input_directory()`
+      - 'output' if the file resides under `folder_paths.get_output_directory()`
+      - 'models' if the file resides under any base path of categories returned by `get_comfy_models_folders()`
 
     Returns:
         (root_category, relative_path_inside_that_root)
+        For 'models', the relative path is prefixed with the category name:
+            e.g. ('models', 'vae/test/sub/ae.safetensors')
 
     Raises:
-        ValueError: path does not belong to any known root.
+        ValueError: if the path does not belong to input, output, or configured model bases.
     """
     fp_abs = os.path.abspath(file_path)
 
     def _check_is_within(child: str, parent: str) -> bool:
-        return Path(child).is_relative_to(parent)
+        try:
+            return os.path.commonpath([child, parent]) == parent
+        except Exception:
+            return False
 
     def _compute_relative(child: str, parent: str) -> str:
-        # Normalize relative path, stripping any leading ".." components
-        # by anchoring to root (os.sep) then computing relpath back from it.
         return os.path.relpath(
             os.path.join(os.sep, os.path.relpath(child, parent)), os.sep
         )
@@ -130,12 +128,7 @@ def get_asset_category_and_relative_path(
     if _check_is_within(fp_abs, output_base):
         return "output", _compute_relative(fp_abs, output_base)
 
-    # 3) temp
-    temp_base = os.path.abspath(folder_paths.get_temp_directory())
-    if _check_is_within(fp_abs, temp_base):
-        return "temp", _compute_relative(fp_abs, temp_base)
-
-    # 4) models (check deepest matching base to avoid ambiguity)
+    # 3) models (check deepest matching base to avoid ambiguity)
     best: tuple[int, str, str] | None = None  # (base_len, bucket, rel_inside_bucket)
     for bucket, bases in get_comfy_models_folders():
         for b in bases:
@@ -152,18 +145,36 @@ def get_asset_category_and_relative_path(
         return "models", os.path.relpath(os.path.join(os.sep, combined), os.sep)
 
     raise ValueError(
-        f"Path is not within input, output, temp, or configured model bases: {file_path}"
+        f"Path is not within input, output, or configured model bases: {file_path}"
     )
 
 
-def get_name_and_tags_from_asset_path(file_path: str) -> tuple[str, list[str]]:
-    """Return (name, tags) derived from a filesystem path.
+def compute_filename_for_asset(session, asset_id: str) -> str | None:
+    """Compute the relative filename for an asset from its best live cache state path."""
+    from app.assets.database.queries import list_cache_states_by_asset_id
+    from app.assets.helpers import select_best_live_path
 
-    - name: base filename with extension
-    - tags: [root_category] + parent folder names in order
+    primary_path = select_best_live_path(
+        list_cache_states_by_asset_id(session, asset_id=asset_id)
+    )
+    return compute_relative_filename(primary_path) if primary_path else None
+
+
+def get_name_and_tags_from_asset_path(file_path: str) -> tuple[str, list[str]]:
+    """Return a tuple (name, tags) derived from a filesystem path.
+
+    Semantics:
+      - Root category is determined by `get_asset_category_and_relative_path`.
+      - The returned `name` is the base filename with extension from the relative path.
+      - The returned `tags` are:
+            [root_category] + parent folders of the relative path (in order)
+        For 'models', this means:
+            file '/.../ModelsDir/vae/test_tag/ae.safetensors'
+            -> root_category='models', some_path='vae/test_tag/ae.safetensors'
+            -> name='ae.safetensors', tags=['models', 'vae', 'test_tag']
 
     Raises:
-        ValueError: path does not belong to any known root.
+        ValueError: if the path does not belong to input, output, or configured model bases.
     """
     root_category, some_path = get_asset_category_and_relative_path(file_path)
     p = Path(some_path)

app/assets/services/schemas.py

@@ -2,44 +2,39 @@ from dataclasses import dataclass
 from datetime import datetime
 from typing import Any, NamedTuple
 
-from app.assets.database.models import Asset, AssetReference
+from app.assets.database.models import Asset, AssetInfo
 
 UserMetadata = dict[str, Any] | None
 
 
 @dataclass(frozen=True)
 class AssetData:
-    hash: str | None
+    hash: str
     size_bytes: int | None
     mime_type: str | None
 
 
 @dataclass(frozen=True)
-class ReferenceData:
-    """Data transfer object for AssetReference."""
-
+class AssetInfoData:
     id: str
     name: str
-    file_path: str | None
     user_metadata: UserMetadata
     preview_id: str | None
     created_at: datetime
     updated_at: datetime
-    system_metadata: dict[str, Any] | None = None
-    job_id: str | None = None
-    last_access_time: datetime | None = None
+    last_access_time: datetime | None
 
 
 @dataclass(frozen=True)
 class AssetDetailResult:
-    ref: ReferenceData
+    info: AssetInfoData
     asset: AssetData | None
     tags: list[str]
 
 
 @dataclass(frozen=True)
 class RegisterAssetResult:
-    ref: ReferenceData
+    info: AssetInfoData
     asset: AssetData
     tags: list[str]
     created: bool
@@ -49,9 +44,30 @@ class RegisterAssetResult:
 class IngestResult:
     asset_created: bool
     asset_updated: bool
-    ref_created: bool
-    ref_updated: bool
-    reference_id: str | None
+    state_created: bool
+    state_updated: bool
+    asset_info_id: str | None
+
+
+@dataclass(frozen=True)
+class AddTagsResult:
+    added: list[str]
+    already_present: list[str]
+    total_tags: list[str]
+
+
+@dataclass(frozen=True)
+class RemoveTagsResult:
+    removed: list[str]
+    not_present: list[str]
+    total_tags: list[str]
+
+
+@dataclass(frozen=True)
+class SetTagsResult:
+    added: list[str]
+    removed: list[str]
+    total: list[str]
 
 
 class TagUsage(NamedTuple):
@@ -62,7 +78,7 @@ class TagUsage(NamedTuple):
 
 @dataclass(frozen=True)
 class AssetSummaryData:
-    ref: ReferenceData
+    info: AssetInfoData
     asset: AssetData | None
     tags: list[str]
 
@@ -82,24 +98,21 @@ class DownloadResolutionResult:
 
 @dataclass(frozen=True)
 class UploadResult:
-    ref: ReferenceData
+    info: AssetInfoData
     asset: AssetData
     tags: list[str]
     created_new: bool
 
 
-def extract_reference_data(ref: AssetReference) -> ReferenceData:
-    return ReferenceData(
-        id=ref.id,
-        name=ref.name,
-        file_path=ref.file_path,
-        user_metadata=ref.user_metadata,
-        preview_id=ref.preview_id,
-        system_metadata=ref.system_metadata,
-        job_id=ref.job_id,
-        created_at=ref.created_at,
-        updated_at=ref.updated_at,
-        last_access_time=ref.last_access_time,
+def extract_info_data(info: AssetInfo) -> AssetInfoData:
+    return AssetInfoData(
+        id=info.id,
+        name=info.name,
+        user_metadata=info.user_metadata,
+        preview_id=info.preview_id,
+        created_at=info.created_at,
+        updated_at=info.updated_at,
+        last_access_time=info.last_access_time,
     )
 
 

app/assets/services/tagging.py

@@ -1,56 +1,67 @@
-from typing import Sequence
-
 from app.assets.database.queries import (
-    AddTagsResult,
-    RemoveTagsResult,
-    add_tags_to_reference,
-    get_reference_with_owner_check,
+    add_tags_to_asset_info,
+    get_asset_info_by_id,
     list_tags_with_usage,
-    remove_tags_from_reference,
+    remove_tags_from_asset_info,
 )
-from app.assets.database.queries.tags import list_tag_counts_for_filtered_assets
-from app.assets.services.schemas import TagUsage
+from app.assets.services.schemas import AddTagsResult, RemoveTagsResult, TagUsage
 from app.database.db import create_session
 
 
 def apply_tags(
-    reference_id: str,
+    asset_info_id: str,
     tags: list[str],
     origin: str = "manual",
     owner_id: str = "",
 ) -> AddTagsResult:
     with create_session() as session:
-        ref_row = get_reference_with_owner_check(session, reference_id, owner_id)
+        info_row = get_asset_info_by_id(session, asset_info_id=asset_info_id)
+        if not info_row:
+            raise ValueError(f"AssetInfo {asset_info_id} not found")
+        if info_row.owner_id and info_row.owner_id != owner_id:
+            raise PermissionError("not owner")
 
-        result = add_tags_to_reference(
+        data = add_tags_to_asset_info(
             session,
-            reference_id=reference_id,
+            asset_info_id=asset_info_id,
             tags=tags,
             origin=origin,
             create_if_missing=True,
-            reference_row=ref_row,
+            asset_info_row=info_row,
         )
         session.commit()
 
-    return result
+    return AddTagsResult(
+        added=data["added"],
+        already_present=data["already_present"],
+        total_tags=data["total_tags"],
+    )
 
 
 def remove_tags(
-    reference_id: str,
+    asset_info_id: str,
     tags: list[str],
     owner_id: str = "",
 ) -> RemoveTagsResult:
     with create_session() as session:
-        get_reference_with_owner_check(session, reference_id, owner_id)
+        info_row = get_asset_info_by_id(session, asset_info_id=asset_info_id)
+        if not info_row:
+            raise ValueError(f"AssetInfo {asset_info_id} not found")
+        if info_row.owner_id and info_row.owner_id != owner_id:
+            raise PermissionError("not owner")
 
-        result = remove_tags_from_reference(
+        data = remove_tags_from_asset_info(
             session,
-            reference_id=reference_id,
+            asset_info_id=asset_info_id,
             tags=tags,
         )
         session.commit()
 
-    return result
+    return RemoveTagsResult(
+        removed=data["removed"],
+        not_present=data["not_present"],
+        total_tags=data["total_tags"],
+    )
 
 
 def list_tags(
@@ -76,23 +87,3 @@ def list_tags(
         )
 
     return [TagUsage(name, tag_type, count) for name, tag_type, count in rows], total
-
-
-def list_tag_histogram(
-    owner_id: str = "",
-    include_tags: Sequence[str] | None = None,
-    exclude_tags: Sequence[str] | None = None,
-    name_contains: str | None = None,
-    metadata_filter: dict | None = None,
-    limit: int = 100,
-) -> dict[str, int]:
-    with create_session() as session:
-        return list_tag_counts_for_filtered_assets(
-            session,
-            owner_id=owner_id,
-            include_tags=include_tags,
-            exclude_tags=exclude_tags,
-            name_contains=name_contains,
-            metadata_filter=metadata_filter,
-            limit=limit,
-        )

app/database/db.py

@@ -3,7 +3,6 @@ import os
 import shutil
 from app.logger import log_startup_warning
 from utils.install_util import get_missing_requirements_message
-from filelock import FileLock, Timeout
 from comfy.cli_args import args
 
 _DB_AVAILABLE = False
@@ -15,12 +14,8 @@ try:
     from alembic.config import Config
     from alembic.runtime.migration import MigrationContext
     from alembic.script import ScriptDirectory
-    from sqlalchemy import create_engine, event
+    from sqlalchemy import create_engine
     from sqlalchemy.orm import sessionmaker
-    from sqlalchemy.pool import StaticPool
-
-    from app.database.models import Base
-    import app.assets.database.models  # noqa: F401 — register models with Base.metadata
 
     _DB_AVAILABLE = True
 except ImportError as e:
@@ -70,69 +65,9 @@ def get_db_path():
         raise ValueError(f"Unsupported database URL '{url}'.")
 
 
-_db_lock = None
-
-def _acquire_file_lock(db_path):
-    """Acquire an OS-level file lock to prevent multi-process access.
-
-    Uses filelock for cross-platform support (macOS, Linux, Windows).
-    The OS automatically releases the lock when the process exits, even on crashes.
-    """
-    global _db_lock
-    lock_path = db_path + ".lock"
-    _db_lock = FileLock(lock_path)
-    try:
-        _db_lock.acquire(timeout=0)
-    except Timeout:
-        raise RuntimeError(
-            f"Could not acquire lock on database '{db_path}'. "
-            "Another ComfyUI process may already be using it. "
-            "Use --database-url to specify a separate database file."
-        )
-
-
-def _is_memory_db(db_url):
-    """Check if the database URL refers to an in-memory SQLite database."""
-    return db_url in ("sqlite:///:memory:", "sqlite://")
-
-
 def init_db():
     db_url = args.database_url
     logging.debug(f"Database URL: {db_url}")
-
-    if _is_memory_db(db_url):
-        _init_memory_db(db_url)
-    else:
-        _init_file_db(db_url)
-
-
-def _init_memory_db(db_url):
-    """Initialize an in-memory SQLite database using metadata.create_all.
-
-    Alembic migrations don't work with in-memory SQLite because each
-    connection gets its own separate database — tables created by Alembic's
-    internal connection are lost immediately.
-    """
-    engine = create_engine(
-        db_url,
-        poolclass=StaticPool,
-        connect_args={"check_same_thread": False},
-    )
-
-    @event.listens_for(engine, "connect")
-    def set_sqlite_pragma(dbapi_connection, connection_record):
-        cursor = dbapi_connection.cursor()
-        cursor.execute("PRAGMA foreign_keys=ON")
-        cursor.close()
-
-    Base.metadata.create_all(engine)
-
-    global Session
-    Session = sessionmaker(bind=engine)
-
-
-def _init_file_db(db_url):
-    """Initialize a file-backed SQLite database using Alembic migrations."""
     db_path = get_db_path()
     db_exists = os.path.exists(db_path)
 
@@ -140,14 +75,6 @@ def _init_file_db(db_url):
 
     # Check if we need to upgrade
     engine = create_engine(db_url)
-
-    # Enable foreign key enforcement for SQLite
-    @event.listens_for(engine, "connect")
-    def set_sqlite_pragma(dbapi_connection, connection_record):
-        cursor = dbapi_connection.cursor()
-        cursor.execute("PRAGMA foreign_keys=ON")
-        cursor.close()
-
     conn = engine.connect()
 
     context = MigrationContext.configure(conn)
@@ -177,12 +104,6 @@ def _init_file_db(db_url):
             logging.exception("Error upgrading database: ")
             raise e
 
-    # Acquire an OS-level file lock after migrations are complete.
-    # Alembic uses its own connection, so we must wait until it's done
-    # before locking — otherwise our own lock blocks the migration.
-    conn.close()
-    _acquire_file_lock(db_path)
-
     global Session
     Session = sessionmaker(bind=engine)
 

app/database/models.py

@@ -1,18 +1,9 @@
 from typing import Any
 from datetime import datetime
-from sqlalchemy import MetaData
 from sqlalchemy.orm import DeclarativeBase
 
-NAMING_CONVENTION = {
-    "ix": "ix_%(table_name)s_%(column_0_N_name)s",
-    "uq": "uq_%(table_name)s_%(column_0_N_name)s",
-    "ck": "ck_%(table_name)s_%(constraint_name)s",
-    "fk": "fk_%(table_name)s_%(column_0_name)s_%(referred_table_name)s",
-    "pk": "pk_%(table_name)s",
-}
-
 class Base(DeclarativeBase):
-    metadata = MetaData(naming_convention=NAMING_CONVENTION)
+    pass
 
 def to_dict(obj: Any, include_none: bool = False) -> dict[str, Any]:
     fields = obj.__table__.columns.keys()

app/frontend_management.py

@@ -17,7 +17,7 @@ from importlib.metadata import version
 import requests
 from typing_extensions import NotRequired
 
-from utils.install_util import get_missing_requirements_message, get_required_packages_versions
+from utils.install_util import get_missing_requirements_message, requirements_path
 
 from comfy.cli_args import DEFAULT_VERSION_STRING
 import app.logger
@@ -45,7 +45,25 @@ def get_installed_frontend_version():
 
 
 def get_required_frontend_version():
-    return get_required_packages_versions().get("comfyui-frontend-package", None)
+    """Get the required frontend version from requirements.txt."""
+    try:
+        with open(requirements_path, "r", encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if line.startswith("comfyui-frontend-package=="):
+                    version_str = line.split("==")[-1]
+                    if not is_valid_version(version_str):
+                        logging.error(f"Invalid version format in requirements.txt: {version_str}")
+                        return None
+                    return version_str
+            logging.error("comfyui-frontend-package not found in requirements.txt")
+            return None
+    except FileNotFoundError:
+        logging.error("requirements.txt not found. Cannot determine required frontend version.")
+        return None
+    except Exception as e:
+        logging.error(f"Error reading requirements.txt: {e}")
+        return None
 
 
 def check_frontend_version():
@@ -199,7 +217,25 @@ class FrontendManager:
 
     @classmethod
     def get_required_templates_version(cls) -> str:
-        return get_required_packages_versions().get("comfyui-workflow-templates", None)
+        """Get the required workflow templates version from requirements.txt."""
+        try:
+            with open(requirements_path, "r", encoding="utf-8") as f:
+                for line in f:
+                    line = line.strip()
+                    if line.startswith("comfyui-workflow-templates=="):
+                        version_str = line.split("==")[-1]
+                        if not is_valid_version(version_str):
+                            logging.error(f"Invalid templates version format in requirements.txt: {version_str}")
+                            return None
+                        return version_str
+                logging.error("comfyui-workflow-templates not found in requirements.txt")
+                return None
+        except FileNotFoundError:
+            logging.error("requirements.txt not found. Cannot determine required templates version.")
+            return None
+        except Exception as e:
+            logging.error(f"Error reading requirements.txt: {e}")
+            return None
 
     @classmethod
     def default_frontend_path(cls) -> str:

app/node_replace_manager.py

@@ -1,107 +0,0 @@
-from __future__ import annotations
-
-from aiohttp import web
-
-from typing import TYPE_CHECKING, TypedDict
-if TYPE_CHECKING:
-    from comfy_api.latest._io_public import NodeReplace
-
-from comfy_execution.graph_utils import is_link
-import nodes
-
-class NodeStruct(TypedDict):
-    inputs: dict[str, str | int | float | bool | tuple[str, int]]
-    class_type: str
-    _meta: dict[str, str]
-
-def copy_node_struct(node_struct: NodeStruct, empty_inputs: bool = False) -> NodeStruct:
-    new_node_struct = node_struct.copy()
-    if empty_inputs:
-        new_node_struct["inputs"] = {}
-    else:
-        new_node_struct["inputs"] = node_struct["inputs"].copy()
-    new_node_struct["_meta"] = node_struct["_meta"].copy()
-    return new_node_struct
-
-
-class NodeReplaceManager:
-    """Manages node replacement registrations."""
-
-    def __init__(self):
-        self._replacements: dict[str, list[NodeReplace]] = {}
-
-    def register(self, node_replace: NodeReplace):
-        """Register a node replacement mapping."""
-        self._replacements.setdefault(node_replace.old_node_id, []).append(node_replace)
-
-    def get_replacement(self, old_node_id: str) -> list[NodeReplace] | None:
-        """Get replacements for an old node ID."""
-        return self._replacements.get(old_node_id)
-
-    def has_replacement(self, old_node_id: str) -> bool:
-        """Check if a replacement exists for an old node ID."""
-        return old_node_id in self._replacements
-
-    def apply_replacements(self, prompt: dict[str, NodeStruct]):
-        connections: dict[str, list[tuple[str, str, int]]] = {}
-        need_replacement: set[str] = set()
-        for node_number, node_struct in prompt.items():
-            if "class_type" not in node_struct or "inputs" not in node_struct:
-                continue
-            class_type = node_struct["class_type"]
-            # need replacement if not in NODE_CLASS_MAPPINGS and has replacement
-            if class_type not in nodes.NODE_CLASS_MAPPINGS.keys() and self.has_replacement(class_type):
-                need_replacement.add(node_number)
-            # keep track of connections
-            for input_id, input_value in node_struct["inputs"].items():
-                if is_link(input_value):
-                    conn_number = input_value[0]
-                    connections.setdefault(conn_number, []).append((node_number, input_id, input_value[1]))
-        for node_number in need_replacement:
-            node_struct = prompt[node_number]
-            class_type = node_struct["class_type"]
-            replacements = self.get_replacement(class_type)
-            if replacements is None:
-                continue
-            # just use the first replacement
-            replacement = replacements[0]
-            new_node_id = replacement.new_node_id
-            # if replacement is not a valid node, skip trying to replace it as will only cause confusion
-            if new_node_id not in nodes.NODE_CLASS_MAPPINGS.keys():
-                continue
-            # first, replace node id (class_type)
-            new_node_struct = copy_node_struct(node_struct, empty_inputs=True)
-            new_node_struct["class_type"] = new_node_id
-            # TODO: consider replacing display_name in _meta as well for error reporting purposes; would need to query node schema
-            # second, replace inputs
-            if replacement.input_mapping is not None:
-                for input_map in replacement.input_mapping:
-                    if "set_value" in input_map:
-                        new_node_struct["inputs"][input_map["new_id"]] = input_map["set_value"]
-                    elif "old_id" in input_map:
-                        new_node_struct["inputs"][input_map["new_id"]] = node_struct["inputs"][input_map["old_id"]]
-            # finalize input replacement
-            prompt[node_number] = new_node_struct
-            # third, replace outputs
-            if replacement.output_mapping is not None:
-                # re-mapping outputs requires changing the input values of nodes that receive connections from this one
-                if node_number in connections:
-                    for conns in connections[node_number]:
-                        conn_node_number, conn_input_id, old_output_idx = conns
-                        for output_map in replacement.output_mapping:
-                            if output_map["old_idx"] == old_output_idx:
-                                new_output_idx = output_map["new_idx"]
-                                previous_input = prompt[conn_node_number]["inputs"][conn_input_id]
-                                previous_input[1] = new_output_idx
-
-    def as_dict(self):
-        """Serialize all replacements to dict."""
-        return {
-            k: [v.as_dict() for v in v_list]
-            for k, v_list in self._replacements.items()
-        }
-
-    def add_routes(self, routes):
-        @routes.get("/node_replacements")
-        async def get_node_replacements(request):
-            return web.json_response(self.as_dict())

app/subgraph_manager.py

@@ -53,7 +53,7 @@ class SubgraphManager:
         return entry_id, entry
 
     async def load_entry_data(self, entry: SubgraphEntry):
-        with open(entry['path'], 'r', encoding='utf-8') as f:
+        with open(entry['path'], 'r') as f:
             entry['data'] = f.read()
         return entry
 

app/user_manager.py

@@ -6,7 +6,6 @@ import uuid
 import glob
 import shutil
 import logging
-import tempfile
 from aiohttp import web
 from urllib import parse
 from comfy.cli_args import args
@@ -378,15 +377,8 @@ class UserManager():
             try:
                 body = await request.read()
 
-                dir_name = os.path.dirname(path)
-                fd, tmp_path = tempfile.mkstemp(dir=dir_name)
-                try:
-                    with os.fdopen(fd, "wb") as f:
-                        f.write(body)
-                    os.replace(tmp_path, path)
-                except:
-                    os.unlink(tmp_path)
-                    raise
+                with open(path, "wb") as f:
+                    f.write(body)
             except OSError as e:
                 logging.warning(f"Error saving file '{path}': {e}")
                 return web.Response(

blueprints/.glsl/Brightness_and_Contrast_1.frag

@@ -1,44 +0,0 @@
-#version 300 es
-precision highp float;
-
-uniform sampler2D u_image0;
-uniform float u_float0; // Brightness slider -100..100
-uniform float u_float1; // Contrast slider -100..100
-
-in vec2 v_texCoord;
-out vec4 fragColor;
-
-const float MID_GRAY = 0.18;  // 18% reflectance
-
-// sRGB gamma 2.2 approximation
-vec3 srgbToLinear(vec3 c) {
-    return pow(max(c, 0.0), vec3(2.2));
-}
-
-vec3 linearToSrgb(vec3 c) {
-    return pow(max(c, 0.0), vec3(1.0/2.2));
-}
-
-float mapBrightness(float b) {
-    return clamp(b / 100.0, -1.0, 1.0);
-}
-
-float mapContrast(float c) {
-    return clamp(c / 100.0 + 1.0, 0.0, 2.0);
-}
-
-void main() {
-    vec4 orig = texture(u_image0, v_texCoord);
-
-    float brightness = mapBrightness(u_float0);
-    float contrast   = mapContrast(u_float1);
-
-    vec3 lin = srgbToLinear(orig.rgb);
-
-    lin = (lin - MID_GRAY) * contrast + brightness + MID_GRAY;
-
-    // Convert back to sRGB
-    vec3 result = linearToSrgb(clamp(lin, 0.0, 1.0));
-
-    fragColor = vec4(result, orig.a);
-}

blueprints/.glsl/Chromatic_Aberration_16.frag

@@ -1,72 +0,0 @@
-#version 300 es
-precision highp float;
-
-uniform sampler2D u_image0;
-uniform vec2 u_resolution;
-uniform int u_int0;      // Mode
-uniform float u_float0;  // Amount (0 to 100)
-
-in vec2 v_texCoord;
-out vec4 fragColor;
-
-const int MODE_LINEAR   = 0;
-const int MODE_RADIAL   = 1;
-const int MODE_BARREL   = 2;
-const int MODE_SWIRL    = 3;
-const int MODE_DIAGONAL = 4;
-
-const float AMOUNT_SCALE = 0.0005;
-const float RADIAL_MULT = 4.0;
-const float BARREL_MULT = 8.0;
-const float INV_SQRT2 = 0.70710678118;
-
-void main() {
-    vec2 uv = v_texCoord;
-    vec4 original = texture(u_image0, uv);
-
-    float amount = u_float0 * AMOUNT_SCALE;
-
-    if (amount < 0.000001) {
-        fragColor = original;
-        return;
-    }
-
-    // Aspect-corrected coordinates for circular effects
-    float aspect = u_resolution.x / u_resolution.y;
-    vec2 centered = uv - 0.5;
-    vec2 corrected = vec2(centered.x * aspect, centered.y);
-    float r = length(corrected);
-    vec2 dir = r > 0.0001 ? corrected / r : vec2(0.0);
-    vec2 offset = vec2(0.0);
-
-    if (u_int0 == MODE_LINEAR) {
-        // Horizontal shift (no aspect correction needed)
-        offset = vec2(amount, 0.0);
-    }
-    else if (u_int0 == MODE_RADIAL) {
-        // Outward from center, stronger at edges
-        offset = dir * r * amount * RADIAL_MULT;
-        offset.x /= aspect;  // Convert back to UV space
-    }
-    else if (u_int0 == MODE_BARREL) {
-        // Lens distortion simulation (r² falloff)
-        offset = dir * r * r * amount * BARREL_MULT;
-        offset.x /= aspect;  // Convert back to UV space
-    }
-    else if (u_int0 == MODE_SWIRL) {
-        // Perpendicular to radial (rotational aberration)
-        vec2 perp = vec2(-dir.y, dir.x);
-        offset = perp * r * amount * RADIAL_MULT;
-        offset.x /= aspect;  // Convert back to UV space
-    }
-    else if (u_int0 == MODE_DIAGONAL) {
-        // 45° offset (no aspect correction needed)
-        offset = vec2(amount, amount) * INV_SQRT2;
-    }
-    
-    float red = texture(u_image0, uv + offset).r;
-    float green = original.g;
-    float blue = texture(u_image0, uv - offset).b;
-    
-    fragColor = vec4(red, green, blue, original.a);
-}

blueprints/.glsl/Color_Adjustment_15.frag

@@ -1,78 +0,0 @@
-#version 300 es
-precision highp float;
-
-uniform sampler2D u_image0;
-uniform float u_float0; // temperature (-100 to 100)
-uniform float u_float1; // tint (-100 to 100)
-uniform float u_float2; // vibrance (-100 to 100)
-uniform float u_float3; // saturation (-100 to 100)
-
-in vec2 v_texCoord;
-out vec4 fragColor;
-
-const float INPUT_SCALE = 0.01;
-const float TEMP_TINT_PRIMARY = 0.3;
-const float TEMP_TINT_SECONDARY = 0.15;
-const float VIBRANCE_BOOST = 2.0;
-const float SATURATION_BOOST = 2.0;
-const float SKIN_PROTECTION = 0.5;
-const float EPSILON = 0.001;
-const vec3 LUMA_WEIGHTS = vec3(0.299, 0.587, 0.114);
-
-void main() {
-    vec4 tex = texture(u_image0, v_texCoord);
-    vec3 color = tex.rgb;
-    
-    // Scale inputs: -100/100 → -1/1
-    float temperature = u_float0 * INPUT_SCALE;
-    float tint = u_float1 * INPUT_SCALE;
-    float vibrance = u_float2 * INPUT_SCALE;
-    float saturation = u_float3 * INPUT_SCALE;
-    
-    // Temperature (warm/cool): positive = warm, negative = cool
-    color.r += temperature * TEMP_TINT_PRIMARY;
-    color.b -= temperature * TEMP_TINT_PRIMARY;
-    
-    // Tint (green/magenta): positive = green, negative = magenta
-    color.g += tint * TEMP_TINT_PRIMARY;
-    color.r -= tint * TEMP_TINT_SECONDARY;
-    color.b -= tint * TEMP_TINT_SECONDARY;
-    
-    // Single clamp after temperature/tint
-    color = clamp(color, 0.0, 1.0);
-    
-    // Vibrance with skin protection
-    if (vibrance != 0.0) {
-        float maxC = max(color.r, max(color.g, color.b));
-        float minC = min(color.r, min(color.g, color.b));
-        float sat = maxC - minC;
-        float gray = dot(color, LUMA_WEIGHTS);
-        
-        if (vibrance < 0.0) {
-            // Desaturate: -100 → gray
-            color = mix(vec3(gray), color, 1.0 + vibrance);
-        } else {
-            // Boost less saturated colors more
-            float vibranceAmt = vibrance * (1.0 - sat);
-            
-            // Branchless skin tone protection
-            float isWarmTone = step(color.b, color.g) * step(color.g, color.r);
-            float warmth = (color.r - color.b) / max(maxC, EPSILON);
-            float skinTone = isWarmTone * warmth * sat * (1.0 - sat);
-            vibranceAmt *= (1.0 - skinTone * SKIN_PROTECTION);
-            
-            color = mix(vec3(gray), color, 1.0 + vibranceAmt * VIBRANCE_BOOST);
-        }
-    }
-    
-    // Saturation
-    if (saturation != 0.0) {
-        float gray = dot(color, LUMA_WEIGHTS);
-        float satMix = saturation < 0.0
-            ? 1.0 + saturation                      // -100 → gray
-            : 1.0 + saturation * SATURATION_BOOST;  // +100 → 3x boost
-        color = mix(vec3(gray), color, satMix);
-    }
-    
-    fragColor = vec4(clamp(color, 0.0, 1.0), tex.a);
-}

blueprints/.glsl/Color_Balance_15.frag

@@ -1,90 +0,0 @@
-#version 300 es
-precision highp float;
-
-uniform sampler2D u_image0;
-uniform float u_float0;
-uniform float u_float1;
-uniform float u_float2;
-uniform float u_float3;
-uniform float u_float4;
-uniform float u_float5;
-uniform float u_float6;
-uniform float u_float7;
-uniform float u_float8;
-uniform bool u_bool0;
-
-in vec2 v_texCoord;
-out vec4 fragColor;
-
-vec3 rgb2hsl(vec3 c) {
-    float maxC = max(c.r, max(c.g, c.b));
-    float minC = min(c.r, min(c.g, c.b));
-    float l = (maxC + minC) * 0.5;
-    if (maxC == minC) return vec3(0.0, 0.0, l);
-    float d = maxC - minC;
-    float s = l > 0.5 ? d / (2.0 - maxC - minC) : d / (maxC + minC);
-    float h;
-    if (maxC == c.r) {
-        h = (c.g - c.b) / d + (c.g < c.b ? 6.0 : 0.0);
-    } else if (maxC == c.g) {
-        h = (c.b - c.r) / d + 2.0;
-    } else {
-        h = (c.r - c.g) / d + 4.0;
-    }
-    h /= 6.0;
-    return vec3(h, s, l);
-}
-
-float hue2rgb(float p, float q, float t) {
-    if (t < 0.0) t += 1.0;
-    if (t > 1.0) t -= 1.0;
-    if (t < 1.0 / 6.0) return p + (q - p) * 6.0 * t;
-    if (t < 1.0 / 2.0) return q;
-    if (t < 2.0 / 3.0) return p + (q - p) * (2.0 / 3.0 - t) * 6.0;
-    return p;
-}
-
-vec3 hsl2rgb(vec3 hsl) {
-    float h = hsl.x, s = hsl.y, l = hsl.z;
-    if (s == 0.0) return vec3(l);
-    float q = l < 0.5 ? l * (1.0 + s) : l + s - l * s;
-    float p = 2.0 * l - q;
-    return vec3(
-        hue2rgb(p, q, h + 1.0 / 3.0),
-        hue2rgb(p, q, h),
-        hue2rgb(p, q, h - 1.0 / 3.0)
-    );
-}
-
-void main() {
-    vec4 tex = texture(u_image0, v_texCoord);
-    vec3 color = tex.rgb;
-
-    vec3 shadows = vec3(u_float0, u_float1, u_float2) * 0.01;
-    vec3 midtones = vec3(u_float3, u_float4, u_float5) * 0.01;
-    vec3 highlights = vec3(u_float6, u_float7, u_float8) * 0.01;
-
-    float maxC = max(color.r, max(color.g, color.b));
-    float minC = min(color.r, min(color.g, color.b));
-    float lightness = (maxC + minC) * 0.5;
-
-    // GIMP weight curves: linear ramps with constants a=0.25, b=0.333, scale=0.7
-    const float a = 0.25;
-    const float b = 0.333;
-    const float scale = 0.7;
-
-    float sw = clamp((lightness - b) / -a + 0.5, 0.0, 1.0) * scale;
-    float mw = clamp((lightness - b) / a + 0.5, 0.0, 1.0) *
-               clamp((lightness + b - 1.0) / -a + 0.5, 0.0, 1.0) * scale;
-    float hw = clamp((lightness + b - 1.0) / a + 0.5, 0.0, 1.0) * scale;
-
-    color += sw * shadows + mw * midtones + hw * highlights;
-
-    if (u_bool0) {
-        vec3 hsl = rgb2hsl(clamp(color, 0.0, 1.0));
-        hsl.z = lightness;
-        color = hsl2rgb(hsl);
-    }
-
-    fragColor = vec4(clamp(color, 0.0, 1.0), tex.a);
-}

blueprints/.glsl/Color_Curves_8.frag

@@ -1,49 +0,0 @@
-#version 300 es
-precision highp float;
-
-uniform sampler2D u_image0;
-uniform sampler2D u_curve0;  // RGB master curve (256x1 LUT)
-uniform sampler2D u_curve1;  // Red channel curve
-uniform sampler2D u_curve2;  // Green channel curve
-uniform sampler2D u_curve3;  // Blue channel curve
-
-in vec2 v_texCoord;
-layout(location = 0) out vec4 fragColor0;
-
-// GIMP-compatible curve lookup with manual linear interpolation.
-// Matches gimp_curve_map_value_inline() from gimpcurve-map.c:
-//   index = value * (n_samples - 1)
-//   f = fract(index)
-//   result = (1-f) * samples[floor] + f * samples[ceil]
-//
-// Uses texelFetch (NEAREST) to avoid GPU half-texel offset issues
-// that occur with texture() + GL_LINEAR on small 256x1 LUTs.
-float applyCurve(sampler2D curve, float value) {
-    value = clamp(value, 0.0, 1.0);
-
-    float pos = value * 255.0;
-    int lo = int(floor(pos));
-    int hi = min(lo + 1, 255);
-    float f = pos - float(lo);
-
-    float a = texelFetch(curve, ivec2(lo, 0), 0).r;
-    float b = texelFetch(curve, ivec2(hi, 0), 0).r;
-
-    return a + f * (b - a);
-}
-
-void main() {
-    vec4 color = texture(u_image0, v_texCoord);
-
-    // GIMP order: per-channel curves first, then RGB master curve.
-    // See gimp_curve_map_pixels() default case in gimpcurve-map.c:
-    //   dest = colors_curve( channel_curve( src ) )
-    float tmp_r = applyCurve(u_curve1, color.r);
-    float tmp_g = applyCurve(u_curve2, color.g);
-    float tmp_b = applyCurve(u_curve3, color.b);
-    color.r = applyCurve(u_curve0, tmp_r);
-    color.g = applyCurve(u_curve0, tmp_g);
-    color.b = applyCurve(u_curve0, tmp_b);
-
-    fragColor0 = vec4(color.rgb, color.a);
-}

blueprints/.glsl/Edge-Preserving_Blur_128.frag

@@ -1,94 +0,0 @@
-#version 300 es
-precision highp float;
-
-uniform sampler2D u_image0;
-uniform float u_float0;   // Blur radius (0–20, default ~5)
-uniform float u_float1;   // Edge threshold (0–100, default ~30)
-uniform int u_int0;       // Step size (0/1 = every pixel, 2+ = skip pixels)
-
-in vec2 v_texCoord;
-out vec4 fragColor;
-
-const int MAX_RADIUS = 20;
-const float EPSILON = 0.0001;
-
-// Perceptual luminance
-float getLuminance(vec3 rgb) {
-    return dot(rgb, vec3(0.299, 0.587, 0.114));
-}
-
-vec4 bilateralFilter(vec2 uv, vec2 texelSize, int radius,
-                     float sigmaSpatial, float sigmaColor)
-{
-    vec4 center = texture(u_image0, uv);
-    vec3 centerRGB = center.rgb;
-
-    float invSpatial2 = -0.5 / (sigmaSpatial * sigmaSpatial);
-    float invColor2   = -0.5 / (sigmaColor * sigmaColor + EPSILON);
-
-    vec3 sumRGB = vec3(0.0);
-    float sumWeight = 0.0;
-
-    int step = max(u_int0, 1);
-    float radius2 = float(radius * radius);
-
-    for (int dy = -MAX_RADIUS; dy <= MAX_RADIUS; dy++) {
-        if (dy < -radius || dy > radius) continue;
-        if (abs(dy) % step != 0) continue;
-
-        for (int dx = -MAX_RADIUS; dx <= MAX_RADIUS; dx++) {
-            if (dx < -radius || dx > radius) continue;
-            if (abs(dx) % step != 0) continue;
-
-            vec2 offset = vec2(float(dx), float(dy));
-            float dist2 = dot(offset, offset);
-            if (dist2 > radius2) continue;
-
-            vec3 sampleRGB = texture(u_image0, uv + offset * texelSize).rgb;
-
-            // Spatial Gaussian
-            float spatialWeight = exp(dist2 * invSpatial2);
-
-            // Perceptual color distance (weighted RGB)
-            vec3 diff = sampleRGB - centerRGB;
-            float colorDist = dot(diff * diff, vec3(0.299, 0.587, 0.114));
-            float colorWeight = exp(colorDist * invColor2);
-
-            float w = spatialWeight * colorWeight;
-            sumRGB += sampleRGB * w;
-            sumWeight += w;
-        }
-    }
-
-    vec3 resultRGB = sumRGB / max(sumWeight, EPSILON);
-    return vec4(resultRGB, center.a); // preserve center alpha
-}
-
-void main() {
-    vec2 texelSize = 1.0 / vec2(textureSize(u_image0, 0));
-
-    float radiusF = clamp(u_float0, 0.0, float(MAX_RADIUS));
-    int radius = int(radiusF + 0.5);
-
-    if (radius == 0) {
-        fragColor = texture(u_image0, v_texCoord);
-        return;
-    }
-
-    // Edge threshold → color sigma
-    // Squared curve for better low-end control
-    float t = clamp(u_float1, 0.0, 100.0) / 100.0;
-    t *= t;
-    float sigmaColor = mix(0.01, 0.5, t);
-
-    // Spatial sigma tied to radius
-    float sigmaSpatial = max(radiusF * 0.75, 0.5);
-
-    fragColor = bilateralFilter(
-        v_texCoord,
-        texelSize,
-        radius,
-        sigmaSpatial,
-        sigmaColor
-    );
-}

blueprints/.glsl/Film_Grain_15.frag

@@ -1,124 +0,0 @@
-#version 300 es
-precision highp float;
-
-uniform sampler2D u_image0;
-uniform vec2 u_resolution;
-uniform float u_float0; // grain amount      [0.0 – 1.0]   typical: 0.2–0.8
-uniform float u_float1; // grain size        [0.3 – 3.0]   lower = finer grain
-uniform float u_float2; // color amount      [0.0 – 1.0]   0 = monochrome, 1 = RGB grain
-uniform float u_float3; // luminance bias    [0.0 – 1.0]   0 = uniform, 1 = shadows only
-uniform int   u_int0;   // noise mode        [0 or 1]      0 = smooth, 1 = grainy
-
-in vec2 v_texCoord;
-layout(location = 0) out vec4 fragColor0;
-
-// High-quality integer hash (pcg-like)
-uint pcg(uint v) {
-    uint state = v * 747796405u + 2891336453u;
-    uint word = ((state >> ((state >> 28u) + 4u)) ^ state) * 277803737u;
-    return (word >> 22u) ^ word;
-}
-
-// 2D -> 1D hash input
-uint hash2d(uvec2 p) {
-    return pcg(p.x + pcg(p.y));
-}
-
-// Hash to float [0, 1]
-float hashf(uvec2 p) {
-    return float(hash2d(p)) / float(0xffffffffu);
-}
-
-// Hash to float with offset (for RGB channels)
-float hashf(uvec2 p, uint offset) {
-    return float(pcg(hash2d(p) + offset)) / float(0xffffffffu);
-}
-
-// Convert uniform [0,1] to roughly Gaussian distribution
-// Using simple approximation: average of multiple samples
-float toGaussian(uvec2 p) {
-    float sum = hashf(p, 0u) + hashf(p, 1u) + hashf(p, 2u) + hashf(p, 3u);
-    return (sum - 2.0) * 0.7;  // Centered, scaled
-}
-
-float toGaussian(uvec2 p, uint offset) {
-    float sum = hashf(p, offset) + hashf(p, offset + 1u) 
-              + hashf(p, offset + 2u) + hashf(p, offset + 3u);
-    return (sum - 2.0) * 0.7;
-}
-
-// Smooth noise with better interpolation
-float smoothNoise(vec2 p) {
-    vec2 i = floor(p);
-    vec2 f = fract(p);
-    
-    // Quintic interpolation (less banding than cubic)
-    f = f * f * f * (f * (f * 6.0 - 15.0) + 10.0);
-    
-    uvec2 ui = uvec2(i);
-    float a = toGaussian(ui);
-    float b = toGaussian(ui + uvec2(1u, 0u));
-    float c = toGaussian(ui + uvec2(0u, 1u));
-    float d = toGaussian(ui + uvec2(1u, 1u));
-    
-    return mix(mix(a, b, f.x), mix(c, d, f.x), f.y);
-}
-
-float smoothNoise(vec2 p, uint offset) {
-    vec2 i = floor(p);
-    vec2 f = fract(p);
-    
-    f = f * f * f * (f * (f * 6.0 - 15.0) + 10.0);
-    
-    uvec2 ui = uvec2(i);
-    float a = toGaussian(ui, offset);
-    float b = toGaussian(ui + uvec2(1u, 0u), offset);
-    float c = toGaussian(ui + uvec2(0u, 1u), offset);
-    float d = toGaussian(ui + uvec2(1u, 1u), offset);
-    
-    return mix(mix(a, b, f.x), mix(c, d, f.x), f.y);
-}
-
-void main() {
-    vec4 color = texture(u_image0, v_texCoord);
-    
-    // Luminance (Rec.709)
-    float luma = dot(color.rgb, vec3(0.2126, 0.7152, 0.0722));
-    
-    // Grain UV (resolution-independent)
-    vec2 grainUV = v_texCoord * u_resolution / max(u_float1, 0.01);
-    uvec2 grainPixel = uvec2(grainUV);
-    
-    float g;
-    vec3 grainRGB;
-    
-    if (u_int0 == 1) {
-        // Grainy mode: pure hash noise (no interpolation = no banding)
-        g = toGaussian(grainPixel);
-        grainRGB = vec3(
-            toGaussian(grainPixel, 100u),
-            toGaussian(grainPixel, 200u),
-            toGaussian(grainPixel, 300u)
-        );
-    } else {
-        // Smooth mode: interpolated with quintic curve
-        g = smoothNoise(grainUV);
-        grainRGB = vec3(
-            smoothNoise(grainUV, 100u),
-            smoothNoise(grainUV, 200u),
-            smoothNoise(grainUV, 300u)
-        );
-    }
-    
-    // Luminance weighting (less grain in highlights)
-    float lumWeight = mix(1.0, 1.0 - luma, clamp(u_float3, 0.0, 1.0));
-    
-    // Strength
-    float strength = u_float0 * 0.15;
-    
-    // Color vs monochrome grain
-    vec3 grainColor = mix(vec3(g), grainRGB, clamp(u_float2, 0.0, 1.0));
-    
-    color.rgb += grainColor * strength * lumWeight;
-    fragColor0 = vec4(clamp(color.rgb, 0.0, 1.0), color.a);
-}

blueprints/.glsl/Glow_30.frag

@@ -1,133 +0,0 @@
-#version 300 es
-precision mediump float;
-
-uniform sampler2D u_image0;
-uniform vec2 u_resolution;
-uniform int u_int0;      // Blend mode
-uniform int u_int1;      // Color tint
-uniform float u_float0;  // Intensity
-uniform float u_float1;  // Radius
-uniform float u_float2;  // Threshold
-
-in vec2 v_texCoord;
-out vec4 fragColor;
-
-const int BLEND_ADD      = 0;
-const int BLEND_SCREEN   = 1;
-const int BLEND_SOFT     = 2;
-const int BLEND_OVERLAY  = 3;
-const int BLEND_LIGHTEN  = 4;
-
-const float GOLDEN_ANGLE = 2.39996323;
-const int MAX_SAMPLES = 48;
-const vec3 LUMA = vec3(0.299, 0.587, 0.114);
-
-float hash(vec2 p) {
-    p = fract(p * vec2(123.34, 456.21));
-    p += dot(p, p + 45.32);
-    return fract(p.x * p.y);
-}
-
-vec3 hexToRgb(int h) {
-    return vec3(
-        float((h >> 16) & 255),
-        float((h >> 8) & 255),
-        float(h & 255)
-    ) * (1.0 / 255.0);
-}
-
-vec3 blend(vec3 base, vec3 glow, int mode) {
-    if (mode == BLEND_SCREEN) {
-        return 1.0 - (1.0 - base) * (1.0 - glow);
-    }
-    if (mode == BLEND_SOFT) {
-        return mix(
-            base - (1.0 - 2.0 * glow) * base * (1.0 - base),
-            base + (2.0 * glow - 1.0) * (sqrt(base) - base),
-            step(0.5, glow)
-        );
-    }
-    if (mode == BLEND_OVERLAY) {
-        return mix(
-            2.0 * base * glow,
-            1.0 - 2.0 * (1.0 - base) * (1.0 - glow),
-            step(0.5, base)
-        );
-    }
-    if (mode == BLEND_LIGHTEN) {
-        return max(base, glow);
-    }
-    return base + glow;
-}
-
-void main() {
-    vec4 original = texture(u_image0, v_texCoord);
-    
-    float intensity = u_float0 * 0.05;
-    float radius = u_float1 * u_float1 * 0.012;
-    
-    if (intensity < 0.001 || radius < 0.1) {
-        fragColor = original;
-        return;
-    }
-    
-    float threshold = 1.0 - u_float2 * 0.01;
-    float t0 = threshold - 0.15;
-    float t1 = threshold + 0.15;
-    
-    vec2 texelSize = 1.0 / u_resolution;
-    float radius2 = radius * radius;
-    
-    float sampleScale = clamp(radius * 0.75, 0.35, 1.0);
-    int samples = int(float(MAX_SAMPLES) * sampleScale);
-    
-    float noise = hash(gl_FragCoord.xy);
-    float angleOffset = noise * GOLDEN_ANGLE;
-    float radiusJitter = 0.85 + noise * 0.3;
-    
-    float ca = cos(GOLDEN_ANGLE);
-    float sa = sin(GOLDEN_ANGLE);
-    vec2 dir = vec2(cos(angleOffset), sin(angleOffset));
-    
-    vec3 glow = vec3(0.0);
-    float totalWeight = 0.0;
-    
-    // Center tap
-    float centerMask = smoothstep(t0, t1, dot(original.rgb, LUMA));
-    glow += original.rgb * centerMask * 2.0;
-    totalWeight += 2.0;
-    
-    for (int i = 1; i < MAX_SAMPLES; i++) {
-        if (i >= samples) break;
-        
-        float fi = float(i);
-        float dist = sqrt(fi / float(samples)) * radius * radiusJitter;
-        
-        vec2 offset = dir * dist * texelSize;
-        vec3 c = texture(u_image0, v_texCoord + offset).rgb;
-        float mask = smoothstep(t0, t1, dot(c, LUMA));
-        
-        float w = 1.0 - (dist * dist) / (radius2 * 1.5);
-        w = max(w, 0.0);
-        w *= w;
-        
-        glow += c * mask * w;
-        totalWeight += w;
-        
-        dir = vec2(
-            dir.x * ca - dir.y * sa,
-            dir.x * sa + dir.y * ca
-        );
-    }
-    
-    glow *= intensity / max(totalWeight, 0.001);
-    
-    if (u_int1 > 0) {
-        glow *= hexToRgb(u_int1);
-    }
-    
-    vec3 result = blend(original.rgb, glow, u_int0);
-    result += (noise - 0.5) * (1.0 / 255.0);
-    
-    fragColor = vec4(clamp(result, 0.0, 1.0), original.a);
-}

blueprints/.glsl/Hue_and_Saturation_1.frag

@@ -1,222 +0,0 @@
-#version 300 es
-precision highp float;
-
-uniform sampler2D u_image0;
-uniform int u_int0;      // Mode: 0=Master, 1=Reds, 2=Yellows, 3=Greens, 4=Cyans, 5=Blues, 6=Magentas, 7=Colorize
-uniform int u_int1;      // Color Space: 0=HSL, 1=HSB/HSV
-uniform float u_float0;  // Hue (-180 to 180)
-uniform float u_float1;  // Saturation (-100 to 100)
-uniform float u_float2;  // Lightness/Brightness (-100 to 100)
-uniform float u_float3;  // Overlap (0 to 100) - feathering between adjacent color ranges
-
-in vec2 v_texCoord;
-out vec4 fragColor;
-
-// Color range modes
-const int MODE_MASTER   = 0;
-const int MODE_RED      = 1;
-const int MODE_YELLOW   = 2;
-const int MODE_GREEN    = 3;
-const int MODE_CYAN     = 4;
-const int MODE_BLUE     = 5;
-const int MODE_MAGENTA  = 6;
-const int MODE_COLORIZE = 7;
-
-// Color space modes
-const int COLORSPACE_HSL = 0;
-const int COLORSPACE_HSB = 1;
-
-const float EPSILON = 0.0001;
-
-//=============================================================================
-// RGB <-> HSL Conversions
-//=============================================================================
-
-vec3 rgb2hsl(vec3 c) {
-    float maxC = max(max(c.r, c.g), c.b);
-    float minC = min(min(c.r, c.g), c.b);
-    float delta = maxC - minC;
-
-    float h = 0.0;
-    float s = 0.0;
-    float l = (maxC + minC) * 0.5;
-
-    if (delta > EPSILON) {
-        s = l < 0.5
-            ? delta / (maxC + minC)
-            : delta / (2.0 - maxC - minC);
-
-        if (maxC == c.r) {
-            h = (c.g - c.b) / delta + (c.g < c.b ? 6.0 : 0.0);
-        } else if (maxC == c.g) {
-            h = (c.b - c.r) / delta + 2.0;
-        } else {
-            h = (c.r - c.g) / delta + 4.0;
-        }
-        h /= 6.0;
-    }
-
-    return vec3(h, s, l);
-}
-
-float hue2rgb(float p, float q, float t) {
-    t = fract(t);
-    if (t < 1.0/6.0) return p + (q - p) * 6.0 * t;
-    if (t < 0.5)       return q;
-    if (t < 2.0/3.0)   return p + (q - p) * (2.0/3.0 - t) * 6.0;
-    return p;
-}
-
-vec3 hsl2rgb(vec3 hsl) {
-    if (hsl.y < EPSILON) return vec3(hsl.z);
-
-    float q = hsl.z < 0.5
-        ? hsl.z * (1.0 + hsl.y)
-        : hsl.z + hsl.y - hsl.z * hsl.y;
-    float p = 2.0 * hsl.z - q;
-
-    return vec3(
-        hue2rgb(p, q, hsl.x + 1.0/3.0),
-        hue2rgb(p, q, hsl.x),
-        hue2rgb(p, q, hsl.x - 1.0/3.0)
-    );
-}
-
-vec3 rgb2hsb(vec3 c) {
-    float maxC = max(max(c.r, c.g), c.b);
-    float minC = min(min(c.r, c.g), c.b);
-    float delta = maxC - minC;
-
-    float h = 0.0;
-    float s = (maxC > EPSILON) ? delta / maxC : 0.0;
-    float b = maxC;
-
-    if (delta > EPSILON) {
-        if (maxC == c.r) {
-            h = (c.g - c.b) / delta + (c.g < c.b ? 6.0 : 0.0);
-        } else if (maxC == c.g) {
-            h = (c.b - c.r) / delta + 2.0;
-        } else {
-            h = (c.r - c.g) / delta + 4.0;
-        }
-        h /= 6.0;
-    }
-
-    return vec3(h, s, b);
-}
-
-vec3 hsb2rgb(vec3 hsb) {
-    vec3 rgb = clamp(abs(mod(hsb.x * 6.0 + vec3(0.0, 4.0, 2.0), 6.0) - 3.0) - 1.0, 0.0, 1.0);
-    return hsb.z * mix(vec3(1.0), rgb, hsb.y);
-}
-
-//=============================================================================
-// Color Range Weight Calculation
-//=============================================================================
-
-float hueDistance(float a, float b) {
-    float d = abs(a - b);
-    return min(d, 1.0 - d);
-}
-
-float getHueWeight(float hue, float center, float overlap) {
-    float baseWidth = 1.0 / 6.0;
-    float feather = baseWidth * overlap;
-
-    float d = hueDistance(hue, center);
-
-    float inner = baseWidth * 0.5;
-    float outer = inner + feather;
-
-    return 1.0 - smoothstep(inner, outer, d);
-}
-
-float getModeWeight(float hue, int mode, float overlap) {
-    if (mode == MODE_MASTER || mode == MODE_COLORIZE) return 1.0;
-
-    if (mode == MODE_RED) {
-        return max(
-            getHueWeight(hue, 0.0, overlap),
-            getHueWeight(hue, 1.0, overlap)
-        );
-    }
-
-    float center = float(mode - 1) / 6.0;
-    return getHueWeight(hue, center, overlap);
-}
-
-//=============================================================================
-// Adjustment Functions
-//=============================================================================
-
-float adjustLightness(float l, float amount) {
-    return amount > 0.0
-        ? l + (1.0 - l) * amount
-        : l + l * amount;
-}
-
-float adjustBrightness(float b, float amount) {
-    return clamp(b + amount, 0.0, 1.0);
-}
-
-float adjustSaturation(float s, float amount) {
-    return amount > 0.0
-        ? s + (1.0 - s) * amount
-        : s + s * amount;
-}
-
-vec3 colorize(vec3 rgb, float hue, float sat, float light) {
-    float lum = dot(rgb, vec3(0.299, 0.587, 0.114));
-    float l = adjustLightness(lum, light);
-
-    vec3 hsl = vec3(fract(hue), clamp(sat, 0.0, 1.0), clamp(l, 0.0, 1.0));
-    return hsl2rgb(hsl);
-}
-
-//=============================================================================
-// Main
-//=============================================================================
-
-void main() {
-    vec4 original = texture(u_image0, v_texCoord);
-
-    float hueShift   = u_float0 / 360.0;   // -180..180 -> -0.5..0.5
-    float satAmount  = u_float1 / 100.0;   // -100..100 -> -1..1
-    float lightAmount= u_float2 / 100.0;   // -100..100 -> -1..1
-    float overlap    = u_float3 / 100.0;   // 0..100 -> 0..1
-
-    vec3 result;
-
-    if (u_int0 == MODE_COLORIZE) {
-        result = colorize(original.rgb, hueShift, satAmount, lightAmount);
-        fragColor = vec4(result, original.a);
-        return;
-    }
-
-    vec3 hsx = (u_int1 == COLORSPACE_HSL)
-        ? rgb2hsl(original.rgb)
-        : rgb2hsb(original.rgb);
-
-    float weight = getModeWeight(hsx.x, u_int0, overlap);
-
-    if (u_int0 != MODE_MASTER && hsx.y < EPSILON) {
-        weight = 0.0;
-    }
-
-    if (weight > EPSILON) {
-        float h = fract(hsx.x + hueShift * weight);
-        float s = clamp(adjustSaturation(hsx.y, satAmount * weight), 0.0, 1.0);
-        float v = (u_int1 == COLORSPACE_HSL)
-            ? clamp(adjustLightness(hsx.z, lightAmount * weight), 0.0, 1.0)
-            : clamp(adjustBrightness(hsx.z, lightAmount * weight), 0.0, 1.0);
-
-        vec3 adjusted = vec3(h, s, v);
-        result = (u_int1 == COLORSPACE_HSL)
-            ? hsl2rgb(adjusted)
-            : hsb2rgb(adjusted);
-    } else {
-        result = original.rgb;
-    }
-
-    fragColor = vec4(result, original.a);
-}

blueprints/.glsl/Image_Blur_1.frag

@@ -1,111 +0,0 @@
-#version 300 es
-#pragma passes 2
-precision highp float;
-
-// Blur type constants
-const int BLUR_GAUSSIAN = 0;
-const int BLUR_BOX = 1;
-const int BLUR_RADIAL = 2;
-
-// Radial blur config
-const int RADIAL_SAMPLES = 12;
-const float RADIAL_STRENGTH = 0.0003;
-
-uniform sampler2D u_image0;
-uniform vec2 u_resolution;
-uniform int u_int0;      // Blur type (BLUR_GAUSSIAN, BLUR_BOX, BLUR_RADIAL)
-uniform float u_float0;  // Blur radius/amount
-uniform int u_pass;      // Pass index (0 = horizontal, 1 = vertical)
-
-in vec2 v_texCoord;
-layout(location = 0) out vec4 fragColor0;
-
-float gaussian(float x, float sigma) {
-    return exp(-(x * x) / (2.0 * sigma * sigma));
-}
-
-void main() {
-    vec2 texelSize = 1.0 / u_resolution;
-    float radius = max(u_float0, 0.0);
-
-    // Radial (angular) blur - single pass, doesn't use separable
-    if (u_int0 == BLUR_RADIAL) {
-        // Only execute on first pass
-        if (u_pass > 0) {
-            fragColor0 = texture(u_image0, v_texCoord);
-            return;
-        }
-
-        vec2 center = vec2(0.5);
-        vec2 dir = v_texCoord - center;
-        float dist = length(dir);
-
-        if (dist < 1e-4) {
-            fragColor0 = texture(u_image0, v_texCoord);
-            return;
-        }
-
-        vec4 sum = vec4(0.0);
-        float totalWeight = 0.0;
-        float angleStep = radius * RADIAL_STRENGTH;
-
-        dir /= dist;
-
-        float cosStep = cos(angleStep);
-        float sinStep = sin(angleStep);
-
-        float negAngle = -float(RADIAL_SAMPLES) * angleStep;
-        vec2 rotDir = vec2(
-            dir.x * cos(negAngle) - dir.y * sin(negAngle),
-            dir.x * sin(negAngle) + dir.y * cos(negAngle)
-        );
-
-        for (int i = -RADIAL_SAMPLES; i <= RADIAL_SAMPLES; i++) {
-            vec2 uv = center + rotDir * dist;
-            float w = 1.0 - abs(float(i)) / float(RADIAL_SAMPLES);
-            sum += texture(u_image0, uv) * w;
-            totalWeight += w;
-
-            rotDir = vec2(
-                rotDir.x * cosStep - rotDir.y * sinStep,
-                rotDir.x * sinStep + rotDir.y * cosStep
-            );
-        }
-
-        fragColor0 = sum / max(totalWeight, 0.001);
-        return;
-    }
-
-    // Separable Gaussian / Box blur
-    int samples = int(ceil(radius));
-
-    if (samples == 0) {
-        fragColor0 = texture(u_image0, v_texCoord);
-        return;
-    }
-
-    // Direction: pass 0 = horizontal, pass 1 = vertical
-    vec2 dir = (u_pass == 0) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
-
-    vec4 color = vec4(0.0);
-    float totalWeight = 0.0;
-    float sigma = radius / 2.0;
-
-    for (int i = -samples; i <= samples; i++) {
-        vec2 offset = dir * float(i) * texelSize;
-        vec4 sample_color = texture(u_image0, v_texCoord + offset);
-
-        float weight;
-        if (u_int0 == BLUR_GAUSSIAN) {
-            weight = gaussian(float(i), sigma);
-        } else {
-            // BLUR_BOX
-            weight = 1.0;
-        }
-
-        color += sample_color * weight;
-        totalWeight += weight;
-    }
-
-    fragColor0 = color / totalWeight;
-}

blueprints/.glsl/Image_Channels_23.frag

@@ -1,19 +0,0 @@
-#version 300 es
-precision highp float;
-
-uniform sampler2D u_image0;
-
-in vec2 v_texCoord;
-layout(location = 0) out vec4 fragColor0;
-layout(location = 1) out vec4 fragColor1;
-layout(location = 2) out vec4 fragColor2;
-layout(location = 3) out vec4 fragColor3;
-
-void main() {
-  vec4 color = texture(u_image0, v_texCoord);
-  // Output each channel as grayscale to separate render targets
-  fragColor0 = vec4(vec3(color.r), 1.0);  // Red channel
-  fragColor1 = vec4(vec3(color.g), 1.0);  // Green channel
-  fragColor2 = vec4(vec3(color.b), 1.0);  // Blue channel
-  fragColor3 = vec4(vec3(color.a), 1.0);  // Alpha channel
-}

blueprints/.glsl/Image_Levels_1.frag

@@ -1,71 +0,0 @@
-#version 300 es
-precision highp float;
-
-// Levels Adjustment
-// u_int0:   channel      (0=RGB, 1=R, 2=G, 3=B)         default: 0
-// u_float0: input black  (0-255)                        default: 0
-// u_float1: input white  (0-255)                        default: 255
-// u_float2: gamma        (0.01-9.99)                    default: 1.0
-// u_float3: output black (0-255)                        default: 0
-// u_float4: output white (0-255)                        default: 255
-
-uniform sampler2D u_image0;
-uniform int u_int0;
-uniform float u_float0;
-uniform float u_float1;
-uniform float u_float2;
-uniform float u_float3;
-uniform float u_float4;
-
-in vec2 v_texCoord;
-out vec4 fragColor;
-
-vec3 applyLevels(vec3 color, float inBlack, float inWhite, float gamma, float outBlack, float outWhite) {
-    float inRange = max(inWhite - inBlack, 0.0001);
-    vec3 result = clamp((color - inBlack) / inRange, 0.0, 1.0);
-    result = pow(result, vec3(1.0 / gamma));
-    result = mix(vec3(outBlack), vec3(outWhite), result);
-    return result;
-}
-
-float applySingleChannel(float value, float inBlack, float inWhite, float gamma, float outBlack, float outWhite) {
-    float inRange = max(inWhite - inBlack, 0.0001);
-    float result = clamp((value - inBlack) / inRange, 0.0, 1.0);
-    result = pow(result, 1.0 / gamma);
-    result = mix(outBlack, outWhite, result);
-    return result;
-}
-
-void main() {
-    vec4 texColor = texture(u_image0, v_texCoord);
-    vec3 color = texColor.rgb;
-    
-    float inBlack = u_float0 / 255.0;
-    float inWhite = u_float1 / 255.0;
-    float gamma = u_float2;
-    float outBlack = u_float3 / 255.0;
-    float outWhite = u_float4 / 255.0;
-    
-    vec3 result;
-    
-    if (u_int0 == 0) {
-        result = applyLevels(color, inBlack, inWhite, gamma, outBlack, outWhite);
-    }
-    else if (u_int0 == 1) {
-        result = color;
-        result.r = applySingleChannel(color.r, inBlack, inWhite, gamma, outBlack, outWhite);
-    }
-    else if (u_int0 == 2) {
-        result = color;
-        result.g = applySingleChannel(color.g, inBlack, inWhite, gamma, outBlack, outWhite);
-    }
-    else if (u_int0 == 3) {
-        result = color;
-        result.b = applySingleChannel(color.b, inBlack, inWhite, gamma, outBlack, outWhite);
-    }
-    else {
-        result = color;
-    }
-    
-    fragColor = vec4(result, texColor.a);
-}

blueprints/.glsl/README.md

@@ -1,28 +0,0 @@
-# GLSL Shader Sources
-
-This folder contains the GLSL fragment shaders extracted from blueprint JSON files for easier editing and version control.
-
-## File Naming Convention
-
-`{Blueprint_Name}_{node_id}.frag`
-
-- **Blueprint_Name**: The JSON filename with spaces/special chars replaced by underscores
-- **node_id**: The GLSLShader node ID within the subgraph
-
-## Usage
-
-```bash
-# Extract shaders from blueprint JSONs to this folder
-python update_blueprints.py extract
-
-# Patch edited shaders back into blueprint JSONs
-python update_blueprints.py patch
-```
-
-## Workflow
-
-1. Run `extract` to pull current shaders from JSONs
-2. Edit `.frag` files
-3. Run `patch` to update the blueprint JSONs
-4. Test
-5. Commit both `.frag` files and updated JSONs

blueprints/.glsl/Sharpen_23.frag

@@ -1,28 +0,0 @@
-#version 300 es
-precision highp float;
-
-uniform sampler2D u_image0;
-uniform vec2 u_resolution;
-uniform float u_float0;  // strength [0.0 – 2.0] typical: 0.3–1.0
-
-in vec2 v_texCoord;
-layout(location = 0) out vec4 fragColor0;
-
-void main() {
-    vec2 texel = 1.0 / u_resolution;
-    
-    // Sample center and neighbors
-    vec4 center = texture(u_image0, v_texCoord);
-    vec4 top    = texture(u_image0, v_texCoord + vec2( 0.0, -texel.y));
-    vec4 bottom = texture(u_image0, v_texCoord + vec2( 0.0,  texel.y));
-    vec4 left   = texture(u_image0, v_texCoord + vec2(-texel.x,  0.0));
-    vec4 right  = texture(u_image0, v_texCoord + vec2( texel.x,  0.0));
-    
-    // Edge enhancement (Laplacian)
-    vec4 edges = center * 4.0 - top - bottom - left - right;
-    
-    // Add edges back scaled by strength
-    vec4 sharpened = center + edges * u_float0;
-    
-    fragColor0 = vec4(clamp(sharpened.rgb, 0.0, 1.0), center.a);
-}

blueprints/.glsl/Unsharp_Mask_26.frag

@@ -1,61 +0,0 @@
-#version 300 es
-precision highp float;
-
-uniform sampler2D u_image0;
-uniform vec2 u_resolution;
-uniform float u_float0;  // amount    [0.0 - 3.0]  typical: 0.5-1.5
-uniform float u_float1;  // radius    [0.5 - 10.0] blur radius in pixels
-uniform float u_float2;  // threshold [0.0 - 0.1]  min difference to sharpen
-
-in vec2 v_texCoord;
-layout(location = 0) out vec4 fragColor0;
-
-float gaussian(float x, float sigma) {
-    return exp(-(x * x) / (2.0 * sigma * sigma));
-}
-
-float getLuminance(vec3 color) {
-    return dot(color, vec3(0.2126, 0.7152, 0.0722));
-}
-
-void main() {
-    vec2 texel = 1.0 / u_resolution;
-    float radius = max(u_float1, 0.5);
-    float amount = u_float0;
-    float threshold = u_float2;
-
-    vec4 original = texture(u_image0, v_texCoord);
-
-    // Gaussian blur for the "unsharp" mask
-    int samples = int(ceil(radius));
-    float sigma = radius / 2.0;
-
-    vec4 blurred = vec4(0.0);
-    float totalWeight = 0.0;
-
-    for (int x = -samples; x <= samples; x++) {
-        for (int y = -samples; y <= samples; y++) {
-            vec2 offset = vec2(float(x), float(y)) * texel;
-            vec4 sample_color = texture(u_image0, v_texCoord + offset);
-
-            float dist = length(vec2(float(x), float(y)));
-            float weight = gaussian(dist, sigma);
-            blurred += sample_color * weight;
-            totalWeight += weight;
-        }
-    }
-    blurred /= totalWeight;
-
-    // Unsharp mask = original - blurred
-    vec3 mask = original.rgb - blurred.rgb;
-
-    // Luminance-based threshold with smooth falloff
-    float lumaDelta = abs(getLuminance(original.rgb) - getLuminance(blurred.rgb));
-    float thresholdScale = smoothstep(0.0, threshold, lumaDelta);
-    mask *= thresholdScale;
-
-    // Sharpen: original + mask * amount
-    vec3 sharpened = original.rgb + mask * amount;
-
-    fragColor0 = vec4(clamp(sharpened, 0.0, 1.0), original.a);
-}

blueprints/.glsl/update_blueprints.py

@@ -1,159 +0,0 @@
-#!/usr/bin/env python3
-"""
-Shader Blueprint Updater
-
-Syncs GLSL shader files between this folder and blueprint JSON files.
-
-File naming convention:
-    {Blueprint Name}_{node_id}.frag
-
-Usage:
-    python update_blueprints.py extract   # Extract shaders from JSONs to here
-    python update_blueprints.py patch     # Patch shaders back into JSONs
-    python update_blueprints.py           # Same as patch (default)
-"""
-
-import json
-import logging
-import sys
-import re
-from pathlib import Path
-
-logging.basicConfig(level=logging.INFO, format='%(message)s')
-logger = logging.getLogger(__name__)
-
-GLSL_DIR = Path(__file__).parent
-BLUEPRINTS_DIR = GLSL_DIR.parent
-
-
-def get_blueprint_files():
-    """Get all blueprint JSON files."""
-    return sorted(BLUEPRINTS_DIR.glob("*.json"))
-
-
-def sanitize_filename(name):
-    """Convert blueprint name to safe filename."""
-    return re.sub(r'[^\w\-]', '_', name)
-
-
-def extract_shaders():
-    """Extract all shaders from blueprint JSONs to this folder."""
-    extracted = 0
-    for json_path in get_blueprint_files():
-        blueprint_name = json_path.stem
-
-        try:
-            with open(json_path, 'r') as f:
-                data = json.load(f)
-        except (json.JSONDecodeError, IOError) as e:
-            logger.warning("Skipping %s: %s", json_path.name, e)
-            continue
-
-        # Find GLSLShader nodes in subgraphs
-        for subgraph in data.get('definitions', {}).get('subgraphs', []):
-            for node in subgraph.get('nodes', []):
-                if node.get('type') == 'GLSLShader':
-                    node_id = node.get('id')
-                    widgets = node.get('widgets_values', [])
-
-                    # Find shader code (first string that looks like GLSL)
-                    for widget in widgets:
-                        if isinstance(widget, str) and widget.startswith('#version'):
-                            safe_name = sanitize_filename(blueprint_name)
-                            frag_name = f"{safe_name}_{node_id}.frag"
-                            frag_path = GLSL_DIR / frag_name
-
-                            with open(frag_path, 'w') as f:
-                                f.write(widget)
-
-                            logger.info("  Extracted: %s", frag_name)
-                            extracted += 1
-                            break
-
-    logger.info("\nExtracted %d shader(s)", extracted)
-
-
-def patch_shaders():
-    """Patch shaders from this folder back into blueprint JSONs."""
-    # Build lookup: blueprint_name -> [(node_id, shader_code), ...]
-    shader_updates = {}
-
-    for frag_path in sorted(GLSL_DIR.glob("*.frag")):
-        # Parse filename: {blueprint_name}_{node_id}.frag
-        parts = frag_path.stem.rsplit('_', 1)
-        if len(parts) != 2:
-            logger.warning("Skipping %s: invalid filename format", frag_path.name)
-            continue
-
-        blueprint_name, node_id_str = parts
-
-        try:
-            node_id = int(node_id_str)
-        except ValueError:
-            logger.warning("Skipping %s: invalid node_id", frag_path.name)
-            continue
-
-        with open(frag_path, 'r') as f:
-            shader_code = f.read()
-
-        if blueprint_name not in shader_updates:
-            shader_updates[blueprint_name] = []
-        shader_updates[blueprint_name].append((node_id, shader_code))
-
-    # Apply updates to JSON files
-    patched = 0
-    for json_path in get_blueprint_files():
-        blueprint_name = sanitize_filename(json_path.stem)
-
-        if blueprint_name not in shader_updates:
-            continue
-
-        try:
-            with open(json_path, 'r') as f:
-                data = json.load(f)
-        except (json.JSONDecodeError, IOError) as e:
-            logger.error("Error reading %s: %s", json_path.name, e)
-            continue
-
-        modified = False
-        for node_id, shader_code in shader_updates[blueprint_name]:
-            # Find the node and update
-            for subgraph in data.get('definitions', {}).get('subgraphs', []):
-                for node in subgraph.get('nodes', []):
-                    if node.get('id') == node_id and node.get('type') == 'GLSLShader':
-                        widgets = node.get('widgets_values', [])
-                        if len(widgets) > 0 and widgets[0] != shader_code:
-                            widgets[0] = shader_code
-                            modified = True
-                            logger.info("  Patched: %s (node %d)", json_path.name, node_id)
-                            patched += 1
-
-        if modified:
-            with open(json_path, 'w') as f:
-                json.dump(data, f)
-
-    if patched == 0:
-        logger.info("No changes to apply.")
-    else:
-        logger.info("\nPatched %d shader(s)", patched)
-
-
-def main():
-    if len(sys.argv) < 2:
-        command = "patch"
-    else:
-        command = sys.argv[1].lower()
-
-    if command == "extract":
-        logger.info("Extracting shaders from blueprints...")
-        extract_shaders()
-    elif command in ("patch", "update", "apply"):
-        logger.info("Patching shaders into blueprints...")
-        patch_shaders()
-    else:
-        logger.info(__doc__)
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()

blueprints/Image Channels.json

@@ -1 +0,0 @@
-{"revision": 0, "last_node_id": 29, "last_link_id": 0, "nodes": [{"id": 29, "type": "4c9d6ea4-b912-40e5-8766-6793a9758c53", "pos": [1970, -230], "size": [180, 86], "flags": {}, "order": 5, "mode": 0, "inputs": [{"label": "image", "localized_name": "images.image0", "name": "images.image0", "type": "IMAGE", "link": null}], "outputs": [{"label": "R", "localized_name": "IMAGE0", "name": "IMAGE0", "type": "IMAGE", "links": []}, {"label": "G", "localized_name": "IMAGE1", "name": "IMAGE1", "type": "IMAGE", "links": []}, {"label": "B", "localized_name": "IMAGE2", "name": "IMAGE2", "type": "IMAGE", "links": []}, {"label": "A", "localized_name": "IMAGE3", "name": "IMAGE3", "type": "IMAGE", "links": []}], "title": "Image Channels", "properties": {"proxyWidgets": []}, "widgets_values": []}], "links": [], "version": 0.4, "definitions": {"subgraphs": [{"id": "4c9d6ea4-b912-40e5-8766-6793a9758c53", "version": 1, "state": {"lastGroupId": 0, "lastNodeId": 28, "lastLinkId": 39, "lastRerouteId": 0}, "revision": 0, "config": {}, "name": "Image Channels", "inputNode": {"id": -10, "bounding": [1820, -185, 120, 60]}, "outputNode": {"id": -20, "bounding": [2460, -215, 120, 120]}, "inputs": [{"id": "3522932b-2d86-4a1f-a02a-cb29f3a9d7fe", "name": "images.image0", "type": "IMAGE", "linkIds": [39], "localized_name": "images.image0", "label": "image", "pos": [1920, -165]}], "outputs": [{"id": "605cb9c3-b065-4d9b-81d2-3ec331889b2b", "name": "IMAGE0", "type": "IMAGE", "linkIds": [26], "localized_name": "IMAGE0", "label": "R", "pos": [2480, -195]}, {"id": "fb44a77e-0522-43e9-9527-82e7465b3596", "name": "IMAGE1", "type": "IMAGE", "linkIds": [27], "localized_name": "IMAGE1", "label": "G", "pos": [2480, -175]}, {"id": "81460ee6-0131-402a-874f-6bf3001fc4ff", "name": "IMAGE2", "type": "IMAGE", "linkIds": [28], "localized_name": "IMAGE2", "label": "B", "pos": [2480, -155]}, {"id": "ae690246-80d4-4951-b1d9-9306d8a77417", "name": "IMAGE3", "type": "IMAGE", "linkIds": [29], "localized_name": "IMAGE3", "label": "A", "pos": [2480, -135]}], "widgets": [], "nodes": [{"id": 23, "type": "GLSLShader", "pos": [2000, -330], "size": [400, 172], "flags": {}, "order": 0, "mode": 0, "inputs": [{"label": "image", "localized_name": "images.image0", "name": "images.image0", "type": "IMAGE", "link": 39}, {"localized_name": "fragment_shader", "name": "fragment_shader", "type": "STRING", "widget": {"name": "fragment_shader"}, "link": null}, {"localized_name": "size_mode", "name": "size_mode", "type": "COMFY_DYNAMICCOMBO_V3", "widget": {"name": "size_mode"}, "link": null}, {"label": "image1", "localized_name": "images.image1", "name": "images.image1", "shape": 7, "type": "IMAGE", "link": null}], "outputs": [{"label": "R", "localized_name": "IMAGE0", "name": "IMAGE0", "type": "IMAGE", "links": [26]}, {"label": "G", "localized_name": "IMAGE1", "name": "IMAGE1", "type": "IMAGE", "links": [27]}, {"label": "B", "localized_name": "IMAGE2", "name": "IMAGE2", "type": "IMAGE", "links": [28]}, {"label": "A", "localized_name": "IMAGE3", "name": "IMAGE3", "type": "IMAGE", "links": [29]}], "properties": {"Node name for S&R": "GLSLShader"}, "widgets_values": ["#version 300 es\nprecision highp float;\n\nuniform sampler2D u_image0;\n\nin vec2 v_texCoord;\nlayout(location = 0) out vec4 fragColor0;\nlayout(location = 1) out vec4 fragColor1;\nlayout(location = 2) out vec4 fragColor2;\nlayout(location = 3) out vec4 fragColor3;\n\nvoid main() {\n  vec4 color = texture(u_image0, v_texCoord);\n  // Output each channel as grayscale to separate render targets\n  fragColor0 = vec4(vec3(color.r), 1.0);  // Red channel\n  fragColor1 = vec4(vec3(color.g), 1.0);  // Green channel\n  fragColor2 = vec4(vec3(color.b), 1.0);  // Blue channel\n  fragColor3 = vec4(vec3(color.a), 1.0);  // Alpha channel\n}\n", "from_input"]}], "groups": [], "links": [{"id": 39, "origin_id": -10, "origin_slot": 0, "target_id": 23, "target_slot": 0, "type": "IMAGE"}, {"id": 26, "origin_id": 23, "origin_slot": 0, "target_id": -20, "target_slot": 0, "type": "IMAGE"}, {"id": 27, "origin_id": 23, "origin_slot": 1, "target_id": -20, "target_slot": 1, "type": "IMAGE"}, {"id": 28, "origin_id": 23, "origin_slot": 2, "target_id": -20, "target_slot": 2, "type": "IMAGE"}, {"id": 29, "origin_id": 23, "origin_slot": 3, "target_id": -20, "target_slot": 3, "type": "IMAGE"}], "extra": {"workflowRendererVersion": "LG"}, "category": "Image Tools/Color adjust"}]}}

blueprints/Prompt Enhance.json

@@ -1 +0,0 @@
-{"revision": 0, "last_node_id": 15, "last_link_id": 0, "nodes": [{"id": 15, "type": "24d8bbfd-39d4-4774-bff0-3de40cc7a471", "pos": [-1490, 2040], "size": [400, 260], "flags": {}, "order": 0, "mode": 0, "inputs": [{"name": "prompt", "type": "STRING", "widget": {"name": "prompt"}, "link": null}, {"label": "reference images", "name": "images", "type": "IMAGE", "link": null}], "outputs": [{"name": "STRING", "type": "STRING", "links": null}], "title": "Prompt Enhance", "properties": {"proxyWidgets": [["-1", "prompt"]], "cnr_id": "comfy-core", "ver": "0.14.1"}, "widgets_values": [""]}], "links": [], "version": 0.4, "definitions": {"subgraphs": [{"id": "24d8bbfd-39d4-4774-bff0-3de40cc7a471", "version": 1, "state": {"lastGroupId": 0, "lastNodeId": 15, "lastLinkId": 14, "lastRerouteId": 0}, "revision": 0, "config": {}, "name": "Prompt Enhance", "inputNode": {"id": -10, "bounding": [-2170, 2110, 138.876953125, 80]}, "outputNode": {"id": -20, "bounding": [-640, 2110, 120, 60]}, "inputs": [{"id": "aeab7216-00e0-4528-a09b-bba50845c5a6", "name": "prompt", "type": "STRING", "linkIds": [11], "pos": [-2051.123046875, 2130]}, {"id": "7b73fd36-aa31-4771-9066-f6c83879994b", "name": "images", "type": "IMAGE", "linkIds": [14], "label": "reference images", "pos": [-2051.123046875, 2150]}], "outputs": [{"id": "c7b0d930-68a1-48d1-b496-0519e5837064", "name": "STRING", "type": "STRING", "linkIds": [13], "pos": [-620, 2130]}], "widgets": [], "nodes": [{"id": 11, "type": "GeminiNode", "pos": [-1560, 1990], "size": [470, 470], "flags": {}, "order": 0, "mode": 0, "inputs": [{"localized_name": "images", "name": "images", "shape": 7, "type": "IMAGE", "link": 14}, {"localized_name": "audio", "name": "audio", "shape": 7, "type": "AUDIO", "link": null}, {"localized_name": "video", "name": "video", "shape": 7, "type": "VIDEO", "link": null}, {"localized_name": "files", "name": "files", "shape": 7, "type": "GEMINI_INPUT_FILES", "link": null}, {"localized_name": "prompt", "name": "prompt", "type": "STRING", "widget": {"name": "prompt"}, "link": 11}, {"localized_name": "model", "name": "model", "type": "COMBO", "widget": {"name": "model"}, "link": null}, {"localized_name": "seed", "name": "seed", "type": "INT", "widget": {"name": "seed"}, "link": null}, {"localized_name": "system_prompt", "name": "system_prompt", "shape": 7, "type": "STRING", "widget": {"name": "system_prompt"}, "link": null}], "outputs": [{"localized_name": "STRING", "name": "STRING", "type": "STRING", "links": [13]}], "properties": {"cnr_id": "comfy-core", "ver": "0.14.1", "Node name for S&R": "GeminiNode"}, "widgets_values": ["", "gemini-3-pro-preview", 42, "randomize", "You are an expert in prompt writing.\nBased on the input, rewrite the user's input into a detailed prompt.\nincluding camera settings, lighting, composition, and style.\nReturn the prompt only"], "color": "#432", "bgcolor": "#653"}], "groups": [], "links": [{"id": 11, "origin_id": -10, "origin_slot": 0, "target_id": 11, "target_slot": 4, "type": "STRING"}, {"id": 13, "origin_id": 11, "origin_slot": 0, "target_id": -20, "target_slot": 0, "type": "STRING"}, {"id": 14, "origin_id": -10, "origin_slot": 1, "target_id": 11, "target_slot": 0, "type": "IMAGE"}], "extra": {"workflowRendererVersion": "LG"}, "category": "Text generation/Prompt enhance"}]}, "extra": {}}

blueprints/Sharpen.json

@@ -1 +0,0 @@
-{"revision": 0, "last_node_id": 25, "last_link_id": 0, "nodes": [{"id": 25, "type": "621ba4e2-22a8-482d-a369-023753198b7b", "pos": [4610, -790], "size": [230, 58], "flags": {}, "order": 4, "mode": 0, "inputs": [{"label": "image", "localized_name": "images.image0", "name": "images.image0", "type": "IMAGE", "link": null}], "outputs": [{"label": "IMAGE", "localized_name": "IMAGE0", "name": "IMAGE0", "type": "IMAGE", "links": []}], "title": "Sharpen", "properties": {"proxyWidgets": [["24", "value"]]}, "widgets_values": []}], "links": [], "version": 0.4, "definitions": {"subgraphs": [{"id": "621ba4e2-22a8-482d-a369-023753198b7b", "version": 1, "state": {"lastGroupId": 0, "lastNodeId": 24, "lastLinkId": 36, "lastRerouteId": 0}, "revision": 0, "config": {}, "name": "Sharpen", "inputNode": {"id": -10, "bounding": [4090, -825, 120, 60]}, "outputNode": {"id": -20, "bounding": [5150, -825, 120, 60]}, "inputs": [{"id": "37011fb7-14b7-4e0e-b1a0-6a02e8da1fd7", "name": "images.image0", "type": "IMAGE", "linkIds": [34], "localized_name": "images.image0", "label": "image", "pos": [4190, -805]}], "outputs": [{"id": "e9182b3f-635c-4cd4-a152-4b4be17ae4b9", "name": "IMAGE0", "type": "IMAGE", "linkIds": [35], "localized_name": "IMAGE0", "label": "IMAGE", "pos": [5170, -805]}], "widgets": [], "nodes": [{"id": 24, "type": "PrimitiveFloat", "pos": [4280, -1240], "size": [270, 58], "flags": {}, "order": 0, "mode": 0, "inputs": [{"label": "strength", "localized_name": "value", "name": "value", "type": "FLOAT", "widget": {"name": "value"}, "link": null}], "outputs": [{"localized_name": "FLOAT", "name": "FLOAT", "type": "FLOAT", "links": [36]}], "properties": {"Node name for S&R": "PrimitiveFloat", "min": 0, "max": 3, "precision": 2, "step": 0.05}, "widgets_values": [0.5]}, {"id": 23, "type": "GLSLShader", "pos": [4570, -1240], "size": [370, 192], "flags": {}, "order": 1, "mode": 0, "inputs": [{"label": "image0", "localized_name": "images.image0", "name": "images.image0", "type": "IMAGE", "link": 34}, {"label": "image1", "localized_name": "images.image1", "name": "images.image1", "shape": 7, "type": "IMAGE", "link": null}, {"label": "u_float0", "localized_name": "floats.u_float0", "name": "floats.u_float0", "shape": 7, "type": "FLOAT", "link": 36}, {"label": "u_float1", "localized_name": "floats.u_float1", "name": "floats.u_float1", "shape": 7, "type": "FLOAT", "link": null}, {"label": "u_int0", "localized_name": "ints.u_int0", "name": "ints.u_int0", "shape": 7, "type": "INT", "link": null}, {"localized_name": "fragment_shader", "name": "fragment_shader", "type": "STRING", "widget": {"name": "fragment_shader"}, "link": null}, {"localized_name": "size_mode", "name": "size_mode", "type": "COMFY_DYNAMICCOMBO_V3", "widget": {"name": "size_mode"}, "link": null}], "outputs": [{"localized_name": "IMAGE0", "name": "IMAGE0", "type": "IMAGE", "links": [35]}, {"localized_name": "IMAGE1", "name": "IMAGE1", "type": "IMAGE", "links": null}, {"localized_name": "IMAGE2", "name": "IMAGE2", "type": "IMAGE", "links": null}, {"localized_name": "IMAGE3", "name": "IMAGE3", "type": "IMAGE", "links": null}], "properties": {"Node name for S&R": "GLSLShader"}, "widgets_values": ["#version 300 es\nprecision highp float;\n\nuniform sampler2D u_image0;\nuniform vec2 u_resolution;\nuniform float u_float0;  // strength [0.0 – 2.0] typical: 0.3–1.0\n\nin vec2 v_texCoord;\nlayout(location = 0) out vec4 fragColor0;\n\nvoid main() {\n    vec2 texel = 1.0 / u_resolution;\n    \n    // Sample center and neighbors\n    vec4 center = texture(u_image0, v_texCoord);\n    vec4 top    = texture(u_image0, v_texCoord + vec2( 0.0, -texel.y));\n    vec4 bottom = texture(u_image0, v_texCoord + vec2( 0.0,  texel.y));\n    vec4 left   = texture(u_image0, v_texCoord + vec2(-texel.x,  0.0));\n    vec4 right  = texture(u_image0, v_texCoord + vec2( texel.x,  0.0));\n    \n    // Edge enhancement (Laplacian)\n    vec4 edges = center * 4.0 - top - bottom - left - right;\n    \n    // Add edges back scaled by strength\n    vec4 sharpened = center + edges * u_float0;\n    \n    fragColor0 = vec4(clamp(sharpened.rgb, 0.0, 1.0), center.a);\n}", "from_input"]}], "groups": [], "links": [{"id": 36, "origin_id": 24, "origin_slot": 0, "target_id": 23, "target_slot": 2, "type": "FLOAT"}, {"id": 34, "origin_id": -10, "origin_slot": 0, "target_id": 23, "target_slot": 0, "type": "IMAGE"}, {"id": 35, "origin_id": 23, "origin_slot": 0, "target_id": -20, "target_slot": 0, "type": "IMAGE"}], "extra": {"workflowRendererVersion": "LG"}, "category": "Image Tools/Sharpen"}]}}

blueprints/Video Upscale(GAN x4).json

@@ -1 +0,0 @@
-{"revision": 0, "last_node_id": 13, "last_link_id": 0, "nodes": [{"id": 13, "type": "cf95b747-3e17-46cb-8097-cac60ff9b2e1", "pos": [1120, 330], "size": [240, 58], "flags": {}, "order": 3, "mode": 0, "inputs": [{"localized_name": "video", "name": "video", "type": "VIDEO", "link": null}, {"name": "model_name", "type": "COMBO", "widget": {"name": "model_name"}, "link": null}], "outputs": [{"localized_name": "VIDEO", "name": "VIDEO", "type": "VIDEO", "links": []}], "title": "Video Upscale(GAN x4)", "properties": {"proxyWidgets": [["-1", "model_name"]], "cnr_id": "comfy-core", "ver": "0.14.1"}, "widgets_values": ["RealESRGAN_x4plus.safetensors"]}], "links": [], "version": 0.4, "definitions": {"subgraphs": [{"id": "cf95b747-3e17-46cb-8097-cac60ff9b2e1", "version": 1, "state": {"lastGroupId": 0, "lastNodeId": 13, "lastLinkId": 19, "lastRerouteId": 0}, "revision": 0, "config": {}, "name": "Video Upscale(GAN x4)", "inputNode": {"id": -10, "bounding": [550, 460, 120, 80]}, "outputNode": {"id": -20, "bounding": [1490, 460, 120, 60]}, "inputs": [{"id": "666d633e-93e7-42dc-8d11-2b7b99b0f2a6", "name": "video", "type": "VIDEO", "linkIds": [10], "localized_name": "video", "pos": [650, 480]}, {"id": "2e23a087-caa8-4d65-99e6-662761aa905a", "name": "model_name", "type": "COMBO", "linkIds": [19], "pos": [650, 500]}], "outputs": [{"id": "0c1768ea-3ec2-412f-9af6-8e0fa36dae70", "name": "VIDEO", "type": "VIDEO", "linkIds": [15], "localized_name": "VIDEO", "pos": [1510, 480]}], "widgets": [], "nodes": [{"id": 2, "type": "ImageUpscaleWithModel", "pos": [1110, 450], "size": [320, 46], "flags": {}, "order": 1, "mode": 0, "inputs": [{"localized_name": "upscale_model", "name": "upscale_model", "type": "UPSCALE_MODEL", "link": 1}, {"localized_name": "image", "name": "image", "type": "IMAGE", "link": 14}], "outputs": [{"localized_name": "IMAGE", "name": "IMAGE", "type": "IMAGE", "links": [13]}], "properties": {"cnr_id": "comfy-core", "ver": "0.10.0", "Node name for S&R": "ImageUpscaleWithModel"}}, {"id": 11, "type": "CreateVideo", "pos": [1110, 550], "size": [320, 78], "flags": {}, "order": 3, "mode": 0, "inputs": [{"localized_name": "images", "name": "images", "type": "IMAGE", "link": 13}, {"localized_name": "audio", "name": "audio", "shape": 7, "type": "AUDIO", "link": 16}, {"localized_name": "fps", "name": "fps", "type": "FLOAT", "widget": {"name": "fps"}, "link": 12}], "outputs": [{"localized_name": "VIDEO", "name": "VIDEO", "type": "VIDEO", "links": [15]}], "properties": {"cnr_id": "comfy-core", "ver": "0.10.0", "Node name for S&R": "CreateVideo"}, "widgets_values": [30]}, {"id": 10, "type": "GetVideoComponents", "pos": [1110, 330], "size": [320, 70], "flags": {}, "order": 2, "mode": 0, "inputs": [{"localized_name": "video", "name": "video", "type": "VIDEO", "link": 10}], "outputs": [{"localized_name": "images", "name": "images", "type": "IMAGE", "links": [14]}, {"localized_name": "audio", "name": "audio", "type": "AUDIO", "links": [16]}, {"localized_name": "fps", "name": "fps", "type": "FLOAT", "links": [12]}], "properties": {"cnr_id": "comfy-core", "ver": "0.10.0", "Node name for S&R": "GetVideoComponents"}}, {"id": 1, "type": "UpscaleModelLoader", "pos": [750, 450], "size": [280, 60], "flags": {}, "order": 0, "mode": 0, "inputs": [{"localized_name": "model_name", "name": "model_name", "type": "COMBO", "widget": {"name": "model_name"}, "link": 19}], "outputs": [{"localized_name": "UPSCALE_MODEL", "name": "UPSCALE_MODEL", "type": "UPSCALE_MODEL", "links": [1]}], "properties": {"cnr_id": "comfy-core", "ver": "0.10.0", "Node name for S&R": "UpscaleModelLoader", "models": [{"name": "RealESRGAN_x4plus.safetensors", "url": "https://huggingface.co/Comfy-Org/Real-ESRGAN_repackaged/resolve/main/RealESRGAN_x4plus.safetensors", "directory": "upscale_models"}]}, "widgets_values": ["RealESRGAN_x4plus.safetensors"]}], "groups": [], "links": [{"id": 1, "origin_id": 1, "origin_slot": 0, "target_id": 2, "target_slot": 0, "type": "UPSCALE_MODEL"}, {"id": 14, "origin_id": 10, "origin_slot": 0, "target_id": 2, "target_slot": 1, "type": "IMAGE"}, {"id": 13, "origin_id": 2, "origin_slot": 0, "target_id": 11, "target_slot": 0, "type": "IMAGE"}, {"id": 16, "origin_id": 10, "origin_slot": 1, "target_id": 11, "target_slot": 1, "type": "AUDIO"}, {"id": 12, "origin_id": 10, "origin_slot": 2, "target_id": 11, "target_slot": 2, "type": "FLOAT"}, {"id": 10, "origin_id": -10, "origin_slot": 0, "target_id": 10, "target_slot": 0, "type": "VIDEO"}, {"id": 15, "origin_id": 11, "origin_slot": 0, "target_id": -20, "target_slot": 0, "type": "VIDEO"}, {"id": 19, "origin_id": -10, "origin_slot": 1, "target_id": 1, "target_slot": 0, "type": "COMBO"}], "extra": {"workflowRendererVersion": "LG"}, "category": "Video generation and editing/Enhance video"}]}, "extra": {}}

comfy/audio_encoders/audio_encoders.py

@@ -27,7 +27,6 @@ class AudioEncoderModel():
         self.model.eval()
         self.patcher = comfy.model_patcher.CoreModelPatcher(self.model, load_device=self.load_device, offload_device=offload_device)
         self.model_sample_rate = 16000
-        comfy.model_management.archive_model_dtypes(self.model)
 
     def load_sd(self, sd):
         return self.model.load_state_dict(sd, strict=False, assign=self.patcher.is_dynamic())

comfy/checkpoint_pickle.py

@@ -0,0 +1,13 @@
+import pickle
+
+load = pickle.load
+
+class Empty:
+    pass
+
+class Unpickler(pickle.Unpickler):
+    def find_class(self, module, name):
+        #TODO: safe unpickle
+        if module.startswith("pytorch_lightning"):
+            return Empty
+        return super().find_class(module, name)

comfy/cli_args.py

@@ -83,8 +83,6 @@ fpte_group.add_argument("--fp16-text-enc", action="store_true", help="Store text
 fpte_group.add_argument("--fp32-text-enc", action="store_true", help="Store text encoder weights in fp32.")
 fpte_group.add_argument("--bf16-text-enc", action="store_true", help="Store text encoder weights in bf16.")
 
-parser.add_argument("--fp16-intermediates", action="store_true", help="Experimental: Use fp16 for intermediate tensors between nodes instead of fp32.")
-
 parser.add_argument("--force-channels-last", action="store_true", help="Force channels last format when inferencing the models.")
 
 parser.add_argument("--directml", type=int, nargs="?", metavar="DIRECTML_DEVICE", const=-1, help="Use torch-directml.")
@@ -110,13 +108,11 @@ parser.add_argument("--preview-method", type=LatentPreviewMethod, default=Latent
 
 parser.add_argument("--preview-size", type=int, default=512, help="Sets the maximum preview size for sampler nodes.")
 
-CACHE_RAM_AUTO_GB = -1.0
-
 cache_group = parser.add_mutually_exclusive_group()
 cache_group.add_argument("--cache-classic", action="store_true", help="Use the old style (aggressive) caching.")
 cache_group.add_argument("--cache-lru", type=int, default=0, help="Use LRU caching with a maximum of N node results cached. May use more RAM/VRAM.")
 cache_group.add_argument("--cache-none", action="store_true", help="Reduced RAM/VRAM usage at the expense of executing every node for each run.")
-cache_group.add_argument("--cache-ram", nargs='?', const=CACHE_RAM_AUTO_GB, type=float, default=0, help="Use RAM pressure caching with the specified headroom threshold. If available RAM drops below the threshold the cache removes large items to free RAM. Default (when no value is provided): 25%% of system RAM (min 4GB, max 32GB).")
+cache_group.add_argument("--cache-ram", nargs='?', const=4.0, type=float, default=0, help="Use RAM pressure caching with the specified headroom threshold. If available RAM drops below the threhold the cache remove large items to free RAM. Default 4GB")
 
 attn_group = parser.add_mutually_exclusive_group()
 attn_group.add_argument("--use-split-cross-attention", action="store_true", help="Use the split cross attention optimization. Ignored when xformers is used.")
@@ -150,8 +146,6 @@ parser.add_argument("--reserve-vram", type=float, default=None, help="Set the am
 
 parser.add_argument("--async-offload", nargs='?', const=2, type=int, default=None, metavar="NUM_STREAMS", help="Use async weight offloading. An optional argument controls the amount of offload streams. Default is 2. Enabled by default on Nvidia.")
 parser.add_argument("--disable-async-offload", action="store_true", help="Disable async weight offloading.")
-parser.add_argument("--disable-dynamic-vram", action="store_true", help="Disable dynamic VRAM and use estimate based model loading.")
-parser.add_argument("--enable-dynamic-vram", action="store_true", help="Enable dynamic VRAM on systems where it's not enabled by default.")
 
 parser.add_argument("--force-non-blocking", action="store_true", help="Force ComfyUI to use non-blocking operations for all applicable tensors. This may improve performance on some non-Nvidia systems but can cause issues with some workflows.")
 
@@ -165,6 +159,7 @@ class PerformanceFeature(enum.Enum):
     Fp8MatrixMultiplication = "fp8_matrix_mult"
     CublasOps = "cublas_ops"
     AutoTune = "autotune"
+    DynamicVRAM = "dynamic_vram"
 
 parser.add_argument("--fast", nargs="*", type=PerformanceFeature, help="Enable some untested and potentially quality deteriorating optimizations. This is used to test new features so using it might crash your comfyui. --fast with no arguments enables everything. You can pass a list specific optimizations if you only want to enable specific ones. Current valid optimizations: {}".format(" ".join(map(lambda c: c.value, PerformanceFeature))))
 
@@ -237,7 +232,7 @@ database_default_path = os.path.abspath(
     os.path.join(os.path.dirname(__file__), "..", "user", "comfyui.db")
 )
 parser.add_argument("--database-url", type=str, default=f"sqlite:///{database_default_path}", help="Specify the database URL, e.g. for an in-memory database you can use 'sqlite:///:memory:'.")
-parser.add_argument("--enable-assets", action="store_true", help="Enable the assets system (API routes, database synchronization, and background scanning).")
+parser.add_argument("--disable-assets-autoscan", action="store_true", help="Disable asset scanning on startup for database synchronization.")
 
 if comfy.options.args_parsing:
     args = parser.parse_args()
@@ -265,6 +260,4 @@ else:
     args.fast = set(args.fast)
 
 def enables_dynamic_vram():
-    if args.enable_dynamic_vram:
-        return True
-    return not args.disable_dynamic_vram and not args.highvram and not args.gpu_only and not args.novram and not args.cpu
+    return PerformanceFeature.DynamicVRAM in args.fast and not args.highvram and not args.gpu_only

comfy/comfy_types/node_typing.py

@@ -176,8 +176,6 @@ class InputTypeOptions(TypedDict):
     """COMBO type only. Specifies the configuration for a multi-select widget.
     Available after ComfyUI frontend v1.13.4
     https://github.com/Comfy-Org/ComfyUI_frontend/pull/2987"""
-    gradient_stops: NotRequired[list[dict]]
-    """Gradient color stops for gradientslider display mode. Each stop is {"offset": float, "color": [r, g, b]}."""
 
 
 class HiddenInputTypeDict(TypedDict):

comfy/conds.py

@@ -4,25 +4,6 @@ import comfy.utils
 import logging
 
 
-def is_equal(x, y):
-    if torch.is_tensor(x) and torch.is_tensor(y):
-        return torch.equal(x, y)
-    elif isinstance(x, dict) and isinstance(y, dict):
-        if x.keys() != y.keys():
-            return False
-        return all(is_equal(x[k], y[k]) for k in x)
-    elif isinstance(x, (list, tuple)) and isinstance(y, (list, tuple)):
-        if type(x) is not type(y) or len(x) != len(y):
-            return False
-        return all(is_equal(a, b) for a, b in zip(x, y))
-    else:
-        try:
-            return x == y
-        except Exception:
-            logging.warning("comparison issue with COND")
-            return False
-
-
 class CONDRegular:
     def __init__(self, cond):
         self.cond = cond
@@ -103,7 +84,7 @@ class CONDConstant(CONDRegular):
         return self._copy_with(self.cond)
 
     def can_concat(self, other):
-        if not is_equal(self.cond, other.cond):
+        if self.cond != other.cond:
             return False
         return True