@synopackageland/templates 0.9.9 → 0.10.0

package/templates/native-rust-jobs/backend/src/jobs.rs

@@ -0,0 +1,240 @@
+//! Background jobs: hash a NAS file the caller may read.
+//!
+//! The SDK's worker runs each job as the package account: it hashes the job's
+//! input (SHA-256) and keeps the result for the job's owner, the caller. The
+//! runtime serves files.read with the caller's DSM session and bg.* for the
+//! caller's own jobs only.
+
+use crate::routes::{Config, internal};
+use serde::Deserialize;
+use serde_json::{Value, json};
+use std::os::unix::fs::DirBuilderExt;
+use std::path::{Path, PathBuf};
+use syno_pkg_land_app::{App, Context, Error, Params};
+
+/// A job's input is at most 512 KiB, copied into the job when it is submitted.
+const MAX_INPUT: u64 = 512 * 1024;
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields)]
+struct Submit {
+    key: String,
+    path: String,
+}
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields)]
+struct JobId {
+    id: String,
+}
+
+#[derive(Deserialize)]
+struct Read {
+    path: PathBuf,
+    size: u64,
+}
+
+pub fn register(app: &mut App, cfg: &Config) {
+    let cfg = cfg.clone();
+    app.method("hash.submit", move |ctx, params| submit(&cfg, ctx, params));
+    app.method("hash.get", |ctx, params| job(ctx, "bg.get", params));
+    app.method("hash.cancel", |ctx, params| job(ctx, "bg.cancel", params));
+}
+
+fn job(ctx: &Context, op: &str, params: &Params) -> Result<Value, Error> {
+    let JobId { id } = params.decode()?;
+    ctx.runtime(op, &json!({"id": id}))
+}
+
+fn submit(cfg: &Config, ctx: &Context, params: &Params) -> Result<Value, Error> {
+    let p: Submit = params.decode()?;
+    let read: Read = ctx.runtime("files.read", &json!({"path": p.path}))?;
+    if read.size > MAX_INPUT {
+        return Err(Error::new(
+            "limit_exceeded",
+            "The file is larger than allowed.",
+        ));
+    }
+    // bg.submit takes its input from the data directory; the call's spool is elsewhere.
+    let inputs = cfg.data_dir.join("hash-inputs");
+    std::fs::DirBuilder::new()
+        .recursive(true)
+        .mode(0o700)
+        .create(&inputs)
+        .map_err(internal)?;
+    let copy = inputs.join(&ctx.request_id);
+    std::fs::copy(&read.path, &copy).map_err(internal)?;
+    let name = Path::new(&p.path)
+        .file_name()
+        .map_or(String::new(), |n| n.to_string_lossy().into_owned());
+    let submitted = ctx.runtime(
+        "bg.submit",
+        &json!({"key": p.key, "name": name, "input": copy}),
+    );
+    let _ = std::fs::remove_file(&copy);
+    submitted
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test_support::{Services, TempDir, call};
+    use serde_json::{Value, json};
+    use std::sync::{Arc, Mutex};
+
+    /// What bg.submit was asked: its params and the input it read.
+    type Submitted = Arc<Mutex<Vec<(Value, Vec<u8>)>>>;
+
+    fn setup() -> (TempDir, Config) {
+        let dir = TempDir::new();
+        let cfg = Config {
+            package: "ExampleApp".into(),
+            data_dir: dir.path().join("var"),
+            packages_root: dir.path().into(),
+        };
+        std::fs::create_dir(&cfg.data_dir).unwrap();
+        (dir, cfg)
+    }
+
+    fn job() -> Value {
+        json!({"job": {"id": "j1", "state": "queued"}, "duplicate": false})
+    }
+
+    /// files.read answers a spool file with content; bg.submit records its params and the input it read.
+    fn services(dir: &TempDir, content: Vec<u8>, submitted: &Submitted) -> Services {
+        let spool = dir.path().join("spool");
+        std::fs::write(&spool, &content).unwrap();
+        let read = json!({"path": spool, "size": content.len()});
+        let submitted = submitted.clone();
+        [
+            (
+                "files.read",
+                Box::new(move |_: &Value| Ok(read.clone())) as _,
+            ),
+            (
+                "bg.submit",
+                Box::new(move |p: &Value| {
+                    // The runtime reads the input file while it answers bg.submit.
+                    let input = std::fs::read(p["input"].as_str().unwrap()).unwrap();
+                    submitted.lock().unwrap().push((p.clone(), input));
+                    Ok(job())
+                }) as _,
+            ),
+        ]
+        .into()
+    }
+
+    #[test]
+    fn submit_hashes_a_copy_of_the_callers_file() {
+        let (dir, cfg) = setup();
+        let submitted = Arc::new(Mutex::new(Vec::new()));
+        let services = services(&dir, b"hello".to_vec(), &submitted);
+        let reply = call(
+            crate::routes::build(cfg.clone()),
+            "hash.submit",
+            json!({"key": "k1", "path": "/home/report.txt"}),
+            "alice",
+            &services,
+        );
+        assert_eq!(reply.data, job());
+        let ops: Vec<_> = reply.services.iter().map(|(op, _)| op.as_str()).collect();
+        assert_eq!(ops, ["files.read", "bg.submit"]);
+        assert_eq!(reply.services[0].1, json!({"path": "/home/report.txt"}));
+        let submitted = submitted.lock().unwrap();
+        let (params, content) = &submitted[0];
+        assert_eq!(
+            (&params["key"], &params["name"], content.as_slice()),
+            (&json!("k1"), &json!("report.txt"), b"hello".as_slice())
+        );
+        let input = params["input"].as_str().unwrap();
+        assert!(input.starts_with(cfg.data_dir.to_str().unwrap()), "{input}");
+        assert!(
+            !std::path::Path::new(input).exists(),
+            "the copy is removed once submitted"
+        );
+    }
+
+    #[test]
+    fn submit_refuses_a_file_over_the_job_input_limit() {
+        let (dir, cfg) = setup();
+        let submitted = Arc::new(Mutex::new(Vec::new()));
+        let services = services(&dir, vec![0; MAX_INPUT as usize + 1], &submitted);
+        let reply = call(
+            crate::routes::build(cfg),
+            "hash.submit",
+            json!({"key": "k1", "path": "/home/big.bin"}),
+            "alice",
+            &services,
+        );
+        assert_eq!(reply.code(), "limit_exceeded");
+        assert!(submitted.lock().unwrap().is_empty());
+    }
+
+    #[test]
+    fn submit_passes_on_the_runtimes_refusal() {
+        let (_dir, cfg) = setup();
+        let services: Services = [(
+            "files.read",
+            Box::new(|_: &Value| Err(Error::new("read_failed", "Unable to read the file."))) as _,
+        )]
+        .into();
+        let reply = call(
+            crate::routes::build(cfg),
+            "hash.submit",
+            json!({"key": "k1", "path": "/home/a"}),
+            "alice",
+            &services,
+        );
+        assert_eq!(reply.code(), "read_failed");
+    }
+
+    #[test]
+    fn submit_refuses_invalid_params_before_any_service() {
+        let (_dir, cfg) = setup();
+        for params in [
+            Value::Null,
+            json!({"key": "k1"}),
+            json!({"key": 1, "path": "/home/a"}),
+            json!({"key": "k1", "path": "/home/a", "x": 1}),
+        ] {
+            let reply = call(
+                crate::routes::build(cfg.clone()),
+                "hash.submit",
+                params.clone(),
+                "alice",
+                &Services::new(),
+            );
+            assert_eq!(
+                (reply.code(), reply.services.len()),
+                ("bad_request", 0),
+                "{params}"
+            );
+        }
+    }
+
+    #[test]
+    fn get_and_cancel_act_on_the_callers_job() {
+        let (_dir, cfg) = setup();
+        for (method, op) in [("hash.get", "bg.get"), ("hash.cancel", "bg.cancel")] {
+            let services: Services =
+                [(op, Box::new(|_: &Value| Ok(job()["job"].clone())) as _)].into();
+            let reply = call(
+                crate::routes::build(cfg.clone()),
+                method,
+                json!({"id": "j1"}),
+                "alice",
+                &services,
+            );
+            assert_eq!(reply.data, job()["job"]);
+            assert_eq!(reply.services, vec![(op.to_string(), json!({"id": "j1"}))]);
+            let reply = call(
+                crate::routes::build(cfg.clone()),
+                method,
+                json!({}),
+                "alice",
+                &Services::new(),
+            );
+            assert_eq!(reply.code(), "bad_request");
+        }
+    }
+}

package/templates/native-rust-root-ops/backend/src/root_ops.rs

@@ -0,0 +1,83 @@
+//! Root operations: run `whoami`, a program the package ships in root/ and
+//! dsm-package.yaml approves, as root through the executor. The runtime
+//! serves root.run only when the executor has the program's grant.
+
+use crate::routes::Config;
+use serde::Deserialize;
+use serde_json::Value;
+use syno_pkg_land_app::App;
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields)]
+struct NoParams {}
+
+pub fn register(app: &mut App, _cfg: &Config) {
+    app.method("whoami.run", |ctx, params| {
+        params.decode::<Option<NoParams>>()?;
+        ctx.runtime::<Value>("root.run", &serde_json::json!({"name": "whoami"}))
+    });
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::routes::{Config, build};
+    use crate::test_support::{Services, call};
+    use serde_json::{Value, json};
+    use syno_pkg_land_app::Error;
+
+    fn cfg() -> Config {
+        Config {
+            package: "ExampleApp".into(),
+            data_dir: "/nonexistent".into(),
+            packages_root: "/nonexistent".into(),
+        }
+    }
+
+    #[test]
+    fn whoami_runs_the_approved_root_program() {
+        let output = json!({"exit_code": 0, "stdout": "0\n", "stderr": ""});
+        for params in [Value::Null, json!({})] {
+            let answer = output.clone();
+            let services: Services = [(
+                "root.run",
+                Box::new(move |_: &Value| Ok(answer.clone())) as _,
+            )]
+            .into();
+            let reply = call(build(cfg()), "whoami.run", params, "admin", &services);
+            assert_eq!(reply.data, output);
+            assert_eq!(
+                reply.services,
+                vec![("root.run".to_string(), json!({"name": "whoami"}))]
+            );
+        }
+    }
+
+    #[test]
+    fn whoami_passes_on_the_executors_refusal() {
+        let services: Services = [(
+            "root.run",
+            Box::new(|_: &Value| Err(Error::new("EXECUTOR_PAUSED", "The executor is paused.")))
+                as _,
+        )]
+        .into();
+        assert_eq!(
+            call(build(cfg()), "whoami.run", json!({}), "admin", &services).code(),
+            "EXECUTOR_PAUSED"
+        );
+    }
+
+    #[test]
+    fn whoami_takes_no_params() {
+        assert_eq!(
+            call(
+                build(cfg()),
+                "whoami.run",
+                json!({"name": "other"}),
+                "admin",
+                &Services::new()
+            )
+            .code(),
+            "bad_request"
+        );
+    }
+}

package/templates/native-rust-vue/README.md

@@ -1,10 +1,10 @@
 # Native Rust with Vue
 
-Edit `frontend/src/App.vue` and `main.ts` to build a DSM-window app with the
-public `@synopackageland/ui` components and embedded theme. The shell, sign-in,
-files, portal, jobs and delegate components come from `@synopackageland/sdk/vue`
-(types from `@synopackageland/sdk`); its version must equal the
-`syno-pkg-land-sdk` tag in `backend/Cargo.toml`. See
+The Vue shell is the same as the Go template's. Edit `frontend/src/App.vue`
+and `main.ts` to build a DSM-window app with the public `@synopackageland/ui`
+components and embedded theme. The shell, sign-in, files, portal, jobs and
+delegate components come from `@synopackageland/sdk/vue` (types from
+`@synopackageland/sdk`); its version must equal the `syno-pkg-land-app` tag in backend/Cargo.toml. See
 <https://github.com/synopackageland/syno-pkg-land-sdk> for the components and their props.
 
 ```sh
@@ -15,41 +15,42 @@ npm run build
 ```
 
 The base app reads package status and edits the package greeting through
-`ctx.call`. Each window has its own Vue mount, request state and host
-subscriptions; unmount disposes subscriptions and ignores late responses.
+`ctx.call`. Errors show the app's own `frontend/src/i18n` text, or the SDK's
+`bridgeErrorCopy` for the codes the bridge runtime adds (`app_unavailable`
+and the services' refusals). Each window has its own Vue mount, request state
+and host subscriptions; unmount disposes subscriptions and ignores late responses.
 
-`--with root-ops` adds the existing DSM approval gate for fixed `root/*.sh`
-operations. `--with jobs` adds package-account jobs and schedules; it combines with root-ops and files. `--with files` enables current-session File Station access,
-and the background picker uses the retained session provider.
-
-With `portal:` declared (`synopkgland add portal`, executor Apps only), the status page shows
-the SDK's `PortalSettings`: the DSM Application Portal link, the alias form
-for administrators, and the Control Panel shortcut.
-
-Use public library controls, the embedded theme, per-app modal scope and unique
-Vue ID prefixes. Backend route permissions and DSM checks remain authoritative.
-Generated build and unit tests do not establish NAS runtime acceptance.
-
-The manifest is dsm-package.yaml schema 2: backend.kind: rust and capabilities.files: session, jobs: true, identity: standalone, rootOps: true. Use --with login to declare standalone identity. Existing projects use synopkgland add <cap>...; app entrypoints stay app-owned, SDK conflicts are refused. check, inspect, build, deploy and status accept --json.
+The `--with jobs`, `root-ops` and `delegate` examples add their methods to
+the Rust App; the shell's panels call them with `ctx.call`. The SDK's
+background-jobs page and executor settings call the runtime's own browser
+methods (`bg.*`, `executor.*`); check the SDK release notes for the ones a
+bridge App's runtime serves.
 
 Use the installed `@synopackageland/ui`; package.json pins its version.
-`AppRoot` defaults to app modal scope and stays bounded at `height: 100%`;
-`AppLayout wide-layout="window"` keeps the DSM shell in window mode even when
-maximized. Only whole-page web/Portal apps should opt into document scope or
-`wide-layout="web"`. The DSM host sets the 700px minimum window width.
-In a DSM window (`ctx.host.platform().host === 'dsm'`) `AppRoot` takes
+`App.vue` lays the shell out with the SDK's `AppShell` (`@synopackageland/sdk/vue`):
+`pages` from `shellPages`, the header buttons in `#actions` and the pages in its
+default slot. Given `ctx`, it follows the launch. In a DSM desktop window it
+keeps `wide-layout="window"`, even maximized; the DSM host sets the 700px
+minimum window width. A Portal or standalone launch owns the whole page
+(`ctx.fullPage`, from the generated window): `AppShell` takes
+`wide-layout="web"` (the SaaS layout at 1200px or wider, mobile on a phone) and
+a device-width viewport, undone at unmount, since DSM's page has no
+device-width viewport. Its full-page sidebar names the App with
+`ctx.displayName` and `ctx.appIcon` (without them the page title and icon) and
+shows the signed-in DSM account and its role from `ctx.user`. See the ui's
+`docs/adaptive-layout.md`.
+`AppShell`'s `app-root` wraps it in an app-local `AppRoot` (app modal scope, on
+a full page as well, bounded at `height: 100%`) with the UI locale from
+`locale`; do not add another `AppRoot`.
+In a DSM window (not a full page) that `AppRoot` takes
 `dialog-bounds="viewport"`, so Dialogs can be dragged out of the window, and
-its `activate` event calls `ctx.host.activateWindow()` to bring the window to
-the front. Elsewhere Dialogs stay inside the App.
+pressing one calls `ctx.host.activateWindow()` to bring the window to the
+front. Elsewhere Dialogs stay inside the App. A confirmed sign-in need sets
+`denied`: the `#denied` slot's `LoginPage` takes the place of the App's pages.
 Import `themes/dsm7-embedded.css` and assign each mount a unique
 `app.config.idPrefix` before mounting.
 
 Start with AGENTS.md, `synopkgland skill list` and `synopkgland skill path`.
-Read `synopkgland skill show ui-vue` for direct Vue component work and
-`synopkgland skill show ui-json` for optional declarative specs and their
-validate/render workflow. The existing host/backend lifecycle remains in place.
-
-For UI discovery, run `npx --no syno-pkg-land-ui catalog --json` and
+Read `synopkgland skill show ui-vue` for direct Vue component work. For UI
+discovery, run `npx --no syno-pkg-land-ui catalog --json` and
 `npx --no syno-pkg-land-ui describe Button --json` from the installed frontend.
-Read its prompt and exported Vue docs/types before choosing component APIs.
-Use `syno-pkg-land-ui` directly in npm scripts; keep AI guidance version-independent.

package/templates/native-rust/backend/THIRD_PARTY_NOTICES.txt

@@ -1,207 +0,0 @@
-Native Rust package build dependencies (crates linked into the backend binaries)
-
-syno-pkg-land-sdk v0.9.9 (MIT)
-
-MIT License
-
-Copyright (c) 2026 synopkgland
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-
-itoa v1.0.18 (MIT OR Apache-2.0; used under MIT)
-
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
-
-libc v0.2.190 (MIT OR Apache-2.0; used under MIT)
-
-Copyright (c) The Rust Project Developers
-
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
-
-memchr v2.8.3 (Unlicense OR MIT; used under MIT)
-
-The MIT License (MIT)
-
-Copyright (c) 2015 Andrew Gallant
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
-serde v1.0.229 (MIT OR Apache-2.0; used under MIT)
-
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
-
-serde_core v1.0.229 (MIT OR Apache-2.0; used under MIT)
-
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
-
-serde_json v1.0.154 (MIT OR Apache-2.0; used under MIT)
-
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
-
-zmij v1.0.23 (MIT)
-
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.