@owear/win32-x64 0.1.1

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,36 @@
+<!-- Copyright 2026 Owear Contributors
+     SPDX-License-Identifier: Apache-2.0 -->
+
+# @owear/win32-x64
+
+Runtime de Owear para **Windows x64**: el binario del kernel nativo, los módulos
+stock (`.owm`) y los headers públicos.
+
+No se usa directamente: lo instala `@owear/cli` como dependencia opcional según
+tu plataforma. El CLI lo detecta y lo usa **en vez de compilar** el kernel.
+
+## Contenido
+
+```
+bin/owear.exe      binario del kernel (WebView2)
+bin/modules/*.dll  módulos stock: fs, path, process, screen, net, dialog, …
+include/**         headers para `owear-build-native` (tus módulos native/*.cpp)
+```
+
+## Requisitos del sistema (Windows)
+
+- **WebView2 Runtime**: viene preinstalado en Windows 11 y en la mayoría de
+  Windows 10 con Edge actualizado. Si falta:
+  <https://developer.microsoft.com/microsoft-edge/webview2/>
+- Nada más. **No** necesitas Visual Studio, CMake, vcpkg ni OpenSSL: el kernel
+  ya viene compilado en este paquete.
+
+## Uso
+
+```powershell
+npm i -g @owear/cli
+ow create mi-app
+cd mi-app
+npm install
+npm run dev
+```

package/include/ow/App.h

@@ -0,0 +1,40 @@
+// Copyright 2026 Owear Contributors
+// SPDX-License-Identifier: Apache-2.0
+#pragma once
+//
+// ow/App.h — ciclo de vida de la aplicación.
+// La implementación vive en src/Core/App_<platform>.cpp (convención de sufijos).
+//
+
+#include "ow/Common.h"
+
+namespace ow {
+
+struct AppOptions {
+    std::string id    = "dev.owear.app";   // identificador único de la app
+    std::string name  = "Owear App";
+    std::string version = "0.1.0";
+};
+
+/// Punto de entrada del kernel. Bloquea hasta Quit().
+/// En modo JS-driven (Electron-like), el kernel arranca antes y expone el
+/// Control Socket; ver src/Control/.
+class App {
+public:
+    /// Inicializa plataforma, registra módulos builtin y corre el main loop.
+    /// Devuelve el código de salida cuando el loop termina.
+    static int Main(int argc, char** argv, const AppOptions& options);
+
+    /// Callback tras Bootstrap (plataforma lista, módulos cargados) y antes
+    /// de arrancar el loop. Lugar correcto para crear ventanas.
+    static void OnReady(std::function<void()> fn);
+
+    /// Encola una devolución en el main loop (thread-safe).
+    static void Post(std::function<void()> fn);
+
+    static void Quit(int exitCode = 0);
+
+    static const AppOptions& Options();
+};
+
+} // namespace ow

package/include/ow/Base64.h

@@ -0,0 +1,89 @@
+// Copyright 2026 Owear Contributors
+// SPDX-License-Identifier: Apache-2.0
+//
+// ow/Base64.h — codec base64 header-only, disponible para módulos y kernel.
+// v1 del bridge transporta binarios embebidos en JSON con este codec;
+// F3 introduce handles SHM para payloads grandes sin copia.
+//
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace ow::b64 {
+
+inline const char* Table() {
+    return "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+}
+
+inline std::string Encode(const uint8_t* data, size_t len) {
+    const char* tbl = Table();
+    std::string out;
+    out.reserve(((len + 2) / 3) * 4);
+    size_t i = 0;
+    while (i + 2 < len) {
+        uint32_t v = (data[i] << 16) | (data[i + 1] << 8) | data[i + 2];
+        out += tbl[(v >> 18) & 63];
+        out += tbl[(v >> 12) & 63];
+        out += tbl[(v >> 6) & 63];
+        out += tbl[v & 63];
+        i += 3;
+    }
+    if (i + 1 == len) {
+        uint32_t v = data[i] << 16;
+        out += tbl[(v >> 18) & 63];
+        out += tbl[(v >> 12) & 63];
+        out += "==";
+    } else if (i + 2 == len) {
+        uint32_t v = (data[i] << 16) | (data[i + 1] << 8);
+        out += tbl[(v >> 18) & 63];
+        out += tbl[(v >> 12) & 63];
+        out += tbl[(v >> 6) & 63];
+        out += "=";
+    }
+    return out;
+}
+
+inline std::string Encode(const std::vector<uint8_t>& v) { return Encode(v.data(), v.size()); }
+inline std::string Encode(std::string_view s) {
+    return Encode(reinterpret_cast<const uint8_t*>(s.data()), s.size());
+}
+
+/// false si hay caracteres inválidos (ignora '=' y whitespace).
+inline bool Decode(std::string_view in, std::string& out) {
+    auto val = [](char c) -> int {
+        if (c >= 'A' && c <= 'Z') return c - 'A';
+        if (c >= 'a' && c <= 'z') return c - 'a' + 26;
+        if (c >= '0' && c <= '9') return c - '0' + 52;
+        if (c == '+') return 62;
+        if (c == '/') return 63;
+        return -1;
+    };
+    out.clear();
+    out.reserve(in.size() / 4 * 3);
+    uint32_t acc = 0;
+    int bits = 0;
+    for (char c : in) {
+        if (c == '=' || c == '\n' || c == '\r' || c == ' ' || c == '\t') continue;
+        int v = val(c);
+        if (v < 0) return false;
+        acc = (acc << 6) | static_cast<uint32_t>(v);
+        bits += 6;
+        if (bits >= 8) {
+            bits -= 8;
+            out.push_back(static_cast<char>((acc >> bits) & 0xFF));
+        }
+    }
+    return true;
+}
+
+inline bool Decode(std::string_view in, std::vector<uint8_t>& out) {
+    std::string tmp;
+    if (!Decode(in, tmp)) return false;
+    out.assign(tmp.begin(), tmp.end());
+    return true;
+}
+
+} // namespace ow::b64

package/include/ow/Bridge/Codec.h

@@ -0,0 +1,50 @@
+// Copyright 2026 Owear Contributors
+// SPDX-License-Identifier: Apache-2.0
+#pragma once
+//
+// ow/Bridge/Codec.h — codificación de mensajes del puente JS ↔ nativo.
+//
+// Wire format v1 (text frames; los binarios viajan embebidos):
+//   invoke:       {"t":"invoke","id":N,"m":"module","f":"fn","a":[...],"w":windowId}
+//   invokeResult: {"t":"result","id":N,"ok":true|false,"r":<json>,"b":"<base64>"}
+//   event:        {"t":"event","w":windowId,"n":"name","p":<json>}
+//
+// El codec es el punto único donde F3 sustituirá base64 por handles SHM.
+//
+
+#include "ow/Common.h"
+
+namespace ow::bridge {
+
+enum class MsgType : uint8_t { Invoke, InvokeResult, Event };
+
+struct Message {
+    MsgType type = MsgType::Invoke;
+    uint64_t id = 0;          // correlación invoke/result
+    WindowId window = 0;      // ventana invocante
+    WindowId to = 0;          // evento dirigido (0 = broadcast)
+    std::string module;
+    std::string method;
+    std::string name;         // evento
+    std::string json;         // args (array) | result | payload — texto JSON válido
+    std::vector<uint8_t> bin; // binario adjunto opcional (base64 en v1)
+};
+
+/// Decodifica un frame de texto proveniente del WebView. false si es inválido.
+bool DecodeMessage(std::string_view text, Message& out);
+
+/// Serializa un resultado de invoke para inyectarlo vía evalJS.
+/// `resultJson` debe ser JSON válido ("null" permitido).
+std::string EncodeInvokeResult(uint64_t id, bool ok,
+                               std::string_view resultJson,
+                               const uint8_t* bin = nullptr, size_t binLen = 0);
+
+/// Serializa un evento para inyectarlo vía evalJS (batch-friendly).
+std::string EncodeEvent(WindowId window, std::string_view name,
+                        std::string_view jsonPayload);
+/// Evento global (todas las ventanas): window == 0.
+inline std::string EncodeBroadcast(std::string_view name, std::string_view json) {
+    return EncodeEvent(0, name, json);
+}
+
+} // namespace ow::bridge

package/include/ow/Common.h

@@ -0,0 +1,70 @@
+// Copyright 2026 Owear Contributors
+// SPDX-License-Identifier: Apache-2.0
+#pragma once
+//
+// ow/Common.h — tipos base compartidos por todo el framework.
+// Este header es parte del CONTRATO PÚBLICO: cambiarlo debe romper
+// la compilación de las 3 plataformas en CI (anti-drift).
+//
+
+#include <cstdint>
+#include <cstddef>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <vector>
+#include <functional>
+#include <memory>
+
+#define OW_VERSION_MAJOR 0
+#define OW_VERSION_MINOR 1
+#define OW_VERSION_PATCH 0
+#define OW_VERSION_STRING "0.1.0"
+
+namespace ow {
+
+/// Identificador estable de ventana dentro del proceso del kernel.
+using WindowId = uint32_t;
+
+/// Bloque de bytes crudos (payload binario del bridge, archivos, etc).
+struct OwBytes {
+    const uint8_t* data = nullptr;
+    size_t size = 0;
+};
+
+/// Copia segura de un OwBytes a memoria propia.
+inline std::vector<uint8_t> CopyBytes(const OwBytes& b) {
+    return std::vector<uint8_t>(b.data, b.data + b.size);
+}
+
+/// Resultado simple para APIs nativas (sin excepciones a través de ABI-C).
+template <typename T>
+class Result {
+public:
+    static Result Ok(T value) { return Result(std::move(value), {}); }
+    static Result Err(std::string message) { return Result({}, std::move(message)); }
+
+    bool IsOk() const { return !error_.has_value(); }
+    bool IsErr() const { return error_.has_value(); }
+    const T& Value() const { return value_; }
+    T& Value() { return value_; }
+    const std::string& Error() const { return *error_; }
+
+private:
+    Result(T v, std::string err) : value_(std::move(v)) {
+        if (!err.empty()) error_ = std::move(err);
+    }
+    T value_;
+    std::optional<std::string> error_;
+};
+
+/// Base no copiable para objetos con identidad (Window, backends...).
+class NonCopyable {
+protected:
+    NonCopyable() = default;
+    ~NonCopyable() = default;
+    NonCopyable(const NonCopyable&) = delete;
+    NonCopyable& operator=(const NonCopyable&) = delete;
+};
+
+} // namespace ow

package/include/ow/Json.h

@@ -0,0 +1,15 @@
+// Copyright 2026 Owear Contributors
+// SPDX-License-Identifier: Apache-2.0
+#pragma once
+//
+// ow/Json.h — acceso público al parser JSON del framework para módulos.
+//
+
+#include "ow/detail/minjson.hpp"
+
+namespace ow::json {
+using ow::json::Value;
+using ow::json::Parse;
+using ow::json::ParseResult;
+using ow::json::JsLiteral;
+} // namespace ow::json

package/include/ow/Module.h

@@ -0,0 +1,78 @@
+// Copyright 2026 Owear Contributors
+// SPDX-License-Identifier: Apache-2.0
+#pragma once
+//
+// ow/Module.h — API de usuario para escribir módulos nativos (.owm).
+//
+// Ejemplo (native/files.cpp):
+//
+//   #include <ow/Module.h>
+//   #include <ow/Json.h>
+//
+//   static void readFile(const ow_request_t* req, ow_response_t* res) {
+//     auto args = ow::json::Parse(req->json, req->json_len);
+//     ...
+//     ow::Module::RespondOk(res, "\"hola\"");
+//   }
+//
+//   OW_MODULE_BEGIN(files, "1.0.0")
+//     OW_FN(readFile)
+//   OW_MODULE_END()
+//
+// El loader del kernel busca `ow_module_descriptor` con dlopen y registra
+// las funciones en el dispatcher del bridge.
+//
+
+#include "ow/Common.h"
+#include "ow_api.h"
+
+#define OW_MODULE_EXPORT_SYMBOL ow_module_descriptor
+
+/// Abre la tabla de funciones del módulo.
+#define OW_MODULE_BEGIN(Name, Version)                                        \
+    static constexpr const char* _ow_mod_name = #Name;                        \
+    static constexpr const char* _ow_mod_version = Version;                   \
+    static const ::ow_fn_entry_t _ow_fn_table[] = {
+
+#define OW_FN(FnName) { #FnName, &FnName },
+
+#define OW_MODULE_END()                                                       \
+    };                                                                        \
+    static const ::ow_module_desc_t _ow_module_desc {                         \
+        _ow_mod_name, _ow_mod_version,                                        \
+        _ow_fn_table,                                                         \
+        static_cast<uint32_t>(sizeof(_ow_fn_table) / sizeof(_ow_fn_table[0])) \
+    };                                                                        \
+    extern "C" OW_MODULE_EXPORT const ::ow_module_desc_t*                     \
+    ow_module_descriptor(void) { return &_ow_module_desc; }
+
+namespace ow::Module {
+
+/// Helpers de respuesta (copian a buffers estáticos del módulo NO — ver nota).
+/// RespondOk copia `json` a un buffer interno thread-local que vive hasta la
+/// próxima llamada de ese hilo; suficiente porque el host copia al instante.
+
+inline void RespondOk(ow_response_t* res, std::string_view json,
+                      const uint8_t* bin = nullptr, uint32_t binLen = 0) {
+    static thread_local std::string buf;
+    buf.assign(json);
+    res->status = 0;
+    res->error = nullptr;
+    res->json = buf.c_str();
+    res->json_len = static_cast<uint32_t>(buf.size());
+    res->bin = bin;
+    res->bin_len = binLen;
+}
+
+inline void RespondError(ow_response_t* res, std::string_view message) {
+    static thread_local std::string buf;
+    buf.assign(message);
+    res->status = 1;
+    res->error = buf.c_str();
+    res->json = "null";
+    res->json_len = 4;
+    res->bin = nullptr;
+    res->bin_len = 0;
+}
+
+} // namespace ow::Module