chore(project-info): archive Bilibili dynamic 9503f2ac8981

MB-X Bilibili Pipeline

7 days ago febaf381f00f1b157ae6d707f57e85018e1b9da7

 dev/project-dev/bili_authenticated_extension/constants.py

@@ -1,17 +1,123 @@
"""Frozen identities and limits for the authenticated ingress."""
"""Generic identities, validators, and limits for authenticated Bilibili jobs."""

from __future__ import annotations

TARGET_BVID = "BV1HA3o6oEJJ"
CANONICAL_URL = "https://www.bilibili.com/video/BV1HA3o6oEJJ"
TARGET_PATH = "/video/BV1HA3o6oEJJ"
EXPECTED_DURATION_MS = 3_133_950
DURATION_TOLERANCE_MS = 3_134
import hashlib
import re

SCHEMA_VERSION = 2
BVID_RE = re.compile(r"BV1[1-9A-HJ-NP-Za-km-z]{9}\Z")
CREATOR_UID_RE = re.compile(r"[1-9][0-9]{0,19}\Z")
JOB_ID_RE = re.compile(r"[0-9a-f]{64}\Z")
MESSAGE_ID_RE = re.compile(r"msg_[0-9]{17}_[0-9a-f]{8}\Z")
HANDOFF_ID_RE = re.compile(r"HANDOFF-[A-Z0-9-]{8,240}\Z")
AUDIT_ID_RE = re.compile(r"DEV-AUDIT-[A-Z0-9-]{8,240}\Z")
ERROR_CODE_RE = re.compile(r"E_[A-Z0-9_]{1,48}\Z")
UPPER_SHA256_RE = re.compile(r"[0-9A-F]{64}\Z")

# Lineage-only marker for an already COMPLETE job whose exact published pair
# still needs the governed formal-manifest and processing-handoff closure.  It
# is never a durable runtime terminal code.
COMPLETION_CLOSURE_REQUIRED = "E_COMPLETION_CLOSURE_REQUIRED"


def validate_bvid(value: object) -> str:
    if not isinstance(value, str) or not BVID_RE.fullmatch(value):
        raise ValueError("invalid BVID")
    return value


def validate_creator_uid(value: object) -> str:
    if not isinstance(value, str) or not CREATOR_UID_RE.fullmatch(value):
        raise ValueError("invalid creator UID")
    return value


def canonical_url(bvid: str) -> str:
    return f"https://www.bilibili.com/video/{validate_bvid(bvid)}"


def target_path(bvid: str) -> str:
    return f"/video/{validate_bvid(bvid)}"


def stable_job_id(creator_uid: str, bvid: str) -> str:
    creator = validate_creator_uid(creator_uid)
    target = validate_bvid(bvid)
    return hashlib.sha256(f"bili-auth-job-v1\0{creator}\0{target}".encode("ascii")).hexdigest()


def stable_successor_job_id(
    creator_uid: str,
    bvid: str,
    predecessor_job_id: str,
    retry_generation: int,
    predecessor_terminal_error_code: str,
    authorization_message_id: str,
    authorization_handoff_id: str,
    authorization_sha256: str,
    repair_review_result_message_id: str,
    repair_audit_id: str,
    repair_audit_bytes: int,
    repair_audit_sha256: str,
) -> str:
    """Derive the exact schema-2 successor identity frozen by V001."""
    creator = validate_creator_uid(creator_uid)
    target = validate_bvid(bvid)
    fields: tuple[tuple[object, re.Pattern[str] | None], ...] = (
        (predecessor_job_id, JOB_ID_RE),
        (retry_generation, None),
        (predecessor_terminal_error_code, ERROR_CODE_RE),
        (authorization_message_id, MESSAGE_ID_RE),
        (authorization_handoff_id, HANDOFF_ID_RE),
        (authorization_sha256, UPPER_SHA256_RE),
        (repair_review_result_message_id, MESSAGE_ID_RE),
        (repair_audit_id, AUDIT_ID_RE),
        (repair_audit_bytes, None),
        (repair_audit_sha256, UPPER_SHA256_RE),
    )
    for value, pattern in fields:
        if pattern is not None and (not isinstance(value, str) or not pattern.fullmatch(value)):
            raise ValueError("invalid successor identity")
    if (
        isinstance(retry_generation, bool) or not isinstance(retry_generation, int)
        or not 1 <= retry_generation <= 1_000_000
        or isinstance(repair_audit_bytes, bool) or not isinstance(repair_audit_bytes, int)
        or repair_audit_bytes <= 0
    ):
        raise ValueError("invalid successor identity")
    payload = "\0".join((
        "bili-auth-job-v2",
        creator,
        target,
        predecessor_job_id,
        str(retry_generation),
        predecessor_terminal_error_code,
        authorization_message_id,
        authorization_handoff_id,
        authorization_sha256,
        repair_review_result_message_id,
        repair_audit_id,
        str(repair_audit_bytes),
        repair_audit_sha256,
    ))
    return hashlib.sha256(payload.encode("ascii")).hexdigest()


def duration_tolerance_ms(expected_duration_ms: int) -> int:
    if isinstance(expected_duration_ms, bool) or not isinstance(expected_duration_ms, int):
        raise ValueError("invalid duration")
    if not 1_000 <= expected_duration_ms <= 86_400_000:
        raise ValueError("invalid duration")
    return max(1_500, min(10_000, (expected_duration_ms + 999) // 1_000))


SCHEMA_VERSION = 3
QUEUE_SCHEMA_VERSION = 1
SUCCESSOR_QUEUE_SCHEMA_VERSION = 2
HOST_NAME = "com.project_info.bili_auth_ingress"
EXTENSION_BUILD = "project-info-bili-auth-ingress/1.0.0+20260805.v002"
HOST_BUILD = "project-info-bili-auth-native-host/1.0.0+20260805.v002"
EXTENSION_BUILD = "project-info-bili-auth-ingress/1.2.25+20260829.generic.v027"
HOST_BUILD = "project-info-bili-auth-native-host/1.2.25+20260829.generic.v027"
RELOAD_GENERATION = "bili-auth-generic-v027"
EXPECTED_EXTENSION_ID = "oidmclckpdmpabbfedplkbdplmfcenbb"
EXPECTED_ORIGIN = f"chrome-extension://{EXPECTED_EXTENSION_ID}/"
PUBLIC_KEY_DER_SHA256 = (
@@ -30,6 +136,267 @@
MAX_OUTPUT_FRAME = 16_384
MAX_COOKIE_COUNT = 128
MAX_SAFE_INTEGER = (1 << 53) - 1
QUEUE_LEASE_SECONDS = 300
MAX_CLAIM_ATTEMPTS = 2
PRESTART_ABORT_CODES = frozenset({
    "E_COOKIE_ACCESS",
})
COOKIE_ACCESS_REASONS = frozenset({
    "COOKIE_API_ERROR",
    "COOKIE_API_SHAPE",
    "COOKIE_AUTH_SET_EMPTY",
    "COOKIE_EQUAL_PRECEDENCE_CONFLICT",
    "COOKIE_RELEVANCE_AMBIGUOUS",
    "COOKIE_SELECTED_INVALID",
    "COOKIE_SELECTION_EXCEPTION",
    "COOKIE_TRANSFER_INVALID",
    "COOKIE_TRANSFER_OVERFLOW",
})
COOKIE_ACCESS_TERMINAL_CODES = {
    reason: f"E_{reason}" for reason in COOKIE_ACCESS_REASONS
}
RUNTIME_DIAGNOSTIC_STATES = frozenset({
    "BRIDGE_EXIT",
    "BRIDGE_FFPROBE",
    "BRIDGE_INVOCATION",
    "BRIDGE_METADATA_BINDING",
    "BRIDGE_OUTPUT_SCHEMA",
    "BRIDGE_SOURCE_STABILITY",
    "CREATE_NEW_PUBLISH",
    "DIMENSIONS_PENDING",
    "DURATION_SHA_VERIFICATION",
    "IDENTITY_PENDING",
    "MAPPING_READBACK",
    "MEDIA_MAPPING_PRESENCE",
    "METADATA_NOT_READY",
    "OWNER_PENDING",
    "PAGE_REJECTED",
    "READY_UNSTABLE",
    "SCRIPT_TIMEOUT",
    "TAB_IDENTITY",
    "VIDEO_ABSENT",
})
RUNTIME_DIAGNOSTIC_REASONS = frozenset({
    "BATCH_RECEIPT_CREATE_FAILED",
    "BRIDGE_REPORTED_PUBLISH_FAILURE",
    "DEADLINE_EXHAUSTED",
    "DURATION_OR_SHA_MISMATCH",
    "MEDIA_OR_MAPPING_MISSING",
    "METADATA_FIELDS_PENDING",
    "INITIAL_STATE_ASSIGNMENT_ABSENT",
    "INITIAL_STATE_JSON_INVALID",
    "INITIAL_STATE_VIDEO_DATA_ABSENT",
    "NONZERO_EXIT",
    "EXPECTED_METADATA_MISMATCH",
    "LOCAL_MEDIA_PROBE_FAILED",
    "OUTPUT_SCHEMA_INVALID",
    "OWNER_ANCHOR_ABSENT",
    "OWNER_ANCHOR_AMBIGUOUS",
    "OWNER_ANCHOR_MISMATCH",
    "PAGE_DRM_REJECTED",
    "PAGE_DURATION_REJECTED",
    "PAGE_ACCESS_REJECTED",
    "PAGE_BVID_REJECTED",
    "PAGE_DOM_IDENTITY_PENDING",
    "PAGE_IDENTITY_REJECTED",
    "PAGE_MULTIPART_REJECTED",
    "PAGE_NAVIGATION_PENDING",
    "PAGE_ORIGIN_REJECTED",
    "PAGE_OWNER_REJECTED",
    "PAGE_SCRIPTING_PENDING",
    "PAGE_TAB_ACTIVATION_PENDING",
    "PAGE_URL_PENDING",
    "PAGE_URL_REJECTED",
    "PAGE_VISIBILITY_PENDING",
    "PAGE_WINDOW_FOCUS_PENDING",
    "PAGE_WINDOW_MINIMIZED_PENDING",
    "PAGE_WINDOW_STATE_PENDING",
    "PERSISTED_MAPPING_INVALID",
    "SOURCE_FILE_INVALID",
    "SCRIPT_INVOCATION_FAILED",
    "STABLE_SNAPSHOTS_PENDING",
    "SUBPROCESS_INVOCATION_FAILED",
    "SUBPROCESS_TIMEOUT",
    "TAB_IDENTITY_DRIFT",
    "VIDEO_DIMENSIONS_PENDING",
    "VIDEO_ELEMENT_ABSENT",
})

PREPARELESS_TERMINAL_DIAGNOSTIC_CONTRACT = {
    "E_DRM": {
        "PAGE_REJECTED": frozenset({"PAGE_DRM_REJECTED"}),
    },
    "E_DURATION": {
        "PAGE_REJECTED": frozenset({"PAGE_DURATION_REJECTED"}),
    },
    "E_MULTI_PART": {
        "PAGE_REJECTED": frozenset({"PAGE_MULTIPART_REJECTED"}),
    },
    "E_OWNER": {
        "PAGE_REJECTED": frozenset({"PAGE_IDENTITY_REJECTED", "PAGE_OWNER_REJECTED"}),
    },
    "E_PAGE_ACCESS_CONTROL": {
        "PAGE_REJECTED": frozenset({"PAGE_ACCESS_REJECTED"}),
    },
    "E_PAGE_DUPLICATE_TAB": {
        "TAB_IDENTITY": frozenset({"TAB_IDENTITY_DRIFT"}),
    },
    "E_PAGE_DIMENSIONS_UNAVAILABLE": {
        "DIMENSIONS_PENDING": frozenset({"VIDEO_DIMENSIONS_PENDING"}),
    },
    "E_PAGE_METADATA_UNAVAILABLE": {
        "METADATA_NOT_READY": frozenset({
            "INITIAL_STATE_ASSIGNMENT_ABSENT",
            "INITIAL_STATE_JSON_INVALID",
            "INITIAL_STATE_VIDEO_DATA_ABSENT",
        }),
    },
    "E_PAGE_IDENTITY_UNAVAILABLE": {
        "IDENTITY_PENDING": frozenset({
            "PAGE_DOM_IDENTITY_PENDING",
            "PAGE_NAVIGATION_PENDING",
            "PAGE_SCRIPTING_PENDING",
            "PAGE_TAB_ACTIVATION_PENDING",
            "PAGE_URL_PENDING",
            "PAGE_VISIBILITY_PENDING",
            "PAGE_WINDOW_FOCUS_PENDING",
            "PAGE_WINDOW_MINIMIZED_PENDING",
            "PAGE_WINDOW_STATE_PENDING",
        }),
    },
    "E_PAGE_OWNER_ANCHOR_UNAVAILABLE": {
        "OWNER_PENDING": frozenset({
            "OWNER_ANCHOR_ABSENT",
            "OWNER_ANCHOR_AMBIGUOUS",
            "OWNER_ANCHOR_MISMATCH",
        }),
    },
    "E_PAGE_PROOF": {
        "PAGE_REJECTED": frozenset({
            "PAGE_BVID_REJECTED",
            "PAGE_IDENTITY_REJECTED",
            "PAGE_ORIGIN_REJECTED",
            "PAGE_URL_REJECTED",
        }),
    },
    "E_PAGE_SCRIPT_TIMEOUT": {
        "SCRIPT_TIMEOUT": frozenset({"SCRIPT_INVOCATION_FAILED"}),
    },
    "E_PAGE_STABILITY_TIMEOUT": {
        "READY_UNSTABLE": frozenset({"STABLE_SNAPSHOTS_PENDING"}),
    },
    "E_PAGE_TAB_DRIFT": {
        "TAB_IDENTITY": frozenset({"TAB_IDENTITY_DRIFT"}),
    },
    "E_PAGE_VIDEO_ABSENT": {
        "VIDEO_ABSENT": frozenset({"VIDEO_ELEMENT_ABSENT"}),
    },
}
PREPARELESS_REJECT_CODES = frozenset(PREPARELESS_TERMINAL_DIAGNOSTIC_CONTRACT)
INTERNAL_ONLY_PAGE_PENDING_CODES = frozenset({"E_PAGE_METADATA_NOT_READY"})

# One bounded compatibility contract for the immutable pre-V017 journal.  The
# legacy code remains forbidden on every live write/wire boundary; only these
# exact raw lines inside the exact governed prefix may be decoded during
# append-only state replay.
LEGACY_PAGE_METADATA_REPLAY_STATE_SUFFIX = (
    "project-info", "bili-auth-generic-runtime", "queue-state.jsonl",
)
LEGACY_PAGE_METADATA_REPLAY_PREFIX_BYTES = 27_899
LEGACY_PAGE_METADATA_REPLAY_PREFIX_SHA256 = (
    "43CB0D7994AC349038026D202DBC85B897E8BF322A3B0EEFD536997FFCBE32DB"
)
LEGACY_PAGE_METADATA_REPLAY_LINES = (
    (68, 307, "4F0AF7297B700E045C66E91812C470335447833A9248898C7A746521D6DB688D"),
    (70, 307, "10B4B3A77CA2F11D5DA2E2A1503006182C9B2EA616E7E265AC504B88329179C8"),
    (75, 415, "C3CA763D02CE4A45E23131759CE4F2B8449885975E0848AABBD0C5D290076C76"),
    (80, 415, "F62B30976883F027D1F9AF4BA883BE7DAA9E055328DB345E73B71CFA98249CE1"),
    (82, 415, "B889763C7B9C65140CA8403B26628A58E8F9BF0FA58FFE7D64637017CF15A2DF"),
    (86, 415, "AE93EDC05478CCC0699ACA31BA957FE9537A067E9409F71FF88768F08561E5BA"),
    (88, 415, "A4D748BEF18B15A75A65DA7F9D88D40772421CEA4041AC604579D40EF822DFC5"),
    (93, 415, "DA83626D0C7D45D29CD55A5556F8214E71C2781D52A91FACCCB695EF37AF11A1"),
)
LEGACY_MISSING_DIAGNOSTIC_REPLAY_LINES = (
    (2, 294, "474B56CD9D57ABCD11F663D1FECE38087CE5CC6F18A4C02837F867548EF42242", "E_PAGE_PROOF"),
    (4, 294, "C9C38D1559A519661E9C00EC2B2C8DD56073F117726CB477343283860D52324F", "E_PAGE_PROOF"),
    (6, 294, "A4DB42C3223611CD14B4EF25F4A028964DBABF93903BA65931398166E1936424", "E_PAGE_PROOF"),
    (14, 294, "F69E2BFF4A2EF51AA614E5C510FE7E9A965B47BCC97ED671E572D62AD2FB875C", "E_PAGE_PROOF"),
    (16, 294, "40D03BF0F736B8207A61DFFAF807E75BDED2F645F8CED9C586B2C5257AD86E43", "E_PAGE_PROOF"),
    (22, 294, "8D07285C1364D147DFD4060CB3B6E6BCADD057D686F64C5BC3D2A7AD097635EE", "E_PAGE_PROOF"),
    (24, 294, "42D3A599A00D37F5C65B2DC86CEFDC2E971C32FFFA163C7C2407D5E0CA95E20D", "E_PAGE_PROOF"),
    (26, 298, "1477BA661C0F060149D6725D2E44D1F1A419714C9350AD266FFDF6344C02EEAF", "E_PAGE_TAB_DRIFT"),
    (30, 298, "DA135304B6F29B4A3937C9DF9C8E6861C179F71675414ED49931EEF461E2890E", "E_PAGE_TAB_DRIFT"),
)


def validate_runtime_diagnostic(value: object) -> dict[str, object]:
    """Validate the only durable, non-secret runtime diagnostic shape."""

    if not isinstance(value, dict) or set(value) != {"attempts", "elapsed_ms", "state", "reason"}:
        raise ValueError("invalid runtime diagnostic")
    attempts = value["attempts"]
    elapsed_ms = value["elapsed_ms"]
    if (
        isinstance(attempts, bool) or not isinstance(attempts, int) or not 0 <= attempts <= 10_000
        or isinstance(elapsed_ms, bool) or not isinstance(elapsed_ms, int)
        or not 0 <= elapsed_ms <= 7_200_000
        or value["state"] not in RUNTIME_DIAGNOSTIC_STATES
        or value["reason"] not in RUNTIME_DIAGNOSTIC_REASONS
    ):
        raise ValueError("invalid runtime diagnostic")
    return value


POSTPROCESS_TERMINAL_DIAGNOSTIC_CONTRACT = {
    "E_BRIDGE_OUTPUT_SCHEMA": {
        "BRIDGE_OUTPUT_SCHEMA": frozenset({"OUTPUT_SCHEMA_INVALID"}),
    },
}


def validate_postprocess_terminal(
    error_code: object, diagnostic: object,
) -> dict[str, object] | None:
    """Validate the canonical diagnostic matrix for a post-media terminal."""

    if not isinstance(error_code, str) or ERROR_CODE_RE.fullmatch(error_code) is None:
        raise ValueError("invalid postprocess terminal")
    if (
        error_code == COMPLETION_CLOSURE_REQUIRED
        or error_code in INTERNAL_ONLY_PAGE_PENDING_CODES
        or error_code in PREPARELESS_REJECT_CODES
    ):
        raise ValueError("invalid postprocess terminal")
    contract = POSTPROCESS_TERMINAL_DIAGNOSTIC_CONTRACT.get(error_code)
    if diagnostic is None:
        if contract is not None:
            raise ValueError("invalid postprocess terminal")
        return None
    if contract is None:
        raise ValueError("invalid postprocess terminal")
    validated = validate_runtime_diagnostic(diagnostic)
    reasons = contract.get(validated["state"])
    if reasons is None or validated["reason"] not in reasons:
        raise ValueError("invalid postprocess terminal")
    return validated


def validate_prepareless_terminal(
    error_code: object, diagnostic: object,
) -> dict[str, object]:
    """Validate one canonical durable pre-secret terminal and its typed diagnostic."""

    if not isinstance(error_code, str):
        raise ValueError("invalid prepareless terminal")
    contract = PREPARELESS_TERMINAL_DIAGNOSTIC_CONTRACT.get(error_code)
    if contract is None:
        raise ValueError("invalid prepareless terminal")
    validated = validate_runtime_diagnostic(diagnostic)
    allowed_reasons = contract.get(validated["state"])
    if allowed_reasons is None or validated["reason"] not in allowed_reasons:
        raise ValueError("invalid prepareless terminal")
    return validated
RELOAD_BACKOFF_SECONDS = 3_600

SOCKET_TIMEOUT_SECONDS = 20
EXTRACTOR_RETRIES = 1
@@ -70,14 +437,7 @@
}

SAFE_PHASES = {
    "IDLE",
    "READY",
    "CHECKING",
    "DOWNLOADING",
    "MERGING",
    "VALIDATING",
    "PUBLISHING",
    "COMPLETE",
    "FAILED",
    "CANCELED",
    "IDLE", "READY", "CHECKING", "DOWNLOADING", "MERGING", "VALIDATING",
    "PUBLISHING", "MEDIA_COMPLETE", "POSTPROCESS_PENDING", "POSTPROCESS_FAILED",
    "COMPLETE", "FAILED", "CANCELED", "RELOAD_REQUIRED",
}