Adjusted the naming of the library in the Package file.

Sources/PlaydateKit/Support.swift

@@ -0,0 +1,91 @@
+//
+//  Support.swift
+//  Internal helpers shared by the wrappers.
+//
+//  C-string conversions are implemented manually (rather than with
+//  `String(cString:)` / `withCString`) so the module stays within the
+//  Embedded Swift subset used for device builds.
+//
+
+internal import CPlaydate
+
+extension String {
+    /// Creates a string by copying a null-terminated UTF-8 C string.
+    init(playdateCString pointer: UnsafePointer<CChar>) {
+        var count = 0
+        while pointer[count] != 0 { count += 1 }
+        let bytes = UnsafeRawBufferPointer(start: pointer, count: count)
+        self = String(decoding: bytes, as: UTF8.self)
+    }
+
+    /// Creates a string from a nullable C string, or `nil` if the pointer is null.
+    init?(playdateCString pointer: UnsafePointer<CChar>?) {
+        guard let pointer else { return nil }
+        self.init(playdateCString: pointer)
+    }
+
+    /// Calls `body` with a temporary null-terminated UTF-8 copy of the
+    /// string. The copy lives on the stack for short strings, so calling
+    /// this in the update loop does not churn the heap.
+    func withPlaydateCString<Result>(_ body: (UnsafePointer<CChar>) -> Result) -> Result {
+        let count = utf8.count
+        return withUnsafeTemporaryAllocation(of: CChar.self, capacity: count + 1) { buffer in
+            var index = 0
+            for byte in utf8 {
+                buffer[index] = CChar(bitPattern: byte)
+                index += 1
+            }
+            buffer[count] = 0
+            return body(buffer.baseAddress.unsafelyUnwrapped)
+        }
+    }
+
+    /// Calls `body` with a temporary buffer of the string's UTF-8 bytes (not
+    /// null-terminated) and its length, for the `(const void*, size_t)` text
+    /// APIs. Stack-allocated for short strings.
+    func withPlaydateUTF8<Result>(_ body: (UnsafeRawPointer, Int) -> Result) -> Result {
+        let count = utf8.count
+        return withUnsafeTemporaryAllocation(of: UInt8.self, capacity: count + 1) { buffer in
+            var index = 0
+            for byte in utf8 {
+                buffer[index] = byte
+                index += 1
+            }
+            return body(UnsafeRawPointer(buffer.baseAddress.unsafelyUnwrapped), count)
+        }
+    }
+
+    /// Copies the string into a newly allocated null-terminated C string.
+    /// The caller owns the memory and must free it with `deallocate()`.
+    func copiedPlaydateCString() -> UnsafeMutablePointer<CChar> {
+        let count = utf8.count
+        let buffer = UnsafeMutablePointer<CChar>.allocate(capacity: count + 1)
+        var index = 0
+        for byte in utf8 {
+            buffer[index] = CChar(bitPattern: byte)
+            index += 1
+        }
+        buffer[count] = 0
+        return buffer
+    }
+}
+
+#if hasFeature(Embedded) && !os(macOS)
+/// The Embedded Swift runtime allocates through `posix_memalign(3)`, which
+/// the Playdate device C library does not provide. Memory comes from
+/// `malloc`, which the SDK's setup code routes to the firmware allocator.
+/// The pointer is later released with plain `free`, so it cannot be offset
+/// to adjust alignment; the firmware allocator's natural alignment has to
+/// satisfy the request, which the precondition asserts.
+@_cdecl("posix_memalign")
+public func posix_memalign(
+    _ memptr: UnsafeMutablePointer<UnsafeMutableRawPointer?>,
+    _ alignment: Int,
+    _ size: Int
+) -> CInt {
+    guard let allocation = malloc(size) else { fatalError() }
+    precondition(Int(bitPattern: allocation) % alignment == 0)
+    memptr.pointee = allocation
+    return 0
+}
+#endif