awrtifact 0.2.0__tar.gz → 0.2.2__tar.gz

{awrtifact-0.2.0 → awrtifact-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: awrtifact
-Version: 0.2.0
+Version: 0.2.2
 Summary: Aither World Artifact — deliberately chunk artifacts into GitHub release assets and fetch them back byte-verified. The productized aitherkvcache mirror lane.
 License: Apache-2.0
 Project-URL: Homepage, https://github.com/Aitherium/awrtifact

{awrtifact-0.2.0 → awrtifact-0.2.2}/awrtifact/__init__.py

@@ -9,4 +9,4 @@ fetched back byte-verified.
 The core is stdlib-only; the spec-shaped commands need PyYAML (extra: `spec`).
 """
 
-__version__ = "0.2.0"
+__version__ = "0.2.2"

{awrtifact-0.2.0 → awrtifact-0.2.2}/awrtifact/data/workflows/mirror-to-release.yml

@@ -132,7 +132,7 @@ jobs:
           gh release upload "$RELEASE" "$PART_FILE" --repo "$GITHUB_REPOSITORY" --clobber
           echo "uploaded $PART_FILE ($SIZE bytes)"
 
-          # The release-manifest contract (D-2261): every release carries its
+          # The release-manifest contract: every release carries its
           # own <name>.manifest.json. The manifest job needs this part's hash —
           # ship it as a tiny artifact rather than re-downloading the part. The
           # inner filename is UNIQUE per row: merge-multiple with a shared

{awrtifact-0.2.0 → awrtifact-0.2.2}/awrtifact/worker_template.py

@@ -124,20 +124,12 @@ async function serveChunked(request, spec, name) {
         if (partStart > end) break;
         const subStart = Math.max(0, start - partStart);
         const subEnd = Math.min(part.size - 1, end - partStart);
-        const upstreamResp = await fetch(spec.upstream + part.name, {
-          headers: { Range: `bytes=${subStart}-${subEnd}` },
-          redirect: 'follow',
-        });
-        if (upstreamResp.status !== 206 && upstreamResp.status !== 200) {
-          throw new Error(`upstream ${part.name} -> ${upstreamResp.status}`);
-        }
-        const reader = upstreamResp.body.getReader();
-        // eslint-disable-next-line no-constant-condition
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) break;
-          await writer.write(value);
-        }
+        await streamUpstream(
+          spec.upstream + part.name,
+          { Range: `bytes=${subStart}-${subEnd}` },
+          writer,
+          part.name,
+        );
         partStart += part.size;
       }
       await writer.close();
@@ -148,6 +140,64 @@ async function serveChunked(request, spec, name) {
   return new Response(readable, { status, headers });
 }
 
+// Stream one upstream body into the writer, RETRYING an EMPTY body. A
+// Cloudflare→GitHub fetch can return a valid status with ZERO bytes
+// (measured 2026-08-28: 206/0 at a part seam — the client then sees
+// Content-Length promise a full range and receive nothing, which its
+// truncation check reads as corruption; the AW002 seam gate caught it as
+// 'does not stitch'). Streaming-safe: only the FIRST chunk is awaited to
+// decide, so large bodies are never buffered.
+async function streamUpstream(url, headers, writer, what) {
+  for (let attempt = 1; attempt <= 5; attempt++) {
+    const resp = await fetch(url, { headers, redirect: 'follow' });
+    if (resp.status === 429 || resp.status >= 500) {
+      // TRANSIENT upstream state (GitHub rate-limits the shared egress IP —
+      // measured 2026-08-28: a burst of fresh-fetch probes tripped it, and
+      // throwing here killed the stream into a 206/0 to the client). Retry,
+      // never fail the stream on a 429/5xx.
+      continue;
+    }
+    if (resp.status !== 206 && resp.status !== 200) {
+      throw new Error(`upstream ${what} -> ${resp.status}`);
+    }
+    const reader = resp.body.getReader();
+    let first;
+    try {
+      first = await reader.read();
+    } catch (_e) {
+      // The connection died between the response headers and the first body
+      // chunk — measured 2026-09-01 at ~40% of cold Cloudflare->GitHub
+      // fetches of the 90MB part, and the deployed empty-chunk retry did NOT
+      // move the client-visible rate (3/10 pre -> 4/10 post): the read
+      // THROWS here, it does not return empty, so no retry loop ever saw it.
+      // Uncaught, it aborts the writer AFTER the 206 status was sent — the
+      // client-visible 206/0. Same treatment as an empty body: back off and
+      // retry the fetch.
+      await new Promise((r) => setTimeout(r, 500));
+      continue;
+    }
+    if (!first.value) {
+      // 0-length FIRST chunk — cold upstream connections (Cloudflare -> GitHub)
+      // can deliver valid 206/200 headers with an empty body, and the first
+      // chunk is NOT always final (measured 2026-09-01: ~30-40% of cold first
+      // fetches). Cancel the reader so the connection drains, back off, and
+      // retry the fetch.
+      await reader.cancel();
+      await new Promise((r) => setTimeout(r, 500));
+      continue;
+    }
+    await writer.write(first.value);
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      await writer.write(value);
+    }
+    return;
+  }
+  throw new Error(`upstream ${what} failed after 5 attempts`);
+}
+
 /**
  * R2 first. Everything below is unchanged and stays as the fallback.
  *
@@ -241,21 +291,71 @@ export default {
     // R2 before everything, INCLUDING the chunked path: an object uploaded whole
     // to R2 makes its `.partN` manifest irrelevant, and checking after would keep
     // serving the stitched copy of a file that no longer needs stitching.
-    const fromR2 = await serveFromR2(request, env, name);
+    // A PREFIXED request names one release, so a same-named object from another
+    // release must not answer it. Measured 2026-09-03: /microembedder-v2/config.json
+    // served microembedder-v1's 650-byte config (and its 22,972,370-byte ONNX) because
+    // R2 and the chunked map are keyed by bare name and were consulted BEFORE the
+    // prefix. R2 is skipped for prefixed paths (its keys carry no release); chunked
+    // entries answer only when their upstream IS the requested release.
+    const fromR2 = baseOverride ? null : await serveFromR2(request, env, name);
     if (fromR2) return fromR2;
     // Virtual chunked asset (>2 GiB source, split at upload).
-    if (CHUNKED[name]) return serveChunked(request, CHUNKED[name], name);
+    if (CHUNKED[name] && (!baseOverride || CHUNKED[name].upstream === baseOverride)) {
+      return serveChunked(request, CHUNKED[name], name);
+    }
     // Try each upstream until one has the file. A GitHub release 404s fast for a
     // missing asset, so the fallback cost is one small miss per unknown name.
     // A prefixed path has exactly ONE candidate (its own release).
     const candidates = baseOverride ? [baseOverride] : UPSTREAMS;
     for (const base of candidates) {
-      const upstream = await fetch(base + name, {
-        method: request.method === 'HEAD' ? 'HEAD' : 'GET',
-        headers: request.headers.has('Range') ? { Range: request.headers.get('Range') } : {},
-        redirect: 'follow',
-      });
-      if (upstream.status !== 404 && upstream.status !== 410) {
+      if (request.method === 'HEAD') {
+        const upstream = await fetch(base + name, { method: 'HEAD', redirect: 'follow' });
+        if (upstream.status === 404 || upstream.status === 410) continue;
+        const headers = new Headers(upstream.headers);
+        for (const [k, v] of Object.entries(cors)) headers.set(k, v);
+        headers.set('Cache-Control', 'public, max-age=31536000, immutable');
+        headers.set('Content-Type', contentTypeFor(name));
+        return new Response(null, { status: upstream.status, headers });
+      }
+      // GET with retry on an EMPTY body (the 206/0 class, measured 2026-08-28).
+      // Streaming-safe: only the first chunk is awaited to decide.
+      for (let attempt = 1; attempt <= 3; attempt++) {
+        const upstream = await fetch(base + name, {
+          method: 'GET',
+          headers: request.headers.has('Range') ? { Range: request.headers.get('Range') } : {},
+          redirect: 'follow',
+        });
+        if (upstream.status === 404 || upstream.status === 410) break; // next upstream
+        if (upstream.status === 429 || upstream.status >= 500) {
+          // transient (rate limit) — retry, never serve the error as bytes
+          continue;
+        }
+        const reader = upstream.body.getReader();
+        let first;
+        try {
+          first = await reader.read();
+        } catch (_e) {
+          // The connection died between headers and the first chunk — the
+          // same class as streamUpstream (measured 2026-09-01 at ~40% of cold
+          // Cloudflare->GitHub fetches); a throw here is NOT the empty-body
+          // check below, and uncaught it aborts the response after the status
+          // was sent. Back off and retry the fetch.
+          await new Promise((r) => setTimeout(r, 500));
+          continue;
+        }
+        if (!first.value) continue; // empty first chunk (0-length or done) — retry
+        const body = new ReadableStream({
+          async start(controller) {
+            if (first.value) controller.enqueue(first.value);
+            // eslint-disable-next-line no-constant-condition
+            while (true) {
+              const { done, value } = await reader.read();
+              if (done) break;
+              controller.enqueue(value);
+            }
+            controller.close();
+          },
+        });
         const headers = new Headers(upstream.headers);
         for (const [k, v] of Object.entries(cors)) headers.set(k, v);
         headers.set('Cache-Control', 'public, max-age=31536000, immutable');
@@ -263,7 +363,7 @@ export default {
         // `import()` refuses that MIME (measured 2026-08-26). The upstream
         // headers are copied for Content-Length/Range, but the TYPE is always ours.
         headers.set('Content-Type', contentTypeFor(name));
-        return new Response(upstream.body, { status: upstream.status, headers });
+        return new Response(body, { status: upstream.status, headers });
       }
     }
     const headers = new Headers(cors);

{awrtifact-0.2.0 → awrtifact-0.2.2}/awrtifact.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: awrtifact
-Version: 0.2.0
+Version: 0.2.2
 Summary: Aither World Artifact — deliberately chunk artifacts into GitHub release assets and fetch them back byte-verified. The productized aitherkvcache mirror lane.
 License: Apache-2.0
 Project-URL: Homepage, https://github.com/Aitherium/awrtifact

{awrtifact-0.2.0 → awrtifact-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "awrtifact"
-version = "0.2.0"
+version = "0.2.2"
 description = "Aither World Artifact — deliberately chunk artifacts into GitHub release assets and fetch them back byte-verified. The productized aitherkvcache mirror lane."
 readme = "README.md"
 requires-python = ">=3.10"

{awrtifact-0.2.0 → awrtifact-0.2.2}/tests/test_fetch.py

@@ -1,9 +1,13 @@
 """awrtifact fetch: base-URL and full-URL forms both land the named asset; a 404 is a
 refusal with a non-zero exit, never a silent success.
 
-Measured 2026-09-02 from inside a fleet container: `awrtifact fetch NAME --url
-https://artifact.aitherium.com/` (the README's documented form) fetched the BASE
-verbatim, got the worker's 404 for the root, and the caller saw an empty output dir.
+Measured 2026-09-02 from inside a fleet container: `awrtifact fetch NAME --url https://<store>/`
+(the README's documented form) fetched the BASE verbatim, got the worker's 404 for
+the root, and the caller saw an empty output dir.
+
+The asset here is a neutral placeholder on purpose: this file SHIPS in the sdist,
+and the moat rule (AWRF005) is that a published package must not advertise which
+models we serve. The behaviour under test is the URL join, not the name.
 """
 from __future__ import annotations
 
@@ -30,7 +34,7 @@ class _Handler(http.server.BaseHTTPRequestHandler):
         pass
 
     def _serve(self, head_only: bool) -> None:
-        if self.path != "/aither-code-embed.config.json":
+        if self.path != "/example-model.config.json":
             self.send_response(404)
             self.end_headers()
             return
@@ -68,18 +72,18 @@ def server():
 
 
 def test_base_url_form_lands_the_named_asset(server, tmp_path):
-    r = fetch_mod.fetch("aither-code-embed.config.json", server, tmp_path, expected=len(BODY),
+    r = fetch_mod.fetch("example-model.config.json", server, tmp_path, expected=len(BODY),
                         lockfile=tmp_path / "lock.json")
     assert r["status"] == "fetched"
-    assert (tmp_path / "aither-code-embed.config.json").read_bytes() == BODY
+    assert (tmp_path / "example-model.config.json").read_bytes() == BODY
     assert r["sha256"] == hashlib.sha256(BODY).hexdigest()
 
 
 def test_full_url_form_still_works(server, tmp_path):
-    r = fetch_mod.fetch("aither-code-embed.config.json", server + "aither-code-embed.config.json",
+    r = fetch_mod.fetch("example-model.config.json", server + "example-model.config.json",
                         tmp_path, expected=len(BODY), lockfile=tmp_path / "lock.json")
     assert r["status"] == "fetched"
-    assert (tmp_path / "aither-code-embed.config.json").read_bytes() == BODY
+    assert (tmp_path / "example-model.config.json").read_bytes() == BODY
 
 
 def test_missing_asset_is_a_refusal_not_an_empty_dir(server, tmp_path):

{awrtifact-0.2.0 → awrtifact-0.2.2}/tests/test_serve_spec.py

@@ -157,3 +157,16 @@ def test_prefix_route_namespaces_duplicate_names(tmp_path):
     base["artifacts"] = list(base["artifacts"]) + [same]
     with pytest.raises(ValueError, match="same name"):
         spec_mod.validate(base)
+
+
+def test_prefix_route_is_a_namespace_for_chunked_and_r2():
+    """2026-09-03: /microembedder-v2/config.json served microembedder-v1's 650-byte config
+    because R2 and CHUNKED were consulted by bare name BEFORE the release prefix. The
+    generated worker must skip R2 for prefixed paths and answer a chunked entry only
+    when its upstream IS the requested release."""
+    from awrtifact import worker_template
+
+    src = worker_template.__file__
+    text = open(src, encoding="utf-8").read()
+    assert "const fromR2 = baseOverride ? null : await serveFromR2(request, env, name);" in text
+    assert "CHUNKED[name].upstream === baseOverride" in text