@antprofuse/saddle-skill 0.1.2 → 0.2.0-rc.19

package/scripts/validate-identity-closure.py

@@ -0,0 +1,137 @@
+#!/usr/bin/env python3
+"""Fail closed unless every packaged Skill identity comes from one closure."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+import sys
+from pathlib import Path
+
+
+def digest(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def exactly(pattern: str, text: str, label: str) -> str:
+    values = re.findall(pattern, text, flags=re.MULTILINE)
+    if len(values) != 1:
+        raise SystemExit(f"identity closure invalid: {label} count={len(values)}")
+    return values[0]
+
+
+def main() -> None:
+    if len(sys.argv) != 2:
+        raise SystemExit("usage: validate-identity-closure.py <skill-directory>")
+    skill = Path(sys.argv[1]).resolve()
+    manifest = json.loads((skill / "package-manifest.json").read_text(encoding="utf-8"))
+    closure_path = skill / manifest["identity_closure"]["path"]
+    closure = json.loads(closure_path.read_text(encoding="utf-8"))
+    if closure.get("schema") != "saddle-skill-identity-closure/2":
+        raise SystemExit("identity closure invalid: schema")
+    if digest(closure_path) != manifest["identity_closure"]["sha256"]:
+        raise SystemExit("identity closure invalid: closure digest")
+
+    source = closure["artifact_source_commit"]
+    snapshot = skill / "references/public-api.snapshot"
+    boundary = skill / "references/api-boundary.md"
+    machine_doc = skill / "references/machine-schema.md"
+    validator = skill / "scripts/validate-machine-input.sh"
+    observed = {
+        "manifest": manifest["rust"]["source_commit"],
+        "snapshot": exactly(r"^source_commit=([0-9a-f]{40})$", snapshot.read_text(), "snapshot source"),
+        "boundary": exactly(r"Facade source `([0-9a-f]{40})`", boundary.read_text(), "boundary source"),
+        "validator": exactly(r"rust_facade_source=([0-9a-f]{40})", validator.read_text(), "validator source"),
+    }
+    if set(observed.values()) != {source}:
+        raise SystemExit(f"identity closure invalid: source drift {observed}")
+    registry_source = closure.get("registry_artifact_source_commit")
+    if not re.fullmatch(r"[0-9a-f]{40}", registry_source or "") or registry_source != source:
+        raise SystemExit("identity closure invalid: registry/source identity mismatch")
+    if manifest.get("release_approval") is not False or manifest.get("publish") is not False:
+        raise SystemExit("identity closure invalid: incompatible registry candidate must remain unpublished")
+    documented_schema = exactly(
+        r"machine：`(saddle-approved-build/[0-9]+)`", machine_doc.read_text(), "machine schema"
+    )
+    if {documented_schema, manifest["skill"]["machine_schema"], closure["machine_schema"]} != {"saddle-approved-build/2"}:
+        raise SystemExit("identity closure invalid: machine schema drift")
+    if digest(snapshot) != closure["public_api_snapshot_sha256"]:
+        raise SystemExit("identity closure invalid: snapshot digest")
+    if digest(machine_doc) != closure["machine_schema_document_sha256"]:
+        raise SystemExit("identity closure invalid: machine schema digest")
+    if manifest["rust"]["public_api_snapshot_sha256"] != closure["public_api_snapshot_sha256"]:
+        raise SystemExit("identity closure invalid: manifest snapshot digest")
+    expected_locks = {"registry_consumer": digest(skill / "assets/registry-consumer/Cargo.lock")}
+    if manifest["consumer_evidence"]["approved_locks"] != expected_locks or closure["approved_locks"] != expected_locks:
+        raise SystemExit("identity closure invalid: approved locks")
+    template_root = skill / "assets/registry-consumer"
+    template_inputs = {
+        "cargo_lock": template_root / "Cargo.lock",
+        "cargo_manifest": template_root / "Cargo.toml",
+        "library": template_root / "src/lib.rs",
+        "generated_owner": template_root / "src/generated_artifact.rs",
+        "external_consumer_test": template_root / "tests/provider_consumer.rs",
+        "output_validator": skill / "scripts/validate-generated-project.sh",
+        "preflight_validator": skill / "scripts/validate-generated-preflight.sh",
+    }
+    observed_template = {name: digest(path) for name, path in template_inputs.items()}
+    template_identity = hashlib.sha256(
+        json.dumps(observed_template, separators=(",", ":")).encode()
+    ).hexdigest()
+    if closure.get("registry_consumer_template") != observed_template:
+        raise SystemExit("identity closure invalid: registry consumer template")
+    if manifest["consumer_evidence"].get("registry_consumer_template") != observed_template:
+        raise SystemExit("identity closure invalid: manifest registry consumer template")
+    if closure.get("template_identity_sha256") != template_identity or manifest["generated_static_facts"].get("template_identity_sha256") != template_identity:
+        raise SystemExit("identity closure invalid: template identity")
+    if manifest["generated_static_facts"].get("application_machine_fingerprint") != "NOT_GENERATED_SK_02":
+        raise SystemExit("identity closure invalid: SK-02 fabricated application fingerprint")
+    if manifest["consumer_evidence"].get("unified_application_sha256") != observed_template["library"] or closure.get("unified_application_sha256") != observed_template["library"]:
+        raise SystemExit("identity closure invalid: unified application")
+    if manifest["consumer_evidence"].get("unified_owner_sha256") != observed_template["generated_owner"] or closure.get("unified_owner_sha256") != observed_template["generated_owner"]:
+        raise SystemExit("identity closure invalid: unified owner")
+    if manifest.get("gate_identity") != closure.get("gate_identity"):
+        raise SystemExit("identity closure invalid: Gate identity")
+    gate = closure.get("gate_identity", {})
+    if not re.fullmatch(r"[0-9a-f]{40}", gate.get("d1_source_candidate", "")):
+        raise SystemExit("identity closure invalid: D1 source candidate")
+    for name, value in gate.items():
+        if name != "d1_source_candidate" and not re.fullmatch(r"[0-9a-f]{64}", value):
+            raise SystemExit(f"identity closure invalid: Gate digest {name}")
+    for field in (
+        "registry_artifact_source_commit",
+        "rust_candidate_manifest_sha256",
+        "registry_packages_sha256",
+        "framework_crate_sha256",
+        "fresh_registry_cargo_lock_sha256",
+        "registry_consumer_cargo_lock_sha256",
+    ):
+        if manifest["identity_closure"][field] != closure[field]:
+            raise SystemExit(f"identity closure invalid: {field}")
+    expected_packages = {
+        "saddle-core", "saddle-macros", "saddle-admission", "saddle-observability", "saddle-runtime",
+        "saddle-db", "saddle-service", "saddle-framework",
+    }
+    if set(closure.get("registry_packages_sha256", {})) != expected_packages:
+        raise SystemExit("identity closure invalid: registry package set")
+    if any(not re.fullmatch(r"[0-9a-f]{64}", value) for value in closure["registry_packages_sha256"].values()):
+        raise SystemExit("identity closure invalid: registry package digest")
+    if manifest["npm"]["version"] != "0.2.0-rc.19" or closure.get("skill_release") != "0.2.0-rc.19":
+        raise SystemExit("identity closure invalid: Skill candidate version")
+    if manifest["rust"]["requirement"] != "=0.2.0-rc.19" or closure.get("rust_release") != "0.2.0-rc.19":
+        raise SystemExit("identity closure invalid: Rust RC version")
+    installation = manifest.get("installation", {})
+    if installation != {
+        "kind": "npm-tgz",
+        "command": "npm install --ignore-scripts --no-audit --no-fund <exact-tgz>",
+        "skill_root": "node_modules/@antprofuse/saddle-skill",
+        "entry": "SKILL.md",
+        "lifecycle_scripts": False,
+    }:
+        raise SystemExit("identity closure invalid: installation entry")
+    print("saddle-skill-identity-closure/2: valid")
+
+
+if __name__ == "__main__":
+    main()

package/scripts/validate-machine-input.sh

@@ -0,0 +1,48 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+if [[ $# -ne 1 || ! -f "$1" ]]; then
+  echo "usage: validate-machine-input.sh <machine-input>" >&2
+  exit 64
+fi
+input=$1
+expected_keys=(
+  schema status release_approval declaration_schema skill_package rust_facade
+  rust_facade_source rust_compatibility rust_abi_frozen public_api public_api_snapshot
+  generated_static_schema generator_handoff build_internal runtime_profile
+  signed_production_bundle final_calibration baseline declaration_sha256
+  public_api_snapshot_sha256 skill_sha256 package_manifest_sha256 machine_schema_sha256
+  api_consumer_lock_sha256 unified_consumer_lock_sha256
+  query_db_compile_fail_lock_sha256 raw_signal_compile_fail_lock_sha256
+  generated_application_sha256 unified_owner_sha256 unified_machine_fingerprint
+  rustc_commit contract_validation unified_consumer_validation
+  public_api_snapshot_validation generated_static_validation migration_compile_fail
+  npm_pack_dry_run
+)
+actual_keys_file="$(mktemp)"
+expected_keys_file="$(mktemp)"
+trap 'rm -f "$actual_keys_file" "$expected_keys_file"' EXIT
+awk -F= 'NF < 2 || $1 !~ /^[a-z][a-z0-9_]*$/ { exit 2 } { print $1 }' "$input" |
+  LC_ALL=C sort >"$actual_keys_file" || {
+    echo "invalid machine key/value syntax" >&2
+    exit 1
+  }
+printf '%s\n' "${expected_keys[@]}" | LC_ALL=C sort >"$expected_keys_file"
+if [[ "$(uniq -d "$actual_keys_file" | wc -l)" -ne 0 ]] ||
+  ! diff -u "$expected_keys_file" "$actual_keys_file"; then
+  echo "unknown, duplicate, or missing machine field" >&2
+  exit 1
+fi
+grep -Fxq 'schema=saddle-approved-build/2' "$input"
+grep -Fxq 'status=rc-blackbox-candidate-unpublished' "$input"
+grep -Fxq 'release_approval=false' "$input"
+grep -Fxq 'rust_facade_source=669162c8730e33eaf8ffc246936c3eaa216d530c' "$input"
+grep -Fxq 'generated_static_schema=saddle-generated-static-facts/2' "$input"
+grep -Fxq 'runtime_profile=opaque-verified-startup-plan-layout' "$input"
+grep -Fxq 'signed_production_bundle=deployment-required' "$input"
+grep -Fxq 'final_calibration=deployment-required' "$input"
+if grep -Eq '(^|_)(capacity_profile|capacity_domain|task_storage|deadline_ms)=' "$input"; then
+  echo "generated machine input contains a deployment-owned field" >&2
+  exit 1
+fi
+echo "saddle-approved-build/2 machine input: rc-blackbox-candidate-unpublished"

package/scripts/validate-managed-objects-peak.py

@@ -0,0 +1,147 @@
+#!/usr/bin/env python3
+"""Validate canonical Saddle generated managed-object peak machine facts."""
+
+from __future__ import annotations
+
+import re
+import sys
+from pathlib import Path
+
+U64_MAX = (1 << 64) - 1
+BASE_KEYS = {
+    "schema",
+    "target_pointer_width",
+    "runtime_profile_sha256",
+    "max_active_requests",
+    "max_waiters",
+    "waiter_managed_objects_peak",
+    "route_count",
+    "max_route_managed_objects_peak",
+    "managed_objects_peak",
+    "derivation",
+}
+ROUTE_FIELDS = {
+    "path",
+    "artifact_sha256",
+    "request_body_owners",
+    "response_reservation_owners",
+    "other_managed_owners",
+    "managed_objects_peak",
+}
+ROUTE_KEY = re.compile(r"route\.(\d+)\.([a-z][a-z0-9_]*)\Z")
+
+
+def fail(message: str) -> None:
+    raise ValueError(message)
+
+
+def checked(value: int, label: str) -> int:
+    if value < 0 or value > U64_MAX:
+        fail(f"{label} exceeds target usize")
+    return value
+
+
+def number(values: dict[str, str], key: str) -> int:
+    text = values[key]
+    if not re.fullmatch(r"0|[1-9][0-9]*", text):
+        fail(f"{key} is not canonical unsigned decimal")
+    return checked(int(text), key)
+
+
+def validate(path: Path) -> None:
+    values: dict[str, str] = {}
+    routes: dict[int, dict[str, str]] = {}
+    for line_number, raw in enumerate(path.read_text(encoding="utf-8").splitlines(), 1):
+        if not raw or "=" not in raw:
+            fail(f"line {line_number} is not canonical key=value")
+        key, value = raw.split("=", 1)
+        if key in values:
+            fail(f"duplicate field: {key}")
+        match = ROUTE_KEY.fullmatch(key)
+        if match:
+            index = int(match.group(1))
+            field = match.group(2)
+            if field not in ROUTE_FIELDS:
+                fail(f"unknown route field: {key}")
+            route = routes.setdefault(index, {})
+            if field in route:
+                fail(f"duplicate route field: {key}")
+            route[field] = value
+        elif key not in BASE_KEYS:
+            fail(f"unknown field: {key}")
+        values[key] = value
+
+    missing_base = BASE_KEYS - values.keys()
+    if missing_base:
+        fail(f"missing fields: {','.join(sorted(missing_base))}")
+    if values["schema"] != "saddle-managed-objects-peak/1":
+        fail("unsupported managed-object peak schema")
+    if values["target_pointer_width"] != "64":
+        fail("only the approved 64-bit target is supported")
+    if values["derivation"] != "checked(active*max_route+waiters*waiter)":
+        fail("unexpected derivation")
+
+    route_count = number(values, "route_count")
+    if route_count == 0 or set(routes) != set(range(route_count)):
+        fail("route set is missing, sparse, or contains an unexpected route")
+
+    route_peaks: list[int] = []
+    paths: set[str] = set()
+    for index in range(route_count):
+        route = routes[index]
+        missing = ROUTE_FIELDS - route.keys()
+        if missing:
+            fail(f"route.{index} missing fields: {','.join(sorted(missing))}")
+        if not route["path"].startswith("/") or route["path"] in paths:
+            fail(f"route.{index}.path is invalid or duplicated")
+        paths.add(route["path"])
+        if not re.fullmatch(r"[0-9a-f]{64}", route["artifact_sha256"]):
+            fail(f"route.{index}.artifact_sha256 is not SHA-256")
+
+        components = []
+        for field in (
+            "request_body_owners",
+            "response_reservation_owners",
+            "other_managed_owners",
+        ):
+            components.append(
+                number(values, f"route.{index}.{field}")
+            )
+        if components != [1, 1, 0]:
+            fail(f"route.{index} is not the generated linear owner shape")
+        peak = number(values, f"route.{index}.managed_objects_peak")
+        if checked(sum(components), f"route.{index} component sum") != peak:
+            fail(f"route.{index} peak drifted from its owner components")
+        route_peaks.append(peak)
+
+    maximum = max(route_peaks)
+    if number(values, "max_route_managed_objects_peak") != maximum:
+        fail("max route peak drifted")
+
+    active = number(values, "max_active_requests")
+    waiters = number(values, "max_waiters")
+    waiter_peak = number(values, "waiter_managed_objects_peak")
+    if waiter_peak != 0:
+        fail("pre-admission waiters cannot own generated route objects")
+    active_total = checked(active * maximum, "active managed-object product")
+    waiter_total = checked(waiters * waiter_peak, "waiter managed-object product")
+    total = checked(active_total + waiter_total, "managed-object total")
+    if number(values, "managed_objects_peak") != total:
+        fail("managed_objects_peak drifted from checked derivation")
+
+
+def main() -> int:
+    if len(sys.argv) != 2:
+        print("usage: validate-managed-objects-peak.py <machine-facts>", file=sys.stderr)
+        return 64
+    try:
+        validate(Path(sys.argv[1]))
+    except (OSError, ValueError) as error:
+        print(f"managed-object peak invalid: {error}", file=sys.stderr)
+        return 1
+    print("saddle-managed-objects-peak/1: valid")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/LICENSE-APACHE

@@ -1,203 +0,0 @@
-
-                                 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/LICENSE-MIT

@@ -1,22 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Saddle contributors
-
-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.
-