@vfrey/vfrey 0.0.1 → 1.0.0-beta.0

package/vendor/framey/dist/play-BUTDQ4DV.js

@@ -0,0 +1,353 @@
+import { createRequire as __hf_createRequire } from "node:module";
+import { fileURLToPath as __hf_fileURLToPath } from "node:url";
+import { dirname as __hf_dirname } from "node:path";
+var require = __hf_createRequire(import.meta.url);
+var __filename = __hf_fileURLToPath(import.meta.url);
+var __dirname = __hf_dirname(__filename);
+import {
+  openBrowser,
+  parseRemoteDebuggingPort,
+  validateRemoteDebuggingPortDeps
+} from "./chunk-LFGJWOVA.js";
+import {
+  R,
+  ft,
+  ge
+} from "./chunk-WMQNIQDJ.js";
+import {
+  resolveProject
+} from "./chunk-O7BGSQ5F.js";
+import "./chunk-X7MTZ4T2.js";
+import {
+  assetContentType,
+  buildRangeResponse,
+  injectRuntime,
+  listenOnFreePort,
+  resolvePlayerPath,
+  resolveRuntimePath,
+  revalidatedResponse
+} from "./chunk-6DDPOHMK.js";
+import {
+  PROXY_VARIANT_CONFIG,
+  ProxyCapacityError,
+  ProxyTranscodeError,
+  decideMediaProxyEligibility,
+  injectMediaCodecMapIntoHtml,
+  isProxyVariantRequest,
+  probeAssetCodec,
+  recordProxyRequest,
+  resolveProxy,
+  resolveProxyVariantRequest
+} from "./chunk-THJALHFJ.js";
+import "./chunk-IUONB55J.js";
+import "./chunk-6JR2XUEE.js";
+import {
+  requestSubPath
+} from "./chunk-MI5FTLYK.js";
+import "./chunk-YPRBGITP.js";
+import "./chunk-7JQFJ6JJ.js";
+import "./chunk-P5ZBLXJ6.js";
+import {
+  resolveAutoProxy
+} from "./chunk-4BNN5FGX.js";
+import "./chunk-XT7X6QCP.js";
+import "./chunk-4YYJOFKS.js";
+import "./chunk-HVW7ABXD.js";
+import "./chunk-XX7LTW5Y.js";
+import "./chunk-JHOCK3DG.js";
+import "./chunk-XPTOJZJF.js";
+import "./chunk-RGLQURIX.js";
+import "./chunk-P6LJ4Y32.js";
+import "./chunk-GMECXFAN.js";
+import "./chunk-FLREUEHW.js";
+import "./chunk-EOVYQ3IG.js";
+import "./chunk-GNEFDLFB.js";
+import "./chunk-2UZQHDM7.js";
+import "./chunk-NYEXNSHM.js";
+import {
+  defineCommand
+} from "./chunk-S3S4TGEH.js";
+import "./chunk-54HJ63Q2.js";
+import "./chunk-ISN5GRYI.js";
+import {
+  c
+} from "./chunk-VORQIH64.js";
+import {
+  setCommandExitCode
+} from "./chunk-JVBRJMOP.js";
+import "./chunk-KLIKCX6Q.js";
+import "./chunk-EVMY7IPL.js";
+import "./chunk-7FMUTGOH.js";
+import "./chunk-IZCW2NKT.js";
+import "./chunk-RNV3DM4S.js";
+import "./chunk-DLA44CMS.js";
+import "./chunk-UJZREAV6.js";
+import "./chunk-VC76R6W2.js";
+import "./chunk-X7HBSTCZ.js";
+import "./chunk-B7RJV74O.js";
+import "./chunk-DPVXBVLL.js";
+import "./chunk-OFQWTKPW.js";
+import "./chunk-634HSJ3J.js";
+import "./chunk-FXMKHHPO.js";
+import "./chunk-RQVDTPGD.js";
+import "./chunk-AHX34EFP.js";
+import "./chunk-T2EUWCJE.js";
+import "./chunk-T6AGUTZJ.js";
+import "./chunk-XT6MXC7A.js";
+import "./chunk-4P7NX5BM.js";
+import "./chunk-VAS6HQX3.js";
+import "./chunk-6BNTGNGD.js";
+import "./chunk-CZGHFATT.js";
+import "./chunk-PKZ7RK5N.js";
+import "./chunk-W2LGJSEN.js";
+import "./chunk-MMQ52NIZ.js";
+import "./chunk-BSQ7XANM.js";
+import "./chunk-SDYDNHEE.js";
+import "./chunk-RXATE6FZ.js";
+import "./chunk-3422KMTD.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/commands/play.ts
+import { existsSync, readFileSync } from "fs";
+import { resolve } from "path";
+var examples = [
+  ["Play the current project", "framey play"],
+  ["Play a specific project directory", "framey play ./my-video"],
+  ["Use a custom port", "framey play --port 8080"],
+  ["Start without opening the browser", "framey play --no-open"],
+  ["Open with a specific browser", "framey play --browser-path /usr/bin/chromium"],
+  [
+    "Open with CDP enabled (requires browser path + isolated profile)",
+    "framey play --browser-path /usr/bin/chromium --user-data-dir /tmp/hf-profile --remote-debugging-port 9222"
+  ],
+  [
+    "Disable auto-proxying of browser-hostile video codecs (HEVC, ProRes, AV1)",
+    "framey play --no-proxy"
+  ]
+];
+var play_default = defineCommand({
+  meta: { name: "play", description: "Play a composition in a lightweight browser player" },
+  args: {
+    dir: { type: "positional", description: "Project directory", required: false },
+    port: { type: "string", description: "Port to run the player server on", default: "3003" },
+    open: {
+      type: "boolean",
+      default: true,
+      description: "Open browser automatically"
+    },
+    "browser-path": {
+      type: "string",
+      description: "Path to the browser executable to open"
+    },
+    "user-data-dir": {
+      type: "string",
+      description: "Chromium-compatible user data directory (requires --browser-path)"
+    },
+    "remote-debugging-port": {
+      type: "string",
+      description: "Chromium remote debugging port (requires --browser-path and --user-data-dir)"
+    },
+    proxy: {
+      type: "boolean",
+      description: "Auto-transcode browser-hostile video codecs (HEVC, ProRes, AV1) to a cached authoring proxy for preview (default: on; overrides hyperframes.json's media.autoProxy)",
+      negativeDescription: "Disable auto-proxying of browser-hostile video codecs"
+    }
+  },
+  async run({ args }) {
+    const project = resolveProject(args.dir);
+    const startPort = parseInt(args.port ?? "3003", 10);
+    if (args["user-data-dir"] && !args["browser-path"]) {
+      R.error("--user-data-dir requires --browser-path");
+      setCommandExitCode(1);
+      return;
+    }
+    const depsError = validateRemoteDebuggingPortDeps({
+      browserPath: args["browser-path"],
+      userDataDir: args["user-data-dir"],
+      remoteDebuggingPort: args["remote-debugging-port"]
+    });
+    if (depsError) {
+      R.error(depsError);
+      setCommandExitCode(1);
+      return;
+    }
+    let remoteDebuggingPort;
+    try {
+      remoteDebuggingPort = parseRemoteDebuggingPort(
+        args["remote-debugging-port"]
+      );
+    } catch (err) {
+      R.error(err.message);
+      setCommandExitCode(1);
+      return;
+    }
+    const runtimePath = resolveRuntimePath();
+    if (!runtimePath) {
+      R.error("Framey runtime not found. Run `bun run build` first.");
+      setCommandExitCode(1);
+      return;
+    }
+    const playerPath = resolvePlayerPath();
+    if (!playerPath) {
+      R.error("@framey/player not found. Run `bun run --cwd packages/player build` first.");
+      setCommandExitCode(1);
+      return;
+    }
+    const { Hono } = await import("hono");
+    const { createAdaptorServer } = await import("@hono/node-server");
+    const app = new Hono();
+    app.get(
+      "/player.js",
+      (ctx) => revalidatedResponse(
+        readFileSync(playerPath, "utf-8"),
+        "application/javascript",
+        ctx.req.header("If-None-Match")
+      )
+    );
+    app.get(
+      "/runtime.js",
+      (ctx) => revalidatedResponse(
+        readFileSync(runtimePath, "utf-8"),
+        "application/javascript",
+        ctx.req.header("If-None-Match")
+      )
+    );
+    const autoProxy = resolveAutoProxy(project.dir, args.proxy);
+    await registerCompositionRoute(app, project, autoProxy);
+    app.get("/", (ctx) => {
+      return ctx.html(buildPlayerPage(project.name));
+    });
+    ge(c.bold("framey play"));
+    const s = ft();
+    s.start("Starting player...");
+    const server = createAdaptorServer({ fetch: app.fetch });
+    const actualPort = await listenOnFreePort(server, startPort);
+    const url = `http://localhost:${actualPort}`;
+    s.stop(c.success("Player running"));
+    console.log();
+    if (actualPort !== startPort) {
+      console.log(`  ${c.warn(`Port ${startPort} is in use, using ${actualPort} instead`)}`);
+    }
+    console.log(`  ${c.dim("Project")}   ${c.accent(project.name)}`);
+    console.log(`  ${c.dim("Player")}    ${c.accent(url)}`);
+    console.log();
+    console.log(`  ${c.dim("Press Ctrl+C to stop")}`);
+    console.log();
+    if (args.open) {
+      void openBrowser(url, {
+        browserPath: args["browser-path"],
+        userDataDir: args["user-data-dir"],
+        remoteDebuggingPort
+      });
+    }
+    return new Promise(() => {
+    });
+  }
+});
+async function registerCompositionRoute(app, project, autoProxy) {
+  const { isSafePath } = await import("./studio-api-2NECGRMB.js");
+  app.get("/composition/*", async (ctx) => {
+    const reqPath = requestSubPath(ctx.req.url, "composition");
+    const filePath = resolve(project.dir, reqPath);
+    if (!isSafePath(project.dir, filePath)) return ctx.text("Forbidden", 403);
+    if (!existsSync(filePath)) return ctx.text("Not found", 404);
+    if (filePath.endsWith(".html")) {
+      let html = injectRuntime(readFileSync(filePath, "utf-8"));
+      if (autoProxy) {
+        html = await injectMediaCodecMapIntoHtml(html, project.dir, [{ html, compSrcPath: reqPath }]);
+      }
+      return revalidatedResponse(html, "text/html; charset=UTF-8", ctx.req.header("If-None-Match"));
+    }
+    const contentType = assetContentType(filePath);
+    const mediaType = contentType.split(";")[0].trim();
+    const isText = mediaType.startsWith("text/") || mediaType === "application/json" || mediaType === "image/svg+xml";
+    if (isText && !ctx.req.header("Range")) {
+      return revalidatedResponse(
+        readFileSync(filePath, "utf-8"),
+        contentType,
+        ctx.req.header("If-None-Match")
+      );
+    }
+    const proxyParam = ctx.req.query("hf-proxy");
+    if (proxyParam !== void 0 && isProxyVariantRequest(proxyParam)) {
+      if (!autoProxy || !contentType.startsWith("video/")) return ctx.text("Not found", 404);
+      try {
+        const facts = await probeAssetCodec(filePath);
+        const eligibility = decideMediaProxyEligibility(facts);
+        if (!eligibility.eligible) {
+          return ctx.text(`Media proxy unavailable: ${eligibility.reason}`, 422);
+        }
+        if (!facts) return ctx.text("Media proxy unavailable: unknown_codec", 422);
+        const proxyVariant = resolveProxyVariantRequest(proxyParam, facts);
+        if (!proxyVariant) {
+          return ctx.text("Media proxy variant does not match asset", 422);
+        }
+        recordProxyRequest();
+        const proxyPath = await resolveProxy(project.dir, filePath, proxyVariant);
+        return buildRangeResponse(
+          proxyPath,
+          PROXY_VARIANT_CONFIG[proxyVariant].contentType,
+          ctx.req.header("Range"),
+          ctx.req.header("If-None-Match")
+        );
+      } catch (err) {
+        if (err instanceof ProxyCapacityError) {
+          return ctx.text(`Proxy transcode deferred: ${err.message}`, 503, {
+            "Retry-After": "1"
+          });
+        }
+        if (err instanceof ProxyTranscodeError) {
+          return ctx.text(`Proxy transcode failed: ${err.message}`, 502);
+        }
+        throw err;
+      }
+    }
+    return buildRangeResponse(
+      filePath,
+      contentType,
+      ctx.req.header("Range"),
+      ctx.req.header("If-None-Match")
+    );
+  });
+}
+function buildPlayerPage(projectName) {
+  return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>${projectName} \u2014 Framey Player</title>
+    <style>
+      * { margin: 0; padding: 0; box-sizing: border-box; }
+      body {
+        background: #0a0a0a; color: #fff;
+        font-family: system-ui, -apple-system, sans-serif;
+        height: 100vh; display: flex; flex-direction: column;
+        align-items: center; justify-content: center;
+        padding: 24px;
+      }
+      .player-wrap {
+        width: 100%; max-width: 1280px; aspect-ratio: 16/9;
+        border-radius: 8px; overflow: hidden;
+      }
+      hyperframes-player { width: 100%; height: 100%; }
+      .info {
+        margin-top: 16px; font-size: 12px; color: #444;
+        font-family: monospace;
+      }
+    </style>
+  </head>
+  <body>
+    <div class="player-wrap">
+      <hyperframes-player src="/composition/index.html" controls muted></hyperframes-player>
+    </div>
+    <div class="info">${projectName} \u2014 framey play</div>
+    <script src="/player.js"></script>
+  </body>
+</html>`;
+}
+export {
+  play_default as default,
+  examples,
+  registerCompositionRoute
+};

package/vendor/framey/dist/policies-OLDYGFK5.js

@@ -0,0 +1,309 @@
+import { createRequire as __hf_createRequire } from "node:module";
+import { fileURLToPath as __hf_fileURLToPath } from "node:url";
+import { dirname as __hf_dirname } from "node:path";
+var require = __hf_createRequire(import.meta.url);
+var __filename = __hf_fileURLToPath(import.meta.url);
+var __dirname = __hf_dirname(__filename);
+import {
+  c
+} from "./chunk-VORQIH64.js";
+import {
+  setCommandExitCode
+} from "./chunk-JVBRJMOP.js";
+import {
+  normalizeErrorMessage
+} from "./chunk-T2EUWCJE.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/commands/lambda/policies.ts
+import { readFileSync } from "fs";
+var REQUIRED_ACTIONS = {
+  cloudformation: [
+    "cloudformation:CreateChangeSet",
+    "cloudformation:CreateStack",
+    "cloudformation:DeleteChangeSet",
+    "cloudformation:DeleteStack",
+    "cloudformation:DescribeChangeSet",
+    "cloudformation:DescribeStackEvents",
+    "cloudformation:DescribeStackResource",
+    "cloudformation:DescribeStackResources",
+    "cloudformation:DescribeStacks",
+    "cloudformation:ExecuteChangeSet",
+    "cloudformation:GetTemplate",
+    "cloudformation:GetTemplateSummary",
+    "cloudformation:ListStacks",
+    "cloudformation:UpdateStack",
+    "cloudformation:ValidateTemplate"
+  ],
+  cloudwatchAlarms: [
+    "cloudwatch:DeleteAlarms",
+    "cloudwatch:DescribeAlarms",
+    "cloudwatch:PutMetricAlarm"
+  ],
+  // `deploy --video-arch arm64` tags and pushes the video image; Set/GetRepositoryPolicy let Lambda pull it.
+  ecr: [
+    "ecr:BatchCheckLayerAvailability",
+    "ecr:BatchGetImage",
+    "ecr:CompleteLayerUpload",
+    "ecr:CreateRepository",
+    "ecr:DeleteRepository",
+    "ecr:DescribeRepositories",
+    "ecr:GetDownloadUrlForLayer",
+    "ecr:GetRepositoryPolicy",
+    "ecr:InitiateLayerUpload",
+    "ecr:ListTagsForResource",
+    "ecr:PutImage",
+    "ecr:SetRepositoryPolicy",
+    "ecr:TagResource",
+    "ecr:UploadLayerPart"
+  ],
+  iam: [
+    "iam:AttachRolePolicy",
+    "iam:CreateRole",
+    "iam:DeleteRole",
+    "iam:DeleteRolePolicy",
+    "iam:DetachRolePolicy",
+    "iam:GetRole",
+    "iam:GetRolePolicy",
+    "iam:PassRole",
+    "iam:PutRolePolicy",
+    "iam:TagRole",
+    "iam:UntagRole"
+  ],
+  lambda: [
+    "lambda:AddPermission",
+    "lambda:CreateFunction",
+    "lambda:DeleteFunction",
+    "lambda:DeleteFunctionConcurrency",
+    "lambda:GetFunction",
+    "lambda:GetFunctionConfiguration",
+    "lambda:InvokeFunction",
+    "lambda:ListFunctions",
+    "lambda:PutFunctionConcurrency",
+    "lambda:RemovePermission",
+    "lambda:TagResource",
+    "lambda:UntagResource",
+    "lambda:UpdateFunctionCode",
+    "lambda:UpdateFunctionConfiguration"
+  ],
+  logs: [
+    "logs:CreateLogGroup",
+    "logs:DeleteLogGroup",
+    "logs:DescribeLogGroups",
+    "logs:PutRetentionPolicy",
+    "logs:TagResource"
+  ],
+  s3Bucket: [
+    "s3:CreateBucket",
+    "s3:DeleteBucket",
+    "s3:DeleteBucketPolicy",
+    "s3:GetBucketLocation",
+    "s3:GetBucketPolicy",
+    "s3:GetBucketTagging",
+    "s3:GetBucketVersioning",
+    // SAM's `--resolve-s3` managed bucket (aws-sam-cli-managed-default) sets
+    // default SSE encryption; CloudFormation reads it on update/drift. Without
+    // Get/PutEncryptionConfiguration the first `lambda deploy` 403s creating
+    // that bucket and the managed stack rolls back.
+    "s3:GetEncryptionConfiguration",
+    "s3:GetLifecycleConfiguration",
+    "s3:ListAllMyBuckets",
+    "s3:ListBucket",
+    "s3:PutBucketPolicy",
+    "s3:PutBucketTagging",
+    "s3:PutBucketVersioning",
+    "s3:PutEncryptionConfiguration",
+    "s3:PutLifecycleConfiguration",
+    "s3:PutPublicAccessBlock"
+  ],
+  s3Object: ["s3:DeleteObject", "s3:GetObject", "s3:PutObject"],
+  states: [
+    "states:CreateStateMachine",
+    "states:DeleteStateMachine",
+    "states:DescribeExecution",
+    "states:DescribeMapRun",
+    "states:DescribeStateMachine",
+    "states:GetExecutionHistory",
+    "states:ListExecutions",
+    "states:ListStateMachines",
+    "states:StartExecution",
+    "states:StopExecution",
+    "states:TagResource",
+    "states:UntagResource",
+    "states:UpdateStateMachine"
+  ]
+};
+function allRequiredActions() {
+  const set = /* @__PURE__ */ new Set();
+  for (const group of Object.values(REQUIRED_ACTIONS)) {
+    for (const action of group) set.add(action);
+  }
+  return [...set].sort();
+}
+function buildPolicyDocument() {
+  return {
+    Version: "2012-10-17",
+    Statement: [
+      {
+        Effect: "Allow",
+        Action: allRequiredActions(),
+        Resource: "*"
+      }
+    ]
+  };
+}
+function buildRoleTrustPolicy() {
+  return {
+    Version: "2012-10-17",
+    Statement: [
+      {
+        Effect: "Allow",
+        Principal: { Service: "cloudformation.amazonaws.com" },
+        Action: "sts:AssumeRole"
+      }
+    ]
+  };
+}
+async function runPolicies(args) {
+  switch (args.verb) {
+    case "user": {
+      const doc = buildPolicyDocument();
+      console.log(JSON.stringify(doc, null, 2));
+      if (!args.json) {
+        console.error(
+          c.dim(
+            "\n# Attach the above as an inline policy to the IAM user/role that runs `framey lambda *`.\n# Scope `Resource` to your stack's ARNs after the first successful deploy."
+          )
+        );
+      }
+      return;
+    }
+    case "role": {
+      const trust = buildRoleTrustPolicy();
+      const inline = buildPolicyDocument();
+      const wrapped = {
+        TrustRelationship: trust,
+        InlinePolicy: inline
+      };
+      console.log(JSON.stringify(wrapped, null, 2));
+      return;
+    }
+    case "validate": {
+      if (!args.inputPath) {
+        const msg = "[lambda policies validate] usage: framey lambda policies validate <policy.json>";
+        if (args.json) {
+          console.log(JSON.stringify({ ok: false, error: msg }, null, 2));
+          setCommandExitCode(1);
+          return;
+        }
+        throw new Error(msg);
+      }
+      let result;
+      try {
+        result = validatePolicy(args.inputPath);
+      } catch (err) {
+        const msg = normalizeErrorMessage(err);
+        if (args.json) {
+          console.log(JSON.stringify({ ok: false, error: msg }, null, 2));
+          setCommandExitCode(1);
+          return;
+        }
+        console.error(c.error(`Failed to validate ${args.inputPath}: ${msg}`));
+        setCommandExitCode(1);
+        return;
+      }
+      if (args.json) {
+        console.log(JSON.stringify({ ok: result.missing.length === 0, ...result }, null, 2));
+        if (result.missing.length > 0) setCommandExitCode(1);
+        return;
+      }
+      for (const warning of result.warnings) {
+        console.warn(c.dim(`Warning: ${warning}`));
+      }
+      if (result.missing.length === 0) {
+        console.log(c.success(`Policy covers all ${result.required.length} required actions.`));
+        return;
+      }
+      console.log(c.error(`Policy is missing ${result.missing.length} required action(s):`));
+      for (const action of result.missing) {
+        console.log(`  \u2022 ${action}`);
+      }
+      console.log();
+      console.log(c.dim("Run `framey lambda policies user` to print the full required policy."));
+      setCommandExitCode(1);
+      return;
+    }
+  }
+}
+function validatePolicy(policyPath) {
+  const raw = readFileSync(policyPath, "utf-8");
+  const parsed = JSON.parse(raw);
+  const statements = Array.isArray(parsed.Statement) ? parsed.Statement : parsed.Statement ? [
+    parsed.Statement
+  ] : [];
+  const grantedPatterns = [];
+  const warnings = [];
+  for (const stmt of statements) {
+    if (stmt.Effect !== "Allow") continue;
+    if (stmt.NotAction !== void 0) {
+      warnings.push(
+        "Allow statement uses NotAction; the validator only checks positive Action grants, so this statement is being ignored. Convert to an explicit Action list to validate it."
+      );
+      continue;
+    }
+    if (stmt.NotResource !== void 0) {
+      warnings.push(
+        "Allow statement uses NotResource; resource-scoping is not modelled by this validator. Treating the statement as fully granted on its Action set."
+      );
+    }
+    const actions = stmt.Action;
+    if (typeof actions === "string") {
+      grantedPatterns.push(actions);
+    } else if (Array.isArray(actions)) {
+      for (const a of actions) if (typeof a === "string") grantedPatterns.push(a);
+    }
+  }
+  for (const pattern of grantedPatterns) {
+    if (hasMidStringWildcard(pattern)) {
+      warnings.push(
+        `Action pattern ${JSON.stringify(pattern)} contains a mid-string wildcard the validator can't expand; only end-anchored wildcards (\`*\`, \`service:*\`, \`prefix*\`) are honoured.`
+      );
+    }
+  }
+  const required = allRequiredActions();
+  const granted = [];
+  const missing = [];
+  for (const action of required) {
+    if (grantedPatterns.some((pattern) => actionMatches(pattern, action))) {
+      granted.push(action);
+    } else {
+      missing.push(action);
+    }
+  }
+  return { required, granted, missing, warnings };
+}
+function hasMidStringWildcard(pattern) {
+  if (pattern === "*") return false;
+  if (pattern.endsWith(":*")) return false;
+  if (pattern.endsWith("*") && !pattern.slice(0, -1).includes("*")) return false;
+  return pattern.includes("*") || pattern.includes("?");
+}
+function actionMatches(pattern, action) {
+  if (pattern === "*") return true;
+  if (pattern === action) return true;
+  if (pattern.endsWith(":*")) {
+    const service = pattern.slice(0, -2);
+    return action.startsWith(`${service}:`);
+  }
+  if (pattern.endsWith("*")) {
+    return action.startsWith(pattern.slice(0, -1));
+  }
+  return false;
+}
+export {
+  allRequiredActions,
+  buildPolicyDocument,
+  buildRoleTrustPolicy,
+  runPolicies,
+  validatePolicy
+};