@endo-ui/license 1.0.0

package/LICENSE.md

@@ -0,0 +1,381 @@
+# EndoUI / @endo-ui Software License Agreement
+
+**Effective Date: August 10, 2026**
+
+This EndoUI / @endo-ui Software License Agreement (the **“Agreement”**) is entered into between **ECAP Software LLC**, doing business as ECAP Software (**“ECAP,” “we,” “us,” or “our”**), and the individual or legal entity that obtains, installs, accesses, or uses EndoUI (**“Licensee,” “you,” or “your”**).
+
+By installing, accessing, copying, downloading, or using EndoUI, you agree to be bound by this Agreement.
+
+If you are using EndoUI on behalf of a company, organization, governmental entity, or other legal entity, you represent and warrant that you have authority to bind that entity to this Agreement.
+
+If you do not agree to this Agreement, you may not install, access, copy, or use EndoUI.
+
+## 1. Definitions
+
+### 1.1 EndoUI
+
+**“EndoUI”** means ECAP's proprietary software library and related materials distributed under the names **EndoUI**, **Endo UI**, **Endo-UI**, or through packages within the **`@endo-ui` npm namespace**, including applicable source code, object code, compiled code, npm packages, UI components, development tools, documentation, examples, templates, updates, patches, modifications, and related materials distributed by ECAP.
+
+EndoUI is proprietary software and is **licensed, not sold**.
+
+### 1.2 Seat
+
+A **“Seat”** means authorization for one identified individual developer or other authorized individual to use EndoUI for software-development purposes.
+
+A Seat is assigned to a person, not to a particular computer or device.
+
+### 1.3 Major Version
+
+A **“Major Version”** means the first numeric component of an EndoUI semantic version.
+
+For example:
+
+- `1.0.0` is Major Version 1;
+- `1.7.4` is Major Version 1;
+- `2.0.0` is Major Version 2.
+
+### 1.4 Application
+
+An **“Application”** means software, a website, service, product, system, or other work developed by or for Licensee that incorporates or makes use of EndoUI.
+
+## 2. Ownership
+
+EndoUI and all intellectual-property rights in EndoUI are owned by ECAP or its licensors.
+
+Except for third-party materials expressly governed by separate license terms, ECAP retains all right, title, and interest in and to EndoUI, including all copyrights, patents, trade secrets, trademarks, proprietary rights, and other intellectual-property rights.
+
+No ownership rights in EndoUI are transferred to Licensee under this Agreement.
+
+Licensee retains ownership of its own Applications and original materials, excluding EndoUI and other ECAP-owned materials incorporated into them.
+
+## 3. License Grant
+
+Subject to:
+
+1. payment of all applicable fees;
+2. the license rights recorded or issued by ECAP; and
+3. Licensee's continued compliance with this Agreement,
+
+ECAP grants Licensee a limited, non-exclusive, non-transferable, non-sublicensable license to:
+
+a. install and use EndoUI by the number of authorized Seats purchased or otherwise granted by ECAP;
+
+b. use EndoUI to design, develop, test, build, maintain, and support Applications;
+
+c. incorporate EndoUI components into Applications;
+
+d. modify EndoUI configuration, styling, composition, and integration as reasonably necessary to create Licensee's Applications; and
+
+e. distribute Applications containing compiled, bundled, minified, transformed, or otherwise incorporated portions of EndoUI as permitted by this Agreement.
+
+Licensee receives only those rights expressly granted under this Agreement.
+
+## 4. Organizational Licensing
+
+Unless ECAP expressly agrees otherwise in writing, an EndoUI license is issued to the legal entity identified in the applicable order, invoice, purchase record, license record, subscription, agreement, or other transaction record.
+
+One organizational license may authorize multiple Seats.
+
+A license issued to one organization may not be shared with an unaffiliated legal entity.
+
+Affiliates, subsidiaries, parent companies, contractors, customers, or other third parties are not automatically covered unless expressly included in the applicable license or written agreement.
+
+## 5. Developer Seats
+
+Every individual who directly uses EndoUI for development must occupy an authorized Seat unless ECAP has granted that organization a license expressly providing unlimited users.
+
+Seats:
+
+- are assigned to individual users;
+- may not be concurrently shared among multiple individuals;
+- may be reassigned when personnel or responsibilities change;
+- may not exceed the quantity purchased or granted; and
+- are associated with Licensee's organizational license.
+
+A licensed developer may use EndoUI from multiple computers or devices as reasonably necessary for that individual's work.
+
+**Seats are not machine licenses.**
+
+A developer does not require additional Seats merely because that developer uses a workstation, laptop, remote development environment, virtual machine, development container, or similar secondary development environment.
+
+Automated CI/CD, build, testing, deployment, and hosting systems do not independently consume a Seat merely because EndoUI is processed by those systems.
+
+## 6. Contractors
+
+Licensee may permit a contractor to use EndoUI on Licensee's behalf only if:
+
+1. the contractor occupies an authorized Seat unless the applicable license provides unlimited Seats;
+2. the contractor uses EndoUI solely for work performed for Licensee;
+3. the contractor is subject to confidentiality and intellectual-property obligations consistent with this Agreement; and
+4. the contractor ceases using Licensee's EndoUI license when the authorized engagement ends.
+
+A contractor may not use Licensee's EndoUI license for unrelated customers or projects.
+
+## 7. Application Distribution Rights
+
+Subject to this Agreement, Licensee may distribute Applications developed using EndoUI to an unlimited number of application users or customers unless a separate written agreement states otherwise.
+
+Application end users do **not** require EndoUI developer Seats merely because they use an Application developed with EndoUI.
+
+Licensee may distribute production Application code containing EndoUI where EndoUI is compiled, bundled, minified, transformed, tree-shaken, packaged, or otherwise incorporated as part of the Application.
+
+Licensee may not intentionally distribute EndoUI in a manner designed to allow recipients to extract, reuse, or consume EndoUI as an independent development library.
+
+## 8. Major-Version Licensing
+
+EndoUI license rights are granted by Major Version.
+
+Authorization for Major Version 1 authorizes Licensee to use EndoUI releases within the `1.x.x` release family.
+
+For example, authorization for Major Version 1 includes:
+
+- `1.0.0`;
+- `1.1.0`;
+- `1.8.4`; and
+- other authorized `1.x.x` releases.
+
+It does **not** automatically authorize EndoUI `2.x.x`.
+
+Authorization for a subsequent Major Version may require an upgrade purchase, additional fees, a subscription entitlement, a partner entitlement, an enterprise agreement, or another authorization from ECAP.
+
+Unless otherwise stated in the applicable order or agreement, Licensee may continue using a Major Version for which it has received a perpetual license entitlement even after ECAP releases a newer Major Version.
+
+Release of a new Major Version does not revoke Licensee's rights to continue using an earlier Major Version for which Licensee retains a valid entitlement.
+
+## 9. Updates, Patches, and Minor Releases
+
+Authorization for a Major Version includes releases within that same major release family that ECAP makes available to Licensee.
+
+ECAP may provide bug fixes, patches, security updates, feature releases, compatibility updates, or other improvements.
+
+ECAP does not guarantee that maintenance, technical support, security fixes, dependency updates, or platform compatibility will continue indefinitely for older Major Versions unless a separate written agreement provides otherwise.
+
+## 10. Partner Licenses
+
+ECAP may issue special EndoUI licenses to authorized partners.
+
+A Partner License may include unlimited Seats, access to specified Major Versions, special pricing, development rights, demonstration rights, internal-use rights, or other benefits specified by ECAP.
+
+Partner status and Partner License rights remain subject to the applicable partnership agreement, program requirements, or written authorization from ECAP.
+
+Termination or expiration of a partnership may affect future partner entitlements as specified in the applicable agreement.
+
+## 11. Internal Licenses
+
+ECAP may issue Internal Licenses for its own employees, contractors, demonstrations, testing, development, CI/CD, internal systems, and other authorized business purposes.
+
+Internal Licenses may contain different Seat, expiration, or Major Version restrictions from commercial licenses.
+
+## 12. License Verification
+
+EndoUI may use technical measures to verify compliance with this Agreement.
+
+License verification may include verification of:
+
+- license validity;
+- license status;
+- licensed product;
+- organizational license;
+- authorized users;
+- purchased Seat quantities;
+- authorized Major Versions;
+- license entitlements;
+- suspension status;
+- expiration status where applicable; and
+- other licensing conditions.
+
+Licensee agrees not to intentionally disable, defeat, bypass, tamper with, circumvent, reverse, falsify, or interfere with EndoUI's license-verification mechanisms.
+
+ECAP may use reasonable cached authorization, signed authorization, offline authorization, grace periods, periodic revalidation, or similar mechanisms to reduce unnecessary disruption caused by temporary connectivity failures.
+
+License verification does not authorize ECAP to inspect unrelated proprietary Application source code or customer content.
+
+## 13. Restrictions
+
+Except as expressly permitted by this Agreement, Licensee may not:
+
+1. sell, rent, lease, sublicense, publish, distribute, or otherwise make EndoUI available as a standalone library, package, SDK, component collection, development toolkit, or similar product;
+2. redistribute a package within the `@endo-ui` namespace for independent use by another party;
+3. create and distribute a materially equivalent repackaging of EndoUI intended to substitute for EndoUI itself;
+4. provide EndoUI to another organization for that organization's independent development use;
+5. share license credentials or Seats for the purpose of exceeding authorized Seat limits;
+6. use a license issued to another organization without ECAP's authorization;
+7. use an EndoUI Major Version for which Licensee does not hold the required entitlement;
+8. remove, obscure, conceal, or alter proprietary, copyright, trademark, attribution, or license notices contained in EndoUI;
+9. circumvent or interfere with technical licensing controls;
+10. represent EndoUI as software owned or authored by Licensee;
+11. publish ECAP confidential source code except as expressly permitted by this Agreement; or
+12. use EndoUI in violation of applicable law.
+
+Nothing in this Agreement prohibits Licensee from independently developing software that does not unlawfully copy, disclose, or misuse EndoUI or ECAP Confidential Information.
+
+## 14. Competing Development Products
+
+Without ECAP's prior written authorization, Licensee may not use EndoUI source code or substantial portions of EndoUI to create or distribute a standalone reusable UI component library, SDK, framework, or development product whose primary purpose is to replace or directly compete with EndoUI.
+
+This restriction does not prohibit Licensee from developing ordinary Applications, design systems, internal component abstractions, or application-specific UI components using EndoUI as permitted under this Agreement.
+
+## 15. Third-Party Software
+
+EndoUI may include, depend upon, or interoperate with third-party software.
+
+Third-party software may be governed by separate open-source licenses, commercial terms, privacy terms, or other agreements.
+
+Those terms continue to govern the applicable third-party software.
+
+Nothing in this Agreement is intended to restrict rights granted under an applicable third-party open-source license.
+
+## 16. Confidentiality
+
+Non-public EndoUI materials may constitute ECAP Confidential Information, including non-public source code, private packages, unreleased features, internal documentation, license credentials, product tokens, security information, and materials identified as confidential.
+
+Licensee will use reasonable measures to protect ECAP Confidential Information from unauthorized use or disclosure.
+
+Confidentiality obligations do not apply to information Licensee can demonstrate:
+
+a. became publicly available without violation of this Agreement;
+
+b. was lawfully known without confidentiality restriction before disclosure;
+
+c. was independently developed without use of ECAP Confidential Information; or
+
+d. was lawfully obtained from another party without confidentiality restriction.
+
+## 17. License Credentials
+
+License credentials provided to Licensee are intended solely for Licensee's authorized use.
+
+Licensee must use reasonable measures to protect license credentials from unauthorized disclosure.
+
+Licensee must promptly notify ECAP if it becomes aware that a license credential has been compromised, publicly exposed, stolen, or used without authorization.
+
+ECAP may rotate, replace, revoke, or suspend compromised credentials.
+
+## 18. Support
+
+Technical support, maintenance, service levels, response times, update commitments, and other support obligations apply only if included in Licensee's purchase, subscription, support plan, enterprise agreement, order, or other written agreement with ECAP.
+
+An EndoUI license does not by itself require ECAP to provide custom development, consulting, implementation, integration, migration, or other professional services.
+
+## 19. Suspension
+
+ECAP may suspend an EndoUI license if ECAP reasonably determines that:
+
+- applicable fees are materially overdue;
+- the license is being used fraudulently;
+- Licensee materially exceeds authorized Seat limits;
+- license credentials have been compromised;
+- the license is being shared with unauthorized entities;
+- Licensee is using unauthorized Major Versions;
+- Licensee materially breaches this Agreement; or
+- suspension is reasonably necessary to protect ECAP systems or comply with applicable law.
+
+Where reasonably practicable, ECAP will provide notice and an opportunity to cure a remediable material breach before permanent termination.
+
+Suspension does not transfer ownership of Licensee Applications to ECAP.
+
+## 20. Termination
+
+Licensee may cease using EndoUI at any time.
+
+ECAP may terminate this Agreement or an applicable license if Licensee materially breaches this Agreement and fails to cure the breach within a reasonable period following notice, where the breach is capable of cure.
+
+Upon termination of Licensee's rights, Licensee must cease unauthorized use of EndoUI and delete copies that Licensee is no longer authorized to retain.
+
+Unless otherwise required by law or a separate agreement, termination does not require Licensee to withdraw Applications previously and lawfully distributed under this Agreement solely because those Applications contain permitted compiled or bundled EndoUI code.
+
+Sections that by their nature should survive termination will survive, including provisions concerning ownership, restrictions, confidentiality, disclaimers, limitations of liability, indemnification, and accrued payment obligations.
+
+## 21. Feedback
+
+If Licensee voluntarily provides suggestions, ideas, recommendations, improvements, or other feedback regarding EndoUI, Licensee grants ECAP a perpetual, irrevocable, worldwide, royalty-free right to use, reproduce, modify, and incorporate that feedback for any lawful purpose.
+
+This provision does not grant ECAP ownership of Licensee's Applications, confidential information, proprietary source code, customer information, or business data.
+
+## 22. Disclaimer of Warranties
+
+**TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, ENDOUI IS PROVIDED “AS IS” AND “AS AVAILABLE.”**
+
+Except for an express warranty contained in a separate written agreement signed by ECAP, ECAP disclaims all express, implied, statutory, and other warranties, including warranties of merchantability, fitness for a particular purpose, title, non-infringement, quiet enjoyment, compatibility, and warranties arising from course of dealing or usage of trade.
+
+ECAP does not warrant that EndoUI will be error-free, operate without interruption, meet every Licensee requirement, remain compatible with every browser, framework, dependency, platform, operating system, or tool, or be free from vulnerabilities.
+
+## 23. Limitation of Liability
+
+**TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, NEITHER PARTY WILL BE LIABLE UNDER THIS AGREEMENT FOR INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, PUNITIVE, OR CONSEQUENTIAL DAMAGES, OR FOR LOSS OF PROFITS, REVENUE, BUSINESS OPPORTUNITIES, GOODWILL, OR DATA, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.**
+
+To the maximum extent permitted by applicable law, ECAP's aggregate liability arising out of or relating to EndoUI or this Agreement will not exceed the amounts paid or payable by Licensee to ECAP for EndoUI during the twelve (12) months immediately preceding the event giving rise to the claim.
+
+If Licensee purchased a perpetual license through a one-time payment and no fees were paid during the preceding twelve months, the liability cap will be the amount originally paid for the applicable EndoUI license.
+
+Nothing in this Agreement excludes or limits liability that applicable law does not permit to be excluded or limited.
+
+## 24. Indemnification
+
+Licensee will defend, indemnify, and hold harmless ECAP and its officers, directors, employees, and agents from third-party claims, damages, liabilities, costs, and reasonable attorneys' fees arising from Licensee's Applications, Licensee's unlawful use of EndoUI, Licensee's material breach of this Agreement, materials supplied by Licensee, or Licensee's violation of applicable law, except to the extent a claim results from ECAP's material breach of this Agreement or infringement arising directly from unmodified EndoUI supplied by ECAP.
+
+Any indemnification terms contained in a separately signed agreement between the parties will control over conflicting terms in this section.
+
+## 25. Export Controls and Legal Compliance
+
+Licensee will comply with applicable export-control laws, economic sanctions, anti-corruption laws, trade restrictions, and other laws relating to Licensee's use or transfer of EndoUI.
+
+Licensee may not export, re-export, transfer, or use EndoUI in violation of applicable law.
+
+## 26. Government Users
+
+If EndoUI is acquired by or on behalf of a governmental entity, EndoUI is commercial computer software and commercial computer software documentation and is licensed only with the rights granted under this Agreement except where applicable law requires otherwise.
+
+## 27. Orders and Enterprise Agreements
+
+A separate order, order form, enterprise agreement, master services agreement, partnership agreement, negotiated software agreement, or other written contract may modify the rights granted under this Agreement.
+
+If a separately signed agreement between ECAP and Licensee conflicts with this Agreement, the separately signed agreement will control to the extent of the conflict.
+
+Otherwise, this Agreement governs Licensee's use of EndoUI.
+
+## 28. Changes to License Terms
+
+ECAP may revise these license terms for future purchases, renewals, subscriptions, future Major Versions, or future licensing programs.
+
+A material modification will not retroactively reduce perpetual rights previously granted and fully paid for an authorized EndoUI Major Version unless:
+
+1. Licensee agrees to the modification; or
+2. applicable law requires the change.
+
+## 29. Governing Law
+
+This Agreement will be governed by the laws of the State of **Texas**, without regard to conflict-of-laws rules.
+
+The parties consent to exclusive jurisdiction and venue in the state and federal courts having jurisdiction over **Ellis County, Texas**, except that either party may seek appropriate injunctive or equitable relief in another court having jurisdiction.
+
+## 30. Assignment
+
+Licensee may not assign or transfer this Agreement or an EndoUI license without ECAP's prior written consent, except in connection with a merger, acquisition, corporate restructuring, or sale of substantially all assets relating to the licensed business, provided that the successor agrees to be bound by this Agreement.
+
+ECAP may assign this Agreement in connection with a merger, acquisition, financing, corporate restructuring, or sale of all or a material portion of its business or assets.
+
+## 31. Severability
+
+If any provision of this Agreement is held invalid or unenforceable, that provision will be modified to the minimum extent necessary to make it enforceable where permitted by law.
+
+The remaining provisions will remain in full force and effect.
+
+## 32. Waiver
+
+Failure to enforce any provision of this Agreement does not waive the right to enforce that provision or another provision later.
+
+## 33. Entire Agreement
+
+This Agreement, together with applicable orders, invoices, license records, signed agreements, partnership agreements, and other incorporated written terms, constitutes the agreement governing Licensee's use of EndoUI.
+
+## 34. Contact
+
+Questions concerning EndoUI licensing may be directed to:
+
+**ECAP Software LLC**  
+d/b/a ECAP Software
+
+Licensing: **licensing@ecapsoftware.com**  
+Website: **https://www.ecapsoftware.com**
+

package/README.md

@@ -0,0 +1,40 @@
+# @endo-ui/license
+
+Private Node-only activation and Angular 22 build enforcement for EndoUI. Nothing in this
+package is imported into the browser application or its production runtime.
+
+## Configure an Angular workspace
+
+After installing `@endo-ui/core` and this package from the private `@endo-ui` namespace:
+
+```bash
+npx ng add @endo-ui/license
+```
+
+The schematic replaces Angular's application and development-server builders with EndoUI
+wrappers. The wrappers verify a signed local authorization before delegating to Angular's
+official builders.
+
+## Developer activation
+
+```bash
+npx endoui-license activate \
+  --developer "jane@customer.com"
+```
+
+The command securely prompts for the customer license key. The email identifies the named
+developer Seat; it is not an EndoUI login account. The customer license key is sent only to
+ECAP's licensing service and is not cached by this package. For non-interactive environments,
+provide it through the protected `ENDOUI_LICENSE_KEY` environment variable.
+
+## CI activation
+
+Store `ENDOUI_LICENSE_KEY` in the CI provider's protected secret storage, then run:
+
+```bash
+npx endoui-license ci-activate
+npx ng build
+```
+
+CI authorization does not consume a human Seat. The signed authorization is cached outside the
+application source and remains valid for its bounded offline period.

package/bin/api.js

@@ -0,0 +1,34 @@
+const DEFAULT_SERVICE_URL = "https://license.ecapsoftware.com";
+async function requestLease(pathname, licenseKey, body) {
+    const baseUrl = process.env['ENDOUI_LICENSE_URL'] ?? DEFAULT_SERVICE_URL;
+    const response = await fetch(new URL(pathname, baseUrl), {
+        method: "POST",
+        headers: {
+            Accept: "application/json",
+            "Content-Type": "application/json",
+            Authorization: `License ${licenseKey}`
+        },
+        body: JSON.stringify(body)
+    });
+    let value;
+    try {
+        value = await response.json();
+    }
+    catch {
+        value = undefined;
+    }
+    if (!response.ok || typeof value?.lease !== "string") {
+        const detail = typeof value?.error === "string" ? ` ${value.error}` : "";
+        throw new Error(`EndoUI activation failed.${detail}`);
+    }
+    return value.lease;
+}
+export function activateDeveloper(licenseKey, developerEmail, packageVersion) {
+    return requestLease("/v1/endoui/leases/developer", licenseKey, {
+        developerEmail,
+        packageVersion
+    });
+}
+export function activateCi(licenseKey, packageVersion) {
+    return requestLease("/v1/endoui/leases/ci", licenseKey, { packageVersion });
+}

package/bin/builders/application.js

@@ -0,0 +1,7 @@
+import { createBuilder } from "@angular-devkit/architect";
+import { buildApplication } from "@angular/build";
+import { verifyAuthorization } from "./verify-authorization.js";
+export default createBuilder(async function* endoUiApplicationBuilder(options, context) {
+    await verifyAuthorization();
+    yield* buildApplication(options, context);
+});

package/bin/builders/dev-server.js

@@ -0,0 +1,7 @@
+import { createBuilder } from "@angular-devkit/architect";
+import { executeDevServerBuilder } from "@angular/build";
+import { verifyAuthorization } from "./verify-authorization.js";
+export default createBuilder(async function* endoUiDevServerBuilder(options, context) {
+    await verifyAuthorization();
+    yield* executeDevServerBuilder(options, context);
+});

package/bin/builders/verify-authorization.js

@@ -0,0 +1,8 @@
+import { resolveEndoUiVersion } from "../package-version.js";
+import { verifyLease } from "../lease.js";
+import { readLease } from "../storage.js";
+export async function verifyAuthorization() {
+    const version = resolveEndoUiVersion();
+    const major = Number(version.split(".", 1)[0]);
+    verifyLease(await readLease(major), version);
+}

package/bin/cli.js

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+import { activateCi, activateDeveloper } from "./api.js";
+import { createInterface } from "node:readline/promises";
+import { Writable } from "node:stream";
+import { verifyLease } from "./lease.js";
+import { resolveEndoUiVersion } from "./package-version.js";
+import { readLease, writeLease } from "./storage.js";
+function argument(name) {
+    const index = process.argv.indexOf(name);
+    return index >= 0 ? process.argv[index + 1] : undefined;
+}
+function packageMajor(version) {
+    const major = Number(version.split(".", 1)[0]);
+    if (!Number.isSafeInteger(major) || major <= 0) {
+        throw new Error(`EndoUI package version ${version} is not eligible for activation.`);
+    }
+    return major;
+}
+async function licenseCredential() {
+    const configured = process.env['ENDOUI_LICENSE_KEY'];
+    if (configured)
+        return configured;
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        throw new Error("ENDOUI_LICENSE_KEY is required in non-interactive environments.");
+    }
+    let muted = false;
+    const output = new Writable({
+        write(chunk, encoding, callback) {
+            if (!muted)
+                process.stdout.write(chunk, encoding);
+            callback();
+        }
+    });
+    const prompt = createInterface({ input: process.stdin, output, terminal: true });
+    try {
+        const answer = prompt.question("Customer license key: ");
+        muted = true;
+        const value = (await answer).trim();
+        process.stdout.write("\n");
+        if (!value)
+            throw new Error("A customer license key is required.");
+        return value;
+    }
+    finally {
+        prompt.close();
+    }
+}
+async function activate() {
+    const licenseKey = await licenseCredential();
+    const developerEmail = argument("--developer") ?? process.env['ENDOUI_DEVELOPER_EMAIL'];
+    if (!developerEmail) {
+        throw new Error("Activation requires --developer.");
+    }
+    const normalizedEmail = developerEmail.trim().toLowerCase();
+    const version = resolveEndoUiVersion();
+    const major = packageMajor(version);
+    const lease = await activateDeveloper(licenseKey, normalizedEmail, version);
+    verifyLease(lease, version);
+    await writeLease(major, lease);
+    console.log(`EndoUI ${major}.x activated for ${normalizedEmail}.`);
+}
+async function activateBuild() {
+    const licenseKey = process.env['ENDOUI_LICENSE_KEY'];
+    if (!licenseKey)
+        throw new Error("CI activation requires ENDOUI_LICENSE_KEY.");
+    const version = resolveEndoUiVersion();
+    const major = packageMajor(version);
+    const lease = await activateCi(licenseKey, version);
+    verifyLease(lease, version);
+    await writeLease(major, lease);
+    console.log(`EndoUI ${version} CI authorization activated.`);
+}
+async function check() {
+    const version = resolveEndoUiVersion();
+    const major = packageMajor(version);
+    const lease = verifyLease(await readLease(major), version);
+    const refreshNotice = Math.floor(Date.now() / 1000) >= lease.refreshAfter
+        ? " Refresh activation when connectivity is available."
+        : "";
+    console.log(`EndoUI ${version} license verified.${refreshNotice}`);
+}
+async function main() {
+    switch (process.argv[2]) {
+        case "activate":
+            await activate();
+            return;
+        case "ci-activate":
+            await activateBuild();
+            return;
+        case "verify":
+            await check();
+            return;
+        default:
+            console.log("Usage: endoui-license <activate|ci-activate|verify> " +
+                "[--developer <email>]");
+    }
+}
+main().catch((error) => {
+    console.error(error instanceof Error ? error.message : "EndoUI licensing failed.");
+    process.exitCode = 1;
+});

package/bin/lease.js

@@ -0,0 +1,36 @@
+import { createPublicKey, verify } from "node:crypto";
+import { ENDOUI_LEASE_KEY_ID, ENDOUI_LEASE_PUBLIC_KEY } from "./public-key.js";
+function json(value) { try {
+    return JSON.parse(Buffer.from(value, "base64url").toString("utf8"));
+}
+catch {
+    throw new Error("The cached EndoUI authorization is malformed.");
+} }
+export function verifyLease(token, packageVersion, now = Date.now(), trust = {
+    publicKey: ENDOUI_LEASE_PUBLIC_KEY,
+    keyId: ENDOUI_LEASE_KEY_ID,
+    issuer: "https://license.ecapsoftware.com"
+}) {
+    if (!trust.publicKey)
+        throw new Error("The EndoUI verification key has not been configured for publication.");
+    const parts = token.split(".");
+    if (parts.length !== 3 || !parts[0] || !parts[1] || !parts[2])
+        throw new Error("The cached EndoUI authorization is malformed.");
+    const header = json(parts[0]);
+    if (header.alg !== "EdDSA" || header.typ !== "JWT" || header.kid !== trust.keyId)
+        throw new Error("The authorization uses an unsupported signature.");
+    if (!verify(null, Buffer.from(`${parts[0]}.${parts[1]}`, "ascii"), createPublicKey(trust.publicKey), Buffer.from(parts[2], "base64url")))
+        throw new Error("The authorization signature is invalid.");
+    const lease = json(parts[1]);
+    const seconds = Math.floor(now / 1000);
+    const major = Number(packageVersion.split(".", 1)[0]);
+    if (lease.iss !== trust.issuer || lease.aud !== "@endo-ui/license" || lease.product !== "endoui" || lease.package !== "@endo-ui/core" || lease.majorVersion !== major || lease.entitlement !== `endoui-v${major}`)
+        throw new Error("The authorization does not cover this EndoUI package.");
+    if (!Number.isSafeInteger(lease.nbf) || !Number.isSafeInteger(lease.exp))
+        throw new Error("The authorization has invalid timestamps.");
+    if (seconds < lease.nbf)
+        throw new Error("The authorization is not active yet. Check the system clock.");
+    if (seconds >= lease.exp)
+        throw new Error("The authorization has expired. Activate again while online.");
+    return lease;
+}

package/bin/package-version.js

@@ -0,0 +1,9 @@
+import { createRequire } from "node:module";
+import path from "node:path";
+export function resolveEndoUiVersion(cwd = process.cwd()) { const require = createRequire(path.join(cwd, "package.json")); let file; try {
+    file = require.resolve("@endo-ui/core/package.json");
+}
+catch {
+    throw new Error("Unable to find @endo-ui/core from the current project.");
+} const value = require(file); if (value.name !== "@endo-ui/core" || typeof value.version !== "string")
+    throw new Error("@endo-ui/core has invalid package metadata."); return value.version; }

package/bin/public-key.js

@@ -0,0 +1,5 @@
+// ECAP's public Ed25519 trust root. The matching private key remains on the VPS.
+export const ENDOUI_LEASE_PUBLIC_KEY = `-----BEGIN PUBLIC KEY-----
+MCowBQYDK2VwAyEAu6C5H6wO9CFNj9QUF2AQH9xCcNmxQVzZs5rNrL4uWtU=
+-----END PUBLIC KEY-----`;
+export const ENDOUI_LEASE_KEY_ID = "endoui-lease-v1";

package/bin/schematics/ng-add/index.js

@@ -0,0 +1,31 @@
+import { SchematicsException } from "@angular-devkit/schematics";
+export default function ngAdd() {
+    return (tree) => {
+        const workspaceFile = tree.get("angular.json");
+        if (!workspaceFile) {
+            throw new SchematicsException("This project does not contain angular.json.");
+        }
+        const workspace = JSON.parse(workspaceFile.content.toString("utf8"));
+        let configured = false;
+        for (const project of Object.values(workspace.projects ?? {})) {
+            if (project.projectType !== "application")
+                continue;
+            const targets = project.architect ?? project.targets;
+            if (!targets)
+                continue;
+            if (targets['build']?.builder === "@angular/build:application") {
+                targets['build'].builder = "@endo-ui/license:application";
+                configured = true;
+            }
+            if (targets['serve']?.builder === "@angular/build:dev-server") {
+                targets['serve'].builder = "@endo-ui/license:dev-server";
+                configured = true;
+            }
+        }
+        if (!configured) {
+            throw new SchematicsException("No Angular 22 application build or serve targets were found to configure.");
+        }
+        tree.overwrite("angular.json", `${JSON.stringify(workspace, null, 2)}\n`);
+        return tree;
+    };
+}

package/bin/storage.js

@@ -0,0 +1,14 @@
+import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+function target(major) { const override = process.env['ENDOUI_LICENSE_CACHE']?.trim(); return override ? path.resolve(override) : path.join(os.homedir(), ".endoui", `endoui-v${major}.jwt`); }
+export async function readLease(major) { try {
+    return (await readFile(target(major), "utf8")).trim();
+}
+catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT")
+        throw new Error("EndoUI is not activated. Run `endoui-license activate`.");
+    throw error;
+} }
+export async function writeLease(major, lease) { const file = target(major); await mkdir(path.dirname(file), { recursive: true, mode: 0o700 }); await writeFile(file, `${lease}\n`, { encoding: "utf8", mode: 0o600 }); if (process.platform !== "win32")
+    await chmod(file, 0o600); }

package/builders.json

@@ -0,0 +1,15 @@
+{
+  "$schema": "https://json.schemastore.org/angular-builders.json",
+  "builders": {
+    "application": {
+      "implementation": "./bin/builders/application.js",
+      "schema": "./schemas/application.json",
+      "description": "Verify EndoUI authorization and build an Angular application."
+    },
+    "dev-server": {
+      "implementation": "./bin/builders/dev-server.js",
+      "schema": "./schemas/dev-server.json",
+      "description": "Verify EndoUI authorization and serve an Angular application."
+    }
+  }
+}

package/collection.json

@@ -0,0 +1,9 @@
+{
+  "$schema": "https://json.schemastore.org/schematics.json",
+  "schematics": {
+    "ng-add": {
+      "description": "Configure Angular build and serve targets to verify EndoUI licensing.",
+      "factory": "./bin/schematics/ng-add/index.js"
+    }
+  }
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@endo-ui/license",
+  "version": "1.0.0",
+  "description": "Developer and CI license activation for EndoUI.",
+  "license": "SEE LICENSE IN LICENSE.md",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "type": "module",
+  "builders": "./builders.json",
+  "schematics": "./collection.json",
+  "bin": {
+    "endoui-license": "./bin/cli.js"
+  },
+  "files": [
+    "bin",
+    "builders.json",
+    "collection.json",
+    "schemas",
+    "LICENSE.md",
+    "README.md"
+  ],
+  "scripts": {
+    "prepack": "tsc -p tsconfig.json"
+  },
+  "peerDependencies": {
+    "@angular-devkit/architect": "^0.2200.0",
+    "@angular-devkit/schematics": "^22.0.0",
+    "@angular/build": "^22.0.0"
+  },
+  "engines": {
+    "node": "^22.22.3 || ^24.15.0 || ^26.0.0"
+  }
+}

package/schemas/application.json

@@ -0,0 +1,5 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "type": "object",
+  "additionalProperties": true
+}

package/schemas/dev-server.json

@@ -0,0 +1,5 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "type": "object",
+  "additionalProperties": true
+}