feat: publish Dever core with project scaffolding and versioned AI skills

test/performance/fixtures/bench.dever

@@ -0,0 +1,21 @@
+ready(port: Int) () {
+  dever.io.println("READY|" + int.to_text(port))
+}
+
+pause(millis: Int) () {
+  dever.task.sleep(millis)
+}
+
+report(
+  begin: Int,
+  finish: Int,
+  name: Text,
+  count: Int,
+  checksum: Int
+) () recover("基准失败输出由运行器检查") {
+  dever.io.println(
+    "SAMPLE|" + name + "|" + int.to_text(count) + "|" + int.to_text(finish - begin) + "|" + int.to_text(
+      checksum
+    )
+  )
+}

test/performance/fixtures/http/adapter.dever

@@ -0,0 +1,136 @@
+type Content {
+  body: Bytes
+  kind: Text
+}
+
+listening(result: dever.net.ListenResult.Listening(listener)) (
+  value: dever.system.Listener
+) {
+  value = listener
+}
+
+listening(result: dever.net.ListenResult.Failed(message)) (value: dever.system.Listener) {
+  fail(app.WorkerFailure.Failed(message))
+}
+
+bound(result: dever.net.PortResult.Bound(port)) (value: Int) {
+  value = port
+}
+
+bound(result: dever.net.PortResult.Failed(message)) (value: Int) {
+  fail(app.WorkerFailure.Failed(message))
+}
+
+paused(result: dever.time.SleepResult.Done) () {}
+
+paused(result: dever.time.SleepResult.Failed(message)) () {
+  fail(app.WorkerFailure.Failed(message))
+}
+
+closed(result: dever.io.CloseResult.Closed) () {}
+
+closed(result: dever.io.CloseResult.Failed(message)) () {
+  fail(app.WorkerFailure.Failed(message))
+}
+
+server_tls(result: dever.tls.ServerResult.Ready(tls)) (value: dever.system.ServerTls) {
+  value = tls
+}
+
+server_tls(result: dever.tls.ServerResult.Failed(message)) (
+  value: dever.system.ServerTls
+) {
+  fail(app.WorkerFailure.Failed(message))
+}
+
+response_value(content: Content) (result: dever.http.Response) {
+  result = dever.http.Response {
+    status = 200
+    headers = [dever.http.header("Content-Type", content.kind)]
+    body = content.body
+  }
+}
+
+route(request: dever.http.Request, large: Bytes) (response: dever.http.Response) {
+  response = response_value(select(request.target, large))
+}
+
+select(path: "/plain", large: Bytes) (result: Content) {
+  result = Content {
+    body = dever.bytes.from_text("hello")
+    kind = "text/plain"
+  }
+}
+
+select(path: "/json", large: Bytes) (result: Content) {
+  result = Content {
+    body = dever.bytes.from_text("{\"ok\":true}")
+    kind = "application/json"
+  }
+}
+
+select(path: "/bytes", large: Bytes) (result: Content) {
+  result = Content {
+    body = large
+    kind = "application/octet-stream"
+  }
+}
+
+select(path: other, large: Bytes) (result: Content) {
+  result = Content {
+    body = dever.bytes.from_text("unknown benchmark path")
+    kind = "text/plain"
+  }
+}
+
+serve(
+  listener: dever.system.Listener,
+  tls: null,
+  limits: dever.http.Limits,
+  large: Bytes
+) () {
+  dever.system.http_serve(route, listener, limits, large)
+}
+
+serve(
+  listener: dever.system.Listener,
+  tls: dever.system.ServerTls,
+  limits: dever.http.Limits,
+  large: Bytes
+) () {
+  dever.system.http_serve_tls(route, listener, limits, tls, large)
+}
+
+worker(
+  tls: dever.system.ServerTls?,
+  limits: dever.http.Limits,
+  large: Bytes,
+  lifetime: Int
+) () {
+  listener = listening(result(dever.net.listen("127.0.0.1", 0)))
+  port = bound(result(dever.net.port(listener)))
+  server = run(serve(listener, tls, limits, large))
+  blocking(dever.io.println("READY|" + int.to_text(port)))
+  paused(result(dever.task.sleep(lifetime)))
+  closed(result(dever.net.close_listener(listener)))
+  stop(server)
+}
+
+port.plain(limits: dever.http.Limits, large: Bytes, lifetime: Int) () {
+  worker(null, limits, large, lifetime)
+}
+
+port.secure(
+  limits: dever.http.Limits,
+  large: Bytes,
+  lifetime: Int,
+  certificate: Bytes,
+  key: Bytes
+) () {
+  worker(
+    server_tls(result(dever.tls.server(certificate, key))),
+    limits,
+    large,
+    lifetime
+  )
+}

test/performance/fixtures/http/api.dever

@@ -0,0 +1,7 @@
+cmd http = app.http
+
+cmd https = app.https
+
+cmd http2 = app.http2
+
+cmd https2 = app.https2

test/performance/fixtures/http/app.dever

@@ -0,0 +1,35 @@
+type WorkerFailure {
+  error Failed(message: Text)
+}
+
+http() (result: Bool) {
+  port.plain(config.limits(), config.large_body(), config.lifetime())
+  result = true
+}
+
+https() (result: Bool) {
+  port.secure(
+    config.limits(),
+    config.large_body(),
+    config.lifetime(),
+    config.certificate(),
+    config.key()
+  )
+  result = true
+}
+
+http2() (result: Bool) {
+  port.plain(config.http2_limits(), config.large_body(), config.lifetime())
+  result = true
+}
+
+https2() (result: Bool) {
+  port.secure(
+    config.http2_limits(),
+    config.large_body(),
+    config.lifetime(),
+    config.certificate(),
+    config.key()
+  )
+  result = true
+}

test/performance/fixtures/http/port.dever

@@ -0,0 +1,9 @@
+plain(limits: dever.http.Limits, large: Bytes, lifetime: Int) () fails app.WorkerFailure
+
+secure(
+  limits: dever.http.Limits,
+  large: Bytes,
+  lifetime: Int,
+  certificate: Bytes,
+  key: Bytes
+) () fails app.WorkerFailure

test/performance/fixtures/live/adapter.dever

@@ -0,0 +1,213 @@
+setting {
+  limits: dever.http.Limits
+  lifetime_ms: Int
+}
+
+type Service {
+  Tcp
+  Live
+}
+
+listening(result: dever.net.ListenResult.Listening(listener)) (
+  value: dever.system.Listener
+) {
+  value = listener
+}
+
+listening(result: dever.net.ListenResult.Failed(message)) (value: dever.system.Listener) {
+  fail(app.WorkerFailure.Failed(message))
+}
+
+bound(result: dever.net.PortResult.Bound(port)) (value: Int) {
+  value = port
+}
+
+bound(result: dever.net.PortResult.Failed(message)) (value: Int) {
+  fail(app.WorkerFailure.Failed(message))
+}
+
+written(result: dever.io.WriteResult.Done) () {}
+
+written(result: dever.io.WriteResult.Failed(message)) () {
+  fail(app.WorkerFailure.Failed(message))
+}
+
+closed(result: dever.io.CloseResult.Closed) () {}
+
+closed(result: dever.io.CloseResult.Failed(message)) () {
+  fail(app.WorkerFailure.Failed(message))
+}
+
+paused(result: dever.time.SleepResult.Done) () {}
+
+paused(result: dever.time.SleepResult.Failed(message)) () {
+  fail(app.WorkerFailure.Failed(message))
+}
+
+tcp_chunk(event: dever.io.ReadEvent.Chunk(bytes), socket: dever.system.Socket) () recover("TCP 连接错误由运行器检查") {
+  written(result(dever.net.write(socket, bytes)))
+}
+
+tcp_chunk(event: dever.io.ReadEvent.Failed(message), socket: dever.system.Socket) () recover("TCP 连接错误由运行器检查") {
+  blocking(dever.io.println("ERROR|" + message))
+}
+
+tcp_stream(
+  result: dever.net.ReadStreamResult.Streaming(stream),
+  socket: dever.system.Socket
+) () {
+  each(tcp_chunk, stream, socket)
+}
+
+tcp_stream(
+  result: dever.net.ReadStreamResult.Failed(message),
+  socket: dever.system.Socket
+) () {
+  fail(app.WorkerFailure.Failed(message))
+}
+
+tcp_connection(
+  event: dever.net.ConnectResult.Connected(socket),
+  limits: dever.http.Limits
+) () recover("TCP 连接错误由运行器检查") {
+  written(result(dever.net.timeout(socket, limits.timeout_ms)))
+  tcp_stream(result(dever.net.chunks(socket, 4096)), socket)
+  closed(result(dever.net.close(socket)))
+}
+
+tcp_connection(
+  event: dever.net.ConnectResult.Failed(message),
+  limits: dever.http.Limits
+) () recover("TCP 连接错误由运行器检查") {
+  blocking(dever.io.println("ERROR|" + message))
+}
+
+tcp_server(listener: dever.system.Listener, limits: dever.http.Limits) () {
+  stream = dever.net.connections(listener)
+  parallel_each(tcp_connection, stream, limits.connections, limits)
+}
+
+websocket_message(
+  event: dever.websocket.MessageEvent.Read(message),
+  socket: dever.system.WebSocket
+) () recover("WebSocket 连接错误由运行器检查") {
+  websocket_echo(message, socket)
+}
+
+websocket_message(
+  event: dever.websocket.MessageEvent.Failed(message),
+  socket: dever.system.WebSocket
+) () recover("WebSocket 连接错误由运行器检查") {
+  blocking(dever.io.println("ERROR|" + message))
+}
+
+websocket_echo(
+  message: dever.websocket.Message.Text(value),
+  socket: dever.system.WebSocket
+) () recover("WebSocket 连接错误由运行器检查") {
+  written(result(dever.websocket.send(socket, dever.websocket.Message.Text(value))))
+}
+
+websocket_echo(
+  message: dever.websocket.Message.Binary(value),
+  socket: dever.system.WebSocket
+) () recover("WebSocket 连接错误由运行器检查") {
+  written(result(dever.websocket.send(socket, dever.websocket.Message.Binary(value))))
+}
+
+websocket_echo(message: other, socket: dever.system.WebSocket) () recover("WebSocket 连接错误由运行器检查") {}
+
+websocket_limits() (result: dever.websocket.Limits) {
+  result = dever.websocket.Limits {
+    message_bytes = 4096
+    idle_ms = setting.lifetime_ms
+    write_ms = setting.limits.timeout_ms
+  }
+}
+
+websocket_connection(result: dever.websocket.ConnectResult.Connected(socket)) () {
+  each(websocket_message, dever.websocket.messages(socket), socket)
+}
+
+websocket_connection(result: dever.websocket.ConnectResult.Failed(message)) () {
+  fail(app.WorkerFailure.Failed(message))
+}
+
+route(request: dever.http.Request, reply: dever.system.HttpReply) () {
+  live_path(request.target, reply)
+}
+
+live_path(target: "/ws", reply: dever.system.HttpReply) () recover("实时连接错误由运行器检查") {
+  websocket_connection(result(dever.websocket.accept(reply, websocket_limits())))
+}
+
+live_path(target: "/events", reply: dever.system.HttpReply) () recover("实时连接错误由运行器检查") {
+  written(result(dever.sse.start(reply, [])))
+  written(
+    result(
+      dever.sse.send(
+        reply,
+        dever.sse.Event {
+          event = "live"
+          data = "ready"
+          id = "1"
+          retry_ms = null
+        }
+      )
+    )
+  )
+  paused(result(dever.task.sleep(setting.lifetime_ms)))
+}
+
+live_path(target: other, reply: dever.system.HttpReply) () recover("实时连接错误由运行器检查") {
+  written(
+    result(
+      dever.http.respond(
+        reply,
+        dever.http.Response {
+          status = 404
+          headers = []
+          body = dever.bytes.from_text("unknown live benchmark path")
+        }
+      )
+    )
+  )
+}
+
+live_limits() (result: dever.http.LiveLimits) {
+  result = dever.http.LiveLimits {
+    chunk_bytes = 4096
+    idle_ms = setting.lifetime_ms
+    heartbeat_ms = 100
+  }
+}
+
+live_server(listener: dever.system.Listener) () {
+  dever.system.http_serve_live(route, listener, setting.limits, live_limits())
+}
+
+serve(service: Service.Tcp, listener: dever.system.Listener) () {
+  tcp_server(listener, setting.limits)
+}
+
+serve(service: Service.Live, listener: dever.system.Listener) () {
+  live_server(listener)
+}
+
+worker(service: Service) () {
+  listener = listening(result(dever.net.listen("127.0.0.1", 0)))
+  port = bound(result(dever.net.port(listener)))
+  server = run(serve(service, listener))
+  blocking(dever.io.println("READY|" + int.to_text(port)))
+  paused(result(dever.task.sleep(setting.lifetime_ms)))
+  stop(server)
+  closed(result(dever.net.close_listener(listener)))
+}
+
+port.tcp() () {
+  worker(Service.Tcp)
+}
+
+port.live() () {
+  worker(Service.Live)
+}

test/performance/fixtures/live/api.dever

@@ -0,0 +1,5 @@
+cmd tcp = app.tcp
+
+cmd ws = app.ws
+
+cmd sse = app.sse

test/performance/fixtures/live/app.dever

@@ -0,0 +1,18 @@
+type WorkerFailure {
+  error Failed(message: Text)
+}
+
+tcp() (result: Bool) {
+  port.tcp()
+  result = true
+}
+
+ws() (result: Bool) {
+  port.live()
+  result = true
+}
+
+sse() (result: Bool) {
+  port.live()
+  result = true
+}

test/performance/fixtures/live/port.dever

@@ -0,0 +1,3 @@
+tcp() () fails app.WorkerFailure
+
+live() () fails app.WorkerFailure

test/performance/fixtures/orm/app.dever

@@ -0,0 +1,144 @@
+type Identity {
+  id: Text
+  user_id: model.id?
+  tenant_id: model.id?
+}
+
+verify(claims: dever.auth.Claims) (identity: Identity) {
+  identity = Identity {
+    id = claims.subject
+    user_id = null
+    tenant_id = null
+  }
+}
+
+ready() () {
+  blocking(bench.ready(0))
+}
+
+populate_one(value: Int) () {
+  created = model.create({
+    value = value
+    label = "fixture"
+  })
+}
+
+populate() () {
+  each(populate_one, config.orm_rows())
+}
+
+crud_once(value: Int) () {
+  begin = dever.time.monotonic_nanos()
+  created = model.create({
+    value = value
+    label = "created"
+  })
+  changed = model.update(created.id, { label = "updated" })
+  removed = model.delete(created.id)
+  end = dever.time.monotonic_nanos()
+  blocking(bench.report(begin, end, "crud", 1, changed + removed))
+}
+
+list_once(value: Int) () {
+  begin = dever.time.monotonic_nanos()
+  page = model.list({
+    order = id.asc
+    page = 1
+    size = 32
+  })
+  end = dever.time.monotonic_nanos()
+  blocking(bench.report(begin, end, "list", 1, page.total + length(page.items)))
+}
+
+cursor_once(value: Int) () {
+  begin = dever.time.monotonic_nanos()
+  page = model.cursor({
+    order = id.asc
+    size = 32
+  })
+  end = dever.time.monotonic_nanos()
+  blocking(bench.report(begin, end, "cursor", 1, length(page.items)))
+}
+
+count_item(value: model.Item, total: Int) (next: Int) {
+  next = total + 1
+}
+
+stream_once(value: Int) () {
+  begin = dever.time.monotonic_nanos()
+  rows = model.stream({
+    order = id.asc
+    size = 16
+  })
+  total = reduce(count_item, rows, 0)
+  end = dever.time.monotonic_nanos()
+  blocking(bench.report(begin, end, "stream", 1, total))
+}
+
+pool_once(value: Int) () {
+  begin = dever.time.monotonic_nanos()
+  total = model.count()
+  end = dever.time.monotonic_nanos()
+  blocking(bench.report(begin, end, "pool", 1, total))
+}
+
+transaction fill_cancelled_transaction() () {
+  created = model.create({
+    value = 1
+    label = "cancelled"
+  })
+  delayed = model.delay(config.orm_cancel_work())
+}
+
+orm_idle() (result: Bool) {
+  total = model.count()
+  blocking(bench.ready(total))
+  bench.pause(config.lifetime())
+  result = true
+}
+
+orm_crud() (result: Bool) {
+  ready()
+  each(crud_once, config.orm_input())
+  result = true
+}
+
+orm_list() (result: Bool) {
+  populate()
+  ready()
+  each(list_once, config.orm_input())
+  result = true
+}
+
+orm_cursor() (result: Bool) {
+  populate()
+  ready()
+  each(cursor_once, config.orm_input())
+  result = true
+}
+
+orm_stream() (result: Bool) {
+  ready()
+  each(stream_once, config.orm_input())
+  result = true
+}
+
+orm_pool() (result: Bool) {
+  ready()
+  parallel_each(pool_once, config.orm_input(), config.orm_concurrency())
+  result = true
+}
+
+orm_seed() (result: Bool) {
+  populate()
+  result = true
+}
+
+count() (total: Int) {
+  total = model.count()
+}
+
+cancel() (result: Bool) {
+  fill_cancelled_transaction()
+  result = true
+}

test/performance/fixtures/orm/app/api.dever

@@ -0,0 +1,9 @@
+public get count = app.count
+public post cancel = app.cancel
+cmd idle = app.orm_idle
+cmd crud = app.orm_crud
+cmd list = app.orm_list
+cmd cursor = app.orm_cursor
+cmd stream = app.orm_stream
+cmd pool = app.orm_pool
+cmd seed = app.orm_seed

test/performance/fixtures/orm/app/model/item.dever

@@ -0,0 +1,13 @@
+type DelayResult {
+  total: Int
+}
+
+global type Item {
+  value: Int index
+  label: Text(1, 32)
+}
+
+sql delay(work: Int) (result: DelayResult) {
+  sqlite = "WITH RECURSIVE counter(value) AS (SELECT 1 UNION ALL SELECT value + 1 FROM counter WHERE value < ?1) SELECT SUM(value) AS total FROM counter"
+  postgres = "SELECT SUM(value)::bigint AS total FROM generate_series(1::bigint, $1::bigint) AS value"
+}

test/performance/fixtures/profile/benchmark/command/api.dever

@@ -0,0 +1 @@
+cmd run = app.run

test/performance/fixtures/profile/benchmark/command/app.dever

@@ -0,0 +1,4 @@
+run() (result: Bool) {
+  dever.io.println("profile")
+  result = true
+}

test/performance/fixtures/runtime/adapter.dever

@@ -0,0 +1,7 @@
+port.blocking_pause(millis: Int) () {
+  dever.time.sleep(millis)
+}
+
+port.report_error(message: Text) () {
+  dever.io.println("ERROR|" + message)
+}

test/performance/fixtures/runtime/api.dever

@@ -0,0 +1,11 @@
+cmd sync_idle = app.sync_idle
+
+cmd async_idle = app.async_idle
+
+cmd tasks = app.tasks
+
+cmd tasks_on_worker = app.tasks_on_worker
+
+cmd channels = app.channels
+
+cmd cancel = app.cancel

test/performance/fixtures/runtime/app.dever

@@ -0,0 +1,132 @@
+type Parking {
+  ready: Channel<Int>
+  gate: Channel<Int>
+}
+
+sync_idle() (result: Bool) {
+  bench.ready(0)
+  port.blocking_pause(config.lifetime())
+  result = true
+}
+
+idle() () {
+  blocking(bench.ready(0))
+  bench.pause(config.lifetime())
+}
+
+async_idle() (result: Bool) {
+  idle()
+  result = true
+}
+
+identity(value: Int) (result: Int) {
+  result = value
+}
+
+task_sum(value: Int, state: Int) (result: Int) {
+  job = run(identity(value))
+  result = state + wait(job)
+}
+
+sum(value: Int, state: Int) (result: Int) {
+  result = state + value
+}
+
+task_sample(index: Int, input: Bytes) () {
+  begin = dever.time.monotonic_nanos()
+  checksum = reduce(task_sum, input, 0)
+  end = dever.time.monotonic_nanos()
+  blocking(bench.report(begin, end, "tasks", length(input), checksum))
+}
+
+send_byte(value: Int, output: Channel<Int>) () {
+  send(output, value)
+}
+
+produce(input: Bytes, output: Channel<Int>) () {
+  each(send_byte, input, output)
+  close(output)
+}
+
+channel_sample(index: Int, input: Bytes) () {
+  output = channel(Int, config.channel_capacity())
+  begin = dever.time.monotonic_nanos()
+  producer = run(produce(input, output))
+  checksum = reduce(sum, stream(output), 0)
+  wait(producer)
+  end = dever.time.monotonic_nanos()
+  blocking(bench.report(begin, end, "channels", length(input), checksum))
+}
+
+wait_one(value: Int, parking: Parking) () {
+  send(parking.ready, value)
+  signaled(receive(parking.gate))
+}
+
+signaled(value: Int) () {}
+
+signaled(value: null) () {
+  blocking(port.report_error("channel closed before expected signal"))
+}
+
+hold(parking: Parking) () {
+  parallel_each(wait_one, config.pending_input(), config.pending(), parking)
+}
+
+started(value: Int, ready: Channel<Int>) () {
+  signaled(receive(ready))
+}
+
+cancel_worker() () {
+  parking = Parking {
+    ready = channel(Int, config.pending())
+    gate = channel(Int, 1)
+  }
+  job = run(hold(parking))
+  each(started, config.pending_input(), parking.ready)
+  blocking(bench.ready(config.pending()))
+  bench.pause(config.idle_sample_ms())
+  begin = dever.time.monotonic_nanos()
+  stop(job)
+  end = dever.time.monotonic_nanos()
+  close(parking.ready)
+  close(parking.gate)
+  blocking(bench.report(begin, end, "cancel", config.pending(), config.pending()))
+}
+
+task_worker() () {
+  input = config.input()
+  blocking(bench.ready(0))
+  each(task_sample, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], input)
+}
+
+channel_worker() () {
+  input = config.input()
+  blocking(bench.ready(0))
+  each(channel_sample, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], input)
+}
+
+tasks() (result: Bool) {
+  task_worker()
+  result = true
+}
+
+nested_task_worker() () {
+  job = run(task_worker())
+  wait(job)
+}
+
+tasks_on_worker() (result: Bool) {
+  nested_task_worker()
+  result = true
+}
+
+channels() (result: Bool) {
+  channel_worker()
+  result = true
+}
+
+cancel() (result: Bool) {
+  cancel_worker()
+  result = true
+}

test/performance/fixtures/runtime/port.dever

@@ -0,0 +1,3 @@
+blocking_pause(millis: Int) () fails dever.time.SleepResult
+
+report_error(message: Text) () fails dever.io.WriteResult