@modootoday/pmcp 0.13.0 → 0.14.0

package/plugins/happy-dom-20/skills/happy-dom/SKILL.md

@@ -0,0 +1,172 @@
+---
+name: happy-dom
+description: Use happy-dom ^20.0.0 as a headless DOM/browser implementation in standalone Bun or Node scripts, with v20 security defaults and lifecycle cleanup in mind.
+---
+
+Verified against happy-dom@20.14.0 on 2026-09-07. 5 of 5 examples executed.
+
+# happy-dom
+
+## Scope
+
+`happy-dom` provides a headless DOM implementation and a programmatic browser API. The examples below are standalone scripts: each can be run as `bun example.ts` with only `happy-dom` installed.
+
+## `Window`: create and manipulate a DOM
+
+Import `Window` from `happy-dom`. Pass a URL when code under test depends on the document location. Access the DOM through `window.document`.
+
+```ts pmcp-example
+import { strict as assert } from 'node:assert';
+import { Window } from 'happy-dom';
+
+const window = new Window({ url: 'https://localhost:8080' });
+const document = window.document;
+
+document.body.innerHTML = '<div class="container"></div>';
+const container = document.querySelector('.container');
+assert.ok(container);
+
+const button = document.createElement('button');
+container.appendChild(button);
+
+assert.equal(document.body.innerHTML, '<div class="container"><button></button></div>');
+assert.equal(window.location.href, 'https://localhost:8080/');
+
+await window.happyDOM.abort();
+window.close();
+```
+
+Use `window.happyDOM.abort()` when pending Happy DOM work should be stopped, and call `window.close()` when the window is no longer needed.
+
+## JavaScript evaluation is disabled by default in v20
+
+Do not assume that scripts embedded in markup execute. Since v20, JavaScript evaluation is disabled by default for security reasons. Enable it explicitly with `settings: { enableJavaScriptEvaluation: true }` only when the evaluated code is trusted. A VM context is not an isolation boundary; untrusted JavaScript can pose an RCE risk.
+
+```ts pmcp-example
+import { strict as assert } from 'node:assert';
+import { Window } from 'happy-dom';
+
+const window = new Window({
+  settings: { enableJavaScriptEvaluation: true }
+});
+
+window.document.write(`
+  <script>
+    document.body.setAttribute('data-evaluated', 'yes');
+  </script>
+`);
+
+assert.equal(window.document.body.getAttribute('data-evaluated'), 'yes');
+
+await window.happyDOM.abort();
+window.close();
+```
+
+A common outdated pattern is to rely on HTML scripts executing without this setting. In v20 that default is intentionally off.
+
+## `Browser` and pages
+
+Import `Browser` and, when configuring error handling, `BrowserErrorCaptureEnum`. Create a page with `browser.newPage()`, navigate with `page.goto()`, use `page.mainFrame.document`, and wait with `page.waitUntilComplete()`.
+
+The documented browser flow navigates to a URL and therefore requires the browser's page-loading environment. The standalone example below only exercises the constructible, offline portion of the API and does not make a network request.
+
+```ts pmcp-example
+import { strict as assert } from 'node:assert';
+import { Browser, BrowserErrorCaptureEnum } from 'happy-dom';
+
+const browser = new Browser({
+  settings: { errorCapture: BrowserErrorCaptureEnum.processLevel }
+});
+
+const page = browser.newPage();
+assert.ok(page);
+assert.ok(page.mainFrame);
+assert.ok(page.mainFrame.document);
+
+await page.waitUntilComplete();
+await browser.close();
+```
+
+For a loaded page, the documented sequence is:
+
+```ts
+const browser = new Browser({
+  settings: { errorCapture: BrowserErrorCaptureEnum.processLevel }
+});
+const page = browser.newPage();
+await page.goto('https://example.test/');
+page.mainFrame.document.querySelector('a')?.click();
+await page.waitUntilComplete();
+await browser.close();
+```
+
+Always close the browser when finished. The browser/page API is not the same shape as the older examples that only construct a `Window`.
+
+## `GlobalWindow`
+
+`GlobalWindow` extends `Window` but evaluates document scripts in the global scope rather than in a Node.js VM context. This changes global state, so use it only when that behavior is required. Enable JavaScript evaluation explicitly in v20.
+
+```ts pmcp-example
+import { strict as assert } from 'node:assert';
+import { GlobalWindow } from 'happy-dom';
+
+const key = '__happyDomSkillExampleValue';
+const window = new GlobalWindow({
+  settings: { enableJavaScriptEvaluation: true }
+});
+
+window.document.write(`
+  <script>
+    globalThis.${key} = 'Hello world!';
+  </script>
+`);
+
+assert.equal((globalThis as Record<string, unknown>)[key], 'Hello world!');
+delete (globalThis as Record<string, unknown>)[key];
+
+await window.happyDOM.close();
+```
+
+The older `GlobalWindow` example shape that expects scripts to run without an explicit setting is not appropriate for v20.
+
+## Finding the owning window with `PropertySymbol`
+
+`PropertySymbol` exposes the internal symbol used to retrieve the Happy DOM window associated with a document. Current code uses `PropertySymbol.window`; the setup documentation also shows an older `PropertySymbol.ownerWindow` name, so use the fallback when supporting both shapes.
+
+```ts pmcp-example
+import { strict as assert } from 'node:assert';
+import { PropertySymbol, Window } from 'happy-dom';
+
+const window = new Window();
+const document = window.document as typeof window.document & {
+  [PropertySymbol.ownerWindow]?: Window;
+  [PropertySymbol.window]?: Window;
+};
+
+const owningWindow =
+  document[PropertySymbol.ownerWindow] || document[PropertySymbol.window];
+
+assert.equal(owningWindow, window);
+
+await window.happyDOM.abort();
+window.close();
+```
+
+## Test-environment integrations are separate
+
+Happy DOM can be used by test tools, but those integrations are not needed for the standalone `Window` and `Browser` APIs:
+
+- Jest requires the separate `@happy-dom/jest-environment` package.
+- Node's native test runner requires `@happy-dom/global-registrator` to be imported before tests.
+- Global DOM globals require `@happy-dom/global-registrator`, for example `GlobalRegistrator.register({ url: 'http://localhost:3000' })`.
+- In Vitest, the documented timer workaround replaces the host timer functions with the window's timer functions. The relevant window is obtained through `PropertySymbol.ownerWindow` or the current `PropertySymbol.window` fallback.
+
+Do not copy runner globals such as `describe`, `it`, or `expect` into a direct Bun script; they are not provided by `happy-dom`.
+
+## Server rendering is a separate package
+
+SSR/SSG command-line rendering belongs to `@happy-dom/server-renderer`, not the `happy-dom` package itself. Its command-line JavaScript option is separate from the programmatic `Window` setting. The server renderer keeps JavaScript disabled by default and enables it with its `--javascript` option.
+
+## Not covered
+
+This skill does not cover the complete DOM API, browser navigation and network behavior, every browser/page lifecycle method, Vitest/Jest configuration, the `@happy-dom/global-registrator` package API, or `@happy-dom/server-renderer` usage beyond identifying that these are separate integrations. It also does not establish a security boundary for evaluated JavaScript.

package/plugins/hono-4/.claude-plugin/plugin.json

@@ -0,0 +1,9 @@
+{
+  "name": "hono-4",
+  "version": "4.0.1",
+  "description": "Validate requests, compose middleware and consume status-aware RPC types across packages.",
+  "author": { "name": "modootoday" },
+  "license": "Elastic-2.0",
+  "repository": "https://github.com/modootoday/pmcp",
+  "homepage": "https://pmcp.build/skills/"
+}

package/plugins/hono-4/LICENSE

@@ -0,0 +1,93 @@
+Elastic License 2.0
+
+URL: https://www.elastic.co/licensing/elastic-license
+
+## Acceptance
+
+By using the software, you agree to all of the terms and conditions below.
+
+## Copyright License
+
+The licensor grants you a non-exclusive, royalty-free, worldwide,
+non-sublicensable, non-transferable license to use, copy, distribute, make
+available, and prepare derivative works of the software, in each case subject to
+the limitations and conditions below.
+
+## Limitations
+
+You may not provide the software to third parties as a hosted or managed
+service, where the service provides users with access to any substantial set of
+the features or functionality of the software.
+
+You may not move, change, disable, or circumvent the license key functionality
+in the software, and you may not remove or obscure any functionality in the
+software that is protected by the license key.
+
+You may not alter, remove, or obscure any licensing, copyright, or other notices
+of the licensor in the software. Any use of the licensor’s trademarks is subject
+to applicable law.
+
+## Patents
+
+The licensor grants you a license, under any patent claims the licensor can
+license, or becomes able to license, to make, have made, use, sell, offer for
+sale, import and have imported the software, in each case subject to the
+limitations and conditions in this license. This license does not cover any
+patent claims that you cause to be infringed by modifications or additions to
+the software. If you or your company make any written claim that the software
+infringes or contributes to infringement of any patent, your patent license for
+the software granted under these terms ends immediately. If your company makes
+such a claim, your patent license ends immediately for work on behalf of your
+company.
+
+## Notices
+
+You must ensure that anyone who gets a copy of any part of the software from you
+also gets a copy of these terms.
+
+If you modify the software, you must include in any modified copies of the
+software prominent notices stating that you have modified the software.
+
+## No Other Rights
+
+These terms do not imply any licenses other than those expressly granted in
+these terms.
+
+## Termination
+
+If you use the software in violation of these terms, such use is not licensed,
+and your licenses will automatically terminate. If the licensor provides you
+with a notice of your violation, and you cease all violation of this license no
+later than 30 days after you receive that notice, your licenses will be
+reinstated retroactively. However, if you violate these terms after such
+reinstatement, any additional violation of these terms will cause your licenses
+to terminate automatically and permanently.
+
+## No Liability
+
+*As far as the law allows, the software comes as is, without any warranty or
+condition, and the licensor will not be liable to you for any damages arising
+out of these terms or the use or nature of the software, under any kind of
+legal claim.*
+
+## Definitions
+
+The **licensor** is the entity offering these terms, and the **software** is the
+software the licensor makes available under these terms, including any portion
+of it.
+
+**you** refers to the individual or entity agreeing to these terms.
+
+**your company** is any legal entity, sole proprietorship, or other kind of
+organization that you work for, plus all organizations that have control over,
+are under the control of, or are under common control with that
+organization. **control** means ownership of substantially all the assets of an
+entity, or the power to direct its management and policies by vote, contract, or
+otherwise. Control can be direct or indirect.
+
+**your licenses** are all the licenses granted to you for the software under
+these terms.
+
+**use** means anything you do with the software requiring one of your licenses.
+
+**trademark** means trademarks, service marks, and similar rights.

package/plugins/hono-4/NOTICE

@@ -0,0 +1,51 @@
+pmcp
+
+Copyright (c) 2026 modootoday. All rights reserved.
+
+Licensor: modootoday
+Licensed under the Elastic License 2.0; see LICENSE.
+
+The licensor is modootoday, the company, not any individual contributor. This
+file names the licensor because the Elastic License 2.0 defines that term rather
+than carrying a copyright line of its own; LICENSE is kept unmodified.
+
+What the licence permits, in short, without replacing the terms in LICENSE:
+
+  - Using this software inside your own company, on any scale.
+  - Embedding it in a product you sell, and modifying or forking it.
+  - Redistributing it, with these notices intact.
+  - Running it locally as an MCP server, which is what it is for. A host
+    process spawning it on your own machine is use, not a hosted service.
+
+What it does not permit:
+
+  - Offering this software to third parties as a hosted or managed service.
+    A remotely hosted MCP endpoint serving other people is the case this
+    forbids.
+  - Circumventing licence key functionality.
+  - Removing or obscuring these notices.
+
+The Elastic License 2.0 is source-available, not an OSI-approved open source
+licence. It grants a patent licence and ends that licence if you assert a patent
+claim against the software; see the Patents section of LICENSE.
+
+LICENSE governs. Where this summary and LICENSE differ, LICENSE is what applies.
+
+---
+
+This software depends on the following packages, which are distributed under
+their own terms and are not covered by the licence above.
+
+  @modelcontextprotocol/server   MIT   Copyright (c) Anthropic, PBC
+  @modelcontextprotocol/core     MIT   Copyright (c) Anthropic, PBC
+  zod                            MIT   Copyright (c) Colin McDonnell
+  semver                         ISC   See the dependency's LICENSE file.
+  smol-toml              BSD-3-Clause   Copyright (c) Squirrel Chat et al.
+  yaml                           ISC   Copyright Eemeli Aro
+
+Full licence texts and copyright notices ship with those packages. Their
+respective licence terms govern distribution of those dependencies.
+
+@huggingface/transformers is an optional peer dependency. It is never
+distributed with this package; a user who wants semantic ranking installs it
+themselves, under its own Apache-2.0 terms.

package/plugins/hono-4/gemini-extension.json

@@ -0,0 +1 @@
+{ "name": "hono-4", "version": "4.0.1" }

package/plugins/hono-4/plugin.json

@@ -0,0 +1,10 @@
+{
+  "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
+  "name": "hono-4",
+  "version": "4.0.1",
+  "description": "Validate requests, compose middleware and consume status-aware RPC types across packages.",
+  "author": { "name": "modootoday" },
+  "license": "Elastic-2.0",
+  "repository": "https://github.com/modootoday/pmcp",
+  "homepage": "https://pmcp.build/skills/"
+}

package/plugins/hono-4/skills/hono/SKILL.md

@@ -0,0 +1,203 @@
+---
+name: hono
+description: Use Hono 4.x as a Fetch-compatible web application router. Covers the current Hono API, standalone request testing, middleware, context responses, validation, and migration traps from Hono 3.x.
+---
+
+The original four request examples were verified against hono@4.13.7 on 2026-09-07. Development fixtures separately verify middleware ordering, invalid JSON responses, RPC client/server type consumption and a Node HTTP request followed by server shutdown; current exact versions are recorded in the catalog.
+
+# Hono 4.x
+
+## Use the current app API
+
+Import the recommended preset from `hono`, construct an app, register routes, and export or pass the app to a runtime server:
+
+```ts
+import { Hono } from 'hono'
+
+const app = new Hono()
+app.get('/', (c) => c.text('Hello Hono!'))
+
+export default app
+```
+
+Hono creates a Fetch-compatible app. Its runtime/server integration is separate. For Node.js, the documented integration uses `@hono/node-server` and `serve(app)`; Bun and Deno can serve Fetch handlers natively. Do not assume that importing `hono` starts an HTTP server.
+
+For a standalone script, use `app.request()` to exercise routes without a server:
+
+```ts pmcp-example
+import { strict as assert } from 'node:assert'
+import { Hono } from 'hono'
+
+const app = new Hono()
+app.get('/hello', (c) => c.text('Hello Hono!'))
+
+const response = await app.request('/hello')
+assert.equal(response.status, 200)
+assert.equal(await response.text(), 'Hello Hono!')
+```
+
+`app.fetch(request, env, event)` is the Fetch-compatible handler API. `app.request(path, options)` is the convenient request helper for programmatic calls. Other documented app methods include HTTP method helpers, `all`, `on`, `use`, `route`, `basePath`, `notFound`, `onError`, `mount`, and `fire`.
+
+## Context and responses
+
+Route and middleware callbacks receive a context object. The documented context surface includes `c.req`, `c.status()`, `c.text()`, `c.json()`, `c.html()`, `c.set()`, `c.get()`, `c.var`, `c.header()`, `c.redirect()`, `c.notFound()`, and `c.body()`. Cookie helpers are imported from `hono/cookie`.
+
+Read request headers through `c.req.header()`, and set the response status with `c.status()` before returning a response:
+
+```ts pmcp-example
+import { strict as assert } from 'node:assert'
+import { Hono } from 'hono'
+
+const app = new Hono()
+app.get('/created', (c) => {
+  const userAgent = c.req.header('User-Agent')
+  c.status(201)
+  return c.json({ userAgent })
+})
+
+const response = await app.request('/created', {
+  headers: { 'User-Agent': 'pmcp-example' },
+})
+
+assert.equal(response.status, 201)
+assert.deepEqual(await response.json(), { userAgent: 'pmcp-example' })
+```
+
+Use `c.json()` rather than the removed `c.jsonT()` API.
+
+## Middleware
+
+Create custom middleware with `createMiddleware` from `hono/factory`. Middleware receives `(c, next)` and must await `next()` when it wants downstream handlers to run:
+
+```ts pmcp-example
+import { strict as assert } from 'node:assert'
+import { Hono } from 'hono'
+import { createMiddleware } from 'hono/factory'
+
+const app = new Hono()
+
+const addMarker = createMiddleware(async (c, next) => {
+  c.set('marker', 'middleware')
+  await next()
+})
+
+app.use(addMarker)
+app.get('/', (c) => c.text(c.get('marker')))
+
+const response = await app.request('/')
+assert.equal(await response.text(), 'middleware')
+```
+
+The documented built-in middleware entry points include `logger` from `hono/logger` and `cors` from `hono/cors`, used as `app.use(logger())` and `app.use('/api/*', cors())`.
+
+## Validation
+
+Use `validator` from `hono/validator`. Documented validation targets are `form`, `json`, `query`, `header`, `cookie`, and `param`. A validator callback may return a response for invalid input or return validated data; later handlers retrieve it with `c.req.valid(target)`.
+
+```ts pmcp-example
+import { strict as assert } from 'node:assert'
+import { Hono } from 'hono'
+import { validator } from 'hono/validator'
+
+const app = new Hono()
+
+app.get(
+  '/search',
+  validator('query', (value, c) => {
+    const term = value['term']
+    if (!term || typeof term !== 'string') return c.text('Invalid!', 400)
+    return { term }
+  }),
+  (c) => c.json(c.req.valid('query'))
+)
+
+const valid = await app.request('/search?term=hono')
+assert.equal(valid.status, 200)
+assert.deepEqual(await valid.json(), { term: 'hono' })
+
+const invalid = await app.request('/search')
+assert.equal(invalid.status, 400)
+assert.equal(await invalid.text(), 'Invalid!')
+```
+
+## Hono 4 migration traps
+
+When updating older examples, apply these changes:
+
+- `c.jsonT()` was removed; use `c.json()`.
+- `c.stream()` and `c.streamText()` moved to `hono/streaming`.
+- `c.env()` was removed; use `getRuntimeKey()`.
+- `app.handleEvent()` was removed; use `app.fetch()`.
+- `app.showRoutes()` and `app.routerName` moved to `showRoutes()` and `getRouterName()` from `hono/dev`.
+- `c.req.cookie()` was removed; use `getCookie()` from `hono/cookie`.
+- `app.head()` is no longer needed because `app.get()` implicitly handles `HEAD`.
+- Hono request members including `headers()`, `body()`, `bodyUsed()`, `integrity()`, `keepalive()`, `referrer()`, and `signal()` are now accessed on `req.raw`; for example, `req.raw.headers`.
+- Cloudflare Workers `serveStatic` requires a manifest, passed as `{ root: './assets', manifest }`.
+- JSX renderer `docType` now defaults to `true`.
+- `FC` in `hono/jsx` no longer passes `children`; use `PropsWithChildren` when children are needed.
+
+## Other entry points
+
+The research documents these entry points:
+
+- `hono/quick`: `Hono` for applications initialized per request.
+- `hono/tiny`: the smallest router package.
+- `hono/html`: `html` and `raw`.
+- `hono/cookie`: `getCookie` and `setCookie`.
+- `hono/testing`: `testClient`.
+- `hono/adapter`: `env` and `getRuntimeKey`.
+
+Use the documented exports from those subpaths rather than assuming they are methods on the app or context. In particular, cookie access moved out of `c.req`, and runtime-key access replaced `c.env()`.
+
+## JSX and RPC boundaries
+
+JSX requires a `.tsx` file and compiler configuration with `jsx: "react-jsx"` and `jsxImportSource: "hono/jsx"`; JSX is not a plain `.ts` feature.
+
+RPC is type-level and build-tool dependent. The server exports `typeof route` as `AppType`; separate projects need matching Hono versions, strict TypeScript and built declarations before consumption. Preserve project references when the existing build graph uses them. It is not something to validate with a bare `bun example.ts` script.
+
+## Build a typed client from the route value
+
+Preserve the return type of the chained route registration. Export that route's type and import it with `import type` in the client. Keep strict TypeScript and matching Hono versions across both projects.
+
+```ts
+import { Hono } from "hono";
+import { validator } from "hono/validator";
+
+const route = new Hono().post(
+  "/items",
+  validator("json", (value: { title: string }, c) => {
+    if (typeof value?.title !== "string") return c.json({ error: "title" }, 400);
+    return { title: value.title };
+  }),
+  (c) => c.json({ title: c.req.valid("json").title }, 201),
+);
+
+export type AppType = typeof route;
+export default route;
+```
+
+For a separate package, build exported declarations before the consumer typecheck. Use `hc<AppType>` from `hono/client`. The JSON input and status-specific response types should fail compilation when the client sends the wrong shape. Request-only tests cannot prove that boundary.
+
+## Keep serving and runtime boundaries separate
+
+Use the runtime's documented adapter to serve `app.fetch`; request tests do not start a listener. Verify one valid request, one rejected request and middleware ordering before serving. Set the JSON Content-Type in validator tests. Retain the host's connection, authentication and shutdown conventions.
+
+For Node.js, install a compatible `@hono/node-server` separately and close its returned server during graceful shutdown:
+
+```ts
+import { serve } from "@hono/node-server";
+import app from "./app.js";
+
+const server = serve({ fetch: app.fetch, port: 3000 });
+process.once("SIGTERM", () => {
+  server.close();
+});
+```
+
+The loopback fixture checks adapter 2.1.4, an assigned local port, response status and body, and listener closure. It does not validate production signal handling, WebSockets, Bun or Deno serving.
+
+Read [Hono RPC](https://hono.dev/docs/guides/rpc) when consuming typed routes, and [Node integration](https://hono.dev/docs/getting-started/nodejs) when starting a Node server. Other runtimes need their own documented entry point.
+
+## Remaining API coverage
+
+Detailed signatures for the `quick` and `tiny` presets, HTML and cookie helpers, streaming, static serving and JSX components require their own task-specific examples. RPC transport authentication and non-Node server lifecycles remain outside these fixtures. Consult the relevant runtime documentation before deployment.

package/plugins/http-proxy-agent-9/.claude-plugin/plugin.json

@@ -0,0 +1,9 @@
+{
+  "name": "http-proxy-agent-9",
+  "version": "9.0.0",
+  "description": "Use http-proxy-agent 9.x to route Node HTTP requests through an HTTP or HTTPS proxy.",
+  "author": { "name": "modootoday" },
+  "license": "Elastic-2.0",
+  "repository": "https://github.com/modootoday/pmcp",
+  "homepage": "https://pmcp.build/skills/"
+}

package/plugins/http-proxy-agent-9/LICENSE

@@ -0,0 +1,93 @@
+Elastic License 2.0
+
+URL: https://www.elastic.co/licensing/elastic-license
+
+## Acceptance
+
+By using the software, you agree to all of the terms and conditions below.
+
+## Copyright License
+
+The licensor grants you a non-exclusive, royalty-free, worldwide,
+non-sublicensable, non-transferable license to use, copy, distribute, make
+available, and prepare derivative works of the software, in each case subject to
+the limitations and conditions below.
+
+## Limitations
+
+You may not provide the software to third parties as a hosted or managed
+service, where the service provides users with access to any substantial set of
+the features or functionality of the software.
+
+You may not move, change, disable, or circumvent the license key functionality
+in the software, and you may not remove or obscure any functionality in the
+software that is protected by the license key.
+
+You may not alter, remove, or obscure any licensing, copyright, or other notices
+of the licensor in the software. Any use of the licensor’s trademarks is subject
+to applicable law.
+
+## Patents
+
+The licensor grants you a license, under any patent claims the licensor can
+license, or becomes able to license, to make, have made, use, sell, offer for
+sale, import and have imported the software, in each case subject to the
+limitations and conditions in this license. This license does not cover any
+patent claims that you cause to be infringed by modifications or additions to
+the software. If you or your company make any written claim that the software
+infringes or contributes to infringement of any patent, your patent license for
+the software granted under these terms ends immediately. If your company makes
+such a claim, your patent license ends immediately for work on behalf of your
+company.
+
+## Notices
+
+You must ensure that anyone who gets a copy of any part of the software from you
+also gets a copy of these terms.
+
+If you modify the software, you must include in any modified copies of the
+software prominent notices stating that you have modified the software.
+
+## No Other Rights
+
+These terms do not imply any licenses other than those expressly granted in
+these terms.
+
+## Termination
+
+If you use the software in violation of these terms, such use is not licensed,
+and your licenses will automatically terminate. If the licensor provides you
+with a notice of your violation, and you cease all violation of this license no
+later than 30 days after you receive that notice, your licenses will be
+reinstated retroactively. However, if you violate these terms after such
+reinstatement, any additional violation of these terms will cause your licenses
+to terminate automatically and permanently.
+
+## No Liability
+
+*As far as the law allows, the software comes as is, without any warranty or
+condition, and the licensor will not be liable to you for any damages arising
+out of these terms or the use or nature of the software, under any kind of
+legal claim.*
+
+## Definitions
+
+The **licensor** is the entity offering these terms, and the **software** is the
+software the licensor makes available under these terms, including any portion
+of it.
+
+**you** refers to the individual or entity agreeing to these terms.
+
+**your company** is any legal entity, sole proprietorship, or other kind of
+organization that you work for, plus all organizations that have control over,
+are under the control of, or are under common control with that
+organization. **control** means ownership of substantially all the assets of an
+entity, or the power to direct its management and policies by vote, contract, or
+otherwise. Control can be direct or indirect.
+
+**your licenses** are all the licenses granted to you for the software under
+these terms.
+
+**use** means anything you do with the software requiring one of your licenses.
+
+**trademark** means trademarks, service marks, and similar rights.