@hypit/hypit 0.0.1 → 0.1.1

package/packages/gpt-image/src/fragment.ts

@@ -0,0 +1,101 @@
+import { artifactTypes } from "@hypit/artifact";
+import { sealGraphFragment } from "@hypit/elaborator";
+import { generationProducers } from "@hypit/generation";
+import { imageTransformProducers, imageTransformTypes } from "@hypit/image-transform";
+import { exactModelMediaInputNames, exactModelTextInputName } from "@hypit/model-kit";
+import type { ExactModelMediaInput, ExactModelTextInput } from "@hypit/model-kit";
+import type { FragmentOperation } from "@hypit/elaborator";
+import { textTypes } from "@hypit/text";
+
+import { gptImageEndpoints } from "./index.js";
+
+const input = (name: string) => ({ kind: "fragment-input" as const, name });
+const operation = (id: string) => ({ kind: "fragment-operation" as const, operation: id });
+
+/**
+ * Official clean GPT Image result: exact generation followed by the explicit,
+ * replaceable Raster transform already used everywhere else. This is one
+ * author-facing component but remains two visible graph operations/Needs.
+ */
+export function createGptImageCleanFragment(
+  mediaInputs: readonly ExactModelMediaInput[] = [],
+  textInputs: readonly ExactModelTextInput[] = [],
+) {
+  const endpoint = gptImageEndpoints.image!;
+  const names = [...mediaInputs, ...textInputs].map((item) => item.name);
+  if (new Set(names).size !== names.length) throw new Error("GPT Image input names must be unique");
+  const inputs = [
+    { name: "draft", type: endpoint.draftType },
+    { name: "cleanup", type: imageTransformTypes.program },
+  ];
+  const operations: FragmentOperation[] = [];
+  let draft = input("draft") as ReturnType<typeof input> | ReturnType<typeof operation>;
+  for (const [index, item] of textInputs.entries()) {
+    const binding = endpoint.textBindings[item.port];
+    if (binding === undefined) throw new Error(`gpt-image-2 has no text port ${item.port}`);
+    const name = exactModelTextInputName(item.name);
+    inputs.push({ name, type: textTypes.text });
+    const id = `bind-text:${String(index + 1).padStart(4, "0")}:${item.port}`;
+    operations.push({
+      id,
+      producer: binding.producer,
+      inputs: { draft, text: input(name) },
+      result: { kind: "output", name: "draft" },
+    });
+    draft = operation(id);
+  }
+  for (const [index, item] of mediaInputs.entries()) {
+    const binding = endpoint.mediaBindings[item.port];
+    if (binding === undefined) throw new Error(`gpt-image-2 has no media port ${item.port}`);
+    const inputNames = exactModelMediaInputNames(item.name);
+    inputs.push({ name: inputNames.binding, type: binding.type });
+    inputs.push({ name: inputNames.artifact, type: artifactTypes.blob });
+    const id = `bind:${String(index + 1).padStart(4, "0")}:${item.port}`;
+    operations.push({
+      id,
+      producer: binding.producer,
+      inputs: { draft, binding: input(inputNames.binding), artifact: input(inputNames.artifact) },
+      result: { kind: "output", name: "draft" },
+    });
+    draft = operation(id);
+  }
+  operations.push(
+    {
+      id: "finalize-request",
+      producer: endpoint.finalizeProducer,
+      inputs: { draft },
+      result: { kind: "output", name: "request" },
+    },
+    {
+      id: "generate",
+      producer: endpoint.producer,
+      inputs: { request: operation("finalize-request") },
+      result: { kind: "need", name: "generation" },
+    },
+    {
+      id: "select-primary-image",
+      producer: generationProducers.primaryImage,
+      inputs: { set: operation("generate") },
+      result: { kind: "output", name: "image" },
+    },
+    {
+      id: "clean-image",
+      producer: imageTransformProducers.request,
+      inputs: { source: operation("select-primary-image"), program: input("cleanup") },
+      result: { kind: "need", name: "image" },
+    },
+  );
+  const shape = [
+    ...textInputs.map((item) => `${item.name}=${item.port}:text`),
+    ...mediaInputs.map((item) => `${item.name}=${item.port}:media`),
+  ].join(",") || "no-dynamic-inputs";
+  return sealGraphFragment({
+    inputs,
+    operations,
+    exports: [{
+      name: "image",
+      type: artifactTypes.blob,
+      root: operation("clean-image"),
+    }],
+  });
+}

package/packages/gpt-image/src/index.ts

@@ -0,0 +1,203 @@
+import { artifactTypes } from "@hypit/artifact";
+import {
+  sealGenerationPortRequest,
+  sealGenerationRequestDraft,
+  sealGenerationPortTable,
+} from "@hypit/generation";
+import type { GenerationPortTable, GenerationPortValue, GenerationRequest } from "@hypit/generation";
+import type { SurfaceAttributeVocabulary, SurfaceChildVocabulary } from "@hypit/markup";
+import { defineExactModelModule } from "@hypit/model-kit";
+import { imageTransformModuleRef, imageTransformTypes } from "@hypit/image-transform";
+import { textTypes } from "@hypit/text";
+
+export const gptImageModuleRef = { name: "@hypit/gpt-image", version: "1" } as const;
+
+export const gptImage2Ports: GenerationPortTable = sealGenerationPortTable({
+  model: "gpt-image-2",
+  result: "image",
+  ports: [
+    { name: "prompt", value: { kind: "text", maxChars: 20_000 }, minItems: 1, maxItems: 1 },
+    {
+      name: "aspectRatio",
+      value: {
+        kind: "enum",
+        values: [
+          "auto", "1:1", "3:2", "2:3", "4:3", "3:4", "16:9", "9:16",
+          "2:1", "1:2", "3:1", "1:3", "21:9", "9:21", "5:4", "4:5",
+        ],
+      },
+      minItems: 1,
+      maxItems: 1,
+    },
+    { name: "resolution", value: { kind: "enum", values: ["1K", "2K", "4K"] }, minItems: 1, maxItems: 1 },
+    {
+      name: "background",
+      value: { kind: "enum", values: ["transparent", "opaque", "auto"] },
+      minItems: 0,
+      maxItems: 1,
+    },
+    { name: "images", value: { kind: "media", accepts: ["image"] }, minItems: 0, maxItems: 16 },
+  ],
+  requires: [],
+});
+
+export function sealGptImage2Request(
+  ports: Readonly<Record<string, readonly GenerationPortValue[]>>,
+): GenerationRequest {
+  return sealGenerationPortRequest(gptImage2Ports, ports);
+}
+
+/** Scalar request seed; reference images are attached later by explicit graph edges. */
+export function sealGptImage2Draft(
+  ports: Readonly<Record<string, readonly GenerationPortValue[]>>,
+) {
+  return sealGenerationRequestDraft(gptImage2Ports, ports);
+}
+
+const gptImageBaseDefinition = defineExactModelModule({
+  module: gptImageModuleRef,
+  endpoints: [{
+    key: "image",
+    requestTypeName: "GptImage2Request",
+    producerName: "request-gpt-image-2",
+    ports: gptImage2Ports,
+  }],
+});
+
+export const gptImageEndpoints = gptImageBaseDefinition.endpoints;
+export const gptImageComponent = gptImageBaseDefinition.component;
+const gptImageAttributes: readonly SurfaceAttributeVocabulary[] = [
+  {
+    name: "id",
+    kind: "identifier",
+    required: true,
+    summary: "Names this generation and prefixes the bindings it publishes.",
+  },
+  {
+    name: "prompt",
+    kind: "reference",
+    required: true,
+    summary: "The Text edge describing the picture the model renders.",
+    accepts: [textTypes.text],
+  },
+  {
+    name: "aspect-ratio",
+    kind: "literal",
+    required: true,
+    summary: "The shape of the generated picture.",
+    values: [
+      "auto", "1:1", "3:2", "2:3", "4:3", "3:4", "16:9", "9:16",
+      "2:1", "1:2", "3:1", "1:3", "21:9", "9:21", "5:4", "4:5",
+    ],
+  },
+  {
+    name: "resolution",
+    kind: "literal",
+    required: true,
+    summary: "The model's output resolution tier.",
+    values: ["1K", "2K", "4K"],
+  },
+  {
+    name: "background",
+    kind: "literal",
+    required: false,
+    summary: "Requests transparent pixels or a fully opaque generated picture.",
+    values: ["transparent", "opaque", "auto"],
+  },
+];
+
+const gptImageChildren: readonly SurfaceChildVocabulary[] = [
+  { tag: "Reference", cardinality: "many",
+    summary: "Attaches one image Artifact as a reference picture.",
+    attributes: [
+      { name: "image", kind: "reference", required: true, accepts: [artifactTypes.blob],
+        summary: "Selects the image Artifact this reference contributes." },
+    ] },
+];
+
+const gptImageExample = `<gpt:Image
+  id="holding"
+  prompt={prompt}
+  aspect-ratio="9:16"
+  resolution="2K"
+>
+  <gpt:Reference image={person.image}/>
+  <gpt:Reference image={product.image}/>
+</gpt:Image>`;
+
+const gptImageNotes: readonly string[] = [
+  "The element accepts at most 16 `Reference` children and no text content.",
+  "Every `Reference` is an ordinary image Artifact edge; the Surface copies no runtime media into request metadata.",
+];
+
+const gptImageSurfaceDeclaration = {
+  name: "image",
+  tag: "Image",
+  mode: "structured" as const,
+  outputs: [gptImageEndpoints.image!.draftType, gptImageEndpoints.image!.mediaBindings.images!.type],
+  vocabulary: {
+    summary: "Generates one picture with the exact GPT Image 2 model from a Text prompt and optional reference images.",
+    attributes: gptImageAttributes,
+    children: gptImageChildren,
+    ports: [{
+      name: "image",
+      type: artifactTypes.blob,
+      summary: "The primary generated image, addressed as `<id>.image`.",
+    }],
+    example: gptImageExample,
+    notes: gptImageNotes,
+  },
+};
+
+export const gptImageMarkupSurfaces = [gptImageSurfaceDeclaration] as const;
+
+export const gptImageManifest = {
+  ...gptImageBaseDefinition.manifest,
+};
+export const gptImageDefinition = {
+  ...gptImageBaseDefinition,
+  manifest: gptImageManifest,
+};
+
+/** Optional authoring submodule; the exact GPT model remains independent of post-processing. */
+export const gptImageCleanModuleRef = { name: "@hypit/gpt-image/clean", version: "1" } as const;
+
+export const gptImageCleanMarkupSurfaces = [{
+    name: "image",
+    tag: "Image",
+    mode: "structured" as const,
+    outputs: [
+      gptImageEndpoints.image!.draftType,
+      gptImageEndpoints.image!.mediaBindings.images!.type,
+      imageTransformTypes.program,
+    ],
+    vocabulary: {
+      summary: "Generates one picture with the exact GPT Image 2 model and runs the official denoise Program over it.",
+      attributes: gptImageAttributes,
+      children: gptImageChildren,
+      ports: [{
+        name: "image",
+        type: artifactTypes.blob,
+        summary: "The cleaned image, addressed as `<id>.image`.",
+      }],
+      example: gptImageExample,
+      notes: [
+        ...gptImageNotes,
+        "Generation and the image-transform Need stay two visible operations in the graph.",
+      ],
+    },
+  }] as const;
+
+export const gptImageCleanManifest = {
+  format: "hypit.module@1" as const,
+  name: gptImageCleanModuleRef.name,
+  version: gptImageCleanModuleRef.version,
+  dependencies: [
+    { module: gptImageModuleRef },
+    { module: imageTransformModuleRef },
+  ],
+  types: [],
+  capabilities: [],
+  producers: [],
+};
+export { createGptImageCleanFragment } from "./fragment.js";

package/packages/gpt-image/src/surface.ts

@@ -0,0 +1,194 @@
+import { artifactTypes } from "@hypit/artifact";
+import {
+  generationPort,
+  sealGenerationMediaBinding,
+} from "@hypit/generation";
+import type { GenerationMediaPort } from "@hypit/generation";
+import {
+  gptImageDenoiseV1,
+  imageTransformTypes,
+} from "@hypit/image-transform";
+import {
+  exactModelMediaInputNames,
+  exactModelTextInputName,
+  createExactModelPrimaryGenerationFragment,
+} from "@hypit/model-kit";
+import type {
+  MarkupAttributeValue,
+  StructuredElement,
+  StructuredSurfaceHandler,
+  SurfaceResolvedReference,
+} from "@hypit/markup";
+import type { CanonicalValue, TypeRef } from "@hypit/protocol";
+import { textTypes, verifyText } from "@hypit/text";
+
+import { createGptImageCleanFragment } from "./fragment.js";
+import {
+  gptImage2Ports,
+  gptImageEndpoints,
+  sealGptImage2Draft,
+} from "./index.js";
+
+function assert(condition: unknown, message: string): asserts condition {
+  if (!condition) throw new Error(message);
+}
+
+function localName(value: string): string {
+  return value.includes(":") ? value.slice(value.lastIndexOf(":") + 1) : value;
+}
+
+function sameType(left: TypeRef, right: TypeRef): boolean {
+  return left.module.name === right.module.name
+    && left.module.version === right.module.version
+    && left.name === right.name;
+}
+
+function exactAttributes(element: StructuredElement, allowed: readonly string[], required: readonly string[]): void {
+  const unknown = Object.keys(element.attributes).filter((name) => !allowed.includes(name));
+  assert(unknown.length === 0, `${element.name} does not accept ${unknown[0]}`);
+  const missing = required.filter((name) => element.attributes[name] === undefined);
+  assert(missing.length === 0, `${element.name} requires ${missing.join(", ")}`);
+}
+
+function textAttribute(element: StructuredElement, name: string): string {
+  const value = element.attributes[name];
+  assert(typeof value === "string" && value.trim().length > 0,
+    `${element.name}.${name} must be a non-empty string`);
+  return value.trim();
+}
+
+function referencePath(value: MarkupAttributeValue | undefined, subject: string): string {
+  assert(typeof value === "object" && value.kind === "reference" && value.path.length > 0,
+    `${subject} must be a whole-value reference`);
+  return value.path;
+}
+
+function resolve(
+  element: StructuredElement,
+  attribute: string,
+  expected: TypeRef,
+  resolveReference: (path: string) => SurfaceResolvedReference | undefined,
+): SurfaceResolvedReference {
+  const path = referencePath(element.attributes[attribute], `${element.name}.${attribute}`);
+  const result = resolveReference(path);
+  assert(result !== undefined, `${element.name}.${attribute} cannot resolve ${path}`);
+  assert(sameType(result.type, expected), `${element.name}.${attribute} has the wrong type`);
+  return result;
+}
+
+function prompt(
+  element: StructuredElement,
+  resolveReference: (path: string) => SurfaceResolvedReference | undefined,
+): SurfaceResolvedReference {
+  const result = resolve(element, "prompt", textTypes.text, resolveReference);
+  if (result.record !== undefined) {
+    assert(result.record.value.kind === "inline", `${element.name}.prompt must reference Text`);
+    verifyText(result.record.value.value);
+  }
+  return result;
+}
+
+function references(
+  element: StructuredElement,
+  resolveReference: (path: string) => SurfaceResolvedReference | undefined,
+): readonly SurfaceResolvedReference[] {
+  const result: SurfaceResolvedReference[] = [];
+  for (const child of element.children) {
+    if (child.kind === "text") {
+      assert(child.value.trim().length === 0, `${element.name} accepts only Reference children`);
+      continue;
+    }
+    assert(localName(child.name) === "Reference", `${element.name} accepts only Reference children`);
+    exactAttributes(child, ["image"], ["image"]);
+    assert(!child.children.some((item) => item.kind === "element" || item.value.trim().length > 0),
+      `${child.name} must be empty`);
+    const image = resolve(child, "image", artifactTypes.blob, resolveReference);
+    if (image.record !== undefined) {
+      assert(image.record.value.kind === "blob" && image.record.value.mediaType.startsWith("image/"),
+        `${child.name}.image must reference image media`);
+    }
+    result.push(image);
+  }
+  assert(result.length <= 16, `${element.name} accepts at most 16 Reference children`);
+  return result;
+}
+
+function decode(clean: boolean): StructuredSurfaceHandler {
+  return ({ element, resolveReference }) => {
+    exactAttributes(element, ["id", "prompt", "aspect-ratio", "resolution", "background"],
+      ["id", "prompt", "aspect-ratio", "resolution"]);
+    const id = textAttribute(element, "id");
+    const promptSource = prompt(element, resolveReference);
+    const images = references(element, resolveReference);
+    const endpoint = gptImageEndpoints.image!;
+    const imagePort = generationPort(gptImage2Ports, "images");
+    assert(imagePort.value.kind === "media", "GPT Image images port is not media");
+    const background = element.attributes.background === undefined
+      ? undefined
+      : textAttribute(element, "background");
+    const draft = sealGptImage2Draft({
+      aspectRatio: [textAttribute(element, "aspect-ratio")],
+      resolution: [textAttribute(element, "resolution")],
+      ...(background === undefined ? {} : { background: [background] }),
+    });
+    const records: Array<{
+      readonly id: string;
+      readonly type: TypeRef;
+      readonly value: { readonly kind: "inline"; readonly value: CanonicalValue };
+      readonly range: StructuredElement["range"];
+    }> = [{
+      id: `${id}.draft`,
+      type: endpoint.draftType,
+      value: { kind: "inline", value: draft as unknown as CanonicalValue },
+      range: element.range,
+    }];
+    const inputs: Record<string, SurfaceResolvedReference["ref"] | { readonly kind: "record"; readonly id: string }> = {
+      draft: { kind: "record", id: `${id}.draft` },
+      [exactModelTextInputName("prompt")]: promptSource.ref,
+    };
+    const mediaInputs = images.map((image, index) => {
+      const name = `image-${String(index + 1).padStart(4, "0")}`;
+      const bindingId = `${id}.${name}.binding`;
+      records.push({
+        id: bindingId,
+        type: endpoint.mediaBindings.images!.type,
+        value: {
+          kind: "inline",
+          value: sealGenerationMediaBinding(imagePort as GenerationMediaPort, { role: "image" }) as unknown as CanonicalValue,
+        },
+        range: element.range,
+      });
+      const names = exactModelMediaInputNames(name);
+      inputs[names.binding] = { kind: "record", id: bindingId };
+      inputs[names.artifact] = image.ref;
+      return { name, port: "images" } as const;
+    });
+    if (clean) {
+      records.push({
+        id: `${id}.cleanup`,
+        type: imageTransformTypes.program,
+        value: { kind: "inline", value: gptImageDenoiseV1 as unknown as CanonicalValue },
+        range: element.range,
+      });
+      inputs.cleanup = { kind: "record", id: `${id}.cleanup` };
+    }
+    const textInputs = [{ name: "prompt", port: "prompt" }] as const;
+    const fragment = clean
+      ? createGptImageCleanFragment(mediaInputs, textInputs)
+      : createExactModelPrimaryGenerationFragment(endpoint, mediaInputs, textInputs);
+    return {
+      records,
+      components: [{
+        id,
+        fragment: fragment.id,
+        inputs,
+        outputs: { image: `${id}.image` },
+        range: element.range,
+      }],
+      fragments: [fragment],
+    };
+  };
+}
+
+export const decodeGptImageSurface = decode(false);
+export const decodeCleanGptImageSurface = decode(true);

package/packages/gpt-image-kits/README.md

@@ -0,0 +1,44 @@
+# `@hypit/gpt-image-kits`
+
+`phone-ugc-v1` is a data-only Text Template for assembling image prompts. Its
+[source](kits/phone-ugc-v1.svs) emits a fixed iPhone-video capture paragraph, followed by the supplied
+Text slots, with paragraph separators. Import it as `@hypit/gpt-image-kits/phone-ugc-v1`.
+
+For creative direction, see the Image direction page in the Hypit Skill.
+
+## Blocks and inputs
+
+The capture block is fixed by this template version. Selecting a different capture language means
+selecting or authoring another Text Template. The caller supplies the variable direction:
+
+| Text slot | Required | Content |
+| --- | --- | --- |
+| `shot` | Yes | Camera view, framing, posture, gaze and interaction. |
+| `direction` | Yes | Subject, styling, setting and intended appearance. |
+| `references` | No | What each connected reference supplies or changes. |
+
+Each slot accepts an ordinary Text Output and may contain several paragraphs. The template produces
+Text; the image Surface consumes it. Actual reference Resources and model parameters are connected
+on that Surface.
+
+## Assemble the prompt
+
+Given authored Text Outputs `portrait-shot` and `portrait-direction`, this fragment assembles the
+prompt and passes it to `gpt:Image`:
+
+```svml
+<import as="text" from="@hypit/text@1"/>
+<import as="gpt" from="@hypit/gpt-image@1"/>
+<import as="ugc" source="@hypit/gpt-image-kits/phone-ugc-v1"/>
+
+<text:Render id="portrait-prompt" template={ugc.phone-ugc-v1}>
+  <text:Set name="shot" text={portrait-shot}/>
+  <text:Set name="direction" text={portrait-direction}/>
+</text:Render>
+
+<gpt:Image id="portrait" prompt={portrait-prompt} aspect-ratio="9:16" resolution="2K"/>
+```
+
+To explain reference inputs, add a `text:Set` named `references` to the Render. Connect those same
+images through `gpt:Reference` children on `gpt:Image`. Omit the optional Set when no reference
+direction is needed. The Text does not create Resource bindings.

package/packages/gpt-image-kits/kits/phone-ugc-v1.svs

@@ -0,0 +1,34 @@
+<?svml using="@hypit/text/svs@1"?>
+
+<sheet version="1" id="phone-ugc-v1">
+  text-template.phone-ugc-v1 {
+    separator: paragraph;
+  }
+
+  text-template.phone-ugc-v1.block.capture {
+    kind: fixed;
+    order: 10;
+    text: "A photograph with the texture of real iPhone footage, captured as a single frame from a video actually shot on an iPhone. The image looks real, without an oily, overprocessed finish, and has the texture of video footage. The background is clearly visible, with no depth-of-field blur. Skin texture is natural and fine, the lighting is natural, and the image is coherent and free of visual artifacts.";
+  }
+
+  text-template.phone-ugc-v1.block.shot {
+    kind: slot;
+    order: 20;
+    slot: shot;
+    optional: false;
+  }
+
+  text-template.phone-ugc-v1.block.direction {
+    kind: slot;
+    order: 30;
+    slot: direction;
+    optional: false;
+  }
+
+  text-template.phone-ugc-v1.block.references {
+    kind: slot;
+    order: 40;
+    slot: references;
+    optional: true;
+  }
+</sheet>

package/packages/gpt-image-kits/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@hypit/gpt-image-kits",
+  "version": "0.0.0-dev",
+  "license": "SEE LICENSE IN LICENSE",
+  "private": true,
+  "type": "module",
+  "exports": {
+    "./phone-ugc-v1": "./kits/phone-ugc-v1.svs"
+  },
+  "files": ["kits", "README.md"],
+  "devDependencies": {
+    "@hypit/svs": "workspace:*",
+    "@hypit/text": "workspace:*"
+  }
+}

package/packages/grok-imagine/README.md

@@ -0,0 +1,21 @@
+# `@hypit/grok-imagine`
+
+Exact author/compute contracts and package-owned author Surfaces for Grok Imagine video generation.
+
+It exposes the standard and 1.5-preview models as distinct Surfaces. Each request is nominally typed and
+validated before yielding an ordinary video Artifact. The package declares the model
+choice; it does not route to another model or access a Provider. `@hypit/provider-kie` is one
+optional Runtime implementation.
+
+```xml
+<grok:Video id="clip" prompt={prompt} duration="6" aspect-ratio="9:16" resolution="720p">
+  <grok:Reference image={person.image}/>
+</grok:Video>
+
+<grok:PreviewVideo id="preview" prompt={previewPrompt} duration="6"
+  aspect-ratio="9:16" resolution="720p"/>
+```
+
+Both Surfaces accept up to seven reference images. `Video` accepts 6–30 seconds; `PreviewVideo`
+accepts 1–15 seconds and also offers `auto` aspect ratio. Provider task identifiers are execution
+state, not author inputs, and are deliberately absent from both Surfaces.

package/packages/grok-imagine/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@hypit/grok-imagine",
+  "version": "0.0.0-dev",
+  "license": "SEE LICENSE IN LICENSE",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "hypit": {
+    "activation": "./src/activation.ts"
+  },
+  "dependencies": {
+    "@hypit/artifact": "workspace:*",
+    "@hypit/generation": "workspace:*",
+    "@hypit/markup": "workspace:*",
+    "@hypit/model-kit": "workspace:*",
+    "@hypit/protocol": "workspace:*",
+    "@hypit/text": "workspace:*"
+  }
+}

package/packages/grok-imagine/src/activation.ts

@@ -0,0 +1,29 @@
+import { createMarkupSurfaceHostFacet } from "@hypit/markup";
+import {
+  grokImagineComponent,
+  grokImagineDefinition,
+  grokImagineManifest,
+  grokImagineModuleRef,
+  grokImagineMarkupSurfaces,
+} from "./index.js";
+import { decodeGrokImaginePreviewVideoSurface, decodeGrokImagineVideoSurface } from "./surface.js";
+
+export const hypitPackage = {
+  format: "hypit.node-package@1" as const,
+  modules: [{ manifest: grokImagineManifest }],
+  components: [grokImagineComponent],
+  hostFacets: [
+    grokImagineDefinition.hostFacet,
+    createMarkupSurfaceHostFacet({
+      module: grokImagineModuleRef,
+    declaration: grokImagineMarkupSurfaces.find((item) => item.name === "video")!,
+      handler: decodeGrokImagineVideoSurface,
+    }),
+    createMarkupSurfaceHostFacet({
+      module: grokImagineModuleRef,
+    declaration: grokImagineMarkupSurfaces.find((item) => item.name === "preview-video")!,
+      handler: decodeGrokImaginePreviewVideoSurface,
+    }),
+  ],
+};
+export default hypitPackage;