0.4.0 --- the region a context stands on, published by the platform

`kal_task_stack` reports the stack of the CALLING context, and this platform
publishes it per context: the runtime that starts a thread calls
`emscripten_stack_set_limits` for it before its entry runs, so
`emscripten_stack_get_base` and `emscripten_stack_get_end` answer about the
context that asks and no record is kept here. The stack grows down, so the end
is the low address and the base the high one, and the region is the pair.

THE END IS THE END OF THE STACK AND NOT OF THE MEMORY. Below it is the guard
Emscripten places for a thread that overflowed, so the answer begins at the end
rather than at the bottom of what the thread was given --- which is what a caller
that walked to the boundary would otherwise walk into.

The continuous integration gate that already builds a task program under
`-pthread` now asks both of its contexts for their own region and asserts that
each contains a local of that context, and the count it asserts moves from eight
`kal_task_*` symbols to nine.

Measured here before it was pushed: the gate's program builds for
`wasm32-emscripten`, the objects carry the nine names, and it exits 0 under node
--- so both the main thread and a pthread are told a region that contains the
context that asked.

Author: Sunrisepeak

.github/workflows/ci.yml

@@ -12,7 +12,7 @@ name: CI
 #                 does not have fails at LINK naming the symbol, which is
 #                 clause 6.2's second time and is the mechanism rather than a
 #                 defect
-#   task gating   the eight kal_task_* symbols exist in a `-pthread` link and
+#   task gating   the nine kal_task_* symbols exist in a `-pthread` link and
 #                 in no other, and the interfaces word follows the link
 #
 # ONE TOOLCHAIN, NOT TWO, AND THAT IS A PROPERTY OF THE TARGET RATHER THAN A
@@ -308,8 +308,9 @@ jobs:
       #   1. without the feature and the switch, no task symbol exists;
       #   2. the feature without the switch is refused before anything compiles,
       #      naming the feature;
-      #   3. with both, the eight symbols exist and a program that starts a task
-      #      and joins it exits 0 under node.
+      #   3. with both, the nine symbols exist and a program that starts a task,
+      #      joins it, and asks each context for its own stack, exits 0 under
+      #      node.
       #
       # The consumer names `openkal` by path, as the implementation's manifest
       # now does (the step above): mcpp refuses one package reached both by path
@@ -329,16 +330,42 @@ jobs:
           rm -rf "$work"; mkdir -p "$work/src"
           cat > "$work/src/main.cpp" << 'CPP'
           import openkal.task;
-          static void entry(void* arg) { *static_cast<int*>(arg) = 1; }
+          import openkal.types;
+
+          // THE REGION EACH CONTEXT STANDS ON, ASKED FROM INSIDE IT. Containment
+          // is the observation rather than the shape of the numbers: a range
+          // that does not contain a local of the asking context describes
+          // something other than that context.
+          static bool holds(kal_uintptr at, int e, void* base, kal_uintptr size) {
+            const kal_uintptr b = reinterpret_cast<kal_uintptr>(base);
+            return e == 0 && size != 0 && b + size > b && at >= b && at - b < size;
+          }
+
+          static int inside = 0;
+          static void entry(void* arg) {
+            *static_cast<int*>(arg) = 1;
+            char here = 0;
+            void* base = nullptr;
+            kal_uintptr size = 0;
+            inside = holds(reinterpret_cast<kal_uintptr>(&here),
+                           kal_task_stack(&base, &size), base, size) ? 1 : 0;
+          }
+
           int main() {
             // KAL_TASK_PROP_PARALLEL is bit 1 (openkal/task.h); a macro does not
             // cross a module.
             if ((kal_task_props() & 2u) == 0) return 2;
+            char here = 0;
+            void* base = nullptr;
+            kal_uintptr size = 0;
+            if (!holds(reinterpret_cast<kal_uintptr>(&here),
+                       kal_task_stack(&base, &size), base, size)) return 6;
             int ran = 0;
             kal_task t{};
             if (kal_task_start(&entry, &ran, &t) != 0) return 3;
             if (kal_task_join(t) != 0) return 4;
-            return ran == 1 ? 0 : 5;
+            if (ran != 1) return 5;
+            return inside == 1 ? 0 : 7;
           }
           CPP
           manifest() {
@@ -368,11 +395,11 @@ jobs:
           n=$("$NM" --defined-only $objs 2>/dev/null \
               | awk '$2=="T"||$2=="W"{print $3}' | sed 's/^_//' \
               | grep -c '^kal_task' || true)
-          test "$n" -eq 8 || { echo "::error::expected 8 kal_task symbols with the switch, found $n"; exit 1; }
-          echo "  ok  eight task symbols with the switch"
+          test "$n" -eq 9 || { echo "::error::expected 9 kal_task symbols with the switch, found $n"; exit 1; }
+          echo "  ok  nine task symbols with the switch"
           ( cd "$work" && timeout 300 mcpp run --target wasm32-emscripten ) \
             || { echo "::error::the task program did not exit 0 under node"; exit 1; }
-          echo "  ok  a task starts, runs and joins under node"
+          echo "  ok  a task starts, runs and joins under node, and both contexts are told their own stack"
 
       - name: Restore the manifest
         if: always()

README.md

@@ -61,10 +61,10 @@ So the interface is carried by a feature:
 
 ```toml
 [dependencies]
-openkal-emscripten = { version = "0.3.1", features = ["threads"] }
+openkal-emscripten = { version = "0.4.0", features = ["threads"] }
 ```
 
-Without it, `src/threads/task.cpp` compiles to nothing, the eight `kal_task_*`
+Without it, `src/threads/task.cpp` compiles to nothing, the nine `kal_task_*`
 symbols do not exist, and `kal_interfaces()` does not claim the interface --
 the same treatment the three absent interfaces get, for the same reason.
 
@@ -104,6 +104,24 @@ channel did exist (`[build] dialect_cxxflags`); what was missing was a way to
 scope it to one target and to let this feature state its requirement, which the
 typed table provides.
 
+## The region a context stands on
+
+`kal_task_stack` reports the stack of the calling context, and this platform
+publishes it per context: the runtime that starts a thread calls
+`emscripten_stack_set_limits` for it before its entry runs, so
+`emscripten_stack_get_base` and `emscripten_stack_get_end` answer about the
+context that asks, and no record is kept here.
+
+The stack grows down, so the end is the low address and the base the high one,
+and the region is the pair. The end is the end of the *stack* and not of the
+memory: below it is the guard Emscripten places for a thread that overflowed,
+which is why the answer begins at the end rather than at the bottom of what the
+thread was given.
+
+The continuous integration gate that already builds a task program under
+`-pthread` also asks each of its two contexts for its own region and asserts
+that the region contains a local of that context.
+
 ## Conformance
 
 Measured 2026-09-11, `emsdk 6.0.9`, run under node:
@@ -143,10 +161,10 @@ implementation in its source:
 
 ```toml
 [dependencies]
-openkal = "0.14.1"
+openkal = "0.15.0"
 
 [target.'cfg(os = "emscripten")'.dependencies]
-openkal-emscripten = "0.3.1"
+openkal-emscripten = "0.4.0"
 ```
 
 ## Licence

mcpp.toml

@@ -1,7 +1,7 @@
 [package]
 namespace   = "mcpplibs"
 name        = "openkal-emscripten"
-version     = "0.3.1"
+version     = "0.4.0"
 description = "An implementation of openkal for Emscripten, written ABOVE a C library rather than beneath one, because on this platform there is no kernel to issue calls to."
 license     = "Apache-2.0"
 
@@ -18,7 +18,7 @@ authors     = ["mcpplibs"]
 repo        = "https://github.com/mcpplibs/openkal-emscripten"
 
 [dependencies]
-openkal = "0.14.1"
+openkal = { git = "https://github.com/mcpplibs/openkal.git", branch = "openkal-0.15.0" }
 
 [build]
 # THE DIALECT FLAGS ARE THE SAME AS EVERY OTHER IMPLEMENTATION'S AND THE REASON

src/threads/task.cpp

@@ -15,6 +15,10 @@
 // package-invented `OKE_THREADS` would have: a manifest that set the define
 // and not the flag, or the reverse, and a capability word that then lied.
 #include <emscripten/threading.h>
+// The stack introspection this platform publishes, which is per thread: the
+// pthread runtime calls `emscripten_stack_set_limits` for each context it
+// starts, so the answer below is the asking context's own.
+#include <emscripten/stack.h>
 
 // THREADS ARE A LINK-TIME DECISION ON THIS PLATFORM, WHICH NO OTHER
 // IMPLEMENTATION HAS TO SAY.
@@ -53,7 +57,7 @@ extern "C" {
 //   DID NOT HOLD  contexts that ran at the same time have identities distinct
 //
 // The suite is right. So without the switch this translation unit is empty,
-// the eight `kal_task_*` symbols do not exist, a program that uses one fails
+// the nine `kal_task_*` symbols do not exist, a program that uses one fails
 // at LINK naming it, and `kal_interfaces()` -- keyed on the same
 // `__EMSCRIPTEN_PTHREADS__` -- does not claim the interface. That is clause
 // 6.2's second time, and it is the treatment `openkal.process`,
@@ -124,6 +128,28 @@ kal_uintptr kal_task_current(void) {
     return reinterpret_cast<kal_uintptr>(::pthread_self());
 }
 
+// The stack the calling context runs on. Version 0.15.
+//
+// THE PLATFORM PUBLISHES IT, PER CONTEXT, AND THE STACK GROWS DOWN. The base is
+// where the stack pointer stands when nothing is in use --- the HIGH address ---
+// and the end is where it stops being the stack, so the usable region is
+// [end, base) and that is what this answers. Both are the asking context's:
+// the runtime that starts a pthread sets that thread's pair before its entry
+// runs, which is why no record is kept here and nothing is measured.
+//
+// The end is the end of the stack and not of the memory: a region below it is
+// the guard Emscripten places for a thread that overflowed, and a caller that
+// treats it as usable would be writing past what this context has.
+int kal_task_stack(void** base, kal_uintptr* size) {
+    if (base == nullptr || size == nullptr) return kal_err_invalid;
+    const uintptr_t low  = ::emscripten_stack_get_end();
+    const uintptr_t high = ::emscripten_stack_get_base();
+    if (high <= low) return kal_err_io;
+    *base = reinterpret_cast<void*>(low);
+    *size = static_cast<kal_uintptr>(high - low);
+    return kal_ok;
+}
+
 // SUSPENSION ON A WORD, AND ON THIS PLATFORM IT IS THE MACHINE'S OWN
 // INSTRUCTION RATHER THAN A LIBRARY CALL.
 //