airaknit 1.1.2-rc.9

package/src/shared/profile-types.ts

@@ -0,0 +1,49 @@
+import type { ModelOptions } from "./types"
+
+export interface ProviderProfile {
+  id: string
+  name: string
+  provider: "claude" | "codex"
+  runtime: { version: string } | "system"
+  model: string
+  modelOptions?: ModelOptions
+  apiKeyRef?: string
+  systemPrompt?: string
+  skills?: string[]
+  plugins?: string[]
+  env?: Record<string, string>
+}
+
+export interface WorkspaceProfileOverride {
+  profileId: string
+  workspaceId: string
+  overrides: Partial<Omit<ProviderProfile, "id" | "provider">>
+  updatedAt: number
+}
+
+export interface ProviderProfileRecord {
+  id: string
+  profile: ProviderProfile
+  createdAt: number
+  updatedAt: number
+}
+
+export interface ProfileSnapshot {
+  profiles: ProviderProfileRecord[]
+  workspaceOverrides: WorkspaceProfileOverride[]
+}
+
+export function resolveProfile(
+  global: ProviderProfile,
+  override?: Partial<Omit<ProviderProfile, "id" | "provider">>,
+): ProviderProfile {
+  if (!override) return global
+  return {
+    ...global,
+    ...override,
+    env: override.env ? { ...global.env, ...override.env } : global.env,
+    modelOptions: override.modelOptions
+      ? { ...global.modelOptions, ...override.modelOptions }
+      : global.modelOptions,
+  }
+}

package/src/shared/projectFileUrl.ts

@@ -0,0 +1,36 @@
+export function buildProjectFileContentUrl(
+  projectId: string | null | undefined,
+  relativePath: string | null | undefined,
+): string | null {
+  if (!projectId || !relativePath) return null
+  const encodedPath = relativePath
+    .split("/")
+    .map((segment) => encodeURIComponent(segment))
+    .join("/")
+  return `/api/projects/${encodeURIComponent(projectId)}/files/${encodedPath}/content`
+}
+
+export function buildLocalFileContentUrl(absolutePath: string): string {
+  return `/api/local-file?path=${encodeURIComponent(absolutePath)}`
+}
+
+const WINDOWS_DRIVE_PATH = /^[A-Za-z]:[\\/]/
+
+export function isAbsoluteFilePath(value: string): boolean {
+  return value.startsWith("/") || WINDOWS_DRIVE_PATH.test(value)
+}
+
+/**
+ * Pick the right content URL for a file path. Absolute paths cannot be project-relative,
+ * so they route through `/api/local-file`. Relative paths go through the project route.
+ */
+export function buildContentUrlForFilePath(
+  projectId: string | null | undefined,
+  filePath: string | null | undefined,
+): string | null {
+  if (!filePath) return null
+  if (isAbsoluteFilePath(filePath)) {
+    return buildLocalFileContentUrl(filePath)
+  }
+  return buildProjectFileContentUrl(projectId, filePath)
+}

package/src/shared/protocol.ts

@@ -0,0 +1,153 @@
+import type {
+  AgentProvider,
+  ModelOptions,
+} from "./types"
+
+export type SubscriptionTopic =
+  | { type: "sidebar" }
+  | { type: "local-workspaces" }
+  | { type: "update" }
+  | { type: "chat"; chatId: string }
+  | { type: "terminal"; terminalId: string }
+  | { type: "orchestration"; chatId: string }
+  | { type: "workspace"; workspaceId: string }
+  | { type: "agent-config"; workspaceId: string }
+  | { type: "repos"; workspaceId: string }
+  | { type: "workflow-runs"; workspaceId: string }
+  | { type: "sandbox-status"; workspaceId: string }
+  | { type: "runtime-status" }
+  | { type: "profiles" }
+  | { type: "extension-preferences" }
+  | { type: "runner-teams" }
+
+export interface TerminalSnapshot {
+  terminalId: string
+  title: string
+  cwd: string
+  shell: string
+  cols: number
+  rows: number
+  scrollback: number
+  serializedState: string
+  status: "running" | "exited"
+  exitCode: number | null
+  signal?: number
+}
+
+export type TerminalEvent =
+  | { type: "terminal.output"; terminalId: string; data: string }
+  | { type: "terminal.exit"; terminalId: string; exitCode: number; signal?: number }
+
+export type ClientCommand =
+  | { type: "project.open"; localPath: string }
+  | { type: "project.create"; localPath: string; title: string }
+  | { type: "project.remove"; workspaceId: string }
+  | { type: "independent-workspace.create"; name: string }
+  | { type: "independent-workspace.delete"; workspaceId: string }
+  | { type: "independent-workspace.rename"; workspaceId: string; name: string }
+  | { type: "independent-workspace.set-pinned"; workspaceId: string; pinned: boolean }
+  | { type: "independent-workspace.reorder"; orderedWorkspaceIds: string[] }
+  | { type: "system.ping" }
+  | { type: "update.check"; force?: boolean }
+  | { type: "update.install" }
+  | {
+      type: "system.openExternal"
+      localPath: string
+      action: "open_finder" | "open_terminal"
+    }
+  | {
+      type: "system.readLocalFilePreview"
+      localPath: string
+    }
+  | { type: "chat.create"; workspaceId: string; repoId?: string; chatId?: string }
+  | { type: "chat.rename"; chatId: string; title: string }
+  | { type: "chat.delete"; chatId: string }
+  | { type: "chat.markRead"; chatId: string }
+  | {
+      type: "chat.send"
+      chatId?: string
+      workspaceId?: string
+      provider?: AgentProvider
+      content: string
+      model?: string
+      modelOptions?: ModelOptions
+      effort?: string
+      planMode?: boolean
+    }
+  | {
+      type: "chat.queue"
+      chatId: string
+      provider?: AgentProvider
+      content: string
+      model?: string
+      modelOptions?: ModelOptions
+      effort?: string
+      planMode?: boolean
+    }
+  | { type: "chat.cancel"; chatId: string }
+  | { type: "chat.respondTool"; chatId: string; toolUseId: string; result: unknown }
+  | { type: "chat.generateForkPrompt"; chatId: string; intent: string; preset?: string }
+  | { type: "chat.generateMergePrompt"; chatIds: string[]; intent: string; preset?: string }
+  | { type: "chat.getSessionRuntime"; chatId: string }
+  | { type: "chat.getRepoStatus"; chatId: string }
+  | { type: "chat.getMessageCount"; chatId: string }
+  | { type: "chat.getRenderUnits"; chatId: string; offset?: number; limit?: number; isLoading?: boolean }
+  | { type: "chat.getExternalSessionMessages"; parentChatId: string; sessionId: string }
+  | { type: "terminal.create"; workspaceId: string; terminalId: string; cols: number; rows: number; scrollback: number }
+  | { type: "terminal.input"; terminalId: string; data: string }
+  | { type: "terminal.resize"; terminalId: string; cols: number; rows: number }
+  | { type: "terminal.close"; terminalId: string }
+  | { type: "chat.getMessages"; chatId: string; offset?: number; limit?: number }
+  | { type: "snapshot.subscribe"; subscriptionId: string; topic: SubscriptionTopic }
+  | { type: "snapshot.unsubscribe"; subscriptionId: string }
+  | { type: "workspace.todo.add"; workspaceId: string; todoId: string; description: string; priority?: "high" | "normal" | "low"; createdBy?: string }
+  | { type: "workspace.todo.claim"; workspaceId: string; todoId: string; sessionId: string }
+  | { type: "workspace.todo.complete"; workspaceId: string; todoId: string; outputs: string[] }
+  | { type: "workspace.todo.abandon"; workspaceId: string; todoId: string }
+  | { type: "workspace.claim.create"; workspaceId: string; claimId: string; intent: string; files: string[]; sessionId: string }
+  | { type: "workspace.claim.release"; workspaceId: string; claimId: string }
+  | { type: "workspace.worktree.create"; workspaceId: string; worktreeId: string; branch: string; baseBranch?: string }
+  | { type: "workspace.worktree.assign"; workspaceId: string; worktreeId: string; sessionId: string }
+  | { type: "workspace.worktree.remove"; workspaceId: string; worktreeId: string }
+  | { type: "workspace.rule.set"; workspaceId: string; ruleId: string; content: string; setBy: string }
+  | { type: "workspace.rule.remove"; workspaceId: string; ruleId: string }
+  | { type: "workspace.coordination.snapshot"; workspaceId: string }
+  | { type: "workspace.agent.save"; workspaceId: string; config: import("./agent-config-types").AgentConfig }
+  | { type: "workspace.agent.list"; workspaceId: string }
+  | { type: "workspace.agent.get"; workspaceId: string; agentId: string }
+  | { type: "workspace.agent.remove"; workspaceId: string; agentId: string }
+  | { type: "workspace.repo.add"; workspaceId: string; localPath: string; label?: string }
+  | { type: "workspace.repo.clone"; workspaceId: string; origin: string; targetPath: string; label?: string }
+  | { type: "workspace.repo.remove"; workspaceId: string; repoId: string }
+  | { type: "workspace.repo.label"; repoId: string; label: string }
+  | { type: "workspace.repo.status"; repoId: string }
+  | { type: "workspace.repo.pull"; repoId: string; branch?: string }
+  | { type: "workspace.repo.push"; repoId: string; branch?: string }
+  | { type: "workspace.workflow.run"; workspaceId: string; workflowId: string; triggeredBy?: string }
+  | { type: "workspace.workflow.cancel"; workspaceId: string; runId: string }
+  | { type: "workspace.workflow.list"; workspaceId: string }
+  | { type: "workspace.sandbox.create"; workspaceId: string; resourceLimits?: import("./sandbox-types").ResourceLimits }
+  | { type: "workspace.sandbox.start"; workspaceId: string }
+  | { type: "workspace.sandbox.stop"; workspaceId: string; reason?: string }
+  | { type: "workspace.sandbox.destroy"; workspaceId: string }
+  | { type: "workspace.sandbox.logs"; workspaceId: string; tail?: number }
+  | { type: "workspace.sandbox.status"; workspaceId: string }
+  | { type: "runtime.list" }
+  | { type: "runtime.detect"; provider: "claude" | "codex" }
+  | { type: "runtime.install"; provider: "claude" | "codex"; version: string }
+  | { type: "runtime.remove"; provider: "claude" | "codex"; version: string }
+  | { type: "runtime.health"; provider: "claude" | "codex"; version?: string }
+  | { type: "profile.list" }
+  | { type: "profile.save"; profile: import("./profile-types").ProviderProfile }
+  | { type: "profile.remove"; profileId: string }
+  | { type: "profile.resolve"; workspaceId: string; profileId: string }
+  | { type: "workspace.profile.override.set"; workspaceId: string; profileId: string; overrides: Partial<Omit<import("./profile-types").ProviderProfile, "id" | "provider">> }
+  | { type: "workspace.profile.override.remove"; workspaceId: string; profileId: string }
+  | { type: "extension.preference.set"; extensionId: string; enabled: boolean }
+  | { type: "extension.preference.list" }
+  | { type: "team.member.list" }
+  | { type: "team.member.save"; member: import("./runner-team-types").TeamMember }
+  | { type: "team.member.remove"; memberId: string }
+  | { type: "runner.label.set"; runnerId: string; name: string | null; memberId: string | null }
+  | { type: "runner.label.remove"; runnerId: string }
+  | { type: "chat.selectRunner"; chatId: string; runnerId: string }

package/src/shared/pty-instance.ts

@@ -0,0 +1,43 @@
+export type PtyInstancePhase =
+  | "spawning"
+  | "trust-dialog"
+  | "ready"
+  | "streaming"
+  | "cancelling"
+  | "exited"
+
+export type PtyInstanceSmokeTest = "pending" | "pass" | "fail"
+
+export interface PtyInstanceState {
+  chatId: string
+  sessionId: string | null
+  pid: number | null
+  cwd: string
+  model: string
+  accountLabel: string | null
+  oauthMasked: string | null
+  phase: PtyInstancePhase
+  startedAt: number
+  lastEventAt: number
+  turnCount: number
+  tokensIn: number
+  tokensOut: number
+  planMode: boolean | null
+  smokeTest: PtyInstanceSmokeTest | null
+  outputRingTail: string | null
+  exitedAt: number | null
+  exitCode: number | null
+  rssBytes: number | null
+  rssPeakBytes: number | null
+  cpuPercent: number | null
+  cpuPeakPercent: number | null
+}
+
+export type PtyInstanceDelta =
+  | { type: "added"; instance: PtyInstanceState }
+  | { type: "updated"; instance: PtyInstanceState }
+  | { type: "removed"; chatId: string }
+
+export interface PtyInstancesSnapshot {
+  instances: PtyInstanceState[]
+}

package/src/shared/puggy/diagnostics/result.ts

@@ -0,0 +1,18 @@
+import type { PuggyDiagnostic, PuggyRenderFailure } from "../index";
+
+export function diagnostic(
+  code: string,
+  message: string,
+  line: number,
+  column: number
+): PuggyDiagnostic {
+  return { code, message, line, column };
+}
+
+export function failure(diagnostics: readonly PuggyDiagnostic[]): PuggyRenderFailure {
+  return {
+    ok: false,
+    html: "",
+    diagnostics
+  };
+}

package/src/shared/puggy/expressions/evaluate.ts

@@ -0,0 +1,292 @@
+import { diagnostic } from "../diagnostics/result";
+import type {
+  PuggyDiagnostic,
+  PuggyExpressionCapability,
+  PuggyExpressionOptions,
+  PuggyExpressionProfile
+} from "../index";
+
+export interface EvalSuccess {
+  readonly ok: true;
+  readonly value: unknown;
+}
+
+export interface EvalFailure {
+  readonly ok: false;
+  readonly diagnostic: PuggyDiagnostic;
+}
+
+export type EvalResult = EvalSuccess | EvalFailure;
+
+const DENIED_ROOTS = new Set([
+  "process",
+  "globalThis",
+  "window",
+  "document",
+  "Math",
+  "Date",
+  "Intl",
+  "JSON",
+  "Object",
+  "Array",
+  "String",
+  "Number",
+  "Boolean",
+  "RegExp",
+  "Promise",
+  "Reflect",
+  "Proxy",
+  "Symbol",
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "Function",
+  "eval",
+  "constructor",
+  "__proto__",
+  "prototype",
+  "import",
+  "require",
+  "fetch",
+  "XMLHttpRequest",
+  "WebSocket",
+  "localStorage",
+  "sessionStorage"
+]);
+
+export function evaluateExpression(
+  expression: string,
+  data: Record<string, unknown>,
+  line: number,
+  column: number,
+  expressionOptions: PuggyExpressionProfile | PuggyExpressionOptions | undefined = undefined
+): EvalResult {
+  const trimmed = expression.trim();
+  const stringLiteral = /^"([\s\S]*)"$/.exec(trimmed) ?? /^'([\s\S]*)'$/.exec(trimmed);
+  if (stringLiteral) {
+    return { ok: true, value: stringLiteral[1]!.replace(/\\"/g, "\"").replace(/\\'/g, "'") };
+  }
+
+  const denied = findDeniedRoot(trimmed);
+  if (denied) {
+    return {
+      ok: false,
+      diagnostic: diagnostic(
+        "PUGGY_HOST_ACCESS_DENIED",
+        "Host and global access are not allowed in expressions.",
+        line,
+        column + denied.index
+      )
+    };
+  }
+
+  const call = parseCall(trimmed);
+  if (call) {
+    const options = resolveExpressionOptions(expressionOptions);
+    if (!options.allowCalls) {
+      return {
+        ok: false,
+        diagnostic: diagnostic("PUGGY_UNSUPPORTED_EXPRESSION", "Unsupported expression.", line, column)
+      };
+    }
+
+    const callee = readCapability(options.capabilities, call.callee);
+    if (typeof callee !== "function") {
+      return {
+        ok: false,
+        diagnostic: diagnostic(
+          "PUGGY_HOST_ACCESS_DENIED",
+          "Host and global access are not allowed in expressions.",
+          line,
+          column
+        )
+      };
+    }
+
+    const args: unknown[] = [];
+    for (const arg of splitCallArgs(call.args)) {
+      if (arg.trim() === "") {
+        continue;
+      }
+      const value = evaluateExpression(arg, data, line, column, expressionOptions);
+      if (!value.ok) {
+        return value;
+      }
+      args.push(value.value);
+    }
+
+    return { ok: true, value: callee(...args) };
+  }
+
+  if (trimmed === "true") {
+    return { ok: true, value: true };
+  }
+  if (trimmed === "false") {
+    return { ok: true, value: false };
+  }
+  if (/^-?\d+(?:\.\d+)?$/.test(trimmed)) {
+    return { ok: true, value: Number(trimmed) };
+  }
+
+  if (/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*$/.test(trimmed)) {
+    return { ok: true, value: readPath(data, trimmed) };
+  }
+
+  return {
+    ok: false,
+    diagnostic: diagnostic("PUGGY_UNSUPPORTED_EXPRESSION", "Unsupported expression.", line, column)
+  };
+}
+
+interface ResolvedExpressionOptions {
+  readonly allowCalls: boolean;
+  readonly capabilities: Record<string, PuggyExpressionCapability>;
+}
+
+function resolveExpressionOptions(
+  options: PuggyExpressionProfile | PuggyExpressionOptions | undefined
+): ResolvedExpressionOptions {
+  const normalized = typeof options === "string" ? { profile: options } : options ?? {};
+  const profile = normalized.profile ?? "data-only";
+  const capabilities = {
+    ...(profile === "ui-safe" ? uiSafeCapabilities() : {}),
+    ...(normalized.capabilities ?? {})
+  };
+
+  return {
+    allowCalls: normalized.allowCalls ?? (profile === "ui-safe" || normalized.capabilities !== undefined),
+    capabilities
+  };
+}
+
+function uiSafeCapabilities(): Record<string, PuggyExpressionCapability> {
+  return {
+    math: {
+      abs(value: unknown) {
+        return Math.abs(Number(value));
+      },
+      ceil(value: unknown) {
+        return Math.ceil(Number(value));
+      },
+      floor(value: unknown) {
+        return Math.floor(Number(value));
+      },
+      max(...values: unknown[]) {
+        return Math.max(...values.map(Number));
+      },
+      min(...values: unknown[]) {
+        return Math.min(...values.map(Number));
+      },
+      round(value: unknown) {
+        return Math.round(Number(value));
+      },
+      trunc(value: unknown) {
+        return Math.trunc(Number(value));
+      }
+    },
+    text: {
+      lower(value: unknown) {
+        return String(value).toLowerCase();
+      },
+      upper(value: unknown) {
+        return String(value).toUpperCase();
+      }
+    }
+  };
+}
+
+function parseCall(expression: string): { callee: string; args: string } | null {
+  const match = /^([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*)\(([\s\S]*)\)$/.exec(expression);
+  return match ? { callee: match[1]!, args: match[2]! } : null;
+}
+
+function findDeniedRoot(expression: string): { index: number } | null {
+  for (const match of expression.matchAll(/[A-Za-z_$][\w$]*/g)) {
+    const token = match[0];
+    if (DENIED_ROOTS.has(token)) {
+      return { index: match.index ?? 0 };
+    }
+  }
+  return null;
+}
+
+function readPath(data: Record<string, unknown>, path: string): unknown {
+  let current: unknown = data;
+  for (const part of path.split(".")) {
+    if (typeof current !== "object" || current === null) {
+      return undefined;
+    }
+    const descriptor = Object.getOwnPropertyDescriptor(current, part);
+    if (!descriptor || !("value" in descriptor)) {
+      return undefined;
+    }
+    current = descriptor.value;
+  }
+  return current;
+}
+
+function readCapability(root: Record<string, PuggyExpressionCapability>, path: string): unknown {
+  let current: unknown = root;
+  for (const part of path.split(".")) {
+    if (typeof current !== "object" || current === null) {
+      return undefined;
+    }
+    const descriptor = Object.getOwnPropertyDescriptor(current, part);
+    if (!descriptor || !("value" in descriptor)) {
+      return undefined;
+    }
+    current = descriptor.value;
+  }
+  return current;
+}
+
+function splitCallArgs(source: string): string[] {
+  const args: string[] = [];
+  let current = "";
+  let quote: string | null = null;
+  let depth = 0;
+
+  for (let index = 0; index < source.length; index += 1) {
+    const char = source[index]!;
+    if (quote) {
+      current += char;
+      if (char === quote && source[index - 1] !== "\\") {
+        quote = null;
+      }
+      continue;
+    }
+
+    if (char === "\"" || char === "'") {
+      quote = char;
+      current += char;
+      continue;
+    }
+
+    if (char === "(") {
+      depth += 1;
+      current += char;
+      continue;
+    }
+
+    if (char === ")") {
+      depth -= 1;
+      current += char;
+      continue;
+    }
+
+    if (char === "," && depth === 0) {
+      args.push(current.trim());
+      current = "";
+      continue;
+    }
+
+    current += char;
+  }
+
+  if (current.trim() !== "") {
+    args.push(current.trim());
+  }
+
+  return args;
+}

package/src/shared/puggy/index.test.ts

@@ -0,0 +1,101 @@
+import { describe, expect, test } from "bun:test"
+import { render } from "./index"
+
+describe("puggy render", () => {
+  test("renders nested Pug-style markup with escaped interpolation", () => {
+    const result = render(
+      [
+        "section.card",
+        "  h2 Hello #{name}",
+        "  ul",
+        "    each item in items",
+        "      li= item",
+      ].join("\n"),
+      {
+        name: "<Ada>",
+        items: ["one", "two"],
+      },
+    )
+
+    expect(result).toEqual({
+      ok: true,
+      html: '<section class="card"><h2>Hello &lt;Ada&gt;</h2><ul><li>one</li><li>two</li></ul></section>',
+      diagnostics: [],
+    })
+  })
+
+  test("rejects unsafe tags and attributes", () => {
+    const tagResult = render("script alert(1)")
+    const attrResult = render('button(onclick="alert(1)") Click')
+
+    expect(tagResult.ok).toBe(false)
+    expect(tagResult.diagnostics[0]?.code).toBe("PUGGY_UNSAFE_TAG")
+    expect(attrResult.ok).toBe(false)
+    expect(attrResult.diagnostics[0]?.code).toBe("PUGGY_UNSAFE_ATTR")
+  })
+
+  test("omits full-pug document noise while preserving css", () => {
+    const result = render(
+      [
+        "doctype html",
+        "html(lang=\"en\")",
+        "  head",
+        "    //- skipped comment",
+        "    meta(charset=\"UTF-8\")",
+        "    style.",
+        "      :root {",
+        "        --t1: #6366f1;",
+        "      }",
+        "  body",
+        "    summary.tier-header(style=\"background: var(--t1)\")",
+        "      h2 Tier 1",
+        "    p: strong Insight: board can be trusted",
+        "    .want #[strong see all work]",
+      ].join("\n"),
+    )
+
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    expect(result.html).toContain("<style>:root {\n  --t1: #6366f1;\n}</style>")
+    expect(result.html).toContain('<summary class="tier-header" style="background: var(--t1)">')
+    expect(result.html).toContain("<p>Insight: board can be trusted</p>")
+    expect(result.html).toContain('<div class="want">see all work</div>')
+    expect(result.html).not.toContain("<meta")
+    expect(result.html).not.toContain("skipped comment")
+    expect(result.html).not.toContain("doctype")
+  })
+
+  test("preserves newlines in raw text blocks", () => {
+    const result = render(["p.", "  first line", "  second line"].join("\n"))
+
+    expect(result).toEqual({
+      ok: true,
+      html: "<p>first line\nsecond line</p>",
+      diagnostics: [],
+    })
+  })
+
+  test("supports Tailwind utility classes in selector shorthand", () => {
+    const result = render(
+      [
+        ".grid.md:grid-cols-3.gap-4",
+        "  .w-[320px].bg-[#0f172a].text-white/90.hover:bg-slate-100",
+        "    .data-[state=open]:opacity-100.[&>svg]:size-4.!mt-0",
+        "      .sm:max-w-[min(100%,42rem)].before:content-['ok'].[@media(min-width:900px)]:grid",
+      ].join("\n"),
+    )
+
+    expect(result).toEqual({
+      ok: true,
+      html: '<div class="grid md:grid-cols-3 gap-4"><div class="w-[320px] bg-[#0f172a] text-white/90 hover:bg-slate-100"><div class="data-[state=open]:opacity-100 [&amp;&gt;svg]:size-4 !mt-0"><div class="sm:max-w-[min(100%,42rem)] before:content-[\'ok\'] [@media(min-width:900px)]:grid"></div></div></div></div>',
+      diagnostics: [],
+    })
+  })
+
+  test("rejects malformed Tailwind selector shorthand", () => {
+    const result = render(".w-[320px")
+
+    expect(result.ok).toBe(false)
+    expect(result.diagnostics[0]?.code).toBe("PUGGY_UNSUPPORTED_SELECTOR")
+  })
+})