@zigc/lib 0.17.0-dev.263 → 0.17.0-dev.269

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zigc/lib",
-  "version": "0.17.0-dev.263",
+  "version": "0.17.0-dev.269",
   "description": "Zig standard library and libc headers (shared across all platforms)",
   "repository": {
     "type": "git",

package/std/Io.zig

@@ -54,9 +54,6 @@ pub const VTable = struct {
     /// If it returns `null` it means `result` has been already populated and
     /// `await` will be a no-op.
     ///
-    /// When this function returns non-null, the implementation guarantees that
-    /// a unit of concurrency has been assigned to the returned task.
-    ///
     /// Thread-safe.
     async: *const fn (
         /// Corresponds to `Io.userdata`.
@@ -111,10 +108,6 @@ pub const VTable = struct {
         result_alignment: std.mem.Alignment,
     ) void,
 
-    /// When this function returns, implementation guarantees that `start` has
-    /// either already been called, or a unit of concurrency has been assigned
-    /// to the task of calling the function.
-    ///
     /// Thread-safe.
     groupAsync: *const fn (
         /// Corresponds to `Io.userdata`.
@@ -1251,8 +1244,11 @@ pub const Group = struct {
     /// cancelation propagation boundary.
     ///
     /// Once this function is called, there are resources associated with the
-    /// group. To release those resources, `Group.await` or `Group.cancel` must
-    /// eventually be called.
+    /// group. To release those resources, `await` or `cancel` must eventually
+    /// be called.
+    ///
+    /// `function` is not guaranteed to have been called until `await` or
+    /// `cancel` is called.
     pub fn async(g: *Group, io: Io, function: anytype, args: std.meta.ArgsTuple(@TypeOf(function))) void {
         const Args = @TypeOf(args);
         const TypeErased = struct {
@@ -1290,6 +1286,9 @@ pub const Group = struct {
     /// will also cause `error.Canceled` to be returned when the group
     /// does ultimately finish.
     ///
+    /// After this function returns, all tasks of the `Group` created with
+    /// `async` or `concurrent` are guaranteed to have run.
+    ///
     /// Idempotent. Not threadsafe.
     ///
     /// It is safe to call this function concurrently with `Group.async` or
@@ -1304,6 +1303,9 @@ pub const Group = struct {
     /// Equivalent to `await` but immediately requests cancelation on all
     /// members of the group.
     ///
+    /// After this function returns, all tasks of the `Group` created with
+    /// `async` or `concurrent` are guaranteed to have run.
+    ///
     /// For a description of cancelation and cancelation points, see `Future.cancel`.
     ///
     /// Idempotent. Not threadsafe.

package/std/Thread.zig

@@ -695,6 +695,9 @@ const PosixThreadImpl = struct {
             .linux => {
                 return LinuxThreadImpl.getCpuCount();
             },
+            .emscripten => {
+                return @as(usize, @intCast(std.os.emscripten.emscripten_num_logical_cores()));
+            },
             .openbsd => {
                 var count: c_int = undefined;
                 var count_size: usize = @sizeOf(c_int);

package/std/os/emscripten.zig

@@ -882,6 +882,7 @@ pub extern "c" fn emscripten_hide_mouse() void;
 pub extern "c" fn emscripten_set_canvas_size(width: c_int, height: c_int) void;
 pub extern "c" fn emscripten_get_canvas_size(width: *c_int, height: *c_int, isFullscreen: *c_int) void;
 pub extern "c" fn emscripten_get_now() f64;
+pub extern "c" fn emscripten_num_logical_cores() c_int;
 pub extern "c" fn emscripten_random() f32;
 pub const em_idb_onload_func = ?*const fn (?*anyopaque, ?*anyopaque, c_int) callconv(.c) void;
 pub extern "c" fn emscripten_idb_async_load(db_name: [*:0]const u8, file_id: [*:0]const u8, arg: ?*anyopaque, onload: em_idb_onload_func, onerror: em_arg_callback_func) void;