@tuongaz/seeflow 0.1.98 → 0.1.100

package/src/icons/router.ts

@@ -0,0 +1,211 @@
+import { join } from 'node:path';
+import { Hono } from 'hono';
+import { streamSSE } from 'hono/streaming';
+import { z } from 'zod';
+import { fetchWithProgress } from './fetcher.ts';
+import { readIndex } from './index-store.ts';
+import type { InstallEvent } from './installer-types.ts';
+import { type InstallerDeps, installIconPack as defaultInstallIconPack } from './installer.ts';
+import type { JobRegistry } from './jobs.ts';
+import { summarizePacks } from './list-helper.ts';
+import { iconCacheRoot } from './paths.ts';
+import { removeIconPack } from './remove.ts';
+import { vendorDescriptor } from './vendors.ts';
+
+export type IconFetcher = (url: string) => Promise<Buffer>;
+export type IconInstaller = typeof defaultInstallIconPack;
+
+export interface IconsRouterDeps {
+  jobs: JobRegistry;
+  /** Defaults to seeflowHome()/icons. Tests inject a tmpdir. */
+  cacheRoot?: string;
+  /** Defaults to fetchWithProgress (real network). Tests inject a fixture. */
+  fetcher?: IconFetcher;
+  /** Defaults to installIconPack. Tests can swap. */
+  installer?: IconInstaller;
+}
+
+const VendorSchema = z.enum(['aws', 'azure']);
+const InstallBodySchema = z.object({
+  vendor: VendorSchema,
+  acceptTerms: z.boolean().optional(),
+  packUrl: z.string().optional(),
+});
+
+export function createIconsRouter(deps: IconsRouterDeps): Hono {
+  const app = new Hono();
+  const installer = deps.installer ?? defaultInstallIconPack;
+  const getCacheRoot = () => deps.cacheRoot ?? iconCacheRoot();
+  const getFetcher = (): IconFetcher => deps.fetcher ?? ((url) => fetchWithProgress(url));
+
+  app.get('/packs', (c) => {
+    const idx = readIndex(getCacheRoot());
+    return c.json({ packs: summarizePacks(idx) });
+  });
+
+  app.get('/licenses/:vendor', (c) => {
+    const parsed = VendorSchema.safeParse(c.req.param('vendor'));
+    if (!parsed.success) return c.json({ error: 'unknown vendor' }, 404);
+    const desc = vendorDescriptor(parsed.data);
+    return c.json({
+      vendor: desc.vendor,
+      label: desc.label,
+      summary: desc.licenseSummary,
+      url: desc.licenseUrl,
+      requiresAcceptance: desc.requiresAcceptance,
+    });
+  });
+
+  // Constrain `:filename` to `<name>.svg` so this route doesn't shadow
+  // /licenses/:vendor, /packs/:vendor, or /jobs/:id at the two-segment level.
+  app.get('/:vendor/:filename{[^/]+\\.svg}', async (c) => {
+    const vendorParsed = VendorSchema.safeParse(c.req.param('vendor'));
+    if (!vendorParsed.success) return c.json({ error: 'unknown vendor' }, 404);
+    const vendor = vendorParsed.data;
+    const filename = c.req.param('filename');
+    const name = filename.slice(0, -4);
+
+    const idx = readIndex(getCacheRoot());
+    const pack = idx.packs[vendor];
+    const hint = `POST /api/icons/install { "vendor": "${vendor}" }`;
+    if (!pack) {
+      return c.json({ error: `vendor ${vendor} is not installed`, install: hint }, 404);
+    }
+    const rel = pack.icons[name];
+    if (!rel) {
+      return c.json({ error: `icon ${vendor}:${name} not found`, install: hint }, 404);
+    }
+    const abs = join(getCacheRoot(), rel);
+    const file = Bun.file(abs);
+    if (!(await file.exists())) {
+      return c.json({ error: `icon file missing on disk: ${rel}` }, 404);
+    }
+    return new Response(file.stream(), {
+      headers: {
+        'content-type': 'image/svg+xml',
+        // No `immutable` — pack reinstalls (e.g. after an extractor bugfix)
+        // can change the bytes served at the same /api/icons/<vendor>/<name>.svg
+        // URL. `immutable` would tell the browser to skip revalidation even on
+        // hard refresh, locking users on bad cached content. A 1-day max-age
+        // keeps the picker fast without trapping fixed icons behind cache.
+        'cache-control': 'public, max-age=86400',
+      },
+    });
+  });
+
+  app.post('/install', async (c) => {
+    let body: unknown;
+    try {
+      body = await c.req.json();
+    } catch {
+      return c.json({ error: 'Body must be valid JSON' }, 400);
+    }
+    const parsed = InstallBodySchema.safeParse(body);
+    if (!parsed.success) {
+      return c.json({ error: 'Invalid install body', issues: parsed.error.issues }, 400);
+    }
+    const { vendor, acceptTerms, packUrl } = parsed.data;
+
+    const existing = deps.jobs.inFlightFor(vendor);
+    if (existing !== undefined) {
+      return c.json({ error: `install for ${vendor} already in flight`, jobId: existing }, 409);
+    }
+
+    let jobId: string;
+    try {
+      jobId = deps.jobs.create(vendor);
+    } catch (err) {
+      return c.json({ error: err instanceof Error ? err.message : String(err) }, 409);
+    }
+
+    const installerDeps: InstallerDeps = {
+      cacheRoot: getCacheRoot(),
+      now: Date.now,
+      version: () => new Date().toISOString().slice(0, 10),
+      fetcher: getFetcher(),
+    };
+
+    // Fire-and-forget: pump installer events into the job registry. The SSE
+    // route below replays buffered events on subscribe and races live ones, so
+    // the response can return jobId immediately and the client can subscribe
+    // whenever it likes.
+    (async () => {
+      try {
+        for await (const ev of installer({ vendor, acceptTerms, packUrl }, installerDeps)) {
+          deps.jobs.append(jobId, ev);
+        }
+      } catch (err) {
+        deps.jobs.append(jobId, {
+          type: 'error',
+          vendor,
+          message: err instanceof Error ? err.message : String(err),
+        });
+      } finally {
+        deps.jobs.markComplete(jobId);
+      }
+    })();
+
+    return c.json({ jobId });
+  });
+
+  app.get('/jobs/:id/events', (c) => {
+    const id = c.req.param('id');
+    return streamSSE(c, async (stream) => {
+      let active = true;
+      let ended = false;
+      const queue: InstallEvent[] = [];
+      let resume: (() => void) | null = null;
+
+      const wake = () => {
+        if (resume) {
+          const r = resume;
+          resume = null;
+          r();
+        }
+      };
+
+      const unsubscribe = deps.jobs.subscribe(
+        id,
+        (ev) => {
+          queue.push(ev);
+          wake();
+        },
+        () => {
+          ended = true;
+          wake();
+        },
+      );
+
+      stream.onAbort(() => {
+        active = false;
+        unsubscribe();
+        wake();
+      });
+
+      try {
+        while (active) {
+          while (queue.length > 0) {
+            const next = queue.shift();
+            if (!next) break;
+            await stream.writeSSE({ data: JSON.stringify(next) });
+          }
+          if (ended || !active) break;
+          await new Promise<void>((r) => {
+            resume = r;
+          });
+        }
+      } finally {
+        unsubscribe();
+      }
+    });
+  });
+
+  app.delete('/packs/:vendor', (c) => {
+    const parsed = VendorSchema.safeParse(c.req.param('vendor'));
+    if (!parsed.success) return c.json({ error: 'unknown vendor' }, 404);
+    removeIconPack(parsed.data, { cacheRoot: getCacheRoot() });
+    return c.json({ removed: parsed.data });
+  });
+
+  return app;
+}

package/src/icons/vendors.ts

@@ -0,0 +1,52 @@
+import { canonicalAwsName } from './normalize-aws.ts';
+import { canonicalAzureName } from './normalize-azure.ts';
+import type { IconVendor } from './paths.ts';
+
+export interface VendorDescriptor {
+  vendor: IconVendor;
+  label: string;
+  defaultPackUrl: string;
+  /** Short summary; UI shows it inline. Authoritative terms live at `licenseUrl`. */
+  licenseSummary: string;
+  licenseUrl: string;
+  /** Whether the user must affirmatively accept terms before install. */
+  requiresAcceptance: boolean;
+  /** Filename → canonical kebab-name; null = skip entry. */
+  canonicalName: (filename: string) => string | null;
+}
+
+const AWS: VendorDescriptor = {
+  vendor: 'aws',
+  label: 'AWS',
+  // AWS re-issues this asset every release and removes prior versions; the
+  // q1-2025 path now 403s from CloudFront. Keep this in sync with whatever
+  // the Icon-package link at https://aws.amazon.com/architecture/icons/
+  // currently points to.
+  defaultPackUrl:
+    'https://d1.awsstatic.com/onedam/marketing-channels/website/aws/en_US/architecture/approved/architecture-icons/Icon-package_04302026.4705b90f5aa45b019271a2699e9ce9b97b941ee1.zip',
+  licenseSummary:
+    'Free to use in architecture diagrams. Attribution required for any public publication. See license URL for full terms.',
+  licenseUrl: 'https://aws.amazon.com/architecture/icons/',
+  requiresAcceptance: false,
+  canonicalName: canonicalAwsName,
+};
+
+const AZURE: VendorDescriptor = {
+  vendor: 'azure',
+  label: 'Microsoft Azure',
+  defaultPackUrl: 'https://arch-center.azureedge.net/icons/Azure_Public_Service_Icons_V20.zip',
+  licenseSummary:
+    'Microsoft requires explicit acceptance of the Azure architecture icon terms before use. Icons may not be modified and must not be used to imply Microsoft endorsement. See license URL for full terms.',
+  licenseUrl: 'https://learn.microsoft.com/en-us/azure/architecture/icons/',
+  requiresAcceptance: true,
+  canonicalName: canonicalAzureName,
+};
+
+export const VENDOR_DESCRIPTORS: Record<IconVendor, VendorDescriptor> = {
+  aws: AWS,
+  azure: AZURE,
+};
+
+export function vendorDescriptor(vendor: IconVendor): VendorDescriptor {
+  return VENDOR_DESCRIPTORS[vendor];
+}

package/src/layout.ts

@@ -79,6 +79,7 @@ const DEFAULT_DIMENSIONS: Record<FlowNode['type'], { width: number; height: numb
   html: { width: 320, height: 200 },
   icon: { width: 80, height: 80 },
   component: { width: 320, height: 240 },
+  linkflow: { width: 240, height: 100 },
 };
 
 // Sticky / text variants are floating annotations. They never participate in

package/src/operations.ts

@@ -32,6 +32,7 @@ import {
   EdgePinSchema,
   type Flow,
   FlowSchema,
+  LinkflowTargetSchema,
   NodeTypeSchema,
   PlayActionSchema,
   type ResolvedFlow,
@@ -156,6 +157,12 @@ export const NodePatchBodySchema = z
     // reparse + SSE broadcast, but splitFlow strips it from flow.json so the
     // sidecar is the source of truth on disk.
     spec: ComponentSpecSchema.optional(),
+    // type:'linkflow'-only: slug pair { project, flow } naming the target flow.
+    // Lands at data.target. Explicit `null` clears the field (mergeNodeUpdates
+    // strips the key from disk), so undo of a link/edit reverts a previously-
+    // unset target back to unlinked. The post-merge ResolvedFlowSchema reparse
+    // gates that this is only valid on type:'linkflow'.
+    target: LinkflowTargetSchema.nullable().optional(),
   })
   .strict();
 export type NodePatchBody = z.infer<typeof NodePatchBodySchema>;
@@ -189,6 +196,7 @@ const NODE_DATA_PATCH_KEYS = [
   'statusAction',
   'stateSource',
   'spec',
+  'target',
 ] as const satisfies ReadonlyArray<keyof NodePatchBody>;
 
 const EXTERNALIZED_FIELD_NAMES = new Set<string>(EXTERNALIZED_NODE_FIELDS.map((e) => e.field));
@@ -261,6 +269,21 @@ const SEMANTIC_KEYS_BY_TYPE: Record<z.infer<typeof NodeTypeSchema>, ReadonlySet<
   // semantic-key set covers only the universal capability fields so retype
   // never drags `spec` through `data`. (US-007 wires the sidecar writer.)
   component: GEOMETRIC_SEMANTIC_KEYS,
+  // Linkflow nodes carry an optional `target` slug pair pointing at another
+  // flow. Retype preserves it alongside the universal semantic keys; the
+  // post-merge ResolvedFlowSchema reparse drops it when retyping AWAY from
+  // linkflow.
+  linkflow: new Set([
+    'name',
+    'description',
+    'detail',
+    'icon',
+    'stateSource',
+    'handlerModule',
+    'playAction',
+    'statusAction',
+    'target',
+  ]),
 };
 
 // Visual data keys — routed to style.json on write by splitFlow. Kept here

package/src/schema-catalog.ts

@@ -23,6 +23,7 @@ import {
   FlowHtmlNodeSchema,
   FlowIconNodeSchema,
   FlowImageNodeSchema,
+  FlowLinkflowNodeSchema,
   FlowQueueNodeSchema,
   FlowRectangleNodeSchema,
   FlowServerNodeSchema,
@@ -144,6 +145,7 @@ const PAYLOADS: Record<string, SchemaPayload> = {
       html: toJsonSchema(FlowHtmlNodeSchema),
       icon: toJsonSchema(FlowIconNodeSchema),
       component: toJsonSchema(FlowComponentNodeSchema),
+      linkflow: toJsonSchema(FlowLinkflowNodeSchema),
     },
     notes: [
       "type:'image' data.path must start with 'nodes/<id>/'.",

package/src/schema.ts

@@ -85,7 +85,7 @@ const NodeSemanticBaseShape = {
     .string()
     .optional()
     .describe(
-      "Decorative header glyph (Lucide icon name in kebab-case, e.g. 'database', 'cloud-upload'). Falls back to a placeholder when unknown. On type:'icon' nodes the icon IS the visual and is required.",
+      "Decorative header glyph. Encoded as `vendor:name` — unprefixed values are Lucide kebab-case (e.g. 'database', 'cloud-upload'); prefixed values target installed icon packs ('aws:lambda', 'azure:functions') or the iconify catalog ('iconify:logos:google-cloud'). Falls back to a placeholder when unknown. On type:'icon' nodes the icon IS the visual and is required.",
     ),
 };
 
@@ -184,10 +184,17 @@ const NodeCapabilitiesShape = {
     ),
 };
 
-// 15 flat node types. The first 11 are geometric/illustrative and share
-// GeometricNodeData. `image`, `html`, `icon`, `component` carry per-type
-// fields. The renderer picks the SVG / chrome by `type`; the schema treats
-// them (apart from the per-type fields below) as identical.
+// Flow ids are URL-safe and folder-safe: lowercase alphanumerics + dashes,
+// must start with an alphanumeric character. Same pattern enforced by the
+// manifest CRUD endpoints (POST/PATCH /api/projects/:project/flows[/:flow]).
+// Defined early so the linkflow node data shapes below can reference it; the
+// SeeflowManifest schemas at the bottom of the file reuse the same constant.
+export const FlowIdPattern = /^[a-z0-9][a-z0-9-]*$/;
+
+// 16 flat node types. The first 11 are geometric/illustrative and share
+// GeometricNodeData. `image`, `html`, `icon`, `component`, `linkflow` carry
+// per-type fields. The renderer picks the SVG / chrome by `type`; the schema
+// treats them (apart from the per-type fields below) as identical.
 export const GEOMETRIC_NODE_TYPES = [
   'rectangle',
   'ellipse',
@@ -208,6 +215,7 @@ export const NodeTypeSchema = z.enum([
   'html',
   'icon',
   'component',
+  'linkflow',
 ]);
 
 // --- Component node spec/action schemas --------------------------------------
@@ -318,6 +326,29 @@ const ResolvedComponentNodeData = z.object({
   autoSize: z.boolean().optional(),
 });
 
+// Linkflow node — clickable "go to another flow" link. `target` is optional
+// because freshly-dropped nodes start unlinked; once the user picks a flow
+// via the picker dialog, the studio patches both `project` and `flow` (each
+// matching FlowIdPattern). Target existence (does the project + flow still
+// resolve to a known flow?) is a render-time concern, not a parse-time one:
+// renames/deletes still parse cleanly so undo / cross-project picks work
+// without the schema rejecting them.
+export const LinkflowTargetSchema = z.object({
+  project: z.string().regex(FlowIdPattern, {
+    message: 'target.project must match /^[a-z0-9][a-z0-9-]*$/',
+  }),
+  flow: z.string().regex(FlowIdPattern, {
+    message: 'target.flow must match /^[a-z0-9][a-z0-9-]*$/',
+  }),
+});
+
+const ResolvedLinkflowNodeData = z.object({
+  ...NodeSemanticBaseShape,
+  ...NodeVisualBaseShape,
+  ...NodeCapabilitiesShape,
+  target: LinkflowTargetSchema.optional(),
+});
+
 const NodeBaseShape = {
   id: z.string().min(1),
   position: PositionSchema,
@@ -350,6 +381,11 @@ const NodeSchema = z.discriminatedUnion('type', [
     type: z.literal('component'),
     data: ResolvedComponentNodeData,
   }),
+  z.object({
+    ...NodeBaseShape,
+    type: z.literal('linkflow'),
+    data: ResolvedLinkflowNodeData,
+  }),
 ]);
 
 // Connector — unchanged by the flat-types refactor.
@@ -538,7 +574,7 @@ const FlowIconNodeData = z
       .string()
       .min(1)
       .describe(
-        "Required Lucide icon name (kebab-case, e.g. 'cloud-upload', 'database'). On type:'icon' nodes the icon IS the visual — overrides the optional decorative `icon` from the semantic base.",
+        "Required icon. Encoded as `vendor:name` — unprefixed values are Lucide kebab-case (e.g. 'cloud-upload', 'database'); prefixed values target installed icon packs ('aws:lambda', 'azure:functions') or the iconify catalog ('iconify:logos:google-cloud'). On type:'icon' nodes the icon IS the visual — overrides the optional decorative `icon` from the semantic base.",
       ),
     alt: z.string().optional().describe('Accessibility alt text for the icon glyph.'),
   })
@@ -561,6 +597,21 @@ const FlowComponentNodeData = z
   })
   .strict();
 
+// Linkflow node, on-disk shape. `target` carries the slug pair that names
+// another flow in the registry; optional because a freshly-dropped link node
+// is unlinked until the picker commits a choice. Target existence is checked
+// at render time (broken-link state), never at parse time, so renames /
+// deletes still parse cleanly.
+const FlowLinkflowNodeData = z
+  .object({
+    ...NodeSemanticBaseShape,
+    ...NodeCapabilitiesShape,
+    target: LinkflowTargetSchema.optional().describe(
+      "Slug pair { project, flow } naming the flow this node links to. Both fields are matched against /^[a-z0-9][a-z0-9-]*$/. Omitted on freshly-dropped nodes — the picker dialog patches it once the user picks a target. Cross-project links are allowed (project may differ from the host flow's project).",
+    ),
+  })
+  .strict();
+
 const FlowNodeBaseShape = {
   id: z.string().min(1),
 };
@@ -618,6 +669,14 @@ export const FlowComponentNodeSchema = z
   })
   .strict();
 
+export const FlowLinkflowNodeSchema = z
+  .object({
+    ...FlowNodeBaseShape,
+    type: z.literal('linkflow'),
+    data: FlowLinkflowNodeData,
+  })
+  .strict();
+
 const FlowNodeSchema = z.discriminatedUnion('type', [
   FlowRectangleNodeSchema,
   FlowEllipseNodeSchema,
@@ -634,6 +693,7 @@ const FlowNodeSchema = z.discriminatedUnion('type', [
   FlowHtmlNodeSchema,
   FlowIconNodeSchema,
   FlowComponentNodeSchema,
+  FlowLinkflowNodeSchema,
 ]);
 
 const FlowConnectorBaseShape = {
@@ -765,11 +825,6 @@ export type ConnectorStyleEntry = z.infer<typeof ConnectorStyleEntrySchema>;
 // can consume.
 // =============================================================================
 
-// Flow ids are URL-safe and folder-safe: lowercase alphanumerics + dashes,
-// must start with an alphanumeric character. Same pattern enforced by the
-// manifest CRUD endpoints (POST/PATCH /api/projects/:project/flows[/:flow]).
-export const FlowIdPattern = /^[a-z0-9][a-z0-9-]*$/;
-
 const SeeflowManifestFlowEntrySchema = z.object({
   id: z.string().regex(FlowIdPattern, {
     message: 'flow id must match /^[a-z0-9][a-z0-9-]*$/',

package/src/server.ts

@@ -7,6 +7,8 @@ import { type ProxyFacade, createApi } from './api.ts';
 import { createCorsMiddleware } from './cors.ts';
 import { createDemoRouter } from './demo.ts';
 import { type EventBus, createEventBus } from './events.ts';
+import { type JobRegistry, createJobRegistry } from './icons/jobs.ts';
+import type { IconFetcher } from './icons/router.ts';
 import { createMcpServer } from './mcp.ts';
 import { seeflowHome } from './paths.ts';
 import { type ProcessSpawner, defaultProcessSpawner } from './process-spawner.ts';
@@ -67,6 +69,16 @@ export interface CreateAppOptions {
    *  `Bun.serve` binds — useful for the ephemeral-port boot in
    *  `mcp-shim.ts` where the URL isn't known until the server is up. */
   httpUrl?: string;
+  /** Shared icon-install job registry. Defaults to a per-app registry created
+   *  in createApp so SSE replays survive across requests within the same
+   *  studio process. Integration tests inject their own to assert state. */
+  iconJobs?: JobRegistry;
+  /** Override the icon-cache root. Production resolves it from `seeflowHome()`
+   *  inside the router; tests pass an isolated tmpdir. */
+  iconCacheRoot?: string;
+  /** Override the icon installer's fetcher. Production uses fetchWithProgress
+   *  (real network); integration tests inject a fixture-returning closure. */
+  iconFetcher?: IconFetcher;
 }
 
 const DEFAULT_VITE_DEV_URL = 'http://localhost:5173';
@@ -95,6 +107,7 @@ export function createApp(options: CreateAppOptions = {}): Hono {
   const statusRunner =
     options.statusRunner ??
     createStatusRunner({ registry, events, spawner: defaultProcessSpawner });
+  const iconJobs = options.iconJobs ?? createJobRegistry();
 
   if (watcher && (options.watchAllOnBoot ?? true)) {
     watcher.watchAll();
@@ -155,6 +168,9 @@ export function createApp(options: CreateAppOptions = {}): Hono {
       statusRunner,
       processSpawner: options.processSpawner,
       proxy: options.proxy,
+      iconJobs,
+      iconCacheRoot: options.iconCacheRoot,
+      iconFetcher: options.iconFetcher,
     }),
   );
 

package/dist/web/assets/channel-v9-wsv2r.js

@@ -1 +0,0 @@
-import{U as a,C as n}from"./mermaid.core-Q5Rkziel.js";const t=(r,o)=>a.lang.round(n.parse(r)[o]);export{t as c};

package/dist/web/assets/classDiagram-4FO5ZUOK-CY00ktDc.js

@@ -1 +0,0 @@
-import{s as a,a as s,c as e,C as t}from"./chunk-727SXJPM-B2Ar-3-Y.js";import{a as i}from"./mermaid.core-Q5Rkziel.js";import"./index-B-NP-7Oo.js";import"./chunk-FMBD7UC4-BDQ2jKs8.js";import"./chunk-ND2GUHAM-DbrZoSgU.js";import"./chunk-55IACEB6-DekK1DpQ.js";import"./chunk-2J33WTMH-LVhrEzuA.js";import"./purify.es-CLGrRn1w.js";import"./step-CWvwoXpJ.js";var b={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{b as diagram};

package/dist/web/assets/classDiagram-v2-Q7XG4LA2-CY00ktDc.js

@@ -1 +0,0 @@
-import{s as a,a as s,c as e,C as t}from"./chunk-727SXJPM-B2Ar-3-Y.js";import{a as i}from"./mermaid.core-Q5Rkziel.js";import"./index-B-NP-7Oo.js";import"./chunk-FMBD7UC4-BDQ2jKs8.js";import"./chunk-ND2GUHAM-DbrZoSgU.js";import"./chunk-55IACEB6-DekK1DpQ.js";import"./chunk-2J33WTMH-LVhrEzuA.js";import"./purify.es-CLGrRn1w.js";import"./step-CWvwoXpJ.js";var b={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{b as diagram};