Migrate to PostgreSQL and add Config Status page

.gitignore

@@ -3,3 +3,4 @@
 .kilocode/
 *.pyc
 __pycache__/
+data/

MIGRATION.md

@@ -0,0 +1,63 @@
+# Database Migration Guide
+
+This guide outlines the offline workflow to migrate your `meal_planner` data from SQLite to PostgreSQL.
+
+## Prerequisites
+- Docker Compose installed.
+- The application running (or capable of running) via `docker-compose`.
+
+## Migration Steps
+
+### 1. Backup your SQLite Database
+First, create a safety copy of your current database.
+```bash
+cp data/meal_planner.db meal_planner_backup.db
+```
+
+### 2. Stop the Application
+Stop the running application container to ensure no new data is written.
+```bash
+docker-compose stop foodtracker
+```
+
+### 3. Start PostgreSQL
+Ensure the new PostgreSQL service is running.
+```bash
+docker-compose up -d postgres
+```
+
+### 4. Run the Migration
+Use a temporary container to run the migration script. We mount your backup file and connect to the postgres service.
+```bash
+# Syntax: python migrate_to_postgres.py --sqlite-path <path_to_db> --pg-url <postgres_url>
+
+docker-compose run --rm \
+  -v $(pwd)/meal_planner_backup.db:/backup.db \
+  -v $(pwd)/migrate_to_postgres.py:/app/migrate_to_postgres.py \
+  foodtracker \
+  python migrate_to_postgres.py \
+  --sqlite-path /backup.db \
+  --pg-url postgresql://user:password@postgres/meal_planner
+```
+
+### 5. Update Configuration
+Edit `docker-compose.yml` to switch the active database.
+1. Comment out the SQLite `DATABASE_URL`.
+2. Uncomment the PostgreSQL `DATABASE_URL`.
+
+```yaml
+    environment:
+      # - DATABASE_URL=sqlite:////app/data/meal_planner.db
+      - DATABASE_URL=postgresql://user:password@postgres/meal_planner
+```
+
+### 6. Restart the Application
+Rebuild and start the application to use the new database.
+```bash
+docker-compose up -d --build foodtracker
+```
+
+## Verification
+1. Log in to the application.
+2. Verify your Foods, Meals, and Plans are present.
+3. Check `docker logs foodplanner-foodtracker-1` to ensure no database connection errors.

alembic/env.py

@@ -1,11 +1,17 @@
 from logging.config import fileConfig
 import logging
 import os
+import sys
 from sqlalchemy import engine_from_config
 from sqlalchemy import pool
 
 from alembic import context
 
+# Add the project root to the Python path
+sys.path.insert(0, os.path.realpath(os.path.join(os.path.dirname(__file__), '..')))
+
+from app.database import Base
+
 # this is the Alembic Config object, which provides
 # access to the values within the .ini file in use.
 config = context.config
@@ -17,9 +23,7 @@ if config.config_file_name is not None:
 
 # add your model's MetaData object here
 # for 'autogenerate' support
-# We create an empty metadata object since we're not using autogenerate
-# and we have explicit migration files
-target_metadata = None
+target_metadata = Base.metadata
 
 # other values from the config, defined by the needs of env.py,
 # can be acquired:
@@ -43,7 +47,7 @@ def run_migrations_offline() -> None:
     url = os.getenv('DATABASE_URL', config.get_main_option("sqlalchemy.url"))
     context.configure(
         url=url,
-        target_metadata=None,
+        target_metadata=target_metadata,
         literal_binds=True,
         dialect_opts={"paramstyle": "named"},
     )
@@ -72,7 +76,7 @@ def run_migrations_online() -> None:
     with connectable.connect() as connection:
         logging.info("DEBUG: Database connection established for alembic")
         context.configure(
-            connection=connection, target_metadata=None
+            connection=connection, target_metadata=target_metadata
         )
         logging.info("DEBUG: Alembic context configured")
 

alembic/versions/13939361fc35_data_migration_to_convert_serving_size_.py

@@ -0,0 +1,76 @@
+"""Data migration to convert serving_size to float
+
+Revision ID: 13939361fc35
+Revises: a11a3921f528
+Create Date: 2025-10-01 23:44:34.144506
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = '13939361fc35'
+down_revision: Union[str, None] = 'a11a3921f528'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """
+    Data migration to convert existing string-based 'serving_size' values to floats.
+    This version uses a session to iterate through the data, providing more robust error handling.
+    """
+    bind = op.get_bind()
+    from sqlalchemy.orm import sessionmaker
+    Session = sessionmaker(bind=bind)
+    session = Session()
+
+    # Define a simple table structure for our purpose
+    food_table = sa.Table('foods', sa.MetaData(),
+        sa.Column('id', sa.Integer, primary_key=True),
+        sa.Column('name', sa.String),
+        sa.Column('serving_size', sa.String)  # Treat it as String to be safe
+    )
+
+    try:
+        foods_to_update = session.query(food_table).all()
+        updated_count = 0
+        
+        for food in foods_to_update:
+            # Check if serving_size is a string and needs conversion
+            if isinstance(food.serving_size, str):
+                try:
+                    new_size = float(food.serving_size)
+                    # Use session.execute for the update
+                    session.execute(
+                        food_table.update().
+                        where(food_table.c.id == food.id).
+                        values(serving_size=new_size)
+                    )
+                    updated_count += 1
+                except (ValueError, TypeError):
+                    print(f"Could not convert serving_size for Food ID {food.id} (Name: {food.name}). Value: '{food.serving_size}'")
+
+        if updated_count > 0:
+            session.commit()
+            print(f"Successfully converted {updated_count} food items.")
+        else:
+            print("No food items required an update.")
+
+    except Exception as e:
+        print(f"An error occurred during the data migration: {e}")
+        session.rollback()
+    finally:
+        session.close()
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    # A downgrade for this data migration is not practical as it would require
+    # converting floats back to strings, which could lead to loss of precision.
+    # It is better to back up the database before upgrading.
+    pass
+    # ### end Alembic commands ###

alembic/versions/2295851db11e_change_food_serving_size_to_float_and_.py

@@ -0,0 +1,38 @@
+"""Change Food.serving_size to Float and Pydantic models
+
+Revision ID: 2295851db11e
+Revises: cf94fca21104
+Create Date: 2025-10-01 11:24:54.801648
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = '2295851db11e'
+down_revision = 'cf94fca21104'
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table('foods', schema=None) as batch_op:
+        batch_op.alter_column('serving_size',
+               existing_type=sa.VARCHAR(),
+               type_=sa.Float(),
+               existing_nullable=True)
+
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table('foods', schema=None) as batch_op:
+        batch_op.alter_column('serving_size',
+               existing_type=sa.Float(),
+               type_=sa.VARCHAR(),
+               existing_nullable=True)
+
+    # ### end Alembic commands ###

alembic/versions/2498205b9e48_add_is_deleted_to_trackedmealfood.py

@@ -0,0 +1,30 @@
+"""Add is_deleted to TrackedMealFood
+
+Revision ID: 2498205b9e48
+Revises: d0c142fbf0b0
+Create Date: 2025-10-02 13:22:15.674346
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = '2498205b9e48'
+down_revision: Union[str, None] = 'd0c142fbf0b0'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.add_column('tracked_meal_foods', sa.Column('is_deleted', sa.Boolean(), nullable=True, server_default='0'))
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_column('tracked_meal_foods', 'is_deleted')
+    # ### end Alembic commands ###

alembic/versions/31fdce040eea_snapshot_existing_meals.py

@@ -0,0 +1,101 @@
+"""snapshot_existing_meals
+
+Revision ID: 31fdce040eea
+Revises: 4522e2de4143
+Create Date: 2026-01-10 13:30:49.977264
+
+"""
+from typing import Sequence, Union
+from sqlalchemy import orm, text
+from app.database import Base
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = '31fdce040eea'
+down_revision: Union[str, None] = '4522e2de4143'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+    session = orm.Session(bind=bind)
+
+    # Use reflection or raw SQL to avoid importing app models directly
+    # This ensures the migration remains valid even if app models change later
+    
+    # 1. Get all tracked meals that are NOT already snapshots
+    # We join tracked_meals with meals to check the meal_type
+    sql = text("""
+        SELECT tm.id as tracked_meal_id, tm.meal_id, m.name, m.meal_time
+        FROM tracked_meals tm
+        JOIN meals m ON tm.meal_id = m.id
+        WHERE m.meal_type != 'tracked_snapshot'
+    """)
+    
+    tracked_meals_to_snapshot = session.execute(sql).fetchall()
+    
+    print(f"Found {len(tracked_meals_to_snapshot)} tracked meals to snapshot.")
+    
+    for row in tracked_meals_to_snapshot:
+        tm_id = row.tracked_meal_id
+        original_meal_id = row.meal_id
+        original_name = row.name
+        original_meal_time = row.meal_time
+        
+        # 2. Create a new snapshot meal
+        # We can't easily use ORM since we don't have the classes, so we use raw SQL
+        insert_meal_sql = text("""
+            INSERT INTO meals (name, meal_type, meal_time)
+            VALUES (:name, 'tracked_snapshot', :meal_time)
+        """)
+        
+        # execution_options={"autocommit": True} might be needed for some drivers, 
+        # but session.execute usually handles it. 
+        # For SQLite, we can get the last inserted id via cursor, but SQLAlchemy does this via result.lastrowid
+        
+        result = session.execute(insert_meal_sql, {
+            "name": original_name, 
+            "meal_time": original_meal_time
+        })
+        new_meal_id = result.lastrowid
+        
+        # 3. Copy ingredients from original meal to new snapshot
+        # Get ingredients
+        get_foods_sql = text("""
+            SELECT food_id, quantity 
+            FROM meal_foods 
+            WHERE meal_id = :meal_id
+        """)
+        foods = session.execute(get_foods_sql, {"meal_id": original_meal_id}).fetchall()
+        
+        if foods:
+            insert_food_sql = text("""
+                INSERT INTO meal_foods (meal_id, food_id, quantity)
+                VALUES (:meal_id, :food_id, :quantity)
+            """)
+            
+            for food in foods:
+                session.execute(insert_food_sql, {
+                    "meal_id": new_meal_id,
+                    "food_id": food.food_id,
+                    "quantity": food.quantity
+                })
+        
+        # 4. Update the stored tracked_meal to point to the new snapshot
+        update_tm_sql = text("""
+            UPDATE tracked_meals
+            SET meal_id = :new_meal_id
+            WHERE id = :tm_id
+        """)
+        session.execute(update_tm_sql, {"new_meal_id": new_meal_id, "tm_id": tm_id})
+        
+    session.commit()
+
+
+
+def downgrade() -> None:
+    pass

alembic/versions/4522e2de4143_add_browserless_api_key_to_llm_config.py

@@ -0,0 +1,32 @@
+"""add browserless api key to llm config
+
+Revision ID: 4522e2de4143
+Revises: 882af51512ff
+Create Date: 2025-10-04 15:06:27.893934
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = '4522e2de4143'
+down_revision: Union[str, None] = '882af51512ff'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table('llm_configs', schema=None) as batch_op:
+        batch_op.add_column(sa.Column('browserless_api_key', sa.String(), nullable=True))
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table('llm_configs', schema=None) as batch_op:
+        batch_op.drop_column('browserless_api_key')
+    # ### end Alembic commands ###

alembic/versions/882af51512ff_add_llm_configs_table.py

@@ -0,0 +1,49 @@
+"""Add llm_configs table
+
+Revision ID: 882af51512ff
+Revises: 2498205b9e48
+Create Date: 2025-10-04 13:13:07.498772
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = '882af51512ff'
+down_revision: Union[str, None] = '2498205b9e48'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table('llm_configs',
+    sa.Column('id', sa.Integer(), nullable=False),
+    sa.Column('openrouter_api_key', sa.String(), nullable=True),
+    sa.Column('preferred_model', sa.String(), nullable=True),
+    sa.PrimaryKeyConstraint('id')
+    )
+    op.create_index(op.f('ix_llm_configs_id'), 'llm_configs', ['id'], unique=False)
+    op.drop_table('_litestream_seq')
+    op.drop_table('_litestream_lock')
+    op.drop_column('tracked_meals', 'quantity')
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.add_column('tracked_meals', sa.Column('quantity', sa.FLOAT(), nullable=True))
+    op.create_table('_litestream_lock',
+    sa.Column('id', sa.INTEGER(), nullable=True)
+    )
+    op.create_table('_litestream_seq',
+    sa.Column('id', sa.INTEGER(), nullable=True),
+    sa.Column('seq', sa.INTEGER(), nullable=True),
+    sa.PrimaryKeyConstraint('id')
+    )
+    op.drop_index(op.f('ix_llm_configs_id'), table_name='llm_configs')
+    op.drop_table('llm_configs')
+    # ### end Alembic commands ###

alembic/versions/a11a3921f528_document_quantity_standardization_to_.py

@@ -0,0 +1,70 @@
+"""Document quantity standardization: all quantity fields now represent grams
+
+Revision ID: a11a3921f528
+Revises: 2295851db11e
+Create Date: 2025-10-01 20:25:50.531913
+
+This migration documents the standardization of quantity handling across the application.
+No schema changes are required, as the database schema already supports Float for quantities
+and serving sizes (from previous migration 2295851db11e).
+
+Key Changes Documented:
+- All quantity fields (MealFood.quantity, TrackedMealFood.quantity) now explicitly represent
+  grams of the food item.
+- Food.serving_size represents the base serving size in grams.
+- Nutritional values for Food are per serving_size grams.
+- Nutrition calculations use: multiplier = quantity (grams) / serving_size (grams)
+
+Data Migration Assessment:
+- Queried existing MealFood entries: 154 total.
+- Quantities appear to be stored as grams (e.g., 120.0g for Egg with 50g serving, 350.0g for Black Tea).
+- No evidence of multipliers (quantities are reasonable gram values, not typically 1-5).
+- All Food.serving_size values are numeric (Floats), no strings detected.
+- No None values in core nutrients (calories, protein, carbs, fat).
+- Conclusion: No data conversion needed. Existing data aligns with the grams convention.
+- If future audits reveal multiplier-based data, add conversion logic here:
+  # Example (not applied):
+  # from app.database import Food, MealFood
+  # conn = op.get_bind()
+  # meal_foods = conn.execute(sa.text("SELECT mf.id, mf.quantity, mf.food_id FROM meal_foods mf")).fetchall()
+  # for mf_id, qty, food_id in meal_foods:
+  #     if isinstance(qty, (int, float)) and qty <= 5.0:  # Heuristic for potential multipliers
+  #         serving = conn.execute(sa.text("SELECT serving_size FROM foods WHERE id = :fid"), {"fid": food_id}).scalar()
+  #         if serving and serving > 0:
+  #             new_qty = qty * serving
+  #             conn.execute(sa.text("UPDATE meal_foods SET quantity = :nq WHERE id = :mid"), {"nq": new_qty, "mid": mf_id})
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = 'a11a3921f528'
+down_revision: Union[str, None] = '2295851db11e'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # SQLite does not support comments, so we check the dialect
+    bind = op.get_bind()
+    if bind.dialect.name == 'postgresql':
+        op.execute("COMMENT ON COLUMN meal_foods.quantity IS 'Quantity in grams of this food in the meal'")
+        op.execute("COMMENT ON COLUMN tracked_meal_foods.quantity IS 'Quantity in grams of this food as tracked'")
+        op.execute("COMMENT ON COLUMN foods.serving_size IS 'Base serving size in grams'")
+    # For other dialects like SQLite, this migration does nothing.
+    pass
+
+
+def downgrade() -> None:
+    # SQLite does not support comments, so we check the dialect
+    bind = op.get_bind()
+    if bind.dialect.name == 'postgresql':
+        op.execute("COMMENT ON COLUMN meal_foods.quantity IS NULL")
+        op.execute("COMMENT ON COLUMN tracked_meal_foods.quantity IS NULL")
+        op.execute("COMMENT ON COLUMN foods.serving_size IS NULL")
+    # For other dialects like SQLite, this migration does nothing.
+    pass

alembic/versions/d0c142fbf0b0_ensure_serving_size_column_is_float.py

@@ -0,0 +1,38 @@
+"""Ensure serving_size column is Float
+
+Revision ID: d0c142fbf0b0
+Revises: 13939361fc35
+Create Date: 2025-10-02 00:27:05.400224
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = 'd0c142fbf0b0'
+down_revision: Union[str, None] = '13939361fc35'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table('foods', schema=None) as batch_op:
+        batch_op.alter_column('serving_size',
+               existing_type=sa.VARCHAR(),
+               type_=sa.Float(),
+               existing_nullable=True)
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table('foods', schema=None) as batch_op:
+        batch_op.alter_column('serving_size',
+               existing_type=sa.Float(),
+               type_=sa.VARCHAR(),
+               existing_nullable=True)
+    # ### end Alembic commands ###

alembic/versions/e1c2d8d5c1a8_add_fitbit_tables.py

@@ -0,0 +1,55 @@
+"""add fitbit tables
+
+Revision ID: e1c2d8d5c1a8
+Revises: 4522e2de4143
+Create Date: 2026-01-12 12:00:00.000000
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = 'e1c2d8d5c1a8'
+down_revision: Union[str, None] = '31fdce040eea'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # Create fitbit_config table
+    op.create_table('fitbit_config',
+        sa.Column('id', sa.Integer(), nullable=False),
+        sa.Column('client_id', sa.String(), nullable=True),
+        sa.Column('client_secret', sa.String(), nullable=True),
+        sa.Column('redirect_uri', sa.String(), nullable=True),
+        sa.Column('access_token', sa.String(), nullable=True),
+        sa.Column('refresh_token', sa.String(), nullable=True),
+        sa.Column('expires_at', sa.Float(), nullable=True),
+        sa.PrimaryKeyConstraint('id')
+    )
+    op.create_index(op.f('ix_fitbit_config_id'), 'fitbit_config', ['id'], unique=False)
+
+    # Create weight_logs table
+    op.create_table('weight_logs',
+        sa.Column('id', sa.Integer(), nullable=False),
+        sa.Column('date', sa.Date(), nullable=True),
+        sa.Column('weight', sa.Float(), nullable=True),
+        sa.Column('source', sa.String(), nullable=True),
+        sa.Column('fitbit_log_id', sa.String(), nullable=True),
+        sa.PrimaryKeyConstraint('id')
+    )
+    op.create_index(op.f('ix_weight_logs_date'), 'weight_logs', ['date'], unique=False)
+    op.create_index(op.f('ix_weight_logs_fitbit_log_id'), 'weight_logs', ['fitbit_log_id'], unique=True)
+    op.create_index(op.f('ix_weight_logs_id'), 'weight_logs', ['id'], unique=False)
+
+
+def downgrade() -> None:
+    op.drop_index(op.f('ix_weight_logs_id'), table_name='weight_logs')
+    op.drop_index(op.f('ix_weight_logs_fitbit_log_id'), table_name='weight_logs')
+    op.drop_index(op.f('ix_weight_logs_date'), table_name='weight_logs')
+    op.drop_table('weight_logs')
+    op.drop_index(op.f('ix_fitbit_config_id'), table_name='fitbit_config')
+    op.drop_table('fitbit_config')

app/api/routes/__init__.py

@@ -0,0 +1,28 @@
+from fastapi import APIRouter
+
+from app.api.routes import (
+    admin,
+    charts,
+    export,
+    foods,
+    llm,
+    meals,
+    plans,
+    templates,
+    tracker,
+    weekly_menu,
+    fitbit,
+)
+
+api_router = APIRouter()
+api_router.include_router(tracker.router, tags=["tracker"])
+api_router.include_router(foods.router, tags=["foods"])
+api_router.include_router(meals.router, tags=["meals"])
+api_router.include_router(templates.router, tags=["templates"])
+api_router.include_router(charts.router, tags=["charts"])
+api_router.include_router(admin.router, tags=["admin"])
+api_router.include_router(fitbit.router, tags=["fitbit"])
+api_router.include_router(weekly_menu.router, tags=["weekly_menu"])
+api_router.include_router(plans.router, tags=["plans"])
+api_router.include_router(export.router, tags=["export"])
+api_router.include_router(llm.router, tags=["llm"])

app/api/routes/admin.py

@@ -6,13 +6,21 @@ import shutil
 import sqlite3
 import logging
 from datetime import datetime
+from typing import Optional
 
 # Import from the database module
 from app.database import get_db, DATABASE_URL, engine
 from main import templates
+from app.models.llm_config import LLMConfig
+from pydantic import BaseModel
 
 router = APIRouter()
 
+class LLMConfigUpdate(BaseModel):
+    openrouter_api_key: Optional[str] = None
+    preferred_model: str
+    browserless_api_key: Optional[str] = None
+
 def backup_database(source_db_path, backup_db_path):
     """Backs up an SQLite database using the online backup API."""
     logging.info(f"DEBUG: Starting backup - source: {source_db_path}, backup: {backup_db_path}")
@@ -81,6 +89,56 @@ async def admin_page(request: Request):
 async def admin_imports_page(request: Request):
     return templates.TemplateResponse(request, "admin/imports.html", {"request": request})
 
+@router.get("/admin/llm_config", response_class=HTMLResponse)
+async def admin_llm_config_page(request: Request, db: Session = Depends(get_db)):
+    logging.info("DEBUG: Starting llm_config route")
+    try:
+        llm_config = db.query(LLMConfig).first()
+        logging.info(f"DEBUG: LLMConfig query result: {llm_config}")
+        if not llm_config:
+            logging.info("DEBUG: No LLMConfig found, creating new one")
+            llm_config = LLMConfig()
+            db.add(llm_config)
+            db.commit()
+            db.refresh(llm_config)
+            logging.info(f"DEBUG: Created new LLMConfig: {llm_config}")
+        logging.info(f"DEBUG: Final llm_config object: {llm_config}")
+
+        logging.info("DEBUG: About to render llm_config.html template")
+        response = templates.TemplateResponse(
+            request,
+            "admin/llm_config.html",
+            {"request": request, "llm_config": llm_config}
+        )
+        logging.info("DEBUG: Template rendered successfully")
+        return response
+    except Exception as e:
+        logging.error(f"DEBUG: Error in llm_config route: {e}", exc_info=True)
+        raise
+
+@router.post("/admin/llm_config", response_class=RedirectResponse)
+async def update_llm_config(
+    request: Request,
+    openrouter_api_key: Optional[str] = Form(None),
+    preferred_model: str = Form(...),
+    browserless_api_key: Optional[str] = Form(None),
+    db: Session = Depends(get_db)
+):
+    llm_config = db.query(LLMConfig).first()
+    if not llm_config:
+        llm_config = LLMConfig()
+        db.add(llm_config)
+        db.commit()
+        db.refresh(llm_config)
+
+    llm_config.openrouter_api_key = openrouter_api_key
+    llm_config.preferred_model = preferred_model
+    llm_config.browserless_api_key = browserless_api_key
+    db.commit()
+    db.refresh(llm_config)
+    
+    return RedirectResponse(url="/admin/llm_config", status_code=303)
+
 @router.get("/admin/backups", response_class=HTMLResponse)
 async def admin_backups_page(request: Request):
     BACKUP_DIR = "./backups"
@@ -129,6 +187,45 @@ async def restore_backup(request: Request, backup_file: str = Form(...)):
         # You might want to add some user-facing error feedback here
         pass
 
+    # Redirect back to the backups page
     # Redirect back to the backups page
     from fastapi.responses import RedirectResponse
-    return RedirectResponse(url="/admin/backups", status_code=303)
+    return RedirectResponse(url="/admin/backups", status_code=303)
+
+@router.get("/admin/config-status", response_class=HTMLResponse)
+async def admin_config_status_page(request: Request):
+    """Display current system configuration and database status."""
+    from urllib.parse import urlparse
+    
+    # Analyze DATABASE_URL securely
+    db_url = DATABASE_URL
+    masked_url = db_url
+    db_host = "Unknown"
+    db_type = "Unknown"
+
+    try:
+        # Simple parsing logic to avoid exposing credentials if urlparse fails or acts unexpectedly
+        if "sqlite" in db_url:
+            db_type = "SQLite"
+            db_host = db_url.replace("sqlite:///", "")
+            masked_url = "sqlite:///" + db_host
+        elif "postgresql" in db_url:
+            db_type = "PostgreSQL"
+            parsed = urlparse(db_url)
+            db_host = parsed.hostname
+            # Mask password
+            if parsed.password:
+                masked_url = db_url.replace(parsed.password, "******")
+    except Exception as e:
+        logging.error(f"Error parsing database URL: {e}")
+        masked_url = "Error parsing URL"
+    
+    config_data = {
+        "database_url": db_url, 
+        "database_url_masked": masked_url,
+        "database_type": db_type,
+        "database_host": db_host,
+        "debug": True 
+    }
+
+    return templates.TemplateResponse(request, "admin/config.html", {"request": request, "config": config_data})

app/api/routes/charts.py

@@ -3,7 +3,7 @@ from starlette.responses import HTMLResponse
 from sqlalchemy.orm import Session
 from datetime import date, timedelta
 from typing import List
-from app.database import get_db, TrackedDay, TrackedMeal, calculate_day_nutrition_tracked
+from app.database import get_db, TrackedDay, TrackedMeal, calculate_day_nutrition_tracked, WeightLog
 
 router = APIRouter(tags=["charts"])
 
@@ -37,14 +37,101 @@ async def get_charts_data(
     ).order_by(TrackedDay.date.desc()).all()
     
     chart_data = []
-    for tracked_day in tracked_days:
-        tracked_meals = db.query(TrackedMeal).filter(
-            TrackedMeal.tracked_day_id == tracked_day.id
+    # Fetch all tracked days and weight logs for the period
+    tracked_days_map = {
+        d.date: d for d in db.query(TrackedDay).filter(
+            TrackedDay.person == person,
+            TrackedDay.date >= start_date,
+            TrackedDay.date <= end_date
         ).all()
-        day_totals = calculate_day_nutrition_tracked(tracked_meals, db)
-        chart_data.append({
-            "date": tracked_day.date.isoformat(),
-            "calories": round(day_totals.get("calories", 0), 2)
-        })
+    }
+
+    # Sort logs desc
+    weight_logs_map = {
+        w.date: w for w in db.query(WeightLog).filter(
+            WeightLog.date >= start_date,
+            WeightLog.date <= end_date
+        ).order_by(WeightLog.date.desc()).all()
+    }
     
+    # Get last weight BEFORE start_date (for initial carry forward)
+    last_historical_weight_log = db.query(WeightLog).filter(
+        WeightLog.date < start_date
+    ).order_by(WeightLog.date.desc()).first()
+    
+    last_historical_weight_val = last_historical_weight_log.weight * 2.20462 if last_historical_weight_log else None
+    
+    # Find the most recent weight available (either in range or history)
+    # This is for "Today" (end_date)
+    latest_weight_val = last_historical_weight_val
+    
+    # Check if we have newer weights in the map
+    # Values in weight_logs_map are WeightLog objects.
+    # Find the one with max date <= end_date. Since map key is date, we can check.
+    # But filtering the map is tedious. Let's just iterate.
+    # Actually, we already have `weight_logs_map` (in range).
+    # If the range has weights, the newest one is the "latest" known weight relevant to the end of chart.
+    if weight_logs_map:
+        # Get max date
+        max_date = max(weight_logs_map.keys())
+        latest_weight_val = weight_logs_map[max_date].weight * 2.20462
+
+    chart_data = []
+    
+    # Iterate dates. Note: i=0 is end_date (Today), i=days-1 is start_date (Oldest)
+    for i in range(days):
+        current_date = end_date - timedelta(days=i)
+        
+        tracked_day = tracked_days_map.get(current_date)
+        weight_log = weight_logs_map.get(current_date)
+
+        calories = 0
+        protein = 0
+        fat = 0
+        net_carbs = 0
+        
+        # Calculate nutrition
+        if tracked_day:
+            tracked_meals = db.query(TrackedMeal).filter(
+                TrackedMeal.tracked_day_id == tracked_day.id
+            ).all()
+            day_totals = calculate_day_nutrition_tracked(tracked_meals, db)
+            calories = round(day_totals.get("calories", 0), 2)
+            protein = round(day_totals.get("protein", 0), 2)
+            fat = round(day_totals.get("fat", 0), 2)
+            net_carbs = round(day_totals.get("net_carbs", 0), 2)
+        
+        weight_lbs = None
+        is_real = False
+        
+        if weight_log:
+            weight_lbs = round(weight_log.weight * 2.20462, 2)
+            is_real = True
+            
+        # Logic for Start and End Points (to ensure line connects across view)
+        
+        # If this is the Oldest date in view (start_date) and no real weight
+        if i == days - 1 and weight_lbs is None:
+             # Use historical weight if available (to start the line)
+             if last_historical_weight_val is not None:
+                 weight_lbs = round(last_historical_weight_val, 2)
+                 # is_real remains False (inferred)
+        
+        # If this is the Newest date in view (end_date/Today) and no real weight
+        if i == 0 and weight_lbs is None:
+            # Use latest known weight (to end the line)
+            if latest_weight_val is not None:
+                weight_lbs = round(latest_weight_val, 2)
+                # is_real remains False (inferred)
+
+        chart_data.append({
+            "date": current_date.isoformat(),
+            "calories": calories,
+            "protein": protein,
+            "fat": fat,
+            "net_carbs": net_carbs,
+            "weight_lbs": weight_lbs,
+            "weight_is_real": is_real
+        })
+            
     return chart_data

app/api/routes/export.py

@@ -1,4 +1,4 @@
-from fastapi import APIRouter, Depends, HTTPException, Request, Form, Body, File, UploadFile
+from fastapi import APIRouter, Depends, HTTPException, Request, Form, Body, File, UploadFile, Response
 from sqlalchemy.orm import Session
 from typing import List, Optional
 from datetime import date, datetime
@@ -12,7 +12,7 @@ import re
 import json
 
 from app.database import get_db, Food, Meal, Plan, Template, WeeklyMenu, TrackedDay, MealFood, TemplateMeal, WeeklyMenuDay, TrackedMeal
-from app.database import FoodCreate, FoodResponse, MealCreate, TrackedDayCreate, TrackedMealCreate, AllData, FoodExport, MealFoodExport, MealExport, PlanExport, TemplateMealExport, TemplateExport, TemplateMealDetail, TemplateDetail, WeeklyMenuDayExport, WeeklyMenuDayDetail, WeeklyMenuExport, WeeklyMenuDetail, TrackedMealExport, TrackedDayExport
+from app.database import FoodCreate, FoodResponse, MealCreate, TrackedDayCreate, TrackedMealCreate, AllData, FoodExport, MealFoodExport, MealExport, PlanExport, TemplateMealExport, TemplateExport, TemplateMealDetail, TemplateDetail, WeeklyMenuDayExport, WeeklyMenuDayDetail, WeeklyMenuExport, WeeklyMenuDetail, TrackedMealExport, TrackedDayExport, TrackedMealFoodExport
 
 router = APIRouter()
 
@@ -66,96 +66,117 @@ def validate_import_data(data: AllData):
                     detail=f"Invalid tracked meal: meal_id {tracked_meal.meal_id} not found.",
                 )
 
-@router.get("/export/all", response_model=AllData)
+@router.get("/export/all")
 async def export_all_data(db: Session = Depends(get_db)):
     """Export all data from the database as a single JSON file."""
-    foods = db.query(Food).all()
-    meals = db.query(Meal).all()
-    plans = db.query(Plan).all()
-    templates = db.query(Template).all()
-    weekly_menus = db.query(WeeklyMenu).all()
-    tracked_days = db.query(TrackedDay).all()
 
-    # Manual serialization to handle nested relationships
-    
-    # Meals with MealFoods
-    meals_export = []
-    for meal in meals:
-        meal_foods_export = [
-            MealFoodExport(food_id=mf.food_id, quantity=mf.quantity)
-            for mf in meal.meal_foods
-        ]
-        meals_export.append(
-            MealExport(
-                id=meal.id,
-                name=meal.name,
-                meal_type=meal.meal_type,
-                meal_time=meal.meal_time,
-                meal_foods=meal_foods_export,
+    try:
+        # ... (rest of the code)
+        foods = db.query(Food).all()
+        meals = db.query(Meal).all()
+        plans = db.query(Plan).all()
+        templates = db.query(Template).all()
+        weekly_menus = db.query(WeeklyMenu).all()
+        tracked_days = db.query(TrackedDay).all()
+
+        # Manual serialization to handle nested relationships
+        
+        # Meals with MealFoods
+        meals_export = []
+        for meal in meals:
+            meal_foods_export = [
+                MealFoodExport(food_id=mf.food_id, quantity=mf.quantity)
+                for mf in meal.meal_foods
+            ]
+            meals_export.append(
+                MealExport(
+                    id=meal.id,
+                    name=meal.name,
+                    meal_type=meal.meal_type,
+                    meal_time=meal.meal_time,
+                    meal_foods=meal_foods_export,
+                )
             )
+
+        # Templates with TemplateMeals
+        templates_export = []
+        for template in templates:
+            template_meals_export = [
+                TemplateMealExport(meal_id=tm.meal_id, meal_time=tm.meal_time)
+                for tm in template.template_meals
+            ]
+            templates_export.append(
+                TemplateExport(
+                    id=template.id,
+                    name=template.name,
+                    template_meals=template_meals_export,
+                )
+            )
+
+        # Weekly Menus with WeeklyMenuDays
+        weekly_menus_export = []
+        for weekly_menu in weekly_menus:
+            weekly_menu_days_export = [
+                WeeklyMenuDayExport(
+                    day_of_week=wmd.day_of_week, template_id=wmd.template_id
+                )
+                for wmd in weekly_menu.weekly_menu_days
+            ]
+            weekly_menus_export.append(
+                WeeklyMenuExport(
+                    id=weekly_menu.id,
+                    name=weekly_menu.name,
+                    weekly_menu_days=weekly_menu_days_export,
+                )
+            )
+
+        # Tracked Days with TrackedMeals
+        tracked_days_export = []
+        for tracked_day in tracked_days:
+            tracked_meals_export = [
+                TrackedMealExport(
+                    meal_id=tm.meal_id,
+                    meal_time=tm.meal_time,
+                    tracked_foods=[
+                         TrackedMealFoodExport(
+                             food_id=tmf.food_id,
+                             quantity=tmf.quantity,
+                             is_override=tmf.is_override
+                         ) for tmf in tm.tracked_foods
+                    ]
+                )
+                for tm in tracked_day.tracked_meals
+            ]
+            tracked_days_export.append(
+                TrackedDayExport(
+                    id=tracked_day.id,
+                    person=tracked_day.person,
+                    date=tracked_day.date,
+                    is_modified=tracked_day.is_modified,
+                    tracked_meals=tracked_meals_export,
+                )
+            )
+
+        data = AllData(
+            foods=[FoodExport.from_orm(f) for f in foods],
+            meals=meals_export,
+            plans=[PlanExport.from_orm(p) for p in plans],
+            templates=templates_export,
+            weekly_menus=weekly_menus_export,
+            tracked_days=tracked_days_export,
         )
-
-    # Templates with TemplateMeals
-    templates_export = []
-    for template in templates:
-        template_meals_export = [
-            TemplateMealExport(meal_id=tm.meal_id, meal_time=tm.meal_time)
-            for tm in template.template_meals
-        ]
-        templates_export.append(
-            TemplateExport(
-                id=template.id,
-                name=template.name,
-                template_meals=template_meals_export,
-            )
+        
+        json_content = data.model_dump_json()
+        
+        return Response(
+            content=json_content,
+            media_type="application/json",
+            headers={"Content-Disposition": "attachment; filename=meal_planner_backup.json"}
         )
-
-    # Weekly Menus with WeeklyMenuDays
-    weekly_menus_export = []
-    for weekly_menu in weekly_menus:
-        weekly_menu_days_export = [
-            WeeklyMenuDayExport(
-                day_of_week=wmd.day_of_week, template_id=wmd.template_id
-            )
-            for wmd in weekly_menu.weekly_menu_days
-        ]
-        weekly_menus_export.append(
-            WeeklyMenuExport(
-                id=weekly_menu.id,
-                name=weekly_menu.name,
-                weekly_menu_days=weekly_menu_days_export,
-            )
-        )
-
-    # Tracked Days with TrackedMeals
-    tracked_days_export = []
-    for tracked_day in tracked_days:
-        tracked_meals_export = [
-            TrackedMealExport(
-                meal_id=tm.meal_id,
-                meal_time=tm.meal_time,
-                quantity=tm.quantity,
-            )
-            for tm in tracked_day.tracked_meals
-        ]
-        tracked_days_export.append(
-            TrackedDayExport(
-                id=tracked_day.id,
-                person=tracked_day.person,
-                date=tracked_day.date,
-                is_modified=tracked_day.is_modified,
-                tracked_meals=tracked_meals_export,
-            )
-        )
-
-    return AllData(
-        foods=[FoodExport.from_orm(f) for f in foods],
-        meals=meals_export,
-        plans=[PlanExport.from_orm(p) for p in plans],
-        templates=templates_export,
-        weekly_menus=weekly_menus_export,
-        tracked_days=tracked_days_export,
-    )
+    except Exception as e:
+        import traceback
+        logging.error(f"Error exporting data: {e}\n{traceback.format_exc()}")
+        raise HTTPException(status_code=500, detail=str(e))
 
 @router.post("/import/all")
 async def import_all_data(file: UploadFile = File(...), db: Session = Depends(get_db)):
@@ -259,7 +280,6 @@ async def import_all_data(file: UploadFile = File(...), db: Session = Depends(ge
                         tracked_day_id=tracked_day.id,
                         meal_id=tm_data.meal_id,
                         meal_time=tm_data.meal_time,
-                        quantity=tm_data.quantity,
                     )
                 )
         db.commit()

app/api/routes/fitbit.py

@@ -0,0 +1,283 @@
+from fastapi import APIRouter, Depends, HTTPException, Request, Form
+from fastapi.responses import HTMLResponse, RedirectResponse, JSONResponse
+from sqlalchemy.orm import Session
+import requests
+import base64
+import json
+import datetime
+from datetime import date
+from typing import Optional
+
+from app.database import get_db, FitbitConfig, WeightLog
+from main import templates
+
+from urllib.parse import quote
+
+router = APIRouter()
+
+# --- Helpers ---
+
+def get_config(db: Session) -> FitbitConfig:
+    config = db.query(FitbitConfig).first()
+    if not config:
+        config = FitbitConfig()
+        db.add(config)
+        db.commit()
+        db.refresh(config)
+    return config
+
+def refresh_tokens(db: Session, config: FitbitConfig):
+    if not config.refresh_token:
+        return None
+
+    token_url = "https://api.fitbit.com/oauth2/token"
+    auth_str = f"{config.client_id}:{config.client_secret}"
+    b64_auth = base64.b64encode(auth_str.encode()).decode()
+    
+    headers = {
+        "Authorization": f"Basic {b64_auth}",
+        "Content-Type": "application/x-www-form-urlencoded"
+    }
+    
+    data = {
+        "grant_type": "refresh_token",
+        "refresh_token": config.refresh_token
+    }
+    
+    try:
+        response = requests.post(token_url, headers=headers, data=data)
+        if response.status_code == 200:
+            tokens = response.json()
+            config.access_token = tokens['access_token']
+            config.refresh_token = tokens['refresh_token']
+            # config.expires_at = datetime.datetime.now().timestamp() + tokens['expires_in'] # Optional
+            db.commit()
+            return config.access_token
+        else:
+            print(f"Failed to refresh token: {response.text}")
+            return None
+    except Exception as e:
+        print(f"Error refreshing token: {e}")
+        return None
+
+def get_valid_access_token(db: Session, config: FitbitConfig):
+    # Simply try to refresh if we suspect it's old (or just always return current and handle 401 caller side)
+    # For now, return current, caller handles 401 by calling refresh
+    return config.access_token
+
+
+# --- Routes ---
+
+@router.get("/admin/fitbit", response_class=HTMLResponse)
+async def fitbit_page(request: Request, db: Session = Depends(get_db)):
+    config = get_config(db)
+    # Mask secret
+    masked_secret = "*" * 8 if config.client_secret else ""
+    is_connected = bool(config.access_token)
+    
+    # Get recent logs
+    logs = db.query(WeightLog).order_by(WeightLog.date.desc()).limit(30).all()
+    
+    return templates.TemplateResponse("admin/fitbit.html", {
+        "request": request,
+        "config": config,
+        "masked_secret": masked_secret,
+        "is_connected": is_connected,
+        "logs": logs
+    })
+
+@router.post("/admin/fitbit/config")
+async def update_config(
+    request: Request,
+    client_id: str = Form(...),
+    client_secret: str = Form(...),
+    redirect_uri: str = Form(...),
+    db: Session = Depends(get_db)
+):
+    config = get_config(db)
+    config.client_id = client_id
+    config.client_secret = client_secret
+    config.redirect_uri = redirect_uri
+    db.commit()
+    return RedirectResponse(url="/admin/fitbit", status_code=303)
+
+@router.get("/admin/fitbit/auth_url")
+async def get_auth_url(db: Session = Depends(get_db)):
+    config = get_config(db)
+    if not config.client_id or not config.redirect_uri:
+        return {"status": "error", "message": "Client ID and Redirect URI must be configured first."}
+
+    encoded_redirect_uri = quote(config.redirect_uri, safe='')
+    auth_url = (
+        "https://www.fitbit.com/oauth2/authorize"
+        f"?response_type=code&client_id={config.client_id}"
+        f"&redirect_uri={encoded_redirect_uri}"
+        "&scope=weight"
+        "&expires_in=604800"
+    )
+    return {"status": "success", "url": auth_url}
+
+@router.post("/admin/fitbit/auth/exchange")
+async def exchange_code(
+    request: Request, 
+    code_input: str = Form(...),
+    db: Session = Depends(get_db)
+):
+    config = get_config(db)
+    
+    # Parse code from URL if provided
+    code = code_input.strip()
+    if "?" in code and "code=" in code:
+        from urllib.parse import urlparse, parse_qs
+        try:
+            query = parse_qs(urlparse(code).query)
+            if 'code' in query:
+                code = query['code'][0]
+        except:
+            pass
+            
+    if code.endswith('#_=_'):
+        code = code[:-4]
+
+    # Exchange
+    token_url = "https://api.fitbit.com/oauth2/token"
+    auth_str = f"{config.client_id}:{config.client_secret}"
+    b64_auth = base64.b64encode(auth_str.encode()).decode()
+    
+    headers = {
+        "Authorization": f"Basic {b64_auth}",
+        "Content-Type": "application/x-www-form-urlencoded"
+    }
+    
+    data = {
+        "clientId": config.client_id,
+        "grant_type": "authorization_code",
+        "redirect_uri": config.redirect_uri,
+        "code": code
+    }
+    
+    try:
+        response = requests.post(token_url, headers=headers, data=data)
+        if response.status_code == 200:
+            tokens = response.json()
+            config.access_token = tokens['access_token']
+            config.refresh_token = tokens['refresh_token']
+            db.commit()
+            return RedirectResponse(url="/admin/fitbit", status_code=303)
+        else:
+            return templates.TemplateResponse("error.html", {
+                "request": request,
+                "error_title": "Auth Failed",
+                "error_message": f"Fitbit Error: {response.text}",
+                "error_details": ""
+            })
+    except Exception as e:
+        return templates.TemplateResponse("error.html", {
+            "request": request,
+            "error_title": "Auth Error",
+            "error_message": str(e),
+            "error_details": ""
+        })
+
+@router.post("/admin/fitbit/sync")
+async def sync_data(
+    request: Request, 
+    scope: str = Form("30d"),
+    db: Session = Depends(get_db)
+):
+    config = get_config(db)
+    if not config.access_token:
+        return JSONResponse({"status": "error", "message": "Not connected"}, status_code=400)
+    
+    # Helper to fetch with token refresh support
+    def fetch_weights_range(start_date: date, end_date: date, token: str):
+        url = f"https://api.fitbit.com/1/user/-/body/log/weight/date/{start_date}/{end_date}.json"
+        headers = {
+            "Authorization": f"Bearer {token}",
+            "Accept": "application/json"
+        }
+        return requests.get(url, headers=headers)
+
+    # Determine ranges
+    ranges = []
+    today = datetime.date.today()
+    
+    if scope == "all":
+        # Start from a reasonable past date, e.g., 2015-01-01
+        current_start = datetime.date(2015, 1, 1)
+        while current_start <= today:
+            current_end = current_start + datetime.timedelta(days=30)
+            if current_end > today:
+                current_end = today
+            ranges.append((current_start, current_end))
+            current_start = current_end + datetime.timedelta(days=1)
+    else:
+        # Default 30 days
+        start = today - datetime.timedelta(days=30)
+        ranges.append((start, today))
+        
+    total_new = 0
+    errors = []
+
+    # Iterate ranges
+    # We need to manage token state outside the loop to avoid re-refreshing constantly if it fails
+    current_token = config.access_token
+
+    print(f"DEBUG: Starting sync for scope={scope} with {len(ranges)} ranges.")
+
+    for start, end in ranges:
+        print(f"DEBUG: Fetching range {start} to {end}...")
+        resp = fetch_weights_range(start, end, current_token)
+        
+        print(f"DEBUG: Response status: {resp.status_code}")
+        
+        # Handle 401 (Refresh)
+        if resp.status_code == 401:
+            print(f"Token expired during sync of {start}-{end}, refreshing...")
+            new_token = refresh_tokens(db, config)
+            if new_token:
+                current_token = new_token
+                resp = fetch_weights_range(start, end, current_token)
+                print(f"DEBUG: Retried request status: {resp.status_code}")
+            else:
+                errors.append("Token expired and refresh failed.")
+                break
+        
+        # Handle 429 (Rate Limit) - Basic handling: stop
+        if resp.status_code == 429:
+            errors.append("Rate limit exceeded.")
+            print("DEBUG: Rate limit exceeded.")
+            break
+            
+        if resp.status_code == 200:
+            data = resp.json()
+            weights = data.get('weight', [])
+            print(f"DEBUG: Found {len(weights)} weights in this range.")
+            for w in weights:
+                log_id = str(w.get('logId'))
+                weight_val = float(w.get('weight'))
+                date_str = w.get('date')
+                
+                existing = db.query(WeightLog).filter(WeightLog.fitbit_log_id == log_id).first()
+                if not existing:
+                    log = WeightLog(
+                        date=datetime.date.fromisoformat(date_str),
+                        weight=weight_val,
+                        fitbit_log_id=log_id,
+                        source='fitbit'
+                    )
+                    db.add(log)
+                    total_new += 1
+                else:
+                    existing.weight = weight_val
+            db.commit()
+        else:
+             print(f"DEBUG: Error response: {resp.text}")
+             errors.append(f"Error {resp.status_code} for range {start}-{end}: {resp.text}")
+
+    print(f"DEBUG: Sync complete. Total new: {total_new}. Errors: {errors}")
+
+    if errors:
+        return JSONResponse({"status": "warning", "message": f"Synced {total_new} records, but encountered errors: {', '.join(errors[:3])}..."})
+    else:
+        return JSONResponse({"status": "success", "message": f"Synced {total_new} new records (" + ("All History" if scope == 'all' else "30d") + ")"})

app/api/routes/llm.py

@@ -0,0 +1,167 @@
+import base64
+import json
+import logging
+import os
+from logging.config import fileConfig
+from typing import Optional
+
+import httpx
+from fastapi import APIRouter, Depends, HTTPException, Request, UploadFile, File, Form
+from fastapi.responses import HTMLResponse
+from openai import OpenAI
+from pydantic import BaseModel, Field
+from sqlalchemy.orm import Session
+
+from app.core.config import templates
+from app.database import get_db
+from app.models.llm_config import LLMConfig
+
+router = APIRouter()
+
+@router.get("/llm", response_class=HTMLResponse, include_in_schema=False)
+async def llm_food_extractor_page(request: Request):
+    return templates.TemplateResponse("llm_food_extractor.html", {"request": request})
+
+class FoodItem(BaseModel):
+    name: Optional[str] = Field(None, description="Name of the food item")
+    brand: Optional[str] = Field(None, description="Brand name of the food item")
+    serving_size_g: Optional[float] = Field(None, description="Actual serving size in grams as labeled on the page")
+    calories: Optional[int] = Field(None, description="Calories per actual serving")
+    protein_g: Optional[float] = Field(None, description="Protein in grams per actual serving")
+    carbohydrate_g: Optional[float] = Field(None, description="Carbohydrates in grams per actual serving")
+    fat_g: Optional[float] = Field(None, description="Fat in grams per actual serving")
+    fiber_g: Optional[float] = Field(None, description="Fiber in grams per actual serving")
+    sugar_g: Optional[float] = Field(None, description="Sugar in grams per actual serving")
+    sodium_mg: Optional[int] = Field(None, description="Sodium in milligrams per actual serving")
+    calcium_mg: Optional[int] = Field(None, description="Calcium in milligrams per actual serving")
+    potassium_mg: Optional[int] = Field(None, description="Potassium in milligrams per actual serving")
+    cholesterol_mg: Optional[int] = Field(None, description="Cholesterol in milligrams per actual serving")
+
+@router.post("/llm/extract", response_model=FoodItem)
+async def extract_food_data_from_llm(
+    request: Request,
+    url: Optional[str] = Form(None),
+    webpage_url: Optional[str] = Form(None),
+    image: Optional[UploadFile] = File(None),
+    db: Session = Depends(get_db)
+):
+    logging.info("Starting food data extraction from LLM.")
+    llm_config = db.query(LLMConfig).first()
+    if not llm_config or not llm_config.openrouter_api_key:
+        logging.error("OpenRouter API key not configured.")
+        raise HTTPException(
+            status_code=500,
+            detail="OpenRouter API key not configured. Please configure it in the Admin section."
+        )
+    if not llm_config.browserless_api_key:
+        logging.error("Browserless API key not configured.")
+        raise HTTPException(
+            status_code=500,
+            detail="Browserless API key not configured. Please configure it in the Admin section."
+        )
+    logging.info(f"LLM config loaded: preferred_model={llm_config.preferred_model}")
+
+    client = OpenAI(
+        base_url="https://openrouter.ai/api/v1",
+        api_key=llm_config.openrouter_api_key
+    )
+
+    # LLM prompt for extracting nutrition data from webpage content or images.
+    # Units: serving_size_g in grams; nutrition values per actual serving size (not normalized to 100g).
+    # All nutrition fields are in grams except sodium_mg, calcium_mg, potassium_mg, cholesterol_mg in milligrams.
+    prompt = """You are a nutrition data extractor. Your task is to analyze the provided information (image or website content) and extract the nutritional information for the food item. The output must be a single JSON object that conforms to the following schema. All nutritional values should be for the actual serving size as labeled on the page (e.g., if the page says "per 1 cup (240g)", use values for 240g serving).
+
+     JSON Schema:
+     {
+       "name": "string",
+       "brand": "string",
+       "serving_size_g": "float",
+       "calories": "integer",
+       "protein_g": "float",
+       "carbohydrate_g": "float",
+       "fat_g": "float",
+       "fiber_g": "float",
+       "sugar_g": "float",
+       "sodium_mg": "integer",
+       "calcium_mg": "integer",
+       "potassium_mg": "integer",
+       "cholesterol_mg": "integer"
+     }
+
+     The food name is usually the most prominent header or title on the page. Brand is the manufacturer or brand name if available. serving_size_g should be the actual grams for the serving size shown (e.g., 240 for 1 cup). If any of the fields are not available, set them to null. Do not include any text or explanations outside of the JSON object in your response.
+     """
+    messages = [{"role": "system", "content": prompt}]
+
+    content = []
+    if url:
+        logging.info(f"Processing image from URL: {url}")
+        content.append({"type": "image_url", "image_url": {"url": url}})
+    elif webpage_url:
+        logging.info(f"Processing content from webpage URL: {webpage_url}")
+        try:
+            async with httpx.AsyncClient() as client:
+                browserless_url = f"https://production-sfo.browserless.io/content?token={llm_config.browserless_api_key}"
+                headers = {
+                    "Cache-Control": "no-cache",
+                    "Content-Type": "application/json"
+                }
+                payload = {"url": webpage_url}
+                logging.info(f"Fetching content from Browserless API (POST): {browserless_url} with payload url={webpage_url}")
+                response = await client.post(browserless_url, headers=headers, json=payload, timeout=30.0)
+                logging.info(f"Browserless response status={response.status_code}, content_length={len(response.text) if response and response.text is not None else 0}")
+                response.raise_for_status()
+                content.append({"type": "text", "text": f"Extract nutritional data from this webpage content: {response.text}"})
+                logging.info("Successfully fetched webpage content.")
+        except httpx.HTTPStatusError as e:
+            status = e.response.status_code if getattr(e, "response", None) is not None else "unknown"
+            body = e.response.text if getattr(e, "response", None) is not None else ""
+            logging.error(f"Browserless HTTP error status={status}, body_snippet={body[:500]}", exc_info=True)
+            raise HTTPException(status_code=400, detail=f"Browserless HTTP {status}: unable to fetch webpage content")
+        except httpx.HTTPError as e:
+            logging.error(f"HTTP client error while fetching webpage content: {e}", exc_info=True)
+            raise HTTPException(status_code=400, detail=f"Could not fetch webpage content: {e}")
+    elif image:
+        logging.info(f"Processing uploaded image: {image.filename}")
+        image_data = await image.read()
+        base64_image = base64.b64encode(image_data).decode("utf-8")
+        content.append({
+            "type": "image_url",
+            "image_url": {"url": f"data:image/png;base64,{base64_image}"}
+        })
+        logging.info("Successfully processed uploaded image.")
+    else:
+        logging.error("No input provided. Either a URL, a webpage URL, or an image is required.")
+        raise HTTPException(status_code=400, detail="Either a URL, a webpage URL, or an image must be provided.")
+
+    messages.append({"role": "user", "content": content})
+    logging.info(f"LLM prompt: {messages}")
+    try:
+        os.makedirs("/app/data", exist_ok=True)
+        with open("/app/data/llmprompt.txt", "wt") as file:
+            file.write(json.dumps(messages, indent=2))
+        logging.info("Wrote LLM prompt to /app/data/llmprompt.txt")
+    except Exception as e:
+        logging.warning(f"Could not write LLM prompt file: {e}", exc_info=True)
+
+    try:
+        openai_client = OpenAI(
+            base_url="https://openrouter.ai/api/v1",
+            api_key=llm_config.openrouter_api_key
+        )
+        logging.info(f"Sending request to LLM with model: {llm_config.preferred_model}")
+        response = openai_client.chat.completions.create(
+            model=llm_config.preferred_model,
+            messages=messages,
+            response_format={"type": "json_object"}
+        )
+        food_data_str = response.choices[0].message.content
+        logging.info(f"LLM response: {food_data_str}")
+        food_data = json.loads(food_data_str)
+        logging.info("Successfully parsed LLM response.")
+        # Debug logs for serving size: trace actual serving_size_g from LLM, no rescaling applied
+        serving_size_g = food_data.get('serving_size_g')
+        logging.info(f"Extracted serving_size_g: {serving_size_g}g (actual serving size, no normalization to 100g)")
+        return FoodItem(**food_data)
+    except Exception as e:
+        logging.error(f"Error during LLM data extraction: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Error extracting food data: {e}")

app/api/routes/meals.py

@@ -14,9 +14,10 @@ router = APIRouter()
 # Meals tab
 @router.get("/meals", response_class=HTMLResponse)
 async def meals_page(request: Request, db: Session = Depends(get_db)):
-    meals = db.query(Meal).all()
+    from sqlalchemy.orm import joinedload
+    meals = db.query(Meal).options(joinedload(Meal.meal_foods).joinedload(MealFood.food)).all()
     foods = db.query(Food).all()
-    return templates.TemplateResponse("meals.html", 
+    return templates.TemplateResponse("meals.html",
                                     {"request": request, "meals": meals, "foods": foods})
 
 @router.post("/meals/upload")
@@ -47,7 +48,6 @@ async def bulk_upload_meals(file: UploadFile = File(...), db: Session = Depends(
                         
                     food_name = row[i].strip()
                     grams = float(row[i+1].strip())
-                    quantity = grams
                     
                     # Try multiple matching strategies for food names
                     food = None
@@ -72,7 +72,7 @@ async def bulk_upload_meals(file: UploadFile = File(...), db: Session = Depends(
                         food_names = [f[0] for f in all_foods]
                         raise ValueError(f"Food '{food_name}' not found. Available foods include: {', '.join(food_names[:5])}...")
                     logging.info(f"Found food '{food_name}' with id {food.id}")
-                    ingredients.append((food.id, quantity))
+                    ingredients.append((food.id, grams))
                 
                 # Create/update meal
                 existing = db.query(Meal).filter(Meal.name == meal_name).first()
@@ -89,11 +89,11 @@ async def bulk_upload_meals(file: UploadFile = File(...), db: Session = Depends(
                 db.flush()  # Get meal ID
                 
                 # Add new ingredients
-                for food_id, quantity in ingredients:
+                for food_id, grams in ingredients:
                     meal_food = MealFood(
                         meal_id=existing.id,
                         food_id=food_id,
-                        quantity=quantity
+                        quantity=grams
                     )
                     db.add(meal_food)
                 
@@ -180,10 +180,10 @@ async def get_meal_foods(meal_id: int, db: Session = Depends(get_db)):
 
 @router.post("/meals/{meal_id}/add_food")
 async def add_food_to_meal(meal_id: int, food_id: int = Form(...),
-                           grams: float = Form(..., alias="quantity"), db: Session = Depends(get_db)):
+                           quantity: float = Form(...), db: Session = Depends(get_db)):
     
     try:
-        meal_food = MealFood(meal_id=meal_id, food_id=food_id, quantity=grams)
+        meal_food = MealFood(meal_id=meal_id, food_id=food_id, quantity=quantity)
         db.add(meal_food)
         db.commit()
         return {"status": "success"}
@@ -210,14 +210,14 @@ async def remove_food_from_meal(meal_food_id: int, db: Session = Depends(get_db)
         return {"status": "error", "message": str(e)}
 
 @router.post("/meals/update_food_quantity")
-async def update_meal_food_quantity(meal_food_id: int = Form(...), grams: float = Form(..., alias="quantity"), db: Session = Depends(get_db)):
+async def update_meal_food_quantity(meal_food_id: int = Form(...), quantity: float = Form(...), db: Session = Depends(get_db)):
     """Update the quantity of a food in a meal"""
     try:
         meal_food = db.query(MealFood).filter(MealFood.id == meal_food_id).first()
         if not meal_food:
             return {"status": "error", "message": "Meal food not found"}
         
-        meal_food.quantity = grams
+        meal_food.quantity = quantity
         db.commit()
         return {"status": "success"}
     except ValueError as ve:

app/api/routes/plans.py

@@ -6,7 +6,7 @@ import logging
 from typing import List, Optional
 
 # Import from the database module
-from app.database import get_db, Food, Meal, MealFood, Plan, Template, TemplateMeal, WeeklyMenu, WeeklyMenuDay, TrackedDay, TrackedMeal, calculate_meal_nutrition, calculate_day_nutrition, calculate_tracked_meal_nutrition
+from app.database import get_db, Food, Meal, MealFood, Plan, Template, TemplateMeal, WeeklyMenu, WeeklyMenuDay, TrackedDay, TrackedMeal, TrackedMealFood, calculate_meal_nutrition, calculate_day_nutrition, calculate_tracked_meal_nutrition
 from sqlalchemy.orm import joinedload
 from main import templates
 
@@ -216,17 +216,24 @@ async def detailed(request: Request, person: str = "Sarah", plan_date: str = Non
             
             # Show individual foods in template meals
             for mf in tm.meal.meal_foods:
+                try:
+                    serving_size_value = float(mf.food.serving_size)
+                    num_servings = mf.quantity / serving_size_value if serving_size_value != 0 else 0
+                except (ValueError, TypeError):
+                    num_servings = 0 # Fallback for invalid serving_size
+
                 foods.append({
                     'name': mf.food.name,
-                    'quantity': mf.quantity,
+                    'total_grams': mf.quantity,
+                    'num_servings': num_servings,
                     'serving_size': mf.food.serving_size,
                     'serving_unit': mf.food.serving_unit,
-                    'calories': mf.food.calories * mf.quantity,
-                    'protein': mf.food.protein * mf.quantity,
-                    'carbs': mf.food.carbs * mf.quantity,
-                    'fat': mf.food.fat * mf.quantity,
-                    'fiber': (mf.food.fiber or 0) * mf.quantity,
-                    'sodium': (mf.food.sodium or 0) * mf.quantity,
+                    'calories': (mf.food.calories or 0) * num_servings,
+                    'protein': (mf.food.protein or 0) * num_servings,
+                    'carbs': (mf.food.carbs or 0) * num_servings,
+                    'fat': (mf.food.fat or 0) * num_servings,
+                    'fiber': (mf.food.fiber or 0) * num_servings,
+                    'sodium': (mf.food.sodium or 0) * num_servings,
                 })
             
             meal_details.append({
@@ -286,48 +293,109 @@ async def detailed(request: Request, person: str = "Sarah", plan_date: str = Non
         day_totals = {'calories': 0, 'protein': 0, 'carbs': 0, 'fat': 0, 'fiber': 0, 'sugar': 0, 'sodium': 0, 'calcium': 0}
         
         if tracked_day:
-            tracked_meals = db.query(TrackedMeal).filter(
-                TrackedMeal.tracked_day_id == tracked_day.id
-            ).options(joinedload(TrackedMeal.meal).joinedload(Meal.meal_foods).joinedload(MealFood.food)).all()
+            tracked_meals = db.query(TrackedMeal).options(
+                joinedload(TrackedMeal.meal).joinedload(Meal.meal_foods).joinedload(MealFood.food),
+                joinedload(TrackedMeal.tracked_foods).joinedload(TrackedMealFood.food)
+            ).filter(TrackedMeal.tracked_day_id == tracked_day.id).all()
             
             logging.info(f"debug: found {len(tracked_meals)} tracked meals for {person} on {plan_date_obj}")
             
             for tracked_meal in tracked_meals:
-                meal_nutrition = calculate_tracked_meal_nutrition(tracked_meal, db)
+                meal = tracked_meal.meal
+                base_foods = {mf.food_id: mf for mf in meal.meal_foods}
+                tracked_foods_list = tracked_meal.tracked_foods
+                
+                final_foods = {}
+
+                # Process base foods
+                for food_id, base_food in base_foods.items():
+                    final_foods[food_id] = {
+                        "food_obj": base_food.food,
+                        "total_grams": base_food.quantity,
+                        "is_deleted": False
+                    }
+
+                # Process tracked foods (overrides, additions, deletions)
+                for tf in tracked_foods_list:
+                    if tf.is_deleted:
+                        if tf.food_id in final_foods:
+                            final_foods[tf.food_id]["is_deleted"] = True
+                    else:
+                        # This is an override or a new addition
+                        final_foods[tf.food_id] = {
+                            "food_obj": tf.food,
+                            "total_grams": tf.quantity,
+                            "is_deleted": False
+                        }
+                
                 foods = []
-                
-                # Show base meal foods
-                for mf in tracked_meal.meal.meal_foods:
-                    foods.append({
-                        'name': mf.food.name,
-                        'quantity': mf.quantity,
-                        'serving_size': mf.food.serving_size,
-                        'serving_unit': mf.food.serving_unit,
-                        'calories': mf.food.calories * mf.quantity,
-                        'protein': mf.food.protein * mf.quantity,
-                        'carbs': mf.food.carbs * mf.quantity,
-                        'fat': mf.food.fat * mf.quantity,
-                        'fiber': (mf.food.fiber or 0) * mf.quantity,
-                        'sodium': (mf.food.sodium or 0) * mf.quantity,
-                    })
-                
-                # Show custom tracked foods (overrides/additions)
-                for tracked_food in tracked_meal.tracked_foods:
-                    foods.append({
-                        'name': f"{tracked_food.food.name} {'(override)' if tracked_food.is_override else '(addition)'}",
-                        'quantity': tracked_food.quantity,
-                        'serving_size': tracked_food.food.serving_size,
-                        'serving_unit': tracked_food.food.serving_unit,
-                        'calories': tracked_food.food.calories * tracked_food.quantity,
-                        'protein': tracked_food.food.protein * tracked_food.quantity,
-                        'carbs': tracked_food.food.carbs * tracked_food.quantity,
-                        'fat': tracked_food.food.fat * tracked_food.quantity,
-                        'fiber': (tracked_food.food.fiber or 0) * tracked_food.quantity,
-                        'sodium': (tracked_food.food.sodium or 0) * tracked_food.quantity,
-                    })
-                
+                for food_id, food_data in final_foods.items():
+                    if not food_data["is_deleted"]:
+                        food_obj = food_data["food_obj"]
+                        total_grams = food_data["total_grams"]
+                        
+                        try:
+                            serving_size_value = float(food_obj.serving_size)
+                            num_servings = total_grams / serving_size_value if serving_size_value != 0 else 0
+                        except (ValueError, TypeError):
+                            num_servings = 0
+                        
+                        foods.append({
+                            'name': food_obj.name,
+                            'total_grams': total_grams,
+                            'num_servings': num_servings,
+                            'serving_size': food_obj.serving_size,
+                            'serving_unit': food_obj.serving_unit,
+                            'calories': (food_obj.calories or 0) * num_servings,
+                            'protein': (food_obj.protein or 0) * num_servings,
+                            'carbs': (food_obj.carbs or 0) * num_servings,
+                            'fat': (food_obj.fat or 0) * num_servings,
+                            'fiber': (food_obj.fiber or 0) * num_servings,
+                            'sugar': (food_obj.sugar or 0) * num_servings,
+                            'sodium': (food_obj.sodium or 0) * num_servings,
+                            'calcium': (food_obj.calcium or 0) * num_servings,
+                        })
+
+                # Calculate effective meal nutrition
+                if foods:
+                    cal_sum = sum(f['calories'] for f in foods)
+                    prot_sum = sum(f['protein'] for f in foods)
+                    carb_sum = sum(f['carbs'] for f in foods)
+                    fat_sum = sum(f['fat'] for f in foods)
+                    fiber_sum = sum(f['fiber'] for f in foods)
+                    sugar_sum = sum(f['sugar'] for f in foods)
+                    sodium_sum = sum(f['sodium'] for f in foods)
+                    calcium_sum = sum(f['calcium'] for f in foods)
+
+                    meal_nutrition = {
+                        'calories': cal_sum,
+                        'protein': prot_sum,
+                        'carbs': carb_sum,
+                        'fat': fat_sum,
+                        'fiber': fiber_sum,
+                        'net_carbs': carb_sum - fiber_sum,
+                        'sugar': sugar_sum,
+                        'sodium': sodium_sum,
+                        'calcium': calcium_sum,
+                    }
+
+                    if cal_sum > 0:
+                        meal_nutrition['protein_pct'] = round((prot_sum * 4 / cal_sum) * 100, 1)
+                        meal_nutrition['carbs_pct'] = round((carb_sum * 4 / cal_sum) * 100, 1)
+                        meal_nutrition['fat_pct'] = round((fat_sum * 9 / cal_sum) * 100, 1)
+                    else:
+                        meal_nutrition['protein_pct'] = 0
+                        meal_nutrition['carbs_pct'] = 0
+                        meal_nutrition['fat_pct'] = 0
+                else:
+                    meal_nutrition = {
+                        'calories': 0, 'protein': 0, 'carbs': 0, 'fat': 0, 'fiber': 0,
+                        'net_carbs': 0, 'sugar': 0, 'sodium': 0, 'calcium': 0,
+                        'protein_pct': 0, 'carbs_pct': 0, 'fat_pct': 0
+                    }
+
                 meal_details.append({
-                    'plan': tracked_meal,  # Use tracked_meal instead of plan
+                    'plan': tracked_meal,
                     'nutrition': meal_nutrition,
                     'foods': foods
                 })
@@ -370,17 +438,24 @@ async def detailed(request: Request, person: str = "Sarah", plan_date: str = Non
             
             foods = []
             for mf in plan.meal.meal_foods:
+                try:
+                    serving_size_value = float(mf.food.serving_size)
+                    num_servings = mf.quantity / serving_size_value if serving_size_value != 0 else 0
+                except (ValueError, TypeError):
+                    num_servings = 0 # Fallback for invalid serving_size
+
                 foods.append({
                     'name': mf.food.name,
-                    'quantity': mf.quantity,
+                    'total_grams': mf.quantity,
+                    'num_servings': num_servings,
                     'serving_size': mf.food.serving_size,
                     'serving_unit': mf.food.serving_unit,
-                    'calories': mf.food.calories * mf.quantity,
-                    'protein': mf.food.protein * mf.quantity,
-                    'carbs': mf.food.carbs * mf.quantity,
-                    'fat': mf.food.fat * mf.quantity,
-                    'fiber': (mf.food.fiber or 0) * mf.quantity,
-                    'sodium': (mf.food.sodium or 0) * mf.quantity,
+                    'calories': (mf.food.calories or 0) * num_servings,
+                    'protein': (mf.food.protein or 0) * num_servings,
+                    'carbs': (mf.food.carbs or 0) * num_servings,
+                    'fat': (mf.food.fat or 0) * num_servings,
+                    'fiber': (mf.food.fiber or 0) * num_servings,
+                    'sodium': (mf.food.sodium or 0) * num_servings,
                 })
             
             meal_details.append({

app/api/routes/tracker.py

@@ -2,11 +2,11 @@ from fastapi import APIRouter, Depends, HTTPException, Request, Form, Body
 from fastapi.responses import HTMLResponse, RedirectResponse
 from sqlalchemy.orm import Session, joinedload
 from datetime import date, datetime, timedelta
-import logging
 from typing import List, Optional, Union
+import logging
 
 # Import from the database module
-from app.database import get_db, Meal, Template, TemplateMeal, TrackedDay, TrackedMeal, calculate_meal_nutrition, MealFood, TrackedMealFood, Food, calculate_day_nutrition_tracked
+from app.database import get_db, Meal, Template, TemplateMeal, TrackedDay, TrackedMeal, calculate_meal_nutrition, MealFood, TrackedMealFood, Food, calculate_day_nutrition_tracked, Plan
 from main import templates
 
 router = APIRouter()
@@ -14,68 +14,101 @@ router = APIRouter()
 # Tracker tab - Main page
 @router.get("/tracker", response_class=HTMLResponse)
 async def tracker_page(request: Request, person: str = "Sarah", date: str = None, db: Session = Depends(get_db)):
-    logging.info(f"DEBUG: Tracker page requested with person={person}, date={date}")
-    
-    from datetime import datetime, timedelta
-    
-    # If no date provided, use today
-    if not date:
-        current_date = datetime.now().date()
-    else:
-        current_date = datetime.fromisoformat(date).date()
-    
-    # Calculate previous and next dates
-    prev_date = (current_date - timedelta(days=1)).isoformat()
-    next_date = (current_date + timedelta(days=1)).isoformat()
-    
-    # Get or create tracked day
-    tracked_day = db.query(TrackedDay).filter(
-        TrackedDay.person == person,
-        TrackedDay.date == current_date
-    ).first()
-    
-    if not tracked_day:
-        # Create new tracked day
-        tracked_day = TrackedDay(person=person, date=current_date, is_modified=False)
-        db.add(tracked_day)
-        db.commit()
-        db.refresh(tracked_day)
-        logging.info(f"DEBUG: Created new tracked day for {person} on {current_date}")
-    
-    # Get tracked meals for this day with eager loading of meal foods
-    tracked_meals = db.query(TrackedMeal).options(
-        joinedload(TrackedMeal.meal).joinedload(Meal.meal_foods).joinedload(MealFood.food)
-    ).filter(
-        TrackedMeal.tracked_day_id == tracked_day.id
-    ).all()
-    
-    # Get all meals for dropdown
-    meals = db.query(Meal).all()
-    
-    # Get all templates for template dropdown
-    templates_list = db.query(Template).all()
+    try:
+        from datetime import datetime, timedelta
+        
+        # If no date provided, use today
+        if not date:
+            current_date = datetime.now().date()
+        else:
+            current_date = datetime.fromisoformat(date).date()
+        
+        # Calculate previous and next dates
+        prev_date = (current_date - timedelta(days=1)).isoformat()
+        next_date = (current_date + timedelta(days=1)).isoformat()
+        
+        # Get or create tracked day
+        tracked_day = db.query(TrackedDay).filter(
+            TrackedDay.person == person,
+            TrackedDay.date == current_date
+        ).first()
+        
+        if not tracked_day:
+            # Create new tracked day
+            tracked_day = TrackedDay(person=person, date=current_date, is_modified=False)
+            db.add(tracked_day)
+            db.commit()
+            db.refresh(tracked_day)
+            
+        # Check if we need to sync from Plan (if no tracked meals exist)
+        existing_meals_count = db.query(TrackedMeal).filter(
+            TrackedMeal.tracked_day_id == tracked_day.id
+        ).count()
+        
+        if existing_meals_count == 0:
+            # Look for planned meals
+            planned_meals = db.query(Plan).filter(
+                Plan.person == person,
+                Plan.date == current_date
+            ).all()
+            
+            if planned_meals:
+                logging.info(f"Syncing {len(planned_meals)} planned meals to tracker for {person} on {current_date}")
+                for plan in planned_meals:
+                    tracked_meal = TrackedMeal(
+                        tracked_day_id=tracked_day.id,
+                        meal_id=plan.meal_id,
+                        meal_time=plan.meal_time
+                    )
+                    db.add(tracked_meal)
+                db.commit()
+        
+        # Get tracked meals for this day with eager loading of meal foods
+        tracked_meals = db.query(TrackedMeal).options(
+            joinedload(TrackedMeal.meal)
+            .joinedload(Meal.meal_foods)
+            .joinedload(MealFood.food),
+            joinedload(TrackedMeal.tracked_foods)
+            .joinedload(TrackedMealFood.food)
+        ).filter(
+            TrackedMeal.tracked_day_id == tracked_day.id
+        ).all()
+        
+        # Template will handle filtering of deleted foods
+        # Get all meals for dropdown (exclude snapshots)
+        meals = db.query(Meal).filter(Meal.meal_type != "tracked_snapshot").all()
+        
+        # Get all templates for template dropdown
+        templates_list = db.query(Template).all()
 
-    # Get all foods for dropdown
-    foods = db.query(Food).all()
+        # Get all foods for dropdown
+        foods = db.query(Food).all()
+        
+        # Calculate day totals
+        day_totals = calculate_day_nutrition_tracked(tracked_meals, db)
+        
+        return templates.TemplateResponse("tracker.html", {
+            "request": request,
+            "person": person,
+            "current_date": current_date,
+            "prev_date": prev_date,
+            "next_date": next_date,
+            "tracked_meals": tracked_meals,
+            "is_modified": tracked_day.is_modified,
+            "day_totals": day_totals,
+            "meals": meals,
+            "templates": templates_list,
+            "foods": foods
+        })
     
-    # Calculate day totals
-    day_totals = calculate_day_nutrition_tracked(tracked_meals, db)
-    
-    logging.info(f"DEBUG: Rendering tracker page with {len(tracked_meals)} tracked meals")
-    
-    return templates.TemplateResponse("tracker.html", {
-        "request": request,
-        "person": person,
-        "current_date": current_date,
-        "prev_date": prev_date,
-        "next_date": next_date,
-        "tracked_meals": tracked_meals,
-        "is_modified": tracked_day.is_modified,
-        "day_totals": day_totals,
-        "meals": meals,
-        "templates": templates_list,
-        "foods": foods
-    })
+    except Exception as e:
+        # Return a detailed error page instead of generic Internal Server Error
+        return templates.TemplateResponse("error.html", {
+            "request": request,
+            "error_title": "Error Loading Tracker",
+            "error_message": f"An error occurred while loading the tracker page: {str(e)}",
+            "error_details": f"Person: {person}, Date: {date}"
+        }, status_code=500)
 
 # Tracker API Routes
 @router.post("/tracker/add_meal")
@@ -88,7 +121,6 @@ async def tracker_add_meal(request: Request, db: Session = Depends(get_db)):
         meal_id = form_data.get("meal_id")
         meal_time = form_data.get("meal_time")
         
-        logging.info(f"DEBUG: Adding meal to tracker - person={person}, date={date_str}, meal_id={meal_id}, meal_time={meal_time}")
         
         # Parse date
         from datetime import datetime
@@ -106,10 +138,34 @@ async def tracker_add_meal(request: Request, db: Session = Depends(get_db)):
             db.commit()
             db.refresh(tracked_day)
         
-        # Create tracked meal
+        # 1. Fetch the original meal
+        original_meal = db.query(Meal).filter(Meal.id == int(meal_id)).first()
+        if not original_meal:
+            return {"status": "error", "message": "Meal not found"}
+
+        # 2. Create a snapshot copy of the meal
+        snapshot_meal = Meal(
+            name=original_meal.name,
+            meal_type="tracked_snapshot",
+            meal_time=original_meal.meal_time
+        )
+        db.add(snapshot_meal)
+        db.flush() # get ID
+
+        # 3. Copy ingredients (MealFood)
+        meal_foods = db.query(MealFood).filter(MealFood.meal_id == original_meal.id).all()
+        for mf in meal_foods:
+            snapshot_food = MealFood(
+                meal_id=snapshot_meal.id,
+                food_id=mf.food_id,
+                quantity=mf.quantity
+            )
+            db.add(snapshot_food)
+        
+        # 4. Create tracked meal pointing to the SNAPSHOT
         tracked_meal = TrackedMeal(
             tracked_day_id=tracked_day.id,
-            meal_id=int(meal_id),
+            meal_id=snapshot_meal.id,
             meal_time=meal_time
         )
         db.add(tracked_meal)
@@ -119,19 +175,16 @@ async def tracker_add_meal(request: Request, db: Session = Depends(get_db)):
         
         db.commit()
         
-        logging.info(f"DEBUG: Successfully added meal to tracker")
         return {"status": "success"}
         
     except Exception as e:
         db.rollback()
-        logging.error(f"DEBUG: Error adding meal to tracker: {e}")
         return {"status": "error", "message": str(e)}
 
 @router.delete("/tracker/remove_meal/{tracked_meal_id}")
 async def tracker_remove_meal(tracked_meal_id: int, db: Session = Depends(get_db)):
     """Remove a meal from the tracker"""
     try:
-        logging.info(f"DEBUG: Removing tracked meal with ID: {tracked_meal_id}")
         
         tracked_meal = db.query(TrackedMeal).filter(TrackedMeal.id == tracked_meal_id).first()
         if not tracked_meal:
@@ -144,12 +197,10 @@ async def tracker_remove_meal(tracked_meal_id: int, db: Session = Depends(get_db
         db.delete(tracked_meal)
         db.commit()
         
-        logging.info(f"DEBUG: Successfully removed tracked meal")
         return {"status": "success"}
         
     except Exception as e:
         db.rollback()
-        logging.error(f"DEBUG: Error removing tracked meal: {e}")
         return {"status": "error", "message": str(e)}
 
 @router.post("/tracker/save_template")
@@ -164,7 +215,6 @@ async def tracker_save_template(request: Request, db: Session = Depends(get_db))
         if not all([person, date_str, template_name]):
             raise HTTPException(status_code=400, detail="Missing required form data.")
 
-        logging.info(f"debug: saving template - name={template_name}, person={person}, date={date_str}")
 
         # 1. Check if template name already exists
         existing_template = db.query(Template).filter(Template.name == template_name).first()
@@ -202,12 +252,10 @@ async def tracker_save_template(request: Request, db: Session = Depends(get_db))
             db.add(template_meal_entry)
 
         db.commit()
-        logging.info(f"debug: successfully saved template '{template_name}' with {len(tracked_meals)} meals.")
         return {"status": "success", "message": "Template saved successfully."}
 
     except Exception as e:
         db.rollback()
-        logging.error(f"debug: error saving template: {e}")
         return {"status": "error", "message": str(e)}
 
 @router.post("/tracker/apply_template")
@@ -219,7 +267,6 @@ async def tracker_apply_template(request: Request, db: Session = Depends(get_db)
         date_str = form_data.get("date")
         template_id = form_data.get("template_id")
         
-        logging.info(f"DEBUG: Applying template - template_id={template_id}, person={person}, date={date_str}")
         
         # Parse date
         from datetime import datetime
@@ -267,12 +314,10 @@ async def tracker_apply_template(request: Request, db: Session = Depends(get_db)
         
         db.commit()
         
-        logging.info(f"DEBUG: Successfully applied template with {len(template_meals)} meals")
         return {"status": "success"}
         
     except Exception as e:
         db.rollback()
-        logging.error(f"DEBUG: Error applying template: {e}")
         return {"status": "error", "message": str(e)}
 
 @router.post("/tracker/update_tracked_food")
@@ -280,10 +325,9 @@ async def update_tracked_food(request: Request, data: dict = Body(...), db: Sess
     """Update quantity of a custom food in a tracked meal"""
     try:
         tracked_food_id = data.get("tracked_food_id")
-        quantity = float(data.get("quantity", 1.0))
+        grams = float(data.get("grams", 1.0))
         is_custom = data.get("is_custom", False)
 
-        logging.info(f"DEBUG: Updating tracked food {tracked_food_id} quantity to {quantity}")
 
         if is_custom:
             tracked_food = db.query(TrackedMealFood).filter(TrackedMealFood.id == tracked_food_id).first()
@@ -300,7 +344,7 @@ async def update_tracked_food(request: Request, data: dict = Body(...), db: Sess
             tracked_food = TrackedMealFood(
                 tracked_meal_id=tracked_meal.id,
                 food_id=meal_food.food_id,
-                quantity=quantity
+                quantity=grams
             )
             db.add(tracked_food)
             
@@ -311,7 +355,7 @@ async def update_tracked_food(request: Request, data: dict = Body(...), db: Sess
             return {"status": "error", "message": "Tracked food not found"}
         
         # Update quantity
-        tracked_food.quantity = quantity
+        tracked_food.quantity = grams
         
         # Mark the tracked day as modified
         tracked_day = tracked_food.tracked_meal.tracked_day
@@ -319,12 +363,54 @@ async def update_tracked_food(request: Request, data: dict = Body(...), db: Sess
         
         db.commit()
         
-        logging.info(f"DEBUG: Successfully updated tracked food quantity")
         return {"status": "success"}
         
     except Exception as e:
         db.rollback()
-        logging.error(f"DEBUG: Error updating tracked food: {e}")
+        return {"status": "error", "message": str(e)}
+
+@router.post("/tracker/clear_page")
+async def tracker_clear_page(request: Request, db: Session = Depends(get_db)):
+    """Clear all meals and foods from the tracker page for a given day"""
+    try:
+        form_data = await request.form()
+        person = form_data.get("person")
+        date_str = form_data.get("date")
+        
+        # Parse date
+        from datetime import datetime
+        date = datetime.fromisoformat(date_str).date()
+        
+        # Get tracked day
+        tracked_day = db.query(TrackedDay).filter(
+            TrackedDay.person == person,
+            TrackedDay.date == date
+        ).first()
+        
+        if not tracked_day:
+            return {"status": "success", "message": "No tracked day found to clear."} # Already clear
+        
+        # Delete all tracked meals associated with the tracked day
+        db.query(TrackedMeal).filter(
+            TrackedMeal.tracked_day_id == tracked_day.id
+        ).delete()
+
+        # Delete all tracked foods associated with the tracked day through meals
+        # This handles directly added foods that might not be part of a meal
+        db.query(TrackedMealFood).filter(
+            TrackedMealFood.tracked_meal_id.in_(
+                db.query(TrackedMeal.id).filter(TrackedMeal.tracked_day_id == tracked_day.id)
+            )
+        ).delete(synchronize_session=False) # Use synchronize_session=False for bulk delete
+
+        # Mark the tracked day as not modified and commit
+        tracked_day.is_modified = False
+        db.commit()
+        
+        return {"status": "success", "message": "Tracker page cleared successfully."}
+        
+    except Exception as e:
+        db.rollback()
         return {"status": "error", "message": str(e)}
 
 @router.post("/tracker/reset_to_plan")
@@ -335,7 +421,6 @@ async def tracker_reset_to_plan(request: Request, db: Session = Depends(get_db))
         person = form_data.get("person")
         date_str = form_data.get("date")
         
-        logging.info(f"DEBUG: Resetting to plan - person={person}, date={date_str}")
         
         # Parse date
         from datetime import datetime
@@ -360,87 +445,88 @@ async def tracker_reset_to_plan(request: Request, db: Session = Depends(get_db))
         
         db.commit()
         
-        logging.info(f"DEBUG: Successfully reset to plan")
         return {"status": "success"}
         
     except Exception as e:
         db.rollback()
-        logging.error(f"DEBUG: Error resetting to plan: {e}")
         return {"status": "error", "message": str(e)}
 
 @router.get("/tracker/get_tracked_meal_foods/{tracked_meal_id}")
 async def get_tracked_meal_foods(tracked_meal_id: int, db: Session = Depends(get_db)):
     """Get foods associated with a tracked meal"""
-    logging.info(f"DEBUG: get_tracked_meal_foods called for tracked_meal_id: {tracked_meal_id}")
     try:
         tracked_meal = db.query(TrackedMeal).filter(TrackedMeal.id == tracked_meal_id).first()
-        logging.info(f"DEBUG: Tracked meal found: {tracked_meal.id if tracked_meal else 'None'}")
 
         if not tracked_meal:
             raise HTTPException(status_code=404, detail="Tracked meal not found")
 
         # Load the associated Meal and its foods
         meal = db.query(Meal).options(joinedload(Meal.meal_foods).joinedload(MealFood.food)).filter(Meal.id == tracked_meal.meal_id).first()
-        logging.info(f"DEBUG: Associated meal found: {meal.id if meal else 'None'}")
         if not meal:
             raise HTTPException(status_code=404, detail="Associated meal not found")
 
         # Load custom tracked foods for this tracked meal
         tracked_foods = db.query(TrackedMealFood).options(joinedload(TrackedMealFood.food)).filter(TrackedMealFood.tracked_meal_id == tracked_meal_id).all()
-        logging.info(f"DEBUG: Found {len(tracked_foods)} custom tracked foods.")
 
-        # Combine foods from the base meal and custom tracked foods, handling overrides
+        # New override-based logic
         meal_foods_data = []
-        
-        # Keep track of food_ids that have been overridden by TrackedMealFood entries
-        # These should not be added from the base meal definition
-        overridden_food_ids = {tf.food_id for tf in tracked_foods}
-        logging.info(f"DEBUG: Overridden food IDs: {overridden_food_ids}")
+        base_foods = {mf.food_id: mf for mf in meal.meal_foods}
+        overrides = {tf.food_id: tf for tf in tracked_foods}
 
-        for meal_food in meal.meal_foods:
-            # Only add meal_food if it hasn't been overridden by a TrackedMealFood
-            if meal_food.food_id not in overridden_food_ids:
+        # 1. Handle base meal foods, applying overrides where they exist
+        for food_id, base_meal_food in base_foods.items():
+            if food_id in overrides:
+                override_food = overrides[food_id]
+                if not override_food.is_deleted:
+                    # This food is overridden, use the override's data
+                    meal_foods_data.append({
+                        "id": override_food.id,
+                        "food_id": override_food.food.id,
+                        "food_name": override_food.food.name,
+                        "quantity": override_food.quantity,
+                        "serving_unit": override_food.food.serving_unit,
+                        "serving_size": override_food.food.serving_size,
+                        "is_custom": True  # It's an override, so treat as custom
+                    })
+            else:
+                # No override exists, use the base meal food data
                 meal_foods_data.append({
-                    "id": meal_food.id,
-                    "food_id": meal_food.food.id,
-                    "food_name": meal_food.food.name,
-                    "quantity": meal_food.quantity,
-                    "serving_unit": meal_food.food.serving_unit,
-                    "serving_size": meal_food.food.serving_size,
+                    "id": base_meal_food.id,
+                    "food_id": base_meal_food.food.id,
+                    "food_name": base_meal_food.food.name,
+                    "quantity": base_meal_food.quantity,
+                    "serving_unit": base_meal_food.food.serving_unit,
+                    "serving_size": base_meal_food.food.serving_size,
                     "is_custom": False
                 })
-        
-        logging.info(f"DEBUG: Added {len(meal_foods_data)} meal foods (excluding overridden).")
 
-        for tracked_food in tracked_foods:
-            meal_foods_data.append({
-                "id": tracked_food.id,
-                "food_id": tracked_food.food.id,
-                "food_name": tracked_food.food.name,
-                "quantity": tracked_food.quantity,
-                "serving_unit": tracked_food.food.serving_unit,
-                "serving_size": tracked_food.food.serving_size,
-                "is_custom": True
-            })
-        logging.info(f"DEBUG: Added {len(tracked_foods)} custom tracked foods.")
-        logging.info(f"DEBUG: Total meal foods data items: {len(meal_foods_data)}")
+        # 2. Add new foods that are not in the base meal
+        for food_id, tracked_food in overrides.items():
+            if food_id not in base_foods and not tracked_food.is_deleted:
+                meal_foods_data.append({
+                    "id": tracked_food.id,
+                    "food_id": tracked_food.food.id,
+                    "food_name": tracked_food.food.name,
+                    "quantity": tracked_food.quantity,
+                    "serving_unit": tracked_food.food.serving_unit,
+                    "serving_size": tracked_food.food.serving_size,
+                    "is_custom": True
+                })
 
         return {"status": "success", "meal_foods": meal_foods_data}
 
     except HTTPException as he:
-        logging.error(f"DEBUG: HTTP Error getting tracked meal foods: {he.detail}")
         return {"status": "error", "message": he.detail}
     except Exception as e:
-        logging.error(f"DEBUG: Error getting tracked meal foods: {e}")
         return {"status": "error", "message": str(e)}
 
 @router.post("/tracker/add_food_to_tracked_meal")
 async def add_food_to_tracked_meal(data: dict = Body(...), db: Session = Depends(get_db)):
-    """Add a food to an existing tracked meal"""
+    """Add a food to an existing tracked meal by creating a TrackedMealFood entry."""
     try:
         tracked_meal_id = data.get("tracked_meal_id")
         food_id = data.get("food_id")
-        quantity = float(data.get("quantity", 1.0))
+        grams = float(data.get("grams", 1.0))
 
         tracked_meal = db.query(TrackedMeal).filter(TrackedMeal.id == tracked_meal_id).first()
         if not tracked_meal:
@@ -450,13 +536,14 @@ async def add_food_to_tracked_meal(data: dict = Body(...), db: Session = Depends
         if not food:
             raise HTTPException(status_code=404, detail="Food not found")
 
-        # Create a new MealFood entry for the tracked meal's associated meal
-        meal_food = MealFood(
-            meal_id=tracked_meal.meal_id,
+        # Create a new TrackedMealFood entry to associate the food with the tracked meal
+        tracked_meal_food = TrackedMealFood(
+            tracked_meal_id=tracked_meal.id,
             food_id=food_id,
-            quantity=quantity
+            quantity=grams,
+            is_override=False # This is a new addition, not an override
         )
-        db.add(meal_food)
+        db.add(tracked_meal_food)
 
         # Mark the tracked day as modified
         tracked_meal.tracked_day.is_modified = True
@@ -466,98 +553,94 @@ async def add_food_to_tracked_meal(data: dict = Body(...), db: Session = Depends
 
     except HTTPException as he:
         db.rollback()
-        logging.error(f"DEBUG: HTTP Error adding food to tracked meal: {he.detail}")
         return {"status": "error", "message": he.detail}
     except Exception as e:
         db.rollback()
-        logging.error(f"DEBUG: Error adding food to tracked meal: {e}")
         return {"status": "error", "message": str(e)}
 
 @router.post("/tracker/update_tracked_meal_foods")
 async def update_tracked_meal_foods(data: dict = Body(...), db: Session = Depends(get_db)):
-    """Update quantities of multiple foods in a tracked meal"""
-    logging.info(f"DEBUG: update_tracked_meal_foods called for tracked_meal_id: {data.get('tracked_meal_id')}")
+    """Update, add, or remove foods from a tracked meal using an override system."""
     try:
         tracked_meal_id = data.get("tracked_meal_id")
         foods_data = data.get("foods", [])
-        logging.info(f"DEBUG: Foods data received: {foods_data}")
+        removed_food_ids = data.get("removed_food_ids", [])
 
         tracked_meal = db.query(TrackedMeal).filter(TrackedMeal.id == tracked_meal_id).first()
-        logging.info(f"DEBUG: Tracked meal found: {tracked_meal.id if tracked_meal else 'None'}")
         if not tracked_meal:
             raise HTTPException(status_code=404, detail="Tracked meal not found")
 
+        # Process removals: mark existing foods as deleted
+        for food_id_to_remove in removed_food_ids:
+            # Check if an override already exists
+            override = db.query(TrackedMealFood).filter(
+                TrackedMealFood.tracked_meal_id == tracked_meal_id,
+                TrackedMealFood.food_id == food_id_to_remove
+            ).first()
+            if override:
+                override.is_deleted = True
+            else:
+                # If no override exists, create one to mark the food as deleted
+                new_override = TrackedMealFood(
+                    tracked_meal_id=tracked_meal_id,
+                    food_id=food_id_to_remove,
+                    quantity=0, # Quantity is irrelevant for a deleted item
+                    is_override=True,
+                    is_deleted=True
+                )
+                db.add(new_override)
+
+        # Process updates and additions
         for food_data in foods_data:
             food_id = food_data.get("food_id")
-            grams = float(food_data.get("quantity", 1.0)) # Assuming quantity is now grams
-            is_custom = food_data.get("is_custom", False)
-            item_id = food_data.get("id") # This could be MealFood.id or TrackedMealFood.id
-            logging.info(f"DEBUG: Processing food_id: {food_id}, quantity: {grams}, is_custom: {is_custom}, item_id: {item_id}")
+            grams = float(food_data.get("grams", 1.0))
+            item_id = food_data.get("id") # This is the id from the frontend (TrackedMealFood.id or MealFood.id)
+            is_custom = food_data.get("is_custom")
 
-            quantity = grams
+            print(f"  Processing food_id {food_id} (item_id: {item_id}, is_custom: {is_custom}) with grams {grams}")
 
-            if is_custom:
-                tracked_food = db.query(TrackedMealFood).filter(TrackedMealFood.id == item_id).first()
-                if tracked_food:
-                    tracked_food.quantity = quantity
-                    logging.info(f"DEBUG: Updated existing custom tracked food {item_id} to quantity {quantity}")
+            if is_custom and item_id and item_id != 0: # Existing TrackedMealFood (custom or override)
+                tracked_food_entry = db.query(TrackedMealFood).filter(TrackedMealFood.id == item_id).first()
+                if tracked_food_entry:
+                    tracked_food_entry.quantity = grams
+                    tracked_food_entry.is_deleted = False # Ensure it's not marked as deleted if being updated
+                    print(f"    Updated existing TrackedMealFood (id: {item_id}) quantity to {grams}.")
                 else:
-                    # If it's a new custom food being added
-                    new_tracked_food = TrackedMealFood(
-                        tracked_meal_id=tracked_meal.id,
-                        food_id=food_id,
-                        quantity=quantity
-                    )
-                    db.add(new_tracked_food)
-                    logging.info(f"DEBUG: Added new custom tracked food for food_id {food_id} with quantity {quantity}")
-            else:
-                # This is a food from the original meal definition
-                # We need to check if it's already a TrackedMealFood (meaning it was overridden)
-                # Or if it's still a MealFood
-                existing_tracked_food = db.query(TrackedMealFood).filter(
-                    TrackedMealFood.tracked_meal_id == tracked_meal.id,
+                    print(f"    Error: TrackedMealFood with id {item_id} not found for update.")
+                    # This case should ideally not happen if frontend sends correct IDs
+            else: # New addition (from modal) or modification of a base MealFood
+                # Check if an override (TrackedMealFood) already exists for this food_id
+                existing_override = db.query(TrackedMealFood).filter(
+                    TrackedMealFood.tracked_meal_id == tracked_meal_id,
                     TrackedMealFood.food_id == food_id
                 ).first()
-                logging.info(f"DEBUG: Checking for existing TrackedMealFood for food_id {food_id}: {existing_tracked_food.id if existing_tracked_food else 'None'}")
 
-                if existing_tracked_food:
-                    existing_tracked_food.quantity = quantity
-                    logging.info(f"DEBUG: Updated existing TrackedMealFood {existing_tracked_food.id} (override) to quantity {quantity}")
+                if existing_override:
+                    # Update existing override
+                    existing_override.quantity = grams
+                    existing_override.is_deleted = False
+                    existing_override.is_override = True # Ensure it's marked as an override
+                    print(f"    Updated existing override for food_id {food_id}. Quantity: {grams}.")
                 else:
-                    # If it's not a TrackedMealFood, it must be a MealFood
-                    meal_food = db.query(MealFood).filter(
+                    # Create new TrackedMealFood entry
+                    # Determine if it's an override of a base meal food or a completely new food
+                    base_meal_food_exists = db.query(MealFood).filter(
                         MealFood.meal_id == tracked_meal.meal_id,
                         MealFood.food_id == food_id
                     ).first()
-                    logging.info(f"DEBUG: Checking for existing MealFood for food_id {food_id}: {meal_food.id if meal_food else 'None'}")
-                    if meal_food:
-                        # If quantity changed, convert to TrackedMealFood
-                        # NOTE: meal_food.quantity is already a multiplier,
-                        # but the incoming 'quantity' is a multiplier derived from grams.
-                        # So, we compare the incoming multiplier with the existing multiplier.
-                        if meal_food.quantity != quantity:
-                            new_tracked_food = TrackedMealFood(
-                                tracked_meal_id=tracked_meal.id,
-                                food_id=food_id,
-                                quantity=quantity,
-                                is_override=True
-                            )
-                            db.add(new_tracked_food)
-                            db.delete(meal_food) # Remove original MealFood
-                            logging.info(f"DEBUG: Converted MealFood {meal_food.id} to new TrackedMealFood for food_id {food_id} with quantity {quantity} and deleted original MealFood.")
-                        else:
-                            logging.info(f"DEBUG: MealFood {meal_food.id} quantity unchanged, no override needed.")
-                    else:
-                        # This case should ideally not happen if data is consistent,
-                        # but as a fallback, add as a new TrackedMealFood
-                        new_tracked_food = TrackedMealFood(
-                            tracked_meal_id=tracked_meal.id,
-                            food_id=food_id,
-                            quantity=quantity
-                        )
-                        db.add(new_tracked_food)
-                        logging.warning(f"DEBUG: Fallback: Added new TrackedMealFood for food_id {food_id} with quantity {quantity}. Original MealFood not found.")
-        
+                    
+                    is_override_flag = base_meal_food_exists is not None
+                    
+                    new_entry = TrackedMealFood(
+                        tracked_meal_id=tracked_meal_id,
+                        food_id=food_id,
+                        quantity=grams,
+                        is_override=is_override_flag,
+                        is_deleted=False
+                    )
+                    db.add(new_entry)
+                    print(f"    Created new TrackedMealFood for food_id {food_id}. Quantity: {grams}, is_override: {is_override_flag}.")
+
         # Mark the tracked day as modified
         tracked_meal.tracked_day.is_modified = True
 
@@ -566,66 +649,12 @@ async def update_tracked_meal_foods(data: dict = Body(...), db: Session = Depend
 
     except HTTPException as he:
         db.rollback()
-        logging.error(f"DEBUG: HTTP Error updating tracked meal foods: {he.detail}")
         return {"status": "error", "message": he.detail}
     except Exception as e:
         db.rollback()
-        logging.error(f"DEBUG: Error updating tracked meal foods: {e}")
         return {"status": "error", "message": str(e)}
 
-@router.delete("/tracker/remove_food_from_tracked_meal/{meal_food_id}")
-async def remove_food_from_tracked_meal(meal_food_id: int, db: Session = Depends(get_db)):
-    """Remove a food from a tracked meal"""
-    try:
-        meal_food = db.query(MealFood).filter(MealFood.id == meal_food_id).first()
-        if not meal_food:
-            raise HTTPException(status_code=404, detail="Meal food not found")
 
-        # Mark the tracked day as modified
-        tracked_meal = db.query(TrackedMeal).filter(TrackedMeal.meal_id == meal_food.meal_id).first()
-        if tracked_meal:
-            tracked_meal.tracked_day.is_modified = True
-
-        db.delete(meal_food)
-        db.commit()
-
-        return {"status": "success"}
-
-    except HTTPException as he:
-        db.rollback()
-        logging.error(f"DEBUG: HTTP Error removing food from tracked meal: {he.detail}")
-        return {"status": "error", "message": he.detail}
-    except Exception as e:
-        db.rollback()
-        logging.error(f"DEBUG: Error removing food from tracked meal: {e}")
-        return {"status": "error", "message": str(e)}
-
-@router.delete("/tracker/remove_custom_food_from_tracked_meal/{tracked_meal_food_id}")
-async def remove_custom_food_from_tracked_meal(tracked_meal_food_id: int, db: Session = Depends(get_db)):
-    """Remove a custom food from a tracked meal"""
-    try:
-        tracked_meal_food = db.query(TrackedMealFood).filter(TrackedMealFood.id == tracked_meal_food_id).first()
-        if not tracked_meal_food:
-            raise HTTPException(status_code=404, detail="Tracked meal food not found")
-
-        # Mark the tracked day as modified
-        tracked_meal = tracked_meal_food.tracked_meal
-        if tracked_meal:
-            tracked_meal.tracked_day.is_modified = True
-
-        db.delete(tracked_meal_food)
-        db.commit()
-
-        return {"status": "success"}
-
-    except HTTPException as he:
-        db.rollback()
-        logging.error(f"DEBUG: HTTP Error removing custom food from tracked meal: {he.detail}")
-        return {"status": "error", "message": he.detail}
-    except Exception as e:
-        db.rollback()
-        logging.error(f"DEBUG: Error removing custom food from tracked meal: {e}")
-        return {"status": "error", "message": str(e)}
 
 @router.post("/tracker/save_as_new_meal")
 async def save_as_new_meal(data: dict = Body(...), db: Session = Depends(get_db)):
@@ -656,7 +685,7 @@ async def save_as_new_meal(data: dict = Body(...), db: Session = Depends(get_db)
             meal_food = MealFood(
                 meal_id=new_meal.id,
                 food_id=food_data["food_id"],
-                quantity=food_data["quantity"]
+                quantity=food_data["grams"]
             )
             db.add(meal_food)
 
@@ -678,11 +707,9 @@ async def save_as_new_meal(data: dict = Body(...), db: Session = Depends(get_db)
 
     except HTTPException as he:
         db.rollback()
-        logging.error(f"DEBUG: HTTP Error saving as new meal: {he.detail}")
         return {"status": "error", "message": he.detail}
     except Exception as e:
         db.rollback()
-        logging.error(f"DEBUG: Error saving as new meal: {e}")
         return {"status": "error", "message": str(e)}
 
 @router.post("/tracker/add_food")
@@ -692,10 +719,9 @@ async def tracker_add_food(data: dict = Body(...), db: Session = Depends(get_db)
         person = data.get("person")
         date_str = data.get("date")
         food_id = data.get("food_id")
-        grams = float(data.get("quantity", 1.0))  # Assuming quantity is now grams
+        grams = float(data.get("quantity", 1.0))
         meal_time = data.get("meal_time")
-        
-        logging.info(f"DEBUG: Adding single food to tracker - person={person}, date={date_str}, food_id={food_id}, grams={grams}, meal_time={meal_time}")
+
         
         # Parse date
         from datetime import datetime
@@ -713,21 +739,21 @@ async def tracker_add_food(data: dict = Body(...), db: Session = Depends(get_db)
             db.commit()
             db.refresh(tracked_day)
         
-        # The quantity is already in grams, so no conversion needed
-        quantity = grams
-        
-        # Create a new Meal for this single food entry
-        # This allows it to be treated like any other meal in the tracker view
         food_item = db.query(Food).filter(Food.id == food_id).first()
         if not food_item:
             return {"status": "error", "message": "Food not found"}
-            
+
+        # Store grams directly
+        quantity = grams
+
+        # Create a new Meal for this single food entry
+        # This allows it to be treated like any other meal in the tracker view
         new_meal = Meal(name=food_item.name, meal_type="single_food", meal_time=meal_time)
         db.add(new_meal)
         db.flush() # Flush to get the new meal ID
-        
+
         # Link the food to the new meal
-        meal_food = MealFood(meal_id=new_meal.id, food_id=food_id, quantity=quantity)
+        meal_food = MealFood(meal_id=new_meal.id, food_id=food_id, quantity=grams)
         db.add(meal_food)
         
         # Create tracked meal entry
@@ -743,118 +769,11 @@ async def tracker_add_food(data: dict = Body(...), db: Session = Depends(get_db)
         
         db.commit()
         
-        logging.info(f"DEBUG: Successfully added single food to tracker")
         return {"status": "success"}
         
     except ValueError as ve:
         db.rollback()
-        logging.error(f"DEBUG: Error adding single food to tracker: {ve}")
         return {"status": "error", "message": str(ve)}
     except Exception as e:
         db.rollback()
-        logging.error(f"DEBUG: Error adding single food to tracker: {e}")
         return {"status": "error", "message": str(e)}
-
-@router.get("/detailed_tracked_day", response_class=HTMLResponse, name="detailed_tracked_day")
-async def detailed_tracked_day(request: Request, person: str = "Sarah", date: Optional[str] = None, db: Session = Depends(get_db)):
-    """
-    Displays a detailed view of a tracked day, including all meals and their food breakdowns.
-    """
-    logging.info(f"DEBUG: Detailed tracked day page requested with person={person}, date={date}")
-
-    # If no date is provided, default to today's date
-    if not date:
-        current_date = date.today()
-    else:
-        try:
-            current_date = datetime.fromisoformat(date).date()
-        except ValueError:
-            logging.error(f"DEBUG: Invalid date format for date: {date}")
-            return templates.TemplateResponse("detailed.html", {
-                "request": request, "title": "Invalid Date",
-                "error": "Invalid date format. Please use YYYY-MM-DD.",
-                "day_totals": {},
-                "person": person
-            })
-
-    tracked_day = db.query(TrackedDay).filter(
-        TrackedDay.person == person,
-        TrackedDay.date == current_date
-    ).first()
-
-    if not tracked_day:
-        return templates.TemplateResponse("detailed_tracked_day.html", {
-            "request": request, "title": "No Tracked Day Found",
-            "error": "No tracked meals found for this day.",
-            "day_totals": {},
-            "person": person,
-            "plan_date": current_date # Pass current_date for consistent template behavior
-        })
-    
-    tracked_meals = db.query(TrackedMeal).options(
-        joinedload(TrackedMeal.meal).joinedload(Meal.meal_foods).joinedload(MealFood.food),
-        joinedload(TrackedMeal.tracked_foods).joinedload(TrackedMealFood.food)
-    ).filter(
-        TrackedMeal.tracked_day_id == tracked_day.id
-    ).all()
-
-    day_totals = calculate_day_nutrition_tracked(tracked_meals, db)
-
-    meal_details = []
-    for tracked_meal in tracked_meals:
-        meal_nutrition = calculate_meal_nutrition(tracked_meal.meal, db) # Base meal nutrition
-
-        foods = []
-        # Add foods from the base meal definition
-        for mf in tracked_meal.meal.meal_foods:
-            foods.append({
-                'name': mf.food.name,
-                'quantity': mf.quantity,
-                'serving_size': mf.food.serving_size,
-                'serving_unit': mf.food.serving_unit,
-                'calories': mf.food.calories * mf.quantity,
-                'protein': mf.food.protein * mf.quantity,
-                'carbs': mf.food.carbs * mf.quantity,
-                'fat': mf.food.fat * mf.quantity,
-                'fiber': (mf.food.fiber or 0) * mf.quantity,
-                'sugar': (mf.food.sugar or 0) * mf.quantity,
-                'sodium': (mf.food.sodium or 0) * mf.quantity,
-                'calcium': (mf.food.calcium or 0) * mf.quantity,
-            })
-        # Add custom tracked foods (overrides or additions)
-        for tmf in tracked_meal.tracked_foods:
-            foods.append({
-                'name': tmf.food.name,
-                'quantity': tmf.quantity,
-                'serving_size': tmf.food.serving_size,
-                'serving_unit': tmf.food.serving_unit,
-                'calories': tmf.food.calories * tmf.quantity,
-                'protein': tmf.food.protein * tmf.quantity,
-                'carbs': tmf.food.carbs * tmf.quantity,
-                'fat': tmf.food.fat * tmf.quantity,
-                'fiber': (tmf.food.fiber or 0) * tmf.quantity,
-                'sugar': (tmf.food.sugar or 0) * tmf.quantity,
-                'sodium': (tmf.food.sodium or 0) * tmf.quantity,
-                'calcium': (tmf.food.calcium or 0) * tmf.quantity,
-            })
-        
-        meal_details.append({
-            'plan': {'meal': tracked_meal.meal, 'meal_time': tracked_meal.meal_time},
-            'nutrition': meal_nutrition,
-            'foods': foods
-        })
-
-    context = {
-        "request": request,
-        "title": f"Detailed Day for {person} on {current_date.strftime('%B %d, %Y')}",
-        "meal_details": meal_details,
-        "day_totals": day_totals,
-        "person": person,
-        "plan_date": current_date # Renamed from current_date to plan_date for consistency with detailed.html
-    }
-
-    if not meal_details:
-        context["message"] = "No meals tracked for this day."
-
-    logging.info(f"DEBUG: Rendering tracked day details with context: {context}")
-    return templates.TemplateResponse("detailed_tracked_day.html", context)

app/core/config.py

@@ -1,3 +1,24 @@
-from fastapi.templating import Jinja2Templates
+from functools import lru_cache
+from typing import Optional
 
-templates = Jinja2Templates(directory="templates")
+from fastapi.templating import Jinja2Templates
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+templates = Jinja2Templates(directory="templates")
+
+class Settings(BaseSettings):
+    """
+    Application settings.
+    Settings are loaded from environment variables.
+    """
+    model_config = SettingsConfigDict(env_file=".env", extra="ignore")
+
+    DATABASE_URL: str
+    SECRET_KEY: str
+    ALGORITHM: str
+    ACCESS_TOKEN_EXPIRE_MINUTES: int
+
+
+@lru_cache()
+def get_settings():
+    return Settings()

app/database.py

@@ -1,20 +1,32 @@
 """
 Database models and session management for the meal planner app
 """
+"""
+QUANTITY CONVENTION:
+All quantity fields in this application represent GRAMS.
+
+- Food.serving_size: base serving size in grams (e.g., 100.0)
+- Food nutrition values: per serving_size grams
+- MealFood.quantity: grams of this food in the meal (e.g., 150.0)
+- TrackedMealFood.quantity: grams of this food as tracked (e.g., 200.0)
+
+To calculate nutrition: multiplier = quantity / serving_size
+"""
 from sqlalchemy import create_engine, Column, Integer, String, Float, DateTime, ForeignKey, Text, Date, Boolean
 from sqlalchemy import or_
 from sqlalchemy.orm import sessionmaker, Session, relationship, declarative_base
 from sqlalchemy.orm import joinedload
 from pydantic import BaseModel, ConfigDict
 
-from typing import List, Optional
+from typing import List, Optional, Union
 from datetime import date, datetime
 import os
+import logging
 
 # Database setup - Use SQLite for easier setup
 # Use environment variables if set, otherwise use defaults
 # Use current directory for database
-DATABASE_PATH = os.getenv('DATABASE_PATH', '.')
+DATABASE_PATH = os.getenv('DATABASE_PATH', '/app')
 DATABASE_URL = os.getenv('DATABASE_URL', f'sqlite:///{DATABASE_PATH}/meal_planner.db')
 
 # For production, use PostgreSQL: DATABASE_URL = "postgresql://username:password@localhost/meal_planner"
@@ -23,13 +35,16 @@ engine = create_engine(DATABASE_URL, connect_args={"check_same_thread": False} i
 SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
 Base = declarative_base()
 
+# Import all models to ensure they are registered with Base
+from app.models.llm_config import LLMConfig
+
 # Database Models
 class Food(Base):
     __tablename__ = "foods"
 
     id = Column(Integer, primary_key=True, index=True)
     name = Column(String, unique=True, index=True)
-    serving_size = Column(String)
+    serving_size = Column(Float)
     serving_unit = Column(String)
     calories = Column(Float)
     protein = Column(Float)
@@ -150,14 +165,35 @@ class TrackedMealFood(Base):
     food_id = Column(Integer, ForeignKey("foods.id"))
     quantity = Column(Float, default=1.0)  # Custom quantity for this tracked instance
     is_override = Column(Boolean, default=False)  # True if overriding original meal food, False if addition
+    is_deleted = Column(Boolean, default=False) # True if this food has been deleted from the meal
 
     tracked_meal = relationship("TrackedMeal", back_populates="tracked_foods")
     food = relationship("Food")
 
+class FitbitConfig(Base):
+    __tablename__ = "fitbit_config"
+
+    id = Column(Integer, primary_key=True, index=True)
+    client_id = Column(String)
+    client_secret = Column(String)
+    redirect_uri = Column(String, default="http://localhost:8080/fitbit-callback")
+    access_token = Column(String, nullable=True)
+    refresh_token = Column(String, nullable=True)
+    expires_at = Column(Float, nullable=True)  # Timestamp
+
+class WeightLog(Base):
+    __tablename__ = "weight_logs"
+
+    id = Column(Integer, primary_key=True, index=True)
+    date = Column(Date, index=True)
+    weight = Column(Float)
+    source = Column(String, default="fitbit")
+    fitbit_log_id = Column(String, unique=True, index=True)  # To prevent duplicates
+
 # Pydantic models
 class FoodCreate(BaseModel):
     name: str
-    serving_size: str
+    serving_size: Union[float, str]
     serving_unit: str
     calories: float
     protein: float
@@ -173,7 +209,7 @@ class FoodCreate(BaseModel):
 class FoodResponse(BaseModel):
     id: int
     name: str
-    serving_size: str
+    serving_size: Union[float, str]
     serving_unit: str
     calories: float
     protein: float
@@ -313,7 +349,7 @@ def get_db():
 def calculate_meal_nutrition(meal, db: Session):
     """
     Calculate total nutrition for a meal.
-    Quantities in MealFood are now directly in grams.
+    MealFood.quantity is in GRAMS. Multiplier = quantity / food.serving_size (serving_size in grams).
     """
     totals = {
         'calories': 0, 'protein': 0, 'carbs': 0, 'fat': 0,
@@ -322,23 +358,16 @@ def calculate_meal_nutrition(meal, db: Session):
     
     for meal_food in meal.meal_foods:
         food = meal_food.food
-        grams = meal_food.quantity # quantity is now grams
-        
-        # Convert grams to a multiplier of serving size for nutrition calculation
         try:
-            serving_size_value = float(food.serving_size)
-        except ValueError:
-            serving_size_value = 1 # Fallback if serving_size is not a number
+            serving_size = float(food.serving_size)
+            multiplier = meal_food.quantity / serving_size if serving_size > 0 else 0
+        except (ValueError, TypeError):
+            multiplier = 0
         
-        if serving_size_value == 0:
-            multiplier = 0 # Avoid division by zero
-        else:
-            multiplier = grams / serving_size_value
-        
-        totals['calories'] += food.calories * multiplier
-        totals['protein'] += food.protein * multiplier
-        totals['carbs'] += food.carbs * multiplier
-        totals['fat'] += food.fat * multiplier
+        totals['calories'] += (food.calories or 0) * multiplier
+        totals['protein'] += (food.protein or 0) * multiplier
+        totals['carbs'] += (food.carbs or 0) * multiplier
+        totals['fat'] += (food.fat or 0) * multiplier
         totals['fiber'] += (food.fiber or 0) * multiplier
         totals['sugar'] += (food.sugar or 0) * multiplier
         totals['sodium'] += (food.sodium or 0) * multiplier
@@ -388,30 +417,67 @@ def calculate_day_nutrition(plans, db: Session):
     return day_totals
 
 def calculate_tracked_meal_nutrition(tracked_meal, db: Session):
-    """Calculate nutrition for a tracked meal, including custom foods"""
+    """
+    Calculate nutrition for a tracked meal, including custom foods.
+    TrackedMealFood.quantity is in GRAMS. Multiplier = quantity / food.serving_size (serving_size in grams).
+    Base meal uses calculate_meal_nutrition which handles grams correctly.
+    """
     totals = {
         'calories': 0, 'protein': 0, 'carbs': 0, 'fat': 0,
         'fiber': 0, 'sugar': 0, 'sodium': 0, 'calcium': 0
     }
     
-    # Base meal nutrition
-    base_nutrition = calculate_meal_nutrition(tracked_meal.meal, db)
-    for key in totals:
-        if key in base_nutrition:
-            totals[key] += base_nutrition[key]
+    # 1. Get base foods from the meal
+    # access via relationship, assume eager loading or lazy loading
+    base_foods = {mf.food_id: mf for mf in tracked_meal.meal.meal_foods}
     
-    # Add custom tracked foods
-    for tracked_food in tracked_meal.tracked_foods:
-        food = tracked_food.food
-        food_quantity = tracked_food.quantity
-        totals['calories'] += food.calories * food_quantity
-        totals['protein'] += food.protein * food_quantity
-        totals['carbs'] += food.carbs * food_quantity
-        totals['fat'] += food.fat * food_quantity
-        totals['fiber'] += (food.fiber or 0) * food_quantity
-        totals['sugar'] += (food.sugar or 0) * food_quantity
-        totals['sodium'] += (food.sodium or 0) * food_quantity
-        totals['calcium'] += (food.calcium or 0) * food_quantity
+    # 2. Get tracked foods (overrides, deletions, additions)
+    tracked_foods = tracked_meal.tracked_foods
+    
+    # 3. Determine effective foods
+    # Start with base foods
+    final_foods = {}
+    for food_id, mf in base_foods.items():
+        final_foods[food_id] = {
+            'food': mf.food,
+            'quantity': mf.quantity
+        }
+        
+    # Apply tracked changes
+    for tf in tracked_foods:
+        if tf.is_deleted:
+            # If deleted, remove from final_foods if it exists
+            if tf.food_id in final_foods:
+                del final_foods[tf.food_id]
+        else:
+            # Overrides or Additions
+            # This handles both:
+            # - Overriding a base food (replaces entry with same food_id)
+            # - Adding a new food (adds new entry with new food_id)
+            final_foods[tf.food_id] = {
+                'food': tf.food,
+                'quantity': tf.quantity
+            }
+            
+    # 4. Calculate totals
+    for food_id, item in final_foods.items():
+        food = item['food']
+        quantity = item['quantity']
+        
+        try:
+             serving_size = float(food.serving_size)
+             multiplier = quantity / serving_size if serving_size > 0 else 0
+        except (ValueError, TypeError):
+             multiplier = 0
+        
+        totals['calories'] += (food.calories or 0) * multiplier
+        totals['protein'] += (food.protein or 0) * multiplier
+        totals['carbs'] += (food.carbs or 0) * multiplier
+        totals['fat'] += (food.fat or 0) * multiplier
+        totals['fiber'] += (food.fiber or 0) * multiplier
+        totals['sugar'] += (food.sugar or 0) * multiplier
+        totals['sodium'] += (food.sodium or 0) * multiplier
+        totals['calcium'] += (food.calcium or 0) * multiplier
     
     # Calculate percentages
     total_cals = totals['calories']
@@ -458,10 +524,11 @@ def calculate_day_nutrition_tracked(tracked_meals, db: Session):
     return day_totals
 
 
-def convert_grams_to_quantity(food_id: int, grams: float, db: Session) -> float:
+def calculate_multiplier_from_grams(food_id: int, grams: float, db: Session) -> float:
     """
-    Converts a given amount in grams to the corresponding quantity multiplier
-    based on the food's serving size.
+    Calculate the multiplier from grams based on the food's serving size.
+    Multiplier = grams / serving_size (both in grams).
+    Used for nutrition calculations when quantity is provided in grams.
     """
     food = db.query(Food).filter(Food.id == food_id).first()
     if not food:

app/models/llm_config.py

@@ -0,0 +1,10 @@
+from sqlalchemy import Column, Integer, String
+from app.database import Base
+
+class LLMConfig(Base):
+    __tablename__ = "llm_configs"
+
+    id = Column(Integer, primary_key=True, index=True)
+    openrouter_api_key = Column(String, nullable=True)
+    preferred_model = Column(String, default="anthropic/claude-3.5-sonnet")
+    browserless_api_key = Column(String, nullable=True)

app/utils.py

@@ -0,0 +1,12 @@
+import re
+
+def slugify(s):
+    """
+    Slugifies a string, converting spaces and non-alphanumeric characters to hyphens.
+    """
+    s = s.lower()
+    s = re.sub(r'[^a-z0-9\s-]', '', s)  # Remove all non-alphanumeric characters except spaces and hyphens
+    s = re.sub(r'[-\s]+', '-', s)        # Replace spaces and hyphens with a single hyphen
+    s = s.strip('-')                     # Remove leading/trailing hyphens
+
+    return s

detailed.patch

@@ -1,21 +0,0 @@
---- templates/detailed.html
-+++ templates/detailed.html
-@@ -1,3 +1,7 @@
-+{# Look for the meal details section and ensure it shows food breakdown #}
-+{% for meal_detail in meal_details %}
-+  {# Existing meal header code... #}
-+  
-+  {# ADD FOOD BREAKDOWN SECTION: #}
-+  <div class="food-breakdown">
-+    <h4>Food Breakdown:</h4>
-+    <ul>
-+      {% for food in meal_detail.foods %}
-+        <li>{{ food.quantity }}g {{ food.name }} 
-+          {% if food.serving_size and food.serving_unit %}
-+            ({{ food.serving_size }}{{ food.serving_unit }})
-+          {% endif %}
-+        </li>
-+      {% endfor %}
-+    </ul>
-+  </div>
-+{% endfor %}

docker-compose.yml

@@ -4,7 +4,13 @@ services:
     ports:
       - "8999:8999"
     environment:
-      - DATABASE_URL=sqlite:////app/meal_planner.db
+      #- DATABASE_URL=sqlite:////app/data/meal_planner.db
+      - DATABASE_URL=postgresql://postgres:postgres@master.postgres.service.dc1.consul/meal_planner
+      - PYTHONUNBUFFERED=1
     volumes:
       - ./alembic:/app/alembic
-      - ./meal_planner.db:/app/meal_planner.db
+      - ./data:/app/data
+      - ./backups:/app/backups
+      - ./app:/app/app
+      - ./templates:/app/templates
+      - ./main.py:/app/main.py

docs/testing_strategy.md

@@ -0,0 +1,65 @@
+# Data-TestID Implementation Strategy
+
+This document outlines the new strategy for implementing stable, non-ambiguous `data-testid` attributes across the application. This approach will resolve "strict mode violation" errors in Playwright and ensure our tests are robust against changes in UI class names, element order, and data duplication (e.g., duplicate meal names).
+
+## Goal
+
+To create unique and consistent identifiers for every dynamic element on a page, where consistency is based on stable data (e.g., meal name, meal time) rather than dynamic database IDs.
+
+## I. General Naming Convention
+
+All new testing identifiers will be implemented using the `data-testid` HTML attribute and follow the format:
+
+`data-testid="[element-type-prefix]-[unique-id]"`
+
+The core of this strategy is the **Unique ID**, which ensures that duplicate item names are handled correctly.
+
+## II. The Unique Meal ID Structure (Example from `tracker.html`)
+
+The Unique Meal ID is a composite slug generated using Jinja variables. It provides a unique identifier for a specific instance of a meal in a specific time slot.
+
+**Unique Meal ID** = `[meal-time-slug]-[meal-name-slug]-[loop-index]`
+
+| Component | Jinja Source | Description | Example |
+| :--- | :--- | :--- | :--- |
+| **meal-time-slug** | `meal_time\|lower\|replace(' ', '-')` | The slugified meal time category (e.g., "Breakfast"). | `breakfast` |
+| **meal-name-slug** | `tracked_meal.meal.name\|lower\|replace(' ', '-')\|replace(',', '')\|replace('.', '')` | The slugified and sanitized name of the meal. | `protein-shake` |
+| **loop-index** | `loop.index\|string` | The 1-based index of the meal within its time slot. This is critical for solving duplicate meal name ambiguity. | `1` |
+
+### Example of a Full Unique Meal ID:
+
+| Scenario | Generated ID |
+| :--- | :--- |
+| First "Protein Shake" in Breakfast | `breakfast-protein-shake-1` |
+| Second "Protein Shake" in Breakfast | `breakfast-protein-shake-2` |
+
+## III. Implementation Details (`templates/tracker.html`)
+
+The following slugs and variables must be defined inside the main `{% for tracked_meal in meals_for_time %}` loop.
+
+### A. Setup Variables (To be placed at the top of the loop)
+
+```jinja
+{% for tracked_meal in meals_for_time %}
+    {# 1. Create stable slugs #}
+    {% set meal_time_slug = meal_time|lower|replace(' ', '-') %}
+    {% set meal_name_safe = tracked_meal.meal.name|lower|replace(' ', '-')|replace(',', '')|replace('.', '') %}
+    
+    {# 2. Construct the core Unique Meal ID for non-ambiguous locating #}
+    {% set unique_meal_id = meal_time_slug + '-' + meal_name_safe + '-' + loop.index|string %}
+    
+    ...
+{% endfor %}
+```
+
+### B. HTML Element Locators
+
+| Element | Prefix | HTML Attribute (using the Jinja variable) | Example `data-testid` |
+| :--- | :--- | :--- | :--- |
+| Meal Card Container | `meal-card` | `data-testid="meal-card-{{ unique_meal_id }}"` | `meal-card-breakfast-protein-shake-1` |
+| Meal Name (`<strong>`) | `meal-name` | `data-testid="meal-name-{{ unique_meal_id }}"` | `meal-name-breakfast-protein-shake-1` |
+| Edit Button | `edit-meal` | `data-testid="edit-meal-{{ unique_meal_id }}"` | `edit-meal-breakfast-protein-shake-1` |
+| Delete Button | `delete-meal` | `data-testid="delete-meal-{{ unique_meal_id }}"` | `delete-meal-breakfast-protein-shake-1` |
+| Food Item Display (`<div>`) | `food-display` | `data-testid="food-display-{{ unique_meal_id }}-{{ food_name_safe }}-{{ inner_loop.index }}"` | `food-display-breakfast-ps-1-strawberry-1` |
+
+**Action Required:** This pattern should be used to update existing Playwright tests and applied to other templates to ensure testing consistency.

fix_tracer.py

@@ -1,125 +0,0 @@
-#!/usr/bin/env python3
-"""
-Script to fix the incomplete tracker.py file
-"""
-
-def fix_tracker_file():
-    file_path = "app/api/routes/tracker.py"
-    
-    with open(file_path, 'r') as f:
-        content = f.read()
-    
-    # Check if file is incomplete (ends abruptly)
-    if content.strip().endswith('@router.post("/tracker/save_template")'):
-        print("File is incomplete, adding missing content...")
-        
-        missing_content = '''async def tracker_save_template(request: Request, db: Session = Depends(get_db)):
-    """save current day's meals as template"""
-    try:
-        form_data = await request.form()
-        person = form_data.get("person")
-        date_str = form_data.get("date")
-        template_name = form_data.get("template_name")
-        logging.info(f"debug: saving template - name={template_name}, person={person}, date={date_str}")
-        
-        # Parse date
-        from datetime import datetime
-        date = datetime.fromisoformat(date_str).date()
-        
-        # Get tracked day and meals
-        tracked_day = db.query(TrackedDay).filter(
-            TrackedDay.person == person,
-            TrackedDay.date == date
-        ).first()
-        if not tracked_day:
-            return {"status": "error", "message": "No tracked day found"}
-            
-        tracked_meals = db.query(TrackedMeal).filter(
-            TrackedMeal.tracked_day_id == tracked_day.id
-        ).all()
-        
-        if not tracked_meals:
-            return {"status": "error", "message": "No tracked meals found"}
-        
-        # Create new template
-        template = Template(name=template_name)
-        db.add(template)
-        db.flush()
-        
-        # Add meals to template
-        for tracked_meal in tracked_meals:
-            template_meal = TemplateMeal(
-                template_id=template.id,
-                meal_id=tracked_meal.meal_id,
-                meal_time=tracked_meal.meal_time
-            )
-            db.add(template_meal)
-        
-        db.commit()
-        return {"status": "success", "message": "Template saved successfully"}
-    except Exception as e:
-        db.rollback()
-        logging.error(f"debug: error saving template: {e}")
-        return {"status": "error", "message": str(e)}
-
-@router.post("/tracker/apply_template")
-async def tracker_apply_template(request: Request, db: Session = Depends(get_db)):
-    """apply template to current day"""
-    try:
-        form_data = await request.form()
-        person = form_data.get("person")
-        date_str = form_data.get("date")
-        template_id = form_data.get("template_id")
-        logging.info(f"debug: applying template - template_id={template_id}, person={person}, date={date_str}")
-        
-        # Parse date
-        from datetime import datetime
-        date = datetime.fromisoformat(date_str).date()
-        
-        # Get template meals
-        template_meals = db.query(TemplateMeal).filter(
-            TemplateMeal.template_id == template_id
-        ).all()
-        
-        if not template_meals:
-            return {"status": "error", "message": "Template has no meals"}
-        
-        # Get or create tracked day
-        tracked_day = db.query(TrackedDay).filter(
-            TrackedDay.person == person,
-            TrackedDay.date == date
-        ).first()
-        if not tracked_day:
-            tracked_day = TrackedDay(person=person, date=date, is_modified=True)
-            db.add(tracked_day)
-            db.flush()
-        
-        # Clear existing meals and add template meals
-        db.query(TrackedMeal).filter(TrackedMeal.tracked_day_id == tracked_day.id).delete()
-        
-        for template_meal in template_meals:
-            tracked_meal = TrackedMeal(
-                tracked_day_id=tracked_day.id,
-                meal_id=template_meal.meal_id,
-                meal_time=template_meal.meal_time
-            )
-            db.add(tracked_meal)
-        
-        tracked_day.is_modified = True
-        db.commit()
-        return {"status": "success", "message": "Template applied successfully"}
-    except Exception as e:
-        db.rollback()
-        logging.error(f"debug: error applying template: {e}")
-        return {"status": "error", "message": str(e)}'''
-        
-        # Append the missing content
-        with open(file_path, 'a') as f:
-            f.write('\n' + missing_content)
-        
-        print("Tracker.py file fixed successfully!")
-    else:
-        print("Tracker.py file appears to be complete")
-
-if __name__ == "__main__":
-    fix_tracker_file()

logging.ini

@@ -0,0 +1,21 @@
+[loggers]
+keys=root
+
+[handlers]
+keys=stream_handler
+
+[formatters]
+keys=formatter
+
+[logger_root]
+level=INFO
+handlers=stream_handler
+
+[handler_stream_handler]
+class=StreamHandler
+level=INFO
+formatter=formatter
+args=(sys.stdout,)
+
+[formatter_formatter]
+format=%(asctime)s - %(name)s - %(levelname)s - %(message)s

main.py

@@ -13,11 +13,14 @@ from sqlalchemy import or_
 from sqlalchemy.orm import Session
 from typing import List, Optional
 from datetime import date, datetime
+import time
 import os
 import csv
 import requests
 from fastapi import File, UploadFile
 import logging
+from logging.config import fileConfig
+import sys
 from alembic.config import Config
 from alembic import command
 from apscheduler.schedulers.background import BackgroundScheduler
@@ -25,7 +28,7 @@ import shutil
 import sqlite3
 
 # Configure logging
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+fileConfig('logging.ini', disable_existing_loggers=False)
 
 # Import database components from the database module
 from app.database import DATABASE_URL, engine, Base, get_db, SessionLocal, Food, Meal, MealFood, Plan, Template, TemplateMeal, WeeklyMenu, WeeklyMenuDay, TrackedMeal, FoodCreate, FoodResponse, calculate_meal_nutrition, calculate_day_nutrition, calculate_day_nutrition_tracked
@@ -35,7 +38,9 @@ from app.database import DATABASE_URL, engine, Base, get_db, SessionLocal, Food,
 async def lifespan(app: FastAPI):
     # Startup
     logging.info("DEBUG: Startup event triggered")
+    time.sleep(5)
     run_migrations()
+    
     logging.info("DEBUG: Startup event completed")
 
     # Schedule the backup job - temporarily disabled for debugging
@@ -50,17 +55,15 @@ async def lifespan(app: FastAPI):
 app = FastAPI(title="Meal Planner", lifespan=lifespan)
 templates = Jinja2Templates(directory="templates")
 
-from app.api.routes import foods, meals, plans, templates as templates_router, weekly_menu, tracker, admin, export, charts
+# Import custom filters
+from app.utils import slugify
 
-app.include_router(foods.router, tags=["foods"])
-app.include_router(meals.router, tags=["meals"])
-app.include_router(plans.router, tags=["plans"])
-app.include_router(templates_router.router, tags=["templates"])
-app.include_router(weekly_menu.router, tags=["weekly_menu"])
-app.include_router(tracker.router, tags=["tracker"])
-app.include_router(admin.router, tags=["admin"])
-app.include_router(export.router, tags=["export"])
-app.include_router(charts.router, tags=["charts"])
+# Add custom filters to Jinja2 environment
+templates.env.filters['slugify'] = slugify
+
+from app.api.routes import api_router
+
+app.include_router(api_router)
 
 # Add a logging middleware to see incoming requests
 @app.middleware("http")
@@ -75,7 +78,7 @@ PORT = int(os.getenv("PORT", 8999))
 # This will be called if running directly with Python
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=PORT)
+    uvicorn.run(app, host="0.0.0.0", port=PORT, log_config=None)
     
 # Import Pydantic models from the database module
 from app.database import FoodCreate, FoodResponse, MealCreate, TrackedDayCreate, TrackedMealCreate, FoodExport, MealFoodExport, MealExport, PlanExport, TemplateMealExport, TemplateExport, TemplateMealDetail, TemplateDetail, WeeklyMenuDayExport, WeeklyMenuDayDetail, WeeklyMenuExport, WeeklyMenuDetail, TrackedMealExport, TrackedDayExport, AllData, TrackedDay
@@ -166,7 +169,7 @@ def test_sqlite_connection(db_path):
             dir_perm = stat.filemode(dir_stat.st_mode)
             dir_uid = dir_stat.st_uid
             dir_gid = dir_stat.st_gid
-            logging.info(f"DEBUG: Database directory permissions: {dir_perm}, UID:{dir_uid}, GID:{dir_gid}")
+            logging.info(f"DEBUG: Database directory permissions: {dir_perm}, UID:{dir_uid}, GID:{dir_gid}, CWD: {os.getcwd()}")
             
             # Test write access
             test_file = os.path.join(db_dir, "write_test.txt")
@@ -223,39 +226,46 @@ def test_sqlite_connection(db_path):
         logging.error(f"DEBUG: SQLite connection test failed: {e}", exc_info=True)
         return False
 
+def table_exists(engine, table_name):
+    from sqlalchemy import inspect
+    inspector = inspect(engine)
+    return inspector.has_table(table_name)
+
+def table_has_content(engine, table_name):
+    from sqlalchemy import text
+    with engine.connect() as conn:
+        result = conn.execute(text(f"SELECT COUNT(*) FROM {table_name}")).scalar()
+        return result > 0
+
 def run_migrations():
     logging.info("DEBUG: Starting database setup...")
     try:
-        # Extract database path from URL
-        db_path = DATABASE_URL.split("///")[1]
-        logging.info(f"DEBUG: Database path extracted: {db_path}")
+        alembic_cfg = Config("alembic.ini")
         
-        # Create directory if needed
-        db_dir = os.path.dirname(db_path)
-        logging.info(f"DEBUG: Database directory: {db_dir}")
-        if not os.path.exists(db_dir):
-            logging.info(f"DEBUG: Creating database directory: {db_dir}")
-            os.makedirs(db_dir, exist_ok=True)
-            logging.info(f"DEBUG: Database directory created successfully")
-        else:
-            logging.info(f"DEBUG: Database directory already exists")
+        # Create a new engine for checking tables
+        from sqlalchemy import create_engine
+        db_url = DATABASE_URL
+        temp_engine = create_engine(db_url)
         
-        # Test SQLite connection
-        logging.info("DEBUG: Testing SQLite connection...")
-        if not test_sqlite_connection(db_path):
-            logging.error("DEBUG: SQLite connection test failed")
-            raise Exception("SQLite connection test failed")
-        logging.info("DEBUG: SQLite connection test passed")
+        # Check if the database is old and needs to be stamped
+        has_alembic_version = table_exists(temp_engine, 'alembic_version')
+        has_foods = table_exists(temp_engine, 'foods')
+        alembic_version_has_content = has_alembic_version and table_has_content(temp_engine, 'alembic_version')
         
-        # Create all tables using SQLAlchemy directly instead of alembic
-        logging.info("DEBUG: Creating database tables using SQLAlchemy...")
-        Base.metadata.create_all(bind=engine)
-        logging.info("DEBUG: Database tables created successfully.")
+        logging.info(f"DEBUG: has_alembic_version: {has_alembic_version}, has_foods: {has_foods}, alembic_version_has_content: {alembic_version_has_content}")
         
-        logging.info("DEBUG: Database setup completed, returning to caller")
+        if has_foods and (not has_alembic_version or not alembic_version_has_content):
+            logging.info("DEBUG: Existing database detected. Stamping with initial migration.")
+            # Stamp with the specific initial migration that creates all tables
+            command.stamp(alembic_cfg, "cf94fca21104")
+            logging.info("DEBUG: Database stamped successfully.")
+
+        # Now, run upgrades to bring the database to the latest version
+        logging.info("DEBUG: Running alembic upgrade...")
+        command.upgrade(alembic_cfg, "head")
+        logging.info("DEBUG: Database migrations run successfully.")
     except Exception as e:
         logging.error(f"DEBUG: Failed to setup database: {e}", exc_info=True)
-        raise
 
 # Routes
 @app.get("/", response_class=HTMLResponse)
@@ -267,4 +277,8 @@ async def root(request: Request):
 @app.get("/test")
 async def test_route():
     logging.info("DEBUG: Test route called")
+# Add a test route to check template inheritance
+@app.get("/test_template", response_class=HTMLResponse)
+async def test_template(request: Request):
+    return templates.TemplateResponse("test_template.html", {"request": request, "person": "Sarah"})
     return {"status": "success", "message": "Test route is working"}

migrate_to_postgres.py

@@ -0,0 +1,150 @@
+import os
+import sys
+import logging
+from sqlalchemy import create_engine, text, inspect
+from sqlalchemy.orm import sessionmaker
+
+# Import models to ensure simple table discovery if needed, 
+# though we will mostly work with raw tables or inspection.
+from app.database import Base, Food, Meal, MealFood, Plan, Template, TemplateMeal, WeeklyMenu, WeeklyMenuDay, TrackedDay, TrackedMeal, TrackedMealFood, FitbitConfig, WeightLog
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+def migrate():
+    import argparse
+
+    parser = argparse.ArgumentParser(description='Migrate data from SQLite to PostgreSQL')
+    parser.add_argument('--sqlite-path', help='Path to source SQLite database file', default=os.getenv('SQLITE_PATH', '/app/data/meal_planner.db'))
+    parser.add_argument('--pg-url', help='PostgreSQL connection URL', default=os.getenv('PG_DATABASE_URL'))
+    
+    args = parser.parse_args()
+
+    # Configuration
+    # Source: SQLite
+    sqlite_path = args.sqlite_path
+    sqlite_url = f"sqlite:///{sqlite_path}"
+    
+    # Destination: Postgres
+    if args.pg_url:
+        pg_url = args.pg_url
+    else:
+        # update this if running externally
+        pg_user = os.getenv('POSTGRES_USER', 'user')
+        pg_password = os.getenv('POSTGRES_PASSWORD', 'password')
+        pg_host = os.getenv('POSTGRES_HOST', 'postgres')
+        pg_db = os.getenv('POSTGRES_DB', 'meal_planner')
+        pg_url = f"postgresql://{pg_user}:{pg_password}@{pg_host}/{pg_db}"
+
+    logger.info(f"Source SQLite: {sqlite_url}")
+    logger.info(f"Destination Postgres: {pg_url}")
+
+    # Create Engines
+    try:
+        sqlite_engine = create_engine(sqlite_url)
+        pg_engine = create_engine(pg_url)
+        
+        # Test connections
+        with sqlite_engine.connect() as conn:
+            pass
+        logger.info("Connected to SQLite.")
+        
+        with pg_engine.connect() as conn:
+            pass
+        logger.info("Connected to Postgres.")
+        
+    except Exception as e:
+        logger.error(f"Failed to connect to databases: {e}")
+        return
+
+    # Create tables in Postgres if they don't exist
+    # Using the Base metadata from the app
+    logger.info("Creating tables in Postgres...")
+    Base.metadata.drop_all(pg_engine) # Clean start to avoid conflicts
+    Base.metadata.create_all(pg_engine)
+    logger.info("Tables created.")
+
+    # Define table order to respect Foreign Keys
+    tables_ordered = [
+        'foods',
+        'meals',
+        'meal_foods',
+        'templates',
+        'template_meals',
+        'weekly_menus',
+        'weekly_menu_days',
+        'plans',
+        'tracked_days',
+        'tracked_meals',
+        'tracked_meal_foods',
+        'fitbit_config',
+        'weight_logs'
+    ]
+
+    # Migration Loop
+    with sqlite_engine.connect() as sqlite_conn, pg_engine.connect() as pg_conn:
+        for table_name in tables_ordered:
+            logger.info(f"Migrating table: {table_name}")
+            
+            # Read from SQLite
+            try:
+                # Use raw SQL to get all data, handling potential missing tables gracefully if app changed
+                result = sqlite_conn.execute(text(f"SELECT * FROM {table_name}"))
+                rows = result.fetchall()
+                keys = result.keys()
+                
+                if not rows:
+                    logger.info(f"  No data in {table_name}, skipping.")
+                    continue
+                
+                # Insert into Postgres
+                # We simply create a list of dicts
+                data = [dict(zip(keys, row)) for row in rows]
+                
+                # Setup insert statement
+                # We use SQLAlchemy core to make it db-agnostic enough
+                table_obj = Base.metadata.tables[table_name]
+                
+                pg_conn.execute(table_obj.insert(), data)
+                pg_conn.commit()
+                
+                logger.info(f"  Migrated {len(rows)} rows.")
+                
+                # Reset Sequence for Serial ID columns
+                # Postgres sequences usually named table_id_seq
+                if 'id' in keys:
+                    # Find max id
+                    max_id = max(row[0] for row in rows) # Assuming 'id' is first or we can look it up.
+                    # Safer:
+                    max_id_val = 0
+                    for d in data:
+                        if d['id'] > max_id_val:
+                            max_id_val = d['id']
+                    
+                    if max_id_val > 0:
+                        seq_name = f"{table_name}_id_seq"
+                        # Check if sequence exists (it should for Serial)
+                        try:
+                            pg_conn.execute(text(f"SELECT setval('{seq_name}', {max_id_val})"))
+                            pg_conn.commit()
+                            logger.info(f"  Sequence {seq_name} reset to {max_id_val}")
+                        except Exception as seq_err:
+                            logger.warn(f"  Could not reset sequence {seq_name} (might not exist): {seq_err}")
+                            pg_conn.rollback()
+
+            except Exception as e:
+                # Check for "no such table" specific error which is common if a feature isn't used
+                if "no such table" in str(e):
+                    logger.warning(f"  Table {table_name} not found in source SQLite. Skipping.")
+                    continue
+                
+                logger.error(f"Error migrating {table_name}: {e}")
+                pg_conn.rollback()
+                # Decide whether to stop or continue. Stopping is safer.
+                return
+
+    logger.info("Migration completed successfully.")
+
+if __name__ == "__main__":
+    migrate()

node_modules/.bin/playwright

@@ -0,0 +1 @@
+../@playwright/test/cli.js

node_modules/.bin/playwright-core

@@ -0,0 +1 @@
+../playwright-core/cli.js

node_modules/.package-lock.json

@@ -0,0 +1,51 @@
+{
+  "name": "food-planner-tests",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "node_modules/@playwright/test": {
+      "version": "1.55.1",
+      "resolved": "https://registry.npmjs.org/@playwright/test/-/test-1.55.1.tgz",
+      "integrity": "sha512-IVAh/nOJaw6W9g+RJVlIQJ6gSiER+ae6mKQ5CX1bERzQgbC1VSeBlwdvczT7pxb0GWiyrxH4TGKbMfDb4Sq/ig==",
+      "dev": true,
+      "dependencies": {
+        "playwright": "1.55.1"
+      },
+      "bin": {
+        "playwright": "cli.js"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/playwright": {
+      "version": "1.55.1",
+      "resolved": "https://registry.npmjs.org/playwright/-/playwright-1.55.1.tgz",
+      "integrity": "sha512-cJW4Xd/G3v5ovXtJJ52MAOclqeac9S/aGGgRzLabuF8TnIb6xHvMzKIa6JmrRzUkeXJgfL1MhukP0NK6l39h3A==",
+      "dependencies": {
+        "playwright-core": "1.55.1"
+      },
+      "bin": {
+        "playwright": "cli.js"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "optionalDependencies": {
+        "fsevents": "2.3.2"
+      }
+    },
+    "node_modules/playwright-core": {
+      "version": "1.55.1",
+      "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.55.1.tgz",
+      "integrity": "sha512-Z6Mh9mkwX+zxSlHqdr5AOcJnfp+xUWLCt9uKV18fhzA8eyxUd8NUWzAjxUh55RZKSYwDGX0cfaySdhZJGMoJ+w==",
+      "bin": {
+        "playwright-core": "cli.js"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    }
+  }
+}

node_modules/@playwright/test/LICENSE

@@ -0,0 +1,202 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Portions Copyright (c) Microsoft Corporation.
+   Portions Copyright 2017 Google Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

node_modules/@playwright/test/NOTICE

@@ -0,0 +1,5 @@
+Playwright
+Copyright (c) Microsoft Corporation
+
+This software contains code derived from the Puppeteer project (https://github.com/puppeteer/puppeteer),
+available under the Apache 2.0 license (https://github.com/puppeteer/puppeteer/blob/master/LICENSE).

node_modules/@playwright/test/README.md

@@ -0,0 +1,168 @@
+# 🎭 Playwright
+
+[![npm version](https://img.shields.io/npm/v/playwright.svg)](https://www.npmjs.com/package/playwright) <!-- GEN:chromium-version-badge -->[![Chromium version](https://img.shields.io/badge/chromium-140.0.7339.186-blue.svg?logo=google-chrome)](https://www.chromium.org/Home)<!-- GEN:stop --> <!-- GEN:firefox-version-badge -->[![Firefox version](https://img.shields.io/badge/firefox-141.0-blue.svg?logo=firefoxbrowser)](https://www.mozilla.org/en-US/firefox/new/)<!-- GEN:stop --> <!-- GEN:webkit-version-badge -->[![WebKit version](https://img.shields.io/badge/webkit-26.0-blue.svg?logo=safari)](https://webkit.org/)<!-- GEN:stop --> [![Join Discord](https://img.shields.io/badge/join-discord-informational)](https://aka.ms/playwright/discord)
+
+## [Documentation](https://playwright.dev) | [API reference](https://playwright.dev/docs/api/class-playwright)
+
+Playwright is a framework for Web Testing and Automation. It allows testing [Chromium](https://www.chromium.org/Home), [Firefox](https://www.mozilla.org/en-US/firefox/new/) and [WebKit](https://webkit.org/) with a single API. Playwright is built to enable cross-browser web automation that is **ever-green**, **capable**, **reliable** and **fast**.
+
+|          | Linux | macOS | Windows |
+|   :---   | :---: | :---: | :---:   |
+| Chromium <!-- GEN:chromium-version -->140.0.7339.186<!-- GEN:stop --> | :white_check_mark: | :white_check_mark: | :white_check_mark: |
+| WebKit <!-- GEN:webkit-version -->26.0<!-- GEN:stop --> | :white_check_mark: | :white_check_mark: | :white_check_mark: |
+| Firefox <!-- GEN:firefox-version -->141.0<!-- GEN:stop --> | :white_check_mark: | :white_check_mark: | :white_check_mark: |
+
+Headless execution is supported for all browsers on all platforms. Check out [system requirements](https://playwright.dev/docs/intro#system-requirements) for details.
+
+Looking for Playwright for [Python](https://playwright.dev/python/docs/intro), [.NET](https://playwright.dev/dotnet/docs/intro), or [Java](https://playwright.dev/java/docs/intro)?
+
+## Installation
+
+Playwright has its own test runner for end-to-end tests, we call it Playwright Test.
+
+### Using init command
+
+The easiest way to get started with Playwright Test is to run the init command.
+
+```Shell
+# Run from your project's root directory
+npm init playwright@latest
+# Or create a new project
+npm init playwright@latest new-project
+```
+
+This will create a configuration file, optionally add examples, a GitHub Action workflow and a first test example.spec.ts. You can now jump directly to writing assertions section.
+
+### Manually
+
+Add dependency and install browsers.
+
+```Shell
+npm i -D @playwright/test
+# install supported browsers
+npx playwright install
+```
+
+You can optionally install only selected browsers, see [install browsers](https://playwright.dev/docs/cli#install-browsers) for more details. Or you can install no browsers at all and use existing [browser channels](https://playwright.dev/docs/browsers).
+
+* [Getting started](https://playwright.dev/docs/intro)
+* [API reference](https://playwright.dev/docs/api/class-playwright)
+
+## Capabilities
+
+### Resilient • No flaky tests
+
+**Auto-wait**. Playwright waits for elements to be actionable prior to performing actions. It also has a rich set of introspection events. The combination of the two eliminates the need for artificial timeouts - a primary cause of flaky tests.
+
+**Web-first assertions**. Playwright assertions are created specifically for the dynamic web. Checks are automatically retried until the necessary conditions are met.
+
+**Tracing**. Configure test retry strategy, capture execution trace, videos and screenshots to eliminate flakes.
+
+### No trade-offs • No limits
+
+Browsers run web content belonging to different origins in different processes. Playwright is aligned with the architecture of the modern browsers and runs tests out-of-process. This makes Playwright free of the typical in-process test runner limitations.
+
+**Multiple everything**. Test scenarios that span multiple tabs, multiple origins and multiple users. Create scenarios with different contexts for different users and run them against your server, all in one test.
+
+**Trusted events**. Hover elements, interact with dynamic controls and produce trusted events. Playwright uses real browser input pipeline indistinguishable from the real user.
+
+Test frames, pierce Shadow DOM. Playwright selectors pierce shadow DOM and allow entering frames seamlessly.
+
+### Full isolation • Fast execution
+
+**Browser contexts**. Playwright creates a browser context for each test. Browser context is equivalent to a brand new browser profile. This delivers full test isolation with zero overhead. Creating a new browser context only takes a handful of milliseconds.
+
+**Log in once**. Save the authentication state of the context and reuse it in all the tests. This bypasses repetitive log-in operations in each test, yet delivers full isolation of independent tests.
+
+### Powerful Tooling
+
+**[Codegen](https://playwright.dev/docs/codegen)**. Generate tests by recording your actions. Save them into any language.
+
+**[Playwright inspector](https://playwright.dev/docs/inspector)**. Inspect page, generate selectors, step through the test execution, see click points and explore execution logs.
+
+**[Trace Viewer](https://playwright.dev/docs/trace-viewer)**. Capture all the information to investigate the test failure. Playwright trace contains test execution screencast, live DOM snapshots, action explorer, test source and many more.
+
+Looking for Playwright for [TypeScript](https://playwright.dev/docs/intro), [JavaScript](https://playwright.dev/docs/intro), [Python](https://playwright.dev/python/docs/intro), [.NET](https://playwright.dev/dotnet/docs/intro), or [Java](https://playwright.dev/java/docs/intro)?
+
+## Examples
+
+To learn how to run these Playwright Test examples, check out our [getting started docs](https://playwright.dev/docs/intro).
+
+#### Page screenshot
+
+This code snippet navigates to Playwright homepage and saves a screenshot.
+
+```TypeScript
+import { test } from '@playwright/test';
+
+test('Page Screenshot', async ({ page }) => {
+  await page.goto('https://playwright.dev/');
+  await page.screenshot({ path: `example.png` });
+});
+```
+
+#### Mobile and geolocation
+
+This snippet emulates Mobile Safari on a device at given geolocation, navigates to maps.google.com, performs the action and takes a screenshot.
+
+```TypeScript
+import { test, devices } from '@playwright/test';
+
+test.use({
+  ...devices['iPhone 13 Pro'],
+  locale: 'en-US',
+  geolocation: { longitude: 12.492507, latitude: 41.889938 },
+  permissions: ['geolocation'],
+})
+
+test('Mobile and geolocation', async ({ page }) => {
+  await page.goto('https://maps.google.com');
+  await page.getByText('Your location').click();
+  await page.waitForRequest(/.*preview\/pwa/);
+  await page.screenshot({ path: 'colosseum-iphone.png' });
+});
+```
+
+#### Evaluate in browser context
+
+This code snippet navigates to example.com, and executes a script in the page context.
+
+```TypeScript
+import { test } from '@playwright/test';
+
+test('Evaluate in browser context', async ({ page }) => {
+  await page.goto('https://www.example.com/');
+  const dimensions = await page.evaluate(() => {
+    return {
+      width: document.documentElement.clientWidth,
+      height: document.documentElement.clientHeight,
+      deviceScaleFactor: window.devicePixelRatio
+    }
+  });
+  console.log(dimensions);
+});
+```
+
+#### Intercept network requests
+
+This code snippet sets up request routing for a page to log all network requests.
+
+```TypeScript
+import { test } from '@playwright/test';
+
+test('Intercept network requests', async ({ page }) => {
+  // Log and continue all network requests
+  await page.route('**', route => {
+    console.log(route.request().url());
+    route.continue();
+  });
+  await page.goto('http://todomvc.com');
+});
+```
+
+## Resources
+
+* [Documentation](https://playwright.dev)
+* [API reference](https://playwright.dev/docs/api/class-playwright/)
+* [Contribution guide](CONTRIBUTING.md)
+* [Changelog](https://github.com/microsoft/playwright/releases)

node_modules/@playwright/test/cli.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const { program } = require('playwright/lib/program');
+program.parse(process.argv);

node_modules/@playwright/test/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export * from 'playwright/test';
+export { default } from 'playwright/test';

node_modules/@playwright/test/index.js

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+module.exports = require('playwright/test');

node_modules/@playwright/test/index.mjs

@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export * from 'playwright/test';
+export { default } from 'playwright/test';

node_modules/@playwright/test/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@playwright/test",
+  "version": "1.55.1",
+  "description": "A high-level API to automate web browsers",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/microsoft/playwright.git"
+  },
+  "homepage": "https://playwright.dev",
+  "engines": {
+    "node": ">=18"
+  },
+  "author": {
+    "name": "Microsoft Corporation"
+  },
+  "license": "Apache-2.0",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.mjs",
+      "require": "./index.js",
+      "default": "./index.js"
+    },
+    "./cli": "./cli.js",
+    "./package.json": "./package.json",
+    "./reporter": "./reporter.js"
+  },
+  "bin": {
+    "playwright": "cli.js"
+  },
+  "scripts": {},
+  "dependencies": {
+    "playwright": "1.55.1"
+  }
+}

node_modules/@playwright/test/reporter.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export * from 'playwright/types/testReporter';

node_modules/@playwright/test/reporter.js

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// We only export types in reporter.d.ts.

node_modules/@playwright/test/reporter.mjs

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// We only export types in reporter.d.ts.

node_modules/playwright-core/LICENSE

@@ -0,0 +1,202 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Portions Copyright (c) Microsoft Corporation.
+   Portions Copyright 2017 Google Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

node_modules/playwright-core/NOTICE

@@ -0,0 +1,5 @@
+Playwright
+Copyright (c) Microsoft Corporation
+
+This software contains code derived from the Puppeteer project (https://github.com/puppeteer/puppeteer),
+available under the Apache 2.0 license (https://github.com/puppeteer/puppeteer/blob/master/LICENSE).

node_modules/playwright-core/README.md

@@ -0,0 +1,3 @@
+# playwright-core
+
+This package contains the no-browser flavor of [Playwright](http://github.com/microsoft/playwright).

node_modules/playwright-core/bin/install_media_pack.ps1

@@ -0,0 +1,5 @@
+$osInfo = Get-WmiObject -Class Win32_OperatingSystem
+# check if running on Windows Server
+if ($osInfo.ProductType -eq 3) {
+  Install-WindowsFeature Server-Media-Foundation
+}

node_modules/playwright-core/bin/reinstall_chrome_beta_linux.sh

@@ -0,0 +1,42 @@
+#!/usr/bin/env bash
+set -e
+set -x
+
+if [[ $(arch) == "aarch64" ]]; then
+  echo "ERROR: not supported on Linux Arm64"
+  exit 1
+fi
+
+if [ -z "$PLAYWRIGHT_HOST_PLATFORM_OVERRIDE" ]; then
+  if [[ ! -f "/etc/os-release" ]]; then
+    echo "ERROR: cannot install on unknown linux distribution (/etc/os-release is missing)"
+    exit 1
+  fi
+
+  ID=$(bash -c 'source /etc/os-release && echo $ID')
+  if [[ "${ID}" != "ubuntu" && "${ID}" != "debian" ]]; then
+    echo "ERROR: cannot install on $ID distribution - only Ubuntu and Debian are supported"
+    exit 1
+  fi
+fi
+
+# 1. make sure to remove old beta if any.
+if dpkg --get-selections | grep -q "^google-chrome-beta[[:space:]]*install$" >/dev/null; then
+  apt-get remove -y google-chrome-beta
+fi
+
+# 2. Update apt lists (needed to install curl and chrome dependencies)
+apt-get update
+
+# 3. Install curl to download chrome
+if ! command -v curl >/dev/null; then
+  apt-get install -y curl
+fi
+
+# 4. download chrome beta from dl.google.com and install it.
+cd /tmp
+curl -O https://dl.google.com/linux/direct/google-chrome-beta_current_amd64.deb
+apt-get install -y ./google-chrome-beta_current_amd64.deb
+rm -rf ./google-chrome-beta_current_amd64.deb
+cd -
+google-chrome-beta --version

node_modules/playwright-core/bin/reinstall_chrome_beta_mac.sh

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+set -e
+set -x
+
+rm -rf "/Applications/Google Chrome Beta.app"
+cd /tmp
+curl --retry 3 -o ./googlechromebeta.dmg https://dl.google.com/chrome/mac/universal/beta/googlechromebeta.dmg
+hdiutil attach -nobrowse -quiet -noautofsck -noautoopen -mountpoint /Volumes/googlechromebeta.dmg ./googlechromebeta.dmg
+cp -pR "/Volumes/googlechromebeta.dmg/Google Chrome Beta.app" /Applications
+hdiutil detach /Volumes/googlechromebeta.dmg
+rm -rf /tmp/googlechromebeta.dmg
+
+/Applications/Google\ Chrome\ Beta.app/Contents/MacOS/Google\ Chrome\ Beta --version

node_modules/playwright-core/bin/reinstall_chrome_beta_win.ps1

@@ -0,0 +1,24 @@
+$ErrorActionPreference = 'Stop'
+
+$url = 'https://dl.google.com/tag/s/dl/chrome/install/beta/googlechromebetastandaloneenterprise64.msi'
+
+Write-Host "Downloading Google Chrome Beta"
+$wc = New-Object net.webclient
+$msiInstaller = "$env:temp\google-chrome-beta.msi"
+$wc.Downloadfile($url, $msiInstaller)
+
+Write-Host "Installing Google Chrome Beta"
+$arguments = "/i `"$msiInstaller`" /quiet"
+Start-Process msiexec.exe -ArgumentList $arguments -Wait
+Remove-Item $msiInstaller
+
+$suffix = "\\Google\\Chrome Beta\\Application\\chrome.exe"
+if (Test-Path "${env:ProgramFiles(x86)}$suffix") {
+    (Get-Item "${env:ProgramFiles(x86)}$suffix").VersionInfo
+} elseif (Test-Path "${env:ProgramFiles}$suffix") {
+    (Get-Item "${env:ProgramFiles}$suffix").VersionInfo
+} else {
+    Write-Host "ERROR: Failed to install Google Chrome Beta."
+    Write-Host "ERROR: This could be due to insufficient privileges, in which case re-running as Administrator may help."
+    exit 1
+}

node_modules/playwright-core/bin/reinstall_chrome_stable_linux.sh

@@ -0,0 +1,42 @@
+#!/usr/bin/env bash
+set -e
+set -x
+
+if [[ $(arch) == "aarch64" ]]; then
+  echo "ERROR: not supported on Linux Arm64"
+  exit 1
+fi
+
+if [ -z "$PLAYWRIGHT_HOST_PLATFORM_OVERRIDE" ]; then
+  if [[ ! -f "/etc/os-release" ]]; then
+    echo "ERROR: cannot install on unknown linux distribution (/etc/os-release is missing)"
+    exit 1
+  fi
+
+  ID=$(bash -c 'source /etc/os-release && echo $ID')
+  if [[ "${ID}" != "ubuntu" && "${ID}" != "debian" ]]; then
+    echo "ERROR: cannot install on $ID distribution - only Ubuntu and Debian are supported"
+    exit 1
+  fi
+fi
+
+# 1. make sure to remove old stable if any.
+if dpkg --get-selections | grep -q "^google-chrome[[:space:]]*install$" >/dev/null; then
+  apt-get remove -y google-chrome
+fi
+
+# 2. Update apt lists (needed to install curl and chrome dependencies)
+apt-get update
+
+# 3. Install curl to download chrome
+if ! command -v curl >/dev/null; then
+  apt-get install -y curl
+fi
+
+# 4. download chrome stable from dl.google.com and install it.
+cd /tmp
+curl -O https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb
+apt-get install -y ./google-chrome-stable_current_amd64.deb
+rm -rf ./google-chrome-stable_current_amd64.deb
+cd -
+google-chrome --version

node_modules/playwright-core/bin/reinstall_chrome_stable_mac.sh

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+set -e
+set -x
+
+rm -rf "/Applications/Google Chrome.app"
+cd /tmp
+curl --retry 3 -o ./googlechrome.dmg https://dl.google.com/chrome/mac/universal/stable/GGRO/googlechrome.dmg
+hdiutil attach -nobrowse -quiet -noautofsck -noautoopen -mountpoint /Volumes/googlechrome.dmg ./googlechrome.dmg
+cp -pR "/Volumes/googlechrome.dmg/Google Chrome.app" /Applications
+hdiutil detach /Volumes/googlechrome.dmg
+rm -rf /tmp/googlechrome.dmg
+/Applications/Google\ Chrome.app/Contents/MacOS/Google\ Chrome --version

node_modules/playwright-core/bin/reinstall_chrome_stable_win.ps1

@@ -0,0 +1,24 @@
+$ErrorActionPreference = 'Stop'
+$url = 'https://dl.google.com/tag/s/dl/chrome/install/googlechromestandaloneenterprise64.msi'
+
+$wc = New-Object net.webclient
+$msiInstaller = "$env:temp\google-chrome.msi"
+Write-Host "Downloading Google Chrome"
+$wc.Downloadfile($url, $msiInstaller)
+
+Write-Host "Installing Google Chrome"
+$arguments = "/i `"$msiInstaller`" /quiet"
+Start-Process msiexec.exe -ArgumentList $arguments -Wait
+Remove-Item $msiInstaller
+
+
+$suffix = "\\Google\\Chrome\\Application\\chrome.exe"
+if (Test-Path "${env:ProgramFiles(x86)}$suffix") {
+    (Get-Item "${env:ProgramFiles(x86)}$suffix").VersionInfo
+} elseif (Test-Path "${env:ProgramFiles}$suffix") {
+    (Get-Item "${env:ProgramFiles}$suffix").VersionInfo
+} else {
+    Write-Host "ERROR: Failed to install Google Chrome."
+    Write-Host "ERROR: This could be due to insufficient privileges, in which case re-running as Administrator may help."
+    exit 1
+}

node_modules/playwright-core/bin/reinstall_msedge_beta_linux.sh

@@ -0,0 +1,48 @@
+#!/usr/bin/env bash
+
+set -e
+set -x
+
+if [[ $(arch) == "aarch64" ]]; then
+  echo "ERROR: not supported on Linux Arm64"
+  exit 1
+fi
+
+if [ -z "$PLAYWRIGHT_HOST_PLATFORM_OVERRIDE" ]; then
+  if [[ ! -f "/etc/os-release" ]]; then
+    echo "ERROR: cannot install on unknown linux distribution (/etc/os-release is missing)"
+    exit 1
+  fi
+
+  ID=$(bash -c 'source /etc/os-release && echo $ID')
+  if [[ "${ID}" != "ubuntu" && "${ID}" != "debian" ]]; then
+    echo "ERROR: cannot install on $ID distribution - only Ubuntu and Debian are supported"
+    exit 1
+  fi
+fi
+
+# 1. make sure to remove old beta if any.
+if dpkg --get-selections | grep -q "^microsoft-edge-beta[[:space:]]*install$" >/dev/null; then
+  apt-get remove -y microsoft-edge-beta
+fi
+
+# 2. Install curl to download Microsoft gpg key
+if ! command -v curl >/dev/null; then
+  apt-get update
+  apt-get install -y curl
+fi
+
+# GnuPG is not preinstalled in slim images
+if ! command -v gpg >/dev/null; then
+  apt-get update
+  apt-get install -y gpg
+fi
+
+# 3. Add the GPG key, the apt repo, update the apt cache, and install the package
+curl https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > /tmp/microsoft.gpg
+install -o root -g root -m 644 /tmp/microsoft.gpg /etc/apt/trusted.gpg.d/
+sh -c 'echo "deb [arch=amd64] https://packages.microsoft.com/repos/edge stable main" > /etc/apt/sources.list.d/microsoft-edge-dev.list'
+rm /tmp/microsoft.gpg
+apt-get update && apt-get install -y microsoft-edge-beta
+
+microsoft-edge-beta --version

node_modules/playwright-core/bin/reinstall_msedge_beta_mac.sh

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+set -e
+set -x
+
+cd /tmp
+curl --retry 3 -o ./msedge_beta.pkg "$1"
+# Note: there's no way to uninstall previously installed MSEdge.
+# However, running PKG again seems to update installation.
+sudo installer -pkg /tmp/msedge_beta.pkg -target /
+rm -rf /tmp/msedge_beta.pkg
+/Applications/Microsoft\ Edge\ Beta.app/Contents/MacOS/Microsoft\ Edge\ Beta --version

node_modules/playwright-core/bin/reinstall_msedge_beta_win.ps1

@@ -0,0 +1,23 @@
+$ErrorActionPreference = 'Stop'
+$url = $args[0]
+
+Write-Host "Downloading Microsoft Edge Beta"
+$wc = New-Object net.webclient
+$msiInstaller = "$env:temp\microsoft-edge-beta.msi"
+$wc.Downloadfile($url, $msiInstaller)
+
+Write-Host "Installing Microsoft Edge Beta"
+$arguments = "/i `"$msiInstaller`" /quiet"
+Start-Process msiexec.exe -ArgumentList $arguments -Wait
+Remove-Item $msiInstaller
+
+$suffix = "\\Microsoft\\Edge Beta\\Application\\msedge.exe"
+if (Test-Path "${env:ProgramFiles(x86)}$suffix") {
+    (Get-Item "${env:ProgramFiles(x86)}$suffix").VersionInfo
+} elseif (Test-Path "${env:ProgramFiles}$suffix") {
+    (Get-Item "${env:ProgramFiles}$suffix").VersionInfo
+} else {
+    Write-Host "ERROR: Failed to install Microsoft Edge Beta."
+    Write-Host "ERROR: This could be due to insufficient privileges, in which case re-running as Administrator may help."
+    exit 1
+}

node_modules/playwright-core/bin/reinstall_msedge_dev_linux.sh

@@ -0,0 +1,48 @@
+#!/usr/bin/env bash
+
+set -e
+set -x
+
+if [[ $(arch) == "aarch64" ]]; then
+  echo "ERROR: not supported on Linux Arm64"
+  exit 1
+fi
+
+if [ -z "$PLAYWRIGHT_HOST_PLATFORM_OVERRIDE" ]; then
+  if [[ ! -f "/etc/os-release" ]]; then
+    echo "ERROR: cannot install on unknown linux distribution (/etc/os-release is missing)"
+    exit 1
+  fi
+
+  ID=$(bash -c 'source /etc/os-release && echo $ID')
+  if [[ "${ID}" != "ubuntu" && "${ID}" != "debian" ]]; then
+    echo "ERROR: cannot install on $ID distribution - only Ubuntu and Debian are supported"
+    exit 1
+  fi
+fi
+
+# 1. make sure to remove old dev if any.
+if dpkg --get-selections | grep -q "^microsoft-edge-dev[[:space:]]*install$" >/dev/null; then
+  apt-get remove -y microsoft-edge-dev
+fi
+
+# 2. Install curl to download Microsoft gpg key
+if ! command -v curl >/dev/null; then
+  apt-get update
+  apt-get install -y curl
+fi
+
+# GnuPG is not preinstalled in slim images
+if ! command -v gpg >/dev/null; then
+  apt-get update
+  apt-get install -y gpg
+fi
+
+# 3. Add the GPG key, the apt repo, update the apt cache, and install the package
+curl https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > /tmp/microsoft.gpg
+install -o root -g root -m 644 /tmp/microsoft.gpg /etc/apt/trusted.gpg.d/
+sh -c 'echo "deb [arch=amd64] https://packages.microsoft.com/repos/edge stable main" > /etc/apt/sources.list.d/microsoft-edge-dev.list'
+rm /tmp/microsoft.gpg
+apt-get update && apt-get install -y microsoft-edge-dev
+
+microsoft-edge-dev --version

node_modules/playwright-core/bin/reinstall_msedge_dev_mac.sh

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+set -e
+set -x
+
+cd /tmp
+curl --retry 3 -o ./msedge_dev.pkg "$1"
+# Note: there's no way to uninstall previously installed MSEdge.
+# However, running PKG again seems to update installation.
+sudo installer -pkg /tmp/msedge_dev.pkg -target /
+rm -rf /tmp/msedge_dev.pkg
+/Applications/Microsoft\ Edge\ Dev.app/Contents/MacOS/Microsoft\ Edge\ Dev --version

node_modules/playwright-core/bin/reinstall_msedge_dev_win.ps1

@@ -0,0 +1,23 @@
+$ErrorActionPreference = 'Stop'
+$url = $args[0]
+
+Write-Host "Downloading Microsoft Edge Dev"
+$wc = New-Object net.webclient
+$msiInstaller = "$env:temp\microsoft-edge-dev.msi"
+$wc.Downloadfile($url, $msiInstaller)
+
+Write-Host "Installing Microsoft Edge Dev"
+$arguments = "/i `"$msiInstaller`" /quiet"
+Start-Process msiexec.exe -ArgumentList $arguments -Wait
+Remove-Item $msiInstaller
+
+$suffix = "\\Microsoft\\Edge Dev\\Application\\msedge.exe"
+if (Test-Path "${env:ProgramFiles(x86)}$suffix") {
+    (Get-Item "${env:ProgramFiles(x86)}$suffix").VersionInfo
+} elseif (Test-Path "${env:ProgramFiles}$suffix") {
+    (Get-Item "${env:ProgramFiles}$suffix").VersionInfo
+} else {
+    Write-Host "ERROR: Failed to install Microsoft Edge Dev."
+    Write-Host "ERROR: This could be due to insufficient privileges, in which case re-running as Administrator may help."
+    exit 1
+}

node_modules/playwright-core/bin/reinstall_msedge_stable_linux.sh

@@ -0,0 +1,48 @@
+#!/usr/bin/env bash
+
+set -e
+set -x
+
+if [[ $(arch) == "aarch64" ]]; then
+  echo "ERROR: not supported on Linux Arm64"
+  exit 1
+fi
+
+if [ -z "$PLAYWRIGHT_HOST_PLATFORM_OVERRIDE" ]; then
+  if [[ ! -f "/etc/os-release" ]]; then
+    echo "ERROR: cannot install on unknown linux distribution (/etc/os-release is missing)"
+    exit 1
+  fi
+
+  ID=$(bash -c 'source /etc/os-release && echo $ID')
+  if [[ "${ID}" != "ubuntu" && "${ID}" != "debian" ]]; then
+    echo "ERROR: cannot install on $ID distribution - only Ubuntu and Debian are supported"
+    exit 1
+  fi
+fi
+
+# 1. make sure to remove old stable if any.
+if dpkg --get-selections | grep -q "^microsoft-edge-stable[[:space:]]*install$" >/dev/null; then
+  apt-get remove -y microsoft-edge-stable
+fi
+
+# 2. Install curl to download Microsoft gpg key
+if ! command -v curl >/dev/null; then
+  apt-get update
+  apt-get install -y curl
+fi
+
+# GnuPG is not preinstalled in slim images
+if ! command -v gpg >/dev/null; then
+  apt-get update
+  apt-get install -y gpg
+fi
+
+# 3. Add the GPG key, the apt repo, update the apt cache, and install the package
+curl https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > /tmp/microsoft.gpg
+install -o root -g root -m 644 /tmp/microsoft.gpg /etc/apt/trusted.gpg.d/
+sh -c 'echo "deb [arch=amd64] https://packages.microsoft.com/repos/edge stable main" > /etc/apt/sources.list.d/microsoft-edge-stable.list'
+rm /tmp/microsoft.gpg
+apt-get update && apt-get install -y microsoft-edge-stable
+
+microsoft-edge-stable --version

node_modules/playwright-core/bin/reinstall_msedge_stable_mac.sh

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+set -e
+set -x
+
+cd /tmp
+curl --retry 3 -o ./msedge_stable.pkg "$1"
+# Note: there's no way to uninstall previously installed MSEdge.
+# However, running PKG again seems to update installation.
+sudo installer -pkg /tmp/msedge_stable.pkg -target /
+rm -rf /tmp/msedge_stable.pkg
+/Applications/Microsoft\ Edge.app/Contents/MacOS/Microsoft\ Edge --version

node_modules/playwright-core/bin/reinstall_msedge_stable_win.ps1

@@ -0,0 +1,24 @@
+$ErrorActionPreference = 'Stop'
+
+$url = $args[0]
+
+Write-Host "Downloading Microsoft Edge"
+$wc = New-Object net.webclient
+$msiInstaller = "$env:temp\microsoft-edge-stable.msi"
+$wc.Downloadfile($url, $msiInstaller)
+
+Write-Host "Installing Microsoft Edge"
+$arguments = "/i `"$msiInstaller`" /quiet"
+Start-Process msiexec.exe -ArgumentList $arguments -Wait
+Remove-Item $msiInstaller
+
+$suffix = "\\Microsoft\\Edge\\Application\\msedge.exe"
+if (Test-Path "${env:ProgramFiles(x86)}$suffix") {
+    (Get-Item "${env:ProgramFiles(x86)}$suffix").VersionInfo
+} elseif (Test-Path "${env:ProgramFiles}$suffix") {
+    (Get-Item "${env:ProgramFiles}$suffix").VersionInfo
+} else {
+    Write-Host "ERROR: Failed to install Microsoft Edge."
+    Write-Host "ERROR: This could be due to insufficient privileges, in which case re-running as Administrator may help."
+    exit 1
+}

node_modules/playwright-core/browsers.json

@@ -0,0 +1,80 @@
+{
+  "comment": "Do not edit this file, use utils/roll_browser.js",
+  "browsers": [
+    {
+      "name": "chromium",
+      "revision": "1193",
+      "installByDefault": true,
+      "browserVersion": "140.0.7339.186"
+    },
+    {
+      "name": "chromium-headless-shell",
+      "revision": "1193",
+      "installByDefault": true,
+      "browserVersion": "140.0.7339.186"
+    },
+    {
+      "name": "chromium-tip-of-tree",
+      "revision": "1357",
+      "installByDefault": false,
+      "browserVersion": "141.0.7342.0"
+    },
+    {
+      "name": "chromium-tip-of-tree-headless-shell",
+      "revision": "1357",
+      "installByDefault": false,
+      "browserVersion": "141.0.7342.0"
+    },
+    {
+      "name": "firefox",
+      "revision": "1490",
+      "installByDefault": true,
+      "browserVersion": "141.0"
+    },
+    {
+      "name": "firefox-beta",
+      "revision": "1485",
+      "installByDefault": false,
+      "browserVersion": "142.0b4"
+    },
+    {
+      "name": "webkit",
+      "revision": "2203",
+      "installByDefault": true,
+      "revisionOverrides": {
+        "debian11-x64": "2105",
+        "debian11-arm64": "2105",
+        "mac10.14": "1446",
+        "mac10.15": "1616",
+        "mac11": "1816",
+        "mac11-arm64": "1816",
+        "mac12": "2009",
+        "mac12-arm64": "2009",
+        "mac13": "2140",
+        "mac13-arm64": "2140",
+        "ubuntu20.04-x64": "2092",
+        "ubuntu20.04-arm64": "2092"
+      },
+      "browserVersion": "26.0"
+    },
+    {
+      "name": "ffmpeg",
+      "revision": "1011",
+      "installByDefault": true,
+      "revisionOverrides": {
+        "mac12": "1010",
+        "mac12-arm64": "1010"
+      }
+    },
+    {
+      "name": "winldd",
+      "revision": "1007",
+      "installByDefault": false
+    },
+    {
+      "name": "android",
+      "revision": "1001",
+      "installByDefault": false
+    }
+  ]
+}

node_modules/playwright-core/cli.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const { program } = require('./lib/cli/programWithTestStub');
+program.parse(process.argv);

node_modules/playwright-core/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export * from './types/types';

node_modules/playwright-core/index.js

@@ -0,0 +1,32 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const minimumMajorNodeVersion = 18;
+const currentNodeVersion = process.versions.node;
+const semver = currentNodeVersion.split('.');
+const [major] = [+semver[0]];
+
+if (major < minimumMajorNodeVersion) {
+  console.error(
+      'You are running Node.js ' +
+      currentNodeVersion +
+      '.\n' +
+      `Playwright requires Node.js ${minimumMajorNodeVersion} or higher. \n` +
+      'Please update your version of Node.js.'
+  );
+  process.exit(1);
+}
+
+module.exports = require('./lib/inprocess');

node_modules/playwright-core/index.mjs

@@ -0,0 +1,28 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import playwright from './index.js';
+
+export const chromium = playwright.chromium;
+export const firefox = playwright.firefox;
+export const webkit = playwright.webkit;
+export const selectors = playwright.selectors;
+export const devices = playwright.devices;
+export const errors = playwright.errors;
+export const request = playwright.request;
+export const _electron = playwright._electron;
+export const _android = playwright._android;
+export default playwright;

node_modules/playwright-core/lib/androidServerImpl.js

@@ -0,0 +1,65 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var androidServerImpl_exports = {};
+__export(androidServerImpl_exports, {
+  AndroidServerLauncherImpl: () => AndroidServerLauncherImpl
+});
+module.exports = __toCommonJS(androidServerImpl_exports);
+var import_playwrightServer = require("./remote/playwrightServer");
+var import_playwright = require("./server/playwright");
+var import_crypto = require("./server/utils/crypto");
+var import_utilsBundle = require("./utilsBundle");
+var import_progress = require("./server/progress");
+class AndroidServerLauncherImpl {
+  async launchServer(options = {}) {
+    const playwright = (0, import_playwright.createPlaywright)({ sdkLanguage: "javascript", isServer: true });
+    const controller = new import_progress.ProgressController();
+    let devices = await controller.run((progress) => playwright.android.devices(progress, {
+      host: options.adbHost,
+      port: options.adbPort,
+      omitDriverInstall: options.omitDriverInstall
+    }));
+    if (devices.length === 0)
+      throw new Error("No devices found");
+    if (options.deviceSerialNumber) {
+      devices = devices.filter((d) => d.serial === options.deviceSerialNumber);
+      if (devices.length === 0)
+        throw new Error(`No device with serial number '${options.deviceSerialNumber}' was found`);
+    }
+    if (devices.length > 1)
+      throw new Error(`More than one device found. Please specify deviceSerialNumber`);
+    const device = devices[0];
+    const path = options.wsPath ? options.wsPath.startsWith("/") ? options.wsPath : `/${options.wsPath}` : `/${(0, import_crypto.createGuid)()}`;
+    const server = new import_playwrightServer.PlaywrightServer({ mode: "launchServer", path, maxConnections: 1, preLaunchedAndroidDevice: device });
+    const wsEndpoint = await server.listen(options.port, options.host);
+    const browserServer = new import_utilsBundle.ws.EventEmitter();
+    browserServer.wsEndpoint = () => wsEndpoint;
+    browserServer.close = () => device.close();
+    browserServer.kill = () => device.close();
+    device.on("close", () => {
+      server.close();
+      browserServer.emit("close");
+    });
+    return browserServer;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AndroidServerLauncherImpl
+});

node_modules/playwright-core/lib/browserServerImpl.js

@@ -0,0 +1,123 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var browserServerImpl_exports = {};
+__export(browserServerImpl_exports, {
+  BrowserServerLauncherImpl: () => BrowserServerLauncherImpl
+});
+module.exports = __toCommonJS(browserServerImpl_exports);
+var import_playwrightServer = require("./remote/playwrightServer");
+var import_helper = require("./server/helper");
+var import_playwright = require("./server/playwright");
+var import_crypto = require("./server/utils/crypto");
+var import_debug = require("./server/utils/debug");
+var import_stackTrace = require("./utils/isomorphic/stackTrace");
+var import_time = require("./utils/isomorphic/time");
+var import_utilsBundle = require("./utilsBundle");
+var validatorPrimitives = __toESM(require("./protocol/validatorPrimitives"));
+var import_progress = require("./server/progress");
+class BrowserServerLauncherImpl {
+  constructor(browserName) {
+    this._browserName = browserName;
+  }
+  async launchServer(options = {}) {
+    const playwright = (0, import_playwright.createPlaywright)({ sdkLanguage: "javascript", isServer: true });
+    const metadata = { id: "", startTime: 0, endTime: 0, type: "Internal", method: "", params: {}, log: [], internal: true };
+    const validatorContext = {
+      tChannelImpl: (names, arg, path) => {
+        throw new validatorPrimitives.ValidationError(`${path}: channels are not expected in launchServer`);
+      },
+      binary: "buffer",
+      isUnderTest: import_debug.isUnderTest
+    };
+    let launchOptions = {
+      ...options,
+      ignoreDefaultArgs: Array.isArray(options.ignoreDefaultArgs) ? options.ignoreDefaultArgs : void 0,
+      ignoreAllDefaultArgs: !!options.ignoreDefaultArgs && !Array.isArray(options.ignoreDefaultArgs),
+      env: options.env ? envObjectToArray(options.env) : void 0,
+      timeout: options.timeout ?? import_time.DEFAULT_PLAYWRIGHT_LAUNCH_TIMEOUT
+    };
+    let browser;
+    try {
+      const controller = new import_progress.ProgressController(metadata);
+      browser = await controller.run(async (progress) => {
+        if (options._userDataDir !== void 0) {
+          const validator = validatorPrimitives.scheme["BrowserTypeLaunchPersistentContextParams"];
+          launchOptions = validator({ ...launchOptions, userDataDir: options._userDataDir }, "", validatorContext);
+          const context = await playwright[this._browserName].launchPersistentContext(progress, options._userDataDir, launchOptions);
+          return context._browser;
+        } else {
+          const validator = validatorPrimitives.scheme["BrowserTypeLaunchParams"];
+          launchOptions = validator(launchOptions, "", validatorContext);
+          return await playwright[this._browserName].launch(progress, launchOptions, toProtocolLogger(options.logger));
+        }
+      });
+    } catch (e) {
+      const log = import_helper.helper.formatBrowserLogs(metadata.log);
+      (0, import_stackTrace.rewriteErrorMessage)(e, `${e.message} Failed to launch browser.${log}`);
+      throw e;
+    }
+    return this.launchServerOnExistingBrowser(browser, options);
+  }
+  async launchServerOnExistingBrowser(browser, options) {
+    const path = options.wsPath ? options.wsPath.startsWith("/") ? options.wsPath : `/${options.wsPath}` : `/${(0, import_crypto.createGuid)()}`;
+    const server = new import_playwrightServer.PlaywrightServer({ mode: options._sharedBrowser ? "launchServerShared" : "launchServer", path, maxConnections: Infinity, preLaunchedBrowser: browser, debugController: options._debugController });
+    const wsEndpoint = await server.listen(options.port, options.host);
+    const browserServer = new import_utilsBundle.ws.EventEmitter();
+    browserServer.process = () => browser.options.browserProcess.process;
+    browserServer.wsEndpoint = () => wsEndpoint;
+    browserServer.close = () => browser.options.browserProcess.close();
+    browserServer[Symbol.asyncDispose] = browserServer.close;
+    browserServer.kill = () => browser.options.browserProcess.kill();
+    browserServer._disconnectForTest = () => server.close();
+    browserServer._userDataDirForTest = browser._userDataDirForTest;
+    browser.options.browserProcess.onclose = (exitCode, signal) => {
+      server.close();
+      browserServer.emit("close", exitCode, signal);
+    };
+    return browserServer;
+  }
+}
+function toProtocolLogger(logger) {
+  return logger ? (direction, message) => {
+    if (logger.isEnabled("protocol", "verbose"))
+      logger.log("protocol", "verbose", (direction === "send" ? "SEND \u25BA " : "\u25C0 RECV ") + JSON.stringify(message), [], {});
+  } : void 0;
+}
+function envObjectToArray(env) {
+  const result = [];
+  for (const name in env) {
+    if (!Object.is(env[name], void 0))
+      result.push({ name, value: String(env[name]) });
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BrowserServerLauncherImpl
+});

node_modules/playwright-core/lib/cli/driver.js

@@ -0,0 +1,97 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var driver_exports = {};
+__export(driver_exports, {
+  launchBrowserServer: () => launchBrowserServer,
+  printApiJson: () => printApiJson,
+  runDriver: () => runDriver,
+  runServer: () => runServer
+});
+module.exports = __toCommonJS(driver_exports);
+var import_fs = __toESM(require("fs"));
+var playwright = __toESM(require("../.."));
+var import_pipeTransport = require("../server/utils/pipeTransport");
+var import_playwrightServer = require("../remote/playwrightServer");
+var import_server = require("../server");
+var import_processLauncher = require("../server/utils/processLauncher");
+function printApiJson() {
+  console.log(JSON.stringify(require("../../api.json")));
+}
+function runDriver() {
+  const dispatcherConnection = new import_server.DispatcherConnection();
+  new import_server.RootDispatcher(dispatcherConnection, async (rootScope, { sdkLanguage }) => {
+    const playwright2 = (0, import_server.createPlaywright)({ sdkLanguage });
+    return new import_server.PlaywrightDispatcher(rootScope, playwright2);
+  });
+  const transport = new import_pipeTransport.PipeTransport(process.stdout, process.stdin);
+  transport.onmessage = (message) => dispatcherConnection.dispatch(JSON.parse(message));
+  const isJavaScriptLanguageBinding = !process.env.PW_LANG_NAME || process.env.PW_LANG_NAME === "javascript";
+  const replacer = !isJavaScriptLanguageBinding && String.prototype.toWellFormed ? (key, value) => {
+    if (typeof value === "string")
+      return value.toWellFormed();
+    return value;
+  } : void 0;
+  dispatcherConnection.onmessage = (message) => transport.send(JSON.stringify(message, replacer));
+  transport.onclose = () => {
+    dispatcherConnection.onmessage = () => {
+    };
+    (0, import_processLauncher.gracefullyProcessExitDoNotHang)(0);
+  };
+  process.on("SIGINT", () => {
+  });
+}
+async function runServer(options) {
+  const {
+    port,
+    host,
+    path = "/",
+    maxConnections = Infinity,
+    extension
+  } = options;
+  const server = new import_playwrightServer.PlaywrightServer({ mode: extension ? "extension" : "default", path, maxConnections });
+  const wsEndpoint = await server.listen(port, host);
+  process.on("exit", () => server.close().catch(console.error));
+  console.log("Listening on " + wsEndpoint);
+  process.stdin.on("close", () => (0, import_processLauncher.gracefullyProcessExitDoNotHang)(0));
+}
+async function launchBrowserServer(browserName, configFile) {
+  let options = {};
+  if (configFile)
+    options = JSON.parse(import_fs.default.readFileSync(configFile).toString());
+  const browserType = playwright[browserName];
+  const server = await browserType.launchServer(options);
+  console.log(server.wsEndpoint());
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  launchBrowserServer,
+  printApiJson,
+  runDriver,
+  runServer
+});

node_modules/playwright-core/lib/cli/program.js

@@ -0,0 +1,633 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var program_exports = {};
+__export(program_exports, {
+  program: () => import_utilsBundle2.program
+});
+module.exports = __toCommonJS(program_exports);
+var import_fs = __toESM(require("fs"));
+var import_os = __toESM(require("os"));
+var import_path = __toESM(require("path"));
+var playwright = __toESM(require("../.."));
+var import_driver = require("./driver");
+var import_server = require("../server");
+var import_utils = require("../utils");
+var import_traceViewer = require("../server/trace/viewer/traceViewer");
+var import_utils2 = require("../utils");
+var import_ascii = require("../server/utils/ascii");
+var import_utilsBundle = require("../utilsBundle");
+var import_utilsBundle2 = require("../utilsBundle");
+const packageJSON = require("../../package.json");
+import_utilsBundle.program.version("Version " + (process.env.PW_CLI_DISPLAY_VERSION || packageJSON.version)).name(buildBasePlaywrightCLICommand(process.env.PW_LANG_NAME));
+import_utilsBundle.program.command("mark-docker-image [dockerImageNameTemplate]", { hidden: true }).description("mark docker image").allowUnknownOption(true).action(function(dockerImageNameTemplate) {
+  (0, import_utils2.assert)(dockerImageNameTemplate, "dockerImageNameTemplate is required");
+  (0, import_server.writeDockerVersion)(dockerImageNameTemplate).catch(logErrorAndExit);
+});
+commandWithOpenOptions("open [url]", "open page in browser specified via -b, --browser", []).action(function(url, options) {
+  open(options, url).catch(logErrorAndExit);
+}).addHelpText("afterAll", `
+Examples:
+
+  $ open
+  $ open -b webkit https://example.com`);
+commandWithOpenOptions(
+  "codegen [url]",
+  "open page and generate code for user actions",
+  [
+    ["-o, --output <file name>", "saves the generated script to a file"],
+    ["--target <language>", `language to generate, one of javascript, playwright-test, python, python-async, python-pytest, csharp, csharp-mstest, csharp-nunit, java, java-junit`, codegenId()],
+    ["--test-id-attribute <attributeName>", "use the specified attribute to generate data test ID selectors"]
+  ]
+).action(async function(url, options) {
+  await codegen(options, url);
+}).addHelpText("afterAll", `
+Examples:
+
+  $ codegen
+  $ codegen --target=python
+  $ codegen -b webkit https://example.com`);
+function suggestedBrowsersToInstall() {
+  return import_server.registry.executables().filter((e) => e.installType !== "none" && e.type !== "tool").map((e) => e.name).join(", ");
+}
+function defaultBrowsersToInstall(options) {
+  let executables = import_server.registry.defaultExecutables();
+  if (options.noShell)
+    executables = executables.filter((e) => e.name !== "chromium-headless-shell");
+  if (options.onlyShell)
+    executables = executables.filter((e) => e.name !== "chromium");
+  return executables;
+}
+function checkBrowsersToInstall(args, options) {
+  if (options.noShell && options.onlyShell)
+    throw new Error(`Only one of --no-shell and --only-shell can be specified`);
+  const faultyArguments = [];
+  const executables = [];
+  const handleArgument = (arg) => {
+    const executable = import_server.registry.findExecutable(arg);
+    if (!executable || executable.installType === "none")
+      faultyArguments.push(arg);
+    else
+      executables.push(executable);
+    if (executable?.browserName === "chromium")
+      executables.push(import_server.registry.findExecutable("ffmpeg"));
+  };
+  for (const arg of args) {
+    if (arg === "chromium") {
+      if (!options.onlyShell)
+        handleArgument("chromium");
+      if (!options.noShell)
+        handleArgument("chromium-headless-shell");
+    } else {
+      handleArgument(arg);
+    }
+  }
+  if (process.platform === "win32")
+    executables.push(import_server.registry.findExecutable("winldd"));
+  if (faultyArguments.length)
+    throw new Error(`Invalid installation targets: ${faultyArguments.map((name) => `'${name}'`).join(", ")}. Expecting one of: ${suggestedBrowsersToInstall()}`);
+  return executables;
+}
+function printInstalledBrowsers(browsers2) {
+  const browserPaths = /* @__PURE__ */ new Set();
+  for (const browser of browsers2)
+    browserPaths.add(browser.browserPath);
+  console.log(`  Browsers:`);
+  for (const browserPath of [...browserPaths].sort())
+    console.log(`    ${browserPath}`);
+  console.log(`  References:`);
+  const references = /* @__PURE__ */ new Set();
+  for (const browser of browsers2)
+    references.add(browser.referenceDir);
+  for (const reference of [...references].sort())
+    console.log(`    ${reference}`);
+}
+function printGroupedByPlaywrightVersion(browsers2) {
+  const dirToVersion = /* @__PURE__ */ new Map();
+  for (const browser of browsers2) {
+    if (dirToVersion.has(browser.referenceDir))
+      continue;
+    const packageJSON2 = require(import_path.default.join(browser.referenceDir, "package.json"));
+    const version = packageJSON2.version;
+    dirToVersion.set(browser.referenceDir, version);
+  }
+  const groupedByPlaywrightMinorVersion = /* @__PURE__ */ new Map();
+  for (const browser of browsers2) {
+    const version = dirToVersion.get(browser.referenceDir);
+    let entries = groupedByPlaywrightMinorVersion.get(version);
+    if (!entries) {
+      entries = [];
+      groupedByPlaywrightMinorVersion.set(version, entries);
+    }
+    entries.push(browser);
+  }
+  const sortedVersions = [...groupedByPlaywrightMinorVersion.keys()].sort((a, b) => {
+    const aComponents = a.split(".");
+    const bComponents = b.split(".");
+    const aMajor = parseInt(aComponents[0], 10);
+    const bMajor = parseInt(bComponents[0], 10);
+    if (aMajor !== bMajor)
+      return aMajor - bMajor;
+    const aMinor = parseInt(aComponents[1], 10);
+    const bMinor = parseInt(bComponents[1], 10);
+    if (aMinor !== bMinor)
+      return aMinor - bMinor;
+    return aComponents.slice(2).join(".").localeCompare(bComponents.slice(2).join("."));
+  });
+  for (const version of sortedVersions) {
+    console.log(`
+Playwright version: ${version}`);
+    printInstalledBrowsers(groupedByPlaywrightMinorVersion.get(version));
+  }
+}
+import_utilsBundle.program.command("install [browser...]").description("ensure browsers necessary for this version of Playwright are installed").option("--with-deps", "install system dependencies for browsers").option("--dry-run", "do not execute installation, only print information").option("--list", "prints list of browsers from all playwright installations").option("--force", "force reinstall of stable browser channels").option("--only-shell", "only install headless shell when installing chromium").option("--no-shell", "do not install chromium headless shell").action(async function(args, options) {
+  if (options.shell === false)
+    options.noShell = true;
+  if ((0, import_utils.isLikelyNpxGlobal)()) {
+    console.error((0, import_ascii.wrapInASCIIBox)([
+      `WARNING: It looks like you are running 'npx playwright install' without first`,
+      `installing your project's dependencies.`,
+      ``,
+      `To avoid unexpected behavior, please install your dependencies first, and`,
+      `then run Playwright's install command:`,
+      ``,
+      `    npm install`,
+      `    npx playwright install`,
+      ``,
+      `If your project does not yet depend on Playwright, first install the`,
+      `applicable npm package (most commonly @playwright/test), and`,
+      `then run Playwright's install command to download the browsers:`,
+      ``,
+      `    npm install @playwright/test`,
+      `    npx playwright install`,
+      ``
+    ].join("\n"), 1));
+  }
+  try {
+    const hasNoArguments = !args.length;
+    const executables = hasNoArguments ? defaultBrowsersToInstall(options) : checkBrowsersToInstall(args, options);
+    if (options.withDeps)
+      await import_server.registry.installDeps(executables, !!options.dryRun);
+    if (options.dryRun && options.list)
+      throw new Error(`Only one of --dry-run and --list can be specified`);
+    if (options.dryRun) {
+      for (const executable of executables) {
+        const version = executable.browserVersion ? `version ` + executable.browserVersion : "";
+        console.log(`browser: ${executable.name}${version ? " " + version : ""}`);
+        console.log(`  Install location:    ${executable.directory ?? "<system>"}`);
+        if (executable.downloadURLs?.length) {
+          const [url, ...fallbacks] = executable.downloadURLs;
+          console.log(`  Download url:        ${url}`);
+          for (let i = 0; i < fallbacks.length; ++i)
+            console.log(`  Download fallback ${i + 1}: ${fallbacks[i]}`);
+        }
+        console.log(``);
+      }
+    } else if (options.list) {
+      const browsers2 = await import_server.registry.listInstalledBrowsers();
+      printGroupedByPlaywrightVersion(browsers2);
+    } else {
+      const forceReinstall = hasNoArguments ? false : !!options.force;
+      await import_server.registry.install(executables, forceReinstall);
+      await import_server.registry.validateHostRequirementsForExecutablesIfNeeded(executables, process.env.PW_LANG_NAME || "javascript").catch((e) => {
+        e.name = "Playwright Host validation warning";
+        console.error(e);
+      });
+    }
+  } catch (e) {
+    console.log(`Failed to install browsers
+${e}`);
+    (0, import_utils.gracefullyProcessExitDoNotHang)(1);
+  }
+}).addHelpText("afterAll", `
+
+Examples:
+  - $ install
+    Install default browsers.
+
+  - $ install chrome firefox
+    Install custom browsers, supports ${suggestedBrowsersToInstall()}.`);
+import_utilsBundle.program.command("uninstall").description("Removes browsers used by this installation of Playwright from the system (chromium, firefox, webkit, ffmpeg). This does not include branded channels.").option("--all", "Removes all browsers used by any Playwright installation from the system.").action(async (options) => {
+  delete process.env.PLAYWRIGHT_SKIP_BROWSER_GC;
+  await import_server.registry.uninstall(!!options.all).then(({ numberOfBrowsersLeft }) => {
+    if (!options.all && numberOfBrowsersLeft > 0) {
+      console.log("Successfully uninstalled Playwright browsers for the current Playwright installation.");
+      console.log(`There are still ${numberOfBrowsersLeft} browsers left, used by other Playwright installations.
+To uninstall Playwright browsers for all installations, re-run with --all flag.`);
+    }
+  }).catch(logErrorAndExit);
+});
+import_utilsBundle.program.command("install-deps [browser...]").description("install dependencies necessary to run browsers (will ask for sudo permissions)").option("--dry-run", "Do not execute installation commands, only print them").action(async function(args, options) {
+  try {
+    if (!args.length)
+      await import_server.registry.installDeps(defaultBrowsersToInstall({}), !!options.dryRun);
+    else
+      await import_server.registry.installDeps(checkBrowsersToInstall(args, {}), !!options.dryRun);
+  } catch (e) {
+    console.log(`Failed to install browser dependencies
+${e}`);
+    (0, import_utils.gracefullyProcessExitDoNotHang)(1);
+  }
+}).addHelpText("afterAll", `
+Examples:
+  - $ install-deps
+    Install dependencies for default browsers.
+
+  - $ install-deps chrome firefox
+    Install dependencies for specific browsers, supports ${suggestedBrowsersToInstall()}.`);
+const browsers = [
+  { alias: "cr", name: "Chromium", type: "chromium" },
+  { alias: "ff", name: "Firefox", type: "firefox" },
+  { alias: "wk", name: "WebKit", type: "webkit" }
+];
+for (const { alias, name, type } of browsers) {
+  commandWithOpenOptions(`${alias} [url]`, `open page in ${name}`, []).action(function(url, options) {
+    open({ ...options, browser: type }, url).catch(logErrorAndExit);
+  }).addHelpText("afterAll", `
+Examples:
+
+  $ ${alias} https://example.com`);
+}
+commandWithOpenOptions(
+  "screenshot <url> <filename>",
+  "capture a page screenshot",
+  [
+    ["--wait-for-selector <selector>", "wait for selector before taking a screenshot"],
+    ["--wait-for-timeout <timeout>", "wait for timeout in milliseconds before taking a screenshot"],
+    ["--full-page", "whether to take a full page screenshot (entire scrollable area)"]
+  ]
+).action(function(url, filename, command) {
+  screenshot(command, command, url, filename).catch(logErrorAndExit);
+}).addHelpText("afterAll", `
+Examples:
+
+  $ screenshot -b webkit https://example.com example.png`);
+commandWithOpenOptions(
+  "pdf <url> <filename>",
+  "save page as pdf",
+  [
+    ["--paper-format <format>", "paper format: Letter, Legal, Tabloid, Ledger, A0, A1, A2, A3, A4, A5, A6"],
+    ["--wait-for-selector <selector>", "wait for given selector before saving as pdf"],
+    ["--wait-for-timeout <timeout>", "wait for given timeout in milliseconds before saving as pdf"]
+  ]
+).action(function(url, filename, options) {
+  pdf(options, options, url, filename).catch(logErrorAndExit);
+}).addHelpText("afterAll", `
+Examples:
+
+  $ pdf https://example.com example.pdf`);
+import_utilsBundle.program.command("run-driver", { hidden: true }).action(function(options) {
+  (0, import_driver.runDriver)();
+});
+import_utilsBundle.program.command("run-server").option("--port <port>", "Server port").option("--host <host>", "Server host").option("--path <path>", "Endpoint Path", "/").option("--max-clients <maxClients>", "Maximum clients").option("--mode <mode>", 'Server mode, either "default" or "extension"').action(function(options) {
+  (0, import_driver.runServer)({
+    port: options.port ? +options.port : void 0,
+    host: options.host,
+    path: options.path,
+    maxConnections: options.maxClients ? +options.maxClients : Infinity,
+    extension: options.mode === "extension" || !!process.env.PW_EXTENSION_MODE
+  }).catch(logErrorAndExit);
+});
+import_utilsBundle.program.command("print-api-json", { hidden: true }).action(function(options) {
+  (0, import_driver.printApiJson)();
+});
+import_utilsBundle.program.command("launch-server", { hidden: true }).requiredOption("--browser <browserName>", 'Browser name, one of "chromium", "firefox" or "webkit"').option("--config <path-to-config-file>", "JSON file with launchServer options").action(function(options) {
+  (0, import_driver.launchBrowserServer)(options.browser, options.config);
+});
+import_utilsBundle.program.command("show-trace [trace...]").option("-b, --browser <browserType>", "browser to use, one of cr, chromium, ff, firefox, wk, webkit", "chromium").option("-h, --host <host>", "Host to serve trace on; specifying this option opens trace in a browser tab").option("-p, --port <port>", "Port to serve trace on, 0 for any free port; specifying this option opens trace in a browser tab").option("--stdin", "Accept trace URLs over stdin to update the viewer").description("show trace viewer").action(function(traces, options) {
+  if (options.browser === "cr")
+    options.browser = "chromium";
+  if (options.browser === "ff")
+    options.browser = "firefox";
+  if (options.browser === "wk")
+    options.browser = "webkit";
+  const openOptions = {
+    host: options.host,
+    port: +options.port,
+    isServer: !!options.stdin
+  };
+  if (options.port !== void 0 || options.host !== void 0)
+    (0, import_traceViewer.runTraceInBrowser)(traces, openOptions).catch(logErrorAndExit);
+  else
+    (0, import_traceViewer.runTraceViewerApp)(traces, options.browser, openOptions, true).catch(logErrorAndExit);
+}).addHelpText("afterAll", `
+Examples:
+
+  $ show-trace https://example.com/trace.zip`);
+async function launchContext(options, extraOptions) {
+  validateOptions(options);
+  const browserType = lookupBrowserType(options);
+  const launchOptions = extraOptions;
+  if (options.channel)
+    launchOptions.channel = options.channel;
+  launchOptions.handleSIGINT = false;
+  const contextOptions = (
+    // Copy the device descriptor since we have to compare and modify the options.
+    options.device ? { ...playwright.devices[options.device] } : {}
+  );
+  if (!extraOptions.headless)
+    contextOptions.deviceScaleFactor = import_os.default.platform() === "darwin" ? 2 : 1;
+  if (browserType.name() === "webkit" && process.platform === "linux") {
+    delete contextOptions.hasTouch;
+    delete contextOptions.isMobile;
+  }
+  if (contextOptions.isMobile && browserType.name() === "firefox")
+    contextOptions.isMobile = void 0;
+  if (options.blockServiceWorkers)
+    contextOptions.serviceWorkers = "block";
+  if (options.proxyServer) {
+    launchOptions.proxy = {
+      server: options.proxyServer
+    };
+    if (options.proxyBypass)
+      launchOptions.proxy.bypass = options.proxyBypass;
+  }
+  if (options.viewportSize) {
+    try {
+      const [width, height] = options.viewportSize.split(",").map((n) => +n);
+      if (isNaN(width) || isNaN(height))
+        throw new Error("bad values");
+      contextOptions.viewport = { width, height };
+    } catch (e) {
+      throw new Error('Invalid viewport size format: use "width,height", for example --viewport-size="800,600"');
+    }
+  }
+  if (options.geolocation) {
+    try {
+      const [latitude, longitude] = options.geolocation.split(",").map((n) => parseFloat(n.trim()));
+      contextOptions.geolocation = {
+        latitude,
+        longitude
+      };
+    } catch (e) {
+      throw new Error('Invalid geolocation format, should be "lat,long". For example --geolocation="37.819722,-122.478611"');
+    }
+    contextOptions.permissions = ["geolocation"];
+  }
+  if (options.userAgent)
+    contextOptions.userAgent = options.userAgent;
+  if (options.lang)
+    contextOptions.locale = options.lang;
+  if (options.colorScheme)
+    contextOptions.colorScheme = options.colorScheme;
+  if (options.timezone)
+    contextOptions.timezoneId = options.timezone;
+  if (options.loadStorage)
+    contextOptions.storageState = options.loadStorage;
+  if (options.ignoreHttpsErrors)
+    contextOptions.ignoreHTTPSErrors = true;
+  if (options.saveHar) {
+    contextOptions.recordHar = { path: import_path.default.resolve(process.cwd(), options.saveHar), mode: "minimal" };
+    if (options.saveHarGlob)
+      contextOptions.recordHar.urlFilter = options.saveHarGlob;
+    contextOptions.serviceWorkers = "block";
+  }
+  let browser;
+  let context;
+  if (options.userDataDir) {
+    context = await browserType.launchPersistentContext(options.userDataDir, { ...launchOptions, ...contextOptions });
+    browser = context.browser();
+  } else {
+    browser = await browserType.launch(launchOptions);
+    context = await browser.newContext(contextOptions);
+  }
+  let closingBrowser = false;
+  async function closeBrowser() {
+    if (closingBrowser)
+      return;
+    closingBrowser = true;
+    if (options.saveStorage)
+      await context.storageState({ path: options.saveStorage }).catch((e) => null);
+    if (options.saveHar)
+      await context.close();
+    await browser.close();
+  }
+  context.on("page", (page) => {
+    page.on("dialog", () => {
+    });
+    page.on("close", () => {
+      const hasPage = browser.contexts().some((context2) => context2.pages().length > 0);
+      if (hasPage)
+        return;
+      closeBrowser().catch(() => {
+      });
+    });
+  });
+  process.on("SIGINT", async () => {
+    await closeBrowser();
+    (0, import_utils.gracefullyProcessExitDoNotHang)(130);
+  });
+  const timeout = options.timeout ? parseInt(options.timeout, 10) : 0;
+  context.setDefaultTimeout(timeout);
+  context.setDefaultNavigationTimeout(timeout);
+  delete launchOptions.headless;
+  delete launchOptions.executablePath;
+  delete launchOptions.handleSIGINT;
+  delete contextOptions.deviceScaleFactor;
+  return { browser, browserName: browserType.name(), context, contextOptions, launchOptions, closeBrowser };
+}
+async function openPage(context, url) {
+  let page = context.pages()[0];
+  if (!page)
+    page = await context.newPage();
+  if (url) {
+    if (import_fs.default.existsSync(url))
+      url = "file://" + import_path.default.resolve(url);
+    else if (!url.startsWith("http") && !url.startsWith("file://") && !url.startsWith("about:") && !url.startsWith("data:"))
+      url = "http://" + url;
+    await page.goto(url);
+  }
+  return page;
+}
+async function open(options, url) {
+  const { context } = await launchContext(options, { headless: !!process.env.PWTEST_CLI_HEADLESS, executablePath: process.env.PWTEST_CLI_EXECUTABLE_PATH });
+  await openPage(context, url);
+}
+async function codegen(options, url) {
+  const { target: language, output: outputFile, testIdAttribute: testIdAttributeName } = options;
+  const tracesDir = import_path.default.join(import_os.default.tmpdir(), `playwright-recorder-trace-${Date.now()}`);
+  const { context, browser, launchOptions, contextOptions, closeBrowser } = await launchContext(options, {
+    headless: !!process.env.PWTEST_CLI_HEADLESS,
+    executablePath: process.env.PWTEST_CLI_EXECUTABLE_PATH,
+    tracesDir
+  });
+  const donePromise = new import_utils.ManualPromise();
+  maybeSetupTestHooks(browser, closeBrowser, donePromise);
+  import_utilsBundle.dotenv.config({ path: "playwright.env" });
+  await context._enableRecorder({
+    language,
+    launchOptions,
+    contextOptions,
+    device: options.device,
+    saveStorage: options.saveStorage,
+    mode: "recording",
+    testIdAttributeName,
+    outputFile: outputFile ? import_path.default.resolve(outputFile) : void 0,
+    handleSIGINT: false
+  });
+  await openPage(context, url);
+  donePromise.resolve();
+}
+async function maybeSetupTestHooks(browser, closeBrowser, donePromise) {
+  if (!process.env.PWTEST_CLI_IS_UNDER_TEST)
+    return;
+  const logs = [];
+  require("playwright-core/lib/utilsBundle").debug.log = (...args) => {
+    const line = require("util").format(...args) + "\n";
+    logs.push(line);
+    process.stderr.write(line);
+  };
+  browser.on("disconnected", () => {
+    const hasCrashLine = logs.some((line) => line.includes("process did exit:") && !line.includes("process did exit: exitCode=0, signal=null"));
+    if (hasCrashLine) {
+      process.stderr.write("Detected browser crash.\n");
+      (0, import_utils.gracefullyProcessExitDoNotHang)(1);
+    }
+  });
+  const close = async () => {
+    await donePromise;
+    await closeBrowser();
+  };
+  if (process.env.PWTEST_CLI_EXIT_AFTER_TIMEOUT) {
+    setTimeout(close, +process.env.PWTEST_CLI_EXIT_AFTER_TIMEOUT);
+    return;
+  }
+  let stdin = "";
+  process.stdin.on("data", (data) => {
+    stdin += data.toString();
+    if (stdin.startsWith("exit")) {
+      process.stdin.destroy();
+      close();
+    }
+  });
+}
+async function waitForPage(page, captureOptions) {
+  if (captureOptions.waitForSelector) {
+    console.log(`Waiting for selector ${captureOptions.waitForSelector}...`);
+    await page.waitForSelector(captureOptions.waitForSelector);
+  }
+  if (captureOptions.waitForTimeout) {
+    console.log(`Waiting for timeout ${captureOptions.waitForTimeout}...`);
+    await page.waitForTimeout(parseInt(captureOptions.waitForTimeout, 10));
+  }
+}
+async function screenshot(options, captureOptions, url, path2) {
+  const { context } = await launchContext(options, { headless: true });
+  console.log("Navigating to " + url);
+  const page = await openPage(context, url);
+  await waitForPage(page, captureOptions);
+  console.log("Capturing screenshot into " + path2);
+  await page.screenshot({ path: path2, fullPage: !!captureOptions.fullPage });
+  await page.close();
+}
+async function pdf(options, captureOptions, url, path2) {
+  if (options.browser !== "chromium")
+    throw new Error("PDF creation is only working with Chromium");
+  const { context } = await launchContext({ ...options, browser: "chromium" }, { headless: true });
+  console.log("Navigating to " + url);
+  const page = await openPage(context, url);
+  await waitForPage(page, captureOptions);
+  console.log("Saving as pdf into " + path2);
+  await page.pdf({ path: path2, format: captureOptions.paperFormat });
+  await page.close();
+}
+function lookupBrowserType(options) {
+  let name = options.browser;
+  if (options.device) {
+    const device = playwright.devices[options.device];
+    name = device.defaultBrowserType;
+  }
+  let browserType;
+  switch (name) {
+    case "chromium":
+      browserType = playwright.chromium;
+      break;
+    case "webkit":
+      browserType = playwright.webkit;
+      break;
+    case "firefox":
+      browserType = playwright.firefox;
+      break;
+    case "cr":
+      browserType = playwright.chromium;
+      break;
+    case "wk":
+      browserType = playwright.webkit;
+      break;
+    case "ff":
+      browserType = playwright.firefox;
+      break;
+  }
+  if (browserType)
+    return browserType;
+  import_utilsBundle.program.help();
+}
+function validateOptions(options) {
+  if (options.device && !(options.device in playwright.devices)) {
+    const lines = [`Device descriptor not found: '${options.device}', available devices are:`];
+    for (const name in playwright.devices)
+      lines.push(`  "${name}"`);
+    throw new Error(lines.join("\n"));
+  }
+  if (options.colorScheme && !["light", "dark"].includes(options.colorScheme))
+    throw new Error('Invalid color scheme, should be one of "light", "dark"');
+}
+function logErrorAndExit(e) {
+  if (process.env.PWDEBUGIMPL)
+    console.error(e);
+  else
+    console.error(e.name + ": " + e.message);
+  (0, import_utils.gracefullyProcessExitDoNotHang)(1);
+}
+function codegenId() {
+  return process.env.PW_LANG_NAME || "playwright-test";
+}
+function commandWithOpenOptions(command, description, options) {
+  let result = import_utilsBundle.program.command(command).description(description);
+  for (const option of options)
+    result = result.option(option[0], ...option.slice(1));
+  return result.option("-b, --browser <browserType>", "browser to use, one of cr, chromium, ff, firefox, wk, webkit", "chromium").option("--block-service-workers", "block service workers").option("--channel <channel>", 'Chromium distribution channel, "chrome", "chrome-beta", "msedge-dev", etc').option("--color-scheme <scheme>", 'emulate preferred color scheme, "light" or "dark"').option("--device <deviceName>", 'emulate device, for example  "iPhone 11"').option("--geolocation <coordinates>", 'specify geolocation coordinates, for example "37.819722,-122.478611"').option("--ignore-https-errors", "ignore https errors").option("--load-storage <filename>", "load context storage state from the file, previously saved with --save-storage").option("--lang <language>", 'specify language / locale, for example "en-GB"').option("--proxy-server <proxy>", 'specify proxy server, for example "http://myproxy:3128" or "socks5://myproxy:8080"').option("--proxy-bypass <bypass>", 'comma-separated domains to bypass proxy, for example ".com,chromium.org,.domain.com"').option("--save-har <filename>", "save HAR file with all network activity at the end").option("--save-har-glob <glob pattern>", "filter entries in the HAR by matching url against this glob pattern").option("--save-storage <filename>", "save context storage state at the end, for later use with --load-storage").option("--timezone <time zone>", 'time zone to emulate, for example "Europe/Rome"').option("--timeout <timeout>", "timeout for Playwright actions in milliseconds, no timeout by default").option("--user-agent <ua string>", "specify user agent string").option("--user-data-dir <directory>", "use the specified user data directory instead of a new context").option("--viewport-size <size>", 'specify browser viewport size in pixels, for example "1280, 720"');
+}
+function buildBasePlaywrightCLICommand(cliTargetLang) {
+  switch (cliTargetLang) {
+    case "python":
+      return `playwright`;
+    case "java":
+      return `mvn exec:java -e -D exec.mainClass=com.microsoft.playwright.CLI -D exec.args="...options.."`;
+    case "csharp":
+      return `pwsh bin/Debug/netX/playwright.ps1`;
+    default: {
+      const packageManagerCommand = (0, import_utils2.getPackageManagerExecCommand)();
+      return `${packageManagerCommand} playwright`;
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  program
+});

node_modules/playwright-core/lib/cli/programWithTestStub.js

@@ -0,0 +1,74 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var programWithTestStub_exports = {};
+__export(programWithTestStub_exports, {
+  program: () => import_program2.program
+});
+module.exports = __toCommonJS(programWithTestStub_exports);
+var import_processLauncher = require("../server/utils/processLauncher");
+var import_utils = require("../utils");
+var import_program = require("./program");
+var import_program2 = require("./program");
+function printPlaywrightTestError(command) {
+  const packages = [];
+  for (const pkg of ["playwright", "playwright-chromium", "playwright-firefox", "playwright-webkit"]) {
+    try {
+      require.resolve(pkg);
+      packages.push(pkg);
+    } catch (e) {
+    }
+  }
+  if (!packages.length)
+    packages.push("playwright");
+  const packageManager = (0, import_utils.getPackageManager)();
+  if (packageManager === "yarn") {
+    console.error(`Please install @playwright/test package before running "yarn playwright ${command}"`);
+    console.error(`  yarn remove ${packages.join(" ")}`);
+    console.error("  yarn add -D @playwright/test");
+  } else if (packageManager === "pnpm") {
+    console.error(`Please install @playwright/test package before running "pnpm exec playwright ${command}"`);
+    console.error(`  pnpm remove ${packages.join(" ")}`);
+    console.error("  pnpm add -D @playwright/test");
+  } else {
+    console.error(`Please install @playwright/test package before running "npx playwright ${command}"`);
+    console.error(`  npm uninstall ${packages.join(" ")}`);
+    console.error("  npm install -D @playwright/test");
+  }
+}
+const kExternalPlaywrightTestCommands = [
+  ["test", "Run tests with Playwright Test."],
+  ["show-report", "Show Playwright Test HTML report."],
+  ["merge-reports", "Merge Playwright Test Blob reports"]
+];
+function addExternalPlaywrightTestCommands() {
+  for (const [command, description] of kExternalPlaywrightTestCommands) {
+    const playwrightTest = import_program.program.command(command).allowUnknownOption(true).allowExcessArguments(true);
+    playwrightTest.description(`${description} Available in @playwright/test package.`);
+    playwrightTest.action(async () => {
+      printPlaywrightTestError(command);
+      (0, import_processLauncher.gracefullyProcessExitDoNotHang)(1);
+    });
+  }
+}
+if (!process.env.PW_LANG_NAME)
+  addExternalPlaywrightTestCommands();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  program
+});

node_modules/playwright-core/lib/client/accessibility.js

@@ -0,0 +1,49 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var accessibility_exports = {};
+__export(accessibility_exports, {
+  Accessibility: () => Accessibility
+});
+module.exports = __toCommonJS(accessibility_exports);
+function axNodeFromProtocol(axNode) {
+  const result = {
+    ...axNode,
+    value: axNode.valueNumber !== void 0 ? axNode.valueNumber : axNode.valueString,
+    checked: axNode.checked === "checked" ? true : axNode.checked === "unchecked" ? false : axNode.checked,
+    pressed: axNode.pressed === "pressed" ? true : axNode.pressed === "released" ? false : axNode.pressed,
+    children: axNode.children ? axNode.children.map(axNodeFromProtocol) : void 0
+  };
+  delete result.valueNumber;
+  delete result.valueString;
+  return result;
+}
+class Accessibility {
+  constructor(channel) {
+    this._channel = channel;
+  }
+  async snapshot(options = {}) {
+    const root = options.root ? options.root._elementChannel : void 0;
+    const result = await this._channel.accessibilitySnapshot({ interestingOnly: options.interestingOnly, root });
+    return result.rootAXNode ? axNodeFromProtocol(result.rootAXNode) : null;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Accessibility
+});

node_modules/playwright-core/lib/client/android.js

@@ -0,0 +1,361 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var android_exports = {};
+__export(android_exports, {
+  Android: () => Android,
+  AndroidDevice: () => AndroidDevice,
+  AndroidInput: () => AndroidInput,
+  AndroidSocket: () => AndroidSocket,
+  AndroidWebView: () => AndroidWebView
+});
+module.exports = __toCommonJS(android_exports);
+var import_eventEmitter = require("./eventEmitter");
+var import_browserContext = require("./browserContext");
+var import_channelOwner = require("./channelOwner");
+var import_errors = require("./errors");
+var import_events = require("./events");
+var import_waiter = require("./waiter");
+var import_timeoutSettings = require("./timeoutSettings");
+var import_rtti = require("../utils/isomorphic/rtti");
+var import_time = require("../utils/isomorphic/time");
+var import_timeoutRunner = require("../utils/isomorphic/timeoutRunner");
+var import_webSocket = require("./webSocket");
+class Android extends import_channelOwner.ChannelOwner {
+  static from(android) {
+    return android._object;
+  }
+  constructor(parent, type, guid, initializer) {
+    super(parent, type, guid, initializer);
+    this._timeoutSettings = new import_timeoutSettings.TimeoutSettings(this._platform);
+  }
+  setDefaultTimeout(timeout) {
+    this._timeoutSettings.setDefaultTimeout(timeout);
+  }
+  async devices(options = {}) {
+    const { devices } = await this._channel.devices(options);
+    return devices.map((d) => AndroidDevice.from(d));
+  }
+  async launchServer(options = {}) {
+    if (!this._serverLauncher)
+      throw new Error("Launching server is not supported");
+    return await this._serverLauncher.launchServer(options);
+  }
+  async connect(wsEndpoint, options = {}) {
+    return await this._wrapApiCall(async () => {
+      const deadline = options.timeout ? (0, import_time.monotonicTime)() + options.timeout : 0;
+      const headers = { "x-playwright-browser": "android", ...options.headers };
+      const connectParams = { wsEndpoint, headers, slowMo: options.slowMo, timeout: options.timeout || 0 };
+      const connection = await (0, import_webSocket.connectOverWebSocket)(this._connection, connectParams);
+      let device;
+      connection.on("close", () => {
+        device?._didClose();
+      });
+      const result = await (0, import_timeoutRunner.raceAgainstDeadline)(async () => {
+        const playwright = await connection.initializePlaywright();
+        if (!playwright._initializer.preConnectedAndroidDevice) {
+          connection.close();
+          throw new Error("Malformed endpoint. Did you use Android.launchServer method?");
+        }
+        device = AndroidDevice.from(playwright._initializer.preConnectedAndroidDevice);
+        device._shouldCloseConnectionOnClose = true;
+        device.on(import_events.Events.AndroidDevice.Close, () => connection.close());
+        return device;
+      }, deadline);
+      if (!result.timedOut) {
+        return result.result;
+      } else {
+        connection.close();
+        throw new Error(`Timeout ${options.timeout}ms exceeded`);
+      }
+    });
+  }
+}
+class AndroidDevice extends import_channelOwner.ChannelOwner {
+  constructor(parent, type, guid, initializer) {
+    super(parent, type, guid, initializer);
+    this._webViews = /* @__PURE__ */ new Map();
+    this._shouldCloseConnectionOnClose = false;
+    this._android = parent;
+    this.input = new AndroidInput(this);
+    this._timeoutSettings = new import_timeoutSettings.TimeoutSettings(this._platform, parent._timeoutSettings);
+    this._channel.on("webViewAdded", ({ webView }) => this._onWebViewAdded(webView));
+    this._channel.on("webViewRemoved", ({ socketName }) => this._onWebViewRemoved(socketName));
+    this._channel.on("close", () => this._didClose());
+  }
+  static from(androidDevice) {
+    return androidDevice._object;
+  }
+  _onWebViewAdded(webView) {
+    const view = new AndroidWebView(this, webView);
+    this._webViews.set(webView.socketName, view);
+    this.emit(import_events.Events.AndroidDevice.WebView, view);
+  }
+  _onWebViewRemoved(socketName) {
+    const view = this._webViews.get(socketName);
+    this._webViews.delete(socketName);
+    if (view)
+      view.emit(import_events.Events.AndroidWebView.Close);
+  }
+  setDefaultTimeout(timeout) {
+    this._timeoutSettings.setDefaultTimeout(timeout);
+  }
+  serial() {
+    return this._initializer.serial;
+  }
+  model() {
+    return this._initializer.model;
+  }
+  webViews() {
+    return [...this._webViews.values()];
+  }
+  async webView(selector, options) {
+    const predicate = (v) => {
+      if (selector.pkg)
+        return v.pkg() === selector.pkg;
+      if (selector.socketName)
+        return v._socketName() === selector.socketName;
+      return false;
+    };
+    const webView = [...this._webViews.values()].find(predicate);
+    if (webView)
+      return webView;
+    return await this.waitForEvent("webview", { ...options, predicate });
+  }
+  async wait(selector, options = {}) {
+    await this._channel.wait({ androidSelector: toSelectorChannel(selector), ...options, timeout: this._timeoutSettings.timeout(options) });
+  }
+  async fill(selector, text, options = {}) {
+    await this._channel.fill({ androidSelector: toSelectorChannel(selector), text, ...options, timeout: this._timeoutSettings.timeout(options) });
+  }
+  async press(selector, key, options = {}) {
+    await this.tap(selector, options);
+    await this.input.press(key);
+  }
+  async tap(selector, options = {}) {
+    await this._channel.tap({ androidSelector: toSelectorChannel(selector), ...options, timeout: this._timeoutSettings.timeout(options) });
+  }
+  async drag(selector, dest, options = {}) {
+    await this._channel.drag({ androidSelector: toSelectorChannel(selector), dest, ...options, timeout: this._timeoutSettings.timeout(options) });
+  }
+  async fling(selector, direction, options = {}) {
+    await this._channel.fling({ androidSelector: toSelectorChannel(selector), direction, ...options, timeout: this._timeoutSettings.timeout(options) });
+  }
+  async longTap(selector, options = {}) {
+    await this._channel.longTap({ androidSelector: toSelectorChannel(selector), ...options, timeout: this._timeoutSettings.timeout(options) });
+  }
+  async pinchClose(selector, percent, options = {}) {
+    await this._channel.pinchClose({ androidSelector: toSelectorChannel(selector), percent, ...options, timeout: this._timeoutSettings.timeout(options) });
+  }
+  async pinchOpen(selector, percent, options = {}) {
+    await this._channel.pinchOpen({ androidSelector: toSelectorChannel(selector), percent, ...options, timeout: this._timeoutSettings.timeout(options) });
+  }
+  async scroll(selector, direction, percent, options = {}) {
+    await this._channel.scroll({ androidSelector: toSelectorChannel(selector), direction, percent, ...options, timeout: this._timeoutSettings.timeout(options) });
+  }
+  async swipe(selector, direction, percent, options = {}) {
+    await this._channel.swipe({ androidSelector: toSelectorChannel(selector), direction, percent, ...options, timeout: this._timeoutSettings.timeout(options) });
+  }
+  async info(selector) {
+    return (await this._channel.info({ androidSelector: toSelectorChannel(selector) })).info;
+  }
+  async screenshot(options = {}) {
+    const { binary } = await this._channel.screenshot();
+    if (options.path)
+      await this._platform.fs().promises.writeFile(options.path, binary);
+    return binary;
+  }
+  async [Symbol.asyncDispose]() {
+    await this.close();
+  }
+  async close() {
+    try {
+      if (this._shouldCloseConnectionOnClose)
+        this._connection.close();
+      else
+        await this._channel.close();
+    } catch (e) {
+      if ((0, import_errors.isTargetClosedError)(e))
+        return;
+      throw e;
+    }
+  }
+  _didClose() {
+    this.emit(import_events.Events.AndroidDevice.Close, this);
+  }
+  async shell(command) {
+    const { result } = await this._channel.shell({ command });
+    return result;
+  }
+  async open(command) {
+    return AndroidSocket.from((await this._channel.open({ command })).socket);
+  }
+  async installApk(file, options) {
+    await this._channel.installApk({ file: await loadFile(this._platform, file), args: options && options.args });
+  }
+  async push(file, path, options) {
+    await this._channel.push({ file: await loadFile(this._platform, file), path, mode: options ? options.mode : void 0 });
+  }
+  async launchBrowser(options = {}) {
+    const contextOptions = await (0, import_browserContext.prepareBrowserContextParams)(this._platform, options);
+    const result = await this._channel.launchBrowser(contextOptions);
+    const context = import_browserContext.BrowserContext.from(result.context);
+    const selectors = this._android._playwright.selectors;
+    selectors._contextsForSelectors.add(context);
+    context.once(import_events.Events.BrowserContext.Close, () => selectors._contextsForSelectors.delete(context));
+    await context._initializeHarFromOptions(options.recordHar);
+    return context;
+  }
+  async waitForEvent(event, optionsOrPredicate = {}) {
+    return await this._wrapApiCall(async () => {
+      const timeout = this._timeoutSettings.timeout(typeof optionsOrPredicate === "function" ? {} : optionsOrPredicate);
+      const predicate = typeof optionsOrPredicate === "function" ? optionsOrPredicate : optionsOrPredicate.predicate;
+      const waiter = import_waiter.Waiter.createForEvent(this, event);
+      waiter.rejectOnTimeout(timeout, `Timeout ${timeout}ms exceeded while waiting for event "${event}"`);
+      if (event !== import_events.Events.AndroidDevice.Close)
+        waiter.rejectOnEvent(this, import_events.Events.AndroidDevice.Close, () => new import_errors.TargetClosedError());
+      const result = await waiter.waitForEvent(this, event, predicate);
+      waiter.dispose();
+      return result;
+    });
+  }
+}
+class AndroidSocket extends import_channelOwner.ChannelOwner {
+  static from(androidDevice) {
+    return androidDevice._object;
+  }
+  constructor(parent, type, guid, initializer) {
+    super(parent, type, guid, initializer);
+    this._channel.on("data", ({ data }) => this.emit(import_events.Events.AndroidSocket.Data, data));
+    this._channel.on("close", () => this.emit(import_events.Events.AndroidSocket.Close));
+  }
+  async write(data) {
+    await this._channel.write({ data });
+  }
+  async close() {
+    await this._channel.close();
+  }
+  async [Symbol.asyncDispose]() {
+    await this.close();
+  }
+}
+async function loadFile(platform, file) {
+  if ((0, import_rtti.isString)(file))
+    return await platform.fs().promises.readFile(file);
+  return file;
+}
+class AndroidInput {
+  constructor(device) {
+    this._device = device;
+  }
+  async type(text) {
+    await this._device._channel.inputType({ text });
+  }
+  async press(key) {
+    await this._device._channel.inputPress({ key });
+  }
+  async tap(point) {
+    await this._device._channel.inputTap({ point });
+  }
+  async swipe(from, segments, steps) {
+    await this._device._channel.inputSwipe({ segments, steps });
+  }
+  async drag(from, to, steps) {
+    await this._device._channel.inputDrag({ from, to, steps });
+  }
+}
+function toSelectorChannel(selector) {
+  const {
+    checkable,
+    checked,
+    clazz,
+    clickable,
+    depth,
+    desc,
+    enabled,
+    focusable,
+    focused,
+    hasChild,
+    hasDescendant,
+    longClickable,
+    pkg,
+    res,
+    scrollable,
+    selected,
+    text
+  } = selector;
+  const toRegex = (value) => {
+    if (value === void 0)
+      return void 0;
+    if ((0, import_rtti.isRegExp)(value))
+      return value.source;
+    return "^" + value.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d") + "$";
+  };
+  return {
+    checkable,
+    checked,
+    clazz: toRegex(clazz),
+    pkg: toRegex(pkg),
+    desc: toRegex(desc),
+    res: toRegex(res),
+    text: toRegex(text),
+    clickable,
+    depth,
+    enabled,
+    focusable,
+    focused,
+    hasChild: hasChild ? { androidSelector: toSelectorChannel(hasChild.selector) } : void 0,
+    hasDescendant: hasDescendant ? { androidSelector: toSelectorChannel(hasDescendant.selector), maxDepth: hasDescendant.maxDepth } : void 0,
+    longClickable,
+    scrollable,
+    selected
+  };
+}
+class AndroidWebView extends import_eventEmitter.EventEmitter {
+  constructor(device, data) {
+    super(device._platform);
+    this._device = device;
+    this._data = data;
+  }
+  pid() {
+    return this._data.pid;
+  }
+  pkg() {
+    return this._data.pkg;
+  }
+  _socketName() {
+    return this._data.socketName;
+  }
+  async page() {
+    if (!this._pagePromise)
+      this._pagePromise = this._fetchPage();
+    return await this._pagePromise;
+  }
+  async _fetchPage() {
+    const { context } = await this._device._channel.connectToWebView({ socketName: this._data.socketName });
+    return import_browserContext.BrowserContext.from(context).pages()[0];
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Android,
+  AndroidDevice,
+  AndroidInput,
+  AndroidSocket,
+  AndroidWebView
+});

node_modules/playwright-core/lib/client/api.js

@@ -0,0 +1,137 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var api_exports = {};
+__export(api_exports, {
+  APIRequest: () => import_fetch.APIRequest,
+  APIRequestContext: () => import_fetch.APIRequestContext,
+  APIResponse: () => import_fetch.APIResponse,
+  Accessibility: () => import_accessibility.Accessibility,
+  Android: () => import_android.Android,
+  AndroidDevice: () => import_android.AndroidDevice,
+  AndroidInput: () => import_android.AndroidInput,
+  AndroidSocket: () => import_android.AndroidSocket,
+  AndroidWebView: () => import_android.AndroidWebView,
+  Browser: () => import_browser.Browser,
+  BrowserContext: () => import_browserContext.BrowserContext,
+  BrowserType: () => import_browserType.BrowserType,
+  CDPSession: () => import_cdpSession.CDPSession,
+  Clock: () => import_clock.Clock,
+  ConsoleMessage: () => import_consoleMessage.ConsoleMessage,
+  Coverage: () => import_coverage.Coverage,
+  Dialog: () => import_dialog.Dialog,
+  Download: () => import_download.Download,
+  Electron: () => import_electron.Electron,
+  ElectronApplication: () => import_electron.ElectronApplication,
+  ElementHandle: () => import_elementHandle.ElementHandle,
+  FileChooser: () => import_fileChooser.FileChooser,
+  Frame: () => import_frame.Frame,
+  FrameLocator: () => import_locator.FrameLocator,
+  JSHandle: () => import_jsHandle.JSHandle,
+  Keyboard: () => import_input.Keyboard,
+  Locator: () => import_locator.Locator,
+  Mouse: () => import_input.Mouse,
+  Page: () => import_page.Page,
+  Playwright: () => import_playwright.Playwright,
+  Request: () => import_network.Request,
+  Response: () => import_network.Response,
+  Route: () => import_network.Route,
+  Selectors: () => import_selectors.Selectors,
+  TimeoutError: () => import_errors.TimeoutError,
+  Touchscreen: () => import_input.Touchscreen,
+  Tracing: () => import_tracing.Tracing,
+  Video: () => import_video.Video,
+  WebError: () => import_webError.WebError,
+  WebSocket: () => import_network.WebSocket,
+  WebSocketRoute: () => import_network.WebSocketRoute,
+  Worker: () => import_worker.Worker
+});
+module.exports = __toCommonJS(api_exports);
+var import_accessibility = require("./accessibility");
+var import_android = require("./android");
+var import_browser = require("./browser");
+var import_browserContext = require("./browserContext");
+var import_browserType = require("./browserType");
+var import_clock = require("./clock");
+var import_consoleMessage = require("./consoleMessage");
+var import_coverage = require("./coverage");
+var import_dialog = require("./dialog");
+var import_download = require("./download");
+var import_electron = require("./electron");
+var import_locator = require("./locator");
+var import_elementHandle = require("./elementHandle");
+var import_fileChooser = require("./fileChooser");
+var import_errors = require("./errors");
+var import_frame = require("./frame");
+var import_input = require("./input");
+var import_jsHandle = require("./jsHandle");
+var import_network = require("./network");
+var import_fetch = require("./fetch");
+var import_page = require("./page");
+var import_selectors = require("./selectors");
+var import_tracing = require("./tracing");
+var import_video = require("./video");
+var import_worker = require("./worker");
+var import_cdpSession = require("./cdpSession");
+var import_playwright = require("./playwright");
+var import_webError = require("./webError");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  APIRequest,
+  APIRequestContext,
+  APIResponse,
+  Accessibility,
+  Android,
+  AndroidDevice,
+  AndroidInput,
+  AndroidSocket,
+  AndroidWebView,
+  Browser,
+  BrowserContext,
+  BrowserType,
+  CDPSession,
+  Clock,
+  ConsoleMessage,
+  Coverage,
+  Dialog,
+  Download,
+  Electron,
+  ElectronApplication,
+  ElementHandle,
+  FileChooser,
+  Frame,
+  FrameLocator,
+  JSHandle,
+  Keyboard,
+  Locator,
+  Mouse,
+  Page,
+  Playwright,
+  Request,
+  Response,
+  Route,
+  Selectors,
+  TimeoutError,
+  Touchscreen,
+  Tracing,
+  Video,
+  WebError,
+  WebSocket,
+  WebSocketRoute,
+  Worker
+});

node_modules/playwright-core/lib/client/artifact.js

@@ -0,0 +1,79 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var artifact_exports = {};
+__export(artifact_exports, {
+  Artifact: () => Artifact
+});
+module.exports = __toCommonJS(artifact_exports);
+var import_channelOwner = require("./channelOwner");
+var import_stream = require("./stream");
+var import_fileUtils = require("./fileUtils");
+class Artifact extends import_channelOwner.ChannelOwner {
+  static from(channel) {
+    return channel._object;
+  }
+  async pathAfterFinished() {
+    if (this._connection.isRemote())
+      throw new Error(`Path is not available when connecting remotely. Use saveAs() to save a local copy.`);
+    return (await this._channel.pathAfterFinished()).value;
+  }
+  async saveAs(path) {
+    if (!this._connection.isRemote()) {
+      await this._channel.saveAs({ path });
+      return;
+    }
+    const result = await this._channel.saveAsStream();
+    const stream = import_stream.Stream.from(result.stream);
+    await (0, import_fileUtils.mkdirIfNeeded)(this._platform, path);
+    await new Promise((resolve, reject) => {
+      stream.stream().pipe(this._platform.fs().createWriteStream(path)).on("finish", resolve).on("error", reject);
+    });
+  }
+  async failure() {
+    return (await this._channel.failure()).error || null;
+  }
+  async createReadStream() {
+    const result = await this._channel.stream();
+    const stream = import_stream.Stream.from(result.stream);
+    return stream.stream();
+  }
+  async readIntoBuffer() {
+    const stream = await this.createReadStream();
+    return await new Promise((resolve, reject) => {
+      const chunks = [];
+      stream.on("data", (chunk) => {
+        chunks.push(chunk);
+      });
+      stream.on("end", () => {
+        resolve(Buffer.concat(chunks));
+      });
+      stream.on("error", reject);
+    });
+  }
+  async cancel() {
+    return await this._channel.cancel();
+  }
+  async delete() {
+    return await this._channel.delete();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Artifact
+});

node_modules/playwright-core/lib/client/browser.js

@@ -0,0 +1,173 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var browser_exports = {};
+__export(browser_exports, {
+  Browser: () => Browser
+});
+module.exports = __toCommonJS(browser_exports);
+var import_artifact = require("./artifact");
+var import_browserContext = require("./browserContext");
+var import_cdpSession = require("./cdpSession");
+var import_channelOwner = require("./channelOwner");
+var import_errors = require("./errors");
+var import_events = require("./events");
+var import_fileUtils = require("./fileUtils");
+class Browser extends import_channelOwner.ChannelOwner {
+  constructor(parent, type, guid, initializer) {
+    super(parent, type, guid, initializer);
+    this._contexts = /* @__PURE__ */ new Set();
+    this._isConnected = true;
+    this._shouldCloseConnectionOnClose = false;
+    this._options = {};
+    this._name = initializer.name;
+    this._channel.on("context", ({ context }) => this._didCreateContext(import_browserContext.BrowserContext.from(context)));
+    this._channel.on("close", () => this._didClose());
+    this._closedPromise = new Promise((f) => this.once(import_events.Events.Browser.Disconnected, f));
+  }
+  static from(browser) {
+    return browser._object;
+  }
+  browserType() {
+    return this._browserType;
+  }
+  async newContext(options = {}) {
+    return await this._innerNewContext(options, false);
+  }
+  async _newContextForReuse(options = {}) {
+    return await this._innerNewContext(options, true);
+  }
+  async _disconnectFromReusedContext(reason) {
+    const context = [...this._contexts].find((context2) => context2._forReuse);
+    if (!context)
+      return;
+    await this._instrumentation.runBeforeCloseBrowserContext(context);
+    for (const page of context.pages())
+      page._onClose();
+    context._onClose();
+    await this._channel.disconnectFromReusedContext({ reason });
+  }
+  async _innerNewContext(options = {}, forReuse) {
+    options = this._browserType._playwright.selectors._withSelectorOptions({
+      ...this._browserType._playwright._defaultContextOptions,
+      ...options
+    });
+    const contextOptions = await (0, import_browserContext.prepareBrowserContextParams)(this._platform, options);
+    const response = forReuse ? await this._channel.newContextForReuse(contextOptions) : await this._channel.newContext(contextOptions);
+    const context = import_browserContext.BrowserContext.from(response.context);
+    if (forReuse)
+      context._forReuse = true;
+    if (options.logger)
+      context._logger = options.logger;
+    await context._initializeHarFromOptions(options.recordHar);
+    await this._instrumentation.runAfterCreateBrowserContext(context);
+    return context;
+  }
+  _connectToBrowserType(browserType, browserOptions, logger) {
+    this._browserType = browserType;
+    this._options = browserOptions;
+    this._logger = logger;
+    for (const context of this._contexts)
+      this._setupBrowserContext(context);
+  }
+  _didCreateContext(context) {
+    context._browser = this;
+    this._contexts.add(context);
+    if (this._browserType)
+      this._setupBrowserContext(context);
+  }
+  _setupBrowserContext(context) {
+    context._logger = this._logger;
+    context.tracing._tracesDir = this._options.tracesDir;
+    this._browserType._contexts.add(context);
+    this._browserType._playwright.selectors._contextsForSelectors.add(context);
+    context.setDefaultTimeout(this._browserType._playwright._defaultContextTimeout);
+    context.setDefaultNavigationTimeout(this._browserType._playwright._defaultContextNavigationTimeout);
+  }
+  contexts() {
+    return [...this._contexts];
+  }
+  version() {
+    return this._initializer.version;
+  }
+  async newPage(options = {}) {
+    return await this._wrapApiCall(async () => {
+      const context = await this.newContext(options);
+      const page = await context.newPage();
+      page._ownedContext = context;
+      context._ownerPage = page;
+      return page;
+    }, { title: "Create page" });
+  }
+  isConnected() {
+    return this._isConnected;
+  }
+  async newBrowserCDPSession() {
+    return import_cdpSession.CDPSession.from((await this._channel.newBrowserCDPSession()).session);
+  }
+  async _launchServer(options = {}) {
+    const serverLauncher = this._browserType._serverLauncher;
+    const browserImpl = this._connection.toImpl?.(this);
+    if (!serverLauncher || !browserImpl)
+      throw new Error("Launching server is not supported");
+    return await serverLauncher.launchServerOnExistingBrowser(browserImpl, {
+      _sharedBrowser: true,
+      ...options
+    });
+  }
+  async startTracing(page, options = {}) {
+    this._path = options.path;
+    await this._channel.startTracing({ ...options, page: page ? page._channel : void 0 });
+  }
+  async stopTracing() {
+    const artifact = import_artifact.Artifact.from((await this._channel.stopTracing()).artifact);
+    const buffer = await artifact.readIntoBuffer();
+    await artifact.delete();
+    if (this._path) {
+      await (0, import_fileUtils.mkdirIfNeeded)(this._platform, this._path);
+      await this._platform.fs().promises.writeFile(this._path, buffer);
+      this._path = void 0;
+    }
+    return buffer;
+  }
+  async [Symbol.asyncDispose]() {
+    await this.close();
+  }
+  async close(options = {}) {
+    this._closeReason = options.reason;
+    try {
+      if (this._shouldCloseConnectionOnClose)
+        this._connection.close();
+      else
+        await this._channel.close(options);
+      await this._closedPromise;
+    } catch (e) {
+      if ((0, import_errors.isTargetClosedError)(e))
+        return;
+      throw e;
+    }
+  }
+  _didClose() {
+    this._isConnected = false;
+    this.emit(import_events.Events.Browser.Disconnected, this);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Browser
+});

node_modules/playwright-core/lib/client/browserContext.js

@@ -0,0 +1,535 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var browserContext_exports = {};
+__export(browserContext_exports, {
+  BrowserContext: () => BrowserContext,
+  prepareBrowserContextParams: () => prepareBrowserContextParams,
+  toClientCertificatesProtocol: () => toClientCertificatesProtocol
+});
+module.exports = __toCommonJS(browserContext_exports);
+var import_artifact = require("./artifact");
+var import_cdpSession = require("./cdpSession");
+var import_channelOwner = require("./channelOwner");
+var import_clientHelper = require("./clientHelper");
+var import_clock = require("./clock");
+var import_consoleMessage = require("./consoleMessage");
+var import_dialog = require("./dialog");
+var import_errors = require("./errors");
+var import_events = require("./events");
+var import_fetch = require("./fetch");
+var import_frame = require("./frame");
+var import_harRouter = require("./harRouter");
+var network = __toESM(require("./network"));
+var import_page = require("./page");
+var import_tracing = require("./tracing");
+var import_waiter = require("./waiter");
+var import_webError = require("./webError");
+var import_worker = require("./worker");
+var import_timeoutSettings = require("./timeoutSettings");
+var import_fileUtils = require("./fileUtils");
+var import_headers = require("../utils/isomorphic/headers");
+var import_urlMatch = require("../utils/isomorphic/urlMatch");
+var import_rtti = require("../utils/isomorphic/rtti");
+var import_stackTrace = require("../utils/isomorphic/stackTrace");
+class BrowserContext extends import_channelOwner.ChannelOwner {
+  constructor(parent, type, guid, initializer) {
+    super(parent, type, guid, initializer);
+    this._pages = /* @__PURE__ */ new Set();
+    this._routes = [];
+    this._webSocketRoutes = [];
+    // Browser is null for browser contexts created outside of normal browser, e.g. android or electron.
+    this._browser = null;
+    this._bindings = /* @__PURE__ */ new Map();
+    this._forReuse = false;
+    this._backgroundPages = /* @__PURE__ */ new Set();
+    this._serviceWorkers = /* @__PURE__ */ new Set();
+    this._harRecorders = /* @__PURE__ */ new Map();
+    this._closingStatus = "none";
+    this._harRouters = [];
+    this._options = initializer.options;
+    this._timeoutSettings = new import_timeoutSettings.TimeoutSettings(this._platform);
+    this.tracing = import_tracing.Tracing.from(initializer.tracing);
+    this.request = import_fetch.APIRequestContext.from(initializer.requestContext);
+    this.request._timeoutSettings = this._timeoutSettings;
+    this.clock = new import_clock.Clock(this);
+    this._channel.on("bindingCall", ({ binding }) => this._onBinding(import_page.BindingCall.from(binding)));
+    this._channel.on("close", () => this._onClose());
+    this._channel.on("page", ({ page }) => this._onPage(import_page.Page.from(page)));
+    this._channel.on("route", ({ route }) => this._onRoute(network.Route.from(route)));
+    this._channel.on("webSocketRoute", ({ webSocketRoute }) => this._onWebSocketRoute(network.WebSocketRoute.from(webSocketRoute)));
+    this._channel.on("backgroundPage", ({ page }) => {
+      const backgroundPage = import_page.Page.from(page);
+      this._backgroundPages.add(backgroundPage);
+      this.emit(import_events.Events.BrowserContext.BackgroundPage, backgroundPage);
+    });
+    this._channel.on("serviceWorker", ({ worker }) => {
+      const serviceWorker = import_worker.Worker.from(worker);
+      serviceWorker._context = this;
+      this._serviceWorkers.add(serviceWorker);
+      this.emit(import_events.Events.BrowserContext.ServiceWorker, serviceWorker);
+    });
+    this._channel.on("console", (event) => {
+      const consoleMessage = new import_consoleMessage.ConsoleMessage(this._platform, event);
+      this.emit(import_events.Events.BrowserContext.Console, consoleMessage);
+      const page = consoleMessage.page();
+      if (page)
+        page.emit(import_events.Events.Page.Console, consoleMessage);
+    });
+    this._channel.on("pageError", ({ error, page }) => {
+      const pageObject = import_page.Page.from(page);
+      const parsedError = (0, import_errors.parseError)(error);
+      this.emit(import_events.Events.BrowserContext.WebError, new import_webError.WebError(pageObject, parsedError));
+      if (pageObject)
+        pageObject.emit(import_events.Events.Page.PageError, parsedError);
+    });
+    this._channel.on("dialog", ({ dialog }) => {
+      const dialogObject = import_dialog.Dialog.from(dialog);
+      let hasListeners = this.emit(import_events.Events.BrowserContext.Dialog, dialogObject);
+      const page = dialogObject.page();
+      if (page)
+        hasListeners = page.emit(import_events.Events.Page.Dialog, dialogObject) || hasListeners;
+      if (!hasListeners) {
+        if (dialogObject.type() === "beforeunload")
+          dialog.accept({}).catch(() => {
+          });
+        else
+          dialog.dismiss().catch(() => {
+          });
+      }
+    });
+    this._channel.on("request", ({ request, page }) => this._onRequest(network.Request.from(request), import_page.Page.fromNullable(page)));
+    this._channel.on("requestFailed", ({ request, failureText, responseEndTiming, page }) => this._onRequestFailed(network.Request.from(request), responseEndTiming, failureText, import_page.Page.fromNullable(page)));
+    this._channel.on("requestFinished", (params) => this._onRequestFinished(params));
+    this._channel.on("response", ({ response, page }) => this._onResponse(network.Response.from(response), import_page.Page.fromNullable(page)));
+    this._channel.on("recorderEvent", ({ event, data, page, code }) => {
+      if (event === "actionAdded")
+        this._onRecorderEventSink?.actionAdded?.(import_page.Page.from(page), data, code);
+      else if (event === "actionUpdated")
+        this._onRecorderEventSink?.actionUpdated?.(import_page.Page.from(page), data, code);
+      else if (event === "signalAdded")
+        this._onRecorderEventSink?.signalAdded?.(import_page.Page.from(page), data);
+    });
+    this._closedPromise = new Promise((f) => this.once(import_events.Events.BrowserContext.Close, f));
+    this._setEventToSubscriptionMapping(/* @__PURE__ */ new Map([
+      [import_events.Events.BrowserContext.Console, "console"],
+      [import_events.Events.BrowserContext.Dialog, "dialog"],
+      [import_events.Events.BrowserContext.Request, "request"],
+      [import_events.Events.BrowserContext.Response, "response"],
+      [import_events.Events.BrowserContext.RequestFinished, "requestFinished"],
+      [import_events.Events.BrowserContext.RequestFailed, "requestFailed"]
+    ]));
+  }
+  static from(context) {
+    return context._object;
+  }
+  static fromNullable(context) {
+    return context ? BrowserContext.from(context) : null;
+  }
+  async _initializeHarFromOptions(recordHar) {
+    if (!recordHar)
+      return;
+    const defaultContent = recordHar.path.endsWith(".zip") ? "attach" : "embed";
+    await this._recordIntoHAR(recordHar.path, null, {
+      url: recordHar.urlFilter,
+      updateContent: recordHar.content ?? (recordHar.omitContent ? "omit" : defaultContent),
+      updateMode: recordHar.mode ?? "full"
+    });
+  }
+  _onPage(page) {
+    this._pages.add(page);
+    this.emit(import_events.Events.BrowserContext.Page, page);
+    if (page._opener && !page._opener.isClosed())
+      page._opener.emit(import_events.Events.Page.Popup, page);
+  }
+  _onRequest(request, page) {
+    this.emit(import_events.Events.BrowserContext.Request, request);
+    if (page)
+      page.emit(import_events.Events.Page.Request, request);
+  }
+  _onResponse(response, page) {
+    this.emit(import_events.Events.BrowserContext.Response, response);
+    if (page)
+      page.emit(import_events.Events.Page.Response, response);
+  }
+  _onRequestFailed(request, responseEndTiming, failureText, page) {
+    request._failureText = failureText || null;
+    request._setResponseEndTiming(responseEndTiming);
+    this.emit(import_events.Events.BrowserContext.RequestFailed, request);
+    if (page)
+      page.emit(import_events.Events.Page.RequestFailed, request);
+  }
+  _onRequestFinished(params) {
+    const { responseEndTiming } = params;
+    const request = network.Request.from(params.request);
+    const response = network.Response.fromNullable(params.response);
+    const page = import_page.Page.fromNullable(params.page);
+    request._setResponseEndTiming(responseEndTiming);
+    this.emit(import_events.Events.BrowserContext.RequestFinished, request);
+    if (page)
+      page.emit(import_events.Events.Page.RequestFinished, request);
+    if (response)
+      response._finishedPromise.resolve(null);
+  }
+  async _onRoute(route) {
+    route._context = this;
+    const page = route.request()._safePage();
+    const routeHandlers = this._routes.slice();
+    for (const routeHandler of routeHandlers) {
+      if (page?._closeWasCalled || this._closingStatus !== "none")
+        return;
+      if (!routeHandler.matches(route.request().url()))
+        continue;
+      const index = this._routes.indexOf(routeHandler);
+      if (index === -1)
+        continue;
+      if (routeHandler.willExpire())
+        this._routes.splice(index, 1);
+      const handled = await routeHandler.handle(route);
+      if (!this._routes.length)
+        this._updateInterceptionPatterns({ internal: true }).catch(() => {
+        });
+      if (handled)
+        return;
+    }
+    await route._innerContinue(
+      true
+      /* isFallback */
+    ).catch(() => {
+    });
+  }
+  async _onWebSocketRoute(webSocketRoute) {
+    const routeHandler = this._webSocketRoutes.find((route) => route.matches(webSocketRoute.url()));
+    if (routeHandler)
+      await routeHandler.handle(webSocketRoute);
+    else
+      webSocketRoute.connectToServer();
+  }
+  async _onBinding(bindingCall) {
+    const func = this._bindings.get(bindingCall._initializer.name);
+    if (!func)
+      return;
+    await bindingCall.call(func);
+  }
+  setDefaultNavigationTimeout(timeout) {
+    this._timeoutSettings.setDefaultNavigationTimeout(timeout);
+  }
+  setDefaultTimeout(timeout) {
+    this._timeoutSettings.setDefaultTimeout(timeout);
+  }
+  browser() {
+    return this._browser;
+  }
+  pages() {
+    return [...this._pages];
+  }
+  async newPage() {
+    if (this._ownerPage)
+      throw new Error("Please use browser.newContext()");
+    return import_page.Page.from((await this._channel.newPage()).page);
+  }
+  async cookies(urls) {
+    if (!urls)
+      urls = [];
+    if (urls && typeof urls === "string")
+      urls = [urls];
+    return (await this._channel.cookies({ urls })).cookies;
+  }
+  async addCookies(cookies) {
+    await this._channel.addCookies({ cookies });
+  }
+  async clearCookies(options = {}) {
+    await this._channel.clearCookies({
+      name: (0, import_rtti.isString)(options.name) ? options.name : void 0,
+      nameRegexSource: (0, import_rtti.isRegExp)(options.name) ? options.name.source : void 0,
+      nameRegexFlags: (0, import_rtti.isRegExp)(options.name) ? options.name.flags : void 0,
+      domain: (0, import_rtti.isString)(options.domain) ? options.domain : void 0,
+      domainRegexSource: (0, import_rtti.isRegExp)(options.domain) ? options.domain.source : void 0,
+      domainRegexFlags: (0, import_rtti.isRegExp)(options.domain) ? options.domain.flags : void 0,
+      path: (0, import_rtti.isString)(options.path) ? options.path : void 0,
+      pathRegexSource: (0, import_rtti.isRegExp)(options.path) ? options.path.source : void 0,
+      pathRegexFlags: (0, import_rtti.isRegExp)(options.path) ? options.path.flags : void 0
+    });
+  }
+  async grantPermissions(permissions, options) {
+    await this._channel.grantPermissions({ permissions, ...options });
+  }
+  async clearPermissions() {
+    await this._channel.clearPermissions();
+  }
+  async setGeolocation(geolocation) {
+    await this._channel.setGeolocation({ geolocation: geolocation || void 0 });
+  }
+  async setExtraHTTPHeaders(headers) {
+    network.validateHeaders(headers);
+    await this._channel.setExtraHTTPHeaders({ headers: (0, import_headers.headersObjectToArray)(headers) });
+  }
+  async setOffline(offline) {
+    await this._channel.setOffline({ offline });
+  }
+  async setHTTPCredentials(httpCredentials) {
+    await this._channel.setHTTPCredentials({ httpCredentials: httpCredentials || void 0 });
+  }
+  async addInitScript(script, arg) {
+    const source = await (0, import_clientHelper.evaluationScript)(this._platform, script, arg);
+    await this._channel.addInitScript({ source });
+  }
+  async exposeBinding(name, callback, options = {}) {
+    await this._channel.exposeBinding({ name, needsHandle: options.handle });
+    this._bindings.set(name, callback);
+  }
+  async exposeFunction(name, callback) {
+    await this._channel.exposeBinding({ name });
+    const binding = (source, ...args) => callback(...args);
+    this._bindings.set(name, binding);
+  }
+  async route(url, handler, options = {}) {
+    this._routes.unshift(new network.RouteHandler(this._platform, this._options.baseURL, url, handler, options.times));
+    await this._updateInterceptionPatterns({ title: "Route requests" });
+  }
+  async routeWebSocket(url, handler) {
+    this._webSocketRoutes.unshift(new network.WebSocketRouteHandler(this._options.baseURL, url, handler));
+    await this._updateWebSocketInterceptionPatterns({ title: "Route WebSockets" });
+  }
+  async _recordIntoHAR(har, page, options = {}) {
+    const { harId } = await this._channel.harStart({
+      page: page?._channel,
+      options: {
+        zip: har.endsWith(".zip"),
+        content: options.updateContent ?? "attach",
+        urlGlob: (0, import_rtti.isString)(options.url) ? options.url : void 0,
+        urlRegexSource: (0, import_rtti.isRegExp)(options.url) ? options.url.source : void 0,
+        urlRegexFlags: (0, import_rtti.isRegExp)(options.url) ? options.url.flags : void 0,
+        mode: options.updateMode ?? "minimal"
+      }
+    });
+    this._harRecorders.set(harId, { path: har, content: options.updateContent ?? "attach" });
+  }
+  async routeFromHAR(har, options = {}) {
+    const localUtils = this._connection.localUtils();
+    if (!localUtils)
+      throw new Error("Route from har is not supported in thin clients");
+    if (options.update) {
+      await this._recordIntoHAR(har, null, options);
+      return;
+    }
+    const harRouter = await import_harRouter.HarRouter.create(localUtils, har, options.notFound || "abort", { urlMatch: options.url });
+    this._harRouters.push(harRouter);
+    await harRouter.addContextRoute(this);
+  }
+  _disposeHarRouters() {
+    this._harRouters.forEach((router) => router.dispose());
+    this._harRouters = [];
+  }
+  async unrouteAll(options) {
+    await this._unrouteInternal(this._routes, [], options?.behavior);
+    this._disposeHarRouters();
+  }
+  async unroute(url, handler) {
+    const removed = [];
+    const remaining = [];
+    for (const route of this._routes) {
+      if ((0, import_urlMatch.urlMatchesEqual)(route.url, url) && (!handler || route.handler === handler))
+        removed.push(route);
+      else
+        remaining.push(route);
+    }
+    await this._unrouteInternal(removed, remaining, "default");
+  }
+  async _unrouteInternal(removed, remaining, behavior) {
+    this._routes = remaining;
+    if (behavior && behavior !== "default") {
+      const promises = removed.map((routeHandler) => routeHandler.stop(behavior));
+      await Promise.all(promises);
+    }
+    await this._updateInterceptionPatterns({ title: "Unroute requests" });
+  }
+  async _updateInterceptionPatterns(options) {
+    const patterns = network.RouteHandler.prepareInterceptionPatterns(this._routes);
+    await this._wrapApiCall(() => this._channel.setNetworkInterceptionPatterns({ patterns }), options);
+  }
+  async _updateWebSocketInterceptionPatterns(options) {
+    const patterns = network.WebSocketRouteHandler.prepareInterceptionPatterns(this._webSocketRoutes);
+    await this._wrapApiCall(() => this._channel.setWebSocketInterceptionPatterns({ patterns }), options);
+  }
+  _effectiveCloseReason() {
+    return this._closeReason || this._browser?._closeReason;
+  }
+  async waitForEvent(event, optionsOrPredicate = {}) {
+    return await this._wrapApiCall(async () => {
+      const timeout = this._timeoutSettings.timeout(typeof optionsOrPredicate === "function" ? {} : optionsOrPredicate);
+      const predicate = typeof optionsOrPredicate === "function" ? optionsOrPredicate : optionsOrPredicate.predicate;
+      const waiter = import_waiter.Waiter.createForEvent(this, event);
+      waiter.rejectOnTimeout(timeout, `Timeout ${timeout}ms exceeded while waiting for event "${event}"`);
+      if (event !== import_events.Events.BrowserContext.Close)
+        waiter.rejectOnEvent(this, import_events.Events.BrowserContext.Close, () => new import_errors.TargetClosedError(this._effectiveCloseReason()));
+      const result = await waiter.waitForEvent(this, event, predicate);
+      waiter.dispose();
+      return result;
+    });
+  }
+  async storageState(options = {}) {
+    const state = await this._channel.storageState({ indexedDB: options.indexedDB });
+    if (options.path) {
+      await (0, import_fileUtils.mkdirIfNeeded)(this._platform, options.path);
+      await this._platform.fs().promises.writeFile(options.path, JSON.stringify(state, void 0, 2), "utf8");
+    }
+    return state;
+  }
+  backgroundPages() {
+    return [...this._backgroundPages];
+  }
+  serviceWorkers() {
+    return [...this._serviceWorkers];
+  }
+  async newCDPSession(page) {
+    if (!(page instanceof import_page.Page) && !(page instanceof import_frame.Frame))
+      throw new Error("page: expected Page or Frame");
+    const result = await this._channel.newCDPSession(page instanceof import_page.Page ? { page: page._channel } : { frame: page._channel });
+    return import_cdpSession.CDPSession.from(result.session);
+  }
+  _onClose() {
+    this._closingStatus = "closed";
+    this._browser?._contexts.delete(this);
+    this._browser?._browserType._contexts.delete(this);
+    this._browser?._browserType._playwright.selectors._contextsForSelectors.delete(this);
+    this._disposeHarRouters();
+    this.tracing._resetStackCounter();
+    this.emit(import_events.Events.BrowserContext.Close, this);
+  }
+  async [Symbol.asyncDispose]() {
+    await this.close();
+  }
+  async close(options = {}) {
+    if (this._closingStatus !== "none")
+      return;
+    this._closeReason = options.reason;
+    this._closingStatus = "closing";
+    await this.request.dispose(options);
+    await this._instrumentation.runBeforeCloseBrowserContext(this);
+    await this._wrapApiCall(async () => {
+      for (const [harId, harParams] of this._harRecorders) {
+        const har = await this._channel.harExport({ harId });
+        const artifact = import_artifact.Artifact.from(har.artifact);
+        const isCompressed = harParams.content === "attach" || harParams.path.endsWith(".zip");
+        const needCompressed = harParams.path.endsWith(".zip");
+        if (isCompressed && !needCompressed) {
+          const localUtils = this._connection.localUtils();
+          if (!localUtils)
+            throw new Error("Uncompressed har is not supported in thin clients");
+          await artifact.saveAs(harParams.path + ".tmp");
+          await localUtils.harUnzip({ zipFile: harParams.path + ".tmp", harFile: harParams.path });
+        } else {
+          await artifact.saveAs(harParams.path);
+        }
+        await artifact.delete();
+      }
+    }, { internal: true });
+    await this._channel.close(options);
+    await this._closedPromise;
+  }
+  async _enableRecorder(params, eventSink) {
+    if (eventSink)
+      this._onRecorderEventSink = eventSink;
+    await this._channel.enableRecorder(params);
+  }
+  async _disableRecorder() {
+    this._onRecorderEventSink = void 0;
+    await this._channel.disableRecorder();
+  }
+}
+async function prepareStorageState(platform, storageState) {
+  if (typeof storageState !== "string")
+    return storageState;
+  try {
+    return JSON.parse(await platform.fs().promises.readFile(storageState, "utf8"));
+  } catch (e) {
+    (0, import_stackTrace.rewriteErrorMessage)(e, `Error reading storage state from ${storageState}:
+` + e.message);
+    throw e;
+  }
+}
+async function prepareBrowserContextParams(platform, options) {
+  if (options.videoSize && !options.videosPath)
+    throw new Error(`"videoSize" option requires "videosPath" to be specified`);
+  if (options.extraHTTPHeaders)
+    network.validateHeaders(options.extraHTTPHeaders);
+  const contextParams = {
+    ...options,
+    viewport: options.viewport === null ? void 0 : options.viewport,
+    noDefaultViewport: options.viewport === null,
+    extraHTTPHeaders: options.extraHTTPHeaders ? (0, import_headers.headersObjectToArray)(options.extraHTTPHeaders) : void 0,
+    storageState: options.storageState ? await prepareStorageState(platform, options.storageState) : void 0,
+    serviceWorkers: options.serviceWorkers,
+    colorScheme: options.colorScheme === null ? "no-override" : options.colorScheme,
+    reducedMotion: options.reducedMotion === null ? "no-override" : options.reducedMotion,
+    forcedColors: options.forcedColors === null ? "no-override" : options.forcedColors,
+    contrast: options.contrast === null ? "no-override" : options.contrast,
+    acceptDownloads: toAcceptDownloadsProtocol(options.acceptDownloads),
+    clientCertificates: await toClientCertificatesProtocol(platform, options.clientCertificates)
+  };
+  if (!contextParams.recordVideo && options.videosPath) {
+    contextParams.recordVideo = {
+      dir: options.videosPath,
+      size: options.videoSize
+    };
+  }
+  if (contextParams.recordVideo && contextParams.recordVideo.dir)
+    contextParams.recordVideo.dir = platform.path().resolve(contextParams.recordVideo.dir);
+  return contextParams;
+}
+function toAcceptDownloadsProtocol(acceptDownloads) {
+  if (acceptDownloads === void 0)
+    return void 0;
+  if (acceptDownloads)
+    return "accept";
+  return "deny";
+}
+async function toClientCertificatesProtocol(platform, certs) {
+  if (!certs)
+    return void 0;
+  const bufferizeContent = async (value, path) => {
+    if (value)
+      return value;
+    if (path)
+      return await platform.fs().promises.readFile(path);
+  };
+  return await Promise.all(certs.map(async (cert) => ({
+    origin: cert.origin,
+    cert: await bufferizeContent(cert.cert, cert.certPath),
+    key: await bufferizeContent(cert.key, cert.keyPath),
+    pfx: await bufferizeContent(cert.pfx, cert.pfxPath),
+    passphrase: cert.passphrase
+  })));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BrowserContext,
+  prepareBrowserContextParams,
+  toClientCertificatesProtocol
+});

node_modules/playwright-core/lib/client/browserType.js

@@ -0,0 +1,184 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var browserType_exports = {};
+__export(browserType_exports, {
+  BrowserType: () => BrowserType
+});
+module.exports = __toCommonJS(browserType_exports);
+var import_browser = require("./browser");
+var import_browserContext = require("./browserContext");
+var import_channelOwner = require("./channelOwner");
+var import_clientHelper = require("./clientHelper");
+var import_events = require("./events");
+var import_assert = require("../utils/isomorphic/assert");
+var import_headers = require("../utils/isomorphic/headers");
+var import_time = require("../utils/isomorphic/time");
+var import_timeoutRunner = require("../utils/isomorphic/timeoutRunner");
+var import_webSocket = require("./webSocket");
+var import_timeoutSettings = require("./timeoutSettings");
+class BrowserType extends import_channelOwner.ChannelOwner {
+  constructor() {
+    super(...arguments);
+    this._contexts = /* @__PURE__ */ new Set();
+  }
+  static from(browserType) {
+    return browserType._object;
+  }
+  executablePath() {
+    if (!this._initializer.executablePath)
+      throw new Error("Browser is not supported on current platform");
+    return this._initializer.executablePath;
+  }
+  name() {
+    return this._initializer.name;
+  }
+  async launch(options = {}) {
+    (0, import_assert.assert)(!options.userDataDir, "userDataDir option is not supported in `browserType.launch`. Use `browserType.launchPersistentContext` instead");
+    (0, import_assert.assert)(!options.port, "Cannot specify a port without launching as a server.");
+    const logger = options.logger || this._playwright._defaultLaunchOptions?.logger;
+    options = { ...this._playwright._defaultLaunchOptions, ...options };
+    const launchOptions = {
+      ...options,
+      ignoreDefaultArgs: Array.isArray(options.ignoreDefaultArgs) ? options.ignoreDefaultArgs : void 0,
+      ignoreAllDefaultArgs: !!options.ignoreDefaultArgs && !Array.isArray(options.ignoreDefaultArgs),
+      env: options.env ? (0, import_clientHelper.envObjectToArray)(options.env) : void 0,
+      timeout: new import_timeoutSettings.TimeoutSettings(this._platform).launchTimeout(options)
+    };
+    return await this._wrapApiCall(async () => {
+      const browser = import_browser.Browser.from((await this._channel.launch(launchOptions)).browser);
+      browser._connectToBrowserType(this, options, logger);
+      return browser;
+    });
+  }
+  async launchServer(options = {}) {
+    if (!this._serverLauncher)
+      throw new Error("Launching server is not supported");
+    options = { ...this._playwright._defaultLaunchOptions, ...options };
+    return await this._serverLauncher.launchServer(options);
+  }
+  async launchPersistentContext(userDataDir, options = {}) {
+    const logger = options.logger || this._playwright._defaultLaunchOptions?.logger;
+    (0, import_assert.assert)(!options.port, "Cannot specify a port without launching as a server.");
+    options = this._playwright.selectors._withSelectorOptions({
+      ...this._playwright._defaultLaunchOptions,
+      ...this._playwright._defaultContextOptions,
+      ...options
+    });
+    const contextParams = await (0, import_browserContext.prepareBrowserContextParams)(this._platform, options);
+    const persistentParams = {
+      ...contextParams,
+      ignoreDefaultArgs: Array.isArray(options.ignoreDefaultArgs) ? options.ignoreDefaultArgs : void 0,
+      ignoreAllDefaultArgs: !!options.ignoreDefaultArgs && !Array.isArray(options.ignoreDefaultArgs),
+      env: options.env ? (0, import_clientHelper.envObjectToArray)(options.env) : void 0,
+      channel: options.channel,
+      userDataDir: this._platform.path().isAbsolute(userDataDir) || !userDataDir ? userDataDir : this._platform.path().resolve(userDataDir),
+      timeout: new import_timeoutSettings.TimeoutSettings(this._platform).launchTimeout(options)
+    };
+    const context = await this._wrapApiCall(async () => {
+      const result = await this._channel.launchPersistentContext(persistentParams);
+      const browser = import_browser.Browser.from(result.browser);
+      browser._connectToBrowserType(this, options, logger);
+      const context2 = import_browserContext.BrowserContext.from(result.context);
+      await context2._initializeHarFromOptions(options.recordHar);
+      return context2;
+    });
+    await this._instrumentation.runAfterCreateBrowserContext(context);
+    return context;
+  }
+  async connect(optionsOrWsEndpoint, options) {
+    if (typeof optionsOrWsEndpoint === "string")
+      return await this._connect({ ...options, wsEndpoint: optionsOrWsEndpoint });
+    (0, import_assert.assert)(optionsOrWsEndpoint.wsEndpoint, "options.wsEndpoint is required");
+    return await this._connect(optionsOrWsEndpoint);
+  }
+  async _connect(params) {
+    const logger = params.logger;
+    return await this._wrapApiCall(async () => {
+      const deadline = params.timeout ? (0, import_time.monotonicTime)() + params.timeout : 0;
+      const headers = { "x-playwright-browser": this.name(), ...params.headers };
+      const connectParams = {
+        wsEndpoint: params.wsEndpoint,
+        headers,
+        exposeNetwork: params.exposeNetwork ?? params._exposeNetwork,
+        slowMo: params.slowMo,
+        timeout: params.timeout || 0
+      };
+      if (params.__testHookRedirectPortForwarding)
+        connectParams.socksProxyRedirectPortForTest = params.__testHookRedirectPortForwarding;
+      const connection = await (0, import_webSocket.connectOverWebSocket)(this._connection, connectParams);
+      let browser;
+      connection.on("close", () => {
+        for (const context of browser?.contexts() || []) {
+          for (const page of context.pages())
+            page._onClose();
+          context._onClose();
+        }
+        setTimeout(() => browser?._didClose(), 0);
+      });
+      const result = await (0, import_timeoutRunner.raceAgainstDeadline)(async () => {
+        if (params.__testHookBeforeCreateBrowser)
+          await params.__testHookBeforeCreateBrowser();
+        const playwright = await connection.initializePlaywright();
+        if (!playwright._initializer.preLaunchedBrowser) {
+          connection.close();
+          throw new Error("Malformed endpoint. Did you use BrowserType.launchServer method?");
+        }
+        playwright.selectors = this._playwright.selectors;
+        browser = import_browser.Browser.from(playwright._initializer.preLaunchedBrowser);
+        browser._connectToBrowserType(this, {}, logger);
+        browser._shouldCloseConnectionOnClose = true;
+        browser.on(import_events.Events.Browser.Disconnected, () => connection.close());
+        return browser;
+      }, deadline);
+      if (!result.timedOut) {
+        return result.result;
+      } else {
+        connection.close();
+        throw new Error(`Timeout ${params.timeout}ms exceeded`);
+      }
+    });
+  }
+  async connectOverCDP(endpointURLOrOptions, options) {
+    if (typeof endpointURLOrOptions === "string")
+      return await this._connectOverCDP(endpointURLOrOptions, options);
+    const endpointURL = "endpointURL" in endpointURLOrOptions ? endpointURLOrOptions.endpointURL : endpointURLOrOptions.wsEndpoint;
+    (0, import_assert.assert)(endpointURL, "Cannot connect over CDP without wsEndpoint.");
+    return await this.connectOverCDP(endpointURL, endpointURLOrOptions);
+  }
+  async _connectOverCDP(endpointURL, params = {}) {
+    if (this.name() !== "chromium")
+      throw new Error("Connecting over CDP is only supported in Chromium.");
+    const headers = params.headers ? (0, import_headers.headersObjectToArray)(params.headers) : void 0;
+    const result = await this._channel.connectOverCDP({
+      endpointURL,
+      headers,
+      slowMo: params.slowMo,
+      timeout: new import_timeoutSettings.TimeoutSettings(this._platform).timeout(params)
+    });
+    const browser = import_browser.Browser.from(result.browser);
+    browser._connectToBrowserType(this, {}, params.logger);
+    if (result.defaultContext)
+      await this._instrumentation.runAfterCreateBrowserContext(import_browserContext.BrowserContext.from(result.defaultContext));
+    return browser;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BrowserType
+});

node_modules/playwright-core/lib/client/cdpSession.js

@@ -0,0 +1,51 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cdpSession_exports = {};
+__export(cdpSession_exports, {
+  CDPSession: () => CDPSession
+});
+module.exports = __toCommonJS(cdpSession_exports);
+var import_channelOwner = require("./channelOwner");
+class CDPSession extends import_channelOwner.ChannelOwner {
+  static from(cdpSession) {
+    return cdpSession._object;
+  }
+  constructor(parent, type, guid, initializer) {
+    super(parent, type, guid, initializer);
+    this._channel.on("event", ({ method, params }) => {
+      this.emit(method, params);
+    });
+    this.on = super.on;
+    this.addListener = super.addListener;
+    this.off = super.removeListener;
+    this.removeListener = super.removeListener;
+    this.once = super.once;
+  }
+  async send(method, params) {
+    const result = await this._channel.send({ method, params });
+    return result.result;
+  }
+  async detach() {
+    return await this._channel.detach();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CDPSession
+});

node_modules/playwright-core/lib/client/channelOwner.js

@@ -0,0 +1,201 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var channelOwner_exports = {};
+__export(channelOwner_exports, {
+  ChannelOwner: () => ChannelOwner
+});
+module.exports = __toCommonJS(channelOwner_exports);
+var import_eventEmitter = require("./eventEmitter");
+var import_validator = require("../protocol/validator");
+var import_protocolMetainfo = require("../utils/isomorphic/protocolMetainfo");
+var import_clientStackTrace = require("./clientStackTrace");
+var import_stackTrace = require("../utils/isomorphic/stackTrace");
+class ChannelOwner extends import_eventEmitter.EventEmitter {
+  constructor(parent, type, guid, initializer) {
+    const connection = parent instanceof ChannelOwner ? parent._connection : parent;
+    super(connection._platform);
+    this._objects = /* @__PURE__ */ new Map();
+    this._eventToSubscriptionMapping = /* @__PURE__ */ new Map();
+    this._wasCollected = false;
+    this.setMaxListeners(0);
+    this._connection = connection;
+    this._type = type;
+    this._guid = guid;
+    this._parent = parent instanceof ChannelOwner ? parent : void 0;
+    this._instrumentation = this._connection._instrumentation;
+    this._connection._objects.set(guid, this);
+    if (this._parent) {
+      this._parent._objects.set(guid, this);
+      this._logger = this._parent._logger;
+    }
+    this._channel = this._createChannel(new import_eventEmitter.EventEmitter(connection._platform));
+    this._initializer = initializer;
+  }
+  _setEventToSubscriptionMapping(mapping) {
+    this._eventToSubscriptionMapping = mapping;
+  }
+  _updateSubscription(event, enabled) {
+    const protocolEvent = this._eventToSubscriptionMapping.get(String(event));
+    if (protocolEvent)
+      this._channel.updateSubscription({ event: protocolEvent, enabled }).catch(() => {
+      });
+  }
+  on(event, listener) {
+    if (!this.listenerCount(event))
+      this._updateSubscription(event, true);
+    super.on(event, listener);
+    return this;
+  }
+  addListener(event, listener) {
+    if (!this.listenerCount(event))
+      this._updateSubscription(event, true);
+    super.addListener(event, listener);
+    return this;
+  }
+  prependListener(event, listener) {
+    if (!this.listenerCount(event))
+      this._updateSubscription(event, true);
+    super.prependListener(event, listener);
+    return this;
+  }
+  off(event, listener) {
+    super.off(event, listener);
+    if (!this.listenerCount(event))
+      this._updateSubscription(event, false);
+    return this;
+  }
+  removeListener(event, listener) {
+    super.removeListener(event, listener);
+    if (!this.listenerCount(event))
+      this._updateSubscription(event, false);
+    return this;
+  }
+  _adopt(child) {
+    child._parent._objects.delete(child._guid);
+    this._objects.set(child._guid, child);
+    child._parent = this;
+  }
+  _dispose(reason) {
+    if (this._parent)
+      this._parent._objects.delete(this._guid);
+    this._connection._objects.delete(this._guid);
+    this._wasCollected = reason === "gc";
+    for (const object of [...this._objects.values()])
+      object._dispose(reason);
+    this._objects.clear();
+  }
+  _debugScopeState() {
+    return {
+      _guid: this._guid,
+      objects: Array.from(this._objects.values()).map((o) => o._debugScopeState())
+    };
+  }
+  _validatorToWireContext() {
+    return {
+      tChannelImpl: tChannelImplToWire,
+      binary: this._connection.rawBuffers() ? "buffer" : "toBase64",
+      isUnderTest: () => this._platform.isUnderTest()
+    };
+  }
+  _createChannel(base) {
+    const channel = new Proxy(base, {
+      get: (obj, prop) => {
+        if (typeof prop === "string") {
+          const validator = (0, import_validator.maybeFindValidator)(this._type, prop, "Params");
+          const { internal } = import_protocolMetainfo.methodMetainfo.get(this._type + "." + prop) || {};
+          if (validator) {
+            return async (params) => {
+              return await this._wrapApiCall(async (apiZone) => {
+                const validatedParams = validator(params, "", this._validatorToWireContext());
+                if (!apiZone.internal && !apiZone.reported) {
+                  apiZone.reported = true;
+                  this._instrumentation.onApiCallBegin(apiZone, { type: this._type, method: prop, params });
+                  logApiCall(this._platform, this._logger, `=> ${apiZone.apiName} started`);
+                  return await this._connection.sendMessageToServer(this, prop, validatedParams, apiZone);
+                }
+                return await this._connection.sendMessageToServer(this, prop, validatedParams, { internal: true });
+              }, { internal });
+            };
+          }
+        }
+        return obj[prop];
+      }
+    });
+    channel._object = this;
+    return channel;
+  }
+  async _wrapApiCall(func, options) {
+    const logger = this._logger;
+    const existingApiZone = this._platform.zones.current().data();
+    if (existingApiZone)
+      return await func(existingApiZone);
+    const stackTrace = (0, import_clientStackTrace.captureLibraryStackTrace)(this._platform);
+    const apiZone = { title: options?.title, apiName: stackTrace.apiName, frames: stackTrace.frames, internal: options?.internal ?? false, reported: false, userData: void 0, stepId: void 0 };
+    try {
+      const result = await this._platform.zones.current().push(apiZone).run(async () => await func(apiZone));
+      if (!options?.internal) {
+        logApiCall(this._platform, logger, `<= ${apiZone.apiName} succeeded`);
+        this._instrumentation.onApiCallEnd(apiZone);
+      }
+      return result;
+    } catch (e) {
+      const innerError = (this._platform.showInternalStackFrames() || this._platform.isUnderTest()) && e.stack ? "\n<inner error>\n" + e.stack : "";
+      if (apiZone.apiName && !apiZone.apiName.includes("<anonymous>"))
+        e.message = apiZone.apiName + ": " + e.message;
+      const stackFrames = "\n" + (0, import_stackTrace.stringifyStackFrames)(stackTrace.frames).join("\n") + innerError;
+      if (stackFrames.trim())
+        e.stack = e.message + stackFrames;
+      else
+        e.stack = "";
+      if (!options?.internal) {
+        const recoveryHandlers = [];
+        apiZone.error = e;
+        this._instrumentation.onApiCallRecovery(apiZone, e, recoveryHandlers);
+        for (const handler of recoveryHandlers) {
+          const recoverResult = await handler();
+          if (recoverResult.status === "recovered")
+            return recoverResult.value;
+        }
+        logApiCall(this._platform, logger, `<= ${apiZone.apiName} failed`);
+        this._instrumentation.onApiCallEnd(apiZone);
+      }
+      throw e;
+    }
+  }
+  toJSON() {
+    return {
+      _type: this._type,
+      _guid: this._guid
+    };
+  }
+}
+function logApiCall(platform, logger, message) {
+  if (logger && logger.isEnabled("api", "info"))
+    logger.log("api", "info", message, [], { color: "cyan" });
+  platform.log("api", message);
+}
+function tChannelImplToWire(names, arg, path, context) {
+  if (arg._object instanceof ChannelOwner && (names === "*" || names.includes(arg._object._type)))
+    return { guid: arg._object._guid };
+  throw new import_validator.ValidationError(`${path}: expected channel ${names.toString()}`);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ChannelOwner
+});

node_modules/playwright-core/lib/client/clientHelper.js

@@ -0,0 +1,64 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var clientHelper_exports = {};
+__export(clientHelper_exports, {
+  addSourceUrlToScript: () => addSourceUrlToScript,
+  envObjectToArray: () => envObjectToArray,
+  evaluationScript: () => evaluationScript
+});
+module.exports = __toCommonJS(clientHelper_exports);
+var import_rtti = require("../utils/isomorphic/rtti");
+function envObjectToArray(env) {
+  const result = [];
+  for (const name in env) {
+    if (!Object.is(env[name], void 0))
+      result.push({ name, value: String(env[name]) });
+  }
+  return result;
+}
+async function evaluationScript(platform, fun, arg, addSourceUrl = true) {
+  if (typeof fun === "function") {
+    const source = fun.toString();
+    const argString = Object.is(arg, void 0) ? "undefined" : JSON.stringify(arg);
+    return `(${source})(${argString})`;
+  }
+  if (arg !== void 0)
+    throw new Error("Cannot evaluate a string with arguments");
+  if ((0, import_rtti.isString)(fun))
+    return fun;
+  if (fun.content !== void 0)
+    return fun.content;
+  if (fun.path !== void 0) {
+    let source = await platform.fs().promises.readFile(fun.path, "utf8");
+    if (addSourceUrl)
+      source = addSourceUrlToScript(source, fun.path);
+    return source;
+  }
+  throw new Error("Either path or content property must be present");
+}
+function addSourceUrlToScript(source, path) {
+  return `${source}
+//# sourceURL=${path.replace(/\n/g, "")}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addSourceUrlToScript,
+  envObjectToArray,
+  evaluationScript
+});

node_modules/playwright-core/lib/client/clientInstrumentation.js

@@ -0,0 +1,55 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var clientInstrumentation_exports = {};
+__export(clientInstrumentation_exports, {
+  createInstrumentation: () => createInstrumentation
+});
+module.exports = __toCommonJS(clientInstrumentation_exports);
+function createInstrumentation() {
+  const listeners = [];
+  return new Proxy({}, {
+    get: (obj, prop) => {
+      if (typeof prop !== "string")
+        return obj[prop];
+      if (prop === "addListener")
+        return (listener) => listeners.push(listener);
+      if (prop === "removeListener")
+        return (listener) => listeners.splice(listeners.indexOf(listener), 1);
+      if (prop === "removeAllListeners")
+        return () => listeners.splice(0, listeners.length);
+      if (prop.startsWith("run")) {
+        return async (...params) => {
+          for (const listener of listeners)
+            await listener[prop]?.(...params);
+        };
+      }
+      if (prop.startsWith("on")) {
+        return (...params) => {
+          for (const listener of listeners)
+            listener[prop]?.(...params);
+        };
+      }
+      return obj[prop];
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createInstrumentation
+});

node_modules/playwright-core/lib/client/clientStackTrace.js

@@ -0,0 +1,69 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var clientStackTrace_exports = {};
+__export(clientStackTrace_exports, {
+  captureLibraryStackTrace: () => captureLibraryStackTrace
+});
+module.exports = __toCommonJS(clientStackTrace_exports);
+var import_stackTrace = require("../utils/isomorphic/stackTrace");
+function captureLibraryStackTrace(platform) {
+  const stack = (0, import_stackTrace.captureRawStack)();
+  let parsedFrames = stack.map((line) => {
+    const frame = (0, import_stackTrace.parseStackFrame)(line, platform.pathSeparator, platform.showInternalStackFrames());
+    if (!frame || !frame.file)
+      return null;
+    const isPlaywrightLibrary = !!platform.coreDir && frame.file.startsWith(platform.coreDir);
+    const parsed = {
+      frame,
+      frameText: line,
+      isPlaywrightLibrary
+    };
+    return parsed;
+  }).filter(Boolean);
+  let apiName = "";
+  for (let i = 0; i < parsedFrames.length - 1; i++) {
+    const parsedFrame = parsedFrames[i];
+    if (parsedFrame.isPlaywrightLibrary && !parsedFrames[i + 1].isPlaywrightLibrary) {
+      apiName = apiName || normalizeAPIName(parsedFrame.frame.function);
+      break;
+    }
+  }
+  function normalizeAPIName(name) {
+    if (!name)
+      return "";
+    const match = name.match(/(API|JS|CDP|[A-Z])(.*)/);
+    if (!match)
+      return name;
+    return match[1].toLowerCase() + match[2];
+  }
+  const filterPrefixes = platform.boxedStackPrefixes();
+  parsedFrames = parsedFrames.filter((f) => {
+    if (filterPrefixes.some((prefix) => f.frame.file.startsWith(prefix)))
+      return false;
+    return true;
+  });
+  return {
+    frames: parsedFrames.map((p) => p.frame),
+    apiName
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  captureLibraryStackTrace
+});

node_modules/playwright-core/lib/client/clock.js

@@ -0,0 +1,68 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var clock_exports = {};
+__export(clock_exports, {
+  Clock: () => Clock
+});
+module.exports = __toCommonJS(clock_exports);
+class Clock {
+  constructor(browserContext) {
+    this._browserContext = browserContext;
+  }
+  async install(options = {}) {
+    await this._browserContext._channel.clockInstall(options.time !== void 0 ? parseTime(options.time) : {});
+  }
+  async fastForward(ticks) {
+    await this._browserContext._channel.clockFastForward(parseTicks(ticks));
+  }
+  async pauseAt(time) {
+    await this._browserContext._channel.clockPauseAt(parseTime(time));
+  }
+  async resume() {
+    await this._browserContext._channel.clockResume({});
+  }
+  async runFor(ticks) {
+    await this._browserContext._channel.clockRunFor(parseTicks(ticks));
+  }
+  async setFixedTime(time) {
+    await this._browserContext._channel.clockSetFixedTime(parseTime(time));
+  }
+  async setSystemTime(time) {
+    await this._browserContext._channel.clockSetSystemTime(parseTime(time));
+  }
+}
+function parseTime(time) {
+  if (typeof time === "number")
+    return { timeNumber: time };
+  if (typeof time === "string")
+    return { timeString: time };
+  if (!isFinite(time.getTime()))
+    throw new Error(`Invalid date: ${time}`);
+  return { timeNumber: time.getTime() };
+}
+function parseTicks(ticks) {
+  return {
+    ticksNumber: typeof ticks === "number" ? ticks : void 0,
+    ticksString: typeof ticks === "string" ? ticks : void 0
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Clock
+});

node_modules/playwright-core/lib/client/connection.js

@@ -0,0 +1,314 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var connection_exports = {};
+__export(connection_exports, {
+  Connection: () => Connection
+});
+module.exports = __toCommonJS(connection_exports);
+var import_eventEmitter = require("./eventEmitter");
+var import_android = require("./android");
+var import_artifact = require("./artifact");
+var import_browser = require("./browser");
+var import_browserContext = require("./browserContext");
+var import_browserType = require("./browserType");
+var import_cdpSession = require("./cdpSession");
+var import_channelOwner = require("./channelOwner");
+var import_clientInstrumentation = require("./clientInstrumentation");
+var import_dialog = require("./dialog");
+var import_electron = require("./electron");
+var import_elementHandle = require("./elementHandle");
+var import_errors = require("./errors");
+var import_fetch = require("./fetch");
+var import_frame = require("./frame");
+var import_jsHandle = require("./jsHandle");
+var import_jsonPipe = require("./jsonPipe");
+var import_localUtils = require("./localUtils");
+var import_network = require("./network");
+var import_page = require("./page");
+var import_playwright = require("./playwright");
+var import_stream = require("./stream");
+var import_tracing = require("./tracing");
+var import_worker = require("./worker");
+var import_writableStream = require("./writableStream");
+var import_validator = require("../protocol/validator");
+var import_stackTrace = require("../utils/isomorphic/stackTrace");
+class Root extends import_channelOwner.ChannelOwner {
+  constructor(connection) {
+    super(connection, "Root", "", {});
+  }
+  async initialize() {
+    return import_playwright.Playwright.from((await this._channel.initialize({
+      sdkLanguage: "javascript"
+    })).playwright);
+  }
+}
+class DummyChannelOwner extends import_channelOwner.ChannelOwner {
+}
+class Connection extends import_eventEmitter.EventEmitter {
+  constructor(platform, localUtils, instrumentation, headers = []) {
+    super(platform);
+    this._objects = /* @__PURE__ */ new Map();
+    this.onmessage = (message) => {
+    };
+    this._lastId = 0;
+    this._callbacks = /* @__PURE__ */ new Map();
+    this._isRemote = false;
+    this._rawBuffers = false;
+    this._tracingCount = 0;
+    this._instrumentation = instrumentation || (0, import_clientInstrumentation.createInstrumentation)();
+    this._localUtils = localUtils;
+    this._rootObject = new Root(this);
+    this.headers = headers;
+  }
+  markAsRemote() {
+    this._isRemote = true;
+  }
+  isRemote() {
+    return this._isRemote;
+  }
+  useRawBuffers() {
+    this._rawBuffers = true;
+  }
+  rawBuffers() {
+    return this._rawBuffers;
+  }
+  localUtils() {
+    return this._localUtils;
+  }
+  async initializePlaywright() {
+    return await this._rootObject.initialize();
+  }
+  getObjectWithKnownName(guid) {
+    return this._objects.get(guid);
+  }
+  setIsTracing(isTracing) {
+    if (isTracing)
+      this._tracingCount++;
+    else
+      this._tracingCount--;
+  }
+  async sendMessageToServer(object, method, params, options) {
+    if (this._closedError)
+      throw this._closedError;
+    if (object._wasCollected)
+      throw new Error("The object has been collected to prevent unbounded heap growth.");
+    const guid = object._guid;
+    const type = object._type;
+    const id = ++this._lastId;
+    const message = { id, guid, method, params };
+    if (this._platform.isLogEnabled("channel")) {
+      this._platform.log("channel", "SEND> " + JSON.stringify(message));
+    }
+    const location = options.frames?.[0] ? { file: options.frames[0].file, line: options.frames[0].line, column: options.frames[0].column } : void 0;
+    const metadata = { title: options.title, location, internal: options.internal, stepId: options.stepId };
+    if (this._tracingCount && options.frames && type !== "LocalUtils")
+      this._localUtils?.addStackToTracingNoReply({ callData: { stack: options.frames ?? [], id } }).catch(() => {
+      });
+    this._platform.zones.empty.run(() => this.onmessage({ ...message, metadata }));
+    return await new Promise((resolve, reject) => this._callbacks.set(id, { resolve, reject, title: options.title, type, method }));
+  }
+  _validatorFromWireContext() {
+    return {
+      tChannelImpl: this._tChannelImplFromWire.bind(this),
+      binary: this._rawBuffers ? "buffer" : "fromBase64",
+      isUnderTest: () => this._platform.isUnderTest()
+    };
+  }
+  dispatch(message) {
+    if (this._closedError)
+      return;
+    const { id, guid, method, params, result, error, log } = message;
+    if (id) {
+      if (this._platform.isLogEnabled("channel"))
+        this._platform.log("channel", "<RECV " + JSON.stringify(message));
+      const callback = this._callbacks.get(id);
+      if (!callback)
+        throw new Error(`Cannot find command to respond: ${id}`);
+      this._callbacks.delete(id);
+      if (error && !result) {
+        const parsedError = (0, import_errors.parseError)(error);
+        (0, import_stackTrace.rewriteErrorMessage)(parsedError, parsedError.message + formatCallLog(this._platform, log));
+        callback.reject(parsedError);
+      } else {
+        const validator2 = (0, import_validator.findValidator)(callback.type, callback.method, "Result");
+        callback.resolve(validator2(result, "", this._validatorFromWireContext()));
+      }
+      return;
+    }
+    if (this._platform.isLogEnabled("channel"))
+      this._platform.log("channel", "<EVENT " + JSON.stringify(message));
+    if (method === "__create__") {
+      this._createRemoteObject(guid, params.type, params.guid, params.initializer);
+      return;
+    }
+    const object = this._objects.get(guid);
+    if (!object)
+      throw new Error(`Cannot find object to "${method}": ${guid}`);
+    if (method === "__adopt__") {
+      const child = this._objects.get(params.guid);
+      if (!child)
+        throw new Error(`Unknown new child: ${params.guid}`);
+      object._adopt(child);
+      return;
+    }
+    if (method === "__dispose__") {
+      object._dispose(params.reason);
+      return;
+    }
+    const validator = (0, import_validator.findValidator)(object._type, method, "Event");
+    object._channel.emit(method, validator(params, "", this._validatorFromWireContext()));
+  }
+  close(cause) {
+    if (this._closedError)
+      return;
+    this._closedError = new import_errors.TargetClosedError(cause);
+    for (const callback of this._callbacks.values())
+      callback.reject(this._closedError);
+    this._callbacks.clear();
+    this.emit("close");
+  }
+  _tChannelImplFromWire(names, arg, path, context) {
+    if (arg && typeof arg === "object" && typeof arg.guid === "string") {
+      const object = this._objects.get(arg.guid);
+      if (!object)
+        throw new Error(`Object with guid ${arg.guid} was not bound in the connection`);
+      if (names !== "*" && !names.includes(object._type))
+        throw new import_validator.ValidationError(`${path}: expected channel ${names.toString()}`);
+      return object._channel;
+    }
+    throw new import_validator.ValidationError(`${path}: expected channel ${names.toString()}`);
+  }
+  _createRemoteObject(parentGuid, type, guid, initializer) {
+    const parent = this._objects.get(parentGuid);
+    if (!parent)
+      throw new Error(`Cannot find parent object ${parentGuid} to create ${guid}`);
+    let result;
+    const validator = (0, import_validator.findValidator)(type, "", "Initializer");
+    initializer = validator(initializer, "", this._validatorFromWireContext());
+    switch (type) {
+      case "Android":
+        result = new import_android.Android(parent, type, guid, initializer);
+        break;
+      case "AndroidSocket":
+        result = new import_android.AndroidSocket(parent, type, guid, initializer);
+        break;
+      case "AndroidDevice":
+        result = new import_android.AndroidDevice(parent, type, guid, initializer);
+        break;
+      case "APIRequestContext":
+        result = new import_fetch.APIRequestContext(parent, type, guid, initializer);
+        break;
+      case "Artifact":
+        result = new import_artifact.Artifact(parent, type, guid, initializer);
+        break;
+      case "BindingCall":
+        result = new import_page.BindingCall(parent, type, guid, initializer);
+        break;
+      case "Browser":
+        result = new import_browser.Browser(parent, type, guid, initializer);
+        break;
+      case "BrowserContext":
+        result = new import_browserContext.BrowserContext(parent, type, guid, initializer);
+        break;
+      case "BrowserType":
+        result = new import_browserType.BrowserType(parent, type, guid, initializer);
+        break;
+      case "CDPSession":
+        result = new import_cdpSession.CDPSession(parent, type, guid, initializer);
+        break;
+      case "Dialog":
+        result = new import_dialog.Dialog(parent, type, guid, initializer);
+        break;
+      case "Electron":
+        result = new import_electron.Electron(parent, type, guid, initializer);
+        break;
+      case "ElectronApplication":
+        result = new import_electron.ElectronApplication(parent, type, guid, initializer);
+        break;
+      case "ElementHandle":
+        result = new import_elementHandle.ElementHandle(parent, type, guid, initializer);
+        break;
+      case "Frame":
+        result = new import_frame.Frame(parent, type, guid, initializer);
+        break;
+      case "JSHandle":
+        result = new import_jsHandle.JSHandle(parent, type, guid, initializer);
+        break;
+      case "JsonPipe":
+        result = new import_jsonPipe.JsonPipe(parent, type, guid, initializer);
+        break;
+      case "LocalUtils":
+        result = new import_localUtils.LocalUtils(parent, type, guid, initializer);
+        if (!this._localUtils)
+          this._localUtils = result;
+        break;
+      case "Page":
+        result = new import_page.Page(parent, type, guid, initializer);
+        break;
+      case "Playwright":
+        result = new import_playwright.Playwright(parent, type, guid, initializer);
+        break;
+      case "Request":
+        result = new import_network.Request(parent, type, guid, initializer);
+        break;
+      case "Response":
+        result = new import_network.Response(parent, type, guid, initializer);
+        break;
+      case "Route":
+        result = new import_network.Route(parent, type, guid, initializer);
+        break;
+      case "Stream":
+        result = new import_stream.Stream(parent, type, guid, initializer);
+        break;
+      case "SocksSupport":
+        result = new DummyChannelOwner(parent, type, guid, initializer);
+        break;
+      case "Tracing":
+        result = new import_tracing.Tracing(parent, type, guid, initializer);
+        break;
+      case "WebSocket":
+        result = new import_network.WebSocket(parent, type, guid, initializer);
+        break;
+      case "WebSocketRoute":
+        result = new import_network.WebSocketRoute(parent, type, guid, initializer);
+        break;
+      case "Worker":
+        result = new import_worker.Worker(parent, type, guid, initializer);
+        break;
+      case "WritableStream":
+        result = new import_writableStream.WritableStream(parent, type, guid, initializer);
+        break;
+      default:
+        throw new Error("Missing type " + type);
+    }
+    return result;
+  }
+}
+function formatCallLog(platform, log) {
+  if (!log || !log.some((l) => !!l))
+    return "";
+  return `
+Call log:
+${platform.colors.dim(log.join("\n"))}
+`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Connection
+});

node_modules/playwright-core/lib/client/consoleMessage.js

@@ -0,0 +1,55 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var consoleMessage_exports = {};
+__export(consoleMessage_exports, {
+  ConsoleMessage: () => ConsoleMessage
+});
+module.exports = __toCommonJS(consoleMessage_exports);
+var import_jsHandle = require("./jsHandle");
+var import_page = require("./page");
+class ConsoleMessage {
+  constructor(platform, event) {
+    this._page = "page" in event && event.page ? import_page.Page.from(event.page) : null;
+    this._event = event;
+    if (platform.inspectCustom)
+      this[platform.inspectCustom] = () => this._inspect();
+  }
+  page() {
+    return this._page;
+  }
+  type() {
+    return this._event.type;
+  }
+  text() {
+    return this._event.text;
+  }
+  args() {
+    return this._event.args.map(import_jsHandle.JSHandle.from);
+  }
+  location() {
+    return this._event.location;
+  }
+  _inspect() {
+    return this.text();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConsoleMessage
+});

node_modules/playwright-core/lib/client/coverage.js

@@ -0,0 +1,44 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var coverage_exports = {};
+__export(coverage_exports, {
+  Coverage: () => Coverage
+});
+module.exports = __toCommonJS(coverage_exports);
+class Coverage {
+  constructor(channel) {
+    this._channel = channel;
+  }
+  async startJSCoverage(options = {}) {
+    await this._channel.startJSCoverage(options);
+  }
+  async stopJSCoverage() {
+    return (await this._channel.stopJSCoverage()).entries;
+  }
+  async startCSSCoverage(options = {}) {
+    await this._channel.startCSSCoverage(options);
+  }
+  async stopCSSCoverage() {
+    return (await this._channel.stopCSSCoverage()).entries;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Coverage
+});

node_modules/playwright-core/lib/client/dialog.js

@@ -0,0 +1,56 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dialog_exports = {};
+__export(dialog_exports, {
+  Dialog: () => Dialog
+});
+module.exports = __toCommonJS(dialog_exports);
+var import_channelOwner = require("./channelOwner");
+var import_page = require("./page");
+class Dialog extends import_channelOwner.ChannelOwner {
+  static from(dialog) {
+    return dialog._object;
+  }
+  constructor(parent, type, guid, initializer) {
+    super(parent, type, guid, initializer);
+    this._page = import_page.Page.fromNullable(initializer.page);
+  }
+  page() {
+    return this._page;
+  }
+  type() {
+    return this._initializer.type;
+  }
+  message() {
+    return this._initializer.message;
+  }
+  defaultValue() {
+    return this._initializer.defaultValue;
+  }
+  async accept(promptText) {
+    await this._channel.accept({ promptText });
+  }
+  async dismiss() {
+    await this._channel.dismiss();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Dialog
+});

node_modules/playwright-core/lib/client/download.js

@@ -0,0 +1,62 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var download_exports = {};
+__export(download_exports, {
+  Download: () => Download
+});
+module.exports = __toCommonJS(download_exports);
+class Download {
+  constructor(page, url, suggestedFilename, artifact) {
+    this._page = page;
+    this._url = url;
+    this._suggestedFilename = suggestedFilename;
+    this._artifact = artifact;
+  }
+  page() {
+    return this._page;
+  }
+  url() {
+    return this._url;
+  }
+  suggestedFilename() {
+    return this._suggestedFilename;
+  }
+  async path() {
+    return await this._artifact.pathAfterFinished();
+  }
+  async saveAs(path) {
+    return await this._artifact.saveAs(path);
+  }
+  async failure() {
+    return await this._artifact.failure();
+  }
+  async createReadStream() {
+    return await this._artifact.createReadStream();
+  }
+  async cancel() {
+    return await this._artifact.cancel();
+  }
+  async delete() {
+    return await this._artifact.delete();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Download
+});

node_modules/playwright-core/lib/client/electron.js

@@ -0,0 +1,138 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var electron_exports = {};
+__export(electron_exports, {
+  Electron: () => Electron,
+  ElectronApplication: () => ElectronApplication
+});
+module.exports = __toCommonJS(electron_exports);
+var import_browserContext = require("./browserContext");
+var import_channelOwner = require("./channelOwner");
+var import_clientHelper = require("./clientHelper");
+var import_consoleMessage = require("./consoleMessage");
+var import_errors = require("./errors");
+var import_events = require("./events");
+var import_jsHandle = require("./jsHandle");
+var import_waiter = require("./waiter");
+var import_timeoutSettings = require("./timeoutSettings");
+class Electron extends import_channelOwner.ChannelOwner {
+  static from(electron) {
+    return electron._object;
+  }
+  constructor(parent, type, guid, initializer) {
+    super(parent, type, guid, initializer);
+  }
+  async launch(options = {}) {
+    options = this._playwright.selectors._withSelectorOptions(options);
+    const params = {
+      ...await (0, import_browserContext.prepareBrowserContextParams)(this._platform, options),
+      env: (0, import_clientHelper.envObjectToArray)(options.env ? options.env : this._platform.env),
+      tracesDir: options.tracesDir,
+      timeout: new import_timeoutSettings.TimeoutSettings(this._platform).launchTimeout(options)
+    };
+    const app = ElectronApplication.from((await this._channel.launch(params)).electronApplication);
+    this._playwright.selectors._contextsForSelectors.add(app._context);
+    app.once(import_events.Events.ElectronApplication.Close, () => this._playwright.selectors._contextsForSelectors.delete(app._context));
+    await app._context._initializeHarFromOptions(options.recordHar);
+    app._context.tracing._tracesDir = options.tracesDir;
+    return app;
+  }
+}
+class ElectronApplication extends import_channelOwner.ChannelOwner {
+  constructor(parent, type, guid, initializer) {
+    super(parent, type, guid, initializer);
+    this._windows = /* @__PURE__ */ new Set();
+    this._timeoutSettings = new import_timeoutSettings.TimeoutSettings(this._platform);
+    this._context = import_browserContext.BrowserContext.from(initializer.context);
+    for (const page of this._context._pages)
+      this._onPage(page);
+    this._context.on(import_events.Events.BrowserContext.Page, (page) => this._onPage(page));
+    this._channel.on("close", () => {
+      this.emit(import_events.Events.ElectronApplication.Close);
+    });
+    this._channel.on("console", (event) => this.emit(import_events.Events.ElectronApplication.Console, new import_consoleMessage.ConsoleMessage(this._platform, event)));
+    this._setEventToSubscriptionMapping(/* @__PURE__ */ new Map([
+      [import_events.Events.ElectronApplication.Console, "console"]
+    ]));
+  }
+  static from(electronApplication) {
+    return electronApplication._object;
+  }
+  process() {
+    return this._connection.toImpl?.(this)?.process();
+  }
+  _onPage(page) {
+    this._windows.add(page);
+    this.emit(import_events.Events.ElectronApplication.Window, page);
+    page.once(import_events.Events.Page.Close, () => this._windows.delete(page));
+  }
+  windows() {
+    return [...this._windows];
+  }
+  async firstWindow(options) {
+    if (this._windows.size)
+      return this._windows.values().next().value;
+    return await this.waitForEvent("window", options);
+  }
+  context() {
+    return this._context;
+  }
+  async [Symbol.asyncDispose]() {
+    await this.close();
+  }
+  async close() {
+    try {
+      await this._context.close();
+    } catch (e) {
+      if ((0, import_errors.isTargetClosedError)(e))
+        return;
+      throw e;
+    }
+  }
+  async waitForEvent(event, optionsOrPredicate = {}) {
+    return await this._wrapApiCall(async () => {
+      const timeout = this._timeoutSettings.timeout(typeof optionsOrPredicate === "function" ? {} : optionsOrPredicate);
+      const predicate = typeof optionsOrPredicate === "function" ? optionsOrPredicate : optionsOrPredicate.predicate;
+      const waiter = import_waiter.Waiter.createForEvent(this, event);
+      waiter.rejectOnTimeout(timeout, `Timeout ${timeout}ms exceeded while waiting for event "${event}"`);
+      if (event !== import_events.Events.ElectronApplication.Close)
+        waiter.rejectOnEvent(this, import_events.Events.ElectronApplication.Close, () => new import_errors.TargetClosedError());
+      const result = await waiter.waitForEvent(this, event, predicate);
+      waiter.dispose();
+      return result;
+    });
+  }
+  async browserWindow(page) {
+    const result = await this._channel.browserWindow({ page: page._channel });
+    return import_jsHandle.JSHandle.from(result.handle);
+  }
+  async evaluate(pageFunction, arg) {
+    const result = await this._channel.evaluateExpression({ expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: (0, import_jsHandle.serializeArgument)(arg) });
+    return (0, import_jsHandle.parseResult)(result.value);
+  }
+  async evaluateHandle(pageFunction, arg) {
+    const result = await this._channel.evaluateExpressionHandle({ expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: (0, import_jsHandle.serializeArgument)(arg) });
+    return import_jsHandle.JSHandle.from(result.handle);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Electron,
+  ElectronApplication
+});

node_modules/playwright-core/lib/client/elementHandle.js

@@ -0,0 +1,281 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var elementHandle_exports = {};
+__export(elementHandle_exports, {
+  ElementHandle: () => ElementHandle,
+  convertInputFiles: () => convertInputFiles,
+  convertSelectOptionValues: () => convertSelectOptionValues,
+  determineScreenshotType: () => determineScreenshotType
+});
+module.exports = __toCommonJS(elementHandle_exports);
+var import_frame = require("./frame");
+var import_jsHandle = require("./jsHandle");
+var import_assert = require("../utils/isomorphic/assert");
+var import_fileUtils = require("./fileUtils");
+var import_rtti = require("../utils/isomorphic/rtti");
+var import_writableStream = require("./writableStream");
+var import_mimeType = require("../utils/isomorphic/mimeType");
+class ElementHandle extends import_jsHandle.JSHandle {
+  static from(handle) {
+    return handle._object;
+  }
+  static fromNullable(handle) {
+    return handle ? ElementHandle.from(handle) : null;
+  }
+  constructor(parent, type, guid, initializer) {
+    super(parent, type, guid, initializer);
+    this._frame = parent;
+    this._elementChannel = this._channel;
+  }
+  asElement() {
+    return this;
+  }
+  async ownerFrame() {
+    return import_frame.Frame.fromNullable((await this._elementChannel.ownerFrame()).frame);
+  }
+  async contentFrame() {
+    return import_frame.Frame.fromNullable((await this._elementChannel.contentFrame()).frame);
+  }
+  async getAttribute(name) {
+    const value = (await this._elementChannel.getAttribute({ name })).value;
+    return value === void 0 ? null : value;
+  }
+  async inputValue() {
+    return (await this._elementChannel.inputValue()).value;
+  }
+  async textContent() {
+    const value = (await this._elementChannel.textContent()).value;
+    return value === void 0 ? null : value;
+  }
+  async innerText() {
+    return (await this._elementChannel.innerText()).value;
+  }
+  async innerHTML() {
+    return (await this._elementChannel.innerHTML()).value;
+  }
+  async isChecked() {
+    return (await this._elementChannel.isChecked()).value;
+  }
+  async isDisabled() {
+    return (await this._elementChannel.isDisabled()).value;
+  }
+  async isEditable() {
+    return (await this._elementChannel.isEditable()).value;
+  }
+  async isEnabled() {
+    return (await this._elementChannel.isEnabled()).value;
+  }
+  async isHidden() {
+    return (await this._elementChannel.isHidden()).value;
+  }
+  async isVisible() {
+    return (await this._elementChannel.isVisible()).value;
+  }
+  async dispatchEvent(type, eventInit = {}) {
+    await this._elementChannel.dispatchEvent({ type, eventInit: (0, import_jsHandle.serializeArgument)(eventInit) });
+  }
+  async scrollIntoViewIfNeeded(options = {}) {
+    await this._elementChannel.scrollIntoViewIfNeeded({ ...options, timeout: this._frame._timeout(options) });
+  }
+  async hover(options = {}) {
+    await this._elementChannel.hover({ ...options, timeout: this._frame._timeout(options) });
+  }
+  async click(options = {}) {
+    return await this._elementChannel.click({ ...options, timeout: this._frame._timeout(options) });
+  }
+  async dblclick(options = {}) {
+    return await this._elementChannel.dblclick({ ...options, timeout: this._frame._timeout(options) });
+  }
+  async tap(options = {}) {
+    return await this._elementChannel.tap({ ...options, timeout: this._frame._timeout(options) });
+  }
+  async selectOption(values, options = {}) {
+    const result = await this._elementChannel.selectOption({ ...convertSelectOptionValues(values), ...options, timeout: this._frame._timeout(options) });
+    return result.values;
+  }
+  async fill(value, options = {}) {
+    return await this._elementChannel.fill({ value, ...options, timeout: this._frame._timeout(options) });
+  }
+  async selectText(options = {}) {
+    await this._elementChannel.selectText({ ...options, timeout: this._frame._timeout(options) });
+  }
+  async setInputFiles(files, options = {}) {
+    const frame = await this.ownerFrame();
+    if (!frame)
+      throw new Error("Cannot set input files to detached element");
+    const converted = await convertInputFiles(this._platform, files, frame.page().context());
+    await this._elementChannel.setInputFiles({ ...converted, ...options, timeout: this._frame._timeout(options) });
+  }
+  async focus() {
+    await this._elementChannel.focus();
+  }
+  async type(text, options = {}) {
+    await this._elementChannel.type({ text, ...options, timeout: this._frame._timeout(options) });
+  }
+  async press(key, options = {}) {
+    await this._elementChannel.press({ key, ...options, timeout: this._frame._timeout(options) });
+  }
+  async check(options = {}) {
+    return await this._elementChannel.check({ ...options, timeout: this._frame._timeout(options) });
+  }
+  async uncheck(options = {}) {
+    return await this._elementChannel.uncheck({ ...options, timeout: this._frame._timeout(options) });
+  }
+  async setChecked(checked, options) {
+    if (checked)
+      await this.check(options);
+    else
+      await this.uncheck(options);
+  }
+  async boundingBox() {
+    const value = (await this._elementChannel.boundingBox()).value;
+    return value === void 0 ? null : value;
+  }
+  async screenshot(options = {}) {
+    const mask = options.mask;
+    const copy = { ...options, mask: void 0, timeout: this._frame._timeout(options) };
+    if (!copy.type)
+      copy.type = determineScreenshotType(options);
+    if (mask) {
+      copy.mask = mask.map((locator) => ({
+        frame: locator._frame._channel,
+        selector: locator._selector
+      }));
+    }
+    const result = await this._elementChannel.screenshot(copy);
+    if (options.path) {
+      await (0, import_fileUtils.mkdirIfNeeded)(this._platform, options.path);
+      await this._platform.fs().promises.writeFile(options.path, result.binary);
+    }
+    return result.binary;
+  }
+  async $(selector) {
+    return ElementHandle.fromNullable((await this._elementChannel.querySelector({ selector })).element);
+  }
+  async $$(selector) {
+    const result = await this._elementChannel.querySelectorAll({ selector });
+    return result.elements.map((h) => ElementHandle.from(h));
+  }
+  async $eval(selector, pageFunction, arg) {
+    const result = await this._elementChannel.evalOnSelector({ selector, expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: (0, import_jsHandle.serializeArgument)(arg) });
+    return (0, import_jsHandle.parseResult)(result.value);
+  }
+  async $$eval(selector, pageFunction, arg) {
+    const result = await this._elementChannel.evalOnSelectorAll({ selector, expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: (0, import_jsHandle.serializeArgument)(arg) });
+    return (0, import_jsHandle.parseResult)(result.value);
+  }
+  async waitForElementState(state, options = {}) {
+    return await this._elementChannel.waitForElementState({ state, ...options, timeout: this._frame._timeout(options) });
+  }
+  async waitForSelector(selector, options = {}) {
+    const result = await this._elementChannel.waitForSelector({ selector, ...options, timeout: this._frame._timeout(options) });
+    return ElementHandle.fromNullable(result.element);
+  }
+}
+function convertSelectOptionValues(values) {
+  if (values === null)
+    return {};
+  if (!Array.isArray(values))
+    values = [values];
+  if (!values.length)
+    return {};
+  for (let i = 0; i < values.length; i++)
+    (0, import_assert.assert)(values[i] !== null, `options[${i}]: expected object, got null`);
+  if (values[0] instanceof ElementHandle)
+    return { elements: values.map((v) => v._elementChannel) };
+  if ((0, import_rtti.isString)(values[0]))
+    return { options: values.map((valueOrLabel) => ({ valueOrLabel })) };
+  return { options: values };
+}
+function filePayloadExceedsSizeLimit(payloads) {
+  return payloads.reduce((size, item) => size + (item.buffer ? item.buffer.byteLength : 0), 0) >= import_fileUtils.fileUploadSizeLimit;
+}
+async function resolvePathsAndDirectoryForInputFiles(platform, items) {
+  let localPaths;
+  let localDirectory;
+  for (const item of items) {
+    const stat = await platform.fs().promises.stat(item);
+    if (stat.isDirectory()) {
+      if (localDirectory)
+        throw new Error("Multiple directories are not supported");
+      localDirectory = platform.path().resolve(item);
+    } else {
+      localPaths ??= [];
+      localPaths.push(platform.path().resolve(item));
+    }
+  }
+  if (localPaths?.length && localDirectory)
+    throw new Error("File paths must be all files or a single directory");
+  return [localPaths, localDirectory];
+}
+async function convertInputFiles(platform, files, context) {
+  const items = Array.isArray(files) ? files.slice() : [files];
+  if (items.some((item) => typeof item === "string")) {
+    if (!items.every((item) => typeof item === "string"))
+      throw new Error("File paths cannot be mixed with buffers");
+    const [localPaths, localDirectory] = await resolvePathsAndDirectoryForInputFiles(platform, items);
+    if (context._connection.isRemote()) {
+      const files2 = localDirectory ? (await platform.fs().promises.readdir(localDirectory, { withFileTypes: true, recursive: true })).filter((f) => f.isFile()).map((f) => platform.path().join(f.path, f.name)) : localPaths;
+      const { writableStreams, rootDir } = await context._wrapApiCall(async () => context._channel.createTempFiles({
+        rootDirName: localDirectory ? platform.path().basename(localDirectory) : void 0,
+        items: await Promise.all(files2.map(async (file) => {
+          const lastModifiedMs = (await platform.fs().promises.stat(file)).mtimeMs;
+          return {
+            name: localDirectory ? platform.path().relative(localDirectory, file) : platform.path().basename(file),
+            lastModifiedMs
+          };
+        }))
+      }), { internal: true });
+      for (let i = 0; i < files2.length; i++) {
+        const writable = import_writableStream.WritableStream.from(writableStreams[i]);
+        await platform.streamFile(files2[i], writable.stream());
+      }
+      return {
+        directoryStream: rootDir,
+        streams: localDirectory ? void 0 : writableStreams
+      };
+    }
+    return {
+      localPaths,
+      localDirectory
+    };
+  }
+  const payloads = items;
+  if (filePayloadExceedsSizeLimit(payloads))
+    throw new Error("Cannot set buffer larger than 50Mb, please write it to a file and pass its path instead.");
+  return { payloads };
+}
+function determineScreenshotType(options) {
+  if (options.path) {
+    const mimeType = (0, import_mimeType.getMimeTypeForPath)(options.path);
+    if (mimeType === "image/png")
+      return "png";
+    else if (mimeType === "image/jpeg")
+      return "jpeg";
+    throw new Error(`path: unsupported mime type "${mimeType}"`);
+  }
+  return options.type;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ElementHandle,
+  convertInputFiles,
+  convertSelectOptionValues,
+  determineScreenshotType
+});

node_modules/playwright-core/lib/client/errors.js

@@ -0,0 +1,77 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var errors_exports = {};
+__export(errors_exports, {
+  TargetClosedError: () => TargetClosedError,
+  TimeoutError: () => TimeoutError,
+  isTargetClosedError: () => isTargetClosedError,
+  parseError: () => parseError,
+  serializeError: () => serializeError
+});
+module.exports = __toCommonJS(errors_exports);
+var import_serializers = require("../protocol/serializers");
+var import_rtti = require("../utils/isomorphic/rtti");
+class TimeoutError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TimeoutError";
+  }
+}
+class TargetClosedError extends Error {
+  constructor(cause) {
+    super(cause || "Target page, context or browser has been closed");
+  }
+}
+function isTargetClosedError(error) {
+  return error instanceof TargetClosedError;
+}
+function serializeError(e) {
+  if ((0, import_rtti.isError)(e))
+    return { error: { message: e.message, stack: e.stack, name: e.name } };
+  return { value: (0, import_serializers.serializeValue)(e, (value) => ({ fallThrough: value })) };
+}
+function parseError(error) {
+  if (!error.error) {
+    if (error.value === void 0)
+      throw new Error("Serialized error must have either an error or a value");
+    return (0, import_serializers.parseSerializedValue)(error.value, void 0);
+  }
+  if (error.error.name === "TimeoutError") {
+    const e2 = new TimeoutError(error.error.message);
+    e2.stack = error.error.stack || "";
+    return e2;
+  }
+  if (error.error.name === "TargetClosedError") {
+    const e2 = new TargetClosedError(error.error.message);
+    e2.stack = error.error.stack || "";
+    return e2;
+  }
+  const e = new Error(error.error.message);
+  e.stack = error.error.stack || "";
+  e.name = error.error.name;
+  return e;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TargetClosedError,
+  TimeoutError,
+  isTargetClosedError,
+  parseError,
+  serializeError
+});

node_modules/playwright-core/lib/client/eventEmitter.js

@@ -0,0 +1,314 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var eventEmitter_exports = {};
+__export(eventEmitter_exports, {
+  EventEmitter: () => EventEmitter
+});
+module.exports = __toCommonJS(eventEmitter_exports);
+class EventEmitter {
+  constructor(platform) {
+    this._events = void 0;
+    this._eventsCount = 0;
+    this._maxListeners = void 0;
+    this._pendingHandlers = /* @__PURE__ */ new Map();
+    this._platform = platform;
+    if (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) {
+      this._events = /* @__PURE__ */ Object.create(null);
+      this._eventsCount = 0;
+    }
+    this._maxListeners = this._maxListeners || void 0;
+    this.on = this.addListener;
+    this.off = this.removeListener;
+  }
+  setMaxListeners(n) {
+    if (typeof n !== "number" || n < 0 || Number.isNaN(n))
+      throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + ".");
+    this._maxListeners = n;
+    return this;
+  }
+  getMaxListeners() {
+    return this._maxListeners === void 0 ? this._platform.defaultMaxListeners() : this._maxListeners;
+  }
+  emit(type, ...args) {
+    const events = this._events;
+    if (events === void 0)
+      return false;
+    const handler = events?.[type];
+    if (handler === void 0)
+      return false;
+    if (typeof handler === "function") {
+      this._callHandler(type, handler, args);
+    } else {
+      const len = handler.length;
+      const listeners = handler.slice();
+      for (let i = 0; i < len; ++i)
+        this._callHandler(type, listeners[i], args);
+    }
+    return true;
+  }
+  _callHandler(type, handler, args) {
+    const promise = Reflect.apply(handler, this, args);
+    if (!(promise instanceof Promise))
+      return;
+    let set = this._pendingHandlers.get(type);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this._pendingHandlers.set(type, set);
+    }
+    set.add(promise);
+    promise.catch((e) => {
+      if (this._rejectionHandler)
+        this._rejectionHandler(e);
+      else
+        throw e;
+    }).finally(() => set.delete(promise));
+  }
+  addListener(type, listener) {
+    return this._addListener(type, listener, false);
+  }
+  on(type, listener) {
+    return this._addListener(type, listener, false);
+  }
+  _addListener(type, listener, prepend) {
+    checkListener(listener);
+    let events = this._events;
+    let existing;
+    if (events === void 0) {
+      events = this._events = /* @__PURE__ */ Object.create(null);
+      this._eventsCount = 0;
+    } else {
+      if (events.newListener !== void 0) {
+        this.emit("newListener", type, unwrapListener(listener));
+        events = this._events;
+      }
+      existing = events[type];
+    }
+    if (existing === void 0) {
+      existing = events[type] = listener;
+      ++this._eventsCount;
+    } else {
+      if (typeof existing === "function") {
+        existing = events[type] = prepend ? [listener, existing] : [existing, listener];
+      } else if (prepend) {
+        existing.unshift(listener);
+      } else {
+        existing.push(listener);
+      }
+      const m = this.getMaxListeners();
+      if (m > 0 && existing.length > m && !existing.warned) {
+        existing.warned = true;
+        const w = new Error("Possible EventEmitter memory leak detected. " + existing.length + " " + String(type) + " listeners added. Use emitter.setMaxListeners() to increase limit");
+        w.name = "MaxListenersExceededWarning";
+        w.emitter = this;
+        w.type = type;
+        w.count = existing.length;
+        if (!this._platform.isUnderTest()) {
+          console.warn(w);
+        }
+      }
+    }
+    return this;
+  }
+  prependListener(type, listener) {
+    return this._addListener(type, listener, true);
+  }
+  once(type, listener) {
+    checkListener(listener);
+    this.on(type, new OnceWrapper(this, type, listener).wrapperFunction);
+    return this;
+  }
+  prependOnceListener(type, listener) {
+    checkListener(listener);
+    this.prependListener(type, new OnceWrapper(this, type, listener).wrapperFunction);
+    return this;
+  }
+  removeListener(type, listener) {
+    checkListener(listener);
+    const events = this._events;
+    if (events === void 0)
+      return this;
+    const list = events[type];
+    if (list === void 0)
+      return this;
+    if (list === listener || list.listener === listener) {
+      if (--this._eventsCount === 0) {
+        this._events = /* @__PURE__ */ Object.create(null);
+      } else {
+        delete events[type];
+        if (events.removeListener)
+          this.emit("removeListener", type, list.listener ?? listener);
+      }
+    } else if (typeof list !== "function") {
+      let position = -1;
+      let originalListener;
+      for (let i = list.length - 1; i >= 0; i--) {
+        if (list[i] === listener || wrappedListener(list[i]) === listener) {
+          originalListener = wrappedListener(list[i]);
+          position = i;
+          break;
+        }
+      }
+      if (position < 0)
+        return this;
+      if (position === 0)
+        list.shift();
+      else
+        list.splice(position, 1);
+      if (list.length === 1)
+        events[type] = list[0];
+      if (events.removeListener !== void 0)
+        this.emit("removeListener", type, originalListener || listener);
+    }
+    return this;
+  }
+  off(type, listener) {
+    return this.removeListener(type, listener);
+  }
+  removeAllListeners(type, options) {
+    this._removeAllListeners(type);
+    if (!options)
+      return this;
+    if (options.behavior === "wait") {
+      const errors = [];
+      this._rejectionHandler = (error) => errors.push(error);
+      return this._waitFor(type).then(() => {
+        if (errors.length)
+          throw errors[0];
+      });
+    }
+    if (options.behavior === "ignoreErrors")
+      this._rejectionHandler = () => {
+      };
+    return Promise.resolve();
+  }
+  _removeAllListeners(type) {
+    const events = this._events;
+    if (!events)
+      return;
+    if (!events.removeListener) {
+      if (type === void 0) {
+        this._events = /* @__PURE__ */ Object.create(null);
+        this._eventsCount = 0;
+      } else if (events[type] !== void 0) {
+        if (--this._eventsCount === 0)
+          this._events = /* @__PURE__ */ Object.create(null);
+        else
+          delete events[type];
+      }
+      return;
+    }
+    if (type === void 0) {
+      const keys = Object.keys(events);
+      let key;
+      for (let i = 0; i < keys.length; ++i) {
+        key = keys[i];
+        if (key === "removeListener")
+          continue;
+        this._removeAllListeners(key);
+      }
+      this._removeAllListeners("removeListener");
+      this._events = /* @__PURE__ */ Object.create(null);
+      this._eventsCount = 0;
+      return;
+    }
+    const listeners = events[type];
+    if (typeof listeners === "function") {
+      this.removeListener(type, listeners);
+    } else if (listeners !== void 0) {
+      for (let i = listeners.length - 1; i >= 0; i--)
+        this.removeListener(type, listeners[i]);
+    }
+  }
+  listeners(type) {
+    return this._listeners(this, type, true);
+  }
+  rawListeners(type) {
+    return this._listeners(this, type, false);
+  }
+  listenerCount(type) {
+    const events = this._events;
+    if (events !== void 0) {
+      const listener = events[type];
+      if (typeof listener === "function")
+        return 1;
+      if (listener !== void 0)
+        return listener.length;
+    }
+    return 0;
+  }
+  eventNames() {
+    return this._eventsCount > 0 && this._events ? Reflect.ownKeys(this._events) : [];
+  }
+  async _waitFor(type) {
+    let promises = [];
+    if (type) {
+      promises = [...this._pendingHandlers.get(type) || []];
+    } else {
+      promises = [];
+      for (const [, pending] of this._pendingHandlers)
+        promises.push(...pending);
+    }
+    await Promise.all(promises);
+  }
+  _listeners(target, type, unwrap) {
+    const events = target._events;
+    if (events === void 0)
+      return [];
+    const listener = events[type];
+    if (listener === void 0)
+      return [];
+    if (typeof listener === "function")
+      return unwrap ? [unwrapListener(listener)] : [listener];
+    return unwrap ? unwrapListeners(listener) : listener.slice();
+  }
+}
+function checkListener(listener) {
+  if (typeof listener !== "function")
+    throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
+}
+class OnceWrapper {
+  constructor(eventEmitter, eventType, listener) {
+    this._fired = false;
+    this._eventEmitter = eventEmitter;
+    this._eventType = eventType;
+    this._listener = listener;
+    this.wrapperFunction = this._handle.bind(this);
+    this.wrapperFunction.listener = listener;
+  }
+  _handle(...args) {
+    if (this._fired)
+      return;
+    this._fired = true;
+    this._eventEmitter.removeListener(this._eventType, this.wrapperFunction);
+    return this._listener.apply(this._eventEmitter, args);
+  }
+}
+function unwrapListener(l) {
+  return wrappedListener(l) ?? l;
+}
+function unwrapListeners(arr) {
+  return arr.map((l) => wrappedListener(l) ?? l);
+}
+function wrappedListener(l) {
+  return l.listener;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EventEmitter
+});

node_modules/playwright-core/lib/client/events.js

@@ -0,0 +1,98 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var events_exports = {};
+__export(events_exports, {
+  Events: () => Events
+});
+module.exports = __toCommonJS(events_exports);
+const Events = {
+  AndroidDevice: {
+    WebView: "webview",
+    Close: "close"
+  },
+  AndroidSocket: {
+    Data: "data",
+    Close: "close"
+  },
+  AndroidWebView: {
+    Close: "close"
+  },
+  Browser: {
+    Disconnected: "disconnected"
+  },
+  BrowserContext: {
+    Console: "console",
+    Close: "close",
+    Dialog: "dialog",
+    Page: "page",
+    // Can't use just 'error' due to node.js special treatment of error events.
+    // @see https://nodejs.org/api/events.html#events_error_events
+    WebError: "weberror",
+    BackgroundPage: "backgroundpage",
+    ServiceWorker: "serviceworker",
+    Request: "request",
+    Response: "response",
+    RequestFailed: "requestfailed",
+    RequestFinished: "requestfinished"
+  },
+  BrowserServer: {
+    Close: "close"
+  },
+  Page: {
+    Close: "close",
+    Crash: "crash",
+    Console: "console",
+    Dialog: "dialog",
+    Download: "download",
+    FileChooser: "filechooser",
+    DOMContentLoaded: "domcontentloaded",
+    // Can't use just 'error' due to node.js special treatment of error events.
+    // @see https://nodejs.org/api/events.html#events_error_events
+    PageError: "pageerror",
+    Request: "request",
+    Response: "response",
+    RequestFailed: "requestfailed",
+    RequestFinished: "requestfinished",
+    FrameAttached: "frameattached",
+    FrameDetached: "framedetached",
+    FrameNavigated: "framenavigated",
+    Load: "load",
+    Popup: "popup",
+    WebSocket: "websocket",
+    Worker: "worker"
+  },
+  WebSocket: {
+    Close: "close",
+    Error: "socketerror",
+    FrameReceived: "framereceived",
+    FrameSent: "framesent"
+  },
+  Worker: {
+    Close: "close"
+  },
+  ElectronApplication: {
+    Close: "close",
+    Console: "console",
+    Window: "window"
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Events
+});