@alexanderolsen/create-deepagent 0.1.0

package/registry/frameworks/next/lib/server/session.ts

@@ -0,0 +1,212 @@
+import "server-only";
+
+import type { ReactAgent } from "langchain";
+// `StreamChannel` buffers events; `matchesSubscription` is the shared protocol
+// predicate from `@langchain/langgraph/stream` — the same one langgraph-api
+// uses, so this custom transport stays aligned with the production server.
+import {
+  StreamChannel,
+  matchesSubscription,
+  type ProtocolEvent,
+} from "@langchain/langgraph/stream";
+import type {
+  Command,
+  CommandResponse,
+  ErrorResponse,
+  SubscribeParams,
+} from "@langchain/protocol";
+
+import { isRecord, sanitizeForJson } from "./serialize";
+
+// `ReactAgent<any>` accepts both `createAgent` results and `DeepAgent`
+// instances (which carry a specific, non-default type config).
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type AnyReactAgent = ReactAgent<any>;
+
+type AgentRunInput = Parameters<AnyReactAgent["streamEvents"]>[0];
+
+/**
+ * Make an event safe to `JSON.stringify` onto the SSE wire.
+ *
+ * Only the protocol payload (`params.data`) and any `params.interrupts` can
+ * carry LangChain message instances, so those are the fields we sanitize into
+ * the plain, role-keyed protocol message shape the SDK expects.
+ */
+function sanitizeEvent(event: ProtocolEvent): ProtocolEvent {
+  const params = event.params as Record<string, unknown>;
+  const sanitizedParams: Record<string, unknown> = {
+    ...params,
+    data: sanitizeForJson(params.data),
+  };
+  if ("interrupts" in params) {
+    sanitizedParams.interrupts = sanitizeForJson(params.interrupts);
+  }
+  return { ...event, params: sanitizedParams } as ProtocolEvent;
+}
+
+/**
+ * Encode an Agent Protocol event as a Server-Sent Event frame.
+ *
+ * When available, `event_id` is mirrored into the SSE `id:` field for
+ * transport-level reconnection. The SDK primarily deduplicates by `event_id`
+ * and replays by `seq`; if an event has no `event_id`, this example falls back
+ * to `seq` as a stable frame id.
+ */
+function encodeSse(event: ProtocolEvent) {
+  const eventId = (event as { event_id?: string }).event_id;
+  const id = eventId ?? (typeof event.seq === "number" ? `${event.seq}` : "");
+  const idLine = id ? `id: ${id}\n` : "";
+  return new TextEncoder().encode(
+    `${idLine}event: message\ndata: ${JSON.stringify(event)}\n\n`,
+  );
+}
+
+/**
+ * Minimal in-memory Agent Streaming Protocol session for the example.
+ *
+ * This class is the server-side counterpart to `HttpAgentServerAdapter`:
+ *
+ * - `POST /threads/:thread_id/commands` sends a JSON `Command` and receives a
+ *   `CommandResponse` or `ErrorResponse`.
+ * - `POST /threads/:thread_id/stream` opens a connection-scoped SSE
+ *   subscription described by `SubscribeParams`.
+ * - Events are buffered by `seq` and replayed to later subscriptions, enabling
+ *   the SDK to rotate streams as subscriptions widen or narrow.
+ *
+ * The implementation is intentionally small and process-local. It is suitable
+ * for this example and for understanding the protocol shape, but production
+ * servers should persist threads, enforce concurrency policies, and coordinate
+ * replay buffers across workers.
+ */
+export class LocalThreadSession {
+  readonly #agent: AnyReactAgent;
+  readonly #threadId: string;
+
+  /**
+   * Per-thread protocol event log.
+   *
+   * A {@link StreamChannel} is LangGraph's buffered, append-only stream with
+   * independent per-consumer cursors. Every event ever published stays
+   * buffered, and each SSE subscription gets its own cursor via
+   * {@link StreamChannel.iterate}, so buffered replay and live delivery are the
+   * same iteration.
+   */
+  readonly #log = StreamChannel.local<ProtocolEvent>();
+
+  /** Monotonic seq across all runs on this thread (graph runs reset at 0). */
+  #nextSeq = 0;
+
+  #activeRun:
+    | {
+        abort(reason?: unknown): void;
+      }
+    | undefined;
+
+  constructor(agent: AnyReactAgent, threadId: string) {
+    this.#agent = agent;
+    this.#threadId = threadId;
+  }
+
+  /**
+   * Handle a thread command sent to the Agent Protocol `/commands` endpoint.
+   *
+   * The SDK sends `run.start` to start or resume a graph run on the current
+   * thread. This starts the in-process v3 stream and immediately returns a
+   * success response containing a generated `run_id`, while streamed events
+   * flow asynchronously through active `/stream` subscriptions.
+   */
+  async handleCommand(
+    command: Command,
+  ): Promise<CommandResponse | ErrorResponse> {
+    if (command.method !== "run.start") {
+      return {
+        type: "error",
+        id: command.id,
+        error: "unknown_command",
+        message: `Unsupported command: ${command.method}`,
+      } as ErrorResponse;
+    }
+
+    const params = isRecord(command.params)
+      ? (command.params as { input?: unknown })
+      : {};
+    const runId = crypto.randomUUID();
+    void this.#startRun(params.input as AgentRunInput, runId);
+
+    return {
+      type: "success",
+      id: command.id,
+      result: { run_id: runId },
+    } as CommandResponse;
+  }
+
+  /**
+   * Open a connection-scoped SSE subscription for this thread.
+   *
+   * The returned `ReadableStream` first replays buffered events matching the
+   * requested `channels`, `namespaces`, `depth`, and optional `since` cursor,
+   * then stays attached for live events. Closing the HTTP connection releases
+   * this subscription's event-log cursor.
+   */
+  stream(params: SubscribeParams) {
+    const cursor = this.#log.iterate();
+
+    return new ReadableStream<Uint8Array>({
+      pull: async (controller) => {
+        // Scan forward until we find an event matching this subscription's
+        // filter, enqueue exactly one frame, and return so the channel honors
+        // the consumer's backpressure. `cursor.next()` resolves immediately for
+        // buffered events and suspends once the live edge is reached.
+        for (;;) {
+          const { value: event, done } = await cursor.next();
+          if (done) {
+            controller.close();
+            return;
+          }
+          if (matchesSubscription(event, params)) {
+            controller.enqueue(encodeSse(event));
+            return;
+          }
+        }
+      },
+      cancel: () => {
+        void cursor.return?.(undefined);
+      },
+    });
+  }
+
+  #publish(rawEvent: ProtocolEvent) {
+    const seq = this.#nextSeq;
+    this.#nextSeq += 1;
+    const event = sanitizeEvent({
+      ...rawEvent,
+      type: "event",
+      seq,
+    } as ProtocolEvent);
+    this.#log.push(event);
+  }
+
+  async #startRun(input: AgentRunInput, runId: string) {
+    this.#activeRun?.abort("Starting a new run.");
+    // Thread the `thread_id` / `run_id` into the run config so the checkpointer
+    // persists conversation state per thread and downstream events carry the
+    // run identity.
+    const run = await this.#agent.streamEvents(input, {
+      version: "v3",
+      configurable: { thread_id: this.#threadId, run_id: runId },
+    });
+    this.#activeRun = run;
+
+    try {
+      for await (const rawEvent of run) {
+        this.#publish(rawEvent as ProtocolEvent);
+      }
+    } catch (error) {
+      console.error(error);
+    } finally {
+      if (this.#activeRun === run) {
+        this.#activeRun = undefined;
+      }
+    }
+  }
+}

package/registry/frameworks/next/lib/server/threads.ts

@@ -0,0 +1,406 @@
+import "server-only";
+
+/**
+ * Thread state helpers backed by the graph checkpointer.
+ *
+ * Implements the LangGraph SDK thread state wire-shape consumed by
+ * `client.threads.getState` / `updateState` (`GET|POST /threads/:id/state`) and
+ * `getHistory` (`POST /threads/:id/history`), aligned with the Agent Protocol
+ * thread model.
+ */
+
+import type { MemorySaver } from "@langchain/langgraph";
+import type { CompiledGraphType } from "@langchain/langgraph";
+import type { RunnableConfig } from "@langchain/core/runnables";
+
+import { isRecord, sanitizeForJson } from "./serialize";
+
+/**
+ * Compiled LangGraph instance exposed through the custom protocol server.
+ *
+ * Thread routes read and write checkpointed state through this graph's
+ * checkpointer rather than maintaining a separate thread store.
+ */
+export type LocalProtocolGraph = CompiledGraphType;
+
+type StateSnapshot = Awaited<ReturnType<LocalProtocolGraph["getState"]>>;
+
+/**
+ * Raised when a thread has no checkpoint yet.
+ *
+ * The route handlers map this to HTTP 404 so the LangGraph SDK can bootstrap
+ * the thread via `POST /threads/:id/state` before the first run.
+ */
+export class ThreadNotFoundError extends Error {
+  readonly threadId: string;
+
+  constructor(threadId: string) {
+    super(`Thread ${threadId} not found`);
+    this.name = "ThreadNotFoundError";
+    this.threadId = threadId;
+  }
+}
+
+/**
+ * Graph node used when bootstrapping an empty thread.
+ *
+ * Empty `messages` updates must land on `__start__` so conditional edges are
+ * not evaluated before the first human turn exists.
+ */
+const INITIAL_UPDATE_NODE = "__start__";
+
+/**
+ * Default graph node for non-empty state updates on an existing checkpoint.
+ *
+ * Matches the agent's model node when the client omits `as_node`.
+ */
+const DEFAULT_UPDATE_NODE = "model_request";
+
+/** Build the {@link RunnableConfig} that scopes graph calls to a thread id. */
+function threadConfig(threadId: string): RunnableConfig {
+  return { configurable: { thread_id: threadId } };
+}
+
+/**
+ * Build the config passed to `getStateHistory` for root or subgraph-scoped
+ * history, matching langgraph-api's `{ thread_id, checkpoint_ns: "", ...checkpoint }`.
+ */
+function historyConfig(
+  threadId: string,
+  checkpoint?: Record<string, unknown> | null,
+): RunnableConfig {
+  const configurable: Record<string, unknown> = {
+    thread_id: threadId,
+    checkpoint_ns: "",
+  };
+  if (checkpoint && isRecord(checkpoint)) {
+    Object.assign(configurable, checkpoint);
+  }
+  return { configurable };
+}
+
+/** Read the `configurable` bag from a LangGraph run config. */
+function configurableOf(config: RunnableConfig): Record<string, unknown> {
+  return isRecord(config.configurable) ? config.configurable : {};
+}
+
+/**
+ * Return whether a {@link StateSnapshot} represents a persisted checkpoint.
+ *
+ * LangGraph returns an empty configurable bag before the first write; the SDK
+ * treats that as "thread not found" rather than an empty thread state.
+ */
+function threadHasCheckpoint(snapshot: StateSnapshot): boolean {
+  const checkpointId = configurableOf(snapshot.config).checkpoint_id;
+  return typeof checkpointId === "string" && checkpointId.length > 0;
+}
+
+function isStateSnapshot(state: unknown): state is StateSnapshot {
+  return isRecord(state) && "values" in state && "next" in state;
+}
+
+function serializeTaskError(error: unknown): string | null {
+  if (error == null) return null;
+  if (error instanceof Error) return error.message;
+  if (typeof error === "string") return error;
+  return String(error);
+}
+
+/** Map a LangGraph run config to the SDK checkpoint wire shape. */
+function runnableConfigToCheckpoint(
+  config: RunnableConfig | null | undefined,
+  fallbackThreadId?: string,
+): Record<string, unknown> | null {
+  if (!config || !isRecord(config.configurable)) return null;
+  const c = config.configurable;
+  const thread_id =
+    typeof c.thread_id === "string" ? c.thread_id : fallbackThreadId;
+  if (!thread_id || typeof c.checkpoint_id !== "string") return null;
+
+  return {
+    thread_id,
+    checkpoint_id: c.checkpoint_id,
+    checkpoint_ns: typeof c.checkpoint_ns === "string" ? c.checkpoint_ns : "",
+    checkpoint_map: isRecord(c.checkpoint_map) ? c.checkpoint_map : null,
+  };
+}
+
+function taskCheckpointFromState(
+  state: unknown,
+): Record<string, unknown> | null {
+  if (state == null || !isRecord(state) || !isRecord(state.configurable)) {
+    return null;
+  }
+  const c = state.configurable;
+  if (typeof c.thread_id !== "string") return null;
+  return {
+    thread_id: c.thread_id,
+    checkpoint_id: typeof c.checkpoint_id === "string" ? c.checkpoint_id : null,
+    checkpoint_ns: typeof c.checkpoint_ns === "string" ? c.checkpoint_ns : "",
+    checkpoint_map: isRecord(c.checkpoint_map) ? c.checkpoint_map : null,
+  };
+}
+
+/**
+ * Serialize a LangGraph {@link StateSnapshot} to the SDK `ThreadState` shape.
+ *
+ * Aligned with langgraph-api's `stateSnapshotToThreadState`, plus
+ * {@link sanitizeForJson} on `values` and nested task `result` payloads.
+ */
+export function serializeThreadState(
+  snapshot: StateSnapshot,
+  threadId: string,
+): Record<string, unknown> {
+  const configurable = configurableOf(snapshot.config);
+  const checkpoint = runnableConfigToCheckpoint(snapshot.config, threadId) ?? {
+    thread_id: threadId,
+    checkpoint_id:
+      typeof configurable.checkpoint_id === "string"
+        ? configurable.checkpoint_id
+        : null,
+    checkpoint_ns:
+      typeof configurable.checkpoint_ns === "string"
+        ? configurable.checkpoint_ns
+        : "",
+    checkpoint_map: null,
+  };
+
+  const tasks = (snapshot.tasks ?? []).map((task) => {
+    const record = task as {
+      id?: unknown;
+      name?: unknown;
+      error?: unknown;
+      interrupts?: unknown;
+      path?: unknown;
+      result?: unknown;
+      state?: unknown;
+    };
+    return {
+      id: record.id,
+      name: record.name,
+      error: serializeTaskError(record.error),
+      interrupts: Array.isArray(record.interrupts) ? record.interrupts : [],
+      path: record.path ?? null,
+      checkpoint: taskCheckpointFromState(record.state),
+      state:
+        record.state != null && isStateSnapshot(record.state)
+          ? serializeThreadState(record.state, threadId)
+          : null,
+      result: record.result != null ? sanitizeForJson(record.result) : null,
+    };
+  });
+
+  const parentConfig = (snapshot as { parentConfig?: RunnableConfig })
+    .parentConfig;
+
+  return {
+    values: sanitizeForJson(snapshot.values ?? {}),
+    next: [...(snapshot.next ?? [])],
+    tasks,
+    checkpoint,
+    metadata: { ...snapshot.metadata },
+    created_at: snapshot.createdAt ?? null,
+    parent_checkpoint: runnableConfigToCheckpoint(parentConfig, threadId),
+  };
+}
+
+/** Summary of a thread for the history sidebar. */
+export type ThreadSummary = {
+  id: string;
+  title: string;
+  updatedAt: string | null;
+};
+
+const UNTITLED = "New conversation";
+
+/** Derive a sidebar title from the first human message in a thread. */
+function deriveTitle(values: unknown): string {
+  if (!isRecord(values) || !Array.isArray(values.messages)) return UNTITLED;
+  for (const message of values.messages) {
+    if (!isRecord(message) || message.type !== "human") continue;
+    const { content } = message;
+    const text =
+      typeof content === "string"
+        ? content
+        : Array.isArray(content)
+          ? content
+              .map((block) =>
+                isRecord(block) && typeof block.text === "string"
+                  ? block.text
+                  : "",
+              )
+              .join("")
+          : "";
+    const trimmed = text.trim();
+    if (trimmed) return trimmed.slice(0, 80);
+  }
+  return UNTITLED;
+}
+
+/**
+ * List every thread known to the checkpointer, newest first.
+ *
+ * The checkpointer is the single source of truth: thread ids are the top-level
+ * keys of {@link MemorySaver.storage}, and each thread's title/timestamp is
+ * derived from its latest checkpoint. Restarting the server clears all of this.
+ */
+export async function listThreads(
+  graph: LocalProtocolGraph,
+  checkpointer: MemorySaver,
+): Promise<ThreadSummary[]> {
+  const ids = Object.keys(checkpointer.storage);
+  const summaries: ThreadSummary[] = [];
+  for (const id of ids) {
+    try {
+      const state = await getThreadState(graph, id);
+      summaries.push({
+        id,
+        title: deriveTitle(state.values),
+        updatedAt:
+          typeof state.created_at === "string" ? state.created_at : null,
+      });
+    } catch {
+      // Skip threads without a readable checkpoint.
+    }
+  }
+  summaries.sort((a, b) =>
+    (b.updatedAt ?? "").localeCompare(a.updatedAt ?? ""),
+  );
+  return summaries;
+}
+
+/**
+ * Read checkpointed thread state for `GET /threads/:threadId/state`.
+ *
+ * @throws {@link ThreadNotFoundError} When the thread has no checkpoint yet.
+ */
+export async function getThreadState(
+  graph: LocalProtocolGraph,
+  threadId: string,
+): Promise<Record<string, unknown>> {
+  const snapshot = await graph.getState(threadConfig(threadId));
+  if (!threadHasCheckpoint(snapshot)) throw new ThreadNotFoundError(threadId);
+  return serializeThreadState(snapshot, threadId);
+}
+
+/**
+ * Parse the `before` pagination cursor accepted by `POST /threads/:id/history`.
+ */
+function parseBeforeCursor(
+  threadId: string,
+  before: unknown,
+): RunnableConfig | undefined {
+  if (before == null) return undefined;
+  if (typeof before === "string") {
+    return { configurable: { thread_id: threadId, checkpoint_id: before } };
+  }
+  if (!isRecord(before)) return undefined;
+
+  if (isRecord(before.configurable)) {
+    return {
+      configurable: { thread_id: threadId, ...before.configurable },
+    };
+  }
+
+  const checkpointId = before.checkpoint_id;
+  if (typeof checkpointId !== "string") return undefined;
+
+  const cursor: RunnableConfig = {
+    configurable: { thread_id: threadId, checkpoint_id: checkpointId },
+  };
+  if (typeof before.checkpoint_ns === "string") {
+    (cursor.configurable as Record<string, unknown>).checkpoint_ns =
+      before.checkpoint_ns;
+  }
+  return cursor;
+}
+
+/**
+ * List past thread states for `POST /threads/:threadId/history`.
+ *
+ * @throws {@link ThreadNotFoundError} When the thread has no checkpoint yet.
+ */
+export async function getThreadHistory(
+  graph: LocalProtocolGraph,
+  threadId: string,
+  options: {
+    limit?: number;
+    before?: unknown;
+    metadata?: Record<string, unknown>;
+    checkpoint?: Record<string, unknown> | null;
+  } = {},
+): Promise<Record<string, unknown>[]> {
+  await getThreadState(graph, threadId);
+
+  const history: Record<string, unknown>[] = [];
+  const iterator = graph.getStateHistory(
+    historyConfig(threadId, options.checkpoint),
+    {
+      before: parseBeforeCursor(threadId, options.before),
+      limit: options.limit ?? 10,
+      ...(options.metadata ? { filter: options.metadata } : {}),
+    },
+  );
+  for await (const snapshot of iterator) {
+    history.push(serializeThreadState(snapshot, threadId));
+  }
+  return history;
+}
+
+/** Choose which graph node should receive an `updateState` write. */
+function resolveUpdateNode(options: {
+  asNode?: string;
+  values: Record<string, unknown> | null;
+  hasCheckpoint: boolean;
+}): string {
+  if (options.asNode) return options.asNode;
+  const messages = options.values?.messages;
+  if (!Array.isArray(messages) || messages.length === 0) {
+    return INITIAL_UPDATE_NODE;
+  }
+  if (!options.hasCheckpoint) return INITIAL_UPDATE_NODE;
+  return DEFAULT_UPDATE_NODE;
+}
+
+/**
+ * Create or update thread state for `POST /threads/:threadId/state`.
+ *
+ * Used by the browser bootstrap and by the SDK when hydrating or editing
+ * conversation history. Applies the update at {@link resolveUpdateNode}, then
+ * returns the latest serialized snapshot.
+ */
+export async function updateThreadState(
+  graph: LocalProtocolGraph,
+  threadId: string,
+  options: {
+    values?: Record<string, unknown> | null;
+    checkpoint?: Record<string, unknown> | null;
+    asNode?: string;
+  } = {},
+): Promise<Record<string, unknown>> {
+  let config = threadConfig(threadId);
+  const checkpoint = options.checkpoint;
+  if (checkpoint && typeof checkpoint.checkpoint_id === "string") {
+    config = {
+      configurable: {
+        ...configurableOf(config),
+        checkpoint_id: checkpoint.checkpoint_id,
+        ...(typeof checkpoint.checkpoint_ns === "string"
+          ? { checkpoint_ns: checkpoint.checkpoint_ns }
+          : {}),
+      },
+    };
+  }
+
+  const snapshot = await graph.getState(config);
+  const resolvedValues = options.values ?? { messages: [] };
+  const resolvedAsNode = resolveUpdateNode({
+    asNode: options.asNode,
+    values: resolvedValues,
+    hasCheckpoint: threadHasCheckpoint(snapshot),
+  });
+
+  await graph.updateState(config, resolvedValues, resolvedAsNode);
+  const updated = await graph.getState(threadConfig(threadId));
+  return serializeThreadState(updated, threadId);
+}

package/registry/frameworks/next/next.config.ts

@@ -0,0 +1,7 @@
+import type { NextConfig } from "next";
+
+const nextConfig: NextConfig = {
+  /* config options here */
+};
+
+export default nextConfig;

package/registry/frameworks/next/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "js-next",
+  "version": "0.1.0",
+  "private": true,
+  "scripts": {
+    "dev": "next dev",
+    "build": "next build",
+    "start": "next start",
+    "lint": "eslint"
+  },
+  "dependencies": {
+    "@langchain/core": "^1.2.1",
+    "@langchain/langgraph": "^1.3.7",
+    "@langchain/langgraph-sdk": "^1.9.20",
+    "@langchain/openai": "^1.4.7",
+    "@langchain/protocol": "^0.0.16",
+    "@langchain/react": "^1.0.20",
+    "deepagents": "^1.10.2",
+    "langchain": "^1.4.4",
+    "next": "16.2.9",
+    "react": "19.2.4",
+    "react-dom": "19.2.4",
+    "server-only": "^0.0.1",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@tailwindcss/postcss": "^4",
+    "@types/node": "^20",
+    "@types/react": "^19",
+    "@types/react-dom": "^19",
+    "eslint": "^9",
+    "eslint-config-next": "16.2.9",
+    "tailwindcss": "^4",
+    "typescript": "^5"
+  },
+  "packageManager": "pnpm@10.29.2"
+}

package/registry/frameworks/next/postcss.config.mjs

@@ -0,0 +1,7 @@
+const config = {
+  plugins: {
+    "@tailwindcss/postcss": {},
+  },
+};
+
+export default config;

package/registry/frameworks/next/public/file.svg

@@ -0,0 +1 @@
+<svg fill="none" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg"><path d="M14.5 13.5V5.41a1 1 0 0 0-.3-.7L9.8.29A1 1 0 0 0 9.08 0H1.5v13.5A2.5 2.5 0 0 0 4 16h8a2.5 2.5 0 0 0 2.5-2.5m-1.5 0v-7H8v-5H3v12a1 1 0 0 0 1 1h8a1 1 0 0 0 1-1M9.5 5V2.12L12.38 5zM5.13 5h-.62v1.25h2.12V5zm-.62 3h7.12v1.25H4.5zm.62 3h-.62v1.25h7.12V11z" clip-rule="evenodd" fill="#666" fill-rule="evenodd"/></svg>

package/registry/frameworks/next/public/globe.svg

@@ -0,0 +1 @@
+<svg fill="none" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16"><g clip-path="url(#a)"><path fill-rule="evenodd" clip-rule="evenodd" d="M10.27 14.1a6.5 6.5 0 0 0 3.67-3.45q-1.24.21-2.7.34-.31 1.83-.97 3.1M8 16A8 8 0 1 0 8 0a8 8 0 0 0 0 16m.48-1.52a7 7 0 0 1-.96 0H7.5a4 4 0 0 1-.84-1.32q-.38-.89-.63-2.08a40 40 0 0 0 3.92 0q-.25 1.2-.63 2.08a4 4 0 0 1-.84 1.31zm2.94-4.76q1.66-.15 2.95-.43a7 7 0 0 0 0-2.58q-1.3-.27-2.95-.43a18 18 0 0 1 0 3.44m-1.27-3.54a17 17 0 0 1 0 3.64 39 39 0 0 1-4.3 0 17 17 0 0 1 0-3.64 39 39 0 0 1 4.3 0m1.1-1.17q1.45.13 2.69.34a6.5 6.5 0 0 0-3.67-3.44q.65 1.26.98 3.1M8.48 1.5l.01.02q.41.37.84 1.31.38.89.63 2.08a40 40 0 0 0-3.92 0q.25-1.2.63-2.08a4 4 0 0 1 .85-1.32 7 7 0 0 1 .96 0m-2.75.4a6.5 6.5 0 0 0-3.67 3.44 29 29 0 0 1 2.7-.34q.31-1.83.97-3.1M4.58 6.28q-1.66.16-2.95.43a7 7 0 0 0 0 2.58q1.3.27 2.95.43a18 18 0 0 1 0-3.44m.17 4.71q-1.45-.12-2.69-.34a6.5 6.5 0 0 0 3.67 3.44q-.65-1.27-.98-3.1" fill="#666"/></g><defs><clipPath id="a"><path fill="#fff" d="M0 0h16v16H0z"/></clipPath></defs></svg>

package/registry/frameworks/next/public/next.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 394 80"><path fill="#000" d="M262 0h68.5v12.7h-27.2v66.6h-13.6V12.7H262V0ZM149 0v12.7H94v20.4h44.3v12.6H94v21h55v12.6H80.5V0h68.7zm34.3 0h-17.8l63.8 79.4h17.9l-32-39.7 32-39.6h-17.9l-23 28.6-23-28.6zm18.3 56.7-9-11-27.1 33.7h17.8l18.3-22.7z"/><path fill="#000" d="M81 79.3 17 0H0v79.3h13.6V17l50.2 62.3H81Zm252.6-.4c-1 0-1.8-.4-2.5-1s-1.1-1.6-1.1-2.6.3-1.8 1-2.5 1.6-1 2.6-1 1.8.3 2.5 1a3.4 3.4 0 0 1 .6 4.3 3.7 3.7 0 0 1-3 1.8zm23.2-33.5h6v23.3c0 2.1-.4 4-1.3 5.5a9.1 9.1 0 0 1-3.8 3.5c-1.6.8-3.5 1.3-5.7 1.3-2 0-3.7-.4-5.3-1s-2.8-1.8-3.7-3.2c-.9-1.3-1.4-3-1.4-5h6c.1.8.3 1.6.7 2.2s1 1.2 1.6 1.5c.7.4 1.5.5 2.4.5 1 0 1.8-.2 2.4-.6a4 4 0 0 0 1.6-1.8c.3-.8.5-1.8.5-3V45.5zm30.9 9.1a4.4 4.4 0 0 0-2-3.3 7.5 7.5 0 0 0-4.3-1.1c-1.3 0-2.4.2-3.3.5-.9.4-1.6 1-2 1.6a3.5 3.5 0 0 0-.3 4c.3.5.7.9 1.3 1.2l1.8 1 2 .5 3.2.8c1.3.3 2.5.7 3.7 1.2a13 13 0 0 1 3.2 1.8 8.1 8.1 0 0 1 3 6.5c0 2-.5 3.7-1.5 5.1a10 10 0 0 1-4.4 3.5c-1.8.8-4.1 1.2-6.8 1.2-2.6 0-4.9-.4-6.8-1.2-2-.8-3.4-2-4.5-3.5a10 10 0 0 1-1.7-5.6h6a5 5 0 0 0 3.5 4.6c1 .4 2.2.6 3.4.6 1.3 0 2.5-.2 3.5-.6 1-.4 1.8-1 2.4-1.7a4 4 0 0 0 .8-2.4c0-.9-.2-1.6-.7-2.2a11 11 0 0 0-2.1-1.4l-3.2-1-3.8-1c-2.8-.7-5-1.7-6.6-3.2a7.2 7.2 0 0 1-2.4-5.7 8 8 0 0 1 1.7-5 10 10 0 0 1 4.3-3.5c2-.8 4-1.2 6.4-1.2 2.3 0 4.4.4 6.2 1.2 1.8.8 3.2 2 4.3 3.4 1 1.4 1.5 3 1.5 5h-5.8z"/></svg>

package/registry/frameworks/next/public/vercel.svg

@@ -0,0 +1 @@
+<svg fill="none" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1155 1000"><path d="m577.3 0 577.4 1000H0z" fill="#fff"/></svg>

package/registry/frameworks/next/public/window.svg

@@ -0,0 +1 @@
+<svg fill="none" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16"><path fill-rule="evenodd" clip-rule="evenodd" d="M1.5 2.5h13v10a1 1 0 0 1-1 1h-11a1 1 0 0 1-1-1zM0 1h16v11.5a2.5 2.5 0 0 1-2.5 2.5h-11A2.5 2.5 0 0 1 0 12.5zm3.75 4.5a.75.75 0 1 0 0-1.5.75.75 0 0 0 0 1.5M7 4.75a.75.75 0 1 1-1.5 0 .75.75 0 0 1 1.5 0m1.75.75a.75.75 0 1 0 0-1.5.75.75 0 0 0 0 1.5" fill="#666"/></svg>