@hypit/hypit 0.1.3 → 0.1.5

package/packages/provider-hyperframes-aws-lambda/README.md

@@ -1,30 +0,0 @@
-# `@hypit/provider-hyperframes-aws-lambda`
-
-Asynchronous AWS Step Functions/Lambda implementation of the exact
-`@hypit/render-hyperframes#render-visual` capability.
-
-The Endpoint stages the immutable `HyperframesDocument` with the shared
-`stageHyperframesProject()` layout, uploads that operation-scoped site, starts one distributed
-render and persists its execution ARN in the Operation checkpoint. Its Step Functions execution name is derived from the
-Runtime Operation id, so recovery cannot accidentally submit the same attempt twice.
-Cancellation uses that same identity to stop the remote Step Functions execution, including the
-crash window before the first checkpoint was saved.
-
-This Provider accepts whole-document requests at integer 24, 30 and 60 fps; it currently declines
-requests containing a frame range. Its chunk settings partition a whole render across Lambda workers,
-whereas the local Provider also accepts a selected interval. Unsupported Needs
-are declined by `supports()` so another Endpoint may satisfy them; no frame rate or GPU intent is
-silently changed. The Provider always requests strict SDR H.264, exact CFR assembly, software
-browser rendering and plan protocol v2. It also declines Surface-bearing documents until the
-remote route owns the same byte verifier as the local Endpoint. Chunking remains deployment
-configuration.
-
-On success the Endpoint requires HyperFrames' plan and completed-frame counts to equal the source
-document, then streams the returned S3 object into the current Build's working byte area.
-The Endpoint's Runtime Profile entry selects the AWS state machine and deployment settings. The Provider does not repeat
-the request or selected endpoint as vendor metadata. Container and stream conformance stays in the explicit media
-inspection/mux capabilities, so the orchestrating machine does not acquire a hidden FFmpeg
-dependency.
-
-The production client uses the AWS SDK default credential chain. No access key is accepted by the
-package configuration or written into Build state.

package/packages/provider-hyperframes-aws-lambda/package.json

@@ -1,30 +0,0 @@
-{
-  "name": "@hypit/provider-hyperframes-aws-lambda",
-  "version": "0.0.0-dev",
-  "license": "SEE LICENSE IN LICENSE",
-  "private": true,
-  "type": "module",
-  "exports": {
-    ".": "./src/index.ts"
-  },
-  "hypit": {
-    "activation": "./src/activation.ts"
-  },
-  "dependencies": {
-    "@aws-sdk/client-s3": "3.1103.0",
-    "@aws-sdk/client-sfn": "3.1103.0",
-    "@hyperframes/aws-lambda": "0.7.101",
-    "@hypit/endpoint-kit": "workspace:*",
-    "@hypit/hyperframes": "workspace:*",
-    "@hypit/media": "workspace:*",
-    "@hypit/protocol": "workspace:*",
-    "@hypit/render-hyperframes": "workspace:*",
-    "@hypit/runtime": "workspace:*",
-    "@hypit/runtime-kit": "workspace:*"
-  },
-  "devDependencies": {
-    "@hypit/composition": "workspace:*",
-    "@hypit/driver-node": "workspace:*",
-    "@hypit/program-space": "workspace:*"
-  }
-}

package/packages/provider-hyperframes-aws-lambda/src/activation.ts

@@ -1,97 +0,0 @@
-import type { CanonicalValue } from "@hypit/protocol";
-import {
-  createRuntimeEndpointAdapterFacet,
-  runtimeConfigExact,
-  runtimeConfigObject,
-  runtimeConfigPositiveInteger,
-  runtimeConfigString,
-} from "@hypit/runtime-kit";
-import type { RuntimeAdapterFactoryContext } from "@hypit/runtime-kit";
-
-import { createAwsLambdaHyperframesProvider } from "./provider.js";
-import type {
-  CreateAwsLambdaHyperframesProviderOptions,
-  HyperframesLambdaQuality,
-} from "./provider.js";
-
-const CONFIG_KEYS = [
-  "stateMachineArn", "bucketName", "quality", "chunkSize", "maxParallelChunks",
-  "targetChunkFrames", "defaultMemorySizeMb", "defaultConcurrency", "pollIntervalMs",
-  "maxOperationMs", "maxRenderedBytes",
-] as const;
-
-type RuntimeProviderOptions = Omit<
-  CreateAwsLambdaHyperframesProviderOptions,
-  "client" | "now"
->;
-
-function optionalInteger(
-  config: Record<string, CanonicalValue>,
-  name: string,
-): number | undefined {
-  return runtimeConfigPositiveInteger(config[name], `HyperFrames ${name}`);
-}
-
-function providerOptions(context: RuntimeAdapterFactoryContext): RuntimeProviderOptions {
-  if (context.pool === undefined) throw new Error("AWS Lambda HyperFrames Provider Pool is required");
-  const config = runtimeConfigObject(context.config, "AWS Lambda HyperFrames");
-  runtimeConfigExact(config, CONFIG_KEYS, "AWS Lambda HyperFrames");
-  const stateMachineArn = runtimeConfigString(config.stateMachineArn, "HyperFrames stateMachineArn");
-  if (stateMachineArn === undefined) throw new Error("AWS Lambda HyperFrames stateMachineArn is required");
-  const machine = /^(arn:aws(?:-[a-z]+)*:states):([a-z0-9-]+):(\d{12}):stateMachine:([A-Za-z0-9_-]+)$/u
-    .exec(stateMachineArn);
-  if (machine === null) {
-    throw new Error(`HyperFrames stateMachineArn must be an unqualified AWS Step Functions state-machine ARN; got ${stateMachineArn}`);
-  }
-  const bucketName = runtimeConfigString(config.bucketName, "HyperFrames bucketName");
-  if (bucketName === undefined) throw new Error("AWS Lambda HyperFrames bucketName is required");
-  if (!/^[a-z0-9][a-z0-9.-]{1,61}[a-z0-9]$/u.test(bucketName)
-    || bucketName.includes("..") || bucketName.includes(".-") || bucketName.includes("-.")
-    || /^\d{1,3}(?:\.\d{1,3}){3}$/u.test(bucketName)) {
-    throw new Error("HyperFrames bucketName is invalid");
-  }
-  const quality = runtimeConfigString(config.quality, "HyperFrames quality");
-  if (quality !== undefined && quality !== "draft" && quality !== "standard" && quality !== "high") {
-    throw new Error("HyperFrames quality is invalid");
-  }
-  const chunkSize = optionalInteger(config, "chunkSize");
-  const maxParallelChunks = optionalInteger(config, "maxParallelChunks");
-  const targetChunkFrames = optionalInteger(config, "targetChunkFrames");
-  if (chunkSize !== undefined && targetChunkFrames !== undefined) {
-    throw new Error("HyperFrames chunkSize and targetChunkFrames are mutually exclusive");
-  }
-  const defaultMemorySizeMb = optionalInteger(config, "defaultMemorySizeMb");
-  const defaultConcurrency = optionalInteger(config, "defaultConcurrency");
-  const pollIntervalMs = optionalInteger(config, "pollIntervalMs");
-  const maxOperationMs = optionalInteger(config, "maxOperationMs");
-  const maxRenderedBytes = optionalInteger(config, "maxRenderedBytes");
-  return {
-    instance: context.instance,
-    pool: context.pool,
-    stateMachineArn,
-    bucketName,
-    ...(quality === undefined ? {} : { quality: quality as HyperframesLambdaQuality }),
-    ...(chunkSize === undefined ? {} : { chunkSize }),
-    ...(maxParallelChunks === undefined ? {} : { maxParallelChunks }),
-    ...(targetChunkFrames === undefined ? {} : { targetChunkFrames }),
-    ...(defaultMemorySizeMb === undefined ? {} : { defaultMemorySizeMb }),
-    ...(defaultConcurrency === undefined ? {} : { defaultConcurrency }),
-    ...(pollIntervalMs === undefined ? {} : { pollIntervalMs }),
-    ...(maxOperationMs === undefined ? {} : { maxOperationMs }),
-    ...(maxRenderedBytes === undefined ? {} : { maxRenderedBytes }),
-  };
-}
-
-const awsLambdaHyperframesRuntimeAdapter = createRuntimeEndpointAdapterFacet({
-  use: "@hypit/provider-hyperframes-aws-lambda",
-  activate(context) {
-    return { endpoint: createAwsLambdaHyperframesProvider(providerOptions(context)) };
-  },
-});
-
-export const hypitPackage = {
-  format: "hypit.node-package@1" as const,
-  hostFacets: [awsLambdaHyperframesRuntimeAdapter],
-};
-
-export default hypitPackage;

package/packages/provider-hyperframes-aws-lambda/src/client.ts

@@ -1,114 +0,0 @@
-import { GetObjectCommand, S3Client } from "@aws-sdk/client-s3";
-import { SFNClient, StopExecutionCommand } from "@aws-sdk/client-sfn";
-import {
-  deploySite,
-  getRenderProgress,
-  renderToLambda,
-} from "@hyperframes/aws-lambda/sdk";
-import type {
-  RenderHandle,
-  RenderProgress,
-  SerializableDistributedRenderConfig,
-  SiteHandle,
-} from "@hyperframes/aws-lambda/sdk";
-
-export type HyperframesLambdaSite = SiteHandle;
-export type HyperframesLambdaRender = RenderHandle;
-export type HyperframesLambdaProgress = RenderProgress;
-export type HyperframesLambdaRenderConfig = SerializableDistributedRenderConfig;
-
-export type HyperframesLambdaOutput = {
-  readonly chunks: AsyncIterable<Uint8Array>;
-  readonly contentLength?: number;
-};
-
-export interface HyperframesAwsLambdaClient {
-  deploySite(input: {
-    readonly projectDir: string;
-    readonly bucketName: string;
-    readonly region: string;
-  }): Promise<HyperframesLambdaSite>;
-  render(input: {
-    readonly siteHandle: HyperframesLambdaSite;
-    readonly config: HyperframesLambdaRenderConfig;
-    readonly bucketName: string;
-    readonly stateMachineArn: string;
-    readonly region: string;
-    readonly outputKey: string;
-    readonly executionName: string;
-  }): Promise<HyperframesLambdaRender>;
-  progress(input: {
-    readonly executionArn: string;
-    readonly defaultMemorySizeMb: number;
-    readonly region: string;
-  }): Promise<HyperframesLambdaProgress>;
-  stop(input: {
-    readonly executionArn: string;
-    readonly region: string;
-    readonly reason: string;
-  }): Promise<void>;
-  openOutput(input: {
-    readonly s3Uri: string;
-    readonly region: string;
-  }): Promise<HyperframesLambdaOutput>;
-}
-
-function assert(condition: unknown, message: string): asserts condition {
-  if (!condition) throw new Error(message);
-}
-
-export function parseS3Uri(uri: string): { readonly bucket: string; readonly key: string } {
-  let parsed: URL;
-  try {
-    parsed = new URL(uri);
-  } catch {
-    throw new Error(`HyperFrames output URI is invalid: ${uri}`);
-  }
-  assert(parsed.protocol === "s3:" && parsed.hostname.length > 0 && parsed.pathname.length > 1,
-    `HyperFrames output URI must be s3://bucket/key; got ${uri}`);
-  assert(parsed.search.length === 0 && parsed.hash.length === 0,
-    "HyperFrames output URI must not contain a query or fragment");
-  return { bucket: parsed.hostname, key: decodeURIComponent(parsed.pathname.slice(1)) };
-}
-
-async function* byteChunks(body: unknown): AsyncIterable<Uint8Array> {
-  assert(body !== null && typeof body === "object" && Symbol.asyncIterator in body,
-    "HyperFrames S3 output has no streaming body");
-  for await (const chunk of body as AsyncIterable<unknown>) {
-    if (typeof chunk === "string") yield Buffer.from(chunk);
-    else if (chunk instanceof Uint8Array) yield chunk;
-    else throw new Error("HyperFrames S3 output emitted a non-byte chunk");
-  }
-}
-
-/** Uses only the AWS SDK default credential chain. No credential bytes enter this package. */
-export function createHyperframesAwsLambdaClient(region: string): HyperframesAwsLambdaClient {
-  const s3 = new S3Client({ region });
-  const sfn = new SFNClient({ region });
-  return {
-    deploySite: async (input) => await deploySite({ ...input, s3 }),
-    render: async (input) => await renderToLambda({
-      ...input,
-      planProtocol: "v2",
-      s3,
-      sfn,
-    }),
-    progress: async (input) => await getRenderProgress({ ...input, sfn }),
-    async stop(input) {
-      await sfn.send(new StopExecutionCommand({
-        executionArn: input.executionArn,
-        error: "HypitBuildCancelled",
-        cause: input.reason,
-      }));
-    },
-    async openOutput(input) {
-      const target = parseS3Uri(input.s3Uri);
-      const output = await s3.send(new GetObjectCommand({ Bucket: target.bucket, Key: target.key }));
-      if (output.Body === undefined) throw new Error(`HyperFrames output ${input.s3Uri} has no body`);
-      return {
-        chunks: byteChunks(output.Body),
-        ...(output.ContentLength === undefined ? {} : { contentLength: output.ContentLength }),
-      };
-    },
-  };
-}

package/packages/provider-hyperframes-aws-lambda/src/index.ts

@@ -1,21 +0,0 @@
-export {
-  createHyperframesAwsLambdaClient,
-  parseS3Uri,
-} from "./client.js";
-export type {
-  HyperframesAwsLambdaClient,
-  HyperframesLambdaOutput,
-  HyperframesLambdaProgress,
-  HyperframesLambdaRender,
-  HyperframesLambdaRenderConfig,
-  HyperframesLambdaSite,
-} from "./client.js";
-export {
-  awsLambdaHyperframesProviderModuleRef,
-  createAwsLambdaHyperframesProvider,
-  supportsAwsLambdaHyperframes,
-} from "./provider.js";
-export type {
-  CreateAwsLambdaHyperframesProviderOptions,
-  HyperframesLambdaQuality,
-} from "./provider.js";