arc-lang 0.6.8 → 0.6.10

package/dist/formatter.js

@@ -108,7 +108,10 @@ export function format(source, options) {
     function formatExpr(expr, depth) {
         switch (expr.kind) {
             case "IntLiteral": return String(expr.value);
-            case "FloatLiteral": return String(expr.value);
+            case "FloatLiteral": {
+                const s = String(expr.value);
+                return s.includes('.') ? s : s + '.0';
+            }
             case "BoolLiteral": return expr.value ? "true" : "false";
             case "NilLiteral": return "nil";
             case "StringLiteral": {

package/dist/linter.js

@@ -222,6 +222,9 @@ export function lint(source, options) {
                 for (const t of expr.targets)
                     analyzeExpr(t, scope);
                 break;
+            case "GroupExpr":
+                analyzeExpr(expr.expr, scope);
+                break;
         }
     }
     function analyzePattern(pat, scope) {

package/dist/version.d.ts

@@ -1,4 +1,4 @@
-export declare const ARC_VERSION = "0.6.8";
+export declare const ARC_VERSION = "0.6.9";
 export declare const ARC_BUILD_DATE: string;
 export declare const ARC_PLATFORM: string;
 /** Print version info */

package/dist/version.js

@@ -1,5 +1,5 @@
 // Arc Version System
-export const ARC_VERSION = "0.6.8";
+export const ARC_VERSION = "0.6.9";
 export const ARC_BUILD_DATE = new Date().toISOString().split("T")[0];
 export const ARC_PLATFORM = `${process.platform}-${process.arch}`;
 /** Print version info */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arc-lang",
-  "version": "0.6.8",
+  "version": "0.6.10",
   "description": "Arc ⚡ — A programming language designed by AI agents, for AI agents. 27-63% fewer tokens than JavaScript.",
   "type": "module",
   "bin": {

package/stdlib/crypto.arc

@@ -1,62 +1,62 @@
-# Arc Standard Library: crypto module
-# Hashing, encryption, and cryptographic utilities
-
-# --- Hashing ---
-
-pub fn md5(text) => crypto_hash("md5", text)
-pub fn sha1(text) => crypto_hash("sha1", text)
-pub fn sha256(text) => crypto_hash("sha256", text)
-pub fn sha512(text) => crypto_hash("sha512", text)
-
-# --- HMAC ---
-
-pub fn hmac_sha256(key, message) => crypto_hmac("sha256", key, message)
-pub fn hmac_sha512(key, message) => crypto_hmac("sha512", key, message)
-
-# --- Random ---
-
-pub fn random_bytes(n) {
-  if n < 0 { panic("random_bytes: n must be non-negative") }
-  el { crypto_random_bytes(n) }
-}
-
-pub fn random_int(min, max) {
-  if min > max { panic("random_int: min must be <= max") }
-  el { crypto_random_int(min, max) }
-}
-
-pub fn uuid() => crypto_uuid()
-
-# --- Base64 ---
-
-pub fn base64_encode(text) => crypto_encode_base64(text)
-pub fn base64_decode(text) => crypto_decode_base64(text)
-
-# --- Password Hashing ---
-
-pub fn hash_password(password, salt) {
-  let input = salt ++ ":" ++ password
-  let mut hash = sha256(input)
-  for i in 0..100 {
-    hash = sha256(hash ++ salt)
-  }
-  hash
-}
-
-pub fn verify_password(password, salt, hash) {
-  let computed = hash_password(password, salt)
-  computed == hash
-}
-
-# --- Utility ---
-
-pub fn constant_time_eq(a, b) {
-  if len(a) != len(b) { false }
-  el {
-    let mut result = true
-    for i in 0..len(a) {
-      if char_at(a, i) != char_at(b, i) { result = false }
-    }
-    result
-  }
-}
+# Arc Standard Library: crypto module
+# Hashing, encryption, and cryptographic utilities
+
+# --- Hashing ---
+
+pub fn md5(text) => crypto_hash("md5", text)
+pub fn sha1(text) => crypto_hash("sha1", text)
+pub fn sha256(text) => crypto_hash("sha256", text)
+pub fn sha512(text) => crypto_hash("sha512", text)
+
+# --- HMAC ---
+
+pub fn hmac_sha256(key, message) => crypto_hmac("sha256", key, message)
+pub fn hmac_sha512(key, message) => crypto_hmac("sha512", key, message)
+
+# --- Random ---
+
+pub fn random_bytes(n) {
+  if n < 0 { panic("random_bytes: n must be non-negative") }
+  el { crypto_random_bytes(n) }
+}
+
+pub fn random_int(min, max) {
+  if min > max { panic("random_int: min must be <= max") }
+  el { crypto_random_int(min, max) }
+}
+
+pub fn uuid() => crypto_uuid()
+
+# --- Base64 ---
+
+pub fn base64_encode(text) => crypto_encode_base64(text)
+pub fn base64_decode(text) => crypto_decode_base64(text)
+
+# --- Password Hashing ---
+
+pub fn hash_password(password, salt) {
+  let input = salt ++ ":" ++ password
+  let mut hash = sha256(input)
+  for i in 0..100 {
+    hash = sha256(hash ++ salt)
+  }
+  hash
+}
+
+pub fn verify_password(password, salt, hash) {
+  let computed = hash_password(password, salt)
+  computed == hash
+}
+
+# --- Utility ---
+
+pub fn constant_time_eq(a, b) {
+  if len(a) != len(b) { false }
+  el {
+    let mut result = true
+    for i in 0..len(a) {
+      if char_at(a, i) != char_at(b, i) { result = false }
+    }
+    result
+  }
+}

package/stdlib/datetime.arc

@@ -1,75 +1,75 @@
-# Arc Standard Library: datetime module
-# Comprehensive date and time utilities
-
-# Constants
-let MS_PER_MINUTE = 60000
-let MS_PER_HOUR = 3600000
-let MS_PER_DAY = 86400000
-
-# Returns the current timestamp in milliseconds since Unix epoch
-pub fn now() => __builtin_now()
-
-# Returns today's date as a map {year, month, day}
-pub fn today() {
-  let ts = now()
-  let days = int(ts / MS_PER_DAY)
-  __builtin_date_from_ts(ts)
-}
-
-# Parse a date string with the given format to a timestamp
-# Format tokens: YYYY, MM, DD, hh, mm, ss
-pub fn parse(date_string, format) => __builtin_date_parse(date_string, format)
-
-# Format a timestamp to a string using the given format
-# Format tokens: YYYY, MM, DD, hh, mm, ss
-pub fn format(timestamp, format_string) => __builtin_date_format(timestamp, format_string)
-
-# Add days to a timestamp, returns new timestamp
-pub fn add_days(timestamp, days) => timestamp + days * MS_PER_DAY
-
-# Add hours to a timestamp, returns new timestamp
-pub fn add_hours(timestamp, hours) => timestamp + hours * MS_PER_HOUR
-
-# Add minutes to a timestamp, returns new timestamp
-pub fn add_minutes(timestamp, minutes) => timestamp + minutes * MS_PER_MINUTE
-
-# Difference in days between two timestamps (absolute value)
-pub fn diff_days(ts1, ts2) {
-  let diff = ts1 - ts2
-  let abs_diff = if diff < 0 { 0 - diff } el { diff }
-  int(abs_diff / MS_PER_DAY)
-}
-
-# Difference in hours between two timestamps (absolute value)
-pub fn diff_hours(ts1, ts2) {
-  let diff = ts1 - ts2
-  let abs_diff = if diff < 0 { 0 - diff } el { diff }
-  int(abs_diff / MS_PER_HOUR)
-}
-
-# Difference in minutes between two timestamps (absolute value)
-pub fn diff_minutes(ts1, ts2) {
-  let diff = ts1 - ts2
-  let abs_diff = if diff < 0 { 0 - diff } el { diff }
-  int(abs_diff / MS_PER_MINUTE)
-}
-
-# Returns the day of the week (0 = Sunday, 6 = Saturday)
-pub fn day_of_week(timestamp) {
-  # Jan 1 1970 was a Thursday (4)
-  let days = int(timestamp / MS_PER_DAY)
-  let result = ((days + 4) % 7 + 7) % 7
-  result
-}
-
-# Returns true if ts1 is before ts2
-pub fn is_before(ts1, ts2) => ts1 < ts2
-
-# Returns true if ts1 is after ts2
-pub fn is_after(ts1, ts2) => ts1 > ts2
-
-# Convert a timestamp to an ISO 8601 string
-pub fn to_iso(timestamp) => __builtin_date_to_iso(timestamp)
-
-# Parse an ISO 8601 string to a timestamp
-pub fn from_iso(iso_string) => __builtin_date_from_iso(iso_string)
+# Arc Standard Library: datetime module
+# Comprehensive date and time utilities
+
+# Constants
+let MS_PER_MINUTE = 60000
+let MS_PER_HOUR = 3600000
+let MS_PER_DAY = 86400000
+
+# Returns the current timestamp in milliseconds since Unix epoch
+pub fn now() => __builtin_now()
+
+# Returns today's date as a map {year, month, day}
+pub fn today() {
+  let ts = now()
+  let days = int(ts / MS_PER_DAY)
+  __builtin_date_from_ts(ts)
+}
+
+# Parse a date string with the given format to a timestamp
+# Format tokens: YYYY, MM, DD, hh, mm, ss
+pub fn parse(date_string, format) => __builtin_date_parse(date_string, format)
+
+# Format a timestamp to a string using the given format
+# Format tokens: YYYY, MM, DD, hh, mm, ss
+pub fn format(timestamp, format_string) => __builtin_date_format(timestamp, format_string)
+
+# Add days to a timestamp, returns new timestamp
+pub fn add_days(timestamp, days) => timestamp + days * MS_PER_DAY
+
+# Add hours to a timestamp, returns new timestamp
+pub fn add_hours(timestamp, hours) => timestamp + hours * MS_PER_HOUR
+
+# Add minutes to a timestamp, returns new timestamp
+pub fn add_minutes(timestamp, minutes) => timestamp + minutes * MS_PER_MINUTE
+
+# Difference in days between two timestamps (absolute value)
+pub fn diff_days(ts1, ts2) {
+  let diff = ts1 - ts2
+  let abs_diff = if diff < 0 { 0 - diff } el { diff }
+  int(abs_diff / MS_PER_DAY)
+}
+
+# Difference in hours between two timestamps (absolute value)
+pub fn diff_hours(ts1, ts2) {
+  let diff = ts1 - ts2
+  let abs_diff = if diff < 0 { 0 - diff } el { diff }
+  int(abs_diff / MS_PER_HOUR)
+}
+
+# Difference in minutes between two timestamps (absolute value)
+pub fn diff_minutes(ts1, ts2) {
+  let diff = ts1 - ts2
+  let abs_diff = if diff < 0 { 0 - diff } el { diff }
+  int(abs_diff / MS_PER_MINUTE)
+}
+
+# Returns the day of the week (0 = Sunday, 6 = Saturday)
+pub fn day_of_week(timestamp) {
+  # Jan 1 1970 was a Thursday (4)
+  let days = int(timestamp / MS_PER_DAY)
+  let result = ((days + 4) % 7 + 7) % 7
+  result
+}
+
+# Returns true if ts1 is before ts2
+pub fn is_before(ts1, ts2) => ts1 < ts2
+
+# Returns true if ts1 is after ts2
+pub fn is_after(ts1, ts2) => ts1 > ts2
+
+# Convert a timestamp to an ISO 8601 string
+pub fn to_iso(timestamp) => __builtin_date_to_iso(timestamp)
+
+# Parse an ISO 8601 string to a timestamp
+pub fn from_iso(iso_string) => __builtin_date_from_iso(iso_string)

package/stdlib/error.arc

@@ -1,42 +1,42 @@
-# Arc Standard Library: error module
-# Structured error handling
-
-# Create a structured error
-pub fn error(code, message) => error_new(code, message)
-
-# Check if a value is an error
-pub fn is_error(value) => error_is_error(value)
-
-# Wrap an error with additional context
-pub fn wrap_error(err, context) => error_wrap(err, context)
-
-# Try executing a function, return Ok/Err result
-pub fn try_fn(f) => error_try(f)
-
-# Execute fn, call handler if result is an error
-pub fn try_catch(f, handler) {
-  let result = f()
-  if is_error(result) { handler(result) }
-  el { result }
-}
-
-# Execute fn, always run cleanup
-pub fn try_finally(f, cleanup) {
-  let result = f()
-  cleanup()
-  result
-}
-
-# Full try/catch/finally
-pub fn try_catch_finally(f, handler, cleanup) {
-  let result = f()
-  let handled = if is_error(result) { handler(result) } el { result }
-  cleanup()
-  handled
-}
-
-# Throw an error (raises a runtime exception)
-pub fn throw(code, message) => error_throw(code, message)
-
-# Retry a function up to n times, returning the first success or last error
-pub fn retry(f, times) => error_retry(f, times)
+# Arc Standard Library: error module
+# Structured error handling
+
+# Create a structured error
+pub fn error(code, message) => error_new(code, message)
+
+# Check if a value is an error
+pub fn is_error(value) => error_is_error(value)
+
+# Wrap an error with additional context
+pub fn wrap_error(err, context) => error_wrap(err, context)
+
+# Try executing a function, return Ok/Err result
+pub fn try_fn(f) => error_try(f)
+
+# Execute fn, call handler if result is an error
+pub fn try_catch(f, handler) {
+  let result = f()
+  if is_error(result) { handler(result) }
+  el { result }
+}
+
+# Execute fn, always run cleanup
+pub fn try_finally(f, cleanup) {
+  let result = f()
+  cleanup()
+  result
+}
+
+# Full try/catch/finally
+pub fn try_catch_finally(f, handler, cleanup) {
+  let result = f()
+  let handled = if is_error(result) { handler(result) } el { result }
+  cleanup()
+  handled
+}
+
+# Throw an error (raises a runtime exception)
+pub fn throw(code, message) => error_throw(code, message)
+
+# Retry a function up to n times, returning the first success or last error
+pub fn retry(f, times) => error_retry(f, times)

package/stdlib/llm.arc

@@ -1,193 +1,193 @@
-# Arc Standard Library: llm module
-# Multi-provider LLM API integration
-# Makes it natural for AI agents to call other AI agents.
-
-use json
-use os
-
-# --- Provider registry ---
-
-pub fn providers() {
-  [
-    {name: "openai", base_url: "https://api.openai.com/v1", env_key: "OPENAI_API_KEY"},
-    {name: "anthropic", base_url: "https://api.anthropic.com/v1", env_key: "ANTHROPIC_API_KEY"}
-  ]
-}
-
-fn _provider_config(provider) {
-  let all = providers()
-  let mut found = nil
-  for p in all {
-    if p.name == provider { found = p }
-  }
-  if found == nil { error_new("llm", "Unknown LLM provider: " ++ provider) }
-  found
-}
-
-fn _api_key(provider) {
-  let config = _provider_config(provider)
-  let key = os.get_env(config.env_key)
-  if key == nil { error_new("llm", "Missing API key: set " ++ config.env_key ++ " environment variable") }
-  key
-}
-
-# --- OpenAI payload construction ---
-
-fn _openai_chat_payload(model, messages, options) {
-  let mut payload = {}
-  payload["model"] = model
-  payload["messages"] = messages
-  if options != nil {
-    let ks = keys(options)
-    for k in ks {
-      payload[k] = options[k]
-    }
-  }
-  payload
-}
-
-fn _openai_headers(api_key) {
-  let mut h = {}
-  h["Authorization"] = "Bearer " ++ api_key
-  h["Content-Type"] = "application/json"
-  h
-}
-
-# --- Anthropic payload construction ---
-
-fn _anthropic_chat_payload(model, messages, options) {
-  # Anthropic expects system message separate from messages
-  let mut system_msg = nil
-  let mut user_msgs = []
-  for m in messages {
-    if m.role == "system" {
-      system_msg = m.content
-    } el {
-      user_msgs = push(user_msgs, m)
-    }
-  }
-  let mut payload = {}
-  payload["model"] = model
-  payload["messages"] = user_msgs
-  if system_msg != nil { payload["system"] = system_msg }
-  payload["max_tokens"] = if options != nil and options["max_tokens"] != nil { options["max_tokens"] } el { 1024 }
-  if options != nil {
-    let ks = keys(options)
-    for k in ks {
-      if k != "max_tokens" { payload[k] = options[k] }
-    }
-  }
-  payload
-}
-
-fn _anthropic_headers(api_key) {
-  let mut h = {}
-  h["x-api-key"] = api_key
-  h["anthropic-version"] = "2023-06-01"
-  h["Content-Type"] = "application/json"
-  h
-}
-
-# --- Core API ---
-
-# Send a chat completion request
-# provider: "openai" | "anthropic"
-# model: e.g. "gpt-4o", "claude-sonnet-4-20250514"
-# messages: [{role: "user", content: "Hello"}]
-# options: {temperature: 0.7, max_tokens: 1024} (optional)
-pub fn chat(provider, model, messages, options) {
-  let key = _api_key(provider)
-
-  if provider == "openai" {
-    let payload = _openai_chat_payload(model, messages, options)
-    let body = json.to_json(payload)
-    let headers = _openai_headers(key)
-    let resp = @POST "https://api.openai.com/v1/chat/completions" {data: body, headers: headers}
-    if resp.ok and resp.status == 200 {
-      let data = resp.data
-      {ok: true, content: data.choices[0].message.content, usage: data.usage, raw: data}
-    } el {
-      {ok: false, error: resp.data, status: resp.status}
-    }
-  } el if provider == "anthropic" {
-    let payload = _anthropic_chat_payload(model, messages, options)
-    let body = json.to_json(payload)
-    let headers = _anthropic_headers(key)
-    let resp = @POST "https://api.anthropic.com/v1/messages" {data: body, headers: headers}
-    if resp.ok and resp.status == 200 {
-      let data = resp.data
-      let content = if type_of(data.content) == "list" and len(data.content) > 0 {
-        data.content[0].text
-      } el { nil }
-      {ok: true, content: content, usage: data.usage, raw: data}
-    } el {
-      {ok: false, error: resp.data, status: resp.status}
-    }
-  } el {
-    error_new("llm", "Unsupported provider: " ++ provider)
-  }
-}
-
-# Simple text completion (wraps chat with a single user message)
-pub fn complete(provider, model, prompt, options) {
-  let messages = [{role: "user", content: prompt}]
-  chat(provider, model, messages, options)
-}
-
-# Streaming chat — calls callback with each chunk
-# Note: true streaming requires SSE parsing; this simulates via full response
-pub fn stream(provider, model, messages, callback) {
-  # For now, do a regular call and invoke callback with the full response
-  # True SSE streaming would require async I/O support in the runtime
-  let result = chat(provider, model, messages, nil)
-  if result.ok {
-    callback(result.content)
-  }
-  result
-}
-
-# List available models for a provider
-pub fn models(provider) {
-  let key = _api_key(provider)
-
-  if provider == "openai" {
-    let headers = _openai_headers(key)
-    let resp = @GET "https://api.openai.com/v1/models" {headers: headers}
-    if resp.ok and resp.status == 200 {
-      map(resp.data.data, m => m.id)
-    } el {
-      []
-    }
-  } el if provider == "anthropic" {
-    # Anthropic doesn't have a public models endpoint; return known models
-    [
-      "claude-sonnet-4-20250514",
-      "claude-opus-4-20250514",
-      "claude-haiku-35-20241022",
-      "claude-sonnet-3-5-20241022"
-    ]
-  } el {
-    []
-  }
-}
-
-# Estimate API cost in USD
-# Pricing approximate as of 2025
-pub fn estimate_cost(model, input_tokens, output_tokens) {
-  let pricing = _model_pricing(model)
-  let input_cost = (input_tokens / 1000000.0) * pricing.input
-  let output_cost = (output_tokens / 1000000.0) * pricing.output
-  {input_cost: input_cost, output_cost: output_cost, total: input_cost + output_cost, currency: "USD"}
-}
-
-fn _model_pricing(model) {
-  # Prices per million tokens (input, output)
-  if starts(model, "gpt-4o-mini") { {input: 0.15, output: 0.60} }
-  el if starts(model, "gpt-4o") { {input: 2.50, output: 10.00} }
-  el if starts(model, "gpt-4-turbo") { {input: 10.00, output: 30.00} }
-  el if starts(model, "gpt-3.5") { {input: 0.50, output: 1.50} }
-  el if contains(model, "opus") { {input: 15.00, output: 75.00} }
-  el if contains(model, "sonnet") { {input: 3.00, output: 15.00} }
-  el if contains(model, "haiku") { {input: 0.80, output: 4.00} }
-  el { {input: 1.00, output: 3.00} }  # fallback estimate
-}
+# Arc Standard Library: llm module
+# Multi-provider LLM API integration
+# Makes it natural for AI agents to call other AI agents.
+
+use json
+use os
+
+# --- Provider registry ---
+
+pub fn providers() {
+  [
+    {name: "openai", base_url: "https://api.openai.com/v1", env_key: "OPENAI_API_KEY"},
+    {name: "anthropic", base_url: "https://api.anthropic.com/v1", env_key: "ANTHROPIC_API_KEY"}
+  ]
+}
+
+fn _provider_config(provider) {
+  let all = providers()
+  let mut found = nil
+  for p in all {
+    if p.name == provider { found = p }
+  }
+  if found == nil { error_new("llm", "Unknown LLM provider: " ++ provider) }
+  found
+}
+
+fn _api_key(provider) {
+  let config = _provider_config(provider)
+  let key = os.get_env(config.env_key)
+  if key == nil { error_new("llm", "Missing API key: set " ++ config.env_key ++ " environment variable") }
+  key
+}
+
+# --- OpenAI payload construction ---
+
+fn _openai_chat_payload(model, messages, options) {
+  let mut payload = {}
+  payload["model"] = model
+  payload["messages"] = messages
+  if options != nil {
+    let ks = keys(options)
+    for k in ks {
+      payload[k] = options[k]
+    }
+  }
+  payload
+}
+
+fn _openai_headers(api_key) {
+  let mut h = {}
+  h["Authorization"] = "Bearer " ++ api_key
+  h["Content-Type"] = "application/json"
+  h
+}
+
+# --- Anthropic payload construction ---
+
+fn _anthropic_chat_payload(model, messages, options) {
+  # Anthropic expects system message separate from messages
+  let mut system_msg = nil
+  let mut user_msgs = []
+  for m in messages {
+    if m.role == "system" {
+      system_msg = m.content
+    } el {
+      user_msgs = push(user_msgs, m)
+    }
+  }
+  let mut payload = {}
+  payload["model"] = model
+  payload["messages"] = user_msgs
+  if system_msg != nil { payload["system"] = system_msg }
+  payload["max_tokens"] = if options != nil and options["max_tokens"] != nil { options["max_tokens"] } el { 1024 }
+  if options != nil {
+    let ks = keys(options)
+    for k in ks {
+      if k != "max_tokens" { payload[k] = options[k] }
+    }
+  }
+  payload
+}
+
+fn _anthropic_headers(api_key) {
+  let mut h = {}
+  h["x-api-key"] = api_key
+  h["anthropic-version"] = "2023-06-01"
+  h["Content-Type"] = "application/json"
+  h
+}
+
+# --- Core API ---
+
+# Send a chat completion request
+# provider: "openai" | "anthropic"
+# model: e.g. "gpt-4o", "claude-sonnet-4-20250514"
+# messages: [{role: "user", content: "Hello"}]
+# options: {temperature: 0.7, max_tokens: 1024} (optional)
+pub fn chat(provider, model, messages, options) {
+  let key = _api_key(provider)
+
+  if provider == "openai" {
+    let payload = _openai_chat_payload(model, messages, options)
+    let body = json.to_json(payload)
+    let headers = _openai_headers(key)
+    let resp = @POST "https://api.openai.com/v1/chat/completions" {data: body, headers: headers}
+    if resp.ok and resp.status == 200 {
+      let data = resp.data
+      {ok: true, content: data.choices[0].message.content, usage: data.usage, raw: data}
+    } el {
+      {ok: false, error: resp.data, status: resp.status}
+    }
+  } el if provider == "anthropic" {
+    let payload = _anthropic_chat_payload(model, messages, options)
+    let body = json.to_json(payload)
+    let headers = _anthropic_headers(key)
+    let resp = @POST "https://api.anthropic.com/v1/messages" {data: body, headers: headers}
+    if resp.ok and resp.status == 200 {
+      let data = resp.data
+      let content = if type_of(data.content) == "list" and len(data.content) > 0 {
+        data.content[0].text
+      } el { nil }
+      {ok: true, content: content, usage: data.usage, raw: data}
+    } el {
+      {ok: false, error: resp.data, status: resp.status}
+    }
+  } el {
+    error_new("llm", "Unsupported provider: " ++ provider)
+  }
+}
+
+# Simple text completion (wraps chat with a single user message)
+pub fn complete(provider, model, prompt, options) {
+  let messages = [{role: "user", content: prompt}]
+  chat(provider, model, messages, options)
+}
+
+# Streaming chat — calls callback with each chunk
+# Note: true streaming requires SSE parsing; this simulates via full response
+pub fn stream(provider, model, messages, callback) {
+  # For now, do a regular call and invoke callback with the full response
+  # True SSE streaming would require async I/O support in the runtime
+  let result = chat(provider, model, messages, nil)
+  if result.ok {
+    callback(result.content)
+  }
+  result
+}
+
+# List available models for a provider
+pub fn models(provider) {
+  let key = _api_key(provider)
+
+  if provider == "openai" {
+    let headers = _openai_headers(key)
+    let resp = @GET "https://api.openai.com/v1/models" {headers: headers}
+    if resp.ok and resp.status == 200 {
+      map(resp.data.data, m => m.id)
+    } el {
+      []
+    }
+  } el if provider == "anthropic" {
+    # Anthropic doesn't have a public models endpoint; return known models
+    [
+      "claude-sonnet-4-20250514",
+      "claude-opus-4-20250514",
+      "claude-haiku-35-20241022",
+      "claude-sonnet-3-5-20241022"
+    ]
+  } el {
+    []
+  }
+}
+
+# Estimate API cost in USD
+# Pricing approximate as of 2025
+pub fn estimate_cost(model, input_tokens, output_tokens) {
+  let pricing = _model_pricing(model)
+  let input_cost = (input_tokens / 1000000.0) * pricing.input
+  let output_cost = (output_tokens / 1000000.0) * pricing.output
+  {input_cost: input_cost, output_cost: output_cost, total: input_cost + output_cost, currency: "USD"}
+}
+
+fn _model_pricing(model) {
+  # Prices per million tokens (input, output)
+  if starts(model, "gpt-4o-mini") { {input: 0.15, output: 0.60} }
+  el if starts(model, "gpt-4o") { {input: 2.50, output: 10.00} }
+  el if starts(model, "gpt-4-turbo") { {input: 10.00, output: 30.00} }
+  el if starts(model, "gpt-3.5") { {input: 0.50, output: 1.50} }
+  el if contains(model, "opus") { {input: 15.00, output: 75.00} }
+  el if contains(model, "sonnet") { {input: 3.00, output: 15.00} }
+  el if contains(model, "haiku") { {input: 0.80, output: 4.00} }
+  el { {input: 1.00, output: 3.00} }  # fallback estimate
+}

package/stdlib/math.arc

@@ -1,133 +1,133 @@
-# Arc Standard Library: math module
-
-# === Constants ===
-pub let PI = 3.141592653589793
-pub let E = 2.718281828459045
-pub let TAU = 6.283185307179586
-# INF and NAN available via native runtime
-
-# === Basic ===
-pub fn abs(x) => if x < 0 { 0 - x } el { x }
-
-pub fn sign(x) {
-  if x > 0 { 1 }
-  el if x < 0 { -1 }
-  el { 0 }
-}
-
-pub fn clamp(x, lo, hi) {
-  if x < lo { lo }
-  el if x > hi { hi }
-  el { x }
-}
-
-# === Rounding ===
-pub fn ceil(x) => __native("math.ceil", x)
-
-pub fn floor(x) => int(x)
-
-pub fn round(x) => int(x + 0.5)
-
-# === Powers & Roots ===
-pub fn pow(base, exp) {
-  if exp == 0 { 1 }
-  el if exp < 0 and base == 0 { nil }
-  el if type_of(exp) == "float" { __native("math.pow", base, exp) }
-  el if exp < 0 { 1.0 / pow(base, 0 - exp) }
-  el {
-    let mut result = 1
-    let mut b = base
-    let mut e = exp
-    do {
-      if e % 2 == 1 { result = result * b }
-      e = int(e / 2)
-      b = b * b
-    } until e == 0
-    result
-  }
-}
-
-pub fn sqrt(x) {
-  if x == 0 { 0.0 }
-  el if x < 0 { nil }
-  el {
-    let mut guess = x / 2.0
-    for i in 0..25 {
-      guess = (guess + x / guess) / 2.0
-    }
-    guess
-  }
-}
-
-pub fn cbrt(x) => __native("math.cbrt", x)
-
-pub fn hypot(x, y) => __native("math.hypot", x, y)
-
-# === Trigonometry ===
-pub fn sin(x) => __native("math.sin", x)
-pub fn cos(x) => __native("math.cos", x)
-pub fn tan(x) => __native("math.tan", x)
-pub fn asin(x) => __native("math.asin", x)
-pub fn acos(x) => __native("math.acos", x)
-pub fn atan(x) => __native("math.atan", x)
-pub fn atan2(y, x) => __native("math.atan2", y, x)
-
-pub fn degrees(rad) => rad * 180.0 / PI
-pub fn radians(deg) => deg * PI / 180.0
-
-# === Logarithmic & Exponential ===
-pub fn log(x) => __native("math.log", x)
-pub fn log2(x) => __native("math.log2", x)
-pub fn log10(x) => __native("math.log10", x)
-pub fn exp(x) => __native("math.exp", x)
-
-# === Combinatorics ===
-pub fn factorial(n) {
-  if n < 0 { nil }
-  el if n <= 1 { 1 }
-  el {
-    let mut result = 1
-    for i in 2..n + 1 {
-      result = result * i
-    }
-    if str(result) == "Infinity" { nil }
-    el { result }
-  }
-}
-
-pub fn gcd(a, b) {
-  let mut x = abs(a)
-  let mut y = abs(b)
-  if x == 0 and y == 0 { 0 }
-  el {
-    do {
-      let t = y
-      y = x % y
-      x = t
-    } until y == 0
-    x
-  }
-}
-
-pub fn lcm(a, b) {
-  let d = gcd(a, b)
-  if d == 0 { 0 }
-  el { abs(a / d) * b }
-}
-
-# === Aggregation ===
-pub fn sum(lst) {
-  let mut total = 0
-  for x in lst {
-    if type_of(x) == "int" or type_of(x) == "float" {
-      total = total + x
-    }
-  }
-  total
-}
-
-pub fn product(lst) {
-  let mut total = 1
-  for x in lst { total = total * x }
-  total
-}
+# Arc Standard Library: math module
+
+# === Constants ===
+pub let PI = 3.141592653589793
+pub let E = 2.718281828459045
+pub let TAU = 6.283185307179586
+# INF and NAN available via native runtime
+
+# === Basic ===
+pub fn abs(x) => if x < 0 { 0 - x } el { x }
+
+pub fn sign(x) {
+  if x > 0 { 1 }
+  el if x < 0 { -1 }
+  el { 0 }
+}
+
+pub fn clamp(x, lo, hi) {
+  if x < lo { lo }
+  el if x > hi { hi }
+  el { x }
+}
+
+# === Rounding ===
+pub fn ceil(x) => __native("math.ceil", x)
+
+pub fn floor(x) => int(x)
+
+pub fn round(x) => int(x + 0.5)
+
+# === Powers & Roots ===
+pub fn pow(base, exp) {
+  if exp == 0 { 1 }
+  el if exp < 0 and base == 0 { nil }
+  el if type_of(exp) == "float" { __native("math.pow", base, exp) }
+  el if exp < 0 { 1.0 / pow(base, 0 - exp) }
+  el {
+    let mut result = 1
+    let mut b = base
+    let mut e = exp
+    do {
+      if e % 2 == 1 { result = result * b }
+      e = int(e / 2)
+      b = b * b
+    } until e == 0
+    result
+  }
+}
+
+pub fn sqrt(x) {
+  if x == 0 { 0.0 }
+  el if x < 0 { nil }
+  el {
+    let mut guess = x / 2.0
+    for i in 0..25 {
+      guess = (guess + x / guess) / 2.0
+    }
+    guess
+  }
+}
+
+pub fn cbrt(x) => __native("math.cbrt", x)
+
+pub fn hypot(x, y) => __native("math.hypot", x, y)
+
+# === Trigonometry ===
+pub fn sin(x) => __native("math.sin", x)
+pub fn cos(x) => __native("math.cos", x)
+pub fn tan(x) => __native("math.tan", x)
+pub fn asin(x) => __native("math.asin", x)
+pub fn acos(x) => __native("math.acos", x)
+pub fn atan(x) => __native("math.atan", x)
+pub fn atan2(y, x) => __native("math.atan2", y, x)
+
+pub fn degrees(rad) => rad * 180.0 / PI
+pub fn radians(deg) => deg * PI / 180.0
+
+# === Logarithmic & Exponential ===
+pub fn log(x) => __native("math.log", x)
+pub fn log2(x) => __native("math.log2", x)
+pub fn log10(x) => __native("math.log10", x)
+pub fn exp(x) => __native("math.exp", x)
+
+# === Combinatorics ===
+pub fn factorial(n) {
+  if n < 0 { nil }
+  el if n <= 1 { 1 }
+  el {
+    let mut result = 1
+    for i in 2..n + 1 {
+      result = result * i
+    }
+    if str(result) == "Infinity" { nil }
+    el { result }
+  }
+}
+
+pub fn gcd(a, b) {
+  let mut x = abs(a)
+  let mut y = abs(b)
+  if x == 0 and y == 0 { 0 }
+  el {
+    do {
+      let t = y
+      y = x % y
+      x = t
+    } until y == 0
+    x
+  }
+}
+
+pub fn lcm(a, b) {
+  let d = gcd(a, b)
+  if d == 0 { 0 }
+  el { abs(a / d) * b }
+}
+
+# === Aggregation ===
+pub fn sum(lst) {
+  let mut total = 0
+  for x in lst {
+    if type_of(x) == "int" or type_of(x) == "float" {
+      total = total + x
+    }
+  }
+  total
+}
+
+pub fn product(lst) {
+  let mut total = 1
+  for x in lst { total = total * x }
+  total
+}

package/stdlib/net.arc

@@ -1,17 +1,17 @@
-# Arc Standard Library: net module
-# Networking utilities
-
-# --- URL ---
-
-pub fn url_parse(url) => net_url_parse(url)
-pub fn url_encode(text) => net_url_encode(text)
-pub fn url_decode(text) => net_url_decode(text)
-
-# --- Query String ---
-
-pub fn parse_query(query_string) => net_query_parse(query_string)
-pub fn build_query(params_map) => net_query_stringify(params_map)
-
-# --- IP ---
-
-pub fn ip_is_valid(addr) => net_ip_is_valid(addr)
+# Arc Standard Library: net module
+# Networking utilities
+
+# --- URL ---
+
+pub fn url_parse(url) => net_url_parse(url)
+pub fn url_encode(text) => net_url_encode(text)
+pub fn url_decode(text) => net_url_decode(text)
+
+# --- Query String ---
+
+pub fn parse_query(query_string) => net_query_parse(query_string)
+pub fn build_query(params_map) => net_query_stringify(params_map)
+
+# --- IP ---
+
+pub fn ip_is_valid(addr) => net_ip_is_valid(addr)

package/stdlib/regex.arc

@@ -21,19 +21,19 @@ pub fn test(pattern, text) {
 
 # Replaces the first occurrence of `pattern` with `replacement` in `text`
 # (For global replacement, use replace_all)
-pub fn replace(pattern, replacement, text) {
+pub fn replace(pattern, text, replacement) {
   let re = regex_new(pattern)
   regex_replace(re, replacement, text)
 }
 
 # Alias for replace — replaces only the first occurrence
-pub fn replace_first(pattern, replacement, text) {
+pub fn replace_first(pattern, text, replacement) {
   let re = regex_new(pattern)
   regex_replace(re, replacement, text)
 }
 
 # Replaces all occurrences of `pattern` with `replacement` in `text`
-pub fn replace_all(pattern, replacement, text) {
+pub fn replace_all(pattern, text, replacement) {
   let re = regex_new(pattern)
   regex_replace_all(re, replacement, text)
 }
@@ -56,6 +56,12 @@ pub fn capture_all(pattern, text) {
   regex_captures_all(re, text)
 }
 
+# Returns a list of all matches of `pattern` in `text` (alias for find_all)
+pub fn match_all(pattern, text) {
+  let re = regex_new(pattern)
+  regex_find_all(re, text)
+}
+
 # Escapes all regex special characters in `text`
 pub fn escape(text) => __native("regex.escape", text)