pywebview-htmx 0.3.0__tar.gz → 0.3.1__tar.gz

{pywebview_htmx-0.3.0 → pywebview_htmx-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pywebview-htmx
-Version: 0.3.0
+Version: 0.3.1
 Summary: HTMX-style declarative UI bindings for PyWebview apps
 Author-Email: "B.T. Franklin" <brandon.franklin@gmail.com>
 License: MIT License
@@ -35,7 +35,7 @@ Classifier: Intended Audience :: Developers
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Internet :: WWW/HTTP
 Requires-Python: >=3.14
-Requires-Dist: pywebview>=6.1
+Requires-Dist: pywebview>=6.2.1
 Description-Content-Type: text/markdown
 
 # pywebview-htmx
@@ -84,6 +84,11 @@ pdm install
 pdm add pywebview-htmx
 ```
 
+## Maintainer Docs
+
+For maintainer and agent-facing repository guidance, see
+[`docs/index.md`](docs/index.md).
+
 ## Agent Skill
 
 This repository includes an installable coding-agent skill at
@@ -255,7 +260,7 @@ Unknown value falls back to `innerHTML`.
 ### `py-wait` (optional)
 
 CSS selector of element receiving `.py-waiting` while request is in flight.
-If missing/empty/unresolvable, the triggering element is used.
+If missing, empty, invalid, or unresolvable, the triggering element is used.
 
 ### `py-policy` (optional)
 
@@ -302,17 +307,21 @@ document.body.addEventListener("py:error", (event) => {
 
 ## Concurrency Behavior
 
-Per trigger element, `pywebview-htmx` tracks request state.
+`pywebview-htmx` tracks request state by resolved target. Controls that share
+the same `py-target` coordinate request ordering and `drop` behavior. Controls
+without `py-target` use the triggering element as their request state scope.
+Loading state is counted separately per resolved `py-wait` target so shared
+spinners stay active until all in-flight requests finish.
 
 ### `latest-wins` (default)
 
-Multiple rapid requests are allowed; stale responses are ignored.
-Only latest request updates the DOM.
+Multiple rapid requests are allowed; stale responses in the same request state
+scope are ignored. Only the latest request for that scope updates the DOM.
 
 ### `drop`
 
-If a request is already in flight for that element, new triggers are ignored and
-`py:ignored` is emitted.
+If a request is already in flight for the same request state scope, new triggers
+are ignored and `py:ignored` is emitted.
 
 ## Dynamic Content Re-processing
 

{pywebview_htmx-0.3.0 → pywebview_htmx-0.3.1}/README.md

@@ -44,6 +44,11 @@ pdm install
 pdm add pywebview-htmx
 ```
 
+## Maintainer Docs
+
+For maintainer and agent-facing repository guidance, see
+[`docs/index.md`](docs/index.md).
+
 ## Agent Skill
 
 This repository includes an installable coding-agent skill at
@@ -215,7 +220,7 @@ Unknown value falls back to `innerHTML`.
 ### `py-wait` (optional)
 
 CSS selector of element receiving `.py-waiting` while request is in flight.
-If missing/empty/unresolvable, the triggering element is used.
+If missing, empty, invalid, or unresolvable, the triggering element is used.
 
 ### `py-policy` (optional)
 
@@ -262,17 +267,21 @@ document.body.addEventListener("py:error", (event) => {
 
 ## Concurrency Behavior
 
-Per trigger element, `pywebview-htmx` tracks request state.
+`pywebview-htmx` tracks request state by resolved target. Controls that share
+the same `py-target` coordinate request ordering and `drop` behavior. Controls
+without `py-target` use the triggering element as their request state scope.
+Loading state is counted separately per resolved `py-wait` target so shared
+spinners stay active until all in-flight requests finish.
 
 ### `latest-wins` (default)
 
-Multiple rapid requests are allowed; stale responses are ignored.
-Only latest request updates the DOM.
+Multiple rapid requests are allowed; stale responses in the same request state
+scope are ignored. Only the latest request for that scope updates the DOM.
 
 ### `drop`
 
-If a request is already in flight for that element, new triggers are ignored and
-`py:ignored` is emitted.
+If a request is already in flight for the same request state scope, new triggers
+are ignored and `py:ignored` is emitted.
 
 ## Dynamic Content Re-processing
 

{pywebview_htmx-0.3.0 → pywebview_htmx-0.3.1}/pyproject.toml

@@ -6,7 +6,7 @@ authors = [
     { name = "B.T. Franklin", email = "brandon.franklin@gmail.com" },
 ]
 dependencies = [
-    "pywebview>=6.1",
+    "pywebview>=6.2.1",
 ]
 requires-python = ">=3.14"
 readme = "README.md"
@@ -21,14 +21,14 @@ classifiers = [
     "Topic :: Software Development :: Libraries :: Python Modules",
     "Topic :: Internet :: WWW/HTTP",
 ]
-version = "0.3.0"
+version = "0.3.1"
 
 [project.license]
 file = "LICENSE"
 
 [build-system]
 requires = [
-    "pdm-backend",
+    "pdm-backend>=2.4.9",
 ]
 build-backend = "pdm.backend"
 
@@ -65,6 +65,6 @@ select = [
 
 [dependency-groups]
 dev = [
-    "pytest>=9.0.2",
-    "ruff>=0.15.4",
+    "pytest>=9.0.3",
+    "ruff>=0.15.17",
 ]

pywebview_htmx-0.3.1/src/pywebview_htmx/py.typed

@@ -0,0 +1 @@
+

{pywebview_htmx-0.3.0 → pywebview_htmx-0.3.1}/src/pywebview_htmx/static/runtime.js

@@ -8,10 +8,16 @@
     requestPolicy: "latest-wins",
   };
   const requestState = new WeakMap();
+  const waitState = new WeakMap();
 
   function $(selector, root = document) {
     if (!selector) return null;
-    return root.querySelector(selector);
+    try {
+      return root.querySelector(selector);
+    } catch (error) {
+      console.warn("PyWebview HTMX: invalid selector", selector, error);
+      return null;
+    }
   }
 
   function triggerEvent(target, eventName, detail = {}) {
@@ -126,15 +132,38 @@
     return await func(params);
   }
 
-  function getRequestState(element) {
-    let state = requestState.get(element);
+  function getRequestState(key) {
+    let state = requestState.get(key);
     if (!state) {
       state = { lastIssued: 0, inFlightCount: 0 };
-      requestState.set(element, state);
+      requestState.set(key, state);
     }
     return state;
   }
 
+  function getRequestStateKey(element, targetSelector) {
+    if (!targetSelector) {
+      return element;
+    }
+    return $(targetSelector) || element;
+  }
+
+  function addWaiting(waitTarget) {
+    const count = (waitState.get(waitTarget) || 0) + 1;
+    waitState.set(waitTarget, count);
+    waitTarget.classList.add("py-waiting");
+  }
+
+  function removeWaiting(waitTarget) {
+    const count = Math.max(0, (waitState.get(waitTarget) || 0) - 1);
+    if (count === 0) {
+      waitState.delete(waitTarget);
+      waitTarget.classList.remove("py-waiting");
+      return;
+    }
+    waitState.set(waitTarget, count);
+  }
+
   function shouldPreventDefault(eventName) {
     return eventName === "submit";
   }
@@ -181,7 +210,7 @@
         }
 
         const params = buildRequestParams(element, eventName, event);
-        const state = getRequestState(element);
+        const state = getRequestState(getRequestStateKey(element, targetSelector));
         const requestPolicy = getRequestPolicy(element);
         if (requestPolicy === "drop" && state.inFlightCount > 0) {
           triggerEvent(element, "py:ignored", { reason: "in-flight" });
@@ -198,7 +227,7 @@
           requestId,
         });
 
-        waitTarget.classList.add("py-waiting");
+        addWaiting(waitTarget);
 
         try {
           const response = await invokePython(functionName, params);
@@ -239,9 +268,7 @@
           triggerEvent(element, "py:error", { error, requestId });
         } finally {
           state.inFlightCount = Math.max(0, state.inFlightCount - 1);
-          if (state.inFlightCount === 0) {
-            waitTarget.classList.remove("py-waiting");
-          }
+          removeWaiting(waitTarget);
         }
       });
     });

pywebview_htmx-0.3.1/tests/js_runtime_behavior_harness.mjs

@@ -0,0 +1,369 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import vm from "node:vm";
+
+class DomEvent {
+  constructor(type, options = {}) {
+    this.type = type;
+    this.bubbles = Boolean(options.bubbles);
+    this.cancelable = Boolean(options.cancelable);
+    this.detail = options.detail || {};
+    this.defaultPrevented = false;
+    this.target = null;
+    this.currentTarget = null;
+  }
+
+  preventDefault() {
+    if (this.cancelable) {
+      this.defaultPrevented = true;
+    }
+  }
+}
+
+class DomCustomEvent extends DomEvent {}
+
+class ClassList {
+  constructor() {
+    this.tokens = new Set();
+  }
+
+  add(...tokens) {
+    tokens.forEach((token) => this.tokens.add(token));
+  }
+
+  remove(...tokens) {
+    tokens.forEach((token) => this.tokens.delete(token));
+  }
+
+  contains(token) {
+    return this.tokens.has(token);
+  }
+}
+
+class Element {
+  constructor(tagName, ownerDocument) {
+    this.tagName = tagName.toUpperCase();
+    this.ownerDocument = ownerDocument;
+    this.parentElement = null;
+    this.children = [];
+    this.attributes = new Map();
+    this.classList = new ClassList();
+    this.listeners = new Map();
+    this._innerHTML = "";
+    this.id = "";
+  }
+
+  append(...children) {
+    children.forEach((child) => {
+      child.parentElement = this;
+      child.ownerDocument = this.ownerDocument;
+      this.children.push(child);
+    });
+  }
+
+  setAttribute(name, value) {
+    const stringValue = String(value);
+    this.attributes.set(name, stringValue);
+    if (name === "id") {
+      this.id = stringValue;
+    }
+  }
+
+  getAttribute(name) {
+    return this.attributes.has(name) ? this.attributes.get(name) : null;
+  }
+
+  hasAttribute(name) {
+    return this.attributes.has(name);
+  }
+
+  matches(selector) {
+    return this.ownerDocument.matchesSelector(this, selector);
+  }
+
+  querySelector(selector) {
+    return this.ownerDocument.querySelectorFrom(selector, this);
+  }
+
+  querySelectorAll(selector) {
+    return this.ownerDocument.querySelectorAllFrom(selector, this);
+  }
+
+  addEventListener(type, listener) {
+    const listeners = this.listeners.get(type) || [];
+    listeners.push(listener);
+    this.listeners.set(type, listeners);
+  }
+
+  dispatchEvent(event) {
+    if (!event.target) {
+      event.target = this;
+    }
+    event.currentTarget = this;
+
+    for (const listener of this.listeners.get(event.type) || []) {
+      listener.call(this, event);
+    }
+
+    if (event.bubbles && this.parentElement) {
+      this.parentElement.dispatchEvent(event);
+    }
+    return !event.defaultPrevented;
+  }
+
+  set innerHTML(value) {
+    this._innerHTML = String(value);
+    this.children = [];
+  }
+
+  get innerHTML() {
+    return this._innerHTML;
+  }
+
+  set outerHTML(value) {
+    if (!this.parentElement) {
+      this.innerHTML = value;
+      return;
+    }
+
+    const replacement = this.ownerDocument.createElement("div");
+    replacement.innerHTML = value;
+    const index = this.parentElement.children.indexOf(this);
+    this.parentElement.children.splice(index, 1, replacement);
+    replacement.parentElement = this.parentElement;
+  }
+
+  insertAdjacentHTML(position, value) {
+    assert.equal(position, "beforeend");
+    this._innerHTML += String(value);
+  }
+}
+
+class Document {
+  constructor() {
+    this.listeners = new Map();
+    this.body = new Element("body", this);
+  }
+
+  createElement(tagName) {
+    return new Element(tagName, this);
+  }
+
+  addEventListener(type, listener) {
+    const listeners = this.listeners.get(type) || [];
+    listeners.push(listener);
+    this.listeners.set(type, listeners);
+  }
+
+  querySelector(selector) {
+    return this.querySelectorFrom(selector, this.body);
+  }
+
+  querySelectorAll(selector) {
+    return this.querySelectorAllFrom(selector, this.body);
+  }
+
+  querySelectorFrom(selector, root) {
+    return this.querySelectorAllFrom(selector, root)[0] || null;
+  }
+
+  querySelectorAllFrom(selector, root) {
+    this.validateSelector(selector);
+    const matches = [];
+
+    const visit = (node) => {
+      for (const child of node.children) {
+        if (this.matchesSelector(child, selector)) {
+          matches.push(child);
+        }
+        visit(child);
+      }
+    };
+
+    visit(root);
+    return matches;
+  }
+
+  matchesSelector(element, selector) {
+    this.validateSelector(selector);
+    if (selector === "[py-call]") {
+      return element.hasAttribute("py-call");
+    }
+    if (selector.startsWith("#")) {
+      return element.id === selector.slice(1);
+    }
+    throw new SyntaxError(`Unsupported selector in test harness: ${selector}`);
+  }
+
+  validateSelector(selector) {
+    if (!selector || selector === "[" || selector.includes("###")) {
+      throw new SyntaxError(`Invalid selector: ${selector}`);
+    }
+  }
+}
+
+function makeElement(document, tagName, attributes = {}) {
+  const element = document.createElement(tagName);
+  for (const [name, value] of Object.entries(attributes)) {
+    element.setAttribute(name, value);
+  }
+  return element;
+}
+
+function createHarness(runtimeSource) {
+  const document = new Document();
+  const warnings = [];
+  const context = {
+    clearTimeout,
+    console: {
+      ...console,
+      warn: (...args) => warnings.push(args.map(String).join(" ")),
+    },
+    CustomEvent: DomCustomEvent,
+    document,
+    Promise,
+    setTimeout,
+  };
+  context.window = context;
+  context.globalThis = context;
+
+  vm.createContext(context);
+  vm.runInContext(runtimeSource, context);
+
+  context.pywebviewHtmx.config.settleDelay = 0;
+  context.pywebviewHtmx.config.swapDelay = 0;
+
+  return { document, warnings, window: context };
+}
+
+async function flushAsyncWork() {
+  await Promise.resolve();
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  await Promise.resolve();
+}
+
+function click(element) {
+  element.dispatchEvent(new DomEvent("click", { bubbles: true, cancelable: true }));
+}
+
+async function testInvalidWaitSelectorFallsBackAndDoesNotAbort(runtimeSource) {
+  const { document, warnings, window } = createHarness(runtimeSource);
+  const result = makeElement(document, "div", { id: "result" });
+  const badWait = makeElement(document, "button", {
+    "py-call": "load",
+    "py-target": "#result",
+    "py-wait": "[",
+  });
+  const laterButton = makeElement(document, "button", { "py-call": "later" });
+  document.body.append(badWait, result, laterButton);
+
+  let resolveLoad;
+  window.pywebview = {
+    api: {
+      load: () => new Promise((resolve) => {
+        resolveLoad = resolve;
+      }),
+      later: () => "<p>later</p>",
+    },
+  };
+
+  window.pywebviewHtmx.process(document.body);
+  assert.equal(badWait.getAttribute("data-pywebview-bound"), "true");
+  assert.equal(laterButton.getAttribute("data-pywebview-bound"), "true");
+  assert.ok(warnings.some((warning) => warning.includes("invalid selector")));
+
+  click(badWait);
+  assert.equal(badWait.classList.contains("py-waiting"), true);
+
+  resolveLoad("<p>loaded</p>");
+  await flushAsyncWork();
+
+  assert.equal(result.innerHTML, "<p>loaded</p>");
+  assert.equal(badWait.classList.contains("py-waiting"), false);
+}
+
+async function testLatestWinsIsSharedByTarget(runtimeSource) {
+  const { document, window } = createHarness(runtimeSource);
+  const result = makeElement(document, "div", { id: "race-result" });
+  const wait = makeElement(document, "span", { id: "race-status" });
+  const slow = makeElement(document, "button", {
+    "py-call": "long_task",
+    "py-target": "#race-result",
+    "py-wait": "#race-status",
+  });
+  const fast = makeElement(document, "button", {
+    "py-call": "long_task",
+    "py-target": "#race-result",
+    "py-wait": "#race-status",
+  });
+  document.body.append(slow, fast, wait, result);
+
+  const requests = [];
+  window.pywebview = {
+    api: {
+      long_task: () => new Promise((resolve) => {
+        requests.push(resolve);
+      }),
+    },
+  };
+
+  window.pywebviewHtmx.process(document.body);
+  click(slow);
+  click(fast);
+
+  assert.equal(requests.length, 2);
+  assert.equal(wait.classList.contains("py-waiting"), true);
+
+  requests[1]("<p>fast</p>");
+  await flushAsyncWork();
+
+  assert.equal(result.innerHTML, "<p>fast</p>");
+  assert.equal(wait.classList.contains("py-waiting"), true);
+
+  requests[0]("<p>slow</p>");
+  await flushAsyncWork();
+
+  assert.equal(result.innerHTML, "<p>fast</p>");
+  assert.equal(wait.classList.contains("py-waiting"), false);
+}
+
+async function testDropPolicyIsSharedByTarget(runtimeSource) {
+  const { document, window } = createHarness(runtimeSource);
+  const result = makeElement(document, "div", { id: "drop-result" });
+  const first = makeElement(document, "button", {
+    "py-call": "long_task",
+    "py-policy": "drop",
+    "py-target": "#drop-result",
+  });
+  const second = makeElement(document, "button", {
+    "py-call": "long_task",
+    "py-policy": "drop",
+    "py-target": "#drop-result",
+  });
+  document.body.append(first, second, result);
+
+  const requests = [];
+  window.pywebview = {
+    api: {
+      long_task: () => new Promise((resolve) => {
+        requests.push(resolve);
+      }),
+    },
+  };
+
+  window.pywebviewHtmx.process(document.body);
+  click(first);
+  click(second);
+
+  assert.equal(requests.length, 1);
+  requests[0]("<p>first</p>");
+  await flushAsyncWork();
+  assert.equal(result.innerHTML, "<p>first</p>");
+}
+
+const runtimePath = process.argv[2];
+const runtimeSource = fs.readFileSync(runtimePath, "utf8");
+
+await testInvalidWaitSelectorFallsBackAndDoesNotAbort(runtimeSource);
+await testLatestWinsIsSharedByTarget(runtimeSource);
+await testDropPolicyIsSharedByTarget(runtimeSource);

{pywebview_htmx-0.3.0 → pywebview_htmx-0.3.1}/tests/test_js_contract_request_and_swap.py

@@ -20,12 +20,25 @@ JS_BEHAVIOR_FRAGMENTS: list[tuple[int, tuple[str, ...]]] = [
             "event.preventDefault();",
         ),
     ),
-    (74, ("let state = requestState.get(element);", "if (!state) {")),
+    (
+        74,
+        (
+            "function getRequestState(key)",
+            "let state = requestState.get(key);",
+            "requestState.set(key, state);",
+        ),
+    ),
     (75, ("lastIssued: 0", "state.lastIssued = requestId;")),
     (76, ("inFlightCount: 0", "state.inFlightCount += 1;")),
     (77, ('requestPolicy === "drop"', 'triggerEvent(element, "py:ignored"')),
     (78, ('triggerEvent(element, "py:trigger"', "requestId,")),
-    (79, ('waitTarget.classList.add("py-waiting")',)),
+    (
+        79,
+        (
+            "function addWaiting(waitTarget)",
+            'waitTarget.classList.add("py-waiting")',
+        ),
+    ),
     (80, ("if (requestId !== state.lastIssued) { return; }",)),
     (81, ("const target = targetSelector ? $(targetSelector) : element;",)),
     (82, (" : element;",)),
@@ -50,7 +63,7 @@ JS_BEHAVIOR_FRAGMENTS: list[tuple[int, tuple[str, ...]]] = [
     (
         94,
         (
-            "if (state.inFlightCount === 0)",
+            "function removeWaiting(waitTarget)",
             'waitTarget.classList.remove("py-waiting")',
         ),
     ),

pywebview_htmx-0.3.1/tests/test_js_runtime_behavior.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+import shutil
+import subprocess
+from pathlib import Path
+
+import pytest
+
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+HARNESS = REPO_ROOT / "tests/js_runtime_behavior_harness.mjs"
+RUNTIME = REPO_ROOT / "src/pywebview_htmx/static/runtime.js"
+
+
+def test_runtime_behaviors_execute_in_dom_harness() -> None:
+    node = shutil.which("node")
+    if node is None:
+        pytest.skip("Node.js is required for JavaScript runtime behavior tests")
+
+    result = subprocess.run(
+        [node, str(HARNESS), str(RUNTIME)],
+        capture_output=True,
+        check=False,
+        text=True,
+    )
+
+    assert result.returncode == 0, result.stdout + result.stderr

pywebview_htmx-0.3.1/tests/test_repo_legibility.py

@@ -0,0 +1,125 @@
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+REQUIRED_DOCS = [
+    "AGENTS.md",
+    "docs/index.md",
+    "docs/architecture.md",
+    "docs/development.md",
+    "docs/releasing.md",
+]
+AGENT_REQUIRED_ROUTES = [
+    "README.md",
+    "docs/index.md",
+    "src/pywebview_htmx/runtime.py",
+    "src/pywebview_htmx/static/runtime.js",
+    "app.py",
+    "pyproject.toml",
+    "docs/releasing.md",
+    "tests/",
+    "skills/use-pywebview-htmx/",
+]
+LOCAL_MARKDOWN_LINK_RE = re.compile(r"(?<!!)\[[^\]]+\]\(([^)]+)\)")
+
+
+def _read_repo_file(path: str) -> str:
+    return (REPO_ROOT / path).read_text(encoding="utf-8")
+
+
+def _iter_local_links(markdown_path: Path) -> list[str]:
+    links: list[str] = []
+    for raw_link in LOCAL_MARKDOWN_LINK_RE.findall(
+        markdown_path.read_text(encoding="utf-8"),
+    ):
+        target = raw_link.split("#", 1)[0].strip()
+        if not target or re.match(r"^[a-z][a-z0-9+.-]*:", target):
+            continue
+        links.append(target)
+    return links
+
+
+def test_required_agent_legibility_docs_exist() -> None:
+    missing = [path for path in REQUIRED_DOCS if not (REPO_ROOT / path).exists()]
+    assert not missing, f"Missing agent-legibility docs: {missing}"
+
+
+def test_new_docs_have_resolvable_local_markdown_links() -> None:
+    checked_paths = [REPO_ROOT / path for path in REQUIRED_DOCS]
+    broken_links: list[str] = []
+
+    for markdown_path in checked_paths:
+        for target in _iter_local_links(markdown_path):
+            resolved = (markdown_path.parent / target).resolve()
+            link_description = f"{markdown_path.relative_to(REPO_ROOT)} -> {target}"
+            try:
+                resolved.relative_to(REPO_ROOT)
+            except ValueError:
+                broken_links.append(link_description)
+                continue
+            if not resolved.exists():
+                broken_links.append(link_description)
+
+    assert not broken_links, f"Broken local Markdown links: {broken_links}"
+
+
+def test_agents_md_routes_to_core_repo_surfaces() -> None:
+    agents_md = _read_repo_file("AGENTS.md")
+    missing_routes = [
+        route for route in AGENT_REQUIRED_ROUTES if route not in agents_md
+    ]
+    assert not missing_routes, f"AGENTS.md is missing route(s): {missing_routes}"
+
+
+def test_development_guidance_captures_package_policy() -> None:
+    combined_guidance = "\n".join(
+        _read_repo_file(path) for path in ("AGENTS.md", "docs/development.md")
+    ).lower()
+
+    required_fragments = [
+        "pdm install",
+        "pdm run lint",
+        "pdm run test",
+        "pdm run python app.py",
+        "do not use pip to add",
+        ">=",
+        "latest version",
+    ]
+    missing_fragments = [
+        fragment for fragment in required_fragments if fragment not in combined_guidance
+    ]
+    assert not missing_fragments, (
+        "Development guidance is missing durable instruction(s): "
+        f"{missing_fragments}"
+    )
+
+
+def test_release_guidance_captures_tag_first_release_notes_flow() -> None:
+    release_guidance = _read_repo_file("docs/releasing.md")
+
+    required_fragments = [
+        "release-notes-scribe",
+        "Draft Release Notes",
+        "git tag",
+        "git push origin",
+        ".github/workflows/draft-release-notes.yml",
+        ".github/workflows/python-publish.yml",
+        "PyPI",
+    ]
+    missing_fragments = [
+        fragment for fragment in required_fragments if fragment not in release_guidance
+    ]
+
+    assert not missing_fragments, (
+        "Release guidance must preserve the tag-first release notes process. "
+        f"Missing: {missing_fragments}"
+    )
+
+
+def test_typed_classifier_has_pep_561_marker() -> None:
+    pyproject = _read_repo_file("pyproject.toml")
+    assert "Typing :: Typed" in pyproject
+    assert (REPO_ROOT / "src/pywebview_htmx/py.typed").is_file()