@origingame/engine 0.1.0 → 0.2.0

package/dist/web/origin-engine.js

@@ -8022,22 +8022,22 @@ function __wbg_get_imports() {
             arg0.writeTexture(arg1, getArrayU8FromWasm0(arg2, arg3), arg4, arg5);
         }, arguments); },
         __wbindgen_generic_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 4796, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 4803, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen_b8d3fa9391980f8___convert__closures_____invoke___wasm_bindgen_b8d3fa9391980f8___JsValue__core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_b8d3fa9391980f8___JsError___true_);
             return ret;
         },
         __wbindgen_generic_0000000000000002: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("GPUDevice")], shim_idx: 2658, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("GPUDevice")], shim_idx: 2666, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen_b8d3fa9391980f8___convert__closures_____invoke___wasm_bindgen_b8d3fa9391980f8___sys__JsNullable_wgpu_318367e4ed152831___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_b8d3fa9391980f8___JsError___true_);
             return ret;
         },
         __wbindgen_generic_0000000000000003: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("any")], shim_idx: 2658, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("any")], shim_idx: 2666, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen_b8d3fa9391980f8___convert__closures_____invoke___wasm_bindgen_b8d3fa9391980f8___sys__JsNullable_wgpu_318367e4ed152831___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_b8d3fa9391980f8___JsError___true__352);
             return ret;
         },
         __wbindgen_generic_0000000000000004: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("undefined")], shim_idx: 2658, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("undefined")], shim_idx: 2666, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen_b8d3fa9391980f8___convert__closures_____invoke___wasm_bindgen_b8d3fa9391980f8___sys__JsNullable_wgpu_318367e4ed152831___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_b8d3fa9391980f8___JsError___true__353);
             return ret;
         },

package/dist/web-publish/origin-engine-lanes.js

@@ -7862,32 +7862,32 @@ function __wbg_get_imports(memory) {
             arg0.writeTexture(arg1, getArrayU8FromWasm0(arg2, arg3), arg4, arg5);
         }, arguments); },
         __wbindgen_generic_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 2021, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 2027, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen_4274632476068e3f___convert__closures_____invoke___wasm_bindgen_4274632476068e3f___JsValue______true_);
             return ret;
         },
         __wbindgen_generic_0000000000000002: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 4356, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 4362, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen_4274632476068e3f___convert__closures_____invoke___wasm_bindgen_4274632476068e3f___JsValue__core_f9975da687154ecd___result__Result_____wasm_bindgen_4274632476068e3f___JsError___true_);
             return ret;
         },
         __wbindgen_generic_0000000000000003: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 4358, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 4364, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen_4274632476068e3f___convert__closures_____invoke___js_sys_61cb8e1cd79b86e3___futures__task__wait_async_polyfill__MessageEvent______true_);
             return ret;
         },
         __wbindgen_generic_0000000000000004: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("GPUDevice")], shim_idx: 2019, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("GPUDevice")], shim_idx: 2025, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen_4274632476068e3f___convert__closures_____invoke___wasm_bindgen_4274632476068e3f___sys__JsNullable_wgpu_507ee5aabebc46c8___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_f9975da687154ecd___result__Result_____wasm_bindgen_4274632476068e3f___JsError___true_);
             return ret;
         },
         __wbindgen_generic_0000000000000005: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("any")], shim_idx: 2019, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("any")], shim_idx: 2025, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen_4274632476068e3f___convert__closures_____invoke___wasm_bindgen_4274632476068e3f___sys__JsNullable_wgpu_507ee5aabebc46c8___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_f9975da687154ecd___result__Result_____wasm_bindgen_4274632476068e3f___JsError___true__342);
             return ret;
         },
         __wbindgen_generic_0000000000000006: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("undefined")], shim_idx: 2019, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("undefined")], shim_idx: 2025, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen_4274632476068e3f___convert__closures_____invoke___wasm_bindgen_4274632476068e3f___sys__JsNullable_wgpu_507ee5aabebc46c8___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_f9975da687154ecd___result__Result_____wasm_bindgen_4274632476068e3f___JsError___true__343);
             return ret;
         },

package/dist/web-publish/origin-engine.js

@@ -7707,22 +7707,22 @@ function __wbg_get_imports() {
             arg0.writeTexture(arg1, getArrayU8FromWasm0(arg2, arg3), arg4, arg5);
         }, arguments); },
         __wbindgen_generic_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 3961, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 3968, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen_b8d3fa9391980f8___convert__closures_____invoke___wasm_bindgen_b8d3fa9391980f8___JsValue__core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_b8d3fa9391980f8___JsError___true_);
             return ret;
         },
         __wbindgen_generic_0000000000000002: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("GPUDevice")], shim_idx: 1823, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("GPUDevice")], shim_idx: 1830, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen_b8d3fa9391980f8___convert__closures_____invoke___wasm_bindgen_b8d3fa9391980f8___sys__JsNullable_wgpu_75f3f84ef81abc5a___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_b8d3fa9391980f8___JsError___true_);
             return ret;
         },
         __wbindgen_generic_0000000000000003: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("any")], shim_idx: 1823, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("any")], shim_idx: 1830, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen_b8d3fa9391980f8___convert__closures_____invoke___wasm_bindgen_b8d3fa9391980f8___sys__JsNullable_wgpu_75f3f84ef81abc5a___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_b8d3fa9391980f8___JsError___true__333);
             return ret;
         },
         __wbindgen_generic_0000000000000004: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("undefined")], shim_idx: 1823, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("undefined")], shim_idx: 1830, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen_b8d3fa9391980f8___convert__closures_____invoke___wasm_bindgen_b8d3fa9391980f8___sys__JsNullable_wgpu_75f3f84ef81abc5a___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_b8d3fa9391980f8___JsError___true__334);
             return ret;
         },

package/dist/web-publish-2d/origin-engine-lanes.js

@@ -7862,32 +7862,32 @@ function __wbg_get_imports(memory) {
             arg0.writeTexture(arg1, getArrayU8FromWasm0(arg2, arg3), arg4, arg5);
         }, arguments); },
         __wbindgen_generic_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 1873, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 1881, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen_4274632476068e3f___convert__closures_____invoke___wasm_bindgen_4274632476068e3f___JsValue______true_);
             return ret;
         },
         __wbindgen_generic_0000000000000002: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 4209, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 4216, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen_4274632476068e3f___convert__closures_____invoke___wasm_bindgen_4274632476068e3f___JsValue__core_f9975da687154ecd___result__Result_____wasm_bindgen_4274632476068e3f___JsError___true_);
             return ret;
         },
         __wbindgen_generic_0000000000000003: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 4211, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 4218, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen_4274632476068e3f___convert__closures_____invoke___js_sys_61cb8e1cd79b86e3___futures__task__wait_async_polyfill__MessageEvent______true_);
             return ret;
         },
         __wbindgen_generic_0000000000000004: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("GPUDevice")], shim_idx: 1871, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("GPUDevice")], shim_idx: 1879, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen_4274632476068e3f___convert__closures_____invoke___wasm_bindgen_4274632476068e3f___sys__JsNullable_wgpu_55e897b7c9dc4975___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_f9975da687154ecd___result__Result_____wasm_bindgen_4274632476068e3f___JsError___true_);
             return ret;
         },
         __wbindgen_generic_0000000000000005: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("any")], shim_idx: 1871, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("any")], shim_idx: 1879, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen_4274632476068e3f___convert__closures_____invoke___wasm_bindgen_4274632476068e3f___sys__JsNullable_wgpu_55e897b7c9dc4975___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_f9975da687154ecd___result__Result_____wasm_bindgen_4274632476068e3f___JsError___true__342);
             return ret;
         },
         __wbindgen_generic_0000000000000006: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("undefined")], shim_idx: 1871, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("undefined")], shim_idx: 1879, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen_4274632476068e3f___convert__closures_____invoke___wasm_bindgen_4274632476068e3f___sys__JsNullable_wgpu_55e897b7c9dc4975___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_f9975da687154ecd___result__Result_____wasm_bindgen_4274632476068e3f___JsError___true__343);
             return ret;
         },

package/dist/web-publish-2d/origin-engine.js

@@ -7707,22 +7707,22 @@ function __wbg_get_imports() {
             arg0.writeTexture(arg1, getArrayU8FromWasm0(arg2, arg3), arg4, arg5);
         }, arguments); },
         __wbindgen_generic_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 3816, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 3822, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen_b8d3fa9391980f8___convert__closures_____invoke___wasm_bindgen_b8d3fa9391980f8___JsValue__core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_b8d3fa9391980f8___JsError___true_);
             return ret;
         },
         __wbindgen_generic_0000000000000002: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("GPUDevice")], shim_idx: 1679, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("GPUDevice")], shim_idx: 1685, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen_b8d3fa9391980f8___convert__closures_____invoke___wasm_bindgen_b8d3fa9391980f8___sys__JsNullable_wgpu_d2fbdff2c91c8b93___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_b8d3fa9391980f8___JsError___true_);
             return ret;
         },
         __wbindgen_generic_0000000000000003: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("any")], shim_idx: 1679, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("any")], shim_idx: 1685, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen_b8d3fa9391980f8___convert__closures_____invoke___wasm_bindgen_b8d3fa9391980f8___sys__JsNullable_wgpu_d2fbdff2c91c8b93___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_b8d3fa9391980f8___JsError___true__333);
             return ret;
         },
         __wbindgen_generic_0000000000000004: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("undefined")], shim_idx: 1679, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("undefined")], shim_idx: 1685, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen_b8d3fa9391980f8___convert__closures_____invoke___wasm_bindgen_b8d3fa9391980f8___sys__JsNullable_wgpu_d2fbdff2c91c8b93___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_b8d3fa9391980f8___JsError___true__334);
             return ret;
         },

package/knowledge/package.json

@@ -1,17 +1,17 @@
 {
   "name": "@origingame/engine-knowledge",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Origin Engine knowledge for agents: the API wiki generated from api.ogt, the ten og-* skills, the style catalogue and the project scaffold description, laid out for the OriginGame platform's knowledge packs. Not published on its own: @origingame/engine carries it as knowledge/ (docs/release.md §2).",
   "license": "MIT",
   "private": true,
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/fran0220/origin-engine.git",
+    "url": "git+https://github.com/originai-game/origin-engine.git",
     "directory": "packages/knowledge"
   },
-  "homepage": "https://github.com/fran0220/origin-engine#readme",
+  "homepage": "https://github.com/originai-game/origin-engine#readme",
   "bugs": {
-    "url": "https://github.com/fran0220/origin-engine/issues"
+    "url": "https://github.com/originai-game/origin-engine/issues"
   },
   "type": "module",
   "files": [

package/knowledge/scaffold/origin-engine.json

@@ -4,13 +4,13 @@
   "substrate": "origin-engine-ts",
   "engine": {
     "package": "@origingame/engine",
-    "version": "0.1.0",
+    "version": "0.2.0",
     "repository": "origingame/origin-engine"
   },
   "template": {
     "source": "templates/game",
     "create": "@origingame/create-game",
-    "version": "0.1.0"
+    "version": "0.2.0"
   },
   "probe": {
     "protocol": 5,

package/knowledge/scaffold/template/gitignore

@@ -0,0 +1,8 @@
+# og cook output: rebuilt from assets/, never committed.
+cooked/
+# og build output.
+dist/
+# og run and og test output, and og's bundled entry.
+og-out/
+.og/
+node_modules/

package/knowledge/scaffold/template/package.json

@@ -13,6 +13,6 @@
     "test": "og test ."
   },
   "dependencies": {
-    "@origingame/engine": "0.1.0"
+    "@origingame/engine": "0.2.0"
   }
 }

package/knowledge/scaffold/template/project.ogt

@@ -7,7 +7,7 @@ version 1
 name "Origin Game"
 id "origin-game"
 # The engine this game is written against (design §9: upgrades are explicit).
-engine "0.1.0"
+engine "0.2.0"
 entry "src/main.ts"
 # 2d (orthographic camera, sprites, 2D physics) or 3d.
 profile "3d"

package/knowledge/scripts/lib.ts

@@ -90,7 +90,11 @@ export const TEMPLATE_SKIP: ReadonlySet<string> = new Set(["cooked", "dist", "og
  * overlay as `.gitattributes`, which in the engine repository would route
  * the template's plain-blob media through LFS.
  */
-export const TEMPLATE_RENAMED: ReadonlyMap<string, string> = new Map([["gitattributes", ".gitattributes"]]);
+export const TEMPLATE_RENAMED: ReadonlyMap<string, string> = new Map([
+  ["gitattributes", ".gitattributes"],
+  // npm drops .gitignore from a tarball: the published scaffold/template carries it as `gitignore` (scripts/pack.ts).
+  ["gitignore", ".gitignore"],
+]);
 
 const fatal = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
 

package/knowledge/scripts/pack.ts

@@ -16,7 +16,8 @@ rmSync(target, { recursive: true, force: true });
 let n = 0;
 for (const full of walk(source, TEMPLATE_SKIP)) {
   if (!isText(new Uint8Array(readFileSync(full)))) continue;
-  const to = join(target, relative(source, full));
+  // npm drops .gitignore from a tarball; TEMPLATE_RENAMED maps it back at mount.
+  const to = join(target, relative(source, full) === ".gitignore" ? "gitignore" : relative(source, full));
   mkdirSync(dirname(to), { recursive: true });
   cpSync(full, to);
   n++;

package/knowledge/scripts/validate.ts

@@ -546,11 +546,12 @@ export function readKeys(region: string): string[] {
 }
 
 /**
- * The grammars the skills write out (og-game §8 tilesets and maps, §9 a
+ * The grammars the skills write out (og-game §8 flipbooks, tilesets and maps, §9 a
  * model's animation settings and the animation graph, §10 emitters; og-ai
  * §1 the navmesh, §3 behaviours) and the parsers they come from.
  */
 export const GRAMMARS: readonly Grammar[] = [
+  { type: "flipbook", source: "crates/og-anim/src/flipbook.rs", region: [/impl FlipMode/, /pub fn to_text/], names: { frame: 1, clip: 1 } },
   { type: "tileset", source: "crates/og-tilemap/src/tileset.rs" },
   { type: "tilemap", source: "crates/og-tilemap/src/map.rs", region: [/pub fn parse\(text/, /^pub fn world_to_cell/m] },
   { type: "particles", source: "crates/og-cook/src/fx.rs", unnamed: { key: "colorOverLife's lines: the parser reads their five numbers whatever the key" } },

package/knowledge/skills/og-build/SKILL.md

@@ -74,7 +74,16 @@ a number and a sound (taste 98, feel 79).
    matched count. A system that matched 0 entities is usually a missing
    component on the spawn, not a logic bug.
 
-   Where there is no renderer (a sandbox with no GPU: `og run --json` says
+   Headless means no window, not no rendering: `og run`, `og test` and
+   `og polish` still render every tick when an adapter is available. A
+   sandbox without a GPU may have Mesa lavapipe (`vulkan-cpu` in
+   `og doctor`), which renders on the CPU and can take minutes per
+   game-second. Use `OG_RENDERER=none og test .` (likewise `og run` and
+   `og polish`) for simulation-only iteration there. Do not treat this as
+   visual approval: record and compare frames on the retained reference
+   tier, and run visual polish with a renderer.
+
+   Where there is no renderer (`OG_RENDERER=none`, or no usable adapter: `og run --json` says
    `"tier": "none"`, `og doctor` says the renderer is `none`), the run is
    the same run: the same ticks, dumps and world hash. A `screenshot`
    writes no PNG and logs "no renderer, frame unchecked" with the file it
@@ -117,6 +126,13 @@ step's file by the name the step gave (`run.json("shop.json")`,
 `run.png("title.png")`); give each step's file its own name. A test that ran no checks fails. Run it before
 claiming a change works.
 
+While iterating, `og test . --filter tests/lobby.og.ts` runs only that
+suite. The filter is a case-sensitive substring of the project-relative
+file path, using `/` separators: `--filter lobby` selects every matching
+`.og.ts` and `.test.ts` file; it does not match test titles or use globs.
+No matching files is a failure, not a passing empty run. The project's
+type check still runs. Drop the filter for the complete regression run.
+
 Put every check that reads a frame (`run.png`, a decoded screenshot, a
 comparison with `references/`) inside `t.frame(files, () => ...)`:
 

package/knowledge/skills/og-feel/SKILL.md

@@ -297,7 +297,14 @@ starting from these (the defaults are the first column):
   bounce, `jumpSpeed` from the height you want: `sqrt(2 × 9.81 × h)`.
 - Read `og.CharacterEvent` for juice: `CHARACTER_LANDED` with its `speed`
   scales the landing squash and dust; `CHARACTER_JUMPED` plays the jump
-  stretch (§5) and sound on the same tick.
+  stretch (§5) and sound. The controllers move in the physics step, after
+  the game's systems, so their events are read **the tick after**: the
+  press's tick starts the jump (§1 holds), the next tick plays its juice,
+  one tick (17 ms at 60 Hz) late. Where that tick shows (a rhythm jump, a
+  sound on a beat), start the stretch and sound in the system that sets
+  `jump`, on the press while the controller can jump (`grounded`, or
+  `coyote` above 0), and leave the event's `CHARACTER_JUMPED` to the
+  buffered and air jumps.
 - Ragdolls: `blendTime` 0.15–0.3 s from the animation to the bones; set
   `weight` 1 on the killing blow's tick, with its hit stop, so the fall
   starts from the hit pose.

package/knowledge/skills/og-game/SKILL.md

@@ -43,7 +43,11 @@ change, without a warning, and its refusals named the line and the fix.
 The order the games found productive:
 
 1. **`project.ogt`** (§2): name, id, the engine pin, the profile, tick and
-   seed. The scaffold writes it; change it there and nowhere else.
+   seed. The scaffold writes it (`npm create @origingame/game --profile
+   2d` writes the 2D starter, a platformer with sprites, a tilemap and 2D
+   physics, as does a premise that says 2D, platformer, side-scroller,
+   metroidvania or pixel art; `3d`, the default, the 3D template; an
+   archetype brings its own); change it there and nowhere else.
 2. **`GameDesc`** in `src/main.ts` (§3): the scene, the look, the systems,
    and from the start a command for each state a test must reach (`play`,
    `warp:<where>`) and facts for what it must check.
@@ -393,7 +397,8 @@ else ignores it. The stamp is world state, so a replay reproduces it.
   sprites only.
 - **Sprite sheets** are `.ogt` files of `type flipbook` next to the PNG
   (grid or named frames, or an Aseprite / TexturePacker JSON `atlas`; clips
-  with `fps`, `mode loop | pingPong | once` and `event <frame> "name"`).
+  with `fps`, `mode loop | pingPong | once` and `event <frame> "name"`;
+  every line is the grammar at the end of this section).
   `og.load.flipbook(world, "sprites/hero.ogt")` answers the sheet and its
   clips; `og.Flipbook { sheet, clip: og.anim.clip(info, "walk") }` on the
   sprite's entity plays it, and `og.FlipbookEvent` reports the frames named
@@ -436,7 +441,11 @@ else ignores it. The stamp is world state, so a replay reproduces it.
   `og.tilemap.setTile` edits a cell (terrain layers re-tile their
   neighbours, colliders follow); `getTile` answers the tile there (on a
   terrain layer the one auto-tiling chose, -1 when empty), `cellAt` and
-  `cellCenter` convert positions. Layers scroll by their `parallax`;
+  `cellCenter` convert positions. Every collision layer's colliders sit
+  on `og.Tilemap.colliderLayers` unless the layer names its own
+  `colliderLayers` and `colliderMask` (grammar below): a layer of grates
+  on the bit of the platformer's `oneWayLayers` is one-way while the
+  walls on another layer stay solid. Layers scroll by their `parallax`;
   `repeat x` tiles a background (`reference/tilemap.md`). Every line of a
   tileset and a map, and what the cook reads of a Tiled map, is the
   grammar at the end of this section.
@@ -451,6 +460,55 @@ this; `templates/archetypes/roguelike` carves a tilemap at run time from
 og.Rng and keeps its fog of war on a layer, and
 `templates/archetypes/tower-defense` writes placements to a map's layer.
 
+### Flipbooks: the grammar
+
+A **flipbook** is an `.ogt` of `type flipbook` beside its PNG (give the
+PNG `texture { kind pixel }` import settings for pixel art). Its frames
+are the grid's (row-major from the top left, named `0`, `1`, ... by
+their index), then the `frame` lines', then an atlas's; its clips are
+numbered in file order from 0, and that index is what
+`og.anim.clip(info, "walk")` answers and what `og.Flipbook.clip` holds,
+so a system that compares `og.Flipbook.clip` with a constant relies on
+that order (look the indices up with `og.anim.clip` in `start` instead).
+Every line, with its default:
+
+```text
+type flipbook
+version 1
+---
+texture "hero.png"        # the sheet (required): beside the .ogt when that file exists, else an asset id
+size 256 80               # the texture in pixels: the cook fills it in from the PNG
+filter nearest            # nearest (default, pixel art) | linear
+array false               # true: the frames become the layers of a texture array, one draw for every sprite (one size each)
+pivot 0.5 0               # the point of each frame at the entity's position, from its bottom left (default 0.5 0.5): 0.5 0 stands on the feet
+margin 0                  # grid only: pixels round the grid (default 0)
+spacing 2                 # grid only: pixels between cells (default 0)
+grid 32 40 8 2            # <cell width px> <cell height px> [<columns> <rows>]: frames 0.., row-major
+frame slash 0 80 48 40 0.25 0   # a named frame: <name> x y w h [pivot x y], x y from the texture's top left
+atlas "hero.json"         # an Aseprite or TexturePacker JSON: its frames (and Aseprite's tags as clips)
+clip idle {               # clip 0
+  frames 14 15            # frame indices or names, in order (required)
+  fps 2                   # frames a second (default 12) ...
+}
+clip run {                # clip 1
+  frames 0 1 2 3 4 5 6 7
+  durations 0.07 0.07 0.1 0.07 0.07 0.07 0.1 0.07   # ... or seconds per frame, one per frame
+  mode loop               # loop (default) | pingPong (or pingpong) | once (holds the last frame, sets og.Flipbook.finished)
+  event 2 "step"          # entering clip frame 2 sends og.FlipbookEvent "step" (at most 63 bytes)
+  event 6 "step"
+}
+```
+
+An **atlas** names a JSON exported beside the PNG: Aseprite's (Export
+Sprite Sheet, JSON hash or array: frames in the natural order of their
+names with their own durations, and each `frameTags` entry a clip, its
+direction `forward`, `reverse` or `pingpong`) or TexturePacker's (JSON
+hash or array, its pivots taken; rotated frames are refused). The tags'
+clips come first, in the atlas's order, then the sheet's own `clip`
+blocks; a clip the sheet declares wins over a tag of the same name (to
+give it `event` lines or another `mode`). `templates/archetypes/runner`'s
+`assets/sprites/courier.ogt` is a grid sheet with five clips.
+
 ### Tilesets, maps and Tiled: the grammar
 
 A **tileset** is an `.ogt` of `type tileset` beside its atlas PNG (give the
@@ -539,6 +597,8 @@ layer walls {
   opacity 1                # (default 1)
   visible true             # (default true)
   collision true           # its tiles' collision becomes static colliders (default false)
+  colliderLayers 4         # those colliders' og.Collider.layers bits (default: og.Tilemap.colliderLayers)
+  colliderMask 3           # the layers they collide with, og.Collider.mask bits (default: every layer)
   lit false                # the layer takes no 2D light (og.Lighting2D); default true: lit like a sprite in the lit range
   repeat x                 # x, y or both: tile the layer endlessly (a background)
   terrain wall             # a terrain layer: cells are 1 (filled) or 0, the terrain picks the tiles
@@ -571,6 +631,7 @@ cook reads of a layer and an object:
 |---|---|---|
 | `autotile` | tile layer custom property (string) | the layer is a terrain layer of that terrain of its tileset; any tile in a cell marks it filled, the terrain picks the drawn tile |
 | `collision` | tile layer custom property (bool) | the layer's tile collision becomes static colliders |
+| `colliderLayers`, `colliderMask` | tile layer custom properties (int) | the og.Collider `layers` and `mask` bits of that layer's colliders (default: og.Tilemap.colliderLayers, every layer) |
 | `lit` | tile layer custom property (bool) | false keeps the layer out of og.Lighting2D (a sky or window layer); default true |
 | `z` | tile layer custom property (int) | the sprite layer offset from og.Tilemap.layer (default: the layer's index among the tile layers) |
 | `repeatx`, `repeaty` | tile layer custom properties (bool), or Tiled's own layer fields | the layer repeats along x or y (`repeat` is not a name the cook reads) |
@@ -583,7 +644,7 @@ cook reads of a layer and an object:
 
 `og cook` warns on every custom property it does not read, naming the
 property, its layer, object or tile and the names read there: a tile
-layer's other than the six names above (or one whose value has another
+layer's other than the eight names above (or one whose value has another
 type: a `collision` written as the string "true"), a tile's other than
 `solid`, the map's, a group's, an object layer's or an image layer's own
 (none is imported), and an object's class-typed one (no text to give). A
@@ -945,10 +1006,14 @@ round false               # sprite mode: fade each particle to a round edge over
   speeds are in world units like a sprite's, and the particles take the
   sprite batch's order and glow like any sprite.
 - A one-shot effect (a hit, a pickup, landing dust) is `rate 0`,
-  `looping false`, one `burst 0 <count>` and a short `duration`; restart
-  it by writing the tick to its `og.ParticleSystem.startTick` (moving the
-  entity first). A lasting one (embers, motes, rain) keeps the defaults
-  `looping true` and a `rate`.
+  `looping false`, one `burst 0 <count>` and a short `duration`; fire
+  and restart it by writing the tick to its `og.ParticleSystem.startTick`
+  (moving the entity first). Spawn it in `start` without a `startTick`:
+  the default, `PARTICLES_ARMED`, means never written, so it waits
+  armed and emits nothing until its first use (write `PARTICLES_ARMED`
+  back to re-arm one without firing it). A lasting one (embers, motes,
+  rain) keeps the defaults `looping true` and a `rate`, and emits from
+  tick 0 without a `startTick`.
 - `sheet` animates a sprite sheet texture: `life 1` plays its frames once
   over each particle's life, `fps 12` at a rate, `random` one frame per
   particle. `array` does the same over a texture array's layers (§8), one
@@ -1139,6 +1204,17 @@ there. `world.set(e, og.Velocity, ...)` refuses on
 an entity without one (a body in `start`, before its first step):
 `world.insert` it there, which adds and sets it.
 
+`og.CollisionStarted` is read on the tick after the physics step. Its
+`normal` points from `a` to `b`; the bodies' `og.Velocity` already contains
+the solver's outgoing velocity, not their incoming impact velocity. Do
+not derive impact weight from those velocities: bodies may already be
+separating. There is no contact-time velocity or impulse on this event.
+For driven bodies, retain the velocity handed to physics in a component
+and read that cache before the next drive system overwrites it (as in
+`examples/rumpus-isle/src/critters.ts`). Project `velocityA - velocityB`
+onto the event normal for closing speed. This estimates linear approach
+speed, not contact-point speed from rotation or forces during the step.
+
 ```ts
 const hit = og.physics.raycast(world, { origin: eye, direction: { x: 0, y: 0, z: -1 }, maxDistance: 30, filter: { mask: 0b10, exclude: player } });
 if (hit.ok && hit.value) { /* hit.value.entity, distance, point, normal */ }
@@ -1170,7 +1246,7 @@ deterministic and part of snapshots (`reference/physics.md`):
 - `og.CharacterController` (3D, or top-down with `gravityScale` 0) — set
   `move` every tick and `jump` to jump; it climbs `maxSlope` and
   `stepHeight`, snaps to the ground, rides moving platforms, slides along
-  walls, pushes bodies; read `grounded`, `velocity`, `ground`. Its
+  walls, pushes dynamic bodies; read `grounded`, `velocity`, `ground`. Its
   og.Collider's `layers` and `mask` decide what blocks it, as for bodies
   (a ghost through a gate: leave the gate's layer out of its `mask`); the
   same for the PlatformerController.
@@ -1180,6 +1256,13 @@ deterministic and part of snapshots (`reference/physics.md`):
   `impulse` (m/s, taken once on the next step) knocks it back or launches
   it;
   `og.CharacterEvent` reports jumps and landings for dust and sounds.
+  Both controllers push the dynamic bodies they move into (`pushBodies`,
+  on by default) with at most `pushStrength` (1,000 N): the push is mass
+  times the speed asked of the body, capped, so mass tells. Give a crate
+  its `og.RigidBody.mass`: 2 kg is shoved at the run speed, 100 kg creeps,
+  a tonne on the ground holds (friction beats the push). Lower
+  `pushStrength` for a weak hero; `pushBodies: false` for a hero that
+  never shoves (a crate then blocks like a wall).
   `templates/archetypes/runner`'s courier is one.
 - `og.Vehicle` — a raycast car (3D, `throttle`, `steer`, `brake`; wheels
   from `og.physics.vehicleWheels`) or a car on wheel joints (2D). Its
@@ -1450,15 +1533,36 @@ to 64 KiB a key: a record in one key, the world in a slot
   its tick: restored, the next step completes that tick (the systems
   after the saver and the physics step), so a replay from it (the
   countdown's world restored, the taped inputs fed again) runs the saved
-  race tick for tick. Take it as the system's last write of the tick:
+  race tick for tick. The command channel's scheduled steps keep their
+  remaining delays across a restore (og.Time takes the saved tick), so a
+  playtest that taps Continue onto a save of a later tick, or an earlier
+  one, runs the rest of its script and ends at its last step or `quit`.
+  Take it as the system's last write of the tick:
   what the system does after the call is not in it. A saved type whose fields changed since (a
   release added one) is refused naming the type and fields; pass
   `{ migrate: true }` to map it by field name (new fields take their
   defaults), and keep a saved type's fields stable between releases where
   you can. Keep progress in components and resources, never in module
-  variables (they are not in the save), and keep request numbers and the
-  session's own state (a best score read from the store, an open menu)
-  where a restore cannot roll them back: reset them after it. Asset
+  variables (they are not in the save). Everything in the world rolls
+  back with it, request numbers and the session's own state (a best score
+  read from the store, the settings, an open menu) included, so reset
+  them after it: the tick after a restore delivers `og.WorldRestored`
+  (`from`, the tick the world was at; `tick`, the saved one). A system
+  that reads it (`reads: [og.WorldRestored]`, `world.events(og.WorldRestored)`)
+  forgets the request numbers, asks the store again and closes what the
+  player had open:
+
+  ```ts
+  if (world.events(og.WorldRestored).length > 0) {
+    g.progressRequest = 0;                           // answered long ago, in another session
+    const asked = og.platform.storeGet(world, "settings");
+    g.settingsRequest = asked.ok ? asked.value : 0;  // the language and volumes live on in the session
+  }
+  ```
+
+  It is sent as that tick starts, so the world between the restore and
+  that tick hashes as the save did; after a save taken mid-tick it comes
+  with the first whole tick after the completing step. Asset
   handles are saved as numbers: load in `start`, in the same order every
   launch.
 - **A record** (`storeSet(world, { key: "save", value: { chimes, glimmers,

package/knowledge/skills/og-i18n/SKILL.md

@@ -70,7 +70,9 @@ string "results.time" "タイム {time}"
 - Numbers, times and prices go through arguments, not string building.
 - og.ui's templates have words of their own (Retry, Share, "Best 1,200",
   "New best", Cancel, Settings, Buy, Skip, "1 of 3", a racing HUD's
-  "lap", "Best 1:36.233", Pause and Boost): each is a field of
+  "lap", "Best 1:36.233", Pause and Boost, the other HUDs' Jump, Fire,
+  "kills", "moves left", "Target 1,000", "Lv 3" and "+12/s"): each is a
+  field of
   the template's desc with the English default, so a localised game passes
   its table's: `ResultsDesc.bestLabel`, `newBestLabel`, `shareLabel`,
   `actions`; `ConfirmDesc.confirmLabel`, `cancelLabel`; `SettingsDesc.title`,
@@ -90,12 +92,19 @@ string "results.time" "タイム {time}"
   ("Best {best}", the best lap as m:ss.mmm), `pauseLabel` (the pause
   button's name), `boostLabel`, `brakeLabel`, `leftLabel`, `rightLabel`
   (the touch pedals and arrows) and `unit`, and its `splits`' labels
-  (`S1`) are the game's. `bestLabel: og.i18n.t(world, "results.best")`
+  (`S1`) are the game's; `PlatformerHudDesc.pauseLabel`, `jumpLabel`
+  (the touch Jump); `ShooterHudDesc.killsLabel` (after the count),
+  `fireLabel`, `pauseLabel`; `PuzzleHudDesc.movesLabel` (under the moves
+  left), `targetLabel` ("Target {target}"), `pauseLabel`;
+  `IdleHudDesc.tapLabel`, `levelLabel` ("Lv {level}", a generator's
+  badge), `rateLabel` ("+{rate}/s"), `pauseLabel`. Names, levels,
+  weapons, currencies and a map's label are the game's data, from its
+  table too. `bestLabel: og.i18n.t(world, "results.best")`
   with `"Best {best}"` / `"最佳 {best}"` in the tables (the template fills
   `{best}`, formatted); `stepLabel` the same with `"{step} of {count}"` /
   `"第 {step} 步，共 {count} 步"`. templates/ui-kit passes every one of
   these words from its five tables (`settings.*`, `shop.*`, `inventory.*`,
-  `leaderboard.*`, `tutorial.*`, `cutscene.*`).
+  `leaderboard.*`, `tutorial.*`, `cutscene.*`, the HUDs' `hud.*`).
 - Emphasis inside a sentence is rich-text markup in the message itself
   (`"Your progress in slot [b]{slot}[/b] will be lost."`, shown with
   `og.ui.richText`): each translation bolds or colours its own words, in

package/knowledge/skills/og-platform-sdk/SKILL.md

@@ -61,7 +61,9 @@ if (answer.ok && typeof answer.data.value === "number") run.best[i] = Math.max(r
 - Answers are host input, like key presses: a replay records them, so the
   same answers give the same world.
 - Every answer carries `time` (UTC ms): the host's clock when it was
-  answered. `og.platform.now(world)` is the host's clock at the last
+  answered (a `saveSlot` or `loadSlot` answer, the time of the store
+  answer that ended it, so a slot's load is as good a clock as a
+  `storeGet`). `og.platform.now(world)` is the host's clock at the last
   answer (or when the platform attached) advanced by the ticks since, so
   it is the one wall clock a game may read: the time away is a store
   answer's `time` less the time the save wrote down