pepr 0.32.0 → 0.32.2

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.js

@@ -1888,7 +1888,7 @@ var gitIgnore = "# Ignore node_modules and Pepr build artifacts\nnode_modules\nd
 var readmeMd = '# Pepr Module\n\nThis is a Pepr Module. [Pepr](https://github.com/defenseunicorns/pepr) is a type-safe Kubernetes middleware system.\n\nThe `capabilities` directory contains all the capabilities for this module. By default,\na capability is a single typescript file in the format of `capability-name.ts` that is\nimported in the root `pepr.ts` file as `import { HelloPepr } from "./capabilities/hello-pepr";`.\nBecause this is typescript, you can organize this however you choose, e.g. creating a sub-folder\nper-capability or common logic in shared files or folders.\n\nExample Structure:\n\n```\nModule Root\n\u251C\u2500\u2500 package.json\n\u251C\u2500\u2500 pepr.ts\n\u2514\u2500\u2500 capabilities\n    \u251C\u2500\u2500 example-one.ts\n    \u251C\u2500\u2500 example-three.ts\n    \u2514\u2500\u2500 example-two.ts\n```\n';
 var peprTS = 'import { PeprModule } from "pepr";\n// cfg loads your pepr configuration from package.json\nimport cfg from "./package.json";\n\n// HelloPepr is a demo capability that is included with Pepr. Comment or delete the line below to remove it.\nimport { HelloPepr } from "./capabilities/hello-pepr";\n\n/**\n * This is the main entrypoint for this Pepr module. It is run when the module is started.\n * This is where you register your Pepr configurations and capabilities.\n */\nnew PeprModule(cfg, [\n  // "HelloPepr" is a demo capability that is included with Pepr. Comment or delete the line below to remove it.\n  HelloPepr,\n\n  // Your additional capabilities go here\n]);\n';
 var helloPeprTS = 'import {\n  Capability,\n  K8s,\n  Log,\n  PeprMutateRequest,\n  RegisterKind,\n  a,\n  fetch,\n  fetchStatus,\n  kind,\n} from "pepr";\n\n/**\n *  The HelloPepr Capability is an example capability to demonstrate some general concepts of Pepr.\n *  To test this capability you run `pepr dev`and then run the following command:\n *  `kubectl apply -f capabilities/hello-pepr.samples.yaml`\n */\nexport const HelloPepr = new Capability({\n  name: "hello-pepr",\n  description: "A simple example capability to show how things work.",\n  namespaces: ["pepr-demo", "pepr-demo-2"],\n});\n\n// Use the \'When\' function to create a new action, use \'Store\' to persist data\nconst { When, Store } = HelloPepr;\n\n/**\n * ---------------------------------------------------------------------------------------------------\n *                                   Mutate Action (Namespace)                                   *\n * ---------------------------------------------------------------------------------------------------\n *\n * This action removes the label `remove-me` when a Namespace is created.\n * Note we don\'t need to specify the namespace here, because we\'ve already specified\n * it in the Capability definition above.\n */\nWhen(a.Namespace)\n  .IsCreated()\n  .Mutate(ns => ns.RemoveLabel("remove-me"));\n\n/**\n * ---------------------------------------------------------------------------------------------------\n *                                   Watch Action with K8s SSA (Namespace)                           *\n * ---------------------------------------------------------------------------------------------------\n *\n * This action watches for the `pepr-demo-2` namespace to be created, then creates a ConfigMap with\n * the name `pepr-ssa-demo` and adds the namespace UID to the ConfigMap data. Because Pepr uses\n * server-side apply for this operation, the ConfigMap will be created or updated if it already exists.\n */\nWhen(a.Namespace)\n  .IsCreated()\n  .WithName("pepr-demo-2")\n  .Watch(async ns => {\n    Log.info("Namespace pepr-demo-2 was created.");\n\n    try {\n      // Apply the ConfigMap using K8s server-side apply\n      await K8s(kind.ConfigMap).Apply({\n        metadata: {\n          name: "pepr-ssa-demo",\n          namespace: "pepr-demo-2",\n        },\n        data: {\n          "ns-uid": ns.metadata.uid,\n        },\n      });\n    } catch (error) {\n      // You can use the Log object to log messages to the Pepr controller pod\n      Log.error(error, "Failed to apply ConfigMap using server-side apply.");\n    }\n\n    // You can share data between actions using the Store, including between different types of actions\n    Store.setItem("watch-data", "This data was stored by a Watch Action.");\n  });\n\n/**\n * ---------------------------------------------------------------------------------------------------\n *                                   Mutate Action (CM Example 1)                                *\n * ---------------------------------------------------------------------------------------------------\n *\n * This is a single action. They can be in the same file or put imported from other files.\n * In this example, when a ConfigMap is created with the name `example-1`, then add a label and annotation.\n *\n * Equivalent to manually running:\n * `kubectl label configmap example-1 pepr=was-here`\n * `kubectl annotate configmap example-1 pepr.dev=annotations-work-too`\n */\nWhen(a.ConfigMap)\n  .IsCreated()\n  .WithName("example-1")\n  .Mutate(request => {\n    request\n      .SetLabel("pepr", "was-here")\n      .SetAnnotation("pepr.dev", "annotations-work-too");\n\n    // Use the Store to persist data between requests and Pepr controller pods\n    Store.setItem("example-1", "was-here");\n\n    // This data is written asynchronously and can be read back via `Store.getItem()` or `Store.subscribe()`\n    Store.setItem("example-1-data", JSON.stringify(request.Raw.data));\n  });\n\n/**\n * ---------------------------------------------------------------------------------------------------\n *                                   Mutate & Validate Actions (CM Example 2)                                *\n * ---------------------------------------------------------------------------------------------------\n *\n * This combines 3 different types of actions: \'Mutate\', \'Validate\', and \'Watch\'. The order\n * of the actions is required, but each action is optional. In this example, when a ConfigMap is created\n * with the name `example-2`, then add a label and annotation, validate that the ConfigMap has the label\n * `pepr`, and log the request.\n */\nWhen(a.ConfigMap)\n  .IsCreated()\n  .WithName("example-2")\n  .Mutate(request => {\n    // This Mutate Action will mutate the request before it is persisted to the cluster\n\n    // Use `request.Merge()` to merge the new data with the existing data\n    request.Merge({\n      metadata: {\n        labels: {\n          pepr: "was-here",\n        },\n        annotations: {\n          "pepr.dev": "annotations-work-too",\n        },\n      },\n    });\n  })\n  .Validate(request => {\n    // This Validate Action will validate the request before it is persisted to the cluster\n\n    // Approve the request if the ConfigMap has the label \'pepr\'\n    if (request.HasLabel("pepr")) {\n      return request.Approve();\n    }\n\n    // Otherwise, deny the request with an error message (optional)\n    return request.Deny("ConfigMap must have label \'pepr\'");\n  })\n  .Watch((cm, phase) => {\n    // This Watch Action will watch the ConfigMap after it has been persisted to the cluster\n    Log.info(cm, `ConfigMap was ${phase} with the name example-2`);\n  });\n\n/**\n * ---------------------------------------------------------------------------------------------------\n *                                   Mutate Action (CM Example 2a)                               *\n * ---------------------------------------------------------------------------------------------------\n *\n * This action shows a simple validation that will deny any ConfigMap that has the\n * annotation `evil`. Note that the `Deny()` function takes an optional second parameter that is a\n * user-defined status code to return.\n */\nWhen(a.ConfigMap)\n  .IsCreated()\n  .Validate(request => {\n    if (request.HasAnnotation("evil")) {\n      return request.Deny("No evil CM annotations allowed.", 400);\n    }\n\n    return request.Approve();\n  });\n\n/**\n * ---------------------------------------------------------------------------------------------------\n *                                   Mutate Action (CM Example 3)                                *\n * ---------------------------------------------------------------------------------------------------\n *\n * This action combines different styles. Unlike the previous actions, this one will look\n * for any ConfigMap in the `pepr-demo` namespace that has the label `change=by-label` during either\n * CREATE or UPDATE. Note that all conditions added such as `WithName()`, `WithLabel()`, `InNamespace()`,\n * are ANDs so all conditions must be true for the request to be processed.\n */\nWhen(a.ConfigMap)\n  .IsCreatedOrUpdated()\n  .WithLabel("change", "by-label")\n  .Mutate(request => {\n    // The K8s object e are going to mutate\n    const cm = request.Raw;\n\n    // Get the username and uid of the K8s request\n    const { username, uid } = request.Request.userInfo;\n\n    // Store some data about the request in the configmap\n    cm.data["username"] = username;\n    cm.data["uid"] = uid;\n\n    // You can still mix other ways of making changes too\n    request.SetAnnotation("pepr.dev", "making-waves");\n  });\n\n// This action validates the label `change=by-label` is deleted\nWhen(a.ConfigMap)\n  .IsDeleted()\n  .WithLabel("change", "by-label")\n  .Validate(request => {\n    // Log and then always approve the request\n    Log.info("CM with label \'change=by-label\' was deleted.");\n    return request.Approve();\n  });\n\n/**\n * ---------------------------------------------------------------------------------------------------\n *                                   Mutate Action (CM Example 4)                                *\n * ---------------------------------------------------------------------------------------------------\n *\n * This action show how you can use the `Mutate()` function without an inline function.\n * This is useful if you want to keep your actions small and focused on a single task,\n * or if you want to reuse the same function in multiple actions.\n */\nWhen(a.ConfigMap).IsCreated().WithName("example-4").Mutate(example4Cb);\n\n// This function uses the complete type definition, but is not required.\nfunction example4Cb(cm: PeprMutateRequest<a.ConfigMap>) {\n  cm.SetLabel("pepr.dev/first", "true");\n  cm.SetLabel("pepr.dev/second", "true");\n  cm.SetLabel("pepr.dev/third", "true");\n}\n\n/**\n * ---------------------------------------------------------------------------------------------------\n *                                   Mutate Action (CM Example 4a)                                *\n * ---------------------------------------------------------------------------------------------------\n *\n * This is the same as Example 4, except this only operates on a CM in the `pepr-demo-2` namespace.\n * Note because the Capability defines namespaces, the namespace specified here must be one of those.\n * Alternatively, you can remove the namespace from the Capability definition and specify it here.\n */\nWhen(a.ConfigMap)\n  .IsCreated()\n  .InNamespace("pepr-demo-2")\n  .WithName("example-4a")\n  .Mutate(example4Cb);\n\n/**\n * ---------------------------------------------------------------------------------------------------\n *                                   Mutate Action (CM Example 5)                                *\n * ---------------------------------------------------------------------------------------------------\n *\n * This action is a bit more complex. It will look for any ConfigMap in the `pepr-demo`\n * namespace that has the label `chuck-norris` during CREATE. When it finds one, it will fetch a\n * random Chuck Norris joke from the API and add it to the ConfigMap. This is a great example of how\n * you can use Pepr to make changes to your K8s objects based on external data.\n *\n * Note the use of the `async` keyword. This is required for any action that uses `await` or `fetch()`.\n *\n * Also note we are passing a type to the `fetch()` function. This is optional, but it will help you\n * avoid mistakes when working with the data returned from the API. You can also use the `as` keyword to\n * cast the data returned from the API.\n *\n * These are equivalent:\n * ```ts\n * const joke = await fetch<TheChuckNorrisJoke>("https://api.chucknorris.io/jokes/random?category=dev");\n * const joke = await fetch("https://api.chucknorris.io/jokes/random?category=dev") as TheChuckNorrisJoke;\n * ```\n *\n * Alternatively, you can drop the type completely:\n *\n * ```ts\n * fetch("https://api.chucknorris.io/jokes/random?category=dev")\n * ```\n */\ninterface TheChuckNorrisJoke {\n  icon_url: string;\n  id: string;\n  url: string;\n  value: string;\n}\n\nWhen(a.ConfigMap)\n  .IsCreated()\n  .WithLabel("chuck-norris")\n  .Mutate(async change => {\n    // Try/catch is not needed as a response object will always be returned\n    const response = await fetch<TheChuckNorrisJoke>(\n      "https://api.chucknorris.io/jokes/random?category=dev",\n    );\n\n    // Instead, check the `response.ok` field\n    if (response.ok) {\n      // Add the Chuck Norris joke to the configmap\n      change.Raw.data["chuck-says"] = response.data.value;\n      return;\n    }\n\n    // You can also assert on different HTTP response codes\n    if (response.status === fetchStatus.NOT_FOUND) {\n      // Do something else\n      return;\n    }\n  });\n\n/**\n * ---------------------------------------------------------------------------------------------------\n *                                   Mutate Action (Secret Base64 Handling)                      *\n * ---------------------------------------------------------------------------------------------------\n *\n * The K8s JS client provides incomplete support for base64 encoding/decoding handling for secrets,\n * unlike the GO client. To make this less painful, Pepr automatically handles base64 encoding/decoding\n * secret data before and after the action is executed.\n */\nWhen(a.Secret)\n  .IsCreated()\n  .WithName("secret-1")\n  .Mutate(request => {\n    const secret = request.Raw;\n\n    // This will be encoded at the end of all processing back to base64: "Y2hhbmdlLXdpdGhvdXQtZW5jb2Rpbmc="\n    secret.data.magic = "change-without-encoding";\n\n    // You can modify the data directly, and it will be encoded at the end of all processing\n    secret.data.example += " - modified by Pepr";\n  });\n\n/**\n * ---------------------------------------------------------------------------------------------------\n *                                   Mutate Action (Untyped Custom Resource)                     *\n * ---------------------------------------------------------------------------------------------------\n *\n * Out of the box, Pepr supports all the standard Kubernetes objects. However, you can also create\n * your own types. This is useful if you are working with an Operator that creates custom resources.\n * There are two ways to do this, the first is to use the `When()` function with a `GenericKind`,\n * the second is to create a new class that extends `GenericKind` and use the `RegisterKind()` function.\n *\n * This example shows how to use the `When()` function with a `GenericKind`. Note that you\n * must specify the `group`, `version`, and `kind` of the object (if applicable). This is how Pepr knows\n * if the action should be triggered or not. Since we are using a `GenericKind`,\n * Pepr will not be able to provide any intellisense for the object, so you will need to refer to the\n * Kubernetes API documentation for the object you are working with.\n *\n * You will need to wait for the CRD in `hello-pepr.samples.yaml` to be created, then you can apply\n *\n * ```yaml\n * apiVersion: pepr.dev/v1\n * kind: Unicorn\n * metadata:\n *   name: example-1\n *   namespace: pepr-demo\n * spec:\n *   message: replace-me\n *   counter: 0\n * ```\n */\nWhen(a.GenericKind, {\n  group: "pepr.dev",\n  version: "v1",\n  kind: "Unicorn",\n})\n  .IsCreated()\n  .WithName("example-1")\n  .Mutate(request => {\n    request.Merge({\n      spec: {\n        message: "Hello Pepr without type data!",\n        counter: Math.random(),\n      },\n    });\n  });\n\n/**\n * ---------------------------------------------------------------------------------------------------\n *                                   Mutate Action (Typed Custom Resource)                       *\n * ---------------------------------------------------------------------------------------------------\n *\n * This example shows how to use the `RegisterKind()` function to create a new type. This is useful\n * if you are working with an Operator that creates custom resources and you want to have intellisense\n * for the object. Note that you must specify the `group`, `version`, and `kind` of the object (if applicable)\n * as this is how Pepr knows if the action should be triggered or not.\n *\n * Once you register a new Kind with Pepr, you can use the `When()` function with the new Kind. Ideally,\n * you should register custom Kinds at the top of your Capability file or Pepr Module so they are available\n * to all actions, but we are putting it here for demonstration purposes.\n *\n * You will need to wait for the CRD in `hello-pepr.samples.yaml` to be created, then you can apply\n *\n * ```yaml\n * apiVersion: pepr.dev/v1\n * kind: Unicorn\n * metadata:\n *   name: example-2\n *   namespace: pepr-demo\n * spec:\n *   message: replace-me\n *   counter: 0\n * ```*\n */\nclass UnicornKind extends a.GenericKind {\n  spec: {\n    /**\n     * JSDoc comments can be added to explain more details about the field.\n     *\n     * @example\n     * ```ts\n     * request.Raw.spec.message = "Hello Pepr!";\n     * ```\n     * */\n    message: string;\n    counter: number;\n  };\n}\n\nRegisterKind(UnicornKind, {\n  group: "pepr.dev",\n  version: "v1",\n  kind: "Unicorn",\n});\n\nWhen(UnicornKind)\n  .IsCreated()\n  .WithName("example-2")\n  .Mutate(request => {\n    request.Merge({\n      spec: {\n        message: "Hello Pepr with type data!",\n        counter: Math.random(),\n      },\n    });\n  });\n\n/**\n * A callback function that is called once the Pepr Store is fully loaded.\n */\nStore.onReady(data => {\n  Log.info(data, "Pepr Store Ready");\n});\n';
-var packageJSON = { name: "pepr", description: "Kubernetes application engine", author: "Defense Unicorns", homepage: "https://github.com/defenseunicorns/pepr", license: "Apache-2.0", bin: "dist/cli.js", repository: "defenseunicorns/pepr", engines: { node: ">=18.0.0" }, version: "0.32.0", main: "dist/lib.js", types: "dist/lib.d.ts", scripts: { "gen-data-json": "node hack/build-template-data.js", prebuild: "rm -fr dist/* && npm run gen-data-json", build: "tsc && node build.mjs", "build:image": "npm run build && docker buildx build --tag pepr:dev .", test: "npm run test:unit && npm run test:journey", "test:unit": "npm run gen-data-json && jest src --coverage --detectOpenHandles --coverageDirectory=./coverage", "test:journey": "npm run test:journey:k3d && npm run test:journey:build && npm run test:journey:image && npm run test:journey:run", "test:journey:prep": "if [ ! -d ./pepr-upgrade-test ]; then git clone https://github.com/defenseunicorns/pepr-upgrade-test.git ; fi", "test:journey-wasm": "npm run test:journey:k3d && npm run test:journey:build && npm run test:journey:image && npm run test:journey:run-wasm", "test:journey:k3d": "k3d cluster delete pepr-dev && k3d cluster create pepr-dev --k3s-arg '--debug@server:0' --wait && kubectl rollout status deployment -n kube-system", "test:journey:build": "npm run build && npm pack", "test:journey:image": "docker buildx build --tag pepr:dev . && k3d image import pepr:dev -c pepr-dev", "test:journey:run": "jest --detectOpenHandles journey/entrypoint.test.ts && npm run test:journey:prep && npm run test:journey:upgrade", "test:journey:run-wasm": "jest --detectOpenHandles journey/entrypoint-wasm.test.ts", "test:journey:upgrade": "npm run test:journey:k3d && npm run test:journey:image && jest --detectOpenHandles journey/pepr-upgrade.test.ts", "format:check": "eslint src && prettier src --check", "format:fix": "eslint src --fix && prettier src --write" }, dependencies: { "@types/ramda": "0.30.0", express: "4.19.2", "fast-json-patch": "3.1.1", "kubernetes-fluent-client": "2.6.1", pino: "9.2.0", "pino-pretty": "11.2.0", "prom-client": "15.1.2", ramda: "0.30.1" }, devDependencies: { "@commitlint/cli": "19.3.0", "@commitlint/config-conventional": "19.2.2", "@jest/globals": "29.7.0", "@types/eslint": "8.56.10", "@types/express": "4.17.21", "@types/node": "18.x.x", "@types/node-forge": "1.3.11", "@types/prompts": "2.4.9", "@types/uuid": "9.0.8", jest: "29.7.0", nock: "13.5.4", "ts-jest": "29.1.4" }, peerDependencies: { "@typescript-eslint/eslint-plugin": "6.15.0", "@typescript-eslint/parser": "6.15.0", commander: "11.1.0", esbuild: "0.19.10", eslint: "8.56.0", "node-forge": "1.3.1", prettier: "3.1.1", prompts: "2.4.2", typescript: "5.3.3", uuid: "9.0.1" } };
+var packageJSON = { name: "pepr", description: "Kubernetes application engine", author: "Defense Unicorns", homepage: "https://github.com/defenseunicorns/pepr", license: "Apache-2.0", bin: "dist/cli.js", repository: "defenseunicorns/pepr", engines: { node: ">=18.0.0" }, version: "0.32.2", main: "dist/lib.js", types: "dist/lib.d.ts", scripts: { "gen-data-json": "node hack/build-template-data.js", prebuild: "rm -fr dist/* && npm run gen-data-json", build: "tsc && node build.mjs", "build:image": "npm run build && docker buildx build --tag pepr:dev .", test: "npm run test:unit && npm run test:journey", "test:unit": "npm run gen-data-json && jest src --coverage --detectOpenHandles --coverageDirectory=./coverage", "test:journey": "npm run test:journey:k3d && npm run test:journey:build && npm run test:journey:image && npm run test:journey:run", "test:journey:prep": "if [ ! -d ./pepr-upgrade-test ]; then git clone https://github.com/defenseunicorns/pepr-upgrade-test.git ; fi", "test:journey-wasm": "npm run test:journey:k3d && npm run test:journey:build && npm run test:journey:image && npm run test:journey:run-wasm", "test:journey:k3d": "k3d cluster delete pepr-dev && k3d cluster create pepr-dev --k3s-arg '--debug@server:0' --wait && kubectl rollout status deployment -n kube-system", "test:journey:build": "npm run build && npm pack", "test:journey:image": "docker buildx build --tag pepr:dev . && k3d image import pepr:dev -c pepr-dev", "test:journey:run": "jest --detectOpenHandles journey/entrypoint.test.ts && npm run test:journey:prep && npm run test:journey:upgrade", "test:journey:run-wasm": "jest --detectOpenHandles journey/entrypoint-wasm.test.ts", "test:journey:upgrade": "npm run test:journey:k3d && npm run test:journey:image && jest --detectOpenHandles journey/pepr-upgrade.test.ts", "format:check": "eslint src && prettier src --check", "format:fix": "eslint src --fix && prettier src --write" }, dependencies: { "@types/ramda": "0.30.0", express: "4.19.2", "fast-json-patch": "3.1.1", "kubernetes-fluent-client": "2.6.1", pino: "9.2.0", "pino-pretty": "11.2.1", "prom-client": "15.1.2", ramda: "0.30.1" }, devDependencies: { "@commitlint/cli": "19.3.0", "@commitlint/config-conventional": "19.2.2", "@jest/globals": "29.7.0", "@types/eslint": "8.56.10", "@types/express": "4.17.21", "@types/node": "18.x.x", "@types/node-forge": "1.3.11", "@types/prompts": "2.4.9", "@types/uuid": "9.0.8", jest: "29.7.0", nock: "13.5.4", "ts-jest": "29.1.4" }, peerDependencies: { "@typescript-eslint/eslint-plugin": "6.15.0", "@typescript-eslint/parser": "6.15.0", commander: "11.1.0", esbuild: "0.19.10", eslint: "8.56.0", "node-forge": "1.3.1", prettier: "3.1.1", prompts: "2.4.2", typescript: "5.3.3", uuid: "9.0.1" } };
 
 // src/templates/pepr.code-snippets.json
 var pepr_code_snippets_default = {

package/dist/controller.js

@@ -51,7 +51,7 @@ if (process.env.LOG_LEVEL) {
 var logger_default = Log;
 
 // src/templates/data.json
-var packageJSON = { name: "pepr", description: "Kubernetes application engine", author: "Defense Unicorns", homepage: "https://github.com/defenseunicorns/pepr", license: "Apache-2.0", bin: "dist/cli.js", repository: "defenseunicorns/pepr", engines: { node: ">=18.0.0" }, version: "0.32.0", main: "dist/lib.js", types: "dist/lib.d.ts", scripts: { "gen-data-json": "node hack/build-template-data.js", prebuild: "rm -fr dist/* && npm run gen-data-json", build: "tsc && node build.mjs", "build:image": "npm run build && docker buildx build --tag pepr:dev .", test: "npm run test:unit && npm run test:journey", "test:unit": "npm run gen-data-json && jest src --coverage --detectOpenHandles --coverageDirectory=./coverage", "test:journey": "npm run test:journey:k3d && npm run test:journey:build && npm run test:journey:image && npm run test:journey:run", "test:journey:prep": "if [ ! -d ./pepr-upgrade-test ]; then git clone https://github.com/defenseunicorns/pepr-upgrade-test.git ; fi", "test:journey-wasm": "npm run test:journey:k3d && npm run test:journey:build && npm run test:journey:image && npm run test:journey:run-wasm", "test:journey:k3d": "k3d cluster delete pepr-dev && k3d cluster create pepr-dev --k3s-arg '--debug@server:0' --wait && kubectl rollout status deployment -n kube-system", "test:journey:build": "npm run build && npm pack", "test:journey:image": "docker buildx build --tag pepr:dev . && k3d image import pepr:dev -c pepr-dev", "test:journey:run": "jest --detectOpenHandles journey/entrypoint.test.ts && npm run test:journey:prep && npm run test:journey:upgrade", "test:journey:run-wasm": "jest --detectOpenHandles journey/entrypoint-wasm.test.ts", "test:journey:upgrade": "npm run test:journey:k3d && npm run test:journey:image && jest --detectOpenHandles journey/pepr-upgrade.test.ts", "format:check": "eslint src && prettier src --check", "format:fix": "eslint src --fix && prettier src --write" }, dependencies: { "@types/ramda": "0.30.0", express: "4.19.2", "fast-json-patch": "3.1.1", "kubernetes-fluent-client": "2.6.1", pino: "9.2.0", "pino-pretty": "11.2.0", "prom-client": "15.1.2", ramda: "0.30.1" }, devDependencies: { "@commitlint/cli": "19.3.0", "@commitlint/config-conventional": "19.2.2", "@jest/globals": "29.7.0", "@types/eslint": "8.56.10", "@types/express": "4.17.21", "@types/node": "18.x.x", "@types/node-forge": "1.3.11", "@types/prompts": "2.4.9", "@types/uuid": "9.0.8", jest: "29.7.0", nock: "13.5.4", "ts-jest": "29.1.4" }, peerDependencies: { "@typescript-eslint/eslint-plugin": "6.15.0", "@typescript-eslint/parser": "6.15.0", commander: "11.1.0", esbuild: "0.19.10", eslint: "8.56.0", "node-forge": "1.3.1", prettier: "3.1.1", prompts: "2.4.2", typescript: "5.3.3", uuid: "9.0.1" } };
+var packageJSON = { name: "pepr", description: "Kubernetes application engine", author: "Defense Unicorns", homepage: "https://github.com/defenseunicorns/pepr", license: "Apache-2.0", bin: "dist/cli.js", repository: "defenseunicorns/pepr", engines: { node: ">=18.0.0" }, version: "0.32.2", main: "dist/lib.js", types: "dist/lib.d.ts", scripts: { "gen-data-json": "node hack/build-template-data.js", prebuild: "rm -fr dist/* && npm run gen-data-json", build: "tsc && node build.mjs", "build:image": "npm run build && docker buildx build --tag pepr:dev .", test: "npm run test:unit && npm run test:journey", "test:unit": "npm run gen-data-json && jest src --coverage --detectOpenHandles --coverageDirectory=./coverage", "test:journey": "npm run test:journey:k3d && npm run test:journey:build && npm run test:journey:image && npm run test:journey:run", "test:journey:prep": "if [ ! -d ./pepr-upgrade-test ]; then git clone https://github.com/defenseunicorns/pepr-upgrade-test.git ; fi", "test:journey-wasm": "npm run test:journey:k3d && npm run test:journey:build && npm run test:journey:image && npm run test:journey:run-wasm", "test:journey:k3d": "k3d cluster delete pepr-dev && k3d cluster create pepr-dev --k3s-arg '--debug@server:0' --wait && kubectl rollout status deployment -n kube-system", "test:journey:build": "npm run build && npm pack", "test:journey:image": "docker buildx build --tag pepr:dev . && k3d image import pepr:dev -c pepr-dev", "test:journey:run": "jest --detectOpenHandles journey/entrypoint.test.ts && npm run test:journey:prep && npm run test:journey:upgrade", "test:journey:run-wasm": "jest --detectOpenHandles journey/entrypoint-wasm.test.ts", "test:journey:upgrade": "npm run test:journey:k3d && npm run test:journey:image && jest --detectOpenHandles journey/pepr-upgrade.test.ts", "format:check": "eslint src && prettier src --check", "format:fix": "eslint src --fix && prettier src --write" }, dependencies: { "@types/ramda": "0.30.0", express: "4.19.2", "fast-json-patch": "3.1.1", "kubernetes-fluent-client": "2.6.1", pino: "9.2.0", "pino-pretty": "11.2.1", "prom-client": "15.1.2", ramda: "0.30.1" }, devDependencies: { "@commitlint/cli": "19.3.0", "@commitlint/config-conventional": "19.2.2", "@jest/globals": "29.7.0", "@types/eslint": "8.56.10", "@types/express": "4.17.21", "@types/node": "18.x.x", "@types/node-forge": "1.3.11", "@types/prompts": "2.4.9", "@types/uuid": "9.0.8", jest: "29.7.0", nock: "13.5.4", "ts-jest": "29.1.4" }, peerDependencies: { "@typescript-eslint/eslint-plugin": "6.15.0", "@typescript-eslint/parser": "6.15.0", commander: "11.1.0", esbuild: "0.19.10", eslint: "8.56.0", "node-forge": "1.3.1", prettier: "3.1.1", prompts: "2.4.2", typescript: "5.3.3", uuid: "9.0.1" } };
 
 // src/lib/k8s.ts
 var import_kubernetes_fluent_client = require("kubernetes-fluent-client");

package/dist/lib/assets/deploy.d.ts

@@ -0,0 +1,3 @@
+import { Assets } from ".";
+export declare function deploy(assets: Assets, force: boolean, webhookTimeout?: number): Promise<void>;
+//# sourceMappingURL=deploy.d.ts.map

package/dist/lib/assets/destroy.d.ts

@@ -0,0 +1,2 @@
+export declare function destroyModule(name: string): Promise<void>;
+//# sourceMappingURL=destroy.d.ts.map

package/dist/lib/assets/helm.d.ts

@@ -0,0 +1,5 @@
+export declare function nsTemplate(): string;
+export declare function chartYaml(name: string, description?: string): string;
+export declare function watcherDeployTemplate(buildTimestamp: string): string;
+export declare function admissionDeployTemplate(buildTimestamp: string): string;
+//# sourceMappingURL=helm.d.ts.map

package/dist/lib/assets/index.d.ts

@@ -0,0 +1,25 @@
+import { ModuleConfig } from "../module";
+import { TLSOut } from "../tls";
+import { CapabilityExport } from "../types";
+import { WebhookIgnore } from "../k8s";
+export declare class Assets {
+    readonly config: ModuleConfig;
+    readonly path: string;
+    readonly host?: string | undefined;
+    readonly name: string;
+    readonly tls: TLSOut;
+    readonly apiToken: string;
+    readonly alwaysIgnore: WebhookIgnore;
+    capabilities: CapabilityExport[];
+    image: string;
+    buildTimestamp: string;
+    hash: string;
+    constructor(config: ModuleConfig, path: string, host?: string | undefined);
+    setHash: (hash: string) => void;
+    deploy: (force: boolean, webhookTimeout?: number) => Promise<void>;
+    zarfYaml: (path: string) => string;
+    zarfYamlChart: (path: string) => string;
+    allYaml: (rbacMode: string) => Promise<string>;
+    generateHelmChart: (basePath: string) => Promise<void>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/assets/loader.d.ts

@@ -0,0 +1,8 @@
+import { CapabilityExport } from "../types";
+/**
+ * Read the capabilities from the module by running it in build mode
+ * @param path
+ * @returns
+ */
+export declare function loadCapabilities(path: string): Promise<CapabilityExport[]>;
+//# sourceMappingURL=loader.d.ts.map

package/dist/lib/assets/networking.d.ts

@@ -0,0 +1,7 @@
+import { kind } from "kubernetes-fluent-client";
+import { TLSOut } from "../tls";
+export declare function apiTokenSecret(name: string, apiToken: string): kind.Secret;
+export declare function tlsSecret(name: string, tls: TLSOut): kind.Secret;
+export declare function service(name: string): kind.Service;
+export declare function watcherService(name: string): kind.Service;
+//# sourceMappingURL=networking.d.ts.map

package/dist/lib/assets/pods.d.ts

@@ -0,0 +1,126 @@
+/// <reference types="node" />
+import { V1EnvVar } from "@kubernetes/client-node";
+import { kind } from "kubernetes-fluent-client";
+import { Assets } from ".";
+/** Generate the pepr-system namespace */
+export declare function namespace(namespaceLabels?: Record<string, string>): {
+    apiVersion: string;
+    kind: string;
+    metadata: {
+        name: string;
+        labels: Record<string, string>;
+    };
+} | {
+    apiVersion: string;
+    kind: string;
+    metadata: {
+        name: string;
+        labels?: undefined;
+    };
+};
+export declare function watcher(assets: Assets, hash: string, buildTimestamp: string): {
+    apiVersion: string;
+    kind: string;
+    metadata: {
+        name: string;
+        namespace: string;
+        annotations: {
+            "pepr.dev/description": string;
+        };
+        labels: {
+            app: string;
+            "pepr.dev/controller": string;
+            "pepr.dev/uuid": string;
+        };
+    };
+    spec: {
+        replicas: number;
+        strategy: {
+            type: string;
+        };
+        selector: {
+            matchLabels: {
+                app: string;
+                "pepr.dev/controller": string;
+            };
+        };
+        template: {
+            metadata: {
+                annotations: {
+                    buildTimestamp: string;
+                };
+                labels: {
+                    app: string;
+                    "pepr.dev/controller": string;
+                };
+            };
+            spec: {
+                terminationGracePeriodSeconds: number;
+                serviceAccountName: string;
+                securityContext: {
+                    runAsUser: number;
+                    runAsGroup: number;
+                    runAsNonRoot: boolean;
+                    fsGroup: number;
+                };
+                containers: {
+                    name: string;
+                    image: string;
+                    imagePullPolicy: string;
+                    command: string[];
+                    readinessProbe: {
+                        httpGet: {
+                            path: string;
+                            port: number;
+                            scheme: string;
+                        };
+                    };
+                    livenessProbe: {
+                        httpGet: {
+                            path: string;
+                            port: number;
+                            scheme: string;
+                        };
+                    };
+                    ports: {
+                        containerPort: number;
+                    }[];
+                    resources: {
+                        requests: {
+                            memory: string;
+                            cpu: string;
+                        };
+                        limits: {
+                            memory: string;
+                            cpu: string;
+                        };
+                    };
+                    securityContext: {
+                        runAsUser: number;
+                        runAsGroup: number;
+                        runAsNonRoot: boolean;
+                        allowPrivilegeEscalation: boolean;
+                        capabilities: {
+                            drop: string[];
+                        };
+                    };
+                    volumeMounts: {
+                        name: string;
+                        mountPath: string;
+                        readOnly: boolean;
+                    }[];
+                    env: V1EnvVar[];
+                }[];
+                volumes: {
+                    name: string;
+                    secret: {
+                        secretName: string;
+                    };
+                }[];
+            };
+        };
+    };
+} | null;
+export declare function deployment(assets: Assets, hash: string, buildTimestamp: string): kind.Deployment;
+export declare function moduleSecret(name: string, data: Buffer, hash: string): kind.Secret;
+//# sourceMappingURL=pods.d.ts.map

package/dist/lib/assets/rbac.d.ts

@@ -0,0 +1,14 @@
+import { kind } from "kubernetes-fluent-client";
+import { CapabilityExport } from "../types";
+/**
+ * Grants the controller access to cluster resources beyond the mutating webhook.
+ *
+ * @todo: should dynamically generate this based on resources used by the module. will also need to explore how this should work for multiple modules.
+ * @returns
+ */
+export declare function clusterRole(name: string, capabilities: CapabilityExport[], rbacMode?: string): kind.ClusterRole;
+export declare function clusterRoleBinding(name: string): kind.ClusterRoleBinding;
+export declare function serviceAccount(name: string): kind.ServiceAccount;
+export declare function storeRole(name: string): kind.Role;
+export declare function storeRoleBinding(name: string): kind.RoleBinding;
+//# sourceMappingURL=rbac.d.ts.map

package/dist/lib/assets/store.d.ts

@@ -0,0 +1,7 @@
+import { kind as k } from "kubernetes-fluent-client";
+export declare const group: string, version: string, kind: string;
+export declare const singular: string;
+export declare const plural: string;
+export declare const name: string;
+export declare const peprStoreCRD: k.CustomResourceDefinition;
+//# sourceMappingURL=store.d.ts.map

package/dist/lib/assets/webhooks.d.ts

@@ -0,0 +1,6 @@
+import { V1RuleWithOperations } from "@kubernetes/client-node";
+import { kind } from "kubernetes-fluent-client";
+import { Assets } from ".";
+export declare function generateWebhookRules(assets: Assets, isMutateWebhook: boolean): Promise<V1RuleWithOperations[]>;
+export declare function webhookConfig(assets: Assets, mutateOrValidate: "mutate" | "validate", timeoutSeconds?: number): Promise<kind.MutatingWebhookConfiguration | kind.ValidatingWebhookConfiguration | null>;
+//# sourceMappingURL=webhooks.d.ts.map

package/dist/lib/assets/yaml.d.ts

@@ -0,0 +1,6 @@
+import { Assets } from ".";
+export declare function overridesFile({ hash, name, image, config, apiToken }: Assets, path: string): Promise<void>;
+export declare function zarfYaml({ name, image, config }: Assets, path: string): string;
+export declare function zarfYamlChart({ name, image, config }: Assets, path: string): string;
+export declare function allYaml(assets: Assets, rbacMode: string): Promise<string>;
+//# sourceMappingURL=yaml.d.ts.map

package/dist/lib/capability.d.ts

@@ -0,0 +1,66 @@
+import { GenericClass, GroupVersionKind } from "kubernetes-fluent-client";
+import { PeprStore, Storage } from "./storage";
+import { Schedule } from "./schedule";
+import { Binding, CapabilityCfg, CapabilityExport, WhenSelector } from "./types";
+/**
+ * A capability is a unit of functionality that can be registered with the Pepr runtime.
+ */
+export declare class Capability implements CapabilityExport {
+    #private;
+    hasSchedule: boolean;
+    /**
+     * Run code on a schedule with the capability.
+     *
+     * @param schedule The schedule to run the code on
+     * @returns
+     */
+    OnSchedule: (schedule: Schedule) => void;
+    /**
+     * Store is a key-value data store that can be used to persist data that should be shared
+     * between requests. Each capability has its own store, and the data is persisted in Kubernetes
+     * in the `pepr-system` namespace.
+     *
+     * Note: You should only access the store from within an action.
+     */
+    Store: PeprStore;
+    /**
+     * ScheduleStore is a key-value data store used to persist schedule data that should be shared
+     * between intervals. Each Schedule shares store, and the data is persisted in Kubernetes
+     * in the `pepr-system` namespace.
+     *
+     * Note: There is no direct access to schedule store
+     */
+    ScheduleStore: PeprStore;
+    get bindings(): Binding[];
+    get name(): string;
+    get description(): string;
+    get namespaces(): string[];
+    constructor(cfg: CapabilityCfg);
+    /**
+     * Register the store with the capability. This is called automatically by the Pepr controller.
+     *
+     * @param store
+     */
+    registerScheduleStore: () => {
+        scheduleStore: Storage;
+    };
+    /**
+     * Register the store with the capability. This is called automatically by the Pepr controller.
+     *
+     * @param store
+     */
+    registerStore: () => {
+        store: Storage;
+    };
+    /**
+     * The When method is used to register a action to be executed when a Kubernetes resource is
+     * processed by Pepr. The action will be executed if the resource matches the specified kind and any
+     * filters that are applied.
+     *
+     * @param model the KubernetesObject model to match
+     * @param kind if using a custom KubernetesObject not available in `a.*`, specify the GroupVersionKind
+     * @returns
+     */
+    When: <T extends GenericClass>(model: T, kind?: GroupVersionKind) => WhenSelector<T>;
+}
+//# sourceMappingURL=capability.d.ts.map

package/dist/lib/controller/index.d.ts

@@ -0,0 +1,10 @@
+import { Capability } from "../capability";
+import { MutateResponse, AdmissionRequest, ValidateResponse } from "../k8s";
+import { ModuleConfig } from "../module";
+export declare class Controller {
+    #private;
+    constructor(config: ModuleConfig, capabilities: Capability[], beforeHook?: (req: AdmissionRequest) => void, afterHook?: (res: MutateResponse | ValidateResponse) => void, onReady?: () => void);
+    /** Start the webhook server */
+    startServer: (port: number) => void;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/controller/store.d.ts

@@ -0,0 +1,7 @@
+import { Capability } from "../capability";
+export declare const debounceBackoff = 5000;
+export declare class PeprControllerStore {
+    #private;
+    constructor(capabilities: Capability[], name: string, onReady?: () => void);
+}
+//# sourceMappingURL=store.d.ts.map

package/dist/lib/errors.d.ts

@@ -0,0 +1,12 @@
+export declare const Errors: {
+    audit: string;
+    ignore: string;
+    reject: string;
+};
+export declare const ErrorList: string[];
+/**
+ * Validate the error or throw an error
+ * @param error
+ */
+export declare function ValidateError(error?: string): void;
+//# sourceMappingURL=errors.d.ts.map

package/dist/lib/filter.d.ts

@@ -0,0 +1,11 @@
+import { AdmissionRequest } from "./k8s";
+import { Binding } from "./types";
+/**
+ * shouldSkipRequest determines if a request should be skipped based on the binding filters.
+ *
+ * @param binding the action binding
+ * @param req the incoming request
+ * @returns
+ */
+export declare function shouldSkipRequest(binding: Binding, req: AdmissionRequest, capabilityNamespaces: string[]): boolean;
+//# sourceMappingURL=filter.d.ts.map

package/dist/lib/helpers.d.ts

@@ -0,0 +1,34 @@
+import { KubernetesObject } from "kubernetes-fluent-client";
+import { Binding, CapabilityExport } from "./types";
+export declare class ValidationError extends Error {
+}
+export declare function validateCapabilityNames(capabilities: CapabilityExport[] | undefined): void;
+export declare function validateHash(expectedHash: string): void;
+type RBACMap = {
+    [key: string]: {
+        verbs: string[];
+        plural: string;
+    };
+};
+export declare function checkOverlap(bindingFilters: Record<string, string>, objectFilters: Record<string, string>): boolean;
+/**
+ * Decide to run callback after the event comes back from API Server
+ **/
+export declare function filterNoMatchReason(binding: Partial<Binding>, obj: Partial<KubernetesObject>, capabilityNamespaces: string[]): string;
+export declare function addVerbIfNotExists(verbs: string[], verb: string): void;
+export declare function createRBACMap(capabilities: CapabilityExport[]): RBACMap;
+export declare function createDirectoryIfNotExists(path: string): Promise<void>;
+export declare function hasEveryOverlap<T>(array1: T[], array2: T[]): boolean;
+export declare function hasAnyOverlap<T>(array1: T[], array2: T[]): boolean;
+export declare function ignoredNamespaceConflict(ignoreNamespaces: string[], bindingNamespaces: string[]): boolean;
+export declare function bindingAndCapabilityNSConflict(bindingNamespaces: string[], capabilityNamespaces: string[]): boolean;
+export declare function generateWatchNamespaceError(ignoredNamespaces: string[], bindingNamespaces: string[], capabilityNamespaces: string[]): string;
+export declare function namespaceComplianceValidator(capability: CapabilityExport, ignoredNamespaces?: string[]): void;
+export declare function checkDeploymentStatus(namespace: string): Promise<boolean>;
+export declare function namespaceDeploymentsReady(namespace?: string): Promise<true | undefined>;
+export declare function secretOverLimit(str: string): boolean;
+export declare const parseTimeout: (value: string, previous: unknown) => number;
+export declare function dedent(file: string): string;
+export declare function replaceString(str: string, stringA: string, stringB: string): string;
+export {};
+//# sourceMappingURL=helpers.d.ts.map

package/dist/lib/included-files.d.ts

@@ -0,0 +1,2 @@
+export declare function createDockerfile(version: string, description: string, includedFiles: string[]): Promise<void>;
+//# sourceMappingURL=included-files.d.ts.map

package/dist/lib/k8s.d.ts

@@ -0,0 +1,132 @@
+import { GenericKind, GroupVersionKind, KubernetesObject } from "kubernetes-fluent-client";
+export declare enum Operation {
+    CREATE = "CREATE",
+    UPDATE = "UPDATE",
+    DELETE = "DELETE",
+    CONNECT = "CONNECT"
+}
+/**
+ * PeprStore for internal use by Pepr. This is used to store arbitrary data in the cluster.
+ */
+export declare class PeprStore extends GenericKind {
+    data: {
+        [key: string]: string;
+    };
+}
+export declare const peprStoreGVK: {
+    kind: string;
+    version: string;
+    group: string;
+};
+/**
+ * GroupVersionResource unambiguously identifies a resource. It doesn't anonymously include GroupVersion
+ * to avoid automatic coercion. It doesn't use a GroupVersion to avoid custom marshalling
+ */
+export interface GroupVersionResource {
+    readonly group: string;
+    readonly version: string;
+    readonly resource: string;
+}
+/**
+ * A Kubernetes admission request to be processed by a capability.
+ */
+export interface AdmissionRequest<T = KubernetesObject> {
+    /** UID is an identifier for the individual request/response. */
+    readonly uid: string;
+    /** Kind is the fully-qualified type of object being submitted (for example, v1.Pod or autoscaling.v1.Scale) */
+    readonly kind: GroupVersionKind;
+    /** Resource is the fully-qualified resource being requested (for example, v1.pods) */
+    readonly resource: GroupVersionResource;
+    /** SubResource is the sub-resource being requested, if any (for example, "status" or "scale") */
+    readonly subResource?: string;
+    /** RequestKind is the fully-qualified type of the original API request (for example, v1.Pod or autoscaling.v1.Scale). */
+    readonly requestKind?: GroupVersionKind;
+    /** RequestResource is the fully-qualified resource of the original API request (for example, v1.pods). */
+    readonly requestResource?: GroupVersionResource;
+    /** RequestSubResource is the sub-resource of the original API request, if any (for example, "status" or "scale"). */
+    readonly requestSubResource?: string;
+    /**
+     * Name is the name of the object as presented in the request. On a CREATE operation, the client may omit name and
+     * rely on the server to generate the name. If that is the case, this method will return the empty string.
+     */
+    readonly name: string;
+    /** Namespace is the namespace associated with the request (if any). */
+    readonly namespace?: string;
+    /**
+     * Operation is the operation being performed. This may be different than the operation
+     * requested. e.g. a patch can result in either a CREATE or UPDATE Operation.
+     */
+    readonly operation: Operation;
+    /** UserInfo is information about the requesting user */
+    readonly userInfo: {
+        /** The name that uniquely identifies this user among all active users. */
+        username?: string;
+        /**
+         * A unique value that identifies this user across time. If this user is deleted
+         * and another user by the same name is added, they will have different UIDs.
+         */
+        uid?: string;
+        /** The names of groups this user is a part of. */
+        groups?: string[];
+        /** Any additional information provided by the authenticator. */
+        extra?: {
+            [key: string]: string[];
+        };
+    };
+    /** Object is the object from the incoming request prior to default values being applied */
+    readonly object: T;
+    /** OldObject is the existing object. Only populated for UPDATE or DELETE requests. */
+    readonly oldObject?: T;
+    /** DryRun indicates that modifications will definitely not be persisted for this request. Defaults to false. */
+    readonly dryRun?: boolean;
+    /**
+     * Options contains the options for the operation being performed.
+     * e.g. `meta.k8s.io/v1.DeleteOptions` or `meta.k8s.io/v1.CreateOptions`. This may be
+     * different than the options the caller provided. e.g. for a patch request the performed
+     * Operation might be a CREATE, in which case the Options will a
+     * `meta.k8s.io/v1.CreateOptions` even though the caller provided `meta.k8s.io/v1.PatchOptions`.
+     */
+    readonly options?: any;
+}
+export interface MutateResponse {
+    /** UID is an identifier for the individual request/response. This must be copied over from the corresponding AdmissionRequest. */
+    uid: string;
+    /** Allowed indicates whether or not the admission request was permitted. */
+    allowed: boolean;
+    /** Result contains extra details into why an admission request was denied. This field IS NOT consulted in any way if "Allowed" is "true". */
+    result?: string;
+    /** The patch body. Currently we only support "JSONPatch" which implements RFC 6902. */
+    patch?: string;
+    /** The type of Patch. Currently we only allow "JSONPatch". */
+    patchType?: "JSONPatch";
+    /**
+     * AuditAnnotations is an unstructured key value map set by remote admission controller (e.g. error=image-blacklisted).
+     *
+     * See https://kubernetes.io/docs/reference/labels-annotations-taints/audit-annotations/ for more information
+     */
+    auditAnnotations?: {
+        [key: string]: string;
+    };
+    /** warnings is a list of warning messages to return to the requesting API client. */
+    warnings?: string[];
+}
+export interface ValidateResponse extends MutateResponse {
+    /** Status contains extra details into why an admission request was denied. This field IS NOT consulted in any way if "Allowed" is "true". */
+    status?: {
+        /** A machine-readable description of why this operation is in the
+             "Failure" status. If this value is empty there is no information available. */
+        code: number;
+        /** A human-readable description of the status of this operation. */
+        message: string;
+    };
+}
+export type WebhookIgnore = {
+    /**
+     * List of Kubernetes namespaces to always ignore.
+     * Any resources in these namespaces will be ignored by Pepr.
+     *
+     * Note: `kube-system` and `pepr-system` are always ignored.
+     */
+    namespaces?: string[];
+};
+//# sourceMappingURL=k8s.d.ts.map

package/dist/lib/logger.d.ts

@@ -0,0 +1,3 @@
+declare const Log: import("pino").Logger<never>;
+export default Log;
+//# sourceMappingURL=logger.d.ts.map