@almadar/std 17.0.2 → 17.1.0

package/behaviors/lolo/gpu/atoms/std-gpu-compute.lolo

@@ -0,0 +1,329 @@
+app std-gpu-compute [
+  version: "1.0.0",
+  gpu: { "device:16777216": [open, compute, readback] },
+  description: "One compute job on a GPU device, owning the whole device lifecycle. GPU_OPEN opens the device; GPU_RUN creates three storage buffers sized to input a, builds the shader, pipeline and bind group from config, then submits one job that writes a and b, runs the compute dispatch and reads the output buffer back, and emits GPU_RESULT with the bytes. After that job GPU_STEP runs again on the buffers in place: one job that, for each params blob in order, writes it at the start of input b and runs the dispatch, then reads the output buffer back and emits GPU_RESULT (with readback off it reads nothing and emits GPU_STEPPED with the output buffer, which a canvas draws where it lies), so a simulation keeps its state on the device between steps and a multi-pass step selects its pass from b; GPU_CLOSE releases every handle and closes the device. Every failure lands in failed carrying the kernel's error and kind and emits GPU_ERROR; GPU_CLOSE from failed releases what exists. The WGSL, entry point, workgroup counts and buffer usages are config; the default program adds two f32 vectors. Every gpu call is keyed, so a host that answers it later (a browser client) can bring its outcome back. The grant caps the device at 16 MiB; a call site that needs more grants its own cap."
+]
+
+orbital GpuComputeOrbital {
+  entity GpuJob [runtime] {
+    id : string!
+    device : GpuDevice?
+    bufA : GpuBuffer?
+    bufB : GpuBuffer?
+    bufOut : GpuBuffer?
+    shader : GpuShader?
+    pipeline : GpuPipeline?
+    bindGroup : GpuBindGroup?
+    inputA : bytes = ""
+    inputB : bytes = ""
+    size : int = 0
+    resultBytes : int = 0
+    errorText : string = ""
+    errorKind : string = ""
+  }
+
+  trait GpuCompute -> GpuJob [optimistic] {
+    initial: idle
+
+    state idle {
+      GPU_OPEN -> opening
+        (gpu/device-open { powerPreference: @config.powerPreference } { key: "gpu-open", emit: { success: GPU_DEVICE, failure: GPU_FAILED } })
+      GPU_RUN -> idle
+        (emit GPU_ERROR { error: "the device is not open", kind: "closed" })
+      GPU_STEP -> idle
+        (emit GPU_ERROR { error: "the device is not open", kind: "closed" })
+      GPU_CLOSE -> idle
+    }
+
+    state opening {
+      INIT -> opening
+      GPU_DEVICE -> ready
+        (set @entity.device @payload.device)
+        (emit GPU_OPENED {})
+      GPU_FAILED -> failed
+        (set @entity.errorText @payload.error)
+        (set @entity.errorKind @payload.kind)
+        (emit GPU_ERROR { error: @payload.error, kind: @payload.kind })
+    }
+
+    state ready {
+      GPU_OPEN -> ready
+        (emit GPU_ERROR { error: "the device is already open", kind: "invalid" })
+      GPU_STEP -> ready
+        (emit GPU_ERROR { error: "run the job before stepping it", kind: "invalid" })
+      GPU_RUN -> creatingA when (not (= @entity.device null))
+        (set @entity.inputA @payload.a)
+        (set @entity.inputB @payload.b)
+        (set @entity.size (bytes/length @payload.a))
+        (gpu/buffer-create @entity.device { size: (bytes/length @payload.a), usage: @config.inputUsage } { key: "gpu-buffer", emit: { success: GPU_BUFFER, failure: GPU_FAILED } })
+      GPU_RUN -> failed when (= @entity.device null)
+        (emit GPU_ERROR { error: "the device holds no handle", kind: "closed" })
+      GPU_CLOSE -> releasing
+        (emit GPU_RELEASE_NEXT {})
+    }
+
+    state creatingA {
+      INIT -> creatingA
+      GPU_BUFFER -> creatingB when (not (= @entity.device null))
+        (set @entity.bufA @payload.buffer)
+        (gpu/buffer-create @entity.device { size: @entity.size, usage: @config.inputUsage } { key: "gpu-buffer", emit: { success: GPU_BUFFER, failure: GPU_FAILED } })
+      GPU_BUFFER -> failed when (not (not (= @entity.device null)))
+        (set @entity.errorText "the job holds no device")
+        (set @entity.errorKind "closed")
+        (emit GPU_ERROR { error: "the job holds no device", kind: "closed" })
+      GPU_FAILED -> failed
+        (set @entity.errorText @payload.error)
+        (set @entity.errorKind @payload.kind)
+        (emit GPU_ERROR { error: @payload.error, kind: @payload.kind })
+    }
+
+    state creatingB {
+      INIT -> creatingB
+      GPU_BUFFER -> creatingOut when (not (= @entity.device null))
+        (set @entity.bufB @payload.buffer)
+        (gpu/buffer-create @entity.device { size: @entity.size, usage: @config.outputUsage } { key: "gpu-buffer", emit: { success: GPU_BUFFER, failure: GPU_FAILED } })
+      GPU_BUFFER -> failed when (not (not (= @entity.device null)))
+        (set @entity.errorText "the job holds no device")
+        (set @entity.errorKind "closed")
+        (emit GPU_ERROR { error: "the job holds no device", kind: "closed" })
+      GPU_FAILED -> failed
+        (set @entity.errorText @payload.error)
+        (set @entity.errorKind @payload.kind)
+        (emit GPU_ERROR { error: @payload.error, kind: @payload.kind })
+    }
+
+    state creatingOut {
+      INIT -> creatingOut
+      GPU_BUFFER -> shading when (not (= @entity.device null))
+        (set @entity.bufOut @payload.buffer)
+        (gpu/shader-create @entity.device @config.wgsl { key: "gpu-shader", emit: { success: GPU_SHADER, failure: GPU_FAILED } })
+      GPU_BUFFER -> failed when (not (not (= @entity.device null)))
+        (set @entity.errorText "the job holds no device")
+        (set @entity.errorKind "closed")
+        (emit GPU_ERROR { error: "the job holds no device", kind: "closed" })
+      GPU_FAILED -> failed
+        (set @entity.errorText @payload.error)
+        (set @entity.errorKind @payload.kind)
+        (emit GPU_ERROR { error: @payload.error, kind: @payload.kind })
+    }
+
+    state shading {
+      INIT -> shading
+      GPU_SHADER -> pipelining when (not (= @entity.device null))
+        (set @entity.shader @payload.shader)
+        (gpu/pipeline-create @entity.device { kind: "compute", shader: @payload.shader, entry: @config.entry } { key: "gpu-pipeline", emit: { success: GPU_PIPELINE, failure: GPU_FAILED } })
+      GPU_SHADER -> failed when (not (not (= @entity.device null)))
+        (set @entity.errorText "the job holds no device")
+        (set @entity.errorKind "closed")
+        (emit GPU_ERROR { error: "the job holds no device", kind: "closed" })
+      GPU_FAILED -> failed
+        (set @entity.errorText @payload.error)
+        (set @entity.errorKind @payload.kind)
+        (emit GPU_ERROR { error: @payload.error, kind: @payload.kind })
+    }
+
+    state pipelining {
+      INIT -> pipelining
+      GPU_PIPELINE -> binding when (and (not (= @entity.bufA null)) (not (= @entity.bufB null)) (not (= @entity.bufOut null)))
+        (set @entity.pipeline @payload.pipeline)
+        (gpu/bind-group-create @payload.pipeline 0 [{ binding: 0, buffer: @entity.bufA }, { binding: 1, buffer: @entity.bufB }, { binding: 2, buffer: @entity.bufOut }] { key: "gpu-bind", emit: { success: GPU_BINDGROUP, failure: GPU_FAILED } })
+      GPU_PIPELINE -> failed when (not (and (not (= @entity.bufA null)) (not (= @entity.bufB null)) (not (= @entity.bufOut null))))
+        (set @entity.errorText "the job holds no buffers")
+        (set @entity.errorKind "closed")
+        (emit GPU_ERROR { error: "the job holds no buffers", kind: "closed" })
+      GPU_FAILED -> failed
+        (set @entity.errorText @payload.error)
+        (set @entity.errorKind @payload.kind)
+        (emit GPU_ERROR { error: @payload.error, kind: @payload.kind })
+    }
+
+    state binding {
+      INIT -> binding
+      GPU_BINDGROUP -> submitting when (and (not (= @entity.device null)) (not (= @entity.pipeline null)) (not (= @entity.bufA null)) (not (= @entity.bufB null)) (not (= @entity.bufOut null)))
+        (set @entity.bindGroup @payload.bindGroup)
+        (gpu/submit @entity.device (array/concat [{ write: { buffer: @entity.bufA, data: @entity.inputA } }, { write: { buffer: @entity.bufB, data: @entity.inputB } }, { compute: { pipeline: @entity.pipeline, bindGroups: [@payload.bindGroup], dispatch: @config.workgroups } }] (if @config.readback [{ read: { buffer: @entity.bufOut } }] [])) { key: "gpu-submit", emit: { success: GPU_SUBMITTED, failure: GPU_FAILED } })
+      GPU_BINDGROUP -> failed when (not (and (not (= @entity.device null)) (not (= @entity.pipeline null)) (not (= @entity.bufA null)) (not (= @entity.bufB null)) (not (= @entity.bufOut null))))
+        (set @entity.errorText "the job holds no device, pipeline or buffers")
+        (set @entity.errorKind "closed")
+        (emit GPU_ERROR { error: "the job holds no device, pipeline or buffers", kind: "closed" })
+      GPU_FAILED -> failed
+        (set @entity.errorText @payload.error)
+        (set @entity.errorKind @payload.kind)
+        (emit GPU_ERROR { error: @payload.error, kind: @payload.kind })
+    }
+
+    state submitting {
+      INIT -> submitting
+      GPU_SUBMITTED -> done when (and (not @config.readback) (not (= @entity.bufOut null)))
+        (emit GPU_STEPPED { buffer: @entity.bufOut })
+      GPU_SUBMITTED -> done when @config.readback
+        (let ((out (array/first @payload.reads))) (if (= @out null) (do (set @entity.errorText "the job's read answered no bytes") (set @entity.errorKind "io") (emit GPU_ERROR { error: "the job's read answered no bytes", kind: "io" })) (do (set @entity.resultBytes (bytes/length @out)) (emit GPU_RESULT { data: @out }))))
+      GPU_FAILED -> failed
+        (set @entity.errorText @payload.error)
+        (set @entity.errorKind @payload.kind)
+        (emit GPU_ERROR { error: @payload.error, kind: @payload.kind })
+    }
+
+    state done {
+      GPU_RUN -> done
+        (emit GPU_ERROR { error: "close the job before running another", kind: "invalid" })
+      GPU_STEP -> stepping when (and (not (= @entity.device null)) (not (= @entity.pipeline null)) (not (= @entity.bindGroup null)) (not (= @entity.bufB null)) (not (= @entity.bufOut null)))
+        (gpu/submit @entity.device (array/concat (array/flatten (array/map @payload.params (fn p [{ write: { buffer: @entity.bufB, data: @p } }, { compute: { pipeline: @entity.pipeline, bindGroups: [@entity.bindGroup], dispatch: @config.workgroups } }]))) (if @config.readback [{ read: { buffer: @entity.bufOut } }] [])) { key: "gpu-submit", emit: { success: GPU_SUBMITTED, failure: GPU_FAILED } })
+      GPU_STEP -> failed when (not (and (not (= @entity.device null)) (not (= @entity.pipeline null)) (not (= @entity.bindGroup null)) (not (= @entity.bufB null)) (not (= @entity.bufOut null))))
+        (set @entity.errorText "the job holds no device, pipeline, bind group or buffers")
+        (set @entity.errorKind "closed")
+        (emit GPU_ERROR { error: "the job holds no device, pipeline, bind group or buffers", kind: "closed" })
+      GPU_CLOSE -> releasing
+        (emit GPU_RELEASE_NEXT {})
+    }
+
+    state stepping {
+      INIT -> stepping
+      GPU_STEP -> stepping
+        (emit GPU_ERROR { error: "a step is already running", kind: "invalid" })
+      GPU_SUBMITTED -> done when (and (not @config.readback) (not (= @entity.bufOut null)))
+        (emit GPU_STEPPED { buffer: @entity.bufOut })
+      GPU_SUBMITTED -> done when @config.readback
+        (let ((out (array/first @payload.reads))) (if (= @out null) (do (set @entity.errorText "the step's read answered no bytes") (set @entity.errorKind "io") (emit GPU_ERROR { error: "the step's read answered no bytes", kind: "io" })) (do (set @entity.resultBytes (bytes/length @out)) (emit GPU_RESULT { data: @out }))))
+      GPU_FAILED -> failed
+        (set @entity.errorText @payload.error)
+        (set @entity.errorKind @payload.kind)
+        (emit GPU_ERROR { error: @payload.error, kind: @payload.kind })
+    }
+
+    state failed {
+      GPU_RUN -> failed
+        (emit GPU_ERROR { error: "the job failed; close it", kind: "invalid" })
+      GPU_STEP -> failed
+        (emit GPU_ERROR { error: "the job failed; close it", kind: "invalid" })
+      GPU_CLOSE -> releasing
+        (emit GPU_RELEASE_NEXT {})
+    }
+
+    state releasing {
+      INIT -> releasing
+      GPU_RELEASE_NEXT -> releasing when (not (= @entity.bindGroup null))
+        (gpu/release @entity.bindGroup { key: "gpu-release", emit: { success: GPU_RELEASED, failure: GPU_FAILED } })
+        (set @entity.bindGroup null)
+      GPU_RELEASE_NEXT -> releasing when (and (= @entity.bindGroup null) (not (= @entity.pipeline null)))
+        (gpu/release @entity.pipeline { key: "gpu-release", emit: { success: GPU_RELEASED, failure: GPU_FAILED } })
+        (set @entity.pipeline null)
+      GPU_RELEASE_NEXT -> releasing when (and (= @entity.bindGroup null) (= @entity.pipeline null) (not (= @entity.shader null)))
+        (gpu/release @entity.shader { key: "gpu-release", emit: { success: GPU_RELEASED, failure: GPU_FAILED } })
+        (set @entity.shader null)
+      GPU_RELEASE_NEXT -> releasing when (and (= @entity.bindGroup null) (= @entity.pipeline null) (= @entity.shader null) (not (= @entity.bufOut null)))
+        (gpu/release @entity.bufOut { key: "gpu-release", emit: { success: GPU_RELEASED, failure: GPU_FAILED } })
+        (set @entity.bufOut null)
+      GPU_RELEASE_NEXT -> releasing when (and (= @entity.bindGroup null) (= @entity.pipeline null) (= @entity.shader null) (= @entity.bufOut null) (not (= @entity.bufB null)))
+        (gpu/release @entity.bufB { key: "gpu-release", emit: { success: GPU_RELEASED, failure: GPU_FAILED } })
+        (set @entity.bufB null)
+      GPU_RELEASE_NEXT -> releasing when (and (= @entity.bindGroup null) (= @entity.pipeline null) (= @entity.shader null) (= @entity.bufOut null) (= @entity.bufB null) (not (= @entity.bufA null)))
+        (gpu/release @entity.bufA { key: "gpu-release", emit: { success: GPU_RELEASED, failure: GPU_FAILED } })
+        (set @entity.bufA null)
+      GPU_RELEASE_NEXT -> closing when (and (= @entity.bindGroup null) (= @entity.pipeline null) (= @entity.shader null) (= @entity.bufOut null) (= @entity.bufB null) (= @entity.bufA null) (not (= @entity.device null)))
+        (gpu/device-close @entity.device { key: "gpu-close", emit: { success: GPU_DEVICE_CLOSED, failure: GPU_FAILED } })
+      GPU_RELEASE_NEXT -> idle when (and (= @entity.bindGroup null) (= @entity.pipeline null) (= @entity.shader null) (= @entity.bufOut null) (= @entity.bufB null) (= @entity.bufA null) (= @entity.device null))
+        (emit GPU_CLOSED {})
+      GPU_RELEASED -> releasing
+        (emit GPU_RELEASE_NEXT {})
+      GPU_FAILED -> failed
+        (set @entity.errorText @payload.error)
+        (set @entity.errorKind @payload.kind)
+        (emit GPU_ERROR { error: @payload.error, kind: @payload.kind })
+    }
+
+    state closing {
+      INIT -> closing
+      GPU_DEVICE_CLOSED -> idle
+        (set @entity.device null)
+        (emit GPU_CLOSED {})
+      GPU_FAILED -> failed
+        (set @entity.errorText @payload.error)
+        (set @entity.errorKind @payload.kind)
+        (emit GPU_ERROR { error: @payload.error, kind: @payload.kind })
+    }
+
+    emits {
+      GPU_OPENED -> external {}
+        @description "The device is open; the job accepts GPU_RUN."
+      GPU_RESULT -> external { data : bytes! }
+        @description "The output buffer's bytes after the dispatch (GPU_RUN) or after a step's dispatches (GPU_STEP), read back in the same job."
+      GPU_STEPPED -> external { buffer : GpuBuffer! }
+        @description "With readback off: the job or a step finished on the queue; buffer is the output buffer where it lies, for a drawable to draw without a readback (EXEC-GPU-7)."
+      GPU_CLOSED -> external {}
+        @description "Every handle was released and the device closed."
+      GPU_ERROR -> external { error : string! kind : string! }
+        @description "A gpu call failed or was refused; kind is the kernel's answer (denied, invalid, closed, lost)."
+      GPU_DEVICE { device : GpuDevice! }
+        @description "Internal: the device opened."
+        @tier "internal"
+      GPU_BUFFER { buffer : GpuBuffer! }
+        @description "Internal: a buffer was created."
+        @tier "internal"
+      GPU_SHADER { shader : GpuShader! }
+        @description "Internal: the shader module was created."
+        @tier "internal"
+      GPU_PIPELINE { pipeline : GpuPipeline! }
+        @description "Internal: the compute pipeline was created."
+        @tier "internal"
+      GPU_BINDGROUP { bindGroup : GpuBindGroup! }
+        @description "Internal: the bind group was created."
+        @tier "internal"
+      GPU_SUBMITTED { reads : [bytes]! }
+        @description "Internal: the job finished on the queue; reads holds the output buffer's bytes."
+        @tier "internal"
+      GPU_RELEASE_NEXT {}
+        @description "Internal: release the next live handle."
+        @tier "internal"
+      GPU_RELEASED {}
+        @description "Internal: a handle was released."
+        @tier "internal"
+      GPU_DEVICE_CLOSED {}
+        @description "Internal: the device closed."
+        @tier "internal"
+      GPU_FAILED { error : string! kind : string! }
+        @description "Internal: a gpu call failed."
+        @tier "internal"
+    }
+
+    listens {
+      GPU_OPEN {}
+        @description "Open the device."
+      GPU_RUN { a : bytes! b : bytes! }
+        @description "Add a and b on the device; both must be the same length."
+      GPU_STEP { params : [bytes]! }
+        @description "After GPU_RUN: one job that, for each params blob in order, writes it at offset 0 of input b and runs the dispatch, then reads the output back; the buffers keep their contents between steps."
+      GPU_CLOSE {}
+        @description "Release every handle and close the device."
+      GPU_DEVICE { device : GpuDevice! }
+      GPU_BUFFER { buffer : GpuBuffer! }
+      GPU_SHADER { shader : GpuShader! }
+      GPU_PIPELINE { pipeline : GpuPipeline! }
+      GPU_BINDGROUP { bindGroup : GpuBindGroup! }
+      GPU_SUBMITTED { reads : [bytes]! }
+      GPU_RELEASE_NEXT {}
+      GPU_RELEASED {}
+      GPU_DEVICE_CLOSED {}
+      GPU_FAILED { error : string! kind : string! }
+    }
+
+    config {
+      powerPreference : "low-power" | "high-performance" = "high-performance"
+        @description "Adapter preference passed to gpu/device-open: low-power or high-performance."
+      wgsl : string = "// vector add: out = a + b\n@group(0) @binding(0) var<storage, read> a : array<f32>;\n@group(0) @binding(1) var<storage, read> b : array<f32>;\n@group(0) @binding(2) var<storage, read_write> out : array<f32>;\n@compute @workgroup_size(64)\nfn main(@builtin(global_invocation_id) id : vec3<u32>) {\n  if (id.x < arrayLength(&out)) {\n    out[id.x] = a[id.x] + b[id.x];\n  }\n}\n"
+        @description "WGSL source of the compute program; a string that starts with @ is read as a binding, so keep a leading comment."
+      entry : string = "main"
+        @description "Entry point of the compute program."
+      workgroups : [int] = [1, 1, 1]
+        @description "Workgroup counts x, y, z of the single dispatch."
+      inputUsage : ["map-read" | "map-write" | "copy-src" | "copy-dst" | "index" | "vertex" | "uniform" | "storage" | "indirect" | "query-resolve"] = ["storage", "copy-dst"]
+        @description "Usage of the two input buffers (buffer usage vocabulary: map-read map-write copy-src copy-dst index vertex uniform storage indirect query-resolve)."
+      readback : boolean = true
+        @description "Read the output buffer back after the job and each step (GPU_RESULT with its bytes); off, emit GPU_STEPPED with the buffer itself, for a canvas that draws it on the device (its outputUsage then needs vertex)."
+      outputUsage : ["map-read" | "map-write" | "copy-src" | "copy-dst" | "index" | "vertex" | "uniform" | "storage" | "indirect" | "query-resolve"] = ["storage", "copy-src"]
+        @description "Usage of the output buffer; it must include copy-src for the read in the job."
+    }
+  }
+
+  page boot as GpuComputeOrbitalStart -> GpuCompute
+}

package/behaviors/lolo/net/atoms/std-http-client.lolo

@@ -510,7 +510,7 @@ orbital HttpClientOrbital {
         (set @entity.sock @payload.sock)
         (os/send @payload.sock [{ bytes: @entity.head, credential: @config.credential, scope: "user", encode: "form" }, { bytes: @entity.request, credential: "" }] { key: "send" emit: { success: HC_SENT, failure: HC_IO_FAILED } })
       HC_IO_FAILED -> ready
-        (emit HTTP_FAILED { key: @entity.key, error: @payload.error, kind: (if (array/includes ["denied", "timeout", "tls"] @payload.kind) @payload.kind "io") })
+        (emit HTTP_FAILED { key: @entity.key, error: @payload.error, kind: (if (array/includes ["denied", "unsupported", "timeout", "tls"] @payload.kind) @payload.kind "io") })
     }
 
     state sending {
@@ -586,7 +586,7 @@ orbital HttpClientOrbital {
       HC_IO_FAILED -> ready when (not @entity.reused)
         (os/close @entity.sock { key: "close" emit: { success: HC_CLOSED, failure: HC_CLOSED } })
         (set @entity.sock -1)
-        (emit HTTP_FAILED { key: @entity.key, error: @payload.error, kind: (if (array/includes ["denied", "timeout", "tls"] @payload.kind) @payload.kind "io") })
+        (emit HTTP_FAILED { key: @entity.key, error: @payload.error, kind: (if (array/includes ["denied", "unsupported", "timeout", "tls"] @payload.kind) @payload.kind "io") })
     }
 
     state reading {
@@ -626,7 +626,7 @@ orbital HttpClientOrbital {
       HC_IO_FAILED -> ready when (not (and @entity.reused (= @entity.stage "head") (= (bytes/length @entity.buf) 0)))
         (os/close @entity.sock { key: "close" emit: { success: HC_CLOSED, failure: HC_CLOSED } })
         (set @entity.sock -1)
-        (emit HTTP_FAILED { key: @entity.key, error: @payload.error, kind: (if (array/includes ["denied", "timeout", "tls"] @payload.kind) @payload.kind "io") })
+        (emit HTTP_FAILED { key: @entity.key, error: @payload.error, kind: (if (array/includes ["denied", "unsupported", "timeout", "tls"] @payload.kind) @payload.kind "io") })
 
       HC_READ -> reading
         (set @entity.buf (bytes/concat [@entity.buf, @payload.data]))
@@ -826,7 +826,7 @@ orbital HttpClientOrbital {
         error : string!
         kind : string!
       }
-        @description "The call produced no response: kind refused (nothing opened), denied, timeout, tls or io."
+        @description "The call produced no response: kind refused (nothing opened), denied, unsupported (the host cannot open sockets), timeout, tls or io."
         @tier "primary"
       HC_BUILT -> internal {
         head : bytes!

package/behaviors/lolo/net/atoms/std-http-fetch.lolo

@@ -96,7 +96,7 @@ orbital HttpFetchOrbital {
       HF_REPLIED -> ready
         (emit HTTP_REPLIED { key: @payload.key, status: @payload.status, headers: (default (object/fromEntries (array/map @payload.headers (fn h [(str/lower @h.name), (str/join (array/map (array/filter @payload.headers (fn g (= (str/lower @g.name) (str/lower @h.name)))) (fn g @g.value)) ", ")]))) {}), body: @payload.body })
       HF_FAILED -> ready
-        (emit HTTP_FAILED { key: @payload.key, error: @payload.error, kind: (if (or (= @payload.kind "denied") (= @payload.kind "timeout")) @payload.kind "io") })
+        (emit HTTP_FAILED { key: @payload.key, error: @payload.error, kind: (if (array/includes ["denied", "unsupported", "timeout"] @payload.kind) @payload.kind "io") })
       HF_CLOSED -> ready
     }
 
@@ -107,7 +107,7 @@ orbital HttpFetchOrbital {
       HF_REPLIED -> opening
         (emit HTTP_REPLIED { key: @payload.key, status: @payload.status, headers: (default (object/fromEntries (array/map @payload.headers (fn h [(str/lower @h.name), (str/join (array/map (array/filter @payload.headers (fn g (= (str/lower @g.name) (str/lower @h.name)))) (fn g @g.value)) ", ")]))) {}), body: @payload.body })
       HF_FAILED -> opening
-        (emit HTTP_FAILED { key: @payload.key, error: @payload.error, kind: (if (or (= @payload.kind "denied") (= @payload.kind "timeout")) @payload.kind "io") })
+        (emit HTTP_FAILED { key: @payload.key, error: @payload.error, kind: (if (array/includes ["denied", "unsupported", "timeout"] @payload.kind) @payload.kind "io") })
       HF_CLOSED -> opening
       HF_HEAD -> ready when (== @payload.handle null)
         (emit HTTP_FAILED { key: @entity.key, error: "the host answered a streamed fetch with no handle", kind: "io" })
@@ -117,7 +117,7 @@ orbital HttpFetchOrbital {
         (set @entity.headers (array/map @payload.headers (fn h { name: (str/lower @h.name), value: @h.value })))
         (os/recv @payload.handle @config.recvBytes { key: "read" emit: { success: HF_READ, failure: HF_IO_FAILED } })
       HF_HEAD_FAILED -> ready
-        (emit HTTP_FAILED { key: @entity.key, error: @payload.error, kind: (if (or (= @payload.kind "denied") (= @payload.kind "timeout")) @payload.kind "io") })
+        (emit HTTP_FAILED { key: @entity.key, error: @payload.error, kind: (if (array/includes ["denied", "unsupported", "timeout"] @payload.kind) @payload.kind "io") })
     }
 
     state streaming {
@@ -127,12 +127,12 @@ orbital HttpFetchOrbital {
       HF_REPLIED -> streaming
         (emit HTTP_REPLIED { key: @payload.key, status: @payload.status, headers: (default (object/fromEntries (array/map @payload.headers (fn h [(str/lower @h.name), (str/join (array/map (array/filter @payload.headers (fn g (= (str/lower @g.name) (str/lower @h.name)))) (fn g @g.value)) ", ")]))) {}), body: @payload.body })
       HF_FAILED -> streaming
-        (emit HTTP_FAILED { key: @payload.key, error: @payload.error, kind: (if (or (= @payload.kind "denied") (= @payload.kind "timeout")) @payload.kind "io") })
+        (emit HTTP_FAILED { key: @payload.key, error: @payload.error, kind: (if (array/includes ["denied", "unsupported", "timeout"] @payload.kind) @payload.kind "io") })
       HF_CLOSED -> streaming
       HF_IO_FAILED -> ready
         (os/close @entity.handle { key: "close" emit: { success: HF_CLOSED, failure: HF_CLOSED } })
         (set @entity.handle -1)
-        (emit HTTP_FAILED { key: @entity.key, error: @payload.error, kind: (if (or (= @payload.kind "denied") (= @payload.kind "timeout")) @payload.kind "io") })
+        (emit HTTP_FAILED { key: @entity.key, error: @payload.error, kind: (if (array/includes ["denied", "unsupported", "timeout"] @payload.kind) @payload.kind "io") })
 
       HF_READ -> streaming
         (set @entity.dec (bytes/concat [@entity.dec, @payload.data]))
@@ -190,7 +190,7 @@ orbital HttpFetchOrbital {
         error : string!
         kind : string!
       }
-        @description "The call produced no response: kind refused (nothing sent), denied, timeout, encoding (a stream frame is not UTF-8) or io."
+        @description "The call produced no response: kind refused (nothing sent), denied, unsupported (the host cannot fetch), timeout, encoding (a stream frame is not UTF-8) or io."
         @tier "primary"
       HF_HEAD {
         key : string

package/behaviors/lolo/net/atoms/std-npm-lookup.lolo

@@ -85,7 +85,7 @@ orbital NpmLookupOrbital {
       NPM_LOOKUP_PACKUMENT -> idle when (!= @payload.status 200)
         (emit NPM_LOOKUP_REFUSED { requestId: @entity.requestId, name: @entity.name, code: (if (or (= @payload.status 401) (= @payload.status 403)) "auth" (if (= @payload.status 404) "absent" (if (>= @payload.status 500) "unreachable" "unexpected"))), status: @payload.status, error: (str/concat "the registry answered " @payload.status " for " @entity.name) })
       NPM_LOOKUP_UNREACHABLE -> idle
-        (emit NPM_LOOKUP_REFUSED { requestId: @entity.requestId, name: @entity.name, code: (if (= @payload.kind "denied") "unconfigured" "unreachable"), status: 0, error: @payload.error })
+        (emit NPM_LOOKUP_REFUSED { requestId: @entity.requestId, name: @entity.name, code: (if (array/includes ["denied", "unsupported"] @payload.kind) "unconfigured" "unreachable"), status: 0, error: @payload.error })
     }
 
     emits {

package/behaviors/lolo/net/atoms/std-npm-registry.lolo

@@ -206,10 +206,10 @@ orbital NpmRegistryOrbital {
         (emit NPM_FAILED { name: @entity.name, code: "auth", status: @payload.status, error: (str/concat "the registry refused the token (" @payload.status ") for the tarball of " @entity.name (quote "@") @entity.version) })
       NPM_WAIT_TARBALL_REPLIED -> waiting when (not (or (= @payload.status 200) (= @payload.status 206) (= @payload.status 401) (= @payload.status 403)))
         (emit NPM_WAIT_RETRY_FAILED { key: (as (str/concat "npm-wait:" (+ @entity.seq 1)) CallKey), error: (str/concat "version listed but its tarball is not downloadable yet (" @payload.status ")") })
-      NPM_WAIT_UNREACHABLE -> idle when (= @payload.kind "denied")
+      NPM_WAIT_UNREACHABLE -> idle when (array/includes ["denied", "unsupported"] @payload.kind)
         (emit NPM_WAIT_RETRY_CANCEL { })
         (emit NPM_FAILED { name: @entity.name, code: "unconfigured", status: 0, error: @payload.error })
-      NPM_WAIT_UNREACHABLE -> waiting when (!= @payload.kind "denied")
+      NPM_WAIT_UNREACHABLE -> waiting when (not (array/includes ["denied", "unsupported"] @payload.kind))
         (emit NPM_WAIT_RETRY_FAILED { key: (as (str/concat "npm-wait:" (+ @entity.seq 1)) CallKey), error: @payload.error })
 
       NPM_WAIT_DONE -> idle