SHAPE Product
  id    : UUID    required auto
  name  : String  required
  price : Float   required min=0
  stock : Int     required default=0

FUNC buyProduct(productId, quantity, userId)
  --- Lets a user purchase a product. ---

  VALIDATE
    quantity > 0
    product exists with id = productId
    product.stock >= quantity
    user has valid payment method

  DO
    charge user for quantity * product.price
    reduce product.stock by quantity
    create an Order record
    EMIT OrderPlaced WITH order

  RETURN order
  ON FAIL THROW PurchaseError

FUNC submitExpenseReport(reportId, userId)
  --- Submits a draft expense report for approval. ---

  VALIDATE
    report exists with id = reportId
    report.status IS draft
    report.ownerId IS userId
    report.totalAmount > 0

  DO
    report.status = pending
    report.submittedAt = NOW
    EMIT ReportSubmitted WITH { reportId, userId }

  RETURN report
  ON FAIL LOG error, THROW SubmissionError

FLOW OnboardNewEmployee(employeeId)
  STEP createAccounts
    create email, Slack, and HR system accounts

  STEP scheduleOrientation
    find next available orientation session
    send calendar invite to employee and manager

  STEP notify
    EMIT EmployeeOnboarded WITH { employeeId }
    send welcome email to employee

VALIDATE
  email not empty
  email matches email pattern
  password length >= 8
  age between 18 and 120
  productId exists in Product
  email not exists in User
  startDate is before endDate
  cart.items not empty  MESSAGE "Cart cannot be empty"

GUARD AdminOnly
  REQUIRE user.role IS admin
  ON FAIL THROW ForbiddenError

FUNC deleteRecord(recordId)
  GUARD AdminOnly
  DO
    Record.delete(recordId)

ALLOW publish WHEN user.role IS admin OR user.role IS editor
DENY  delete  WHEN document.locked IS true

POLICY RateLimit
  APPLIES TO all API endpoints
  ALLOW 100 requests PER user PER minute
  ON EXCEED return error "Too many requests"

POLICY DataRetention
  APPLIES TO CustomerActivityLog
  KEEP 2 years
  THEN archive to cold storage
  DELETE after 7 years

QUERY overdueInvoices
  FROM Invoice
  WHERE status IS sent
  AND   dueDate < TODAY
  ORDER BY dueDate ASC

QUERY recentOrdersForUser(userId)
  FROM Order
  WHERE userId IS userId
  AND   createdAt WITHIN 90 days
  INCLUDE items, shippingAddress
  ORDER BY createdAt DESC

EMIT OrderPlaced WITH { orderId, userId, total }

ON OrderPlaced
  send order confirmation to user.email
  notify fulfillment team
  LOG "Order {orderId} placed"

ON PaymentFailed 3 times
  suspend user account
  ALERT billing-team

STATE Invoice
  STATES  draft, sent, paid, overdue, cancelled

  TRANSITION draft   -> sent    ON sendInvoice
  TRANSITION sent    -> paid    ON paymentReceived
  TRANSITION sent    -> overdue ON dueDatePassed
  TRANSITION ANY     -> cancelled ON cancelInvoice
    WHEN status NOT IN [paid]

  ON ENTER overdue
    send reminder to invoice.customerEmail
    ALERT accounts-receivable-team

SCHEDULE cleanExpiredSessions
  EVERY 1 hour
  DO
    deleted = Session.deleteExpired()
    LOG "Purged {deleted} sessions"

SCHEDULE monthlyBilling
  AT "first day of month 00:01 UTC"
  DO
    FOR EACH active subscription
      charge subscriber for their plan

SHAPE   Name          — define a data record
FUNC    name(inputs)  — define an action
FLOW    Name(inputs)  — multi-step process
  STEP  stepName      — one stage of a flow
  PARALLEL … WAIT all — concurrent steps
MODULE  Name          — group related functions
  ENTRY functionName  — mark a function as public

VALIDATE              — pre-flight checks (stop if any fail)
DO                    — sequential side-effect steps
RETURN value          — output value
ON FAIL THROW Error   — error handling
REQUIRE x ELSE THROW  — inline check inside DO
IF condition … ELSE   — branching
FOR EACH item         — iteration

GUARD  Name           — define a reusable access rule
ALLOW action WHEN x   — grant permission
DENY  action WHEN x   — block permission
EMIT  Event WITH data — fire an event
ON    EventName       — react to an event
  TRIGGER fn(args)    — call a function
  ALERT team-name     — notify a team

program     ::= (declaration | comment)*

declaration ::= module | shape | func | flow | guard
              | policy | query | on_handler | state | schedule

IDENT       ::= [a-zA-Z][a-zA-Z0-9_]*
PASCAL      ::= [A-Z][a-zA-Z0-9]*
CAMEL       ::= [a-z][a-zA-Z0-9]*

module      ::= "MODULE" PASCAL NL
                (INDENT import_stmt)*
                (INDENT "ENTRY" CAMEL "(" params? ")")*

shape       ::= "SHAPE" PASCAL NL
                (INDENT field_decl)*

field_decl  ::= CAMEL ":" type constraint*

type        ::= "String" | "Int" | "Float" | "Bool"
              | "UUID" | "Timestamp" | "JSON"
              | "List<" type ">" | "Map<" type "," type ">"
              | "Enum[" CAMEL ("," CAMEL)* "]"

func        ::= annotation* "FUNC" CAMEL "(" params? ")" NL
                doc_comment?
                validate_block?
                do_block?
                return_stmt?
                on_fail?

NL          ::= newline
INDENT      ::= "  " (two spaces)

// PARALLEL + WAIT all → Promise.all
export async function generateDashboard(userId) {
  const [stats, activity, notifications] = await Promise.all([
    Analytics.getUserStats(userId),
    ActivityLog.recent(userId, { limit: 20 }),
    Inbox.unread(userId),
  ]);
  return { stats, activity, notifications };
}

import re, uuid, bcrypt
from dataclasses import dataclass, field
from datetime   import datetime, timezone
from enum       import Enum

class Role(Enum):
    ADMIN = "admin"
    USER  = "user"
    GUEST = "guest"

@dataclass
class User:
    id:            str      = field(default_factory=lambda: str(uuid.uuid4()))
    email:         str      = ""
    name:          str      = ""
    password_hash: str      = ""
    role:          Role     = Role.USER
    created_at:    datetime = field(
        default_factory=lambda: datetime.now(timezone.utc))

class ValidationError(Exception):
    def __init__(self, message: str):
        super().__init__(message)
        self.status_code = 422

EMAIL_RE = re.compile(r"^[^\s@]+@[^\s@]+\.[^\s@]+$")
_users: dict[str, User] = {}

def create_user(email: str, password: str, name: str) -> User:
    """Creates a new user account. Raises ValidationError on failure."""
    if not EMAIL_RE.match(email):
        raise ValidationError("Invalid email format")
    if len(password) < 8:
        raise ValidationError("Password must be at least 8 characters")
    if len(name) < 2:
        raise ValidationError("Name must be at least 2 characters")
    if any(u.email == email for u in _users.values()):
        raise ValidationError("Email is already registered")

    hashed = bcrypt.hashpw(password.encode(), bcrypt.gensalt()).decode()
    user   = User(email=email, password_hash=hashed, name=name)
    _users[user.id] = user
    event_bus.emit("UserCreated", user)
    return user

import asyncio

async def generate_dashboard(user_id: str) -> dict:
    # PARALLEL + WAIT all → asyncio.gather
    stats, activity, notifications = await asyncio.gather(
        analytics.get_user_stats(user_id),
        activity_log.recent(user_id, limit=20),
        inbox.unread(user_id),
    )
    return {"stats": stats, "activity": activity, "notifications": notifications}

def transfer_funds(from_id: str, to_id: str, amount: float, db, event_bus) -> dict:
    if amount <= 0:
        raise TransferError("Amount must be positive")
    if from_id == to_id:
        raise TransferError("Cannot transfer to the same account")

    from_acct = db.query(Account).filter_by(id=from_id).one()
    if from_acct.balance < amount:
        raise TransferError("Insufficient funds")

    try:
        with db.begin():              # @transaction → SQLAlchemy context manager
            from_acct.balance -= amount
            to_acct = db.query(Account).filter_by(id=to_id).one()
            to_acct.balance   += amount
    except Exception as exc:
        raise TransferError(f"Transaction failed: {exc}") from exc

    event_bus.emit("FundsTransferred", {"from": from_id, "to": to_id, "amount": amount})
    return {"success": True}

-- Generated from LogicScript SHAPE User
CREATE TYPE user_role AS ENUM ('admin', 'user', 'guest');

CREATE TABLE users (
  id         UUID         PRIMARY KEY DEFAULT gen_random_uuid(),
  email      TEXT         NOT NULL UNIQUE,
  name       VARCHAR(100) NOT NULL CHECK (length(name) >= 2),
  role       user_role    NOT NULL DEFAULT 'user',
  created_at TIMESTAMPTZ  NOT NULL DEFAULT now()
);

CREATE INDEX idx_users_email ON users (email);
CREATE INDEX idx_users_role  ON users (role);

CREATE EXTENSION IF NOT EXISTS pgcrypto;

CREATE OR REPLACE FUNCTION create_user(
  p_email    TEXT,
  p_password TEXT,
  p_name     TEXT
) RETURNS users LANGUAGE plpgsql AS $$
DECLARE
  v_hash TEXT;  v_user users;
BEGIN
  IF p_email !~ '^[^\s@]+@[^\s@]+\.[^\s@]+$' THEN
    RAISE EXCEPTION 'ValidationError: invalid email'; END IF;
  IF length(p_password) < 8 THEN
    RAISE EXCEPTION 'ValidationError: password too short'; END IF;
  IF length(p_name) < 2 THEN
    RAISE EXCEPTION 'ValidationError: name too short'; END IF;
  IF EXISTS(SELECT 1 FROM users WHERE email = p_email) THEN
    RAISE EXCEPTION 'ValidationError: email taken'; END IF;

  v_hash := crypt(p_password, gen_salt('bf', 12));
  INSERT INTO users(email, password_hash, name)
    VALUES(p_email, v_hash, p_name) RETURNING * INTO v_user;
  PERFORM pg_notify('user_created', row_to_json(v_user)::text);
  RETURN v_user;
END; $$;

CREATE OR REPLACE PROCEDURE transfer_funds(
  p_from_id UUID, p_to_id UUID, p_amount NUMERIC(18,2)
) LANGUAGE plpgsql AS $$
DECLARE v_balance NUMERIC(18,2);
BEGIN
  IF p_amount <= 0 THEN
    RAISE EXCEPTION 'TransferError: amount must be positive'; END IF;
  IF p_from_id = p_to_id THEN
    RAISE EXCEPTION 'TransferError: same account'; END IF;
  SELECT balance INTO v_balance FROM accounts WHERE id = p_from_id FOR UPDATE;
  IF v_balance < p_amount THEN
    RAISE EXCEPTION 'TransferError: insufficient funds'; END IF;
  UPDATE accounts SET balance = balance - p_amount WHERE id = p_from_id;
  UPDATE accounts SET balance = balance + p_amount WHERE id = p_to_id;
  PERFORM pg_notify('funds_transferred',
    json_build_object('from',p_from_id,'to',p_to_id,'amount',p_amount)::text);
END; $$;

// Generated from LogicScript — SHAPE User + FUNC createUser
public record User(UUID id, String email, String name,
                   String passwordHash, Role role, Instant createdAt) {
  public enum Role { ADMIN, USER, GUEST }
}

public class ValidationException extends RuntimeException {
  private final int statusCode;
  public ValidationException(String msg) { super(msg); this.statusCode = 422; }
  public int getStatusCode() { return statusCode; }
}

@Service
public class UserService {
  private static final Pattern EMAIL_PATTERN =
      Pattern.compile("^[^\s@]+@[^\s@]+\.[^\s@]+$");

  private final UserRepository userRepository;
  private final PasswordEncoder passwordEncoder;
  private final ApplicationEventPublisher eventPublisher;

  public User createUser(String email, String password, String name) {
    // VALIDATE
    if (!EMAIL_PATTERN.matcher(email).matches())
      throw new ValidationException("Invalid email format");
    if (password.length() < 8)
      throw new ValidationException("Password must be at least 8 characters");
    if (name.length() < 2)
      throw new ValidationException("Name must be at least 2 characters");
    if (userRepository.existsByEmail(email))
      throw new ValidationException("Email already registered");

    // DO: hash and persist
    String hash = passwordEncoder.encode(password);
    User   user = new User(UUID.randomUUID(), email, name, hash,
                           User.Role.USER, Instant.now());
    user = userRepository.save(user);

    // EMIT UserCreated
    eventPublisher.publishEvent(new UserCreatedEvent(this, user));
    return user;
  }
}

public enum OrderStatus { DRAFT, PENDING, PAID, SHIPPED, DELIVERED, CANCELLED }

@Service
public class OrderStateMachine {
  private record Transition(Set<OrderStatus> from, OrderStatus to) {}

  private static final Map<String, Transition> TRANSITIONS = Map.of(
    "submitOrder",       new Transition(Set.of(DRAFT),                          PENDING),
    "paymentReceived",   new Transition(Set.of(PENDING),                        PAID),
    "fulfillOrder",      new Transition(Set.of(PAID),                           SHIPPED),
    "deliveryConfirmed", new Transition(Set.of(SHIPPED),                        DELIVERED),
    "cancelOrder",       new Transition(Set.of(DRAFT,PENDING,PAID,SHIPPED),     CANCELLED)
  );

  public Order transition(Order order, String event) {
    Transition t = TRANSITIONS.get(event);
    if (t == null) throw new IllegalArgumentException("Unknown event: " + event);
    if (!t.from().contains(order.getStatus()))
      throw new IllegalStateException("Invalid transition");

    order.setStatus(t.to());
    order = orderRepository.save(order);

    if (t.to() == SHIPPED) {
      eventPublisher.publishEvent(new OrderShippedEvent(this, order));
      notificationService.notifyUser(order.getUserId(), order.getTrackingInfo());
    }
    if (t.to() == CANCELLED) refundService.refundIfPaid(order);
    return order;
  }
}

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct User {
    pub id:            Uuid,
    pub email:         String,
    pub name:          String,
    pub password_hash: String,
    pub role:          Role,
    pub created_at:    DateTime<Utc>,
}

#[derive(Debug, thiserror::Error)]
pub enum ValidationError {
    #[error("Invalid email format")]    InvalidEmail,
    #[error("Password too short")]      PasswordTooShort,
    #[error("Name too short")]          NameTooShort,
    #[error("Email already registered")] EmailTaken,
    #[error("Database error: {0}")]
    Database(#[from] sqlx::Error),
}

static EMAIL_RE: OnceLock<Regex> = OnceLock::new();

pub async fn create_user(
    pool: &PgPool, bus: &impl EventBus,
    email: String, password: String, name: String,
) -> Result<User, ValidationError> {
    let re = EMAIL_RE.get_or_init(|| Regex::new(r"^[^\s@]+@[^\s@]+\.[^\s@]+$").unwrap());

    if !re.is_match(&email) { return Err(ValidationError::InvalidEmail); }
    if password.len() < 8   { return Err(ValidationError::PasswordTooShort); }
    if name.len() < 2        { return Err(ValidationError::NameTooShort); }

    let exists: bool = sqlx::query_scalar(
        "SELECT EXISTS(SELECT 1 FROM users WHERE email=$1)")
        .bind(&email).fetch_one(pool).await?;
    if exists { return Err(ValidationError::EmailTaken); }

    let hash = bcrypt::hash(&password, bcrypt::DEFAULT_COST).unwrap();
    let user: User = sqlx::query_as(
        "INSERT INTO users(id,email,name,password_hash,role,created_at)
         VALUES($1,$2,$3,$4,'user',NOW()) RETURNING *")
        .bind(Uuid::new_v4()).bind(&email).bind(&name).bind(&hash)
        .fetch_one(pool).await?;

    bus.emit("UserCreated", &user).await;
    Ok(user)
}

pub async fn transfer_funds(
    pool: &PgPool, bus: &impl EventBus,
    from_id: Uuid, to_id: Uuid, amount: Decimal,
) -> Result<(), TransferError> {
    if amount <= Decimal::ZERO { return Err(TransferError::InvalidAmount); }
    if from_id == to_id        { return Err(TransferError::SameAccount); }

    let mut tx = pool.begin().await?;
    let balance: Decimal = sqlx::query_scalar(
        "SELECT balance FROM accounts WHERE id=$1 FOR UPDATE")
        .bind(from_id).fetch_one(&mut *tx).await?;

    if balance < amount { tx.rollback().await?; return Err(TransferError::InsufficientFunds); }

    sqlx::query("UPDATE accounts SET balance=balance-$1 WHERE id=$2")
        .bind(amount).bind(from_id).execute(&mut *tx).await?;
    sqlx::query("UPDATE accounts SET balance=balance+$1 WHERE id=$2")
        .bind(amount).bind(to_id).execute(&mut *tx).await?;
    tx.commit().await?;

    bus.emit("FundsTransferred", &json!({"from":from_id,"to":to_id,"amount":amount})).await;
    Ok(())
}

// Generated from LogicScript — SHAPE User + FUNC createUser
enum class Role { Admin, User, Guest };

struct User {
    std::string email, name, password_hash, id;
    Role        role{Role::User};
    std::chrono::system_clock::time_point created_at;
};

class ValidationError : public std::runtime_error {
public:
    explicit ValidationError(const std::string& msg)
        : std::runtime_error(msg), status_code_(422) {}
    int status_code() const { return status_code_; }
private:
    int status_code_;
};

class UserService {
public:
    UserService(Database& db, EventBus& bus)
        : db_(db), bus_(bus)
        , email_re_(R"(^[^\s@]+@[^\s@]+\.[^\s@]+$)", std::regex::ECMAScript) {}

    User create_user(std::string_view email, std::string_view password, std::string_view name) {
        if (!std::regex_match(email.begin(), email.end(), email_re_))
            throw ValidationError("Invalid email format");
        if (password.size() < 8u)
            throw ValidationError("Password must be at least 8 characters");
        if (name.size() < 2u)
            throw ValidationError("Name must be at least 2 characters");
        if (db_.user_exists_by_email(email))
            throw ValidationError("Email already registered");

        std::string hash = bcrypt::generate_hash(password, 12);
        User user{.id=uuid::v4(), .email=std::string(email),
                  .name=std::string(name), .password_hash=std::move(hash),
                  .role=Role::User, .created_at=std::chrono::system_clock::now()};
        user = db_.insert_user(user);
        bus_.emit("UserCreated", user);
        return user;
    }

private:
    Database&   db_;
    EventBus&   bus_;
    std::regex  email_re_;
};

#include <future>

struct DashboardResult { Stats stats; std::vector<Activity> activity; std::vector<Notification> notifications; };

DashboardResult DashboardService::generate_dashboard(const std::string& user_id) {
    // PARALLEL + WAIT all → std::async + .get()
    auto stats_fut    = std::async(std::launch::async, [&] { return analytics_.get_user_stats(user_id); });
    auto activity_fut = std::async(std::launch::async, [&] { return activity_log_.recent(user_id, 20); });
    auto notif_fut    = std::async(std::launch::async, [&] { return inbox_.unread(user_id); });

    return { stats_fut.get(), activity_fut.get(), notif_fut.get() };
}